Software Engineer Encyclopedia
0%
Domain 01 · Computer Science & Programming Fundamentals · Topic 1.4

معمارية الكمبيوتر: المبادئ اللي بتفسّر الأداء

Computer Architecture

مش محتاج تصمم معالج، لكن محتاج تفهم ليه نفس الخوارزمية بنفس الـ Big O ممكن تبقى أسرع 10 مرات بس بتغيير ترتيب الـ loops. الدرس ده بيشرح CPU والذاكرة والـ cache والـ bits والـ cores بالقدر اللي بيفسّر أداء كود الـ .NET.

  • Foundation
  • ~21 min read
  • 8 sections
  • 8 code examples
  • 6 diagrams
  • 10 questions
  • Priority L3 · Optional
  • .NET 10 · x64 / ARM64

المتطلبات قبل ما تبدأ

مفيش متطلبات — ده أول الطريق. يكفي إنك كتبت كود بأي لغة قبل كده.

مستوى التعمق المطلوب

STRONG BASICSUnderstand the principles that explain performance; processor internals can wait.

01

الـ CPU والـ Registers والـ Instruction Cycle والـ ALU

CPU · registers · instruction cycle · ALU
Basics

الـ CPU هو اللي بينفذ الكود فعلاً. بيعمل حاجة واحدة بس: ينفذ instructions بسيطة جداً (اجمع رقمين، انقل قيمة، قارن، اقفز لمكان تاني) بمعدل مليارات في الثانية. كل برنامج C#‎ بتكتبه بيتحوّل في النهاية (JIT) لـ machine instructions من النوع ده.

CPU core Control Unit (CU)fetch · decode · schedule ALUadd · sub · AND/OR · compare Registers (RAX, RBX, RCX… · Program Counter · Stack Pointer · Flags)~16 general-purpose 64-bit registers, access in < 1 cycle L1 cache (per core) · L2 cache · shared L3 Main memoryRAM (GBs) bus
مكونات المعالج: Control Unit بيقرر، ALU بيحسب، Registers أسرع تخزين، والـ Cache قريب منهم. كل ده بيتكلم مع الـ RAM عن طريق الـ bus

Registers

أسرع وأصغر تخزين في الجهاز: بتشيل القيم اللي المعالج بيشتغل عليها دلوقتي. أنواعها: General-purpose (للحسابات)، Program Counter (PC/RIP) بيشاور على الـ instruction الجاية، Stack Pointer بيشاور على قمة الـ stack، Flags (نتيجة آخر مقارنة: zero? negative? overflow?). متغيراتك المحلية الحارة بيحطها الـ JIT في registers لو قدر.

ALU (Arithmetic Logic Unit)

الدايرة اللي بتعمل الحساب فعلاً: + - * على الأعداد الصحيحة، عمليات bits (& | ^ ~ << >>)، والمقارنات. الأعداد الـ floating point ليها وحدة منفصلة (FPU/SIMD). القسمة أبطأ بكتير من الجمع (عشرات الـ cycles مقابل 1).

Instruction Cycle (Fetch – Decode – Execute)

1 · Fetchread instruction at PC 2 · Decodewhat op? which regs? 3 · ExecuteALU / memory access 4 · Write backresult → register PC += 1 (or jump) → repeat
الدورة اللي بتتكرر مليارات المرات في الثانية: المعالج مش بيعرف يعمل غير كده

مثال: السطر int c = a + b; بيتحول تقريباً لـ: mov eax, [a] ⇒ add eax, [b] ⇒ mov [c], eax. كل instruction بتعدي على الدورة دي. لو الـ instruction هي jump (if أو loop)، الـ PC بيتغير لمكان تاني.

Pipelining و Branch Prediction

بدل ما المعالج يخلّص instruction كاملة قبل ما يبدأ اللي بعدها، بيعمل pipeline: instruction 1 في الـ execute وفي نفس الوقت instruction 2 في الـ decode و 3 في الـ fetch (زي خط إنتاج). عشان ده يشتغل لازم يعرف الـ instruction الجاية مقدماً، لكن الـ if بتخليه ميعرفش! فالمعالج بيخمّن (branch prediction) ويكمل. لو خمّن صح = لا خسارة. لو غلط = بيرمي شغل الـ pipeline كله ويبدأ من أول (حوالي 15-20 cycle ضايعين).

C#BranchPrediction.cs — the same work, predictable vs unpredictable branches
using System.Diagnostics;

var rnd = new Random(42);
int[] data = Enumerable.Range(0, 20_000_000).Select(_ => rnd.Next(256)).ToArray();

static long SumIfLarge(int[] a)
{
    long sum = 0;
    foreach (var x in a)
        if (x >= 128) sum += x;       // data-dependent branch
    return sum;
}

SumIfLarge(data);                                       // warm-up (JIT)
var sw = Stopwatch.StartNew();
long r1 = SumIfLarge(data);                             // random order: branch is unpredictable
Console.WriteLine($"random: {sw.ElapsedMilliseconds} ms  ({r1})");

