Garbage Collection (GC)

The foundational tracing algorithm that operates in two distinct phases. In the mark phase, the collector traverses the object graph starting from root references (global variables, stack frames) and marks every reachable object. In the sweep phase, it scans the entire heap, deallocating memory for any object not marked as reachable.

• Advantages: Simple to implement, handles cyclic references.
• Disadvantages: Requires pausing the application (stop-the-world), can cause memory fragmentation.
• Example: Early implementations of Java Virtual Machine (JVM).

A performance optimization based on the weak generational hypothesis, which observes that most objects die young. The heap is divided into generations (e.g., Young Generation, Old Generation). New objects are allocated in the young generation, which is collected frequently with a fast minor GC. Objects that survive multiple collections are promoted to the old generation, which is collected infrequently via a slower major GC.

• Key Benefit: Reduces pause times by focusing effort where most garbage is created.
• Common in: Modern JVMs (HotSpot), .NET CLR.

A direct, non-tracing algorithm where each object maintains a count of references to it. The count is incremented when a new reference is created and decremented when a reference is destroyed. When an object's count reaches zero, its memory is immediately reclaimed.

• Advantages: Immediate reclamation, predictable pauses.
• Disadvantages: Cannot reclaim cyclic references (e.g., object A references B, and B references A), overhead on every pointer assignment.
• Use Case: File handles, COM objects, Python's primary GC mechanism (used with a cycle detector).

A tracing collector that divides the heap into two equal-sized spaces: from-space and to-space. Allocation happens only in from-space. When it fills, the collector copies all reachable objects from from-space to to-space, compacting them in the process. The roles of the spaces are then swapped.

• Advantages: Eliminates fragmentation, collection time proportional to number of live objects.
• Disadvantages: Uses only half the available heap for allocation at any time.
• Typical Use: Often used for the young generation in a generational collector.

Designed to minimize stop-the-world pauses by performing most garbage collection work concurrently with the application threads. It has phases:

1. Initial Mark: Brief pause to mark roots.
2. Concurrent Mark: Marks reachable objects while app runs.
3. Remark: Brief pause to catch updates made during concurrent mark.
4. Concurrent Sweep: Reclaims memory while app runs.

• Trade-off: Reduces pause times but increases CPU overhead and can lead to floating garbage. Deprecated in favor of G1 and ZGC in modern JVMs.

A regionalized and predictable low-pause collector for multi-processor machines with large memories. It divides the heap into equal-sized regions. G1 tracks the amount of live data in each region and prioritizes collection in the regions with the most garbage first (hence the name). It aims to meet user-defined pause time targets.

• Key Mechanism: Mixed collections that can include both young and old generation regions.
• Operation: Uses remembered sets to track references into a region, limiting scan scope.
• Default in: Java 9+ for server-style deployments.

Mark-and-sweep is the foundational two-phase algorithm underpinning most tracing garbage collectors. In the mark phase, the collector traverses the object graph starting from root references (e.g., global variables, stack frames) and marks all reachable objects. In the subsequent sweep phase, it iterates through all allocated memory, deallocating any objects not marked as reachable. This algorithm is simple but can cause program pauses and suffers from memory fragmentation.

A cache eviction policy is a deterministic algorithm that selects which items to remove from a finite-capacity cache to accommodate new entries. Unlike GC's automatic reclamation of unreachable objects, eviction policies are proactive, predictive rules based on access patterns. Common policies include:

• Least Recently Used (LRU): Evicts the item unused for the longest time.
• Least Frequently Used (LFU): Evicts the item with the fewest accesses.
• Time-To-Live (TTL): Evicts items after a fixed duration. These policies are critical for managing in-memory caches, CPU caches, and agentic context windows.

Memory fragmentation is a state where free memory is scattered into small, non-contiguous blocks, preventing allocation of larger objects despite sufficient total free space. It is a common side effect of repeated allocation and deallocation, especially with simple collectors like mark-and-sweep. Internal fragmentation occurs when allocated memory is larger than requested, while external fragmentation refers to free memory between allocated blocks. Mitigation strategies include compacting garbage collectors that relocate objects to consolidate free space and specialized allocators.

A memory leak is a software defect where a program retains references to objects that are no longer needed, preventing the garbage collector from reclaiming their memory. This leads to a gradual, monotonic increase in memory consumption, potentially causing Out-Of-Memory (OOM) errors. Leaks in managed languages (Java, C#, Go) occur through unintended long-lived references (e.g., in global caches or event listeners), not through a failure to call free(). Detection requires heap profiling and memory observability tools to identify reference chains keeping objects alive.

A write-back cache is an optimization where data modifications are written only to a fast cache (e.g., memory) initially. The write to the slower backing store (e.g., disk, database) is deferred until the cached block is evicted. This reduces I/O latency and improves throughput. In agentic memory systems, this pattern appears when an agent's working memory holds state changes that are only persisted to a vector store or knowledge graph at specific checkpoints or upon eviction. It introduces complexity around crash consistency, often solved with a Write-Ahead Log (WAL).

Thrashing is a severe performance degradation state where a system spends excessive resources moving data between hierarchy levels instead of doing useful work. In memory management, it occurs when paging or swapping is constant because the working set of active pages exceeds available physical RAM. In garbage collection, a form of thrashing can happen if the collector runs too frequently due to high allocation pressure, consuming most CPU cycles. The symptom is minimal forward progress and is addressed by increasing resource capacity or reducing allocation rates.