Current File : //opt/plesk/ruby/3.1.3/lib64/ruby/gems/3.1.0/gems/rbs-2.7.0/core/gc.rbs
# <!-- rdoc-file=gc.rb -->
# 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.
#
module GC
# <!--
# rdoc-file=gc.rb
# - GC.count -> Integer
# -->
# The number of times GC occurred.
#
# It returns the number of times GC occurred since the process started.
#
def self.count: () -> Integer
# <!--
# rdoc-file=gc.rb
# - GC.disable -> true or false
# -->
# Disables garbage collection, returning `true` if garbage collection was
# already disabled.
#
# GC.disable #=> false
# GC.disable #=> true
#
def self.disable: () -> bool
# <!--
# rdoc-file=gc.rb
# - 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
#
def self.enable: () -> bool
# <!--
# rdoc-file=gc.rb
# - GC.start -> nil
# - ObjectSpace.garbage_collect -> nil
# - include GC; garbage_collect -> nil
# - GC.start(full_mark: true, immediate_sweep: true) -> nil
# - ObjectSpace.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.
#
def self.start: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
# <!--
# rdoc-file=gc.rb
# - GC.stat -> Hash
# - GC.stat(hash) -> Hash
# - GC.stat(:key) -> Numeric
# -->
# Returns a Hash containing information about the GC.
#
# The contents of the hash are implementation specific and may change in the
# future without notice.
#
# The hash includes information about internal statistics about GC such as:
#
# count
# : The total number of garbage collections ran since application start (count
# includes both minor and major garbage collections)
# heap_allocated_pages
# : The total number of `:heap_eden_pages` + `:heap_tomb_pages`
# heap_sorted_length
# : The number of pages that can fit into the buffer that holds references to
# all pages
# heap_allocatable_pages
# : The total number of pages the application could allocate without
# additional GC
# heap_available_slots
# : The total number of slots in all `:heap_allocated_pages`
# heap_live_slots
# : The total number of slots which contain live objects
# heap_free_slots
# : The total number of slots which do not contain live objects
# heap_final_slots
# : The total number of slots with pending finalizers to be run
# heap_marked_slots
# : The total number of objects marked in the last GC
# heap_eden_pages
# : The total number of pages which contain at least one live slot
# heap_tomb_pages
# : The total number of pages which do not contain any live slots
# total_allocated_pages
# : The cumulative number of pages allocated since application start
# total_freed_pages
# : The cumulative number of pages freed since application start
# total_allocated_objects
# : The cumulative number of objects allocated since application start
# total_freed_objects
# : The cumulative number of objects freed since application start
# malloc_increase_bytes
# : Amount of memory allocated on the heap for objects. Decreased by any GC
# malloc_increase_bytes_limit
# : When `:malloc_increase_bytes` crosses this limit, GC is triggered
# minor_gc_count
# : The total number of minor garbage collections run since process start
# major_gc_count
# : The total number of major garbage collections run since process start
# remembered_wb_unprotected_objects
# : The total number of objects without write barriers
# remembered_wb_unprotected_objects_limit
# : When `:remembered_wb_unprotected_objects` crosses this limit, major GC is
# triggered
# old_objects
# : Number of live, old objects which have survived at least 3 garbage
# collections
# old_objects_limit
# : When `:old_objects` crosses this limit, major GC is triggered
# oldmalloc_increase_bytes
# : Amount of memory allocated on the heap for objects. Decreased by major GC
# oldmalloc_increase_bytes_limit
# : When `:old_malloc_increase_bytes` crosses this limit, major GC is
# triggered
#
#
# 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 CRuby.
#
def self.stat: (?::Hash[Symbol, Integer] arg0) -> ::Hash[Symbol, Integer]
| (?Symbol arg0) -> Integer
# <!--
# rdoc-file=gc.rb
# - GC.stress -> integer, true or false
# -->
# Returns current status of GC stress mode.
#
def self.stress: () -> (Integer | TrueClass | FalseClass)
# <!--
# rdoc-file=gc.rb
# - GC.stress = flag -> flag
# -->
# 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
#
def self.stress=: (Integer | TrueClass | FalseClass flag) -> (Integer | TrueClass | FalseClass)
# <!--
# rdoc-file=gc.rb
# - GC.total_time -> int
# -->
# Return measured GC total time in nano seconds.
#
def self.total_time: () -> Integer
# <!--
# rdoc-file=gc.rb
# - GC.compact
# -->
# 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.
#
def self.compact: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
# <!--
# rdoc-file=gc.rb
# - GC.verify_compaction_references(toward: nil, double_heap: false) -> hash
# -->
# 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.
#
def self.verify_compaction_references: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
# <!--
# rdoc-file=gc.c
# - GC.verify_internal_consistency -> nil
# -->
# Verify internal consistency.
#
# This method is implementation specific. Now this method checks generational
# consistency if RGenGC is supported.
#
def self.verify_internal_consistency: () -> nil
# <!--
# rdoc-file=gc.c
# - verify_transient_heap_internal_consistency()
# -->
#
def self.verify_transient_heap_internal_consistency: () -> nil
# <!--
# rdoc-file=gc.rb
# - GC.latest_gc_info -> {:gc_by=>:newobj}
# - GC.latest_gc_info(hash) -> hash
# - GC.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.
#
def self.latest_gc_info: () -> ::Hash[::Symbol, untyped]
| [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
| (Symbol key) -> untyped
# <!--
# rdoc-file=gc.rb
# - garbage_collect(full_mark: true, immediate_mark: true, immediate_sweep: true)
# -->
#
def garbage_collect: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
end
# <!-- rdoc-file=gc.c -->
# internal constants
#
GC::INTERNAL_CONSTANTS: Hash[Symbol, Integer]
# <!-- rdoc-file=gc.c -->
# GC build options
#
GC::OPTS: Array[String]
# <!-- rdoc-file=gc.c -->
# The GC profiler provides access to information on GC runs including time,
# length and object space size.
#
# Example:
#
# GC::Profiler.enable
#
# require 'rdoc/rdoc'
#
# GC::Profiler.report
#
# GC::Profiler.disable
#
# See also GC.count, GC.malloc_allocated_size and GC.malloc_allocations
#
module GC::Profiler
# <!--
# rdoc-file=gc.c
# - GC::Profiler.clear -> nil
# -->
# Clears the GC profiler data.
#
def self.clear: () -> void
# <!--
# rdoc-file=gc.c
# - GC::Profiler.disable -> nil
# -->
# Stops the GC profiler.
#
def self.disable: () -> void
# <!--
# rdoc-file=gc.c
# - GC::Profiler.enable -> nil
# -->
# Starts the GC profiler.
#
def self.enable: () -> void
# <!--
# rdoc-file=gc.c
# - GC::Profiler.enabled? -> true or false
# -->
# The current status of GC profile mode.
#
def self.enabled?: () -> bool
# <!--
# rdoc-file=gc.c
# - GC::Profiler.raw_data -> [Hash, ...]
# -->
# Returns an Array of individual raw profile data Hashes ordered from earliest
# to latest by `:GC_INVOKE_TIME`.
#
# For example:
#
# [
# {
# :GC_TIME=>1.3000000000000858e-05,
# :GC_INVOKE_TIME=>0.010634999999999999,
# :HEAP_USE_SIZE=>289640,
# :HEAP_TOTAL_SIZE=>588960,
# :HEAP_TOTAL_OBJECTS=>14724,
# :GC_IS_MARKED=>false
# },
# # ...
# ]
#
# The keys mean:
#
# `:GC_TIME`
# : Time elapsed in seconds for this GC run
# `:GC_INVOKE_TIME`
# : Time elapsed in seconds from startup to when the GC was invoked
# `:HEAP_USE_SIZE`
# : Total bytes of heap used
# `:HEAP_TOTAL_SIZE`
# : Total size of heap in bytes
# `:HEAP_TOTAL_OBJECTS`
# : Total number of objects
# `:GC_IS_MARKED`
# : Returns `true` if the GC is in mark phase
#
#
# If ruby was built with `GC_PROFILE_MORE_DETAIL`, you will also have access to
# the following hash keys:
#
# `:GC_MARK_TIME`
# `:GC_SWEEP_TIME`
# `:ALLOCATE_INCREASE`
# `:ALLOCATE_LIMIT`
# `:HEAP_USE_PAGES`
# `:HEAP_LIVE_OBJECTS`
# `:HEAP_FREE_OBJECTS`
# `:HAVE_FINALIZE`
# :
#
def self.raw_data: () -> ::Array[::Hash[Symbol, untyped]]
# <!--
# rdoc-file=gc.c
# - GC::Profiler.report
# - GC::Profiler.report(io)
# -->
# Writes the GC::Profiler.result to `$stdout` or the given IO object.
#
def self.report: (?IO io) -> void
# <!--
# rdoc-file=gc.c
# - GC::Profiler.result -> String
# -->
# Returns a profile data report such as:
#
# GC 1 invokes.
# Index Invoke Time(sec) Use Size(byte) Total Size(byte) Total Object GC time(ms)
# 1 0.012 159240 212940 10647 0.00000000000001530000
#
def self.result: () -> String
# <!--
# rdoc-file=gc.c
# - GC::Profiler.total_time -> float
# -->
# The total time used for garbage collection in seconds
#
def self.total_time: () -> Float
end
Mini Shell