Array.Sort(data);                                       // now: all <128 first, then all >=128
sw.Restart();
long r2 = SumIfLarge(data);                             // sorted: branch is almost always predicted
Console.WriteLine($"sorted: {sw.ElapsedMilliseconds} ms  ({r2})");
// On many machines sorted is several times faster even though the work is identical.
// Note: if the JIT turns the `if` into a conditional move (cmov), the gap disappears. Always measure.

الشرح

  1. الداتا هي نفسها (نفس الأرقام) في الحالتين، والـ loop بتعمل نفس عدد الجمع. الفرق الوحيد: ترتيب الأرقام.
  2. في الحالة العشوائية الـ if (x >= 128) نتيجتها 50/50 بلا نمط ⇒ المعالج بيغلط في التنبؤ كتير ⇒ pipeline flushes كتير.
  3. بعد الترتيب أول نص الـ array كله false وتاني نص كله true ⇒ التنبؤ شبه مثالي.
  4. الدرس: الـ Big O مش بيشوف ده. وكمان متبنيش استنتاجات على micro-benchmark واحد: الـ JIT ممكن يغير الكود (cmov) فالنتيجة تتغير بحسب النسخة والمعالج.
02

الذاكرة: Main Memory و Memory Hierarchy و CPU Cache و Locality

Main memory · memory hierarchy · CPU cache · locality
Deep dive

ده أهم جزء في الدرس. المعالج سريع جداً، لكن الـ RAM بطيئة نسبياً (حوالي 100 ns = ~300 cycle). لو المعالج استنى الـ RAM في كل مرة هيقعد فاضي أغلب الوقت. الحل: طبقات ذاكرة، كل طبقة أصغر وأسرع وأغلى من اللي تحتها، وبتحتفظ بنسخة من اللي بنستخدمه كتير.

Registers L1 cache 32-64 KB L2 cache 256 KB – 2 MB L3 cache (shared) 8 – 64 MB RAM GBs SSD / HDD / Network TBs ~ 0.3 ns (1 cycle)~ 1 ns~ 4 ns~ 15–40 ns~ 100 ns fastest, smallestslowest, largest
Memory hierarchy: كل ما ننزل بيزيد الحجم وتزيد الـ latency. الأرقام تقريبية لأجهزة حديثة وبتختلف من جهاز لآخر
Operation (approximate)LatencyScaled: 1 cycle = 1 second
CPU cycle / register~0.3 ns1 sec
L1 cache hit~1 ns3 sec
L2 cache hit~4 ns12 sec
L3 cache hit~15–40 ns1–2 min
Main memory (RAM)~100 ns5 min
NVMe SSD read~100 µs4 days
Network round trip (same datacenter)~0.5 ms~20 days
HDD seek~10 ms~1 year
Network round trip (cross-continent)~100–150 ms~10 years

الجدول ده بيفسّر قرارات كتير: ليه الـ cache (Redis) بيحسّن الأداء، ليه الـ database index مهم، وليه عدد الـ network calls أهم من حجم الداتا.

إزاي الـ CPU Cache بيشتغل

Cache Line

الـ cache مش بيجيب byte واحد من الـ RAM؛ بيجيب cache line كاملة (عادةً 64 bytes). فلو قريت a[0] من int[] بتحمّل معاه الـ 15 int اللي بعده مجاناً.

Cache Hit / Miss

Hit: الداتا في الـ cache ⇒ سريع. Miss: لازم تنزل للطبقة اللي تحتها ⇒ بطيء. نسبة الـ hit rate هي اللي بتحدد الأداء.

Locality

Spatial locality: لو استخدمت عنوان فغالباً هتستخدم اللي جنبه. Temporal locality: لو استخدمت حاجة فغالباً هتستخدمها تاني قريب. الـ cache مبني على الفرضيتين دول.

int[4,4] in memory (row-major): r0c0 r0c1 r0c2 r0c3 | r1c0 r1c1 … Row by row: sequential, 1 miss per 16 ints Column by column: big jumps, a miss on every step
Array 2D في الذاكرة مخزن صف ورا صف (row-major). المرور على الصفوف = وصول متتالي (cache friendly). المرور على الأعمدة = قفزات كبيرة (cache miss في كل خطوة)
C#CacheLocality.cs — same Big-O, very different speed
using System.Diagnostics;

const int N = 8000;
int[,] matrix = new int[N, N];                        // 64M ints = 256 MB, stored row by row

long SumRowMajor()
{
    long sum = 0;
    for (int row = 0; row < N; row++)
        for (int col = 0; col < N; col++)
            sum += matrix[row, col];                  // consecutive addresses
    return sum;
}

long SumColumnMajor()
{
    long sum = 0;
    for (int col = 0; col < N; col++)
        for (int row = 0; row < N; row++)
            sum += matrix[row, col];                  // jumps N*4 bytes each step
    return sum;
}

