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.

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

Defined Under Namespace

Modules: Profiler

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.count ⇒ Integer

The number of times GC occurred.

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

Returns:



3131
3132
3133
3134
3135
 
# File 'gc.c', line 3131

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) 


3280
3281
3282
3283
3284
3285
3286
3287
3288
 
# File 'gc.c', line 3280

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) 


3258
3259
3260
3261
3262
3263
3264
3265
3266
 
# File 'gc.c', line 3258

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

Returns the size of memory allocated by malloc().

Only available if ruby was built with CALC_EXACT_MALLOC_SIZE.

Returns:



3683
3684
3685
3686
3687
 
# File 'gc.c', line 3683

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

.malloc_allocations ⇒ Integer

Returns the number of malloc() allocations.

Only available if ruby was built with CALC_EXACT_MALLOC_SIZE.

Returns:



3698
3699
3700
3701
3702
 
# File 'gc.c', line 3698

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) 


3098
3099
3100
3101
3102
3103
 
# File 'gc.c', line 3098

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

.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.

Returns:



3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
 
# File 'gc.c', line 3164

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;
}

.stress ⇒ Boolean

Returns current status of GC stress mode.

Returns:

  • (Boolean) 


3217
3218
3219
3220
3221
3222
 
# File 'gc.c', line 3217

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

.stress=(bool) ⇒ Boolean

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.

Returns:

  • (Boolean) 


3236
3237
3238
3239
3240
3241
3242
3243
 
# File 'gc.c', line 3236

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) 


3098
3099
3100
3101
3102
3103
 
# File 'gc.c', line 3098

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