modul GC

Source

# File gc.rb, line 444
def self.config hash = nil
  if Primitive.cexpr!("RBOOL(RB_TYPE_P(hash, T_HASH))")
    if hash.include?(:implementation)
      raise ArgumentError, 'Attempting to set read-only key "Implementation"'
    end

    Primitive.gc_config_set hash
  elsif hash != nil
    raise ArgumentError
  end

  Primitive.gc_config_get
end

Diese Methode ist Implementierungs-spezifisch für CRuby.

Legt Informationen über die aktuelle GC-Konfiguration fest oder ruft sie ab.

Konfigurationsparameter sind GC-Implementierungs-spezifisch und können sich ohne Vorankündigung ändern.

Ohne Argument gibt sie einen Hash mit der Konfiguration zurück.

GC.config
# => {rgengc_allow_full_mark: true, implementation: "default"}

Mit dem Argument hash_to_merge wird dieser Hash in den gespeicherten Konfigurations-Hash integriert; unbekannte Hash-Schlüssel werden ignoriert; es wird der Konfigurations-Hash zurückgegeben.

GC.config(rgengc_allow_full_mark: false)
# => {rgengc_allow_full_mark: false, implementation: "default"}
GC.config(foo: 'bar')
# => {rgengc_allow_full_mark: false, implementation: "default"}

Konfiguration für alle Implementierungen

Der einzige schreibgeschützte Eintrag für alle Implementierungen ist

:implementation: der String-Name der Implementierung; für die Ruby-Standardimplementierung 'default'.

Implementierungs-spezifische Konfiguration

Eine GC-Implementierung unterhält ihre eigene Implementierungs-spezifische Konfiguration.

Für die Ruby-Standardimplementierung ist der einzige Eintrag

:rgengc_allow_full_mark: Steuert, ob die GC einen vollständigen Markierungsdurchlauf (junge & alte Objekte) durchführen darf.
- true (Standard): Die GC wechselt zwischen großen und kleinen Sammlungen. Ein Flag wird gesetzt, um GC zu benachrichtigen, dass eine vollständige Markierung angefordert wurde. Dieses Flag ist über GC.latest_gc_info(:need_major_by) zugänglich.
- false: Die GC leitet keinen vollständigen Markierungszyklus ein, es sei denn, sie wird explizit durch Benutzercode angewiesen; siehe GC.start. Das Setzen dieses Parameters auf false deaktiviert die Beförderung von jungen zu alten Objekten. Aus Leistungsgründen wird empfohlen, die Anwendung mit Process.warmup aufzuwärmen, bevor dieser Parameter auf false gesetzt wird.

count → integer

Source

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

Gibt die Gesamtzahl der durchgeführten Garbage Collections zurück.

GC.count # => 385
GC.start
GC.count # => 386

disable → true oder false

Source

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

Deaktiviert die Garbage Collection (aber GC.start bleibt wirksam): Gibt zurück, ob die Garbage Collection bereits deaktiviert war.

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

enable → true oder false

Source

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

Aktiviert die Garbage Collection; gibt zurück, ob die Garbage Collection deaktiviert war.

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

latest_gc_info → new_hash

latest_gc_info(key) → value

latest_gc_info(hash) → hash

Source

# File gc.rb, line 500
def self.latest_gc_info hash_or_key = nil
  if hash_or_key == nil
    hash_or_key = {}
  elsif Primitive.cexpr!("RBOOL(!SYMBOL_P(hash_or_key) && !RB_TYPE_P(hash_or_key, T_HASH))")
    raise TypeError, "non-hash or symbol given"
  end

  Primitive.cstmt! %{
    return rb_gc_latest_gc_info(hash_or_key);
  }
end

Ohne Argument gibt sie Informationen über die letzte Garbage Collection zurück.

GC.latest_gc_info
# =>
{major_by: :force,
 need_major_by: nil,
 gc_by: :method,
 have_finalizer: false,
 immediate_sweep: true,
 state: :none,
 weak_references_count: 0,
 retained_weak_references_count: 0}

Mit einem Symbolargument key wird der Wert für diesen Schlüssel zurückgegeben.

