Module: GC

Defined in:

gc.c

Overview

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.

Defined Under Namespace

Modules: Profiler

Class Method Summary

• .count ⇒ Integer

  The number of times GC occurred.

• .disable ⇒ Boolean

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

• .enable ⇒ Boolean

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

• .malloc_allocated_size ⇒ Integer

  The allocated size by malloc().

• .malloc_allocations ⇒ Integer

  The number of allocated memory object by malloc().

• .start ⇒ Object

  Initiates garbage collection, unless manually disabled.

• .stress ⇒ Boolean

  returns current status of GC stress mode.

• .stress=(bool) ⇒ Object

  updates GC stress mode.

Instance Method Summary

• #garbage_collect ⇒ Object

  Initiates garbage collection, unless manually disabled.

Class Method Details

.count ⇒ Integer

The number of times GC occurred.

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

Returns:

• (Integer)

# File 'gc.c'

/*
 *  call-seq:
 *     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);
}

.disable ⇒ Boolean

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

GC.disable   #=> false
GC.disable   #=> true

Returns:

• (Boolean)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.disable    -> true or false
 *
 *  Disables garbage collection, returning <code>true</code> 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;

    dont_gc = TRUE;
    return old ? Qtrue : Qfalse;
}

.enable ⇒ Boolean

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

GC.disable   #=> false
GC.enable    #=> true
GC.enable    #=> false

Returns:

• (Boolean)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.enable    -> true or false
 *
 *  Enables garbage collection, returning <code>true</code> 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;
}

.malloc_allocated_size ⇒ Integer

The allocated size by malloc().

It returns the allocated size by malloc().

Returns:

• (Integer)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.malloc_allocated_size -> Integer
 *
 *  The allocated size by malloc().
 *
 *  It returns the allocated size by malloc().
 */

static VALUE
gc_malloc_allocated_size(VALUE self)
{
    return UINT2NUM((&rb_objspace)->malloc_params.allocated_size);
}

.malloc_allocations ⇒ Integer

The number of allocated memory object by malloc().

It returns the number of allocated memory object by malloc().

Returns:

• (Integer)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.malloc_allocations -> Integer
 *
 *  The number of allocated memory object by malloc().
 *
 *  It returns the number of allocated memory object by malloc().
 */

static VALUE
gc_malloc_allocations(VALUE self)
{
    return UINT2NUM((&rb_objspace)->malloc_params.allocations);
}

.start ⇒ nil .garbage_collect ⇒ nil .garbage_collect ⇒ nil

Initiates garbage collection, unless manually disabled.

Overloads:

• .start ⇒ nil

  Returns:

  • (nil)
• .garbage_collect ⇒ nil

  Returns:

  • (nil)
• .garbage_collect ⇒ nil

  Returns:

  • (nil)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.start                     -> nil
 *     gc.garbage_collect           -> nil
 *     ObjectSpace.garbage_collect  -> nil
 *
 *  Initiates garbage collection, unless manually disabled.
 *
 */

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

.stress ⇒ Boolean

returns current status of GC stress mode.

Returns:

• (Boolean)

# File 'gc.c'

/*
 *  call-seq:
 *    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;
}

.stress=(bool) ⇒ Object

updates GC stress mode.

When GC.stress = true, GC is invoked for all GC opportunity: all memory and object allocation.

Since it makes Ruby very slow, it is only for debugging.

# File 'gc.c'

/*
 *  call-seq:
 *    GC.stress = bool          -> bool
 *
 *  updates GC stress mode.
 *
 *  When GC.stress = true, GC is invoked for all GC opportunity:
 *  all memory and object allocation.
 *
 *  Since it makes Ruby very slow, 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 Method Details

#start ⇒ nil #garbage_collect ⇒ nil #garbage_collect ⇒ nil

Initiates garbage collection, unless manually disabled.

Overloads:

• #start ⇒ nil

  Returns:

  • (nil)
• #garbage_collect ⇒ nil

  Returns:

  • (nil)
• #garbage_collect ⇒ nil

  Returns:

  • (nil)

# File 'gc.c'

/*
 *  call-seq:
 *     GC.start                     -> nil
 *     gc.garbage_collect           -> nil
 *     ObjectSpace.garbage_collect  -> nil
 *
 *  Initiates garbage collection, unless manually disabled.
 *
 */

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