Yaddaş İerarxiyası

Memory Hierarchy Nədir?

Memory Hierarchy - müxtəlif sürət və tutum xarakteristikalarına malik yaddaş səviyyələrinin təşkilidir. Məqsəd sürətli və ucuz yaddaşın balansını təmin etməkdir.

Yaddaş Piramidası

graph TB
    subgraph "Sürət və Qiymət"
        R[Registers<br/>~1 cycle<br/>~KB]
    end
    
    R --> L1[L1 Cache<br/>~4 cycles<br/>~32-64 KB]
    L1 --> L2[L2 Cache<br/>~10-20 cycles<br/>~256-512 KB]
    L2 --> L3[L3 Cache<br/>~40-75 cycles<br/>~8-32 MB]
    L3 --> RAM[Main Memory RAM<br/>~200+ cycles<br/>~GB]
    RAM --> SSD[SSD Storage<br/>~100K cycles<br/>~TB]
    SSD --> HDD[HDD Storage<br/>~1M cycles<br/>~TB]
    
    style R fill:#ff6b6b
    style L1 fill:#ffa500
    style L2 fill:#ffd700
    style L3 fill:#90ee90
    style RAM fill:#87ceeb
    style SSD fill:#dda0dd
    style HDD fill:#d3d3d3

Əsas Səviyyələr

1. Registers

• Yer: CPU daxilində
• Sürət: 1 cycle (~0.25 ns)
• Ölçü: 32-256 bytes
• Xüsusiyyət: Ən sürətli, ən kiçik

2. Cache Memory

L1 Cache (Level 1)

• CPU core-a aid
• Split: Instruction cache (I-cache) və Data cache (D-cache)
• Ölçü: 32-64 KB per core
• Latency: 4-5 cycles

L2 Cache (Level 2)

• Core-a aid və ya shared
• Unified cache (instruction + data)
• Ölçü: 256-512 KB per core
• Latency: 12-20 cycles

L3 Cache (Level 3)

• Bütün core-lar arasında shared
• Ölçü: 8-32 MB
• Latency: 40-75 cycles

3. Main Memory (RAM)

• Ölçü: 8-128 GB (tipik sistemlərdə)
• Latency: 200-300 cycles (~50-100 ns)
• Volatile: Elektrik kəsilməsi ilə məlumat itirilir

4. Storage (SSD/HDD)

• SSD: 100,000+ cycles (~100 μs)
• HDD: 10,000,000+ cycles (~10 ms)
• Non-volatile: Məlumat qalır

Yaddaş İerarxiyası Cədvəli

Səviyyə	Sürət	Ölçü	Qiymət/GB	Latency
Registers	Ən sürətli	~KB	N/A	~1 cycle
L1 Cache	Çox sürətli	~64 KB	N/A	~4 cycles
L2 Cache	Sürətli	~512 KB	N/A	~12 cycles
L3 Cache	Orta sürətli	~16 MB	N/A	~40 cycles
RAM	Orta	~16 GB	Orta	~200 cycles
SSD	Yavaş	~1 TB	Aşağı	~100 μs
HDD	Çox yavaş	~4 TB	Ən aşağı	~10 ms

Locality Principles

Temporal Locality (Zaman Lokalliği)

Yaxın keçmişdə istifadə olunan məlumatlara yenidən müraciət olma ehtimalı yüksəkdir.

sequenceDiagram
    participant CPU
    participant Cache
    participant Memory
    
    Note over CPU: Loop daxilində<br/>eyni variable
    CPU->>Cache: Request data A
    Cache->>Memory: Miss - fetch A
    Memory-->>Cache: Return A
    Cache-->>CPU: Return A
    
    CPU->>Cache: Request A (again)
    Cache-->>CPU: Hit - return A (fast!)
    
    CPU->>Cache: Request A (again)
    Cache-->>CPU: Hit - return A (fast!)

Nümunə:

for (int i = 0; i < 1000; i++) {
    sum += array[0];  // array[0] - temporal locality
}

Spatial Locality (Məkan Lokalliği)

Yaxın ünvanların da tezliklə istifadə olunma ehtimalı yüksəkdir.

graph LR
    A[Address 100] --> B[Address 104]
    B --> C[Address 108]
    C --> D[Address 112]
    
    style A fill:#90ee90
    style B fill:#90ee90
    style C fill:#90ee90
    style D fill:#90ee90

Nümunə:

for (int i = 0; i < 1000; i++) {
    sum += array[i];  // Sequential access - spatial locality
}

Memory Access Patterns

Sequential Access (Optimal)

// GOOD: Cache-friendly
for (int i = 0; i < N; i++) {
    process(array[i]);
}

Strided Access

// DECENT: Hər k-cı element
for (int i = 0; i < N; i += k) {
    process(array[i]);
}

Random Access (Worst)

// BAD: Cache-unfriendly
for (int i = 0; i < N; i++) {
    int index = random();
    process(array[index]);
}

Matrix Access Pattern

// GOOD: Row-major order (C/C++)
for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
        sum += matrix[i][j];  // Sequential in memory
    }
}

// BAD: Column-major access (C/C++)
for (int j = 0; j < M; j++) {
    for (int i = 0; i < N; i++) {
        sum += matrix[i][j];  // Strided access
    }
}

Virtual Memory

Virtual Memory - hər prosesə öz ayrı yaddaş məkanı illüziyasını yaradır.