GC.latest_gc_info(:gc_by) # => :newobj

Mit einem Hash-Argument hash wird dieser Hash mit zusammengeführten GC-Informationen zurückgegeben; diese Form kann nützlich sein, um Probeeﬀekte zu minimieren.

h = {foo: 0, bar: 1}
GC.latest_gc_info(h)
# =>
{foo: 0,
 bar: 1,
 major_by: nil,
 need_major_by: nil,
 gc_by: :newobj,
 have_finalizer: false,
 immediate_sweep: false,
 state: :sweeping,
 weak_references_count: 0,
 retained_weak_references_count: 0}

measure_total_time → true oder false

Source

# File gc.rb, line 549
def self.measure_total_time
  Primitive.cexpr! %{
    RBOOL(rb_gc_impl_get_measure_total_time(rb_gc_get_objspace()))
  }
end

Gibt die Einstellung für die Messung der gesamten GC-Zeit zurück; die anfängliche Einstellung ist true. Siehe GC.total_time.

measure_total_time = setting → setting

Source

# File gc.rb, line 536
def self.measure_total_time=(flag)
  Primitive.cstmt! %{
    rb_gc_impl_set_measure_total_time(rb_gc_get_objspace(), flag);
    return flag;
  }
end

Aktiviert oder deaktiviert die Messung der gesamten GC-Zeit; gibt setting zurück. Siehe GC.total_time.

Wenn das Argument object nil oder false ist, wird die Messung der Gesamtzeit deaktiviert; GC.measure_total_time gibt dann false zurück.

GC.measure_total_time = nil   # => nil
GC.measure_total_time         # => false
GC.measure_total_time = false # => false
GC.measure_total_time         # => false

Andernfalls wird die Messung der Gesamtzeit aktiviert; GC.measure_total_time gibt dann true zurück.

GC.measure_total_time = true # => true
GC.measure_total_time        # => true
GC.measure_total_time = :foo # => :foo
GC.measure_total_time        # => true

Beachten Sie, dass die Messung der Gesamtzeit bei Aktivierung die Leistung beeinträchtigt.

start (full_mark: true, immediate_mark: true, immediate_sweep: true)

Source

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

Leitet die Garbage Collection ein, auch wenn sie durch GC.disable explizit deaktiviert wurde.

Schlüsselwortargumente

full_mark: sein boolescher Wert bestimmt, ob ein großer Garbage-Collection-Zyklus durchgeführt werden soll.
- true: leitet einen großen Garbage-Collection-Zyklus ein, was bedeutet, dass alle Objekte (alt und neu) markiert werden.
- false: leitet einen kleinen Garbage-Collection-Zyklus ein, was bedeutet, dass nur junge Objekte markiert werden.
immediate_mark: sein boolescher Wert bestimmt, ob inkrementelles Markieren durchgeführt werden soll.
- true: die Markierung wird abgeschlossen, bevor die Methode zurückkehrt.
- false: die Markierung wird in Teilen durchgeführt und mit der Programmausführung sowohl vor als auch nach der Rückkehr der Methode abwechselnd ausgeführt; daher ist die Markierung möglicherweise nicht vor der Rückkehr abgeschlossen. Beachten Sie, dass, wenn full_mark false ist, die Markierung immer sofort erfolgt, unabhängig vom Wert von immediate_mark.
immediate_sweep: sein boolescher Wert bestimmt, ob das Kehren (mittels Lazy Sweep) aufgeschoben werden soll.
- true: die Kehrung wird abgeschlossen, bevor die Methode zurückkehrt.
- false: die Kehrung wird in Teilen durchgeführt und mit der Programmausführung sowohl vor als auch nach der Rückkehr der Methode abwechselnd ausgeführt; daher ist die Kehrung möglicherweise nicht vor der Rückkehr abgeschlossen.

Beachten Sie, dass diese Schlüsselwortargumente Implementierungs- und Versionsabhängig sind, nicht garantiert zukunftssicher sind und in einigen Implementierungen ignoriert werden können.

stat → new_hash

stat(key) → value

stat(hash) → hash

Source

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

Diese Methode ist Implementierungs-spezifisch für CRuby.

