10#include "gc/mmtk/mmtk.h"
12#include "ccan/list/list.h"
16#include <sys/sysctl.h>
25 size_t total_allocated_objects;
29 unsigned long long next_object_id;
35 struct ccan_list_head ractor_caches;
36 unsigned long live_ractor_cache_count;
38 pthread_mutex_t mutex;
40 pthread_cond_t cond_world_stopped;
41 pthread_cond_t cond_world_started;
42 size_t start_the_world_count;
44 struct rb_gc_vm_context vm_context;
48 struct ccan_list_node list_node;
50 MMTk_Mutator *mutator;
58 MMTK_FINAL_JOB_FINALIZE,
67 VALUE finalizer_array;
72#ifdef RB_THREAD_LOCAL_SPECIFIER
75# error We currently need language-supported TLS
83 rb_mmtk_gc_thread_tls = gc_thread_tls;
87rb_mmtk_is_mutator(
void)
93rb_mmtk_stop_the_world(
void)
98 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
99 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
106 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
107 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
112rb_mmtk_resume_mutators(
void)
117 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
118 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
123 pthread_cond_broadcast(&
objspace->cond_world_started);
125 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
126 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
135 size_t starting_gc_count =
objspace->gc_count;
136 int lock_lev = rb_gc_vm_lock();
138 if ((err = pthread_mutex_lock(&
objspace->mutex)) != 0) {
139 rb_bug(
"ERROR: cannot lock objspace->mutex: %s", strerror(err));
142 if (
objspace->gc_count == starting_gc_count) {
145 rb_gc_initialize_vm_context(&
objspace->vm_context);
147 mutator->gc_mutator_p =
true;
151 clock_gettime(CLOCK_MONOTONIC, &gc_start_time);
154 rb_gc_save_machine_context();
160 pthread_cond_broadcast(&
objspace->cond_world_stopped);
169 clock_gettime(CLOCK_MONOTONIC, &gc_end_time);
172 (gc_end_time.tv_sec - gc_start_time.tv_sec) * (1000 * 1000 * 1000) +
173 (gc_end_time.tv_nsec - gc_start_time.tv_nsec);
177 if ((err = pthread_mutex_unlock(&
objspace->mutex)) != 0) {
178 rb_bug(
"ERROR: cannot release objspace->mutex: %s", strerror(err));
180 rb_gc_vm_unlock(lock_lev);
184rb_mmtk_number_of_mutators(
void)
187 return objspace->live_ractor_cache_count;
191rb_mmtk_get_mutators(
void (*visit_mutator)(MMTk_Mutator *mutator,
void *data),
void *data)
196 ccan_list_for_each(&
objspace->ractor_caches, ractor_cache, list_node) {
197 visit_mutator(ractor_cache->mutator, data);
202rb_mmtk_scan_gc_roots(
void)
208 rb_gc_worker_thread_set_vm_context(&
objspace->vm_context);
210 rb_gc_worker_thread_unset_vm_context(&
objspace->vm_context);
214pin_value(st_data_t key, st_data_t value, st_data_t data)
216 rb_gc_impl_mark_and_pin((
void *)data, (
VALUE)value);
222rb_mmtk_scan_objspace(
void)
226 if (
objspace->finalizer_table != NULL) {
230 st_foreach(
objspace->obj_to_id_tbl, gc_mark_tbl_no_pin_i, (st_data_t)
objspace);
233 while (job != NULL) {
235 case MMTK_FINAL_JOB_DFREE:
237 case MMTK_FINAL_JOB_FINALIZE:
238 rb_gc_impl_mark(
objspace, job->as.finalize.object_id);
239 rb_gc_impl_mark(
objspace, job->as.finalize.finalizer_array);
242 rb_bug(
"rb_mmtk_scan_objspace: unknown final job type %d", job->kind);
250rb_mmtk_scan_object_ruby_style(MMTk_ObjectReference
object)
252 rb_gc_mark_children(rb_gc_get_objspace(), (
VALUE)
object);
256rb_mmtk_call_gc_mark_children(MMTk_ObjectReference
object)
258 rb_gc_mark_children(rb_gc_get_objspace(), (
VALUE)
object);
262rb_mmtk_call_obj_free(MMTk_ObjectReference
object)
268 rb_gc_worker_thread_set_vm_context(&
objspace->vm_context);
270 rb_gc_worker_thread_unset_vm_context(&
objspace->vm_context);
277rb_mmtk_vm_live_bytes(
void)
286 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)table));
292 job->next =
objspace->finalizer_jobs;
293 job->kind = MMTK_FINAL_JOB_FINALIZE;
294 job->as.finalize.object_id = rb_obj_id((
VALUE)obj);
295 job->as.finalize.finalizer_array = table;
301rb_mmtk_update_finalizer_table_i(st_data_t key, st_data_t value, st_data_t data)
304 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)value));
309 if (!mmtk_is_reachable((MMTk_ObjectReference)key)) {
321rb_mmtk_update_finalizer_table(
void)
326 st_foreach(
objspace->finalizer_table, rb_mmtk_update_finalizer_table_i, (st_data_t)
objspace);
330rb_mmtk_update_table_i(
VALUE val,
void *data)
332 if (!mmtk_is_reachable((MMTk_ObjectReference)val)) {
340rb_mmtk_update_obj_id_tables_obj_to_id_i(st_data_t key, st_data_t val, st_data_t data)
344 if (!mmtk_is_reachable((MMTk_ObjectReference)key)) {
352rb_mmtk_update_obj_id_tables_id_to_obj_i(st_data_t key, st_data_t val, st_data_t data)
356 if (!mmtk_is_reachable((MMTk_ObjectReference)val)) {
364rb_mmtk_update_obj_id_tables(
void)
368 st_foreach(
objspace->obj_to_id_tbl, rb_mmtk_update_obj_id_tables_obj_to_id_i, 0);
370 st_foreach(
objspace->id_to_obj_tbl, rb_mmtk_update_obj_id_tables_id_to_obj_i, 0);
375rb_mmtk_global_tables_count(
void)
377 return RB_GC_VM_WEAK_TABLE_COUNT;
381rb_mmtk_update_global_tables(
int table)
385 rb_gc_vm_weak_table_foreach(rb_mmtk_update_table_i, NULL, NULL,
true, (
enum rb_gc_vm_weak_tables)table);
390 rb_mmtk_init_gc_worker_thread,
392 rb_mmtk_stop_the_world,
393 rb_mmtk_resume_mutators,
394 rb_mmtk_block_for_gc,
395 rb_mmtk_number_of_mutators,
396 rb_mmtk_get_mutators,
397 rb_mmtk_scan_gc_roots,
398 rb_mmtk_scan_objspace,
399 rb_mmtk_scan_object_ruby_style,
400 rb_mmtk_call_gc_mark_children,
401 rb_mmtk_call_obj_free,
402 rb_mmtk_vm_live_bytes,
403 rb_mmtk_update_global_tables,
404 rb_mmtk_global_tables_count,
405 rb_mmtk_update_finalizer_table,
406 rb_mmtk_update_obj_id_tables,
410#define RB_MMTK_HEAP_LIMIT_PERC 80
411#define RB_MMTK_DEFAULT_HEAP_MIN (1024 * 1024)
412#define RB_MMTK_DEFAULT_HEAP_MAX (rb_mmtk_system_physical_memory() / 100 * RB_MMTK_HEAP_LIMIT_PERC)
415 RB_MMTK_DYNAMIC_HEAP,
420rb_mmtk_builder_init(
void)
422 MMTk_Builder *builder = mmtk_builder_default();
427rb_gc_impl_objspace_alloc(
void)
429 MMTk_Builder *builder = rb_mmtk_builder_init();
430 mmtk_init_binding(builder, NULL, &ruby_upcalls, (MMTk_ObjectReference)
Qundef);
432 return calloc(1,
sizeof(
struct objspace));
436static void gc_run_finalizers(
void *data);
439rb_gc_impl_objspace_init(
void *objspace_ptr)
447 objspace->finalizer_table = st_init_numtable();
450 ccan_list_head_init(&
objspace->ractor_caches);
452 objspace->mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
453 objspace->cond_world_stopped = (pthread_cond_t)PTHREAD_COND_INITIALIZER;
454 objspace->cond_world_started = (pthread_cond_t)PTHREAD_COND_INITIALIZER;
458rb_gc_impl_objspace_free(
void *objspace_ptr)
464rb_gc_impl_ractor_cache_alloc(
void *objspace_ptr,
void *ractor)
467 if (
objspace->live_ractor_cache_count == 0) {
468 mmtk_initialize_collection(ractor);
470 objspace->live_ractor_cache_count++;
473 ccan_list_add(&
objspace->ractor_caches, &cache->list_node);
475 cache->mutator = mmtk_bind_mutator(cache);
481rb_gc_impl_ractor_cache_free(
void *objspace_ptr,
void *cache_ptr)
486 ccan_list_del(&cache->list_node);
489 objspace->live_ractor_cache_count--;
491 mmtk_destroy_mutator(cache->mutator);
494void rb_gc_impl_set_params(
void *objspace_ptr) { }
496static VALUE gc_verify_internal_consistency(
VALUE self) {
return Qnil; }
501 VALUE gc_constants = rb_hash_new();
503 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"RVALUE_OVERHEAD")),
INT2NUM(0));
504 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"RVARGC_MAX_ALLOCATE_SIZE")),
LONG2FIX(640));
506 rb_hash_aset(gc_constants,
ID2SYM(rb_intern(
"SIZE_POOL_COUNT")),
LONG2FIX(5));
508 rb_define_const(
rb_mGC,
"INTERNAL_CONSTANTS", gc_constants);
520static size_t heap_sizes[6] = {
521 40, 80, 160, 320, 640, 0
525rb_gc_impl_heap_sizes(
void *objspace_ptr)
531rb_mmtk_obj_free_iter_wrapper(
VALUE obj,
void *data)
536 rb_gc_obj_free_vm_weak_references(obj);
547rb_gc_impl_shutdown_free_objects(
void *objspace_ptr)
549 mmtk_set_gc_enabled(
false);
550 each_object(objspace_ptr, rb_mmtk_obj_free_iter_wrapper, objspace_ptr);
551 mmtk_set_gc_enabled(
true);
556rb_gc_impl_start(
void *objspace_ptr,
bool full_mark,
bool immediate_mark,
bool immediate_sweep,
bool compact)
558 mmtk_handle_user_collection_request(rb_gc_get_ractor_newobj_cache(),
true, full_mark);
562rb_gc_impl_during_gc_p(
void *objspace_ptr)
569rb_gc_impl_prepare_heap_i(MMTk_ObjectReference obj,
void *d)
571 rb_gc_prepare_heap_process_object((
VALUE)obj);
575rb_gc_impl_prepare_heap(
void *objspace_ptr)
577 mmtk_enumerate_objects(rb_gc_impl_prepare_heap_i, NULL);
581rb_gc_impl_gc_enable(
void *objspace_ptr)
583 mmtk_set_gc_enabled(
true);
587rb_gc_impl_gc_disable(
void *objspace_ptr,
bool finish_current_gc)
589 mmtk_set_gc_enabled(
false);
593rb_gc_impl_gc_enabled_p(
void *objspace_ptr)
595 return mmtk_gc_enabled_p();
599rb_gc_impl_stress_set(
void *objspace_ptr,
VALUE flag)
607rb_gc_impl_stress_get(
void *objspace_ptr)
615rb_gc_impl_config_get(
void *objspace_ptr)
617 VALUE hash = rb_hash_new();
622 size_t heap_min = mmtk_heap_min();
630rb_gc_impl_config_set(
void *objspace_ptr,
VALUE hash)
638rb_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)
640#define MMTK_ALLOCATION_SEMANTICS_DEFAULT 0
644 if (alloc_size > 640) rb_bug(
"too big");
645 for (
int i = 0; i < 5; i++) {
646 if (alloc_size == heap_sizes[i])
break;
647 if (alloc_size < heap_sizes[i]) {
648 alloc_size = heap_sizes[i];
654 mmtk_handle_user_collection_request(ractor_cache,
false,
false);
657 VALUE *alloc_obj = mmtk_alloc(ractor_cache->mutator, alloc_size + 8, MMTk_MIN_OBJ_ALIGN, 0, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
659 alloc_obj[-1] = alloc_size;
660 alloc_obj[0] = flags;
661 alloc_obj[1] = klass;
662 if (alloc_size > 16) alloc_obj[2] = v1;
663 if (alloc_size > 24) alloc_obj[3] = v2;
664 if (alloc_size > 32) alloc_obj[4] = v3;
666 mmtk_post_alloc(ractor_cache->mutator, (
void*)alloc_obj, alloc_size + 8, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
669 mmtk_add_obj_free_candidate(alloc_obj);
671 objspace->total_allocated_objects++;
673 return (
VALUE)alloc_obj;
677rb_gc_impl_obj_slot_size(
VALUE obj)
679 return ((
VALUE *)obj)[-1];
683rb_gc_impl_heap_id_for_size(
void *objspace_ptr,
size_t size)
685 for (
int i = 0; i < 5; i++) {
686 if (size == heap_sizes[i])
return i;
687 if (size < heap_sizes[i])
return i;
690 rb_bug(
"size too big");
694rb_gc_impl_size_allocatable_p(
size_t size)
701rb_gc_impl_malloc(
void *objspace_ptr,
size_t size)
708rb_gc_impl_calloc(
void *objspace_ptr,
size_t size)
711 return calloc(1, size);
715rb_gc_impl_realloc(
void *objspace_ptr,
void *ptr,
size_t new_size,
size_t old_size)
718 return realloc(ptr, new_size);
722rb_gc_impl_free(
void *objspace_ptr,
void *ptr,
size_t old_size)
728void rb_gc_impl_adjust_memory_usage(
void *objspace_ptr, ssize_t diff) { }
732rb_gc_impl_mark(
void *objspace_ptr,
VALUE obj)
737 rb_mmtk_gc_thread_tls->gc_context,
738 (MMTk_ObjectReference)obj,
743rb_gc_impl_mark_and_move(
void *objspace_ptr,
VALUE *ptr)
748 rb_gc_impl_mark(objspace_ptr, *ptr);
752rb_gc_impl_mark_and_pin(
void *objspace_ptr,
VALUE obj)
757 rb_gc_impl_mark(objspace_ptr, obj);
761rb_gc_impl_mark_maybe(
void *objspace_ptr,
VALUE obj)
763 if (rb_gc_impl_pointer_to_heap_p(objspace_ptr, (
const void *)obj)) {
764 rb_gc_impl_mark_and_pin(objspace_ptr, obj);
769rb_gc_impl_mark_weak(
void *objspace_ptr,
VALUE *ptr)
771 mmtk_mark_weak((MMTk_ObjectReference *)ptr);
775rb_gc_impl_remove_weak(
void *objspace_ptr,
VALUE parent_obj,
VALUE *ptr)
777 mmtk_remove_weak((MMTk_ObjectReference *)ptr);
782rb_gc_impl_object_moved_p(
void *objspace_ptr,
VALUE obj)
784 rb_bug(
"unimplemented");
788rb_gc_impl_location(
void *objspace_ptr,
VALUE value)
790 rb_bug(
"unimplemented");
795rb_gc_impl_writebarrier(
void *objspace_ptr,
VALUE a,
VALUE b)
799 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)a);
803rb_gc_impl_writebarrier_unprotect(
void *objspace_ptr,
VALUE obj)
805 mmtk_register_wb_unprotected_object((MMTk_ObjectReference)obj);
809rb_gc_impl_writebarrier_remember(
void *objspace_ptr,
VALUE obj)
813 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)obj);
818each_objects_i(MMTk_ObjectReference obj,
void *d)
820 rb_darray(
VALUE) *objs = d;
822 rb_darray_append(objs, (
VALUE)obj);
828 rb_darray(
VALUE) objs;
829 rb_darray_make(&objs, 0);
831 mmtk_enumerate_objects(each_objects_i, &objs);
834 rb_darray_foreach(objs, i, obj_ptr) {
835 if (!mmtk_is_mmtk_object((MMTk_ObjectReference)*obj_ptr))
continue;
837 if (func(*obj_ptr, data) != 0) {
842 rb_darray_free(objs);
846 int (*func)(
void *,
void *, size_t,
void *);
851rb_gc_impl_each_objects_i(
VALUE obj,
void *d)
855 size_t slot_size = rb_gc_impl_obj_slot_size(obj);
857 return data->func((
void *)obj, (
void *)(obj + slot_size), slot_size, data->data);
861rb_gc_impl_each_objects(
void *objspace_ptr,
int (*func)(
void *,
void *,
size_t,
void *),
void *data)
868 each_object(objspace_ptr, rb_gc_impl_each_objects_i, &each_objects_data);
872 void (*func)(
VALUE,
void *);
877rb_gc_impl_each_object_i(
VALUE obj,
void *d)
881 data->func(obj, data->data);
887rb_gc_impl_each_object(
void *objspace_ptr,
void (*func)(
VALUE,
void *),
void *data)
894 each_object(objspace_ptr, rb_gc_impl_each_object_i, &each_object_data);
899gc_run_finalizers_get_final(
long i,
void *data)
907gc_run_finalizers(
void *data)
911 rb_gc_set_pending_interrupt();
913 while (
objspace->finalizer_jobs != NULL) {
915 objspace->finalizer_jobs = job->next;
918 case MMTK_FINAL_JOB_DFREE:
919 job->as.dfree.func(job->as.dfree.data);
921 case MMTK_FINAL_JOB_FINALIZE: {
922 VALUE object_id = job->as.finalize.object_id;
923 VALUE finalizer_array = job->as.finalize.finalizer_array;
925 rb_gc_run_obj_finalizer(
926 job->as.finalize.object_id,
928 gc_run_finalizers_get_final,
929 (
void *)finalizer_array
941 rb_gc_unset_pending_interrupt();
945rb_gc_impl_make_zombie(
void *objspace_ptr,
VALUE obj,
void (*dfree)(
void *),
void *data)
947 if (dfree == NULL)
return;
952 job->kind = MMTK_FINAL_JOB_DFREE;
953 job->as.dfree.func = dfree;
954 job->as.dfree.data = data;
958 job->next =
objspace->finalizer_jobs;
960 }
while (prev != job->next);
962 if (!ruby_free_at_exit_p()) {
968rb_gc_impl_define_finalizer(
void *objspace_ptr,
VALUE obj,
VALUE block)
976 int lev = rb_gc_vm_lock();
978 if (st_lookup(
objspace->finalizer_table, obj, &data)) {
986 for (i = 0; i <
len; i++) {
989 rb_gc_vm_unlock(lev);
995 rb_ary_push(table, block);
1000 st_add_direct(
objspace->finalizer_table, obj, table);
1003 rb_gc_vm_unlock(lev);
1009rb_gc_impl_undefine_finalizer(
void *objspace_ptr,
VALUE obj)
1013 st_data_t data = obj;
1014 st_delete(
objspace->finalizer_table, &data, 0);
1019rb_gc_impl_copy_finalizer(
void *objspace_ptr,
VALUE dest,
VALUE obj)
1027 if (RB_LIKELY(st_lookup(
objspace->finalizer_table, obj, &data))) {
1028 table = (
VALUE)data;
1029 st_insert(
objspace->finalizer_table, dest, table);
1033 rb_bug(
"rb_gc_copy_finalizer: FL_FINALIZE set but not found in finalizer_table: %s", rb_obj_info(obj));
1038move_finalizer_from_table_i(st_data_t key, st_data_t val, st_data_t arg)
1048rb_gc_impl_shutdown_call_finalizer(
void *objspace_ptr)
1052 while (
objspace->finalizer_table->num_entries) {
1053 st_foreach(
objspace->finalizer_table, move_finalizer_from_table_i, (st_data_t)
objspace);
1059 for (
size_t i = 0; i < registered_candidates.len; i++) {
1060 VALUE obj = (
VALUE)registered_candidates.ptr[i];
1062 if (rb_gc_shutdown_call_finalizer_p(obj)) {
1063 rb_gc_obj_free(objspace_ptr, obj);
1067 mmtk_free_raw_vec_of_obj_ref(registered_candidates);
1074object_id_cmp(st_data_t x, st_data_t y)
1077 return !rb_big_eql(x, y);
1085object_id_hash(st_data_t n)
1090#define OBJ_ID_INCREMENT (RUBY_IMMEDIATE_MASK + 1)
1091#define OBJ_ID_INITIAL (OBJ_ID_INCREMENT)
1093static const struct st_hash_type object_id_hash_type = {
1102 objspace->obj_to_id_tbl = st_init_numtable();
1103 objspace->next_object_id = OBJ_ID_INITIAL;
1107rb_gc_impl_object_id(
void *objspace_ptr,
VALUE obj)
1112 unsigned int lev = rb_gc_vm_lock();
1115 if (st_lookup(
objspace->obj_to_id_tbl, (st_data_t)obj, &val)) {
1119 rb_bug(
"rb_gc_impl_object_id: FL_SEEN_OBJ_ID flag set but not found in table");
1126 objspace->next_object_id += OBJ_ID_INCREMENT;
1128 st_insert(
objspace->obj_to_id_tbl, (st_data_t)obj, (st_data_t)
id);
1129 if (RB_UNLIKELY(
objspace->id_to_obj_tbl)) {
1130 st_insert(
objspace->id_to_obj_tbl, (st_data_t)
id, (st_data_t)obj);
1134 rb_gc_vm_unlock(lev);
1140build_id_to_obj_i(st_data_t key, st_data_t value, st_data_t data)
1143 st_insert(id_to_obj_tbl, value, key);
1148rb_gc_impl_object_id_to_ref(
void *objspace_ptr,
VALUE object_id)
1153 unsigned int lev = rb_gc_vm_lock();
1156 objspace->id_to_obj_tbl = st_init_table_with_size(&object_id_hash_type, st_table_size(
objspace->obj_to_id_tbl));
1157 st_foreach(
objspace->obj_to_id_tbl, build_id_to_obj_i, (st_data_t)
objspace->id_to_obj_tbl);
1161 bool found = st_lookup(
objspace->id_to_obj_tbl, object_id, &obj) && !rb_gc_impl_garbage_object_p(
objspace, obj);
1163 rb_gc_vm_unlock(lev);
1180rb_gc_impl_before_fork(
void *objspace_ptr)
1186rb_gc_impl_after_fork(
void *objspace_ptr, rb_pid_t pid)
1188 mmtk_after_fork(rb_gc_get_ractor_newobj_cache());
1194rb_gc_impl_set_measure_total_time(
void *objspace_ptr,
VALUE flag)
1202rb_gc_impl_get_measure_total_time(
void *objspace_ptr)
1210rb_gc_impl_get_total_time(
void *objspace_ptr)
1218rb_gc_impl_gc_count(
void *objspace_ptr)
1226rb_gc_impl_latest_gc_info(
void *objspace_ptr,
VALUE hash_or_key)
1237 rb_bug(
"gc_info_decode: non-hash or symbol given");
1240#define SET(name, attr) \
1241 if (key == ID2SYM(rb_intern_const(#name))) \
1243 else if (hash != Qnil) \
1244 rb_hash_aset(hash, ID2SYM(rb_intern_const(#name)), (attr));
1262 gc_stat_sym_total_allocated_objects,
1263 gc_stat_sym_total_bytes,
1264 gc_stat_sym_used_bytes,
1265 gc_stat_sym_free_bytes,
1266 gc_stat_sym_starting_heap_address,
1267 gc_stat_sym_last_heap_address,
1271static VALUE gc_stat_symbols[gc_stat_sym_last];
1274setup_gc_stat_symbols(
void)
1276 if (gc_stat_symbols[0] == 0) {
1277#define S(s) gc_stat_symbols[gc_stat_sym_##s] = ID2SYM(rb_intern_const(#s))
1280 S(total_allocated_objects);
1284 S(starting_heap_address);
1285 S(last_heap_address);
1290rb_gc_impl_stat(
void *objspace_ptr,
VALUE hash_or_sym)
1295 setup_gc_stat_symbols();
1304 rb_bug(
"non-hash or symbol given");
1307#define SET(name, attr) \
1308 if (key == gc_stat_symbols[gc_stat_sym_##name]) \
1309 return SIZET2NUM(attr); \
1310 else if (hash != Qnil) \
1311 rb_hash_aset(hash, gc_stat_symbols[gc_stat_sym_##name], SIZET2NUM(attr));
1314 SET(time,
objspace->total_gc_time / (1000 * 1000));
1315 SET(total_allocated_objects,
objspace->total_allocated_objects);
1316 SET(total_bytes, mmtk_total_bytes());
1317 SET(used_bytes, mmtk_used_bytes());
1318 SET(free_bytes, mmtk_free_bytes());
1319 SET(starting_heap_address, (
size_t)mmtk_starting_heap_address());
1320 SET(last_heap_address, (
size_t)mmtk_last_heap_address());
1332rb_gc_impl_stat_heap(
void *objspace_ptr,
VALUE heap_name,
VALUE hash_or_sym)
1344#define RB_GC_OBJECT_METADATA_ENTRY_COUNT 1
1348rb_gc_impl_object_metadata(
void *objspace_ptr,
VALUE obj)
1350 static ID ID_object_id;
1352 if (!ID_object_id) {
1353#define I(s) ID_##s = rb_intern(#s);
1360#define SET_ENTRY(na, v) do { \
1361 RUBY_ASSERT(n <= RB_GC_OBJECT_METADATA_ENTRY_COUNT); \
1362 object_metadata_entries[n].name = ID_##na; \
1363 object_metadata_entries[n].val = v; \
1369 object_metadata_entries[n].name = 0;
1370 object_metadata_entries[n].val = 0;
1372 return object_metadata_entries;
1376rb_gc_impl_pointer_to_heap_p(
void *objspace_ptr,
const void *ptr)
1378 if (ptr == NULL)
return false;
1379 if ((uintptr_t)ptr %
sizeof(
void*) != 0)
return false;
1380 return mmtk_is_mmtk_object((MMTk_Address)ptr);
1384rb_gc_impl_garbage_object_p(
void *objspace_ptr,
VALUE obj)
1389void rb_gc_impl_set_event_hook(
void *objspace_ptr,
const rb_event_flag_t event) { }
1392rb_gc_impl_copy_attributes(
void *objspace_ptr,
VALUE dest,
VALUE obj)
1394 if (mmtk_object_wb_unprotected_p((MMTk_ObjectReference)obj)) {
1395 rb_gc_impl_writebarrier_unprotect(objspace_ptr, dest);
1398 rb_gc_impl_copy_finalizer(objspace_ptr, dest, obj);
1404rb_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 INT2FIX
Old name of RB_INT2FIX.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define FL_SEEN_OBJ_ID
Old name of RUBY_FL_SEEN_OBJ_ID.
#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 ULL2NUM
Old name of RB_ULL2NUM.
#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 FIX2LONG
Old name of RB_FIX2LONG.
#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_eRangeError
RangeError exception.
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_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
#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.
#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.
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.