SumRowMajor();                                        // warm-up
var sw = Stopwatch.StartNew(); SumRowMajor();    Console.WriteLine($"row-major:    {sw.ElapsedMilliseconds} ms");
sw.Restart();                  SumColumnMajor(); Console.WriteLine($"column-major: {sw.ElapsedMilliseconds} ms");
// Typical: column-major is 3x to 10x slower, although both do exactly N*N additions: O(N²)

الشرح وتتبع الـ cache

  1. الـ int[,] في ‎.NET بيتخزن row-major: matrix[0,0], matrix[0,1], … متجاورين.
  2. Row-major loop: أول matrix[r,0] بيعمل cache miss وبيجيب 64 byte = 16 int. الـ 15 الجاية hits. يعني miss واحد لكل 16 عنصر.
  3. Column-major loop: كل خطوة بتقفز 8000 × 4 = 32,000 byte لصف تاني، يعني cache line مختلفة تماماً. الـ line اللي اتحملت قبل كده بتتطرد قبل ما نرجعلها (لأن الـ cache أصغر من المصفوفة) ⇒ miss في كل خطوة تقريباً.
  4. نفس عدد الجمع، ونفس الـ Big O، والفرق في الزمن ممكن يوصل أضعاف. ده بيوضح إن الـ Big O بيتجاهل الثوابت اللي أحياناً بتكون هي المشكلة.
إمتى ده يهمك في الـ backend؟

(1) List<T> أسرع من LinkedList<T> بمراحل لأن العناصر متجاورة. (2) Array of structs أحسن من array of classes للـ hot loops لأن الـ structs متجاورة والـ class instances منتشرة في الـ heap (وكل واحد cache miss). (3) معالجة الداتا بالـ columns (زي الـ columnar stores وـ Parquet وـ DataFrames) سريعة لأنها بتقرأ نوع واحد متجاور. (4) تقليل الـ pointer chasing (obj.Next.Next.Value).

False Sharing (مشكلة cache مع الـ threads)

كل core عنده L1 خاص. لو thread على core 1 بيكتب في متغير و thread على core 2 بيكتب في متغير تاني بس موجودين في نفس الـ 64-byte cache line، الـ cores بتتخانق على الـ line وبيحصل ping-pong بينهم (cache coherency) ⇒ بطء رغم إن الـ threads مش بتشارك أي متغير فعلياً.

C#FalseSharing.cs
using System.Diagnostics;

const long Iterations = 100_000_000;

// Counters packed next to each other: both share ONE cache line
long[] packed = new long[2];
// Counters 16 longs (128 bytes) apart: different cache lines
long[] padded = new long[32];

var sw = Stopwatch.StartNew();
Parallel.Invoke(
    () => { for (long i = 0; i < Iterations; i++) Volatile.Write(ref packed[0], packed[0] + 1); },
    () => { for (long i = 0; i < Iterations; i++) Volatile.Write(ref packed[1], packed[1] + 1); });
Console.WriteLine($"adjacent: {sw.ElapsedMilliseconds} ms");

sw.Restart();
Parallel.Invoke(
    () => { for (long i = 0; i < Iterations; i++) Volatile.Write(ref padded[0],  padded[0]  + 1); },
    () => { for (long i = 0; i < Iterations; i++) Volatile.Write(ref padded[16], padded[16] + 1); });
Console.WriteLine($"padded:   {sw.ElapsedMilliseconds} ms");   // typically noticeably faster
  1. كل thread بيكتب في خانة مختلفة، فمفيش race. لكن في الحالة الأولى الخانتين (8 bytes لكل واحدة) جوه نفس الـ cache line، فكل كتابة بتبطّل الـ line عند الـ core التاني.
  2. التباعد 128 byte بيحط كل counter في line لوحده فمفيش contention.
  3. ده مشكلة متقدمة بتظهر في الـ high-performance code (counters، queues lock-free). النقطة المهمة للـ backend: الأداء مع الـ threads مش بس locks، الـ hardware كمان له رأي. وبتقيسه ولا تخمّنه.

Main Memory (RAM) vs Storage، و Virtual Memory

RAM (Main Memory)Storage (SSD / HDD)
السرعة~100 ns، ~عشرات GB/sSSD ~100 µs و ~GB/s، HDD ~10 ms
Volatile؟نعم: بتضيع الداتا مع انقطاع الكهرباءلا (persistent)
الوصولByte-addressable (random access سريع)بـ blocks/pages (4KB+)، الـ sequential أسرع بكتير من random في الـ HDD
التكلفة لكل GBأغلى بمراحلأرخص
الاستخدامالـ working data للبرامج الشغّالةالملفات، الـ databases، الـ logs

الفرق ده هو سبب إن الـ databases بتبذل جهد كبير: تخزّن الـ hot data في RAM (buffer pool/page cache)، وتكتب الـ WAL بشكل sequential، وتستخدم الـ indexes عشان تقلل القراءات العشوائية من الـ disk. وإن الـ in-memory cache (Redis) أسرع من DB بمراحل.

