Crate shredder

shredder

shredder is a library providing a garbage collected smart pointer: Gc. This is useful for times when you want shared access to some data, but the structure of the data has unpredictable cycles in it. (So Arc would not be appropriate.)

shredder has the following features:

• safe: detects error conditions on the fly, and protects you from undefined behavior
• ergonomic: no need to manually manage roots, just a regular smart pointer
• ready for fearless concurrency: works in multi-threaded contexts
• limited stop-the world: regular processing will rarely be interrupted
• seamless destruction: regular drop for 'static data
• clean finalization: optional finalize for non-'static data
• concurrent collection: collection happens in the background, improving performance
• concurrent destruction: destructors are run in the background, improving performance

shredder has the following limitations:

• guarded access: accessing Gc data requires acquiring a guard
• multiple collectors: only a single global collector is supported
• can't handle Rc/Arc: requires all Gc objects have straightforward ownership semantics
• further parallelization: The collector needs to be optimized and parallelized further (will fix!)
• no no-std support: The collector requires threading and other std features (will fix!)

Modules

wrappers

Helpful wrappers used for convenience methods

Macros

mark_send_type_gc_safe

A Send type can be safely marked as GcSafe, and this macro eases that implementation

Structs

Gc	A smart-pointer for data tracked by shredder garbage collector
GcGuard	A guard object that lets you access the underlying data of a Gc. It exists as data needs protection from being scanned while it's being concurrently modified.
GcSafeWrapper	GcSafeWrapper wraps a Send datatype to make it GcSafe See the documentation of Send to see where this would be useful
R	A GcSafe version of &T
RMut	A GcSafe version of &mut T
Scanner	Scanner is a struct used to manage the scanning of data, sort of analogous to Hasher Usually you will only care about this while implementing Scan

Traits

EmptyScan	Helper trait for implementing an empty scan implementation
Finalize	A trait implementing an alternative to Drop, useful for non-'static data.
GcSafe	A marker trait that marks that data can be managed in the background by the garbage collector.
Scan	A trait capturing the ability of data to be scanned for references to data in a Gc.

Functions

collect	A function for manually running a collection, ignoring the heuristic that governs normal garbage collector operations.
number_of_active_handles	Returns how many Gcs are currently in use.
number_of_tracked_allocations	Returns how many underlying allocations are currently allocated.
run_with_gc_cleanup	A convenience method for helping ensure your destructors are run.
set_gc_trigger_percent	Sets the percent more data that'll trigger collection.
synchronize_destructors	Block the current thread until the background thread has finished running the destructors for all data that was marked as garbage at the point this method was called.

Type Definitions

GMutex	A convenient alias for Gc<Mutex<T>>. Note that Gc<Mutex<T>> has additional specialized methods for working with Mutexs inside Gcs.
GRefCell	A convenient alias for Gc<RefCell<T>>. Note that Gc<RefCell<T>> has additional specialized methods for working with RefCells inside Gcs.
GRwLock	A convenient alias for Gc<RwLock<T>>. Note that Gc<Mutex<T>> has additional specialized methods for working with Mutexs inside Gcs.

Derive Macros

Scan