graph TB
    subgraph "Process 1"
        V1[Virtual Address<br/>0x00000000 - 0xFFFFFFFF]
    end
    
    subgraph "Process 2"
        V2[Virtual Address<br/>0x00000000 - 0xFFFFFFFF]
    end
    
    subgraph "Physical Memory"
        P[Physical Address<br/>0x00000000 - 0x3FFFFFFF]
    end
    
    V1 -->|Page Table 1| P
    V2 -->|Page Table 2| P
    
    subgraph "Disk"
        D[Swap Space]
    end
    
    P -.->|Page out| D
    D -.->|Page in| P

Virtual Memory Üstünlükləri

• İzolyasiya: Proseslər bir-birinin yaddaşına girmə bilməz
• Abstraction: Hər proses öz yaddaşı var kimi görünür
• Paging: Physical memory-dən çox virtual memory istifadəsi
• Sharing: Kod səhifələri shared ola bilər

Virtual Memory Çatışmazlıqları

• Overhead: Address translation vaxt alır
• Page faults: Disk-ə müraciət çox yavaşdır
• TLB miss: Translation overhead

Page Tables

Page Table - virtual address-i physical address-ə çevirən cədvəldir.

graph LR
    VA[Virtual Address] --> VPN[Virtual Page Number]
    VA --> Offset[Page Offset]
    
    VPN --> PT[Page Table]
    PT --> PPN[Physical Page Number]
    
    PPN --> PA[Physical Address]
    Offset --> PA

Address Translation

Virtual Address Structure:

• Virtual Page Number (VPN): Yuxarı bitlər
• Page Offset: Aşağı bitlər

Physical Address Structure:

• Physical Page Number (PPN): Page Table-dan
• Page Offset: Dəyişmir

Multi-Level Page Tables

graph TB
    VA[Virtual Address] --> L1[Level 1 Index]
    VA --> L2[Level 2 Index]
    VA --> L3[Level 3 Index]
    VA --> Offset[Offset]
    
    L1 --> PT1[Page Directory]
    PT1 --> PT2[Page Middle Directory]
    L2 --> PT2
    PT2 --> PT3[Page Table]
    L3 --> PT3
    PT3 --> PPN[Physical Page Number]
    
    PPN --> PA[Physical Address]
    Offset --> PA

Üstünlükləri:

• Yaddaşda az yer tutur
• Sparse address space üçün yaxşı

TLB (Translation Lookaside Buffer)

TLB - page table entry-lərinin cache-idir, address translation-u sürətləndirir.

sequenceDiagram
    participant CPU
    participant TLB
    participant PageTable
    participant Memory
    
    CPU->>TLB: Virtual Address
    
    alt TLB Hit
        TLB-->>CPU: Physical Address (fast!)
        CPU->>Memory: Physical Address
        Memory-->>CPU: Data
    else TLB Miss
        TLB->>PageTable: Lookup VPN
        PageTable-->>TLB: PPN
        TLB-->>CPU: Physical Address
        Note over TLB: Update TLB
        CPU->>Memory: Physical Address
        Memory-->>CPU: Data
    end

TLB Xüsusiyyətləri

• Sürət: 1-2 cycles
• Ölçü: 64-1024 entries
• Hit rate: ~95-99%
• Structure: Fully-associative və ya set-associative

TLB Miss Növləri

Minor (Soft) TLB Miss:

• Page Table-də entry var
• Sadəcə TLB-də yox idi
• Hardware və ya OS tərəfindən həll olunur

Major (Hard) TLB Miss:

• Page Table-də entry yox
• Page disk-də (swap)
• Page fault - disk-dən yükləmə lazımdır

Memory Access Flow

graph TB
    Start[Memory Access] --> TLB_Check{TLB Hit?}
    
    TLB_Check -->|Yes| L1_Check{L1 Hit?}
    TLB_Check -->|No| PT[Page Table Walk]
    PT --> Update_TLB[Update TLB]
    Update_TLB --> L1_Check
    
    L1_Check -->|Yes| Done[Return Data]
    L1_Check -->|No| L2_Check{L2 Hit?}
    
    L2_Check -->|Yes| Update_L1[Update L1]
    L2_Check -->|No| L3_Check{L3 Hit?}
    
    L3_Check -->|Yes| Update_L2[Update L2]
    L3_Check -->|No| RAM_Check{RAM Hit?}
    
    RAM_Check -->|Yes| Update_L3[Update L3]
    RAM_Check -->|No| Page_Fault[Page Fault]
    
    Page_Fault --> Disk[Load from Disk]
    Disk --> Update_RAM[Update RAM]
    
    Update_L1 --> Done
    Update_L2 --> Update_L1
    Update_L3 --> Update_L2
    Update_RAM --> Update_L3

Performans Optimizasiyası

1. Data Structure Alignment

// BAD: Padding waste
struct Bad {
    char a;      // 1 byte
    int b;       // 4 bytes (3 bytes padding)
    char c;      // 1 byte (3 bytes padding)
};  // Total: 12 bytes

// GOOD: Optimized layout
struct Good {
    int b;       // 4 bytes
    char a;      // 1 byte
    char c;      // 1 byte (2 bytes padding)
};  // Total: 8 bytes

2. Cache Line Awareness

#define CACHE_LINE_SIZE 64

// Align to cache line
struct alignas(CACHE_LINE_SIZE) CacheAligned {
    int data;
    // ...
};

3. Sequential Access

// Prefer sequential over random access
// Utilize spatial locality
for (int i = 0; i < N; i++) {
    array[i] = compute(i);  // Sequential write
}

Əlaqəli Mövzular

• Cache Memory: Cache strukturu və protokolları
• Virtual Memory: Paging və memory management
• CPU Performance: Memory bandwidth təsiri
• False Sharing: Multi-threading cache problemləri