garbage collection

Bilingual

Beej's Bit Bucket
2 months ago
- Object pools reuse objects to reduce garbage collection overhead and performance hitches.
- Garbage collectors handle memory automatically but can cause delays when many temporary objects are created.
- An object pool maintains a list of reusable objects; objects are borrowed and returned instead of allocated and freed.
- If no idle object is available, the pool allocates a new one; otherwise, it reuses an existing object from the free list.
- The number of allocated objects stabilizes as the pool adjusts to demand, avoiding unnecessary allocations.
- The free list can be cleared (e.g., with a 'Collect' button) to shrink the pool when it becomes too large.
- Objects should be zeroed or sanitized when returned to the pool to prevent data leaks.
- In JavaScript, a stack (Array with push and pop) can implement the object pool, passing a constructor to define the object type.
GC and Exceptions in Wasmtime
2 months ago
- Wasmtime 47 enables Wasm GC and exceptions by default, supporting more languages on WebAssembly.
- Wasm GC eliminates the need for embedded garbage collectors by adding struct/array types and automatic lifecycle management.
- Wasm Exceptions provides efficient try/catch constructs, replacing custom calling conventions and reducing binary size and overhead.
- Wasmtime uses a Cheney-style copying collector with 32-bit GC references based on linear memory for safety and portability.
- Performance is secondary to correctness for now; the collector is optimized for many short-lived Wasm instances.
- Future work includes alias-analysis optimizations and GC integration with the component model via lazy value lowering.
Meta Garbage Collection: Using OCaml's GC to GC Rust
2 months ago
- Soteria Rust, a symbolic execution tool, experienced quadratic slowdown due to its Tree Borrows aliasing model when handling loops.
- The fix leverages OCaml's garbage collector to automatically remove unreachable tree nodes, using weak references and periodic major collections.
- This change achieved linear execution time and up to 10x speedup on benchmarks, with only about 40 lines of code.
- The approach highlights the benefit of deeply integrating with the host language (OCaml) for complex memory management tasks.
Tune Code Before Your Garbage Collector
3 months ago
- Memory allocation optimization in Java can have a greater impact on performance than the choice of Garbage Collector (GC).
- A benchmark using JLBH for MarketDataSnapshot to NewOrderSingle at 50K/s for 30 minutes compared logging with SLF4J versus no logging (using Chronicle Queue).
- Adding redundant SLF4J logging significantly degraded latency metrics (p99 and p99.99) across various GCs like Parallel, ZGC, G1, and Shenandoah.
- Moving logs to a tmpfs filesystem reduced latency, but removing redundant logging entirely led to even greater improvements, with p99.99 dropping by three orders of magnitude.
- Removing logging changed the optimal GC choice: Parallel GC performed best, while Shenandoah worsened, highlighting that workload optimization should precede GC tuning.
Website is served from a 200KB binary
2 months ago
- AOT systems language that compiles directly to x86-64 with a philosophy of treating world failures as data and bugs as fatal errors.
- Original garbage collector had critical flaws: it moved live objects on macOS/Windows, reclaimed almost no memory, and caused server crashes after 828 requests; rewriting it enabled stable handling of 20,000 requests.
- Many bugs existed unnoticed due to structural issues like untestable heap size, which was fixed by making heap size a compile-time knob, revealing multiple backend and memory management errors.
- Language design prioritized immediate error detection, catching mistakes quickly (e.g., miscompilations, uninitialized stack reads) and enshrining the thesis that 'bugs are fatal' and 'world failures are data'.
- Claude (the AI) contributed significantly to compiler improvements, including garbage collector rewrite, first-class op references, and HTTP stack, highlighting effectiveness in fixing implementation flaws over philosophy changes.

garbage collection

Beej's Bit Bucket

GC and Exceptions in Wasmtime

Meta Garbage Collection: Using OCaml's GC to GC Rust

Tune Code Before Your Garbage Collector

Website is served from a 200KB binary