Gibt GC-Statistiken zurück. Die spezifischen Statistiken sind implementierungsspezifisch und können sich in Zukunft ohne Vorankündigung ändern.

Ohne Argument gibt sie Informationen über die letzte Garbage Collection zurück.

GC.stat
# =>
{count: 28,
 time: 1,
 marking_time: 1,
 sweeping_time: 0,
 heap_allocated_pages: 521,
 heap_empty_pages: 0,
 heap_allocatable_slots: 0,
 heap_available_slots: 539590,
 heap_live_slots: 422243,
 heap_free_slots: 117347,
 heap_final_slots: 0,
 heap_marked_slots: 264877,
 heap_eden_pages: 521,
 total_allocated_pages: 521,
 total_freed_pages: 0,
 total_allocated_objects: 2246376,
 total_freed_objects: 1824133,
 malloc_increase_bytes: 50982,
 malloc_increase_bytes_limit: 18535172,
 minor_gc_count: 18,
 major_gc_count: 10,
 compact_count: 0,
 read_barrier_faults: 0,
 total_moved_objects: 0,
 remembered_wb_unprotected_objects: 0,
 remembered_wb_unprotected_objects_limit: 2162,
 old_objects: 216365,
 old_objects_limit: 432540,
 oldmalloc_increase_bytes: 1654232,
 oldmalloc_increase_bytes_limit: 16846103}

Mit einem Symbolargument key wird der Wert für diesen Schlüssel zurückgegeben.

GC.stat(:count) # => 30

Mit einem Hash-Argument hash wird dieser Hash mit zusammengeführten GC-Statistiken zurückgegeben; diese Form kann nützlich sein, um Probeeﬀekte zu minimieren.

h = {foo: 0, bar: 1}
GC.stat(h)
h.keys.take(5) # => [:foo, :bar, :count, :time, :marking_time]

Der Hash enthält Einträge wie

:count: Die Gesamtzahl der ausgeführten Garbage Collections seit Anwendungsstart (die Zählung umfasst sowohl kleine als auch große Garbage Collections).
:time: Die Gesamtzeit, die in Garbage Collections verbracht wurde (in Millisekunden).
:heap_allocated_pages: Die Gesamtzahl der zugewiesenen Seiten.
:heap_empty_pages: Die Anzahl der Seiten ohne lebende Objekte, die an das System zurückgegeben werden könnten.
:heap_sorted_length: Die Anzahl der Seiten, die in den Puffer passen, der Referenzen auf alle Seiten enthält.
:heap_allocatable_pages: Die Gesamtzahl der Seiten, die die Anwendung ohne zusätzliche GC zuweisen kann.
:heap_available_slots: Die Gesamtzahl der freien Slots in allen :heap_allocated_pages.
:heap_live_slots: Die Gesamtzahl der Slots, die lebende Objekte enthalten.
:heap_free_slots: Die Gesamtzahl der Slots, die keine lebenden Objekte enthalten.
:heap_final_slots: Die Gesamtzahl der Slots mit auszuführenden Finalizern.
:heap_marked_slots: Die Gesamtzahl der Objekte, die in der letzten GC markiert wurden.
:heap_eden_pages: Die Gesamtzahl der Seiten, die mindestens einen lebenden Slot enthalten.
:total_allocated_pages: Die kumulative Anzahl der zugewiesenen Seiten seit Anwendungsstart.
:total_freed_pages: Die kumulative Anzahl der freigegebenen Seiten seit Anwendungsstart.
:total_allocated_objects: Die kumulative Anzahl der zugewiesenen Objekte seit Anwendungsstart.
:total_freed_objects: Die kumulative Anzahl der freigegebenen Objekte seit Anwendungsstart.
:malloc_increase_bytes: Menge des im Heap für Objekte zugewiesenen Speichers. Reduziert durch jede GC.
:malloc_increase_bytes_limit: Wenn :malloc_increase_bytes diesen Grenzwert überschreitet, wird eine GC ausgelöst.
:minor_gc_count: Die Gesamtzahl der kleinen Garbage Collections seit Prozessstart.
:major_gc_count: Die Gesamtzahl der großen Garbage Collections seit Prozessstart.
:compact_count: Die Gesamtzahl der Kompaktierungen seit Prozessstart.
:read_barrier_faults: Die Gesamtzahl der Male, bei denen die Lesesperre während der Kompaktierung ausgelöst wurde.
:total_moved_objects: Die Gesamtzahl der von der Kompaktierung verschobenen Objekte.
:remembered_wb_unprotected_objects: Die Gesamtzahl der Objekte ohne Schreibsperren.
:remembered_wb_unprotected_objects_limit: Wenn :remembered_wb_unprotected_objects diesen Grenzwert überschreitet, wird eine große GC ausgelöst.
:old_objects: Anzahl der lebenden, alten Objekte, die mindestens 3 Garbage Collections überlebt haben.
:old_objects_limit: Wenn :old_objects diesen Grenzwert überschreitet, wird eine große GC ausgelöst.
:oldmalloc_increase_bytes: Menge des im Heap für Objekte zugewiesenen Speichers. Reduziert durch große GC.
:oldmalloc_increase_bytes_limit: Wenn :oldmalloc_increase_bytes diesen Grenzwert überschreitet, wird eine große GC ausgelöst.

