Ruby 3.5.0dev (2025-07-04 revision 4d6fac3e9515a71edd6d77e59c3a04dcbe0c444f)
mmtk.c
1#include <pthread.h>
2#include <stdbool.h>
3
4#include "ruby/assert.h"
5#include "ruby/atomic.h"
6#include "ruby/debug.h"
7
8#include "gc/gc.h"
9#include "gc/gc_impl.h"
10#include "gc/mmtk/mmtk.h"
11
12#include "ccan/list/list.h"
13#include "darray.h"
14
15#ifdef __APPLE__
16#include <sys/sysctl.h>
17#endif
18
19struct objspace {
20 bool measure_gc_time;
21 bool gc_stress;
22
23 size_t gc_count;
24 size_t total_gc_time;
25 size_t total_allocated_objects;
26
27 st_table *finalizer_table;
28 struct MMTk_final_job *finalizer_jobs;
29 rb_postponed_job_handle_t finalizer_postponed_job;
30
31 struct ccan_list_head ractor_caches;
32 unsigned long live_ractor_cache_count;
33
34 pthread_mutex_t mutex;
35 bool world_stopped;
36 pthread_cond_t cond_world_stopped;
37 pthread_cond_t cond_world_started;
38 size_t start_the_world_count;
39
40 struct rb_gc_vm_context vm_context;
41};
42
44 struct ccan_list_node list_node;
45
46 MMTk_Mutator *mutator;
47 bool gc_mutator_p;
48};
49
51 struct MMTk_final_job *next;
52 enum {
53 MMTK_FINAL_JOB_DFREE,
54 MMTK_FINAL_JOB_FINALIZE,
55 } kind;
56 union {
57 struct {
58 void (*func)(void *);
59 void *data;
60 } dfree;
61 struct {
62 /* HACK: we store the object ID on the 0th element of this array. */
63 VALUE finalizer_array;
64 } finalize;
65 } as;
66};
67
68#ifdef RB_THREAD_LOCAL_SPECIFIER
69RB_THREAD_LOCAL_SPECIFIER struct MMTk_GCThreadTLS *rb_mmtk_gc_thread_tls;
70#else
71# error We currently need language-supported TLS
72#endif
73
74#include <pthread.h>
75
76static void
77rb_mmtk_init_gc_worker_thread(MMTk_VMWorkerThread gc_thread_tls)
78{
79 rb_mmtk_gc_thread_tls = gc_thread_tls;
80}
81
82static bool
83rb_mmtk_is_mutator(void)
84{
85 return ruby_native_thread_p();
86}
87
88static void
89rb_mmtk_stop_the_world(void)
90{
91 struct objspace *objspace = rb_gc_get_objspace();
92
93 int err;
94 if ((err = pthread_mutex_lock(&objspace->mutex)) != 0) {
95 rb_bug("ERROR: cannot lock objspace->mutex: %s", strerror(err));
96 }
97
98 while (!objspace->world_stopped) {
99 pthread_cond_wait(&objspace->cond_world_stopped, &objspace->mutex);
100 }
101
102 if ((err = pthread_mutex_unlock(&objspace->mutex)) != 0) {
103 rb_bug("ERROR: cannot release objspace->mutex: %s", strerror(err));
104 }
105}
106
107static void
108rb_mmtk_resume_mutators(void)
109{
110 struct objspace *objspace = rb_gc_get_objspace();
111
112 int err;
113 if ((err = pthread_mutex_lock(&objspace->mutex)) != 0) {
114 rb_bug("ERROR: cannot lock objspace->mutex: %s", strerror(err));
115 }
116
117 objspace->world_stopped = false;
118 objspace->gc_count++;
119 pthread_cond_broadcast(&objspace->cond_world_started);
120
121 if ((err = pthread_mutex_unlock(&objspace->mutex)) != 0) {
122 rb_bug("ERROR: cannot release objspace->mutex: %s", strerror(err));
123 }
124}
125
126static void
127rb_mmtk_block_for_gc(MMTk_VMMutatorThread mutator)
128{
129 struct objspace *objspace = rb_gc_get_objspace();
130
131 size_t starting_gc_count = objspace->gc_count;
132 int lock_lev = RB_GC_VM_LOCK();
133 int err;
134 if ((err = pthread_mutex_lock(&objspace->mutex)) != 0) {
135 rb_bug("ERROR: cannot lock objspace->mutex: %s", strerror(err));
136 }
137
138 if (objspace->gc_count == starting_gc_count) {
139 rb_gc_event_hook(0, RUBY_INTERNAL_EVENT_GC_START);
140
141 rb_gc_initialize_vm_context(&objspace->vm_context);
142
143 mutator->gc_mutator_p = true;
144
145 struct timespec gc_start_time;
146 if (objspace->measure_gc_time) {
147 clock_gettime(CLOCK_MONOTONIC, &gc_start_time);
148 }
149
150 rb_gc_save_machine_context();
151
152 rb_gc_vm_barrier();
153
154 objspace->world_stopped = true;
155
156 pthread_cond_broadcast(&objspace->cond_world_stopped);
157
158 // Wait for GC end
159 while (objspace->world_stopped) {
160 pthread_cond_wait(&objspace->cond_world_started, &objspace->mutex);
161 }
162
163 if (objspace->measure_gc_time) {
164 struct timespec gc_end_time;
165 clock_gettime(CLOCK_MONOTONIC, &gc_end_time);
166
167 objspace->total_gc_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);
170 }
171 }
172
173 if ((err = pthread_mutex_unlock(&objspace->mutex)) != 0) {
174 rb_bug("ERROR: cannot release objspace->mutex: %s", strerror(err));
175 }
176 RB_GC_VM_UNLOCK(lock_lev);
177}
178
179static size_t
180rb_mmtk_number_of_mutators(void)
181{
182 struct objspace *objspace = rb_gc_get_objspace();
183 return objspace->live_ractor_cache_count;
184}
185
186static void
187rb_mmtk_get_mutators(void (*visit_mutator)(MMTk_Mutator *mutator, void *data), void *data)
188{
189 struct objspace *objspace = rb_gc_get_objspace();
190 struct MMTk_ractor_cache *ractor_cache;
191
192 ccan_list_for_each(&objspace->ractor_caches, ractor_cache, list_node) {
193 visit_mutator(ractor_cache->mutator, data);
194 }
195}
196
197static void
198rb_mmtk_scan_gc_roots(void)
199{
200 struct objspace *objspace = rb_gc_get_objspace();
201
202 // FIXME: Make `rb_gc_mark_roots` aware that the current thread may not have EC.
203 // See: https://github.com/ruby/mmtk/issues/22
204 rb_gc_worker_thread_set_vm_context(&objspace->vm_context);
205 rb_gc_mark_roots(objspace, NULL);
206 rb_gc_worker_thread_unset_vm_context(&objspace->vm_context);
207}
208
209static int
210pin_value(st_data_t key, st_data_t value, st_data_t data)
211{
212 rb_gc_impl_mark_and_pin((void *)data, (VALUE)value);
213
214 return ST_CONTINUE;
215}
216
217static void
218rb_mmtk_scan_objspace(void)
219{
220 struct objspace *objspace = rb_gc_get_objspace();
221
222 if (objspace->finalizer_table != NULL) {
223 st_foreach(objspace->finalizer_table, pin_value, (st_data_t)objspace);
224 }
225
226 struct MMTk_final_job *job = objspace->finalizer_jobs;
227 while (job != NULL) {
228 switch (job->kind) {
229 case MMTK_FINAL_JOB_DFREE:
230 break;
231 case MMTK_FINAL_JOB_FINALIZE:
232 rb_gc_impl_mark(objspace, job->as.finalize.finalizer_array);
233 break;
234 default:
235 rb_bug("rb_mmtk_scan_objspace: unknown final job type %d", job->kind);
236 }
237
238 job = job->next;
239 }
240}
241
242static void
243rb_mmtk_scan_object_ruby_style(MMTk_ObjectReference object)
244{
245 rb_gc_mark_children(rb_gc_get_objspace(), (VALUE)object);
246}
247
248static void
249rb_mmtk_call_gc_mark_children(MMTk_ObjectReference object)
250{
251 rb_gc_mark_children(rb_gc_get_objspace(), (VALUE)object);
252}
253
254static void
255rb_mmtk_call_obj_free(MMTk_ObjectReference object)
256{
257 VALUE obj = (VALUE)object;
258 struct objspace *objspace = rb_gc_get_objspace();
259
260 if (RB_UNLIKELY(rb_gc_event_hook_required_p(RUBY_INTERNAL_EVENT_FREEOBJ))) {
261 rb_gc_worker_thread_set_vm_context(&objspace->vm_context);
262 rb_gc_event_hook(obj, RUBY_INTERNAL_EVENT_FREEOBJ);
263 rb_gc_worker_thread_unset_vm_context(&objspace->vm_context);
264 }
265
266 rb_gc_obj_free(objspace, obj);
267}
268
269static size_t
270rb_mmtk_vm_live_bytes(void)
271{
272 return 0;
273}
274
275static void
276make_final_job(struct objspace *objspace, VALUE obj, VALUE table)
277{
279 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)table));
281
283
284 struct MMTk_final_job *job = xmalloc(sizeof(struct MMTk_final_job));
285 job->next = objspace->finalizer_jobs;
286 job->kind = MMTK_FINAL_JOB_FINALIZE;
287 job->as.finalize.finalizer_array = table;
288
289 objspace->finalizer_jobs = job;
290}
291
292static int
293rb_mmtk_update_finalizer_table_i(st_data_t key, st_data_t value, st_data_t data)
294{
296 RUBY_ASSERT(mmtk_is_reachable((MMTk_ObjectReference)value));
298
299 struct objspace *objspace = (struct objspace *)data;
300
301 if (!mmtk_is_reachable((MMTk_ObjectReference)key)) {
302 make_final_job(objspace, (VALUE)key, (VALUE)value);
303
304 rb_postponed_job_trigger(objspace->finalizer_postponed_job);
305
306 return ST_DELETE;
307 }
308
309 return ST_CONTINUE;
310}
311
312static void
313rb_mmtk_update_finalizer_table(void)
314{
315 struct objspace *objspace = rb_gc_get_objspace();
316
317 // TODO: replace with st_foreach_with_replace when GC is moving
318 st_foreach(objspace->finalizer_table, rb_mmtk_update_finalizer_table_i, (st_data_t)objspace);
319}
320
321static int
322rb_mmtk_update_table_i(VALUE val, void *data)
323{
324 if (!mmtk_is_reachable((MMTk_ObjectReference)val)) {
325 return ST_DELETE;
326 }
327
328 return ST_CONTINUE;
329}
330
331static int
332rb_mmtk_global_tables_count(void)
333{
334 return RB_GC_VM_WEAK_TABLE_COUNT;
335}
336
337static void
338rb_mmtk_update_global_tables(int table)
339{
340 RUBY_ASSERT(table < RB_GC_VM_WEAK_TABLE_COUNT);
341
342 rb_gc_vm_weak_table_foreach(rb_mmtk_update_table_i, NULL, NULL, true, (enum rb_gc_vm_weak_tables)table);
343}
344
345// Bootup
346MMTk_RubyUpcalls ruby_upcalls = {
347 rb_mmtk_init_gc_worker_thread,
348 rb_mmtk_is_mutator,
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,
363};
364
365// Use max 80% of the available memory by default for MMTk
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)
369
370enum mmtk_heap_mode {
371 RB_MMTK_DYNAMIC_HEAP,
372 RB_MMTK_FIXED_HEAP
373};
374
375MMTk_Builder *
376rb_mmtk_builder_init(void)
377{
378 MMTk_Builder *builder = mmtk_builder_default();
379 return builder;
380}
381
382void *
383rb_gc_impl_objspace_alloc(void)
384{
385 MMTk_Builder *builder = rb_mmtk_builder_init();
386 mmtk_init_binding(builder, NULL, &ruby_upcalls, (MMTk_ObjectReference)Qundef);
387
388 return calloc(1, sizeof(struct objspace));
389}
390
391static void gc_run_finalizers(void *data);
392
393void
394rb_gc_impl_objspace_init(void *objspace_ptr)
395{
396 struct objspace *objspace = objspace_ptr;
397
398 objspace->measure_gc_time = true;
399
400 objspace->finalizer_table = st_init_numtable();
401 objspace->finalizer_postponed_job = rb_postponed_job_preregister(0, gc_run_finalizers, objspace);
402
403 ccan_list_head_init(&objspace->ractor_caches);
404
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;
408}
409
410void
411rb_gc_impl_objspace_free(void *objspace_ptr)
412{
413 free(objspace_ptr);
414}
415
416void *
417rb_gc_impl_ractor_cache_alloc(void *objspace_ptr, void *ractor)
418{
419 struct objspace *objspace = objspace_ptr;
420 if (objspace->live_ractor_cache_count == 0) {
421 mmtk_initialize_collection(ractor);
422 }
423 objspace->live_ractor_cache_count++;
424
425 struct MMTk_ractor_cache *cache = malloc(sizeof(struct MMTk_ractor_cache));
426 ccan_list_add(&objspace->ractor_caches, &cache->list_node);
427
428 cache->mutator = mmtk_bind_mutator(cache);
429
430 return cache;
431}
432
433void
434rb_gc_impl_ractor_cache_free(void *objspace_ptr, void *cache_ptr)
435{
436 struct objspace *objspace = objspace_ptr;
437 struct MMTk_ractor_cache *cache = cache_ptr;
438
439 ccan_list_del(&cache->list_node);
440
441 RUBY_ASSERT(objspace->live_ractor_cache_count > 1);
442 objspace->live_ractor_cache_count--;
443
444 mmtk_destroy_mutator(cache->mutator);
445}
446
447void rb_gc_impl_set_params(void *objspace_ptr) { }
448
449static VALUE gc_verify_internal_consistency(VALUE self) { return Qnil; }
450
451void
452rb_gc_impl_init(void)
453{
454 VALUE gc_constants = rb_hash_new();
455 rb_hash_aset(gc_constants, ID2SYM(rb_intern("BASE_SLOT_SIZE")), SIZET2NUM(sizeof(VALUE) * 5));
456 rb_hash_aset(gc_constants, ID2SYM(rb_intern("RBASIC_SIZE")), SIZET2NUM(sizeof(struct RBasic)));
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));
459 // Pretend we have 5 size pools
460 rb_hash_aset(gc_constants, ID2SYM(rb_intern("SIZE_POOL_COUNT")), LONG2FIX(5));
461 OBJ_FREEZE(gc_constants);
462 rb_define_const(rb_mGC, "INTERNAL_CONSTANTS", gc_constants);
463
464 // no-ops for compatibility
465 rb_define_singleton_method(rb_mGC, "verify_internal_consistency", gc_verify_internal_consistency, 0);
466
470 rb_define_singleton_method(rb_mGC, "latest_compact_info", rb_f_notimplement, 0);
471 rb_define_singleton_method(rb_mGC, "verify_compaction_references", rb_f_notimplement, -1);
472}
473
474static size_t heap_sizes[6] = {
475 40, 80, 160, 320, 640, 0
476};
477
478size_t *
479rb_gc_impl_heap_sizes(void *objspace_ptr)
480{
481 return heap_sizes;
482}
483
484int
485rb_mmtk_obj_free_iter_wrapper(VALUE obj, void *data)
486{
487 struct objspace *objspace = data;
488
489 if (!RB_TYPE_P(obj, T_NONE)) {
490 rb_gc_obj_free_vm_weak_references(obj);
491 rb_gc_obj_free(objspace, obj);
492 }
493
494 return 0;
495}
496
497// Shutdown
498static void each_object(struct objspace *objspace, int (*func)(VALUE, void *), void *data);
499
500void
501rb_gc_impl_shutdown_free_objects(void *objspace_ptr)
502{
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);
506}
507
508// GC
509void
510rb_gc_impl_start(void *objspace_ptr, bool full_mark, bool immediate_mark, bool immediate_sweep, bool compact)
511{
512 mmtk_handle_user_collection_request(rb_gc_get_ractor_newobj_cache(), true, full_mark);
513}
514
515bool
516rb_gc_impl_during_gc_p(void *objspace_ptr)
517{
518 // TODO
519 return false;
520}
521
522static void
523rb_gc_impl_prepare_heap_i(MMTk_ObjectReference obj, void *d)
524{
525 rb_gc_prepare_heap_process_object((VALUE)obj);
526}
527
528void
529rb_gc_impl_prepare_heap(void *objspace_ptr)
530{
531 mmtk_enumerate_objects(rb_gc_impl_prepare_heap_i, NULL);
532}
533
534void
535rb_gc_impl_gc_enable(void *objspace_ptr)
536{
537 mmtk_set_gc_enabled(true);
538}
539
540void
541rb_gc_impl_gc_disable(void *objspace_ptr, bool finish_current_gc)
542{
543 mmtk_set_gc_enabled(false);
544}
545
546bool
547rb_gc_impl_gc_enabled_p(void *objspace_ptr)
548{
549 return mmtk_gc_enabled_p();
550}
551
552void
553rb_gc_impl_stress_set(void *objspace_ptr, VALUE flag)
554{
555 struct objspace *objspace = objspace_ptr;
556
557 objspace->gc_stress = RTEST(flag);
558}
559
560VALUE
561rb_gc_impl_stress_get(void *objspace_ptr)
562{
563 struct objspace *objspace = objspace_ptr;
564
565 return objspace->gc_stress ? Qtrue : Qfalse;
566}
567
568VALUE
569rb_gc_impl_config_get(void *objspace_ptr)
570{
571 VALUE hash = rb_hash_new();
572
573 rb_hash_aset(hash, ID2SYM(rb_intern_const("mmtk_worker_count")), RB_ULONG2NUM(mmtk_worker_count()));
574 rb_hash_aset(hash, ID2SYM(rb_intern_const("mmtk_plan")), rb_str_new_cstr((const char *)mmtk_plan()));
575 rb_hash_aset(hash, ID2SYM(rb_intern_const("mmtk_heap_mode")), rb_str_new_cstr((const char *)mmtk_heap_mode()));
576 size_t heap_min = mmtk_heap_min();
577 if (heap_min > 0) rb_hash_aset(hash, ID2SYM(rb_intern_const("mmtk_heap_min")), RB_ULONG2NUM(heap_min));
578 rb_hash_aset(hash, ID2SYM(rb_intern_const("mmtk_heap_max")), RB_ULONG2NUM(mmtk_heap_max()));
579
580 return hash;
581}
582
583void
584rb_gc_impl_config_set(void *objspace_ptr, VALUE hash)
585{
586 // TODO
587}
588
589// Object allocation
590
591VALUE
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)
593{
594#define MMTK_ALLOCATION_SEMANTICS_DEFAULT 0
595 struct objspace *objspace = objspace_ptr;
596 struct MMTk_ractor_cache *ractor_cache = cache_ptr;
597
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];
603 break;
604 }
605 }
606
607 if (objspace->gc_stress) {
608 mmtk_handle_user_collection_request(ractor_cache, false, false);
609 }
610
611 VALUE *alloc_obj = mmtk_alloc(ractor_cache->mutator, alloc_size + 8, MMTk_MIN_OBJ_ALIGN, 0, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
612 alloc_obj++;
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;
619
620 mmtk_post_alloc(ractor_cache->mutator, (void*)alloc_obj, alloc_size + 8, MMTK_ALLOCATION_SEMANTICS_DEFAULT);
621
622 // TODO: only add when object needs obj_free to be called
623 mmtk_add_obj_free_candidate(alloc_obj);
624
625 objspace->total_allocated_objects++;
626
627 return (VALUE)alloc_obj;
628}
629
630size_t
631rb_gc_impl_obj_slot_size(VALUE obj)
632{
633 return ((VALUE *)obj)[-1];
634}
635
636size_t
637rb_gc_impl_heap_id_for_size(void *objspace_ptr, size_t size)
638{
639 for (int i = 0; i < 5; i++) {
640 if (size == heap_sizes[i]) return i;
641 if (size < heap_sizes[i]) return i;
642 }
643
644 rb_bug("size too big");
645}
646
647bool
648rb_gc_impl_size_allocatable_p(size_t size)
649{
650 return size <= 640;
651}
652
653// Malloc
654void *
655rb_gc_impl_malloc(void *objspace_ptr, size_t size)
656{
657 // TODO: don't use system malloc
658 return malloc(size);
659}
660
661void *
662rb_gc_impl_calloc(void *objspace_ptr, size_t size)
663{
664 // TODO: don't use system calloc
665 return calloc(1, size);
666}
667
668void *
669rb_gc_impl_realloc(void *objspace_ptr, void *ptr, size_t new_size, size_t old_size)
670{
671 // TODO: don't use system realloc
672 return realloc(ptr, new_size);
673}
674
675void
676rb_gc_impl_free(void *objspace_ptr, void *ptr, size_t old_size)
677{
678 // TODO: don't use system free
679 free(ptr);
680}
681
682void rb_gc_impl_adjust_memory_usage(void *objspace_ptr, ssize_t diff) { }
683
684// Marking
685void
686rb_gc_impl_mark(void *objspace_ptr, VALUE obj)
687{
688 if (RB_SPECIAL_CONST_P(obj)) return;
689
690 rb_mmtk_gc_thread_tls->object_closure.c_function(rb_mmtk_gc_thread_tls->object_closure.rust_closure,
691 rb_mmtk_gc_thread_tls->gc_context,
692 (MMTk_ObjectReference)obj,
693 false);
694}
695
696void
697rb_gc_impl_mark_and_move(void *objspace_ptr, VALUE *ptr)
698{
699 if (RB_SPECIAL_CONST_P(*ptr)) return;
700
701 // TODO: make it movable
702 rb_gc_impl_mark(objspace_ptr, *ptr);
703}
704
705void
706rb_gc_impl_mark_and_pin(void *objspace_ptr, VALUE obj)
707{
708 if (RB_SPECIAL_CONST_P(obj)) return;
709
710 // TODO: also pin
711 rb_gc_impl_mark(objspace_ptr, obj);
712}
713
714void
715rb_gc_impl_mark_maybe(void *objspace_ptr, VALUE obj)
716{
717 if (rb_gc_impl_pointer_to_heap_p(objspace_ptr, (const void *)obj)) {
718 rb_gc_impl_mark_and_pin(objspace_ptr, obj);
719 }
720}
721
722void
723rb_gc_impl_mark_weak(void *objspace_ptr, VALUE *ptr)
724{
725 mmtk_mark_weak((MMTk_ObjectReference *)ptr);
726}
727
728void
729rb_gc_impl_remove_weak(void *objspace_ptr, VALUE parent_obj, VALUE *ptr)
730{
731 mmtk_remove_weak((MMTk_ObjectReference *)ptr);
732}
733
734// Compaction
735bool
736rb_gc_impl_object_moved_p(void *objspace_ptr, VALUE obj)
737{
738 rb_bug("unimplemented");
739}
740
741VALUE
742rb_gc_impl_location(void *objspace_ptr, VALUE value)
743{
744 rb_bug("unimplemented");
745}
746
747// Write barriers
748void
749rb_gc_impl_writebarrier(void *objspace_ptr, VALUE a, VALUE b)
750{
751 struct MMTk_ractor_cache *cache = rb_gc_get_ractor_newobj_cache();
752
753 if (SPECIAL_CONST_P(b)) return;
754
755 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)a);
756}
757
758void
759rb_gc_impl_writebarrier_unprotect(void *objspace_ptr, VALUE obj)
760{
761 mmtk_register_wb_unprotected_object((MMTk_ObjectReference)obj);
762}
763
764void
765rb_gc_impl_writebarrier_remember(void *objspace_ptr, VALUE obj)
766{
767 struct MMTk_ractor_cache *cache = rb_gc_get_ractor_newobj_cache();
768
769 mmtk_object_reference_write_post(cache->mutator, (MMTk_ObjectReference)obj);
770}
771
772// Heap walking
773static void
774each_objects_i(MMTk_ObjectReference obj, void *d)
775{
776 rb_darray(VALUE) *objs = d;
777
778 rb_darray_append(objs, (VALUE)obj);
779}
780
781static void
782each_object(struct objspace *objspace, int (*func)(VALUE, void *), void *data)
783{
784 rb_darray(VALUE) objs;
785 rb_darray_make(&objs, 0);
786
787 mmtk_enumerate_objects(each_objects_i, &objs);
788
789 VALUE *obj_ptr;
790 rb_darray_foreach(objs, i, obj_ptr) {
791 if (!mmtk_is_mmtk_object((MMTk_ObjectReference)*obj_ptr)) continue;
792
793 if (func(*obj_ptr, data) != 0) {
794 break;
795 }
796 }
797
798 rb_darray_free(objs);
799}
800
802 int (*func)(void *, void *, size_t, void *);
803 void *data;
804};
805
806static int
807rb_gc_impl_each_objects_i(VALUE obj, void *d)
808{
809 struct rb_gc_impl_each_objects_data *data = d;
810
811 size_t slot_size = rb_gc_impl_obj_slot_size(obj);
812
813 return data->func((void *)obj, (void *)(obj + slot_size), slot_size, data->data);
814}
815
816void
817rb_gc_impl_each_objects(void *objspace_ptr, int (*func)(void *, void *, size_t, void *), void *data)
818{
819 struct rb_gc_impl_each_objects_data each_objects_data = {
820 .func = func,
821 .data = data
822 };
823
824 each_object(objspace_ptr, rb_gc_impl_each_objects_i, &each_objects_data);
825}
826
828 void (*func)(VALUE, void *);
829 void *data;
830};
831
832static int
833rb_gc_impl_each_object_i(VALUE obj, void *d)
834{
835 struct rb_gc_impl_each_object_data *data = d;
836
837 data->func(obj, data->data);
838
839 return 0;
840}
841
842void
843rb_gc_impl_each_object(void *objspace_ptr, void (*func)(VALUE, void *), void *data)
844{
845 struct rb_gc_impl_each_object_data each_object_data = {
846 .func = func,
847 .data = data
848 };
849
850 each_object(objspace_ptr, rb_gc_impl_each_object_i, &each_object_data);
851}
852
853// Finalizers
854static VALUE
855gc_run_finalizers_get_final(long i, void *data)
856{
857 VALUE table = (VALUE)data;
858
859 return RARRAY_AREF(table, i + 1);
860}
861
862static void
863gc_run_finalizers(void *data)
864{
865 struct objspace *objspace = data;
866
867 rb_gc_set_pending_interrupt();
868
869 while (objspace->finalizer_jobs != NULL) {
870 struct MMTk_final_job *job = objspace->finalizer_jobs;
871 objspace->finalizer_jobs = job->next;
872
873 switch (job->kind) {
874 case MMTK_FINAL_JOB_DFREE:
875 job->as.dfree.func(job->as.dfree.data);
876 break;
877 case MMTK_FINAL_JOB_FINALIZE: {
878 VALUE finalizer_array = job->as.finalize.finalizer_array;
879
880 rb_gc_run_obj_finalizer(
881 RARRAY_AREF(finalizer_array, 0),
882 RARRAY_LEN(finalizer_array) - 1,
883 gc_run_finalizers_get_final,
884 (void *)finalizer_array
885 );
886
887 RB_GC_GUARD(finalizer_array);
888 break;
889 }
890 }
891
892 xfree(job);
893 }
894
895 rb_gc_unset_pending_interrupt();
896}
897
898void
899rb_gc_impl_make_zombie(void *objspace_ptr, VALUE obj, void (*dfree)(void *), void *data)
900{
901 if (dfree == NULL) return;
902
903 struct objspace *objspace = objspace_ptr;
904
905 struct MMTk_final_job *job = xmalloc(sizeof(struct MMTk_final_job));
906 job->kind = MMTK_FINAL_JOB_DFREE;
907 job->as.dfree.func = dfree;
908 job->as.dfree.data = data;
909
910 struct MMTk_final_job *prev;
911 do {
912 job->next = objspace->finalizer_jobs;
913 prev = RUBY_ATOMIC_PTR_CAS(objspace->finalizer_jobs, job->next, job);
914 } while (prev != job->next);
915
916 if (!ruby_free_at_exit_p()) {
917 rb_postponed_job_trigger(objspace->finalizer_postponed_job);
918 }
919}
920
921VALUE
922rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
923{
924 struct objspace *objspace = objspace_ptr;
925 VALUE table;
926 st_data_t data;
927
928 RBASIC(obj)->flags |= FL_FINALIZE;
929
930 int lev = RB_GC_VM_LOCK();
931
932 if (st_lookup(objspace->finalizer_table, obj, &data)) {
933 table = (VALUE)data;
934
935 /* avoid duplicate block, table is usually small */
936 {
937 long len = RARRAY_LEN(table);
938 long i;
939
940 for (i = 0; i < len; i++) {
941 VALUE recv = RARRAY_AREF(table, i);
942 if (rb_equal(recv, block)) {
943 RB_GC_VM_UNLOCK(lev);
944 return recv;
945 }
946 }
947 }
948
949 rb_ary_push(table, block);
950 }
951 else {
952 table = rb_ary_new3(2, rb_obj_id(obj), block);
953 rb_obj_hide(table);
954 st_add_direct(objspace->finalizer_table, obj, table);
955 }
956
957 RB_GC_VM_UNLOCK(lev);
958
959 return block;
960}
961
962void
963rb_gc_impl_undefine_finalizer(void *objspace_ptr, VALUE obj)
964{
965 struct objspace *objspace = objspace_ptr;
966
967 st_data_t data = obj;
968
969 int lev = RB_GC_VM_LOCK();
970 st_delete(objspace->finalizer_table, &data, 0);
971 RB_GC_VM_UNLOCK(lev);
972
973 FL_UNSET(obj, FL_FINALIZE);
974}
975
976void
977rb_gc_impl_copy_finalizer(void *objspace_ptr, VALUE dest, VALUE obj)
978{
979 struct objspace *objspace = objspace_ptr;
980 VALUE table;
981 st_data_t data;
982
983 if (!FL_TEST(obj, FL_FINALIZE)) return;
984
985 int lev = RB_GC_VM_LOCK();
986 if (RB_LIKELY(st_lookup(objspace->finalizer_table, obj, &data))) {
987 table = rb_ary_dup((VALUE)data);
988 RARRAY_ASET(table, 0, rb_obj_id(dest));
989 st_insert(objspace->finalizer_table, dest, table);
990 FL_SET(dest, FL_FINALIZE);
991 }
992 else {
993 rb_bug("rb_gc_copy_finalizer: FL_FINALIZE set but not found in finalizer_table: %s", rb_obj_info(obj));
994 }
995 RB_GC_VM_UNLOCK(lev);
996}
997
998static int
999move_finalizer_from_table_i(st_data_t key, st_data_t val, st_data_t arg)
1000{
1001 struct objspace *objspace = (struct objspace *)arg;
1002
1003 make_final_job(objspace, (VALUE)key, (VALUE)val);
1004
1005 return ST_DELETE;
1006}
1007
1008void
1009rb_gc_impl_shutdown_call_finalizer(void *objspace_ptr)
1010{
1011 struct objspace *objspace = objspace_ptr;
1012
1013 while (objspace->finalizer_table->num_entries) {
1014 st_foreach(objspace->finalizer_table, move_finalizer_from_table_i, (st_data_t)objspace);
1015
1016 gc_run_finalizers(objspace);
1017 }
1018
1019 struct MMTk_RawVecOfObjRef registered_candidates = mmtk_get_all_obj_free_candidates();
1020 for (size_t i = 0; i < registered_candidates.len; i++) {
1021 VALUE obj = (VALUE)registered_candidates.ptr[i];
1022
1023 if (rb_gc_shutdown_call_finalizer_p(obj)) {
1024 rb_gc_obj_free(objspace_ptr, obj);
1025 RBASIC(obj)->flags = 0;
1026 }
1027 }
1028 mmtk_free_raw_vec_of_obj_ref(registered_candidates);
1029
1030 gc_run_finalizers(objspace);
1031}
1032
1033// Forking
1034
1035void
1036rb_gc_impl_before_fork(void *objspace_ptr)
1037{
1038 mmtk_before_fork();
1039}
1040
1041void
1042rb_gc_impl_after_fork(void *objspace_ptr, rb_pid_t pid)
1043{
1044 mmtk_after_fork(rb_gc_get_ractor_newobj_cache());
1045}
1046
1047// Statistics
1048
1049void
1050rb_gc_impl_set_measure_total_time(void *objspace_ptr, VALUE flag)
1051{
1052 struct objspace *objspace = objspace_ptr;
1053
1054 objspace->measure_gc_time = RTEST(flag);
1055}
1056
1057bool
1058rb_gc_impl_get_measure_total_time(void *objspace_ptr)
1059{
1060 struct objspace *objspace = objspace_ptr;
1061
1062 return objspace->measure_gc_time;
1063}
1064
1065unsigned long long
1066rb_gc_impl_get_total_time(void *objspace_ptr)
1067{
1068 struct objspace *objspace = objspace_ptr;
1069
1070 return objspace->total_gc_time;
1071}
1072
1073size_t
1074rb_gc_impl_gc_count(void *objspace_ptr)
1075{
1076 struct objspace *objspace = objspace_ptr;
1077
1078 return objspace->gc_count;
1079}
1080
1081VALUE
1082rb_gc_impl_latest_gc_info(void *objspace_ptr, VALUE hash_or_key)
1083{
1084 VALUE hash = Qnil, key = Qnil;
1085
1086 if (SYMBOL_P(hash_or_key)) {
1087 key = hash_or_key;
1088 }
1089 else if (RB_TYPE_P(hash_or_key, T_HASH)) {
1090 hash = hash_or_key;
1091 }
1092 else {
1093 rb_bug("gc_info_decode: non-hash or symbol given");
1094 }
1095
1096#define SET(name, attr) \
1097 if (key == ID2SYM(rb_intern_const(#name))) \
1098 return (attr); \
1099 else if (hash != Qnil) \
1100 rb_hash_aset(hash, ID2SYM(rb_intern_const(#name)), (attr));
1101
1102 /* Hack to get StackProf working because it calls rb_gc_latest_gc_info with
1103 * the :state key and expects a result. This always returns the :none state. */
1104 SET(state, ID2SYM(rb_intern_const("none")));
1105#undef SET
1106
1107 if (!NIL_P(key)) {
1108 // Matched key should return above
1109 return Qundef;
1110 }
1111
1112 return hash;
1113}
1114
1115enum gc_stat_sym {
1116 gc_stat_sym_count,
1117 gc_stat_sym_time,
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,
1124 gc_stat_sym_last
1125};
1126
1127static VALUE gc_stat_symbols[gc_stat_sym_last];
1128
1129static void
1130setup_gc_stat_symbols(void)
1131{
1132 if (gc_stat_symbols[0] == 0) {
1133#define S(s) gc_stat_symbols[gc_stat_sym_##s] = ID2SYM(rb_intern_const(#s))
1134 S(count);
1135 S(time);
1136 S(total_allocated_objects);
1137 S(total_bytes);
1138 S(used_bytes);
1139 S(free_bytes);
1140 S(starting_heap_address);
1141 S(last_heap_address);
1142 }
1143}
1144
1145VALUE
1146rb_gc_impl_stat(void *objspace_ptr, VALUE hash_or_sym)
1147{
1148 struct objspace *objspace = objspace_ptr;
1149 VALUE hash = Qnil, key = Qnil;
1150
1151 setup_gc_stat_symbols();
1152
1153 if (RB_TYPE_P(hash_or_sym, T_HASH)) {
1154 hash = hash_or_sym;
1155 }
1156 else if (SYMBOL_P(hash_or_sym)) {
1157 key = hash_or_sym;
1158 }
1159 else {
1160 rb_bug("non-hash or symbol given");
1161 }
1162
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));
1168
1169 SET(count, objspace->gc_count);
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());
1177#undef SET
1178
1179 if (!NIL_P(key)) {
1180 // Matched key should return above
1181 return Qundef;
1182 }
1183
1184 return hash;
1185}
1186
1187VALUE
1188rb_gc_impl_stat_heap(void *objspace_ptr, VALUE heap_name, VALUE hash_or_sym)
1189{
1190 if (RB_TYPE_P(hash_or_sym, T_HASH)) {
1191 return hash_or_sym;
1192 }
1193 else {
1194 return Qundef;
1195 }
1196}
1197
1198// Miscellaneous
1199
1200#define RB_GC_OBJECT_METADATA_ENTRY_COUNT 1
1201static struct rb_gc_object_metadata_entry object_metadata_entries[RB_GC_OBJECT_METADATA_ENTRY_COUNT + 1];
1202
1204rb_gc_impl_object_metadata(void *objspace_ptr, VALUE obj)
1205{
1206 static ID ID_object_id;
1207
1208 if (!ID_object_id) {
1209#define I(s) ID_##s = rb_intern(#s);
1210 I(object_id);
1211#undef I
1212 }
1213
1214 size_t n = 0;
1215
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; \
1220 n++; \
1221} while (0)
1222
1223 if (rb_obj_id_p(obj)) SET_ENTRY(object_id, rb_obj_id(obj));
1224
1225 object_metadata_entries[n].name = 0;
1226 object_metadata_entries[n].val = 0;
1227
1228 return object_metadata_entries;
1229}
1230
1231bool
1232rb_gc_impl_pointer_to_heap_p(void *objspace_ptr, const void *ptr)
1233{
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);
1237}
1238
1239bool
1240rb_gc_impl_garbage_object_p(void *objspace_ptr, VALUE obj)
1241{
1242 return false;
1243}
1244
1245void rb_gc_impl_set_event_hook(void *objspace_ptr, const rb_event_flag_t event) { }
1246
1247void
1248rb_gc_impl_copy_attributes(void *objspace_ptr, VALUE dest, VALUE obj)
1249{
1250 if (mmtk_object_wb_unprotected_p((MMTk_ObjectReference)obj)) {
1251 rb_gc_impl_writebarrier_unprotect(objspace_ptr, dest);
1252 }
1253
1254 rb_gc_impl_copy_finalizer(objspace_ptr, dest, obj);
1255}
1256
1257// GC Identification
1258
1259const char *
1260rb_gc_impl_active_gc_name(void)
1261{
1262 return "mmtk";
1263}
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
Atomic operations.
#define RUBY_ATOMIC_PTR_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are void*.
Definition atomic.h:340
#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...
Definition debug.h:703
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...
Definition vm_trace.c:1784
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 ...
Definition vm_trace.c:1750
#define RUBY_INTERNAL_EVENT_FREEOBJ
Object swept.
Definition event.h:94
#define RUBY_INTERNAL_EVENT_GC_START
GC started.
Definition event.h:95
uint32_t rb_event_flag_t
Represents event(s).
Definition event.h:108
static VALUE RB_FL_TEST(VALUE obj, VALUE flags)
Tests if the given flag(s) are set or not.
Definition fl_type.h:489
static void RB_FL_UNSET(VALUE obj, VALUE flags)
Clears the given flag(s).
Definition fl_type.h:675
@ RUBY_FL_FINALIZE
This flag has something to do with finalisers.
Definition fl_type.h:238
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define Qundef
Old name of RUBY_Qundef.
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:134
#define T_NONE
Old name of RUBY_T_NONE.
Definition value_type.h:74
#define SIZET2NUM
Old name of RB_SIZE2NUM.
Definition size_t.h:62
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
#define FL_FINALIZE
Old name of RUBY_FL_FINALIZE.
Definition fl_type.h:61
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define FL_SET
Old name of RB_FL_SET.
Definition fl_type.h:128
#define rb_ary_new3
Old name of rb_ary_new_from_args.
Definition array.h:658
#define Qtrue
Old name of RUBY_Qtrue.
#define INT2NUM
Old name of RB_INT2NUM.
Definition int.h:43
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define NIL_P
Old name of RB_NIL_P.
#define FL_TEST
Old name of RB_FL_TEST.
Definition fl_type.h:130
#define FL_UNSET
Old name of RB_FL_UNSET.
Definition fl_type.h:132
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition object.c:101
VALUE rb_mGC
GC module.
Definition gc.c:427
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
Definition object.c:175
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.
Definition string.h:1514
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
Raises rb_eNotImpError.
Definition vm_method.c:604
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:284
int len
Length of the buffer.
Definition io.h:8
#define RB_ULONG2NUM
Just another name of rb_ulong2num_inline.
Definition long.h:59
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
static void RARRAY_ASET(VALUE ary, long i, VALUE v)
Assigns an object in an array.
Definition rarray.h:386
#define RARRAY_AREF(a, i)
Definition rarray.h:403
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
int ruby_native_thread_p(void)
Queries if the thread which calls this function is a ruby's thread.
Definition thread.c:5761
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.
C99 shim for <stdbool.h>
void * rust_closure
The pointer to the Rust-level closure object.
Definition mmtk.h:45
MMTk_ObjectClosureFunction c_function
The function to be called from C.
Definition mmtk.h:41
Ruby object's base components.
Definition rbasic.h:69
Definition gc_impl.h:15
Definition st.h:79
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static enum ruby_value_type RB_BUILTIN_TYPE(VALUE obj)
Queries the type of the object.
Definition value_type.h:182
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376