Struct rutie::GC

pub struct GC;

Garbage collection

Implementations

impl GC

pub fn adjust_memory_usage(diff: isize)

Notify memory usage to the GC engine by extension libraries, to trigger GC This is useful when you wrap large rust objects using wrap_data, when you do so, ruby is unaware of the allocated memory and might not run GC

Examples

use rutie::{GC, VM};


GC::adjust_memory_usage(25_000); // Tell ruby that we somehow allocated 25_000 bytes of mem
GC::adjust_memory_usage(-15_000); // Tell ruby that freed 15_000 bytes of mem

pub fn count() -> usize

The number of times GC occurred.

It returns the number of times GC occurred since the process started.

Examples

use rutie::{GC, VM};

GC::count();

pub fn disable() -> bool

Disable the garbage collector

Examples

use rutie::{GC, VM};

let _ = GC::disable();

pub fn enable() -> bool

Enable the garbage collector

Examples

use rutie::{GC, VM};

let _ = GC::enable();

pub fn force_recycle(object: impl Object)

Forcibly GC object.

Examples

use rutie::{RString, GC, VM};

let obj = RString::new_utf8("asdf");

GC::force_recycle(obj);

pub unsafe fn is_marked(object: &impl Object) -> bool

Check if object is marked

CAUTION: THIS FUNCTION IS ENABLED ONLY BEFORE SWEEPING. This function is only for GC_END_MARK timing.

Examples

use rutie::{RString, GC, VM};

let obj = RString::new_utf8("asdf");

GC::mark(&obj);
assert!(unsafe {GC::is_marked(&obj) }, "Object was not marked");

pub fn mark(object: &impl Object)

Mark an object for Ruby to avoid garbage collecting item.

If the wrapped struct in Rust references Ruby objects, then you'll have to mark those in the mark callback you are passing to wrapped struct.

Examples

use rutie::{RString, GC, VM};

let object = RString::new_utf8("1");

GC::mark(&object);

pub fn mark_locations(range: &[impl Object])

Mark all of the object from start to end of the array for the GC.

Examples

use rutie::{RString, GC, VM, AnyObject};

let arr = [
    RString::new_utf8("1"),
    RString::new_utf8("2"),
    RString::new_utf8("3"),
    RString::new_utf8("4"),
];

GC::mark_locations(&arr);

pub fn mark_maybe(object: &impl Object)

Maybe mark an object for Ruby to avoid garbage collecting item.

If the wrapped struct in Rust references Ruby objects, then you'll have to mark those in the mark callback you are passing to wrapped struct.

Examples

use rutie::{RString, GC, VM};

let object = RString::new_utf8("1");

GC::mark_maybe(&object);

pub fn register(object: &impl Object)

Registers the objects address with the GC

Examples

use rutie::{RString, GC, VM};

let object = RString::new_utf8("1");

GC::register(&object);

pub fn register_mark(object: &impl Object)

Mark an object as in use for Ruby to avoid garbage collecting item.

If the wrapped struct in Rust references Ruby objects, then you'll have to mark those in the mark callback you are passing to wrapped struct.

Examples

use rutie::{RString, GC, VM};

let object = RString::new_utf8("1");

GC::register_mark(&object);

pub fn start()

Start the garbage collector

Examples

use rutie::{GC, VM};

GC::start();

pub fn stat(key: &str) -> usize

Get the GC stats for a specific key

Note: Will panic if provided an invalid key.

Examples

use rutie::{GC, VM};

let result = GC::stat("heap_allocated_pages");

pub fn unregister(object: &impl Object)

Unregisters the objects address with the GC

Examples

use rutie::{RString, GC, VM};

let object = RString::new_utf8("1");

GC::unregister(&object);