module GC - RDoc Documentation

# module GC

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

### Constants

INTERNAL_CONSTANTS

  internal constants

OPTS

  `GC` build options

### Public Class Methods

add_stress_to_class(class[, ...]) click to toggle source

Raises `NoMemoryError` when allocating an instance of the given classes.

    static VALUE
    rb_gcdebug_add_stress_to_class(int argc, VALUE *argv, VALUE self)
    {
        rb_objspace_t *objspace = &rb_objspace;

        if (!stress_to_class) {
            stress_to_class = rb_ary_tmp_new(argc);
        }
        rb_ary_cat(stress_to_class, argv, argc);
        return self;
    }

auto_compact → true or false click to toggle source

Returns whether or not automatic compaction has been enabled.

    # File gc.rb, line 46
    def self.auto_compact
      Primitive.gc_get_auto_compact
    end

auto_compact = flag click to toggle source

Updates automatic compaction mode.

When enabled, the compactor will execute on every major collection.

Enabling compaction will degrade performance on major collections.

    # File gc.rb, line 58
    def self.auto_compact=(flag)
      Primitive.gc_set_auto_compact(flag)
    end

compact click to toggle source

This function compacts objects together in Ruby's heap. It eliminates unused space (or fragmentation) in the heap by moving objects in to that unused space. This function returns a hash which contains statistics about which objects were moved. See `GC.latest_gc_info` for details about compaction statistics.

This method is implementation specific and not expected to be implemented in any implementation besides MRI.

    # File gc.rb, line 212
    def self.compact
      Primitive.gc_compact
    end

count → Integer click to toggle source

The number of times `GC` occurred.

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

    # File gc.rb, line 120
    def self.count
      Primitive.gc_count
    end

disable → true or false click to toggle source

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

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

    # File gc.rb, line 84
    def self.disable
      Primitive.gc_disable
    end

enable → true or false click to toggle source

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

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

    # File gc.rb, line 72
    def self.enable
      Primitive.gc_enable
    end

latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS→11}} click to toggle source

    Returns information about object moved in the most recent GC compaction.

The returned hash has two keys :considered and :moved. The hash for :considered lists the number of objects that were considered for movement by the compactor, and the :moved hash lists the number of objects that were actually moved. Some objects can't be moved (maybe they were pinned) so these numbers can be used to calculate compaction efficiency.

    # File gc.rb, line 197
    def self.latest_compact_info
      Primitive.gc_compact_stats
    end

latest_gc_info -> {:gc_by→:newobj} click to toggle source
latest_gc_info(hash) → hash
latest_gc_info(:major_by) → :malloc

    Returns information about the most recent garbage collection.

If the optional argument, hash, is given, it is overwritten and returned. This is intended to avoid probe effect.

    # File gc.rb, line 183
    def self.latest_gc_info hash_or_key = nil
      Primitive.gc_latest_gc_info hash_or_key
    end

malloc_allocated_size → Integer click to toggle source

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

malloc_allocations → Integer click to toggle source

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

remove_stress_to_class(class[, ...]) click to toggle source

No longer raises `NoMemoryError` when allocating an instance of the given classes.

    static VALUE
    rb_gcdebug_remove_stress_to_class(int argc, VALUE *argv, VALUE self)
    {
        rb_objspace_t *objspace = &rb_objspace;
        int i;

        if (stress_to_class) {
            for (i = 0; i < argc; ++i) {
                rb_ary_delete_same(stress_to_class, argv[i]);
            }
            if (RARRAY_LEN(stress_to_class) == 0) {
                stress_to_class = 0;
            }
        }
        return Qnil;
    }

start → nil click to toggle source
garbage_collect → nil
include GC; garbage_collect → nil
start(full_mark: true, immediate_sweep: true) → nil
garbage_collect(full_mark: true, immediate_sweep: true) → nil
include GC; garbage_collect(full_mark: true, immediate_sweep: true) → nil

