Memory-Management

Overview Garbage collection and manual memory management are two strategies for reclaiming heap memory once objects are no longer needed. GC relies on the runtime’s automatic tracing to find and free unreachable objects, while manual management puts that responsibility on the programmer via explicit free() calls. The choice trades developer safety and productivity against deterministic timing and fine-grained control. Comparison Diagram Garbage CollectionManual Memory MgmtRoots / StackObj AObj BObj CunreachableGCauto-reclaimedmalloc()Objectfree()freedptrdangling / use-after-freeManaged heapExplicit alloc / free Comparison Table Aspect Garbage Collection Manual Memory Management Object creation Allocated via language runtime (new/literal), same call site as manual Allocated explicitly via malloc/new, programmer owns the pointer Reference tracking Runtime traces reachability from roots automatically No built-in tracking; programmer must track ownership manually Freeing trigger Collector reclaims memory once it’s provably unreachable Programmer calls free()/delete at the point of last use Timing predictability Nondeterministic; collection runs on its own schedule or pauses Deterministic; memory is released the instant free() runs Common failure modes Logical leaks from lingering references, GC pause spikes Dangling pointers, double free, use-after-free, missed frees Runtime overhead Background collector thread and extra heap headroom Minimal; only allocator bookkeeping, no collector thread Developer responsibility None for freeing, but must avoid unintended references Full lifecycle ownership from allocation to deallocation Key Differences GC automates reachability tracing instead of requiring explicit free() calls Manual management gives deterministic release timing; GC introduces collection pauses Manual code risks use-after-free and double-free bugs that GC structurally prevents GC trades memory overhead for safety; manual management stays lean but unsafe Manual management gives full control over layout and timing that latency-critical systems need When to Use Each Garbage Collection ...

Overview The stack and heap are two distinct memory regions used for different allocation strategies at runtime. The stack manages function call frames automatically via a single pointer increment/decrement, while the heap handles dynamic allocations with flexible lifetimes through an allocator. The distinction directly affects allocation speed, data lifetime, size constraints, and thread safety — core considerations in systems, embedded, and performance-sensitive programming. Comparison Diagram STACKgrows downward, LIFOhighlowframe: main()frame: compute(n)frame: factorial(3)SPunusedauto-managed · O(1) · fast~1-8 MB per threadHEAPunordered, explicit lifetimeObjectVec<T>freeHashMapBoxfreeString dataArcmanual/GC · flexible · fragmentslimited by OS / RAM Comparison Table Aspect Stack Heap Allocation mechanism Pointer decrement — O(1), no bookkeeping Allocator call (malloc/new) — higher constant, free-list bookkeeping Deallocation Automatic on scope/frame exit Explicit (free/delete) or garbage collector Data lifetime Bound to the declaring scope or call frame Arbitrary; can outlive any function call Size constraint Fixed at thread creation (typically 1–8 MB) Limited only by available virtual memory / RAM Size known at compile time Required — compiler must know the type’s layout Not required — length/capacity decided at runtime Fragmentation None — LIFO order keeps allocation contiguous Yes — internal and external fragmentation accumulate over time Thread ownership Each thread has its own stack; no synchronization needed Shared across threads; allocator must serialize internally Failure mode Stack overflow → immediate crash (SIGSEGV/signal) OOM → null / exception / OOM-killer; potentially recoverable Key Differences Stack allocation is a single SP register decrement; heap allocation invokes an allocator with metadata updates, free-list traversal, and possible OS syscalls. Stack lifetime is strictly scoped to the function frame — data cannot be returned by pointer from the stack safely; heap memory can be returned, stored globally, or transferred across threads. Each thread has its own stack and needs no locking; the heap is process-wide and requires allocator-level synchronization on every alloc/free. Stack size is fixed and small (set by the OS or linker script); heap can grow dynamically, making it the only viable region for large buffers or runtime-sized collections. Heap fragmentation is a real operational concern in long-lived or allocation-heavy processes; the stack never fragments because it always grows and shrinks from one end in LIFO order. When to Use Each Stack ...