10#include "gc/mmtk/mmtk.h"
12#include "ccan/list/list.h"
16#include <sys/sysctl.h>
25 size_t total_allocated_objects;
31 struct ccan_list_head ractor_caches;
32 unsigned long live_ractor_cache_count;
34 pthread_mutex_t mutex;
36 pthread_cond_t cond_world_stopped;
37 pthread_cond_t cond_world_started;
38 size_t start_the_world_count;
40 struct rb_gc_vm_context vm_context;
44 struct ccan_list_node list_node;
46 MMTk_Mutator *mutator;
54 MMTK_FINAL_JOB_FINALIZE,
63 VALUE finalizer_array;
68#ifdef RB_THREAD_LOCAL_SPECIFIER
71# error We currently need language-supported TLS
79 rb_mmtk_gc_thread_tls = gc_thread_tls;
83rb_mmtk_is_mutator(
void)
89rb_mmtk_stop_the_world(
void)
94 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
95 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
102 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
103 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
108rb_mmtk_resume_mutators(
void)
113 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
114 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
119 pthread_cond_broadcast(&
objspace->cond_world_started);
121 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
122 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
131 size_t starting_gc_count =
objspace->gc_count;
132 int lock_lev = RB_GC_VM_LOCK();
134 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
135 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
138 if (
objspace->gc_count == starting_gc_count) {
141 rb_gc_initialize_vm_context(&
objspace->vm_context);
143 mutator->gc_mutator_p =
true;
147 clock_gettime(CLOCK_MONOTONIC, &gc_start_time);
150 rb_gc_save_machine_context();
156 pthread_cond_broadcast(&
objspace->cond_world_stopped);
165 clock_gettime(CLOCK_MONOTONIC, &gc_end_time);
168 (gc_end_time.tv_sec - gc_start_time.tv_sec) * (1000 * 1000 * 1000) +
169 (gc_end_time.tv_nsec - gc_start_time.tv_nsec);
173 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
174 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
176 RB_GC_VM_UNLOCK(lock_lev);
180rb_mmtk_number_of_mutators(
void)
183 return objspace->live_ractor_cache_count;
187rb_mmtk_get_mutators(
void (*visit_mutator)(MMTk_Mutator *mutator,
void *data),
void *data)
192 ccan_list_for_each(&
objspace->ractor_caches, ractor_cache, list_node) {
193 visit_mutator(ractor_cache->mutator, data);
198rb_mmtk_scan_gc_roots(
void)
204 rb_gc_worker_thread_set_vm_context(&
objspace->vm_context);
206 rb_gc_worker_thread_unset_vm_context(&
objspace->vm_context);
210pin_value(st_data_t key, st_data_t value, st_data_t data)
212 rb_gc_impl_mark_and_pin((
void *)data, (
VALUE)value);
218rb_mmtk_scan_objspace(
void)
222 if (
objspace->finalizer_table != NULL) {
227 while (job != NULL) {
229 case MMTK_FINAL_JOB_DFREE:
231 case MMTK_FINAL_JOB_FINALIZE:
232 rb_gc_impl_mark(
objspace, job->as.finalize.finalizer_array);
235 rb_bug(
"rb_mmtk_scan_objspace: unknown final job type %d", job->kind);
243rb_mmtk_scan_object_ruby_style(MMTk_ObjectReference
object)
245 rb_gc_mark_children(rb_gc_get_objspace(), (
VALUE)
object);
249rb_mmtk_call_gc_mark_children(MMTk_ObjectReference
object)
251 rb_gc_mark_children(rb_gc_get_objspace(), (
VALUE)
object);
255rb_mmtk_call_obj_free(MMTk_ObjectReference
object)
261 rb_gc_worker_thread_set_vm_context(&
objspace->vm_context);
263 rb_gc_worker_thread_unset_vm_context(&
objspace->vm_context);
270rb_mmtk_vm_live_bytes(
void)
279 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)table));
285 job->next =
objspace->finalizer_jobs;
286 job->kind = MMTK_FINAL_JOB_FINALIZE;
287 job->as.finalize.finalizer_array = table;
293rb_mmtk_update_finalizer_table_i(st_data_t key, st_data_t value, st_data_t data)
296 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)value));
301 if (!mmtk_is_reachable((MMTk_ObjectReference)key)) {
313rb_mmtk_update_finalizer_table(
void)
318 st_foreach(
objspace->finalizer_table, rb_mmtk_update_finalizer_table_i, (st_data_t)
objspace);
322rb_mmtk_update_table_i(
VALUE val,
void *data)
324 if (!mmtk_is_reachable((MMTk_ObjectReference)val)) {
332rb_mmtk_global_tables_count(
void)
334 return RB_GC_VM_WEAK_TABLE_COUNT;
338rb_mmtk_update_global_tables(
int table)
342 rb_gc_vm_weak_table_foreach(rb_mmtk_update_table_i, NULL, NULL,
true, (
enum rb_gc_vm_weak_tables)table);
347 rb_mmtk_init_gc_worker_thread,
349 rb_mmtk_stop_the_world,
350 rb_mmtk_resume_mutators,
351 rb_mmtk_block_for_gc,
352 rb_mmtk_number_of_mutators,
353 rb_mmtk_get_mutators,
354 rb_mmtk_scan_gc_roots,
355 rb_mmtk_scan_objspace,
356 rb_mmtk_scan_object_ruby_style,
357 rb_mmtk_call_gc_mark_children,
358 rb_mmtk_call_obj_free,
359 rb_mmtk_vm_live_bytes,
360 rb_mmtk_update_global_tables,
361 rb_mmtk_global_tables_count,
362 rb_mmtk_update_finalizer_table,
366#define RB_MMTK_HEAP_LIMIT_PERC 80
367#define RB_MMTK_DEFAULT_HEAP_MIN (1024 * 1024)
368#define RB_MMTK_DEFAULT_HEAP_MAX (rb_mmtk_system_physical_memory() / 100 * RB_MMTK_HEAP_LIMIT_PERC)
371 RB_MMTK_DYNAMIC_HEAP,
376rb_mmtk_builder_init(
void)
378 MMTk_Builder *builder = mmtk_builder_default();
383rb_gc_impl_objspace_alloc(
void)
385 MMTk_Builder *builder = rb_mmtk_builder_init();
386 mmtk_init_binding(builder, NULL, &ruby_upcalls, (MMTk_ObjectReference)
Qundef);
388 return calloc(1,
sizeof(
struct objspace));
391static void gc_run_finalizers(
void *data);
394rb_gc_impl_objspace_init(
void *objspace_ptr)
400 objspace->finalizer_table = st_init_numtable();
403 ccan_list_head_init(&
objspace->ractor_caches);
405 objspace->mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
406 objspace->cond_world_stopped = (pthread_cond_t)PTHREAD_COND_INITIALIZER;
407 objspace->cond_world_started = (pthread_cond_t)PTHREAD_COND_INITIALIZER;
411rb_gc_impl_objspace_free(
void *objspace_ptr)
417rb_gc_impl_ractor_cache_alloc(
void *objspace_ptr,
void *ractor)
420 if (
objspace->live_ractor_cache_count == 0) {
421 mmtk_initialize_collection(ractor);
423 objspace->live_ractor_cache_count++;
426 ccan_list_add(&
objspace->ractor_caches, &cache->list_node);
428 cache->mutator = mmtk_bind_mutator(cache);
434rb_gc_impl_ractor_cache_free(
void *objspace_ptr,
void *cache_ptr)
439 ccan_list_del(&cache->list_node);
442 objspace->live_ractor_cache_count--;
444 mmtk_destroy_mutator(cache->mutator);
447void rb_gc_impl_set_params(
void *objspace_ptr) { }
449static VALUE gc_verify_internal_consistency(
VALUE self) {
return Qnil; }
454 VALUE gc_constants = rb_hash_new();
457 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"RVALUE_OVERHEAD")),
INT2NUM(0));
458 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"RVARGC_MAX_ALLOCATE_SIZE")),
LONG2FIX(640));
460 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"SIZE_POOL_COUNT")),
LONG2FIX(5));
462 rb_define_const(
rb_mGC,
"INTERNAL_CONSTANTS", gc_constants);
474static size_t heap_sizes[6] = {
475 40, 80, 160, 320, 640, 0
479rb_gc_impl_heap_sizes(
void *objspace_ptr)
485rb_mmtk_obj_free_iter_wrapper(
VALUE obj,
void *data)
490 rb_gc_obj_free_vm_weak_references(obj);
501rb_gc_impl_shutdown_free_objects(
void *objspace_ptr)
503 mmtk_set_gc_enabled(
false);
504 each_object(objspace_ptr, rb_mmtk_obj_free_iter_wrapper, objspace_ptr);
505 mmtk_set_gc_enabled(
true);
510rb_gc_impl_start(
void *objspace_ptr,
bool full_mark,
bool immediate_mark,
bool immediate_sweep,
bool compact)
512 mmtk_handle_user_collection_request(rb_gc_get_ractor_newobj_cache(),
true, full_mark);
516rb_gc_impl_during_gc_p(
void *objspace_ptr)
523rb_gc_impl_prepare_heap_i(MMTk_ObjectReference obj,
void *d)
525 rb_gc_prepare_heap_process_object((
VALUE)obj);
529rb_gc_impl_prepare_heap(
void *objspace_ptr)
531 mmtk_enumerate_objects(rb_gc_impl_prepare_heap_i, NULL);
535rb_gc_impl_gc_enable(
void *objspace_ptr)
537 mmtk_set_gc_enabled(
true);
541rb_gc_impl_gc_disable(
void *objspace_ptr,
bool finish_current_gc)
543 mmtk_set_gc_enabled(
false);
547rb_gc_impl_gc_enabled_p(
void *objspace_ptr)
549 return mmtk_gc_enabled_p();
553rb_gc_impl_stress_set(
void *objspace_ptr,
VALUE flag)
561rb_gc_impl_stress_get(
void *objspace_ptr)
569rb_gc_impl_config_get(
void *objspace_ptr)
571 VALUE hash = rb_hash_new();
576 size_t heap_min = mmtk_heap_min();
584rb_gc_impl_config_set(
void *objspace_ptr,
VALUE hash)
592rb_gc_impl_new_obj(
void *objspace_ptr,
void *cache_ptr,
VALUE klass,
VALUE flags,
VALUE v1,
VALUE v2,
VALUE v3,
bool wb_protected,
size_t alloc_size)
594#define MMTK_ALLOCATION_SEMANTICS_DEFAULT 0
598 if (alloc_size > 640) rb_bug(
"too big");
599 for (
int i = 0; i < 5; i++) {
600 if (alloc_size == heap_sizes[i])
break;
601 if (alloc_size < heap_sizes[i]) {
602 alloc_size = heap_sizes[i];
608 mmtk_handle_user_collection_request(ractor_cache,
false,
false);
611 VALUE *alloc_obj = mmtk_alloc(ractor_cache->mutator, alloc_size + 8, MMTk_MIN_OBJ_ALIGN, 0, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
613 alloc_obj[-1] = alloc_size;
614 alloc_obj[0] = flags;
615 alloc_obj[1] = klass;
616 if (alloc_size > 16) alloc_obj[2] = v1;
617 if (alloc_size > 24) alloc_obj[3] = v2;
618 if (alloc_size > 32) alloc_obj[4] = v3;
620 mmtk_post_alloc(ractor_cache->mutator, (
void*)alloc_obj, alloc_size + 8, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
623 mmtk_add_obj_free_candidate(alloc_obj);
625 objspace->total_allocated_objects++;
627 return (
VALUE)alloc_obj;
631rb_gc_impl_obj_slot_size(
VALUE obj)
633 return ((
VALUE *)obj)[-1];
637rb_gc_impl_heap_id_for_size(
void *objspace_ptr,
size_t size)
639 for (
int i = 0; i < 5; i++) {
640 if (size == heap_sizes[i])
return i;
641 if (size < heap_sizes[i])
return i;
644 rb_bug(
"size too big");
648rb_gc_impl_size_allocatable_p(
size_t size)
655rb_gc_impl_malloc(
void *objspace_ptr,
size_t size)
662rb_gc_impl_calloc(
void *objspace_ptr,
size_t size)
665 return calloc(1, size);
669rb_gc_impl_realloc(
void *objspace_ptr,
void *ptr,
size_t new_size,
size_t old_size)
672 return realloc(ptr, new_size);
676rb_gc_impl_free(
void *objspace_ptr,
void *ptr,
size_t old_size)
682void rb_gc_impl_adjust_memory_usage(
void *objspace_ptr, ssize_t diff) { }
686rb_gc_impl_mark(
void *objspace_ptr,
VALUE obj)
691 rb_mmtk_gc_thread_tls->gc_context,
692 (MMTk_ObjectReference)obj,
697rb_gc_impl_mark_and_move(
void *objspace_ptr,
VALUE *ptr)
702 rb_gc_impl_mark(objspace_ptr, *ptr);
706rb_gc_impl_mark_and_pin(
void *objspace_ptr,
VALUE obj)
711 rb_gc_impl_mark(objspace_ptr, obj);
715rb_gc_impl_mark_maybe(
void *objspace_ptr,
VALUE obj)
717 if (rb_gc_impl_pointer_to_heap_p(objspace_ptr, (
const void *)obj)) {
718 rb_gc_impl_mark_and_pin(objspace_ptr, obj);
723rb_gc_impl_mark_weak(
void *objspace_ptr,
VALUE *ptr)
725 mmtk_mark_weak((MMTk_ObjectReference *)ptr);
729rb_gc_impl_remove_weak(
void *objspace_ptr,
VALUE parent_obj,
VALUE *ptr)
731 mmtk_remove_weak((MMTk_ObjectReference *)ptr);
736rb_gc_impl_object_moved_p(
void *objspace_ptr,
VALUE obj)
738 rb_bug(
"unimplemented");
742rb_gc_impl_location(
void *objspace_ptr,
VALUE value)
744 rb_bug(
"unimplemented");
749rb_gc_impl_writebarrier(
void *objspace_ptr,
VALUE a,
VALUE b)
755 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)a);
759rb_gc_impl_writebarrier_unprotect(
void *objspace_ptr,
VALUE obj)
761 mmtk_register_wb_unprotected_object((MMTk_ObjectReference)obj);
765rb_gc_impl_writebarrier_remember(
void *objspace_ptr,
VALUE obj)
769 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)obj);
774each_objects_i(MMTk_ObjectReference obj,
void *d)
776 rb_darray(
VALUE) *objs = d;
778 rb_darray_append(objs, (
VALUE)obj);
784 rb_darray(
VALUE) objs;
785 rb_darray_make(&objs, 0);
787 mmtk_enumerate_objects(each_objects_i, &objs);
790 rb_darray_foreach(objs, i, obj_ptr) {
791 if (!mmtk_is_mmtk_object((MMTk_ObjectReference)*obj_ptr))
continue;
793 if (func(*obj_ptr, data) != 0) {
798 rb_darray_free(objs);
802 int (*func)(
void *,
void *, size_t,
void *);
807rb_gc_impl_each_objects_i(
VALUE obj,
void *d)
811 size_t slot_size = rb_gc_impl_obj_slot_size(obj);
813 return data->func((
void *)obj, (
void *)(obj + slot_size), slot_size, data->data);
817rb_gc_impl_each_objects(
void *objspace_ptr,
int (*func)(
void *,
void *,
size_t,
void *),
void *data)
824 each_object(objspace_ptr, rb_gc_impl_each_objects_i, &each_objects_data);
828 void (*func)(
VALUE,
void *);
833rb_gc_impl_each_object_i(
VALUE obj,
void *d)
837 data->func(obj, data->data);
843rb_gc_impl_each_object(
void *objspace_ptr,
void (*func)(
VALUE,
void *),
void *data)
850 each_object(objspace_ptr, rb_gc_impl_each_object_i, &each_object_data);
855gc_run_finalizers_get_final(
long i,
void *data)
863gc_run_finalizers(
void *data)
867 rb_gc_set_pending_interrupt();
869 while (
objspace->finalizer_jobs != NULL) {
871 objspace->finalizer_jobs = job->next;
874 case MMTK_FINAL_JOB_DFREE:
875 job->as.dfree.func(job->as.dfree.data);
877 case MMTK_FINAL_JOB_FINALIZE: {
878 VALUE finalizer_array = job->as.finalize.finalizer_array;
880 rb_gc_run_obj_finalizer(
883 gc_run_finalizers_get_final,
884 (
void *)finalizer_array
895 rb_gc_unset_pending_interrupt();
899rb_gc_impl_make_zombie(
void *objspace_ptr,
VALUE obj,
void (*dfree)(
void *),
void *data)
901 if (dfree == NULL)
return;
906 job->kind = MMTK_FINAL_JOB_DFREE;
907 job->as.dfree.func = dfree;
908 job->as.dfree.data = data;
912 job->next =
objspace->finalizer_jobs;
914 }
while (prev != job->next);
916 if (!ruby_free_at_exit_p()) {
922rb_gc_impl_define_finalizer(
void *objspace_ptr,
VALUE obj,
VALUE block)
930 int lev = RB_GC_VM_LOCK();
932 if (st_lookup(
objspace->finalizer_table, obj, &data)) {
940 for (i = 0; i <
len; i++) {
943 RB_GC_VM_UNLOCK(lev);
954 st_add_direct(
objspace->finalizer_table, obj, table);
957 RB_GC_VM_UNLOCK(lev);
963rb_gc_impl_undefine_finalizer(
void *objspace_ptr,
VALUE obj)
967 st_data_t data = obj;
969 int lev = RB_GC_VM_LOCK();
970 st_delete(
objspace->finalizer_table, &data, 0);
971 RB_GC_VM_UNLOCK(lev);
977rb_gc_impl_copy_finalizer(
void *objspace_ptr,
VALUE dest,
VALUE obj)
985 int lev = RB_GC_VM_LOCK();
986 if (RB_LIKELY(st_lookup(
objspace->finalizer_table, obj, &data))) {
989 st_insert(
objspace->finalizer_table, dest, table);
993 rb_bug(
"rb_gc_copy_finalizer: FL_FINALIZE set but not found in finalizer_table: %s", rb_obj_info(obj));
995 RB_GC_VM_UNLOCK(lev);
999move_finalizer_from_table_i(st_data_t key, st_data_t val, st_data_t arg)
1009rb_gc_impl_shutdown_call_finalizer(
void *objspace_ptr)
1013 while (
objspace->finalizer_table->num_entries) {
1014 st_foreach(
objspace->finalizer_table, move_finalizer_from_table_i, (st_data_t)
objspace);
1020 for (
size_t i = 0; i < registered_candidates.len; i++) {
1021 VALUE obj = (
VALUE)registered_candidates.ptr[i];
1023 if (rb_gc_shutdown_call_finalizer_p(obj)) {
1024 rb_gc_obj_free(objspace_ptr, obj);
1028 mmtk_free_raw_vec_of_obj_ref(registered_candidates);
1036rb_gc_impl_before_fork(
void *objspace_ptr)
1042rb_gc_impl_after_fork(
void *objspace_ptr, rb_pid_t pid)
1044 mmtk_after_fork(rb_gc_get_ractor_newobj_cache());
1050rb_gc_impl_set_measure_total_time(
void *objspace_ptr,
VALUE flag)
1058rb_gc_impl_get_measure_total_time(
void *objspace_ptr)
1066rb_gc_impl_get_total_time(
void *objspace_ptr)
1074rb_gc_impl_gc_count(
void *objspace_ptr)
1082rb_gc_impl_latest_gc_info(
void *objspace_ptr,
VALUE hash_or_key)
1093 rb_bug(
"gc_info_decode: non-hash or symbol given");
1096#define SET(name, attr) \
1097 if (key == ID2SYM(rb_intern_const(#name))) \
1099 else if (hash != Qnil) \
1100 rb_hash_aset(hash, ID2SYM(rb_intern_const(#name)), (attr));
1118 gc_stat_sym_total_allocated_objects,
1119 gc_stat_sym_total_bytes,
1120 gc_stat_sym_used_bytes,
1121 gc_stat_sym_free_bytes,
1122 gc_stat_sym_starting_heap_address,
1123 gc_stat_sym_last_heap_address,
1127static VALUE gc_stat_symbols[gc_stat_sym_last];
1130setup_gc_stat_symbols(
void)
1132 if (gc_stat_symbols[0] == 0) {
1133#define S(s) gc_stat_symbols[gc_stat_sym_##s] = ID2SYM(rb_intern_const(#s))
1136 S(total_allocated_objects);
1140 S(starting_heap_address);
1141 S(last_heap_address);
1146rb_gc_impl_stat(
void *objspace_ptr,
VALUE hash_or_sym)
1151 setup_gc_stat_symbols();
1160 rb_bug(
"non-hash or symbol given");
1163#define SET(name, attr) \
1164 if (key == gc_stat_symbols[gc_stat_sym_##name]) \
1165 return SIZET2NUM(attr); \
1166 else if (hash != Qnil) \
1167 rb_hash_aset(hash, gc_stat_symbols[gc_stat_sym_##name], SIZET2NUM(attr));
1170 SET(time,
objspace->total_gc_time / (1000 * 1000));
1171 SET(total_allocated_objects,
objspace->total_allocated_objects);
1172 SET(total_bytes, mmtk_total_bytes());
1173 SET(used_bytes, mmtk_used_bytes());
1174 SET(free_bytes, mmtk_free_bytes());
1175 SET(starting_heap_address, (
size_t)mmtk_starting_heap_address());
1176 SET(last_heap_address, (
size_t)mmtk_last_heap_address());
1188rb_gc_impl_stat_heap(
void *objspace_ptr,
VALUE heap_name,
VALUE hash_or_sym)
1200#define RB_GC_OBJECT_METADATA_ENTRY_COUNT 1
1204rb_gc_impl_object_metadata(
void *objspace_ptr,
VALUE obj)
1206 static ID ID_object_id;
1208 if (!ID_object_id) {
1209#define I(s) ID_##s = rb_intern(#s);
1216#define SET_ENTRY(na, v) do { \
1217 RUBY_ASSERT(n <= RB_GC_OBJECT_METADATA_ENTRY_COUNT); \
1218 object_metadata_entries[n].name = ID_##na; \
1219 object_metadata_entries[n].val = v; \
1223 if (rb_obj_id_p(obj)) SET_ENTRY(object_id, rb_obj_id(obj));
1225 object_metadata_entries[n].name = 0;
1226 object_metadata_entries[n].val = 0;
1228 return object_metadata_entries;
1232rb_gc_impl_pointer_to_heap_p(
void *objspace_ptr,
const void *ptr)
1234 if (ptr == NULL)
return false;
1235 if ((uintptr_t)ptr %
sizeof(
void*) != 0)
return false;
1236 return mmtk_is_mmtk_object((MMTk_Address)ptr);
1240rb_gc_impl_garbage_object_p(
void *objspace_ptr,
VALUE obj)
1245void rb_gc_impl_set_event_hook(
void *objspace_ptr,
const rb_event_flag_t event) { }
1248rb_gc_impl_copy_attributes(
void *objspace_ptr,
VALUE dest,
VALUE obj)
1250 if (mmtk_object_wb_unprotected_p((MMTk_ObjectReference)obj)) {
1251 rb_gc_impl_writebarrier_unprotect(objspace_ptr, dest);
1254 rb_gc_impl_copy_finalizer(objspace_ptr, dest, obj);
1260rb_gc_impl_active_gc_name(
void)
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define RUBY_ATOMIC_PTR_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are void*.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
unsigned int rb_postponed_job_handle_t
The type of a handle returned from rb_postponed_job_preregister and passed to rb_postponed_job_trigge...
void rb_postponed_job_trigger(rb_postponed_job_handle_t h)
Triggers a pre-registered job registered with rb_postponed_job_preregister, scheduling it for executi...
rb_postponed_job_handle_t rb_postponed_job_preregister(unsigned int flags, rb_postponed_job_func_t func, void *data)
Pre-registers a func in Ruby's postponed job preregistration table, returning an opaque handle which ...
#define RUBY_INTERNAL_EVENT_FREEOBJ
Object swept.
#define RUBY_INTERNAL_EVENT_GC_START
GC started.
uint32_t rb_event_flag_t
Represents event(s).
static VALUE RB_FL_TEST(VALUE obj, VALUE flags)
Tests if the given flag(s) are set or not.
static void RB_FL_UNSET(VALUE obj, VALUE flags)
Clears the given flag(s).
@ RUBY_FL_FINALIZE
This flag has something to do with finalisers.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define ID2SYM
Old name of RB_ID2SYM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_NONE
Old name of RUBY_T_NONE.
#define SIZET2NUM
Old name of RB_SIZE2NUM.
#define xmalloc
Old name of ruby_xmalloc.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FL_FINALIZE
Old name of RUBY_FL_FINALIZE.
#define T_HASH
Old name of RUBY_T_HASH.
#define FL_SET
Old name of RB_FL_SET.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define Qtrue
Old name of RUBY_Qtrue.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define FL_TEST
Old name of RB_FL_TEST.
#define FL_UNSET
Old name of RB_FL_UNSET.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
Raises rb_eNotImpError.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
int len
Length of the buffer.
#define RB_ULONG2NUM
Just another name of rb_ulong2num_inline.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define RARRAY_LEN
Just another name of rb_array_len.
static void RARRAY_ASET(VALUE ary, long i, VALUE v)
Assigns an object in an array.
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
int ruby_native_thread_p(void)
Queries if the thread which calls this function is a ruby's thread.
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
#define RTEST
This is an old name of RB_TEST.
void * rust_closure
The pointer to the Rust-level closure object.
MMTk_ObjectClosureFunction c_function
The function to be called from C.
Ruby object's base components.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static enum ruby_value_type RB_BUILTIN_TYPE(VALUE obj)
Queries the type of the object.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.