Struct phoenix_lang::gc::GC

pub struct GC {
    pub instances: Vec<HeapObj>,
    /* private fields */
}

The garbage collector. Let’s go

Important note to make sure I never break the GC: The only way we can deallocate something that we didnt mean to is if we have a PhoenixPointer somewhere other than the stack, globals, or in a reachable HeapObj So be careful if we ever alloc a PhoenixClosure or a PhoenixInstance when a PhoenixPointer is floating around on the rust stack => ie popping a value off, calling alloc, and then doing something with that value. If that value is the last pointer to an instance, it’ll cause the instance to be deleted

Ideas for making this not have placeholder values / fewer placeholder values: Steps to making it work:

1. Use a linked list for instances
2. When removing a value, replace the node with a placeholder
3. When removing a value next to a placeholder, merge the two together and increment a counter in the placeholder
4. When traversing the linked list, a placeholder is worth {counter} slots
5. When allocating values, use the same queue but if it hits the middle of a placeholder, split it down the middle into two placeholders? => Ideally we would not but since the free_slots stack is not ordered in any way we don’t have any guarantees

This would get rid of most of the placeholder values but with a few problems A. The memory usage of the placeholders is minimal already B. Placeholders don’t necessarily “leak”, ie: running the program for a long enough time will not cause a memory shortage unless the code itself had used that much memory without GC’ing C. Linked lists and doing those traversals will undoubtedly be slower than the current Vec implementation, will it even be worth it?

All in all, I think I’ll need to wait until I have some code to profile.

Fields

instances: Vec<HeapObj>

Implementations

impl GC

pub fn alloc( &mut self, val: HeapObj, stack: &[Value], globals: &[Global] ) -> Value

pub fn new() -> GC

Trait Implementations

impl Clone for GC

fn clone(&self) -> GC

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GC

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

Formats the value using the given formatter.

impl Default for GC

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq<GC> for GC

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.