Virtual Memory (مفهوم، والتفاصيل في درس Operating Systems): البرنامج بيشوف عناوين افتراضية والـ MMU بيترجمها لعناوين فعلية بجداول الصفحات. ده بيدّي عزل بين الـ processes، وdemand paging (الصفحات بتتحمل لما تتستخدم)، وإمكانية استخدام الـ disk كامتداد للـ RAM (swap) بتكلفة أداء عالية. وجزء من الـ cache اسمه TLB بيحتفظ بآخر ترجمات الصفحات؛ وده سبب إن الوصول لذاكرة منتشرة جداً (حتى لو في الـ RAM) أبطأ.

03

Binary Representation و Bits و Bytes

Binary representation, bits and bytes
Deep dive

الكمبيوتر بيخزن كل حاجة (أرقام، نصوص، صور، كود) كـ bits: كل bit إما 0 أو 1. Byte = 8 bits (256 قيمة ممكنة). الـ hex مجرد طريقة مختصرة نكتب بيها الـ bits: كل رقم hex = 4 bits (0xFF = 1111 1111 = 255).

bit position 10110010 2⁷=1286432168421 unsigned byte: 128 + 32 + 16 + 2 = 178 (0xB2) signed (two's complement): -128 + 32 + 16 + 2 = -78 negate = invert all bits + 1: -1 = 1111 1111, -78 = ~(78) + 1
الـ byte = 8 bits. الـ two's complement: أكبر bit هو sign bit ووزنه سالب. عشان كده 11111111 = -1 في sbyte و 255 في byte
C#‎ typeSizeRange
byte / sbyte8 bits0..255 / -128..127
short / ushort16 bits-32,768..32,767 / 0..65,535
int / uint32 bits±2.147 billion / 0..4.29 billion
long / ulong64 bits±9.22 × 10¹⁸ / 0..1.8 × 10¹⁹
float / double32 / 64 bitsIEEE 754 (~7 / ~15-16 significant digits)
decimal128 bitsbase-10, 28-29 digits (for money)
char16 bitsUTF-16 code unit
C#Bits.cs — binary, hex, two's complement, overflow, endianness, floating point
// --- Binary & hex literals, formatting ---
int n = 0b1011_0010;                                   // binary literal (178)
Console.WriteLine($"{n} = 0x{n:X2} = {Convert.ToString(n, 2).PadLeft(8, '0')}");   // 178 = 0xB2 = 10110010

// --- Bitwise operators: flags and masks ---
[Flags] enum Permissions { None = 0, Read = 1, Write = 2, Execute = 4 }
var p = Permissions.Read | Permissions.Write;          // 0b011  set bits
bool canWrite = (p & Permissions.Write) != 0;          // test a bit
p &= ~Permissions.Write;                               // clear a bit
Console.WriteLine($"{p} canWrite={canWrite}");        // Read canWrite=True

Console.WriteLine(1 << 10);                            // 1024  (shift left = multiply by 2^10)
Console.WriteLine(0xF0F0 >> 4);                        // 3855  (0x0F0F)
Console.WriteLine(unchecked((int)0xFFFFFFFF));         // -1    (all bits set = -1 in two's complement)

// --- Overflow: wraps silently by default! ---
int max = int.MaxValue;
Console.WriteLine(unchecked(max + 1));                 // -2147483648  (wrapped)
try { Console.WriteLine(checked(max + 1)); }           // throws OverflowException
catch (OverflowException) { Console.WriteLine("overflow detected"); }

// --- Endianness: byte order in memory ---
byte[] bytes = BitConverter.GetBytes(0x01020304);
Console.WriteLine(BitConverter.IsLittleEndian);        // True on x86/x64/ARM
Console.WriteLine(Convert.ToHexString(bytes));         // 04030201  (least significant byte first)

// --- Floating point is binary: 0.1 has no exact representation ---
Console.WriteLine(0.1 + 0.2 == 0.3);                   // False
Console.WriteLine(0.1 + 0.2);                          // 0.30000000000000004
Console.WriteLine(0.1m + 0.2m == 0.3m);                // True (decimal is base-10)
Console.WriteLine(Math.Abs((0.1 + 0.2) - 0.3) < 1e-9); // True: compare with a tolerance

الشرح

  1. Flags enum: كل صلاحية bit مستقل (1,2,4). | بيشغّل bit، & بيختبره، & ~x بيمسحه. ده نفس نظام صلاحيات Linux (rwx = 4+2+1) وبيستخدم في كل مكان (أنظمة صلاحيات، options).
  2. Two's complement: الـ 0xFFFFFFFF في int معناها -1 لأن الـ MSB له وزن سالب. الجمع والطرح بيشتغلوا بنفس دايرة الـ ALU للـ signed والـ unsigned، وده سبب اعتماد الأنظمة عليه.
  3. Overflow: افتراضياً الأعداد الصحيحة في C#‎ بتلف حوالين (wrap) من غير error. ده سبب bugs أمنية (تحسب حجم buffer غلط). استخدم checked للحسابات الحساسة (مثلاً المبالغ والأحجام) أو فعّل <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow> في الـ project.
  4. Endianness: الرقم 0x01020304 بيتخزن 04 03 02 01 في little-endian. مهم لما تقرأ/تكتب binary protocols أو ملفات وتتبادل بين أنظمة (الشبكة بتستخدم big-endian = «network byte order»، وفي ‎.NET BinaryPrimitives بتتحكم في الترتيب صراحة).
  5. Floating point (IEEE 754): 0.1 في binary كسر دوري مالوش تمثيل دقيق، فالجمع بيطلع 0.30000000000000004. متقارنش double بـ == ولا تستخدمها للفلوس؛ استخدم decimal للمبالغ، أو قارن بـ tolerance.
أخطاء حقيقية بتحصل

(1) استخدام double لحسابات مالية ⇒ فروق قروش تتراكم. (2) int للـ ids أو الـ counters اللي ممكن تعدي 2.1 مليار ⇒ wrap لسالب (استخدم long). (3) (a + b) / 2 لما a و b كبار ⇒ overflow (استخدم a + (b - a) / 2). (4) تجاهل الـ endianness في protocols. (5) استخدام Math.Abs(int.MinValue) ⇒ OverflowException لأن +2147483648 مش ممكن تتمثل.

04

CPU Cores و Parallelism

CPU cores and parallelism
Practical

زمان كانت المعالجات بتتسرّع بزيادة التردد (GHz). ده وقف تقريباً (الحرارة والطاقة)، فبقى التطور بـ زيادة عدد الـ cores وبـ تعليمات vector (SIMD). معنى كده إن الكود لازم يتعلم يستغل التوازي عشان يستفيد من الـ hardware الحديث.

Core

وحدة تنفيذ كاملة (ليها registers و ALU و L1/L2 خاصة بيها). المعالج 8-core يقدر ينفذ 8 threads فعلاً في نفس اللحظة.

Hyper-Threading / SMT

core واحد بيظهر كـ 2 «logical processors» عشان يملأ الوقت الضايع (لما thread بيستنى cache miss يشتغل التاني). مش بيضاعف الأداء؛ غالباً مكسب 10-30%. فـ Environment.ProcessorCount بتعد logical processors.

SIMD

Single Instruction, Multiple Data: instruction واحدة بتعمل نفس العملية على 4 أو 8 أو 16 قيمة مرة واحدة (باستخدام registers عريضة 128/256/512 bit). parallelism جوه الـ core.

Amdahl's Law: مفيش speedup بلا حدود

لو جزء من البرنامج لازم يتنفذ تسلسلياً (نسبة s)، فأقصى speedup على N cores هو:

Speedup(N) = 1 / ( s + (1 − s) / N )

مثال: لو 10% من البرنامج تسلسلي (s = 0.1): على 8 cores أقصى speedup ≈ 4.7×، وحتى لو عندك ملايين cores مش هتعدي 10×. عشان كده تقليل الجزء التسلسلي (locks، الـ aggregation النهائي) أهم من زيادة الـ cores.

number of cores N → (1, 2, 4, 8, 16, 32, 64)speedup s = 0 (ideal) s = 5% s = 10% s = 25%
Amdahl's Law: كل ما زادت نسبة الجزء التسلسلي، الـ speedup بيقف عند سقف منخفض بغض النظر عن عدد الـ cores
C#Simd.cs — SIMD with Vector<T> and parallel loops
using System.Numerics;

// Scalar: one add per iteration
static long SumScalar(int[] a)
{
    long s = 0;
    foreach (var x in a) s += x;
    return s;
}

// SIMD: Vector<int> processes Vector<int>.Count values per instruction (4/8/16 depending on the CPU)
static long SumSimd(int[] a)
{
    int w = Vector<int>.Count;
    var acc = Vector<long>.Zero;
    int i = 0;
    for (; i <= a.Length - w; i += w)
    {
        Vector.Widen(new Vector<int>(a, i), out var lo, out var hi);   // widen to long to avoid overflow
        acc += lo + hi;
    }
    long sum = Vector.Sum(acc);
    for (; i < a.Length; i++) sum += a[i];                              // remaining tail elements
    return sum;
}

Console.WriteLine($"Hardware accelerated: {Vector.IsHardwareAccelerated}, lanes: {Vector<int>.Count}");
int[] data = Enumerable.Range(1, 10_000_000).ToArray();
Console.WriteLine(SumScalar(data) == SumSimd(data));     // True

// Multi-core: split a CPU-bound job across cores (parallelism between cores)
var squares = new double[data.Length];
Parallel.For(0, data.Length, i => squares[i] = Math.Sqrt(data[i]));
  1. Vector<int>.Count بتتغير بحسب الـ hardware (مثلاً 8 على AVX2). كل iteration بتجمع 8 قيم بدل واحدة.
  2. بنوسّع القيم لـ long (Widen) عشان نتجنب overflow في الـ int. ممكن تتوقع إن عدد الـ iterations أقل بـ 4-8 مرات، لكن الـ speedup الفعلي بيتأثر بسرعة الذاكرة (memory-bound).
  3. الـ tail loop بتعالج العناصر اللي فاضلة لو الطول مش مضاعف لـ w.
  4. أغلب الوقت مش هتكتب SIMD بإيدك: الـ BCL في ‎.NET الحديث بيستخدمه داخلياً في عمليات كتير (string search، Span.IndexOf، Sum/Min/Max على arrays في LINQ). المهم تفهم إن الـ hardware بيقدر يعمل «أكتر من حاجة في الـ cycle».
  5. Parallel.For ده parallelism على مستوى الـ cores. مناسب للشغل CPU-bound المستقل. (للـ I/O استخدم async).
العلاقة بالـ OS والـ backend

الـ parallelism محتاج الـ OS scheduler يوزّع threads على الـ cores، ومحتاجك تتجنب shared mutable state والـ contention (درس Operating Systems). وفي الـ cloud/containers الـ CPU limit بيحدد كام core «ظاهرية» عندك فعلاً.

05

Performance Basics

Performance basics
Practical

قواعد الأداء الأساسية: (1) قيس قبل ما تحسّن. (2) حسّن الـ bottleneck الحقيقي. (3) الـ algorithm أهم من الـ micro-optimization. (4) فهم الـ hardware بيفسّر النتايج.

تسلسل التفكير

  1. الـ Algorithm / Data structure: O(n²) → O(n log n) أو O(n) (مكسب 100×+).
  2. أقل I/O: network calls و DB queries (N+1) و disk (مكسب 10-1000×).
  3. Memory behavior: allocations، cache locality (مكسب 2-10×).
  4. Micro-optimizations: آخر حاجة، ومكسبها عادةً صغير.

أخطاء الـ benchmarking

  • قياس أول تشغيل (JIT compile + cold cache).
  • Debug build بدل Release.
  • قياس مرة واحدة بدل عدة تكرارات.
  • الـ compiler ممكن يحذف الكود اللي نتيجته مش مستخدمة.
  • استنتاج من micro-benchmark معزول على سلوك النظام الكامل.
C#Benchmarks.cs — BenchmarkDotNet done right
// dotnet add package BenchmarkDotNet
// Run in RELEASE:  dotnet run -c Release
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]                         // also reports allocations and GC counts
public class LookupBenchmarks
{
    private int[] _list = default!;
    private HashSet<int> _set = default!;