stat_heap → new_hash

stat_heap(heap_id) → new_hash

stat_heap(heap_id, key) → value

stat_heap(nil, hash) → hash

stat_heap(heap_id, hash) → hash

Source

# File gc.rb, line 389
def self.stat_heap heap_name = nil, hash_or_key = nil
  Primitive.gc_stat_heap heap_name, hash_or_key
end

Diese Methode ist Implementierungs-spezifisch für CRuby.

Gibt Statistiken für GC-Heaps zurück. Die spezifischen Statistiken sind implementierungsspezifisch und können sich in Zukunft ohne Vorankündigung ändern.

Ohne Argument gibt sie Statistiken für alle Heaps zurück.

GC.stat_heap
# =>
{0 =>
  {slot_size: 40,
   heap_eden_pages: 246,
   heap_eden_slots: 402802,
   total_allocated_pages: 246,
   force_major_gc_count: 2,
   force_incremental_marking_finish_count: 1,
   total_allocated_objects: 33867152,
   total_freed_objects: 33520523},
 1 =>
  {slot_size: 80,
   heap_eden_pages: 84,
   heap_eden_slots: 68746,
   total_allocated_pages: 84,
   force_major_gc_count: 1,
   force_incremental_marking_finish_count: 4,
   total_allocated_objects: 147491,
   total_freed_objects: 90699},
 2 =>
  {slot_size: 160,
   heap_eden_pages: 157,
   heap_eden_slots: 64182,
   total_allocated_pages: 157,
   force_major_gc_count: 0,
   force_incremental_marking_finish_count: 0,
   total_allocated_objects: 211460,
   total_freed_objects: 190075},
 3 =>
  {slot_size: 320,
   heap_eden_pages: 8,
   heap_eden_slots: 1631,
   total_allocated_pages: 8,
   force_major_gc_count: 0,
   force_incremental_marking_finish_count: 0,
   total_allocated_objects: 1422,
   total_freed_objects: 700},
 4 =>
  {slot_size: 640,
   heap_eden_pages: 16,
   heap_eden_slots: 1628,
   total_allocated_pages: 16,
   force_major_gc_count: 0,
   force_incremental_marking_finish_count: 0,
   total_allocated_objects: 1230,
   total_freed_objects: 309}}

Im obigen Beispiel sind die Schlüssel im äußeren Hash die Heap-Identifikatoren.

GC.stat_heap.keys # => [0, 1, 2, 3, 4]

Auf CRuby ist jeder Heap-Identifikator eine Ganzzahl; bei anderen Implementierungen kann ein Heap-Identifikator ein String sein.

Mit nur dem Argument heap_id gibt sie Statistiken für den gegebenen Heap-Identifikator zurück.

GC.stat_heap(2)
# =>
{slot_size: 160,
 heap_eden_pages: 157,
 heap_eden_slots: 64182,
 total_allocated_pages: 157,
 force_major_gc_count: 0,
 force_incremental_marking_finish_count: 0,
 total_allocated_objects: 225018,
 total_freed_objects: 206647}

