Crate zerogc

Zero overhead tracing garbage collection for rust, by abusing the borrow checker.

Features

1. Easy to use, since Gc<T> is Copy and coerces to a reference.
2. Absolutely zero overhead when modifying pointers, since Gc<T> is Copy.
3. Implementation agnostic API
4. Unsafe code has complete freedom to manipulate garbage collected pointers, and it doesn’t need to understand the distinction
5. Uses rust’s lifetime system to ensure all roots are known at explicit safepoints, without any runtime overhead.
6. Collection can only happen with an explicit safepoint call and has no overhead between these calls,
7. API supports moving objects (allowing copying/generational GCs)

Re-exports

pub use crate::vec::GcArray;

Modules

cell

Implements a GcCell to allow mutating values inside garbage collected objects.

dummy_impl

Dummy collector implementation for testing

prelude

The prelude for zergogc, containing a set of commonly used types and macros.

vec

The implementation of GcVec

Macros

freeze_context

Indicate its safe to begin a garbage collection (like safepoint!) and then “freeze” the specified context.

safepoint

Indicate it’s safe to begin a garbage collection, while keeping the specified root alive.

safepoint_recurse

Invoke the closure with a temporary GcContext, then perform a safepoint afterwards.

trait_object_trace

Implement [Trace] for a dynamically dispatched trait object

unfreeze_context

Unfreeze the context, allowing it to be used again

unsafe_trace_lock

Unsafely implement GarbageCollected for the specified type, by acquiring a ‘lock’ in order to trace the underlying value.

unsafe_trace_primitive

Unsafely implement GarbageCollected for the specified type, by assuming it’s a ‘primitive’ and never needs to be traced.

Structs

AssumeNotTraced

A wrapper type that assumes its contents don’t need to be traced

Gc

A garbage collected pointer to a value.

Traits

CollectorId

Uniquely identifies the collector in case there are multiple collectors.

DynTrace

A type that can be traced via dynamic dispatch, specialized for a particular CollectorId.

GcBindHandle

Trait for binding GcHandles to contexts using GcBindHandle::bind_to

GcContext

The context of garbage collection, which can be frozen at a safepoint.

GcDirectBarrier

Safely trigger a write barrier before writing to a garbage collected value.

GcErase

Indicates that it’s safe to erase all GC lifetimes and change them to ’static (logically an ’unsafe)

GcHandle

A owned handle which points to a garbage collected object.

GcHandleSystem

A system which supports creating handles to Gc references.

GcRebrand

Changes all references to garbage collected objects to match a specific lifetime.

GcSafe

A marker type, indicating that a type can be safely allocated by a garbage collector.

GcSimpleAlloc

A simple interface to allocating from a GcContext.

GcSystem

A garbage collector implementation.

GcVisitor

Visits garbage collected objects

NullTrace

Marker types for types that don’t need to be traced

Trace

Indicates that a type can be traced by a garbage collector.

TraceImmutable

A type that can be safely traced/relocated without having to use a mutable reference