    [Params(100, 10_000)]                 // run for each input size so you SEE the growth rate
    public int N;

    [GlobalSetup]
    public void Setup()
    {
        _list = Enumerable.Range(0, N).ToArray();
        _set  = _list.ToHashSet();
    }

    [Benchmark(Baseline = true)]
    public bool ArrayContains() => Array.IndexOf(_list, N - 1) >= 0;     // O(n)

    [Benchmark]
    public bool HashSetContains() => _set.Contains(N - 1);               // O(1)
}

public static class Program
{
    public static void Main() => BenchmarkRunner.Run<LookupBenchmarks>();
}
// Output (shape): for N=100 the array may be comparable; for N=10,000 the HashSet is ~hundreds of times faster.
  1. BenchmarkDotNet بيعمل warm-up تلقائي، وتكرار لحد ما النتايج تثبت، ويحسب mean و std dev، وبيمنع الـ JIT من حذف الكود.
  2. [Params] بيشغّل الـ benchmark لأحجام مختلفة: بتشوف الفرق بين O(n) و O(1) بعينك مش بس نظرياً. وعند الأحجام الصغيرة ممكن الـ array يكسب (ثوابت أصغر + cache) — ده بيوضح ليه الـ Big O مش كل القصة.
  3. [MemoryDiagnoser] بيضيف عمود Allocated. تقليل الـ allocations غالباً بيقلل الـ GC pauses وبيحسن الـ throughput.
  4. للـ endpoint الكامل مش benchmark: استخدم load testing (k6/NBomber) و profiler (dotnet-trace, dotnet-counters) لإيجاد الـ bottleneck الحقيقي قبل ما تغيّر أي سطر.
