Struct gluon_vm::gc::Gc

pub struct Gc { /* fields omitted */ }

A mark and sweep garbage collector.

Implementations

impl Gc

pub fn new(generation: Generation, memory_limit: usize) -> Gc

Constructs a new garbage collector

pub fn allocated_memory(&self) -> usize

pub fn set_memory_limit(&mut self, memory_limit: usize)

pub fn generation(&self) -> Generation

pub fn new_child_gc(&self) -> Gc

pub unsafe fn alloc_and_collect<R, D>(
    &mut self,
    roots: R,
    def: D
) -> Result<OwnedGcRef<'_, D::Value>> where
    R: Trace + CollectScope,
    D: DataDef + Trace,
    D::Value: Sized + Any, 

Allocates a new object. If the garbage collector has hit the collection limit a collection will occur.

Unsafe since roots must be able to trace all accesible GcPtr values.

pub fn alloc<D>(&mut self, def: D) -> Result<GcRef<'_, D::Value>> where
    D: DataDef,
    D::Value: Sized + Any, 

Allocates a new object.

pub fn alloc_owned<D>(&mut self, def: D) -> Result<OwnedGcRef<'_, D::Value>> where
    D: DataDef,
    D::Value: Sized + Any, 

pub fn alloc_ignore_limit<D>(&mut self, def: D) -> GcRef<'_, D::Value> where
    D: DataDef,
    D::Value: Sized + Any, 

pub unsafe fn check_collect<R>(&mut self, roots: R) -> bool where
    R: Trace + CollectScope, 

pub unsafe fn collect<R>(&mut self, roots: R) where
    R: Trace + CollectScope, 

Does a mark and sweep collection by walking from roots. This function is unsafe since roots need to cover all reachable object.

pub fn mark<T: ?Sized>(&mut self, value: &GcPtr<T>) -> bool

Marks the GcPtr Returns true if the pointer was already marked

pub unsafe fn sweep(&mut self)

Clears out any unmarked pointers and resets marked pointers.

Unsafe as it is up to the caller to make sure that all reachable pointers have been marked

pub unsafe fn clear(&mut self)

Trait Implementations

impl Debug for Gc

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'gc> DeserializeState<'de, DeSeed<'gc>> for Gc

fn deserialize_state<__D>(
    __seed: &mut DeSeed<'gc>,
    __deserializer: __D
) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserializes Self using seed and the deserializer

impl Drop for Gc

fn drop(&mut self)

Executes the destructor for this type.

impl SerializeState<SeSeed> for Gc

fn serialize_state<__S>(
    &self,
    __serializer: __S,
    __seed: &SeSeed
) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serializes self