The GC module provides an interface to Ruby's mark and sweep garbage collection mechanism.

Some of the underlying methods are also available via the ObjectSpace module.

You may obtain information about the operation of the GC through GC::Profiler.

Namespace
Methods
C
D
E
G
M
S
Class Public methods
GC.count → Integer

The number of times GC occurred.

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

static VALUE
gc_count(VALUE self)
{
    return UINT2NUM(rb_objspace.count);
}
GC.disable → true or false

Disables garbage collection, returning true if garbage collection was already disabled.

GC.disable   #=> false
GC.disable   #=> true
VALUE
rb_gc_disable(void)
{
    rb_objspace_t *objspace = &rb_objspace;
    int old = dont_gc;

    rest_sweep(objspace);

    dont_gc = TRUE;
    return old ? Qtrue : Qfalse;
}
GC.enable → true or false

Enables garbage collection, returning true if garbage collection was previously disabled.

GC.disable   #=> false
GC.enable    #=> true
GC.enable    #=> false
VALUE
rb_gc_enable(void)
{
    rb_objspace_t *objspace = &rb_objspace;
    int old = dont_gc;

    dont_gc = FALSE;
    return old ? Qtrue : Qfalse;
}
GC.malloc_allocated_size → Integer

Returns the size of memory allocated by malloc().

Only available if ruby was built with CALC_EXACT_MALLOC_SIZE.

static VALUE
gc_malloc_allocated_size(VALUE self)
{
    return UINT2NUM(rb_objspace.malloc_params.allocated_size);
}
GC.malloc_allocations → Integer

Returns the number of malloc() allocations.

Only available if ruby was built with CALC_EXACT_MALLOC_SIZE.

static VALUE
gc_malloc_allocations(VALUE self)
{
    return UINT2NUM(rb_objspace.malloc_params.allocations);
}
GC.start → nil

Initiates garbage collection, unless manually disabled.

VALUE
rb_gc_start(void)
{
    rb_gc();
    return Qnil;
}
GC.stat → Hash

Returns a Hash containing information about the GC.

The hash includes information about internal statistics about GC such as:

{
    :count=>0,
    :heap_used=>12,
    :heap_length=>12,
    :heap_increment=>0,
    :heap_live_num=>7539,
    :heap_free_num=>88,
    :heap_final_num=>0,
    :total_allocated_object=>7630,
    :total_freed_object=>88
}

The contents of the hash are implementation specific and may be changed in the future.

This method is only expected to work on C Ruby.

static VALUE
gc_stat(int argc, VALUE *argv, VALUE self)
{
    rb_objspace_t *objspace = &rb_objspace;
    VALUE hash;
    static VALUE sym_count;
    static VALUE sym_heap_used, sym_heap_length, sym_heap_increment;
    static VALUE sym_heap_live_num, sym_heap_free_num, sym_heap_final_num;
    static VALUE sym_total_allocated_object, sym_total_freed_object;
    if (sym_count == 0) {
        sym_count = ID2SYM(rb_intern_const("count"));
        sym_heap_used = ID2SYM(rb_intern_const("heap_used"));
        sym_heap_length = ID2SYM(rb_intern_const("heap_length"));
        sym_heap_increment = ID2SYM(rb_intern_const("heap_increment"));
        sym_heap_live_num = ID2SYM(rb_intern_const("heap_live_num"));
        sym_heap_free_num = ID2SYM(rb_intern_const("heap_free_num"));
        sym_heap_final_num = ID2SYM(rb_intern_const("heap_final_num"));
        sym_total_allocated_object = ID2SYM(rb_intern_const("total_allocated_object"));
        sym_total_freed_object = ID2SYM(rb_intern_const("total_freed_object"));
    }

    if (rb_scan_args(argc, argv, "01", &hash) == 1) {
        if (!RB_TYPE_P(hash, T_HASH))
            rb_raise(rb_eTypeError, "non-hash given");
    }

    if (hash == Qnil) {
        hash = rb_hash_new();
    }

    rest_sweep(objspace);

    rb_hash_aset(hash, sym_count, SIZET2NUM(objspace->count));
    /* implementation dependent counters */
    rb_hash_aset(hash, sym_heap_used, SIZET2NUM(objspace->heap.used));
    rb_hash_aset(hash, sym_heap_length, SIZET2NUM(objspace->heap.length));
    rb_hash_aset(hash, sym_heap_increment, SIZET2NUM(objspace->heap.increment));
    rb_hash_aset(hash, sym_heap_live_num, SIZET2NUM(objspace_live_num(objspace)));
    rb_hash_aset(hash, sym_heap_free_num, SIZET2NUM(objspace->heap.free_num));
    rb_hash_aset(hash, sym_heap_final_num, SIZET2NUM(objspace->heap.final_num));
    rb_hash_aset(hash, sym_total_allocated_object, SIZET2NUM(objspace->total_allocated_object_num));
    rb_hash_aset(hash, sym_total_freed_object, SIZET2NUM(objspace->total_freed_object_num));

    return hash;
}
GC.stress → true or false

Returns current status of GC stress mode.

static VALUE
gc_stress_get(VALUE self)
{
    rb_objspace_t *objspace = &rb_objspace;
    return ruby_gc_stress ? Qtrue : Qfalse;
}
GC.stress = bool → bool

Updates the GC stress mode.

When stress mode is enabled, the GC is invoked at every GC opportunity: all memory and object allocations.

Enabling stress mode will degrade performance, it is only for debugging.

static VALUE
gc_stress_set(VALUE self, VALUE flag)
{
    rb_objspace_t *objspace = &rb_objspace;
    rb_secure(2);
    ruby_gc_stress = RTEST(flag);
    return flag;
}
Instance Public methods
gc.garbage_collect → nil
ObjectSpace.garbage_collect → nil

Initiates garbage collection, unless manually disabled.

VALUE
rb_gc_start(void)
{
    rb_gc();
    return Qnil;
}