القاعدة العملية

في الـ backend أغلب الأداء بيضيع في الـ I/O (queries كتير، network calls متتالية، serialization)، مش في تفاصيل الـ CPU. أول سؤال: «كام round trip بعمله؟». وبعدين: «فيه O(n²) مخفي؟». وبعدين فقط تفكر في الـ cache locality والـ SIMD، وكل ده بعد القياس.

06

RAM vs Persistent Storage

Volatile working memory versus durable storage
Deep dive

الـ RAM مساحة عمل سريعة ومتطايرة: محتواها عادةً يختفي عند انقطاع الطاقة، ويستخدمها نظام التشغيل والبرامج للاحتفاظ بالكود والبيانات النشطة. أما الـ persistent storage مثل SSD و HDD فيحتفظ بالبيانات بعد إغلاق الجهاز، لكنه أبطأ عادةً في الوصول العشوائي. لا تخلط بين السعة والسرعة: جهاز عنده 16 GB RAM و1 TB SSD لا يمتلك 1 TB ذاكرة تشغيل.

RAM

  • Volatile؛ محتوى العمليات النشطة.
  • زمن وصول منخفض وعرض نطاق مرتفع نسبيًا.
  • تُدار كصفحات افتراضية لكل process.
  • نفادها قد يؤدي إلى ضغط الذاكرة و paging أو OOM.