Initiates garbage collection, even if manually disabled.

This method is defined with keyword arguments that default to true:

    def GC.start(full_mark: true, immediate_sweep: true); end

Use full_mark: false to perform a minor `GC`. Use immediate_sweep: false to defer sweeping (use lazy sweep).

Note: These keyword arguments are implementation and version dependent. They are not guaranteed to be future-compatible, and may be ignored if the underlying implementation does not support them.

    # File gc.rb, line 33
    def self.start full_mark: true, immediate_mark: true, immediate_sweep: true
      Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep, false
    end

stat → Hash click to toggle source
stat(hash) → hash
stat(:key) → Numeric

Returns a `Hash` containing information about the `GC`.

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

    {
        :count=>0,
        :heap_allocated_pages=>24,
        :heap_sorted_length=>24,
        :heap_allocatable_pages=>0,
        :heap_available_slots=>9783,
        :heap_live_slots=>7713,
        :heap_free_slots=>2070,
        :heap_final_slots=>0,
        :heap_marked_slots=>0,
        :heap_eden_pages=>24,
        :heap_tomb_pages=>0,
        :total_allocated_pages=>24,
        :total_freed_pages=>0,
        :total_allocated_objects=>7796,
        :total_freed_objects=>83,
        :malloc_increase_bytes=>2389312,
        :malloc_increase_bytes_limit=>16777216,
        :minor_gc_count=>0,
        :major_gc_count=>0,
        :remembered_wb_unprotected_objects=>0,
        :remembered_wb_unprotected_objects_limit=>0,
        :old_objects=>0,
        :old_objects_limit=>0,
        :oldmalloc_increase_bytes=>2389760,
        :oldmalloc_increase_bytes_limit=>16777216
    }

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

If the optional argument, hash, is given, it is overwritten and returned. This is intended to avoid probe effect.

This method is only expected to work on C Ruby.

    # File gc.rb, line 169
    def self.stat hash_or_key = nil
      Primitive.gc_stat hash_or_key
    end

stress → integer, true or false click to toggle source

Returns current status of `GC` stress mode.

    # File gc.rb, line 92
    def self.stress
      Primitive.gc_stress_get
    end

stress = flag → flag click to toggle source

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.

flag can be true, false, or an integer bit-ORed following flags.

    0x01:: no major GC
    0x02:: no immediate sweep
    0x04:: full mark after malloc/calloc/realloc

    # File gc.rb, line 110
    def self.stress=(flag)
      Primitive.gc_stress_set_m flag
    end

verify_compaction_references(toward: nil, double_heap: false) → hash click to toggle source

Verify compaction reference consistency.

This method is implementation specific. During compaction, objects that were moved are replaced with T_MOVED objects. No object should have a reference to a T_MOVED object after compaction.

This function doubles the heap to ensure room to move all objects, compacts the heap to make sure everything moves, updates all references, then performs a full `GC`. If any object contains a reference to a T_MOVED object, that object should be pushed on the mark stack, and will make a SEGV.

    # File gc.rb, line 230
    def self.verify_compaction_references(toward: nil, double_heap: false)
      Primitive.gc_verify_compaction_references(double_heap, toward == :empty)
    end

verify_internal_consistency → nil click to toggle source

Verify internal consistency.

This method is implementation specific. Now this method checks generational consistency if RGenGC is supported.

    static VALUE
    gc_verify_internal_consistency_m(VALUE dummy)
    {
        gc_verify_internal_consistency(&rb_objspace);
        return Qnil;
    }

verify_transient_heap_internal_consistency() click to toggle source

    static VALUE
    gc_verify_transient_heap_internal_consistency(VALUE dmy)
    {
        rb_transient_heap_verify();
        return Qnil;
    }

### Public Instance Methods

garbage_collect(full_mark: true, immediate_mark: true, immediate_sweep: true) click to toggle source

    # File gc.rb, line 37
    def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true
      Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep, false
    end