performance
38 articles tagged performance.
-
JavaScript Objects, Hidden Classes, and Inline Caches
How JavaScript engines give objects shapes, speed repeated property access, and fall back when those shapes stop matching optimized code.
-
How Compiler Register Allocation Uses Interference and Spilling
Register allocation assigns live intermediate values to CPU registers, building interference constraints and spilling selected values to memory when registers run out.
-
Copy-on-Write fork() and Copying Page Faults
How Linux makes fork() cheap by sharing memory pages until parent or child writes to one.
-
AWS Lambda Execution Environments and Cold Starts
How Lambda initializes execution environments, reuses their state, and creates separate environments as concurrent invocations increase.
-
TLB Shootdowns and Cross-Core Translation Invalidation
How operating systems keep per-core address-translation caches correct when a process’s page tables change.
-
Transformer Key-Value Cache During Generation
A transformer KV cache keeps earlier attention keys and values so each generated token avoids rebuilding the entire prefix.
-
Go’s Concurrent Garbage Collector
How Go combines tri-color marking, write barriers, and brief pauses to reclaim unreachable heap objects while goroutines keep running.
-
Linux io_uring Shared Rings and Batching
How io_uring moves requests through shared submission and completion rings, and how batching and polling reduce syscall and scheduling costs.
-
Linux Page Cache and Dirty-Page Writeback
How Linux serves file reads from memory and turns modified cached pages into storage writes and durable data.
-
HTTP/2 HPACK Header Compression
How HPACK uses shared tables, indexed fields, and Huffman coding to reduce HTTP/2 header overhead without losing decoder synchronization.
-
Python’s Vectorcall Protocol
How CPython passes callable arguments as arrays to avoid temporary tuples, dictionaries, and bound methods on common calls.
-
Linux TLB Shootdowns on Multicore Systems
How Linux keeps per-CPU virtual-to-physical translation caches correct, and why invalidating them with IPIs can hurt multicore performance.
-
Speculative Decoding with Draft and Target Models
Speculative decoding uses a fast model to propose tokens and a slower model to verify several of them in parallel, reducing generation latency.
-
Compiler Escape Analysis and Stack Allocation
How compilers follow object references to decide whether an allocation can stay in a stack frame or must be managed on the heap.
-
Cgroups v2 Resource Control for Containers
How cgroups v2 hierarchies account for and limit CPU time, memory, and process creation inside containers.
-
Rust Monomorphization and Static Dispatch
How Rust generates type-specific code for generics, and why that improves call performance while increasing build time and binary size.
-
V8 Hidden Classes and Inline Caches
How V8 tracks JavaScript object shapes, specializes property access, and deoptimizes code when those assumptions stop being true.
-
TCP Slow Start and Congestion Window Growth
How TCP uses acknowledgements to grow its sending window, then reacts to loss or ECN congestion signals.
-
Transformer KV Cache During Text Generation
How transformers store attention keys and values to avoid recomputing prior tokens, and why longer contexts consume more inference memory.
-
Linux Page-Cache Readahead
How Linux detects sequential file access, reads pages early, and limits wasted I/O when access becomes sparse or random.
-
CPU Branch Predictors and Speculative Execution
How CPUs record branch history, execute past unresolved decisions, and discard pipeline work when a prediction is wrong.
-
Linux Dirty Pages, Writeback, and fsync
How Linux caches file writes in RAM, writes them back in the background, and uses fsync to establish a durability boundary.
-
Git Commit-Graph Files and Generation Numbers
How Git records commit relationships and generation data to answer ancestry, merge-base, and reachability queries with fewer object walks.
-
Linux Copy-on-Write Across forked Processes
How Linux shares forked processes’ pages, changes their page tables, and copies memory only when a write triggers a page fault.
-
AWS Lambda Execution Environment Lifecycle
How Lambda initializes, reuses, freezes, and thaws environments—and why global state changes cold-start and warm-invocation performance.
-
TLB Shootdowns and Deferred Invalidation
How CPUs keep page-table changes safe, why TLB shootdowns interrupt other cores, and how batching reduces their performance cost.
-
Go’s Garbage-Collector Pacer and Mutator Assists
How Go’s GC pacer budgets marking CPU and makes allocating goroutines help when concurrent collection falls behind.
-
Mixture-of-Experts Routing and Load Balancing
How MoE routers send tokens to a few expert networks while capacity limits and balancing losses prevent overloaded experts.
-
DynamoDB Adaptive Capacity and Hot Partition Keys
DynamoDB adaptive capacity shifts unused throughput toward hot partition keys while keeping the table’s provisioned capacity unchanged.
-
Go’s G-M-P Scheduler
How Go’s goroutines, OS threads, processors, run queues, and work stealing determine concurrency, latency, and throughput.
-
NIC Interrupt Coalescing and Packet-Batching Tradeoffs
How NICs batch packet notifications to reduce CPU overhead, and how coalescing thresholds trade that efficiency against network latency.
-
Compiler Escape Analysis and Stack Versus Heap
Escape analysis predicts whether a value can outlive its function, guiding stack or heap placement and influencing allocation and garbage-collection costs.
-
CPU Cache-Line False Sharing
Learn why independent writes can invalidate each other’s cache lines, and how padding and data layout prevent coherence-driven slowdowns.
-
SQL Selectivity Estimates and Query Plans
How database planners use histograms to estimate matching rows, and how bad estimates lead to unexpectedly slow scans, joins, and indexes.
-
LLM Key-Value Caches During Autoregressive Generation
How cached attention keys and values eliminate repeated prefix work during generation, and why the speedup consumes substantial memory.
-
Copy-Up in Container Overlay Filesystems
How Linux overlay filesystems combine read-only image layers with a writable container layer and copy files up when a write requires them.
-
Linux TLB Shootdowns and Their Performance Cost
How Linux keeps per-core address-translation caches consistent when page-table entries change, and why that coordination can slow workloads.
-
CPython’s Global Interpreter Lock
How CPython’s GIL protects interpreter state, coordinates thread execution, and lets native extensions run parallel or blocking work safely.