SSD / HDD

  • Non-volatile؛ ملفات وقواعد بيانات وملفات النظام.
  • أبطأ من RAM، لكنه أكبر وأرخص لكل GB.
  • SSD يعتمد على flash؛ HDD على أقراص ميكانيكية.
  • الـ database buffer pool يستفيد من RAM مع بقاء الملفات على storage.

في تطبيق ‎.NET، كائنات الـ managed heap موجودة في ذاكرة العملية (عادةً RAM أثناء التشغيل). عند حفظ كيان في SQL Server، لا يعني ذلك أن الكائن نفسه انتقل إلى القرص؛ قاعدة البيانات تدير صفحاتها وذاكرتها المؤقتة وعمليات الـ durability بصورة مستقلة.

قاعدة عملية

RAM تخدم العمل الجاري؛ التخزين الدائم يحافظ على الحالة. الـ cache قد يوجد في RAM أو على القرص، لكن كلمة cache تصف غرض الاحتفاظ بنسخة أسرع، لا نوع وسيط التخزين وحده.

07

Virtual Memory and Paging

Address spaces, page tables, page faults and working sets
Deep dive

كل process يرى virtual address space خاصًا به. العنوان الافتراضي لا يشير بالضرورة إلى نفس رقم العنوان الفيزيائي في RAM؛ وحدة إدارة الذاكرة (MMU) تترجم العناوين عبر page tables التي يديرها نظام التشغيل والمعالج. هذا يوفر العزل بين العمليات، ويسمح بتحميل الصفحات المطلوبة فقط، ويبسّط تخصيص الذاكرة.

برنامج يقرأ virtual address داخل صفحة.
MMU تبحث في TLB عن ترجمة حديثة؛ عند hit تتم الترجمة بسرعة.
عند TLB miss يتم الرجوع إلى page tables؛ وإذا كانت الصفحة غير موجودة في RAM يحدث page fault.
نظام التشغيل يتحقق من صلاحية الوصول، ثم يحمّل الصفحة من backing store عند الحاجة أو ينهي العملية إذا كان الوصول غير صالح.

ليس كل page fault خطأ قاتلًا: minor fault قد يُحل دون قراءة من القرص، بينما major fault يحتاج I/O وقد يرفع latency بشدة. والـ swapping/pagefile ليس امتدادًا سريعًا للـ RAM؛ الاعتماد المفرط عليه يسبب thrashing عندما تتنافس العمليات على صفحات أكثر من الذاكرة المتاحة.

من منظور backend: memory leak أو allocations ضخمة ترفع working set و GC pressure. راقب working set و private bytes و GC heap، ولا تفترض أن زيادة RAM وحدها تعالج تسريبًا أو احتفاظًا غير محدود بالكاش.

08

Knowledge Check

Takeaways · conceptual questions · code reading · interview questions
Basics

أهم النقاط

  • الـ CPU بيكرر Fetch-Decode-Execute؛ الـ registers هي أسرع تخزين، والـ ALU بيحسب. الـ pipeline والـ branch prediction بيخلوا الكود المتوقع أسرع.
  • الـ RAM أبطأ بمراحل من المعالج، فبنستخدم caches (L1/L2/L3). الـ cache بيشتغل بـ cache lines (64 bytes)، فالوصول المتجاور سريع (spatial locality).
  • نفس الـ Big O ممكن يختلف أضعاف بسبب الـ cache locality. الـ array أسرع من الـ linked structures.
  • الأعداد في الـ binary: two's complement للـ signed، الـ overflow بيلف بصمت، الـ floating point مش دقيق (استخدم decimal للفلوس).
  • التطور بقى بزيادة cores و SIMD. Amdahl's Law: الجزء التسلسلي بيحدد سقف الـ speedup.
  • قيس قبل ما تحسّن، وابدأ بالـ algorithm والـ I/O.

أسئلة مفاهيمية

ليه List<T> أسرع من LinkedList<T> حتى في الإدراج أحياناً؟