Mit den Argumenten heap_id und key wird der Wert für den gegebenen Schlüssel im gegebenen Heap zurückgegeben.

GC.stat_heap(2, :slot_size) # => 160

Mit den Argumenten nil und hash werden die Statistiken für alle Heaps in den gegebenen Hash integriert.

h = {foo: 0, bar: 1}
GC.stat_heap(nil, h).keys # => [:foo, :bar, 0, 1, 2, 3, 4]

Mit den Argumenten heap_id und hash werden die Statistiken für den gegebenen Heap in den gegebenen Hash integriert.

h = {foo: 0, bar: 1}
GC.stat_heap(2, h).keys
# =>
[:foo,
 :bar,
 :slot_size,
 :heap_eden_pages,
 :heap_eden_slots,
 :total_allocated_pages,
 :force_major_gc_count,
 :force_incremental_marking_finish_count,
 :total_allocated_objects,
 :total_freed_objects]

Die Statistiken für einen Heap können umfassen

:slot_size: Die Slot-Größe des Heaps in Bytes.
:heap_allocatable_pages: Die Anzahl der Seiten, die zugewiesen werden können, ohne einen neuen Garbage-Collection-Zyklus auszulösen.
:heap_eden_pages: Die Anzahl der Seiten im Eden-Heap.
:heap_eden_slots: Die Gesamtzahl der Slots in allen Seiten des Eden-Heaps.
:total_allocated_pages: Die Gesamtzahl der Seiten, die im Heap zugewiesen wurden.
:total_freed_pages: Die Gesamtzahl der Seiten, die freigegeben und an das System im Heap zurückgegeben wurden.
:force_major_gc_count: Die Anzahl der Male, die dieser Heap einen großen Garbage-Collection-Zyklus erzwingen musste, weil die freien Slots zur Neige gingen.
:force_incremental_marking_finish_count: Die Anzahl der Male, die dieser Heap das Beenden der inkrementellen Markierung erzwingen musste, weil die gepoolten Slots zur Neige gingen.

stress → setting

Source

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

Gibt die aktuelle Einstellung für den GC-Stressmodus zurück, die anfangs false ist.

Der Stressmodus kann über die Methode GC.stress= eingestellt werden.

stress = value → value

Source

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

Aktiviert oder deaktiviert den Stressmodus; die Aktivierung des Stressmodus verschlechtert die Leistung; er dient nur zu Debugging-Zwecken.

Setzt den aktuellen GC-Stressmodus auf den gegebenen Wert.

Wenn der Wert nil oder false ist, wird der Stressmodus deaktiviert.
Wenn der Wert eine Ganzzahl ist, wird der Stressmodus mit bestimmten Flags aktiviert; siehe unten.
Andernfalls wird der Stressmodus aktiviert; GC wird bei jeder GC-Gelegenheit aufgerufen: alle Speicher- und Objektzuweisungen.

Die Flags sind Bits in der gegebenen Ganzzahl.

0x01: Keine große GC.
0x02: Kein sofortiges Kehren.
0x04: Vollständige Markierung nach malloc/calloc/realloc.

total_time → integer

Source

# File gc.rb, line 585
def self.total_time
  Primitive.cexpr! %{
    ULL2NUM(rb_gc_impl_get_total_time(rb_gc_get_objspace()))
  }
end

Gibt die GC-Gesamtzeit in Nanosekunden zurück.

GC.total_time # => 156250

Beachten Sie, dass die Gesamtzeit nur dann akkumuliert wird, wenn die Messung der Gesamtzeit aktiviert ist (d. h., wenn GC.measure_total_time true ist).

GC.measure_total_time # => true
GC.total_time # => 625000
GC.start
GC.total_time # => 937500
GC.start
GC.total_time # => 1093750

GC.measure_total_time = false
GC.total_time # => 1250000
GC.start
GC.total_time # => 1250000
GC.start
GC.total_time # => 1250000

GC.measure_total_time = true
GC.total_time # => 1250000
GC.start
GC.total_time # => 1406250

Öffentliche Klassenmethoden

Öffentliche Instanzmethoden