Demand Paging: What Happens When Linux Handles a Page Fault
Understand what happens when you allocate memory versus when you actually access it, what a VMA is, and how the Linux kernel uses VMAs to handle page faults.
Confessions of a Code Addict
I write about how computers work underneath the abstractions: compilers, operating systems, memory, performance, and low-level programming.
Subscribe:.rss.atom.json.md.m3u.pls
Live Last read · last published · next check
Latest episodes
Saves to your Listen queue, to pick up on another day or another device.
x86 Addressing Modes, Part 2: Indirect, Indexed, and Offset-based Modes
In this final part on addressing modes, we learn about indirect, indexed and offset-based addressing modes along with some interesting examples and exercises.
How Big Is a Physical Address?
A short aside from the virtual memory series on physical address size, why it differs from virtual address size, and why different CPUs expose different limits.
What Does a Page Table Entry Actually Store?
Watch now | Learn about the page-level metadata that is stored in the page table and how is that used by the hardware during memory access
Page Tables from First Principles
Watch now | Constructing page tables from first principle as a way to store virtual-to-physical address mappings
Understanding a Process’s Address Space Layout
In this video, we look at how a process’s virtual address space is laid out: code, data, heap, stack, shared libraries, mmap regions, and more.
Why Git Has a Variable Named false_but_the_compiler_does_not_know_it
A small C trick that keeps Clang from flagging valid code as unreachable
How Large Is the Virtual Address Space?
Watch now | How large is a process’s virtual address space, why is it split between user space and the kernel, and what are canonical virtual addresses?
Why do we need virtual memory?
Understanding virtual memory from first principles
Virtual Memory From First Principles
A practical guide to page faults, page tables, TLBs, NUMA topology, Linux internals, and performance in data-intensive systems.
How PyTorch Generates Random Numbers in Parallel on the GPU
A deep dive into Philox and counter-based RNGs