لأن الـ List عناصره متجاورة فبتستفيد من cache lines والـ prefetching (spatial locality)، وكمان نسخ الـ memory المتجاورة سريع جداً (memmove). الـ LinkedList كل node منتشرة في الـ heap فكل خطوة potential cache miss، وكل node بتحتاج allocation.

إيه هو cache line؟ وليه حجمه مهم؟

أصغر وحدة بيتحرك بيها الـ cache بين الذاكرة والمعالج (عادةً 64 byte). بتجيب الجيران مع العنصر المطلوب. وجودها بيفسّر الـ spatial locality وبيسبب false sharing لما threads على cores مختلفة تكتب في متغيرات قريبة.

ليه 0.1 + 0.2 != 0.3؟ وإزاي تتعامل مع الفلوس؟

الـ double بتخزن الأعداد بـ binary وبعض الكسور العشرية (زي 0.1) مالهاش تمثيل binary منتهي. استخدم decimal (base-10) للمبالغ، أو خزّن المبلغ كـ long بالقروش/الوحدة الصغرى.

إيه الـ endianness؟ إمتى يهمك؟

ترتيب بايتات الرقم متعدد البايتات في الذاكرة (little-endian: الأقل أهمية الأول). يهمك لما تتعامل مع binary files/protocols أو شبكات (network order = big-endian)، فـ BinaryPrimitives أو IPAddress.HostToNetworkOrder لتحويل صريح.

قانون Amdahl بيقول إيه بالعملي؟

إن الـ speedup بيتحدد بالجزء التسلسلي. لو 20% تسلسلي أقصى speedup 5× مهما زودت cores. فالمهم تقلل الـ serial work (locks، aggregation، I/O متتالي).

قراءة كود

C#Which is faster and why?
// A
for (int i = 0; i < rows; i++)
    for (int j = 0; j < cols; j++)
        total += grid[i][j];          // jagged array: int[][]

// B
for (int j = 0; j < cols; j++)
    for (int i = 0; i < rows; i++)
        total += grid[i][j];
أيهم أسرع؟ وليه؟ وإيه اللي ممكن يخلي الفرق أقل؟

A أسرع غالباً: بتمشي على كل صف (array متجاور) بالترتيب فبتستفيد من الـ cache lines. B بتقفز بين صفوف مختلفة في كل خطوة (كل صف array منفصل في الـ heap) ⇒ cache misses. الفرق بيقل لو المصفوفة صغيرة بحيث كلها تدخل في L1/L2.

C#Spot the bug
int total = 0;
foreach (var order in orders)         // orders: millions of items
    total += order.PriceInCents * order.Quantity;
فين الخطر؟

الـ int ممكن يعمل overflow بصمت (wrap) لو المجموع عدى 2.147 مليار (21 مليون جنيه بالقروش). الحل: long total وللحسابات الحرجة checked، أو decimal لو بتتعامل بعملات.

أسئلة إنترفيو شائعة

الفرق بين RAM والـ cache والـ registers؟

الـ registers جوه الـ core (أسرع، ~16 قيمة). الـ cache (L1-L3) بين الـ core والـ RAM بيخزن نسخ من اللي بيتستخدم كتير (KBs-MBs). الـ RAM هي الذاكرة الرئيسية (GBs) أبطأ ~100x من L1. الـ hierarchy قائمة على trade-off حجم/سرعة/تكلفة.

ليه تحسين الـ algorithm أهم من الـ micro-optimizations في أغلب الأوقات؟

لأن الـ algorithm بيغير معدل النمو (n² → n log n) فمكسبه بيكبر مع الحجم، بينما micro-optimizations بتحسّن ثابت (مرتين أو 3). ومع ذلك في الـ hot paths والتعامل مع داتا ضخمة الـ locality والـ allocations بتفرق جداً، بعد القياس.

لو الـ API بطيء، هتقيس إيه الأول؟

الـ latency percentiles ثم breakdown: وقت الـ DB (عدد queries وزمن كل واحد)، network calls خارجية، serialization، وضغط الـ GC/thread pool. الأدوات: APM/OpenTelemetry، dotnet-counters، dotnet-trace، وـ query plans. النهاية: غالباً N+1 queries أو index ناقص مش تفاصيل CPU.

↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

مصادر تعليمية ومتقدمة — Third-party & advanced reading

خريطة التغطية: 15 عنصر من الـ Roadmap ومكان شرحه في الدرس
RoadmapCPU§01
RoadmapRegisters§01
RoadmapInstruction Cycle§01
RoadmapALU§01
RoadmapMain Memory§02
RoadmapMemory Hierarchy§02
RoadmapCPU Cache§02
RoadmapCache Locality§02
RoadmapRAM vs Storage§06
RoadmapVirtual Memory Concepts§07
RoadmapBinary Representation§03
RoadmapBits and Bytes§03
RoadmapCPU Cores§04
RoadmapParallelism§04
RoadmapPerformance Basics§05

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس