10#include "ractor_core.h"
11#include "internal/complex.h"
12#include "internal/error.h"
13#include "internal/gc.h"
14#include "internal/hash.h"
15#include "internal/object.h"
16#include "internal/ractor.h"
17#include "internal/rational.h"
18#include "internal/struct.h"
19#include "internal/thread.h"
25static VALUE rb_cRactorSelector;
27VALUE rb_eRactorUnsafeError;
28VALUE rb_eRactorIsolationError;
29static VALUE rb_eRactorError;
30static VALUE rb_eRactorRemoteError;
31static VALUE rb_eRactorMovedError;
32static VALUE rb_eRactorClosedError;
33static VALUE rb_cRactorMovedObject;
35static void vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *r,
const char *file,
int line);
38#if RACTOR_CHECK_MODE > 0
39bool rb_ractor_ignore_belonging_flag =
false;
45ASSERT_ractor_unlocking(rb_ractor_t *r)
47#if RACTOR_CHECK_MODE > 0
48 const rb_execution_context_t *ec = rb_current_ec_noinline();
49 if (ec != NULL && r->sync.locked_by == rb_ractor_self(rb_ec_ractor_ptr(ec))) {
50 rb_bug(
"recursive ractor locking");
56ASSERT_ractor_locking(rb_ractor_t *r)
58#if RACTOR_CHECK_MODE > 0
59 const rb_execution_context_t *ec = rb_current_ec_noinline();
60 if (ec != NULL && r->sync.locked_by != rb_ractor_self(rb_ec_ractor_ptr(ec))) {
61 rp(r->sync.locked_by);
62 rb_bug(
"ractor lock is not acquired.");
68ractor_lock(rb_ractor_t *r,
const char *file,
int line)
70 RUBY_DEBUG_LOG2(file, line,
"locking r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
72 ASSERT_ractor_unlocking(r);
75 const rb_execution_context_t *ec = rb_current_ec_noinline();
77 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
78 VM_ASSERT(!cr->malloc_gc_disabled);
79 cr->malloc_gc_disabled =
true;
82#if RACTOR_CHECK_MODE > 0
84 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
85 r->sync.locked_by = rb_ractor_self(cr);
89 RUBY_DEBUG_LOG2(file, line,
"locked r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
93ractor_lock_self(rb_ractor_t *cr,
const char *file,
int line)
95 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
96#if RACTOR_CHECK_MODE > 0
97 VM_ASSERT(cr->sync.locked_by != cr->pub.self);
99 ractor_lock(cr, file, line);
103ractor_unlock(rb_ractor_t *r,
const char *file,
int line)
105 ASSERT_ractor_locking(r);
106#if RACTOR_CHECK_MODE > 0
107 r->sync.locked_by =
Qnil;
110 const rb_execution_context_t *ec = rb_current_ec_noinline();
112 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
113 VM_ASSERT(cr->malloc_gc_disabled);
114 cr->malloc_gc_disabled =
false;
119 RUBY_DEBUG_LOG2(file, line,
"r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
123ractor_unlock_self(rb_ractor_t *cr,
const char *file,
int line)
125 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
126#if RACTOR_CHECK_MODE > 0
127 VM_ASSERT(cr->sync.locked_by == cr->pub.self);
129 ractor_unlock(cr, file, line);
132#define RACTOR_LOCK(r) ractor_lock(r, __FILE__, __LINE__)
133#define RACTOR_UNLOCK(r) ractor_unlock(r, __FILE__, __LINE__)
134#define RACTOR_LOCK_SELF(r) ractor_lock_self(r, __FILE__, __LINE__)
135#define RACTOR_UNLOCK_SELF(r) ractor_unlock_self(r, __FILE__, __LINE__)
138rb_ractor_lock_self(rb_ractor_t *r)
144rb_ractor_unlock_self(rb_ractor_t *r)
146 RACTOR_UNLOCK_SELF(r);
152ractor_status_str(
enum ractor_status status)
155 case ractor_created:
return "created";
156 case ractor_running:
return "running";
157 case ractor_blocking:
return "blocking";
158 case ractor_terminated:
return "terminated";
160 rb_bug(
"unreachable");
164ractor_status_set(rb_ractor_t *r,
enum ractor_status status)
166 RUBY_DEBUG_LOG(
"r:%u [%s]->[%s]", r->pub.id, ractor_status_str(r->status_), ractor_status_str(status));
169 if (r->status_ != ractor_created) {
170 VM_ASSERT(r == GET_RACTOR());
175 switch (r->status_) {
177 VM_ASSERT(status == ractor_blocking);
180 VM_ASSERT(status == ractor_blocking||
181 status == ractor_terminated);
183 case ractor_blocking:
184 VM_ASSERT(status == ractor_running);
186 case ractor_terminated:
187 rb_bug(
"unreachable");
195ractor_status_p(rb_ractor_t *r,
enum ractor_status status)
197 return rb_ractor_status_p(r, status);
202static void ractor_local_storage_mark(rb_ractor_t *r);
203static void ractor_local_storage_free(rb_ractor_t *r);
205static void ractor_sync_mark(rb_ractor_t *r);
206static void ractor_sync_free(rb_ractor_t *r);
207static size_t ractor_sync_memsize(
const rb_ractor_t *r);
208static void ractor_sync_init(rb_ractor_t *r);
211mark_targeted_hook_list(st_data_t key, st_data_t value, st_data_t _arg)
213 rb_hook_list_t *hook_list = (rb_hook_list_t*)value;
215 if (hook_list->type == hook_list_type_targeted_iseq) {
216 rb_gc_mark((
VALUE)key);
219 rb_method_definition_t *def = (rb_method_definition_t*)key;
220 RUBY_ASSERT(hook_list->type == hook_list_type_targeted_def);
221 rb_gc_mark(def->body.bmethod.proc);
223 rb_hook_list_mark(hook_list);
229ractor_mark(
void *
ptr)
231 rb_ractor_t *r = (rb_ractor_t *)
ptr;
232 bool checking_shareable = rb_gc_checking_shareable();
237 if (!checking_shareable) {
239 rb_gc_mark(r->r_stdin);
240 rb_gc_mark(r->r_stdout);
241 rb_gc_mark(r->r_stderr);
242 rb_gc_mark(r->verbose);
243 rb_gc_mark(r->debug);
248 rb_hook_list_mark(&r->pub.hooks);
249 if (r->pub.targeted_hooks) {
250 st_foreach(r->pub.targeted_hooks, mark_targeted_hook_list, 0);
253 if (r->threads.cnt > 0) {
255 ccan_list_for_each(&r->threads.set, th, lt_node) {
256 VM_ASSERT(th != NULL);
257 rb_gc_mark(th->self);
261 ractor_local_storage_mark(r);
266free_targeted_hook_lists(st_data_t key, st_data_t val, st_data_t _arg)
268 rb_hook_list_t *hook_list = (rb_hook_list_t*)val;
269 rb_hook_list_free(hook_list);
274free_targeted_hooks(st_table *hooks_tbl)
276 st_foreach(hooks_tbl, free_targeted_hook_lists, 0);
280ractor_free(
void *
ptr)
282 rb_ractor_t *r = (rb_ractor_t *)
ptr;
283 RUBY_DEBUG_LOG(
"free r:%d", rb_ractor_id(r));
284 free_targeted_hooks(r->pub.targeted_hooks);
286#ifdef RUBY_THREAD_WIN32_H
289 ractor_local_storage_free(r);
290 rb_hook_list_free(&r->pub.hooks);
291 st_free_table(r->pub.targeted_hooks);
293 if (r->newobj_cache) {
296 rb_gc_ractor_cache_free(r->newobj_cache);
297 r->newobj_cache = NULL;
305ractor_memsize(
const void *
ptr)
307 rb_ractor_t *r = (rb_ractor_t *)
ptr;
310 return sizeof(rb_ractor_t) + ractor_sync_memsize(r);
321 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
335static inline rb_ractor_t *
336RACTOR_PTR(
VALUE self)
338 VM_ASSERT(rb_ractor_p(self));
345#if RACTOR_CHECK_MODE > 0
347rb_ractor_current_id(
void)
349 if (GET_THREAD()->ractor == NULL) {
353 return rb_ractor_id(GET_RACTOR());
358#include "ractor_sync.c"
373vm_insert_ractor0(rb_vm_t *vm, rb_ractor_t *r,
bool single_ractor_mode)
375 RUBY_DEBUG_LOG(
"r:%u ractor.cnt:%u++", r->pub.id, vm->ractor.cnt);
376 VM_ASSERT(single_ractor_mode || RB_VM_LOCKED_P());
378 ccan_list_add_tail(&vm->ractor.set, &r->vmlr_node);
381 if (r->newobj_cache) {
382 VM_ASSERT(r == ruby_single_main_ractor);
385 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
390cancel_single_ractor_mode(
void)
393 RUBY_DEBUG_LOG(
"enable multi-ractor mode");
395 ruby_single_main_ractor = NULL;
400vm_insert_ractor(rb_vm_t *vm, rb_ractor_t *r)
402 VM_ASSERT(ractor_status_p(r, ractor_created));
404 if (rb_multi_ractor_p()) {
407 vm_insert_ractor0(vm, r,
false);
408 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
413 if (vm->ractor.cnt == 0) {
415 vm_insert_ractor0(vm, r,
true);
416 ractor_status_set(r, ractor_blocking);
417 ractor_status_set(r, ractor_running);
420 cancel_single_ractor_mode();
421 vm_insert_ractor0(vm, r,
true);
422 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
428vm_remove_ractor(rb_vm_t *vm, rb_ractor_t *cr)
430 VM_ASSERT(ractor_status_p(cr, ractor_running));
431 VM_ASSERT(vm->ractor.cnt > 1);
432 VM_ASSERT(cr->threads.cnt == 1);
436 RUBY_DEBUG_LOG(
"ractor.cnt:%u-- terminate_waiting:%d",
437 vm->ractor.cnt, vm->ractor.sync.terminate_waiting);
439 VM_ASSERT(vm->ractor.cnt > 0);
440 ccan_list_del(&cr->vmlr_node);
442 if (vm->ractor.cnt <= 2 && vm->ractor.sync.terminate_waiting) {
447 rb_gc_ractor_cache_free(cr->newobj_cache);
448 cr->newobj_cache = NULL;
450 ractor_status_set(cr, ractor_terminated);
456ractor_alloc(
VALUE klass)
462 r->next_ec_serial = 1;
463 VM_ASSERT(ractor_status_p(r, ractor_created));
468rb_ractor_main_alloc(
void)
470 rb_ractor_t *r = ruby_mimcalloc(1,
sizeof(rb_ractor_t));
472 fprintf(stderr,
"[FATAL] failed to allocate memory for main ractor\n");
475 r->pub.id = ++ractor_last_id;
479 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
480 r->next_ec_serial = 1;
481 ruby_single_main_ractor = r;
486#if defined(HAVE_WORKING_FORK)
490rb_ractor_atfork(rb_vm_t *vm, rb_thread_t *th)
494 vm->ractor.blocking_cnt = 0;
495 ruby_single_main_ractor = th->ractor;
496 th->ractor->status_ = ractor_created;
498 ractor_sync_atfork(th->ractor);
499 rb_ractor_living_threads_init(th->ractor);
500 rb_ractor_living_threads_insert(th->ractor, th);
502 VM_ASSERT(vm->ractor.blocking_cnt == 0);
503 VM_ASSERT(vm->ractor.cnt == 1);
507rb_ractor_terminate_atfork(rb_vm_t *vm, rb_ractor_t *r)
509 rb_gc_ractor_cache_free(r->newobj_cache);
510 r->newobj_cache = NULL;
511 r->status_ = ractor_terminated;
512 ractor_sync_terminate_atfork(vm, r);
519rb_ractor_living_threads_init(rb_ractor_t *r)
521 ccan_list_head_init(&r->threads.set);
523 r->threads.blocking_cnt = 0;
527ractor_init(rb_ractor_t *r,
VALUE name,
VALUE loc)
530 r->pub.targeted_hooks = st_init_numtable();
531 r->pub.hooks.type = hook_list_type_ractor_local;
534 rb_thread_sched_init(&r->threads.sched,
false);
535 rb_ractor_living_threads_init(r);
541 enc = rb_enc_get(name);
542 if (!rb_enc_asciicompat(enc)) {
543 rb_raise(rb_eArgError,
"ASCII incompatible encoding (%s)",
555rb_ractor_main_setup(rb_vm_t *vm, rb_ractor_t *r, rb_thread_t *th)
560 r->threads.main = th;
561 rb_ractor_living_threads_insert(r, th);
569 VALUE rv = ractor_alloc(self);
570 rb_ractor_t *r = RACTOR_PTR(rv);
571 ractor_init(r, name, loc);
573 r->pub.id = ractor_next_id();
574 RUBY_DEBUG_LOG(
"r:%u", r->pub.id);
576 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
577 r->verbose = cr->verbose;
578 r->debug = cr->debug;
580 rb_yjit_before_ractor_spawn();
581 rb_zjit_before_ractor_spawn();
582 rb_thread_create_ractor(r, args, block);
593 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
598ractor_atexit(rb_execution_context_t *ec, rb_ractor_t *cr,
VALUE result,
bool exc)
600 ractor_notify_exit(ec, cr, result, exc);
604rb_ractor_atexit(rb_execution_context_t *ec,
VALUE result)
606 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
607 ractor_atexit(ec, cr, result,
false);
611rb_ractor_atexit_exception(rb_execution_context_t *ec)
613 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
614 ractor_atexit(ec, cr, ec->errinfo,
true);
618rb_ractor_teardown(rb_execution_context_t *ec)
620 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
624 VM_ASSERT(cr->threads.main != NULL);
625 cr->threads.main = NULL;
630rb_ractor_receive_parameters(rb_execution_context_t *ec, rb_ractor_t *r,
int len,
VALUE *
ptr)
632 for (
int i=0; i<
len; i++) {
633 ptr[i] = ractor_receive(ec, ractor_default_port(r));
638rb_ractor_send_parameters(rb_execution_context_t *ec, rb_ractor_t *r,
VALUE args)
640 int len = RARRAY_LENINT(args);
641 for (
int i=0; i<
len; i++) {
642 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
647rb_ractor_main_p_(
void)
649 VM_ASSERT(rb_multi_ractor_p());
650 rb_execution_context_t *ec = GET_EC();
651 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
655rb_ractor_living_thread_num(
const rb_ractor_t *r)
657 return r->threads.cnt;
662rb_ractor_thread_list(
void)
664 rb_ractor_t *r = GET_RACTOR();
668 ccan_list_for_each(&r->threads.set, th, lt_node) {
669 switch (th->status) {
670 case THREAD_RUNNABLE:
672 case THREAD_STOPPED_FOREVER:
683rb_ractor_living_threads_insert(rb_ractor_t *r, rb_thread_t *th)
685 VM_ASSERT(th != NULL);
689 RUBY_DEBUG_LOG(
"r(%d)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
690 ccan_list_add_tail(&r->threads.set, &th->lt_node);
696 if (r->threads.cnt == 1) {
697 VM_ASSERT(ractor_status_p(r, ractor_created));
698 vm_insert_ractor(th->vm, r);
703vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *r,
const char *file,
int line)
705 ractor_status_set(r, ractor_blocking);
707 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
708 vm->ractor.blocking_cnt++;
709 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
713rb_vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *cr,
const char *file,
int line)
716 VM_ASSERT(GET_RACTOR() == cr);
717 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
721rb_vm_ractor_blocking_cnt_dec(rb_vm_t *vm, rb_ractor_t *cr,
const char *file,
int line)
724 VM_ASSERT(GET_RACTOR() == cr);
726 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
727 VM_ASSERT(vm->ractor.blocking_cnt > 0);
728 vm->ractor.blocking_cnt--;
730 ractor_status_set(cr, ractor_running);
734ractor_check_blocking(rb_ractor_t *cr,
unsigned int remained_thread_cnt,
const char *file,
int line)
736 VM_ASSERT(cr == GET_RACTOR());
738 RUBY_DEBUG_LOG2(file, line,
739 "cr->threads.cnt:%u cr->threads.blocking_cnt:%u vm->ractor.cnt:%u vm->ractor.blocking_cnt:%u",
740 cr->threads.cnt, cr->threads.blocking_cnt,
741 GET_VM()->ractor.cnt, GET_VM()->ractor.blocking_cnt);
743 VM_ASSERT(cr->threads.cnt >= cr->threads.blocking_cnt + 1);
745 if (remained_thread_cnt > 0 &&
747 cr->threads.cnt == cr->threads.blocking_cnt + 1) {
749 rb_vm_t *vm = GET_VM();
752 rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);
757void rb_threadptr_remove(rb_thread_t *th);
760rb_ractor_living_threads_remove(rb_ractor_t *cr, rb_thread_t *th)
762 VM_ASSERT(cr == GET_RACTOR());
763 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
764 ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
766 rb_threadptr_remove(th);
768 if (cr->threads.cnt == 1) {
769 vm_remove_ractor(th->vm, cr);
774 ccan_list_del(&th->lt_node);
782rb_ractor_blocking_threads_inc(rb_ractor_t *cr,
const char *file,
int line)
784 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
786 VM_ASSERT(cr->threads.cnt > 0);
787 VM_ASSERT(cr == GET_RACTOR());
789 ractor_check_blocking(cr, cr->threads.cnt, __FILE__, __LINE__);
790 cr->threads.blocking_cnt++;
794rb_ractor_blocking_threads_dec(rb_ractor_t *cr,
const char *file,
int line)
796 RUBY_DEBUG_LOG2(file, line,
797 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
798 cr->threads.blocking_cnt, cr->threads.cnt);
800 VM_ASSERT(cr == GET_RACTOR());
802 if (cr->threads.cnt == cr->threads.blocking_cnt) {
803 rb_vm_t *vm = GET_VM();
806 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
810 cr->threads.blocking_cnt--;
814rb_ractor_vm_barrier_interrupt_running_thread(rb_ractor_t *r)
816 VM_ASSERT(r != GET_RACTOR());
817 ASSERT_ractor_unlocking(r);
822 if (ractor_status_p(r, ractor_running)) {
823 rb_execution_context_t *ec = r->threads.running_ec;
825 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
833rb_ractor_terminate_interrupt_main_thread(rb_ractor_t *r)
835 VM_ASSERT(r != GET_RACTOR());
836 ASSERT_ractor_unlocking(r);
839 rb_thread_t *main_th = r->threads.main;
841 if (main_th->status != THREAD_KILLED) {
842 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
843 rb_threadptr_interrupt(main_th);
846 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
851void rb_thread_terminate_all(rb_thread_t *th);
854ractor_terminal_interrupt_all(rb_vm_t *vm)
856 if (vm->ractor.cnt > 1) {
859 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
860 if (r != vm->ractor.main_ractor) {
861 RUBY_DEBUG_LOG(
"r:%d", rb_ractor_id(r));
862 rb_ractor_terminate_interrupt_main_thread(r);
868void rb_add_running_thread(rb_thread_t *th);
869void rb_del_running_thread(rb_thread_t *th);
872rb_ractor_terminate_all(
void)
874 rb_vm_t *vm = GET_VM();
875 rb_ractor_t *cr = vm->ractor.main_ractor;
877 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
879 VM_ASSERT(cr == GET_RACTOR());
883 ractor_terminal_interrupt_all(vm);
886 rb_thread_terminate_all(GET_THREAD());
890 while (vm->ractor.cnt > 1) {
891 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
892 vm->ractor.sync.terminate_waiting =
true;
895 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
896 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
897 rb_vm_cond_timedwait(vm, &vm->ractor.sync.terminate_cond, 1000 );
898#ifdef RUBY_THREAD_PTHREAD_H
899 while (vm->ractor.sched.barrier_waiting) {
906 RB_VM_LOCK_ENTER_LEV_NB(&lev);
909 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
910 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
912 ractor_terminal_interrupt_all(vm);
918rb_execution_context_t *
919rb_vm_main_ractor_ec(rb_vm_t *vm)
935 rb_execution_context_t *running_ec = vm->ractor.main_ractor->threads.running_ec;
936 if (running_ec) {
return running_ec; }
937 return vm->ractor.main_thread->ec;
941ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
943 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
1053 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
1056 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
1060 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
1061 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
1062 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
1063 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1071 rb_vm_t *vm = GET_VM();
1074 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1075 if (r != vm->ractor.main_ractor) {
1076 fprintf(stderr,
"r:%u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1084 if (rb_ractor_main_p()) {
1088 rb_ractor_t *cr = GET_RACTOR();
1094rb_ractor_stdout(
void)
1096 if (rb_ractor_main_p()) {
1100 rb_ractor_t *cr = GET_RACTOR();
1101 return cr->r_stdout;
1106rb_ractor_stderr(
void)
1108 if (rb_ractor_main_p()) {
1112 rb_ractor_t *cr = GET_RACTOR();
1113 return cr->r_stderr;
1120 if (rb_ractor_main_p()) {
1124 rb_ractor_t *cr = GET_RACTOR();
1132 if (rb_ractor_main_p()) {
1136 rb_ractor_t *cr = GET_RACTOR();
1144 if (rb_ractor_main_p()) {
1148 rb_ractor_t *cr = GET_RACTOR();
1154rb_ractor_hooks(rb_ractor_t *cr)
1156 return &cr->pub.hooks;
1160rb_ractor_targeted_hooks(rb_ractor_t *cr)
1162 return cr->pub.targeted_hooks;
1166rb_obj_set_shareable_no_assert(
VALUE obj)
1170 if (rb_obj_gen_fields_p(obj)) {
1171 VALUE fields = rb_obj_fields_no_ractor_check(obj);
1172 if (imemo_type_p(fields, imemo_fields)) {
1179#ifndef STRICT_VERIFY_SHAREABLE
1180#define STRICT_VERIFY_SHAREABLE 0
1184rb_ractor_verify_shareable(
VALUE obj)
1186#if STRICT_VERIFY_SHAREABLE
1187 rb_gc_verify_shareable(obj);
1193rb_obj_set_shareable(
VALUE obj)
1197 rb_obj_set_shareable_no_assert(obj);
1209enum obj_traverse_iterator_result {
1215typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1216typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1217typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1219static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1222 rb_obj_traverse_enter_func enter_func;
1223 rb_obj_traverse_leave_func leave_func;
1242 if (obj_traverse_i(key, d->data)) {
1247 if (obj_traverse_i(val, d->data)) {
1256obj_traverse_reachable_i(
VALUE obj,
void *
ptr)
1260 if (obj_traverse_i(obj, d->data)) {
1265static struct st_table *
1268 if (UNLIKELY(!data->rec)) {
1269 data->rec_hash = rb_ident_hash_new();
1270 data->rec = RHASH_ST_TABLE(data->rec_hash);
1276obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t
ptr)
1280 if (obj_traverse_i(val, d->data)) {
1291 if (RB_SPECIAL_CONST_P(obj))
return 0;
1293 switch (data->enter_func(obj)) {
1294 case traverse_cont:
break;
1295 case traverse_skip:
return 0;
1296 case traverse_stop:
return 1;
1299 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1310 if (d.stop)
return 1;
1328 rb_ary_cancel_sharing(obj);
1330 for (
int i = 0; i < RARRAY_LENINT(obj); i++) {
1332 if (obj_traverse_i(e, data))
return 1;
1345 rb_hash_foreach(obj, obj_hash_traverse_i, (
VALUE)&d);
1346 if (d.stop)
return 1;
1352 long len = RSTRUCT_LEN(obj);
1353 const VALUE *
ptr = RSTRUCT_CONST_PTR(obj);
1355 for (
long i=0; i<
len; i++) {
1356 if (obj_traverse_i(
ptr[i], data))
return 1;
1362 if (obj_traverse_i(
RMATCH(obj)->str, data))
return 1;
1366 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1367 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1370 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1371 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1381 RB_VM_LOCKING_NO_BARRIER() {
1382 rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);
1384 if (d.stop)
return 1;
1394 rb_bug(
"unreachable");
1397 if (data->leave_func(obj) == traverse_stop) {
1406 rb_obj_traverse_final_func final_func;
1411obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1414 if (data->final_func(key)) {
1424rb_obj_traverse(
VALUE obj,
1425 rb_obj_traverse_enter_func enter_func,
1426 rb_obj_traverse_leave_func leave_func,
1427 rb_obj_traverse_final_func final_func)
1430 .enter_func = enter_func,
1431 .leave_func = leave_func,
1435 if (obj_traverse_i(obj, &data))
return 1;
1436 if (final_func && data.rec) {
1438 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1445allow_frozen_shareable_p(
VALUE obj)
1447 if (!RB_TYPE_P(obj,
T_DATA)) {
1450 else if (RTYPEDDATA_P(obj)) {
1452 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1460static enum obj_traverse_iterator_result
1461make_shareable_check_shareable_freeze(
VALUE obj,
enum obj_traverse_iterator_result result)
1463 if (!RB_OBJ_FROZEN_RAW(obj)) {
1466 if (UNLIKELY(!RB_OBJ_FROZEN_RAW(obj))) {
1467 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1471 return traverse_skip;
1478static int obj_refer_only_shareables_p(
VALUE obj);
1480static enum obj_traverse_iterator_result
1481make_shareable_check_shareable(
VALUE obj)
1485 if (rb_ractor_shareable_p(obj)) {
1486 return traverse_skip;
1488 else if (!allow_frozen_shareable_p(obj)) {
1489 if (!RB_TYPE_P(obj,
T_DATA)) {
1490 rb_raise(rb_eRactorError,
1491 "can not make shareable object for %+"PRIsVALUE, obj);
1493 else if (RTYPEDDATA_TYPE(obj)->flags & RUBY_TYPED_FROZEN_SHAREABLE_NO_REC) {
1494 if (obj_refer_only_shareables_p(obj)) {
1495 make_shareable_check_shareable_freeze(obj, traverse_skip);
1496 RB_OBJ_SET_SHAREABLE(obj);
1497 return traverse_skip;
1500 rb_raise(rb_eRactorError,
1501 "can not make shareable object for %+"PRIsVALUE
" because it refers unshareable objects", obj);
1505 rb_proc_ractor_make_shareable(obj,
Qundef);
1506 return traverse_cont;
1509 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
1513 switch (
TYPE(obj)) {
1515 return traverse_skip;
1522 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1523 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1524 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
1525 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
1534 return make_shareable_check_shareable_freeze(obj, traverse_cont);
1537static enum obj_traverse_iterator_result
1538mark_shareable(
VALUE obj)
1541 rb_str_make_independent(obj);
1544 rb_obj_set_shareable_no_assert(obj);
1545 return traverse_cont;
1551 rb_obj_traverse(obj,
1552 make_shareable_check_shareable,
1553 null_leave, mark_shareable);
1560 VALUE copy = ractor_copy(obj);
1565rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
1567 if (!rb_ractor_shareable_p(obj)) {
1568 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
1576rb_ractor_ensure_main_ractor(
const char *msg)
1578 if (!rb_ractor_main_p()) {
1579 rb_raise(rb_eRactorIsolationError,
"%s", msg);
1583static enum obj_traverse_iterator_result
1584shareable_p_enter(
VALUE obj)
1587 return traverse_skip;
1589 else if (RB_TYPE_P(obj,
T_CLASS) ||
1593 mark_shareable(obj);
1594 return traverse_skip;
1596 else if (RB_OBJ_FROZEN_RAW(obj) &&
1597 allow_frozen_shareable_p(obj)) {
1598 return traverse_cont;
1601 return traverse_stop;
1605rb_ractor_shareable_p_continue(
VALUE obj)
1607 if (rb_obj_traverse(obj,
1608 shareable_p_enter, null_leave,
1617#if RACTOR_CHECK_MODE > 0
1619rb_ractor_setup_belonging(
VALUE obj)
1621 rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
1624static enum obj_traverse_iterator_result
1625reset_belonging_enter(
VALUE obj)
1627 if (rb_ractor_shareable_p(obj)) {
1628 return traverse_skip;
1631 rb_ractor_setup_belonging(obj);
1632 return traverse_cont;
1637static enum obj_traverse_iterator_result
1638null_leave(
VALUE obj)
1640 return traverse_cont;
1644ractor_reset_belonging(
VALUE obj)
1646#if RACTOR_CHECK_MODE > 0
1647 rb_obj_traverse(obj, reset_belonging_enter, null_leave, NULL);
1665 rb_obj_traverse_replace_enter_func enter_func;
1666 rb_obj_traverse_replace_leave_func leave_func;
1682obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
1688obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t
ptr,
int exists)
1693 if (obj_traverse_replace_i(*key, data)) {
1697 else if (*key != data->replacement) {
1698 VALUE v = *key = data->replacement;
1702 if (obj_traverse_replace_i(*val, data)) {
1706 else if (*val != data->replacement) {
1707 VALUE v = *val = data->replacement;
1715obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
1721obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t
ptr,
int exists)
1726 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
1730 else if (*(
VALUE *)val != data->replacement) {
1738static struct st_table *
1741 if (UNLIKELY(!data->rec)) {
1742 data->rec_hash = rb_ident_hash_new();
1743 data->rec = RHASH_ST_TABLE(data->rec_hash);
1749obj_refer_only_shareables_p_i(
VALUE obj,
void *
ptr)
1751 int *pcnt = (
int *)
ptr;
1753 if (!rb_ractor_shareable_p(obj)) {
1759obj_refer_only_shareables_p(
VALUE obj)
1762 RB_VM_LOCKING_NO_BARRIER() {
1763 rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);
1771 st_data_t replacement;
1773 if (RB_SPECIAL_CONST_P(obj)) {
1774 data->replacement = obj;
1778 switch (data->enter_func(obj, data)) {
1779 case traverse_cont:
break;
1780 case traverse_skip:
return 0;
1781 case traverse_stop:
return 1;
1784 replacement = (st_data_t)data->replacement;
1786 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
1787 data->replacement = (
VALUE)replacement;
1791 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
1800#define CHECK_AND_REPLACE(parent_obj, v) do { \
1802 if (obj_traverse_replace_i(_val, data)) { return 1; } \
1803 else if (data->replacement != _val) { RB_OBJ_WRITE(parent_obj, &v, data->replacement); } \
1806 if (UNLIKELY(rb_obj_gen_fields_p(obj))) {
1807 VALUE fields_obj = rb_obj_fields_no_ractor_check(obj);
1809 if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {
1815 rb_st_foreach_with_replace(
1816 rb_imemo_fields_complex_tbl(fields_obj),
1817 obj_iv_hash_traverse_replace_foreach_i,
1818 obj_iv_hash_traverse_replace_i,
1821 if (d.stop)
return 1;
1824 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
1825 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
1826 for (uint32_t i = 0; i < fields_count; i++) {
1827 CHECK_AND_REPLACE(fields_obj, fields[i]);
1841 rb_str_make_independent(obj);
1846 if (rb_shape_obj_too_complex_p(obj)) {
1852 rb_st_foreach_with_replace(
1853 ROBJECT_FIELDS_HASH(obj),
1854 obj_iv_hash_traverse_replace_foreach_i,
1855 obj_iv_hash_traverse_replace_i,
1858 if (d.stop)
return 1;
1861 uint32_t
len = ROBJECT_FIELDS_COUNT_NOT_COMPLEX(obj);
1864 for (uint32_t i = 0; i <
len; i++) {
1865 CHECK_AND_REPLACE(obj,
ptr[i]);
1873 rb_ary_cancel_sharing(obj);
1875 for (
int i = 0; i < RARRAY_LENINT(obj); i++) {
1878 if (obj_traverse_replace_i(e, data)) {
1881 else if (e != data->replacement) {
1882 RARRAY_ASET(obj, i, data->replacement);
1895 rb_hash_stlike_foreach_with_replace(obj,
1896 obj_hash_traverse_replace_foreach_i,
1897 obj_hash_traverse_replace_i,
1899 if (d.stop)
return 1;
1903 if (obj_traverse_replace_i(ifnone, data)) {
1906 else if (ifnone != data->replacement) {
1914 long len = RSTRUCT_LEN(obj);
1915 const VALUE *
ptr = RSTRUCT_CONST_PTR(obj);
1917 for (
long i=0; i<
len; i++) {
1918 CHECK_AND_REPLACE(obj,
ptr[i]);
1924 CHECK_AND_REPLACE(obj,
RMATCH(obj)->str);
1928 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->num);
1929 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->den);
1932 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->real);
1933 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->imag);
1937 if (!data->move && obj_refer_only_shareables_p(obj)) {
1941 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
1942 data->move ?
"move" :
"copy", rb_class_of(obj));
1955 rb_bug(
"unreachable");
1958 data->replacement = (
VALUE)replacement;
1960 if (data->leave_func(obj, data) == traverse_stop) {
1971rb_obj_traverse_replace(
VALUE obj,
1972 rb_obj_traverse_replace_enter_func enter_func,
1973 rb_obj_traverse_replace_leave_func leave_func,
1977 .enter_func = enter_func,
1978 .leave_func = leave_func,
1984 if (obj_traverse_replace_i(obj, &data)) {
1988 return data.replacement;
1992static const bool wb_protected_types[
RUBY_T_MASK] = {
2005static enum obj_traverse_iterator_result
2008 if (rb_ractor_shareable_p(obj)) {
2009 data->replacement = obj;
2010 return traverse_skip;
2014 size_t slot_size = rb_gc_obj_slot_size(obj);
2016 NEWOBJ_OF(moved,
struct RBasic, 0,
type, slot_size, 0);
2017 MEMZERO(&moved[1],
char, slot_size -
sizeof(*moved));
2018 data->replacement = (
VALUE)moved;
2019 return traverse_cont;
2023static enum obj_traverse_iterator_result
2028 RBASIC(data->replacement)->flags = (
RBASIC(obj)->flags & ~ignored_flags) | (
RBASIC(data->replacement)->flags & ignored_flags);
2031 (
char *)data->replacement +
sizeof(
VALUE),
2032 (
char *)obj +
sizeof(
VALUE),
2033 rb_gc_obj_slot_size(obj) -
sizeof(
VALUE)
2037 rb_gc_writebarrier_remember(data->replacement);
2039 void rb_replace_generic_ivar(
VALUE clone,
VALUE obj);
2040 if (UNLIKELY(rb_obj_gen_fields_p(obj))) {
2041 rb_replace_generic_ivar(data->replacement, obj);
2044 rb_gc_obj_id_moved(data->replacement);
2050 RBASIC(obj)->flags = flags;
2051 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
2052 return traverse_cont;
2056ractor_move(
VALUE obj)
2058 VALUE val = rb_obj_traverse_replace(obj, move_enter, move_leave,
true);
2059 if (!UNDEF_P(val)) {
2063 rb_raise(rb_eRactorError,
"can not move the object");
2067static enum obj_traverse_iterator_result
2070 if (rb_ractor_shareable_p(obj)) {
2071 data->replacement = obj;
2072 return traverse_skip;
2076 return traverse_cont;
2080static enum obj_traverse_iterator_result
2083 return traverse_cont;
2087ractor_copy(
VALUE obj)
2089 VALUE val = rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
2090 if (!UNDEF_P(val)) {
2094 rb_raise(rb_eRactorError,
"can not copy the object");
2109} freed_ractor_local_keys;
2112ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
2115 if (k->type->
mark) (*k->type->
mark)((
void *)val);
2119static enum rb_id_table_iterator_result
2120idkey_local_storage_mark_i(
VALUE val,
void *dmy)
2123 return ID_TABLE_CONTINUE;
2127ractor_local_storage_mark(rb_ractor_t *r)
2129 if (r->local_storage) {
2130 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
2132 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2134 st_data_t val, k = (st_data_t)key;
2135 if (st_delete(r->local_storage, &k, &val) &&
2137 (*key->type->
free)((
void *)val);
2142 if (r->idkey_local_storage) {
2143 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
2146 rb_gc_mark(r->local_storage_store_lock);
2150ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
2153 if (k->type->
free) (*k->type->
free)((
void *)val);
2158ractor_local_storage_free(rb_ractor_t *r)
2160 if (r->local_storage) {
2161 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
2162 st_free_table(r->local_storage);
2165 if (r->idkey_local_storage) {
2166 rb_id_table_free(r->idkey_local_storage);
2171rb_ractor_local_storage_value_mark(
void *
ptr)
2187 rb_ractor_local_storage_value_mark,
2195 key->type =
type ?
type : &ractor_local_storage_type_null;
2196 key->main_cache = (
void *)
Qundef;
2210 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
2211 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
2214 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
2221 if (rb_ractor_main_p()) {
2222 if (!UNDEF_P((
VALUE)key->main_cache)) {
2223 *pret = key->main_cache;
2231 rb_ractor_t *cr = GET_RACTOR();
2233 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
2245 rb_ractor_t *cr = GET_RACTOR();
2247 if (cr->local_storage == NULL) {
2248 cr->local_storage = st_init_numtable();
2251 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)
ptr);
2253 if (rb_ractor_main_p()) {
2254 key->main_cache =
ptr;
2262 if (ractor_local_ref(key, &val)) {
2273 if (ractor_local_ref(key, (
void **)val)) {
2284 ractor_local_set(key, (
void *)val);
2291 if (ractor_local_ref(key, &ret)) {
2302 ractor_local_set(key,
ptr);
2305#define DEFAULT_KEYS_CAPA 0x10
2308rb_ractor_finish_marking(
void)
2310 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2311 ruby_xfree(freed_ractor_local_keys.keys[i]);
2313 freed_ractor_local_keys.cnt = 0;
2314 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
2315 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
2321ractor_local_value(rb_execution_context_t *ec,
VALUE self,
VALUE sym)
2323 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
2325 struct rb_id_table *tbl = cr->idkey_local_storage;
2328 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
2337ractor_local_value_set(rb_execution_context_t *ec,
VALUE self,
VALUE sym,
VALUE val)
2339 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
2341 struct rb_id_table *tbl = cr->idkey_local_storage;
2344 tbl = cr->idkey_local_storage = rb_id_table_create(2);
2346 rb_id_table_insert(tbl,
id, val);
2351 rb_execution_context_t *ec;
2358ractor_local_value_store_i(
VALUE ptr)
2363 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
2368 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
2374ractor_local_value_store_if_absent(rb_execution_context_t *ec,
VALUE self,
VALUE sym)
2376 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
2381 .tbl = cr->idkey_local_storage,
2385 if (data.tbl == NULL) {
2386 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
2388 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
2393 if (!cr->local_storage_store_lock) {
2403ractor_shareable_proc(rb_execution_context_t *ec,
VALUE replace_self,
bool is_lambda)
2405 if (!rb_ractor_shareable_p(replace_self)) {
2406 rb_raise(rb_eRactorIsolationError,
"self should be shareable: %" PRIsVALUE, replace_self);
2410 return rb_proc_ractor_make_shareable(rb_proc_dup(proc), replace_self);
2434RUBY_REFERENCES(cross_ractor_require_refs) = {
2441 "ractor/cross_ractor_require",
2443 RUBY_REFS_LIST_PTR(cross_ractor_require_refs),
2448 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_DECL_MARKING | RUBY_TYPED_EMBEDDABLE
2452require_body(
VALUE crr_obj)
2456 VALUE feature = crr->as.require.feature;
2462 int rb_require_internal_silent(
VALUE fname);
2463 return INT2NUM(rb_require_internal_silent(feature));
2466 return rb_funcallv(
Qnil, require, 1, &feature);
2480require_result_send_body(
VALUE ary)
2485 rb_execution_context_t *ec = GET_EC();
2487 ractor_port_send(ec, port, results,
Qfalse);
2492require_result_send_resuce(
VALUE port,
VALUE errinfo)
2495 ractor_port_send(GET_EC(), port, errinfo,
Qfalse);
2505 const bool silent = crr->silent;
2507 VALUE debug, errinfo;
2510 errinfo = rb_errinfo();
2518 rb_set_errinfo(errinfo);
2523 rb_ary_new_from_args(2, crr->port, rb_ary_new_from_args(2, result, crr->raised ?
Qtrue :
Qfalse)),
2531ractor_require_func(
void *crr_obj)
2533 return ractor_require_protect((
VALUE)crr_obj, require_body);
2537rb_ractor_require(
VALUE feature,
bool silent)
2540 ASSERT_vm_unlocking();
2544 RB_OBJ_SET_SHAREABLE(crr_obj);
2549 crr->raised =
false;
2550 crr->silent = silent;
2552 rb_execution_context_t *ec = GET_EC();
2553 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2554 rb_ractor_interrupt_exec(main_r, ractor_require_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2557 VALUE results = ractor_port_receive(ec, crr->port);
2558 ractor_port_close(ec, crr->port);
2573ractor_require(rb_execution_context_t *ec,
VALUE self,
VALUE feature)
2575 return rb_ractor_require(feature,
false);
2579autoload_load_body(
VALUE crr_obj)
2587ractor_autoload_load_func(
void *crr_obj)
2589 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
2593rb_ractor_autoload_load(
VALUE module,
ID name)
2597 RB_OBJ_SET_SHAREABLE(crr_obj);
2599 RB_OBJ_WRITE(crr_obj, &crr->as.autoload.module, module);
2603 rb_execution_context_t *ec = GET_EC();
2604 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2605 rb_ractor_interrupt_exec(main_r, ractor_autoload_load_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2608 VALUE results = ractor_port_receive(ec, crr->port);
2609 ractor_port_close(ec, crr->port);
2623#include "ractor.rbinc"
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_FETCH_ADD(var, val)
Atomically replaces the value pointed by var with the result of addition of val to the old value of v...
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
@ RUBY_FL_PROMOTED
Ruby objects are "generational".
@ RUBY_FL_SHAREABLE
This flag has something to do with Ractor.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
#define TYPE(_)
Old name of rb_type.
#define T_FILE
Old name of RUBY_T_FILE.
#define FL_PROMOTED
Old name of RUBY_FL_PROMOTED.
#define REALLOC_N
Old name of RB_REALLOC_N.
#define ALLOC
Old name of RB_ALLOC.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define SYM2ID
Old name of RB_SYM2ID.
#define T_DATA
Old name of RUBY_T_DATA.
#define FL_SHAREABLE
Old name of RUBY_FL_SHAREABLE.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define T_HASH
Old name of RUBY_T_HASH.
#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 T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define FL_FREEZE
Old name of RUBY_FL_FREEZE.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
VALUE rb_rescue2(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*r_proc)(VALUE, VALUE), VALUE data2,...)
An equivalent of rescue clause.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eStopIteration
StopIteration exception.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eException
Mother of all exceptions.
VALUE rb_cRactor
Ractor class.
VALUE rb_stdin
STDIN constant.
VALUE rb_stderr
STDERR constant.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_obj_clone(VALUE obj)
Produces a shallow copy of the given object.
VALUE rb_stdout
STDOUT constant.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
#define RGENGC_WB_PROTECTED_STRUCT
This is a compile-time flag to enable/disable write barrier for struct RStruct.
#define RGENGC_WB_PROTECTED_STRING
This is a compile-time flag to enable/disable write barrier for struct RString.
#define RGENGC_WB_PROTECTED_HASH
This is a compile-time flag to enable/disable write barrier for struct RHash.
#define RGENGC_WB_PROTECTED_MATCH
This is a compile-time flag to enable/disable write barrier for struct RMatch.
#define RGENGC_WB_PROTECTED_ARRAY
This is a compile-time flag to enable/disable write barrier for struct RArray.
#define RGENGC_WB_PROTECTED_COMPLEX
This is a compile-time flag to enable/disable write barrier for struct RComplex.
#define RGENGC_WB_PROTECTED_FLOAT
This is a compile-time flag to enable/disable write barrier for struct RFloat.
#define RGENGC_WB_PROTECTED_RATIONAL
This is a compile-time flag to enable/disable write barrier for struct RRational.
#define RGENGC_WB_PROTECTED_REGEXP
This is a compile-time flag to enable/disable write barrier for struct RRegexp.
#define RGENGC_WB_PROTECTED_OBJECT
This is a compile-time flag to enable/disable write barrier for struct RObject.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_pop(VALUE ary)
Destructively deletes an element from the end of the passed array and returns what was deleted.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_block_lambda(void)
Identical to rb_proc_new(), except it returns a lambda.
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
VALUE rb_str_new_frozen(VALUE str)
Creates a frozen copy of the string, if necessary.
VALUE rb_mutex_new(void)
Creates a mutex.
VALUE rb_mutex_synchronize(VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
Obtains the lock, runs the passed function, and releases the lock when it completes.
VALUE rb_autoload_load(VALUE space, ID name)
Kicks the autoload procedure as if it was "touched".
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int len
Length of the buffer.
const struct rb_ractor_local_storage_type rb_ractor_local_storage_type_free
A type of ractor-local storage that destructs itself using ruby_xfree.
VALUE rb_ractor_make_shareable_copy(VALUE obj)
Identical to rb_ractor_make_shareable(), except it returns a (deep) copy of the passed one instead of...
struct rb_ractor_local_key_struct * rb_ractor_local_key_t
(Opaque) struct that holds a ractor-local storage key.
void * rb_ractor_local_storage_ptr(rb_ractor_local_key_t key)
Identical to rb_ractor_local_storage_value() except the return type.
void rb_ractor_local_storage_ptr_set(rb_ractor_local_key_t key, void *ptr)
Identical to rb_ractor_local_storage_value_set() except the parameter type.
rb_ractor_local_key_t rb_ractor_local_storage_ptr_newkey(const struct rb_ractor_local_storage_type *type)
Extended version of rb_ractor_local_storage_value_newkey().
VALUE rb_ractor_stdin(void)
Queries the standard input of the current Ractor that is calling this function.
void rb_ractor_stderr_set(VALUE io)
Assigns an IO to the standard error of the Ractor that is calling this function.
void rb_ractor_local_storage_value_set(rb_ractor_local_key_t key, VALUE val)
Associates the passed value to the passed key.
bool rb_ractor_local_storage_value_lookup(rb_ractor_local_key_t key, VALUE *val)
Queries the key.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
VALUE rb_ractor_make_shareable(VALUE obj)
Destructively transforms the passed object so that multiple Ractors can share it.
rb_ractor_local_key_t rb_ractor_local_storage_value_newkey(void)
Issues a new key.
void rb_ractor_stdout_set(VALUE io)
Assigns an IO to the standard output of the Ractor that is calling this function.
void rb_ractor_stdin_set(VALUE io)
Assigns an IO to the standard input of the Ractor that is calling this function.
VALUE rb_ractor_local_storage_value(rb_ractor_local_key_t key)
Queries the key.
VALUE rb_yield(VALUE val)
Yields the block.
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE rb_proc_new(type *q, VALUE w)
Creates a rb_cProc instance.
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_ivar_foreach(VALUE q, int_type *w, VALUE e)
Iteration over each instance variable of the object.
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
#define DATA_PTR(obj)
Convenient getter macro.
#define RUBY_DEFAULT_FREE
This is a value you can set to RData::dfree.
#define RHASH_SET_IFNONE(h, ifnone)
Destructively updates the default value of the hash.
#define RMATCH(obj)
Convenient casting macro.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
#define TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
#define FilePathValue(v)
Ensures that the parameter object is a path.
#define RTEST
This is an old name of RB_TEST.
Ruby object's base components.
Type that defines a ractor-local storage.
void(*) free(void *ptr)
A function to destruct a ractor-local storage.
void(*) mark(void *ptr)
A function to mark a ractor-local storage.
void rb_native_mutex_lock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_lock.
void rb_native_mutex_unlock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_unlock.
void rb_native_mutex_destroy(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_destroy.
void rb_native_cond_destroy(rb_nativethread_cond_t *cond)
Destroys the passed condition variable.
void rb_native_cond_signal(rb_nativethread_cond_t *cond)
Signals a condition variable.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
@ RUBY_T_MASK
Bitmask of ruby_value_type.