Memory, Caches & Operating Systems: What Every Systems Rust Developer Must Know First

fn greet(name: &str) {
    let greeting = "Hello, ";   // stack: fixed-size &str slice reference
    let count: u32 = 42;        // stack: 4 bytes, known at compile time
    println!("{}{}", greeting, name);
}   // <-- stack frame is destroyed here, instantly

High addresses  ┌─────────────────────────┐
                │   Kernel space          │  (OS code & data)
                ├─────────────────────────┤
                │   Stack (grows down)    │  local vars, return addrs
                │         ↓               │
                │   ...                   │
                │         ↑               │
                │   Heap  (grows up)      │  Box, Vec, String, etc.
                ├─────────────────────────┤
                │   BSS / Data segments   │  global & static variables
                ├─────────────────────────┤
Low addresses   │   Text segment          │  compiled machine code
                └─────────────────────────┘

// FAST: sequential access — every cache line loaded is fully used
fn sum_array(data: &[u64]) -> u64 {
    data.iter().sum()     // reads data[0], data[1], ... in order
}

// SLOW: random / strided access — many cache lines loaded, each used once
fn sum_every_8th(data: &[u64]) -> u64 {
    (0..data.len()).step_by(8).map(|i| data[i]).sum()
    // CPU loads a full 64-byte cache line, uses 8 bytes, discards the rest
}

// Your Rust code (user space)
use std::fs::File;
use std::io::Write;

let mut f = File::create("hello.txt")?;  // → syscall: openat()
f.write_all(b"Hello, world!")?;          // → syscall: write()
// f dropped here                         // → syscall: close()

// Each syscall:
//   1. Saves user-space registers
//   2. Switches CPU to kernel mode (ring 0)
//   3. Kernel validates and executes the request
//   4. Switches back to user mode (ring 3)
//   5. Returns result to your program
// Cost: ~100-1000 ns per syscall — avoid tight loops of syscalls!

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc = Atomically Reference Counted — heap allocation shared across threads
    // Mutex = mutual exclusion lock — only one thread writes at a time
    let counter = Arc::new(Mutex::new(0u64));

    let handles: Vec<_> = (0..8).map(|_| {
        let counter = Arc::clone(&counter);  // clone the Arc (increments ref count)
        thread::spawn(move || {
            let mut val = counter.lock().unwrap(); // acquire lock
            *val += 1;
        }) // lock released here when 'val' goes out of scope
    }).collect();

    for h in handles { h.join().unwrap(); }

    println!("Final count: {}", *counter.lock().unwrap()); // 8
}