Session 4.1: Memory Management Fundamentals

Memory Access Time Comparison:
- CPU Register:    1 cycle     (baseline)
- L1 Cache:        3-4 cycles  (3-4x slower)
- L2 Cache:        10-20 cycles (10-20x slower)
- L3 Cache:        30-50 cycles (30-50x slower)
- Main Memory:     200-300 cycles (200-300x slower)
- SSD:             100,000+ cycles (100,000x+ slower)
- HDD:             10,000,000+ cycles (10M+ slower)

Example: If CPU register access = 1 second
- L1 Cache access = 3-4 seconds
- Main Memory access = 3-5 minutes
- SSD access = 1-2 days
- HDD access = 4-6 months

C Program Example:

#include <stdio.h>
#include <stdlib.h>

int global_initialized = 100;    // Data segment
int global_uninitialized;        // BSS segment
static int static_var = 50;      // Data segment

void function_example() {        // Text segment
    int local_var = 10;          // Stack segment
    static int static_local;     // BSS segment
    
    int *heap_ptr = malloc(sizeof(int) * 100);  // Heap segment
    
    printf("Addresses:\n");
    printf("Code (function): %p\n", function_example);
    printf("Global init: %p\n", &global_initialized);
    printf("Global uninit: %p\n", &global_uninitialized);
    printf("Local var: %p\n", &local_var);
    printf("Heap memory: %p\n", heap_ptr);
    
    free(heap_ptr);
}

Typical Output (addresses will vary):
Code (function): 0x400526
Global init: 0x601040
Global uninit: 0x601044
Local var: 0x7fff5fbff6ac
Heap memory: 0x1c3e010

Analysis:
- Code addresses are low (0x400000 range)
- Global variables in middle (0x601000 range)
- Stack addresses are high (0x7fff... range)
- Heap addresses vary (allocated by memory manager)

Example: Memory with holes of sizes [100KB, 500KB, 200KB, 300KB, 600KB]
Request: Allocate 212KB

First Fit:
- Check 100KB: Too small
- Check 500KB: ✓ Fits! Allocate here
- Result: [100KB, 288KB remaining, 200KB, 300KB, 600KB]

Best Fit:
- Check all holes: 100KB(no), 500KB(yes), 200KB(no), 300KB(yes), 600KB(yes)
- Best fit: 300KB (smallest that fits)
- Result: [100KB, 500KB, 200KB, 88KB remaining, 600KB]

Worst Fit:
- Check all holes: 100KB(no), 500KB(yes), 200KB(no), 300KB(yes), 600KB(yes)
- Worst fit: 600KB (largest available)
- Result: [100KB, 500KB, 200KB, 300KB, 388KB remaining]

Performance Analysis:
- First Fit: Fastest allocation, moderate fragmentation
- Best Fit: Slowest allocation, least wasted space per allocation
- Worst Fit: Slow allocation, may preserve large holes longer

Address Translation Example:

Process Information:
- Base Register: 14000
- Limit Register: 3000
- Logical Address: 346

Translation Process:
1. Check bounds: 346 < 3000 ✓ (valid)
2. Calculate physical: 14000 + 346 = 14346
3. Access memory at physical address 14346

If logical address ≥ limit register:
- Generate segmentation fault
- Terminate process or handle exception

Common Protection Violations:

1. Segmentation Fault (SIGSEGV):
   - Access outside allocated memory
   - Write to read-only memory
   - Execute non-executable memory
   
2. Bus Error (SIGBUS):
   - Misaligned memory access
   - Access to unmapped memory
   
3. Stack Overflow:
   - Stack grows beyond limit
   - Infinite recursion
   
OS Response to Violations:
1. Hardware generates trap/interrupt
2. OS trap handler invoked
3. Identify violating process
4. Check if violation is recoverable:
   - Recoverable: Expand stack, load page
   - Non-recoverable: Terminate process
5. Send signal to process (SIGSEGV, SIGBUS)
6. Process can handle signal or be terminated

Example Handler:
void segfault_handler(int sig) {
    printf("Segmentation fault detected!\n");
    printf("Cleaning up resources...\n");
    exit(1);
}

signal(SIGSEGV, segfault_handler);

Dynamic Library Loading Process:

1. Program Startup:
   - OS loader examines executable
   - Identifies required shared libraries
   - Checks if libraries already in memory

2. Library Loading:
   - If not loaded: Load library into memory
   - If already loaded: Map to process address space
   - Update process page tables

3. Symbol Resolution:
   - Resolve function/variable addresses
   - Update program's jump tables
   - Perform relocations if necessary

Example: Linux Shared Library (.so)
Program: myapp
Library: libmath.so.1

Loading sequence:
1. execve("myapp")
2. Loader reads ELF header
3. Finds dependency: libmath.so.1
4. Searches library paths: /lib, /usr/lib, LD_LIBRARY_PATH
5. Maps library into process address space
6. Resolves symbols (sqrt, sin, cos, etc.)
7. Updates Procedure Linkage Table (PLT)
8. Transfers control to main()

Memory Layout After Loading:
┌─────────────────────┐ ← High addresses
│ Stack               │
├─────────────────────┤
│ Shared Libraries    │ ← libmath.so, libc.so
├─────────────────────┤
│ Heap                │
├─────────────────────┤
│ BSS                 │
├─────────────────────┤
│ Data                │
├─────────────────────┤
│ Text                │
└─────────────────────┘ ← Low addresses

Non-PIC Code (Position Dependent):
    mov eax, [0x401000]    ; Absolute address
    call 0x402000          ; Absolute function address

PIC Code (Position Independent):
    mov eax, [ebx+offset]  ; Relative to base register
    call function@PLT      ; Through procedure linkage table

PIC Implementation Techniques:

1. Relative Addressing:
   - Use PC-relative addressing modes
   - Calculate addresses relative to current instruction

2. Global Offset Table (GOT):
   - Table of addresses for global variables
   - Accessed via base register

3. Procedure Linkage Table (PLT):
   - Indirect function calls
   - Allows lazy binding of function addresses

Example PIC Function:
get_global_var:
    call get_pc           ; Get current PC
get_pc:
    pop ebx               ; EBX = current PC
    add ebx, offset_to_GOT ; EBX = GOT base
    mov eax, [ebx+var_offset] ; Load variable address
    ret

Benefits of PIC:
- Shared libraries can load at any address
- Multiple processes can share same library code
- Reduces memory usage
- Enables ASLR (Address Space Layout Randomization)