11#include "ractor_core.h"
12#include "internal/array.h"
13#include "internal/class.h"
14#include "internal/complex.h"
15#include "internal/cont.h"
16#include "internal/error.h"
17#include "internal/gc.h"
18#include "internal/hash.h"
19#include "internal/object.h"
20#include "internal/array.h"
21#include "internal/string.h"
22#include "internal/variable.h"
23#include "eval_intern.h"
24#include "internal/io.h"
25#include "internal/load.h"
26#include "internal/marshal.h"
27#include "internal/ractor.h"
28#include "internal/rational.h"
29#include "internal/re.h"
30#include "internal/struct.h"
31#include "internal/st.h"
32#include "internal/thread.h"
33#include "internal/vm.h"
42static VALUE rb_cRactorSelector;
44VALUE rb_eRactorUnsafeError;
45VALUE rb_eRactorIsolationError;
46static VALUE rb_eRactorError;
47static VALUE rb_eRactorRemoteError;
48static VALUE rb_eRactorMovedError;
49static VALUE rb_eRactorClosedError;
50static VALUE rb_cRactorMovedObject;
52static ID id_marshal_dump, id_marshal_load;
53static ID id_dump, id_load, id_dump_data, id_load_data;
55static void vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *r,
const char *file,
int line);
58#if RACTOR_CHECK_MODE > 0
59bool rb_ractor_ignore_belonging_flag =
false;
65ASSERT_ractor_unlocking(rb_ractor_t *r)
67#if RACTOR_CHECK_MODE > 0
68 const rb_execution_context_t *ec = rb_current_ec_noinline();
69 if (ec != NULL && r->sync.locked_by == rb_ractor_self(rb_ec_ractor_ptr(ec))) {
70 rb_bug(
"recursive ractor locking");
76ASSERT_ractor_locking(rb_ractor_t *r)
78#if RACTOR_CHECK_MODE > 0
79 const rb_execution_context_t *ec = rb_current_ec_noinline();
80 if (ec != NULL && r->sync.locked_by != rb_ractor_self(rb_ec_ractor_ptr(ec))) {
81 rp(r->sync.locked_by);
82 rb_bug(
"ractor lock is not acquired.");
88ractor_lock(rb_ractor_t *r,
const char *file,
int line)
90 RUBY_DEBUG_LOG2(file, line,
"locking r:%"PRI_SERIALT_PREFIX
"u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
92 ASSERT_ractor_unlocking(r);
95 const rb_execution_context_t *ec = rb_current_ec_noinline();
97 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
98 VM_ASSERT(!cr->malloc_gc_disabled);
99 cr->malloc_gc_disabled =
true;
102#if RACTOR_CHECK_MODE > 0
104 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
105 r->sync.locked_by = rb_ractor_self(cr);
109 RUBY_DEBUG_LOG2(file, line,
"locked r:%"PRI_SERIALT_PREFIX
"u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
113ractor_lock_self(rb_ractor_t *cr,
const char *file,
int line)
115 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
116#if RACTOR_CHECK_MODE > 0
117 VM_ASSERT(cr->sync.locked_by != cr->pub.self);
119 ractor_lock(cr, file, line);
123ractor_unlock(rb_ractor_t *r,
const char *file,
int line)
125 ASSERT_ractor_locking(r);
126#if RACTOR_CHECK_MODE > 0
127 r->sync.locked_by =
Qnil;
130 const rb_execution_context_t *ec = rb_current_ec_noinline();
132 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
133 VM_ASSERT(cr->malloc_gc_disabled);
134 cr->malloc_gc_disabled =
false;
139 RUBY_DEBUG_LOG2(file, line,
"r:%"PRI_SERIALT_PREFIX
"u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
143ractor_unlock_self(rb_ractor_t *cr,
const char *file,
int line)
145 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
146#if RACTOR_CHECK_MODE > 0
147 VM_ASSERT(cr->sync.locked_by == cr->pub.self);
149 ractor_unlock(cr, file, line);
152#define RACTOR_LOCK(r) ractor_lock(r, __FILE__, __LINE__)
153#define RACTOR_UNLOCK(r) ractor_unlock(r, __FILE__, __LINE__)
154#define RACTOR_LOCK_SELF(r) ractor_lock_self(r, __FILE__, __LINE__)
155#define RACTOR_UNLOCK_SELF(r) ractor_unlock_self(r, __FILE__, __LINE__)
158rb_ractor_lock_self(rb_ractor_t *r)
164rb_ractor_unlock_self(rb_ractor_t *r)
166 RACTOR_UNLOCK_SELF(r);
172ractor_status_str(
enum ractor_status status)
175 case ractor_created:
return "created";
176 case ractor_running:
return "running";
177 case ractor_blocking:
return "blocking";
178 case ractor_terminated:
return "terminated";
180 rb_bug(
"unreachable");
184ractor_status_set(rb_ractor_t *r,
enum ractor_status status)
186 RUBY_DEBUG_LOG(
"r:%"PRI_SERIALT_PREFIX
"u [%s]->[%s]", r->pub.id, ractor_status_str(r->status_), ractor_status_str(status));
189 if (r->status_ != ractor_created) {
190 VM_ASSERT(r == GET_RACTOR());
195 switch (r->status_) {
197 VM_ASSERT(status == ractor_blocking);
200 VM_ASSERT(status == ractor_blocking||
201 status == ractor_terminated);
203 case ractor_blocking:
204 VM_ASSERT(status == ractor_running);
206 case ractor_terminated:
207 rb_bug(
"unreachable");
215ractor_status_p(rb_ractor_t *r,
enum ractor_status status)
217 return rb_ractor_status_p(r, status);
222static void ractor_local_storage_mark(rb_ractor_t *r);
223static void ractor_local_storage_free(rb_ractor_t *r);
225static void ractor_sync_mark(
const struct rb_gc_mark_ctx *ctx, rb_ractor_t *r);
226static void ractor_sync_free(rb_ractor_t *r);
227static size_t ractor_sync_memsize(
const rb_ractor_t *r);
228static void ractor_sync_init(rb_ractor_t *r);
231mark_targeted_hook_list(st_data_t key, st_data_t value, st_data_t _arg)
233 rb_hook_list_t *hook_list = (rb_hook_list_t*)value;
235 if (hook_list->type == hook_list_type_targeted_iseq) {
236 rb_gc_mark((
VALUE)key);
239 rb_method_definition_t *def = (rb_method_definition_t*)key;
240 RUBY_ASSERT(hook_list->type == hook_list_type_targeted_def);
241 rb_gc_mark(def->body.bmethod.proc);
243 rb_hook_list_mark(hook_list);
249ractor_mark_thread(
const struct rb_gc_mark_ctx *ctx, rb_thread_t *th)
251 rb_gc_mark_ctx(ctx, th->self);
255 if (th->root_fiber) {
256 VALUE root_fiber_self = rb_fiberptr_self(th->root_fiber);
257 if (root_fiber_self) rb_gc_mark_ctx(ctx, root_fiber_self);
262 VALUE ec_fiber_self = (th->ec && th->ec->fiber_ptr) ? rb_fiberptr_self(th->ec->fiber_ptr) : 0;
264 rb_gc_mark_ctx(ctx, ec_fiber_self);
267 rb_execution_context_mark_ctx(ctx, th->ec);
272 rb_thread_mark_owned_roots(ctx, th);
276ractor_mark_unshareable_parts(
const struct rb_gc_mark_ctx *ctx, rb_ractor_t *r)
281 rb_gc_mark_ctx(ctx, r->r_stdin);
282 rb_gc_mark_ctx(ctx, r->r_stdout);
283 rb_gc_mark_ctx(ctx, r->r_stderr);
284 rb_gc_mark_ctx(ctx, r->verbose);
285 rb_gc_mark_ctx(ctx, r->debug);
288 ractor_sync_mark(ctx, r);
292 rb_hook_list_mark(&r->pub.hooks);
293 if (r->pub.targeted_hooks.num_entries) {
294 st_foreach(&r->pub.targeted_hooks, mark_targeted_hook_list, 0);
297 if (r->threads.cnt > 0) {
299 ccan_list_for_each(&r->threads.set, th, lt_node) {
300 VM_ASSERT(th != NULL);
301 ractor_mark_thread(ctx, th);
312 if (dying_th) ractor_mark_thread(ctx, dying_th);
314 ractor_local_storage_mark(r);
318static void shareable_p_requests_atfork(rb_ractor_t *r);
321ractor_mark(
void *ptr)
323 rb_ractor_t *r = (rb_ractor_t *)ptr;
324 const struct rb_gc_mark_ctx ctx = rb_gc_current_mark_ctx();
329 rb_gc_mark_ctx(&ctx, r->loc);
330 rb_gc_mark_ctx(&ctx, r->name);
334 rb_gc_mark_ctx(&ctx, r->sync.default_port_value);
338 if (!rb_gc_multi_objspace_p()) {
339 ractor_mark_unshareable_parts(&ctx, r);
340 rb_ractor_mark_terminated_join_value(r);
342 else if (rb_gc_during_global_gc_p()) {
347 rb_ractor_mark_terminated_join_value(r);
355rb_ractor_mark_local_roots(
const struct rb_gc_mark_ctx *ctx, rb_ractor_t *r)
364 rb_ractor_mark_terminated_join_value(r);
365 rb_gc_mark_vm_stack_values((
long)r->registered_marks_cnt, r->registered_marks);
366 rb_gc_mark_registered_addrs(r,
true);
370 rb_gc_mark_ctx(ctx, r->loc);
371 rb_gc_mark_ctx(ctx, r->name);
375 VM_ASSERT(r == rb_current_ractor_raw(
false) || rb_gc_during_global_gc_p());
376 VM_ASSERT(!rb_ractor_status_p(r, ractor_terminated));
377 ractor_mark_unshareable_parts(ctx, r);
382 rb_gc_mark_vm_stack_values((
long)r->registered_marks_cnt, r->registered_marks);
389rb_ractor_mark_terminated_join_value(rb_ractor_t *r)
394 rb_gc_mark_vm_stack_values((
long)numberof(slots), slots);
401rb_ractor_absorb_registered_marks(rb_ractor_t *dst, rb_ractor_t *src)
403 if (src->registered_marks_cnt == 0)
return;
404 size_t need = dst->registered_marks_cnt + src->registered_marks_cnt;
405 if (need > dst->registered_marks_capa) {
406 size_t nc = dst->registered_marks_capa ? dst->registered_marks_capa : 64;
407 while (nc < need) nc *= 2;
408 VALUE *p = realloc(dst->registered_marks, nc *
sizeof(
VALUE));
409 if (!p) rb_bug(
"rb_ractor_absorb_registered_marks: out of memory");
410 dst->registered_marks = p;
411 dst->registered_marks_capa = nc;
413 MEMCPY(dst->registered_marks + dst->registered_marks_cnt,
414 src->registered_marks,
VALUE, src->registered_marks_cnt);
415 dst->registered_marks_cnt = need;
416 src->registered_marks_cnt = 0;
420rb_ractor_absorb_registered_addrs_without_gc(rb_ractor_t *dst, rb_ractor_t *src)
422 rb_vm_t *vm = GET_VM();
425 if (src->registered_addrs_cnt > 0) {
426 size_t need = dst->registered_addrs_cnt + src->registered_addrs_cnt;
427 if (need > dst->registered_addrs_capa) {
428 size_t nc = dst->registered_addrs_capa ? dst->registered_addrs_capa : 64;
429 while (nc < need) nc *= 2;
432 if (!p) rb_bug(
"rb_ractor_absorb_registered_addrs_without_gc: out of memory");
433 dst->registered_addrs = p;
434 dst->registered_addrs_capa = nc;
436 MEMCPY(dst->registered_addrs + dst->registered_addrs_cnt,
438 dst->registered_addrs_cnt = need;
439 src->registered_addrs_cnt = 0;
440 rb_gc_registered_addrs_enroll_without_gc(vm, dst);
442 rb_gc_registered_addrs_unenroll_without_gc(vm, src);
447free_targeted_hook_lists(st_data_t key, st_data_t val, st_data_t _arg)
449 rb_hook_list_t *hook_list = (rb_hook_list_t*)val;
450 rb_hook_list_free(hook_list);
455free_targeted_hooks(st_table *hooks_tbl)
457 st_foreach(hooks_tbl, free_targeted_hook_lists, 0);
463ractor_free(
void *ptr)
465 rb_ractor_t *r = (rb_ractor_t *)ptr;
466 RUBY_DEBUG_LOG(
"free r:%"PRI_SERIALT_PREFIX
"u", rb_ractor_id(r));
468 free_targeted_hooks(&r->pub.targeted_hooks);
469 rb_thread_sched_destroy(&r->threads.sched);
471 ractor_local_storage_free(r);
472 rb_hook_list_free(&r->pub.hooks);
473 rb_st_free_embedded_table(&r->pub.targeted_hooks);
475 if (r->newobj_cache) {
478 rb_gc_ractor_cache_free(r->newobj_cache);
479 r->newobj_cache = NULL;
486 if (r->objspace && !r->main_ractor) {
487 rb_gc_objspace_disown(r->objspace);
493 if (r->in_terminated_set) {
495 ccan_list_del(&r->vmlr_node);
496 r->in_terminated_set =
false;
503 if (!r->main_ractor) {
504 rb_ractor_absorb_registered_marks(GET_VM()->ractor.main_ractor, r);
505 rb_ractor_absorb_registered_addrs_without_gc(GET_VM()->ractor.main_ractor, r);
509 rb_gc_registered_addrs_unenroll_without_gc(GET_VM(), r);
512 free(r->registered_marks);
513 r->registered_marks = NULL;
514 r->registered_marks_cnt = r->registered_marks_capa = 0;
516 free(r->registered_addrs);
517 r->registered_addrs = NULL;
518 r->registered_addrs_cnt = r->registered_addrs_capa = 0;
520 if (!r->main_ractor) {
526targeted_hook_list_memsize_i(st_data_t key, st_data_t val, st_data_t arg)
528 size_t *size = (
size_t *)arg;
529 rb_hook_list_t *hook_list = (rb_hook_list_t *)val;
531 *size +=
sizeof(rb_hook_list_t) + rb_hook_list_memsize(hook_list);
537ractor_memsize(
const void *ptr)
539 rb_ractor_t *r = (rb_ractor_t *)ptr;
540 size_t size =
sizeof(rb_ractor_t);
542 size += ractor_sync_memsize(r);
544 size += rb_st_memsize(&r->pub.targeted_hooks) -
sizeof(
struct st_table);
545 st_foreach(&r->pub.targeted_hooks, targeted_hook_list_memsize_i, (st_data_t)&size);
546 size += rb_hook_list_memsize(&r->pub.hooks);
548 if (r->local_storage) {
549 size += st_memsize(r->local_storage);
551 if (r->idkey_local_storage) {
552 size += rb_id_table_memsize(r->idkey_local_storage);
555 size += r->registered_marks_capa *
sizeof(
VALUE);
562ractor_update_references(
void *ptr)
574 ractor_update_references,
582 if (rb_typeddata_is_kind_of(gv, &ractor_data_type)) {
590static inline rb_ractor_t *
591RACTOR_PTR(
VALUE self)
593 VM_ASSERT(rb_ractor_p(self));
598#define MAIN_RACTOR_ID 1
599static rb_serial_t ractor_last_id = MAIN_RACTOR_ID;
601#include "ractor_sync.c"
612 VM_ASSERT(RB_VM_LOCKED_P() || !rb_multi_ractor_p());
613 return ++ractor_last_id;
617vm_insert_ractor0(rb_vm_t *vm, rb_ractor_t *r,
bool single_ractor_mode)
619 RUBY_DEBUG_LOG(
"r:%"PRI_SERIALT_PREFIX
"u ractor.cnt:%u++", r->pub.id, vm->ractor.cnt);
620 VM_ASSERT(single_ractor_mode || RB_VM_LOCKED_P());
625 if (vm->ractor.cnt == 1) {
629 ccan_list_add_tail(&vm->ractor.set, &r->vmlr_node);
632 if (r->newobj_cache) {
633 VM_ASSERT(r == ruby_single_main_ractor);
636 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
641cancel_single_ractor_mode(
void)
644 RUBY_DEBUG_LOG(
"enable multi-ractor mode");
646 ruby_single_main_ractor = NULL;
647 rb_yjit_invalidate_single_ractor();
648 rb_zjit_invalidate_single_ractor();
650 ASSERT_vm_unlocking();
655vm_insert_ractor(rb_vm_t *vm, rb_ractor_t *r)
657 VM_ASSERT(ractor_status_p(r, ractor_created));
659 if (rb_multi_ractor_p()) {
662 vm_insert_ractor0(vm, r,
false);
663 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
667 rb_ractor_t *cur = rb_current_ractor_raw(
false);
668 if (cur && cur->creating_child_objspace == r->objspace) {
669 cur->creating_child_objspace = NULL;
675 if (vm->ractor.cnt == 0) {
677 vm_insert_ractor0(vm, r,
true);
678 ractor_status_set(r, ractor_blocking);
679 ractor_status_set(r, ractor_running);
682 cancel_single_ractor_mode();
683 vm_insert_ractor0(vm, r,
true);
684 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
688 rb_ractor_t *cur = rb_current_ractor_raw(
false);
689 if (cur && cur->creating_child_objspace == r->objspace) {
690 cur->creating_child_objspace = NULL;
697vm_remove_ractor(rb_vm_t *vm, rb_ractor_t *cr)
699 VM_ASSERT(ractor_status_p(cr, ractor_running));
700 VM_ASSERT(vm->ractor.cnt > 1);
701 VM_ASSERT(cr->threads.cnt == 1);
705 RUBY_DEBUG_LOG(
"ractor.cnt:%u-- terminate_waiting:%d",
706 vm->ractor.cnt, vm->ractor.sync.terminate_waiting);
708 VM_ASSERT(vm->ractor.cnt > 0);
709 ccan_list_del(&cr->vmlr_node);
714 if (!rb_gc_multi_objspace_p()) {
716 ccan_list_add(&vm->ractor.terminated_set, &cr->vmlr_node);
717 cr->in_terminated_set =
true;
721 if (vm->ractor.cnt <= 2 && vm->ractor.sync.terminate_waiting) {
725 rb_gc_ractor_cache_free(cr->newobj_cache);
726 cr->newobj_cache = NULL;
736 rb_gc_objspace_retire(&cr->objspace);
740 ractor_status_set(cr, ractor_terminated);
751 rb_ractor_t *
const cr = th->ractor;
752 VM_ASSERT(cr != GET_VM()->ractor.main_ractor);
753 VM_ASSERT(th->ec != NULL);
756 const bool fiber_wrapped = fiber && rb_fiberptr_self(fiber) != 0;
761 cr->postmortem = rb_gc_multi_objspace_p() && !rb_thread_event_hooks_registered_p();
762 rb_gc_objspace_postmortem_self();
766 pf->th = (th->self == 0) ? th : NULL;
767 pf->fiber = (fiber_wrapped && rb_fiberptr_self(fiber) == 0) ? fiber : NULL;
773 if (pf->fiber == NULL && pf->th == NULL)
return;
778#ifdef RB_THREAD_LOCAL_SPECIFIER
779 rb_current_ec_set(NULL);
781 native_tls_set(ruby_current_ec_key, NULL);
785 if (pf->fiber) rb_fiber_free_body(pf->fiber);
786 if (pf->th) rb_thread_free_body(pf->th);
790ractor_alloc(
VALUE klass)
796 r->next_ec_serial = 1;
797 VM_ASSERT(ractor_status_p(r, ractor_created));
801static rb_ractor_t _main_ractor = {
804 .pub.id = MAIN_RACTOR_ID,
810static void shareable_p_init(
void);
813rb_ractor_main_alloc(
void)
815 rb_ractor_t *r = &_main_ractor;
819 ruby_single_main_ractor = r;
824#if defined(HAVE_WORKING_FORK)
828rb_ractor_atfork(rb_vm_t *vm, rb_thread_t *th)
832 vm->ractor.blocking_cnt = 0;
835 rb_gc_disable_holders_atfork();
839 th->ractor->creating_child_objspace = NULL;
841 shareable_p_requests_atfork(th->ractor);
842 ractor_reply_port_atfork(th->ractor);
843 ruby_single_main_ractor = th->ractor;
844 th->ractor->status_ = ractor_created;
846 ractor_sync_atfork(th->ractor);
847 rb_ractor_living_threads_init(th->ractor);
848 rb_ractor_living_threads_insert(th->ractor, th);
850 VM_ASSERT(vm->ractor.blocking_cnt == 0);
851 VM_ASSERT(vm->ractor.cnt == 1);
855rb_ractor_terminate_atfork(rb_vm_t *vm, rb_ractor_t *r)
857 rb_gc_ractor_cache_free(r->newobj_cache);
858 r->newobj_cache = NULL;
859 r->status_ = ractor_terminated;
861 r->threads.dying_th = NULL;
862 if (!rb_gc_multi_objspace_p()) {
863 ccan_list_del(&r->vmlr_node);
864 ccan_list_add(&vm->ractor.terminated_set, &r->vmlr_node);
865 r->in_terminated_set =
true;
871 rb_gc_objspace_retire(&r->objspace);
873 ractor_sync_terminate_atfork(vm, r);
880rb_ractor_living_threads_init(rb_ractor_t *r)
882 ccan_list_head_init(&r->threads.set);
884 r->threads.blocking_cnt = 0;
885 r->threads.terminating =
false;
887 r->threads.dying_th = NULL;
891ractor_init(rb_ractor_t *r,
VALUE name,
VALUE loc)
894 st_init_existing_numtable_with_size(&r->pub.targeted_hooks, 0);
895 r->pub.hooks.type = hook_list_type_ractor_local;
898 rb_thread_sched_init(&r->threads.sched,
false);
899 rb_ractor_living_threads_init(r);
905 enc = rb_enc_get(name);
906 if (!rb_enc_asciicompat(enc)) {
907 rb_raise(rb_eArgError,
"ASCII incompatible encoding (%s)",
919rb_ractor_main_setup(rb_vm_t *vm, rb_ractor_t *r, rb_thread_t *th)
924 r->threads.main = th;
925 rb_ractor_living_threads_insert(r, th);
926 rb_ractor_setup_default_port(r);
938 block = rb_proc_ractor_make_shareable(rb_proc_dup(block),
Qnil);
940 VALUE rv = ractor_alloc(self);
941 rb_ractor_t *r = RACTOR_PTR(rv);
942 ractor_init(r, name, loc);
945 r->pub.id = ractor_next_id();
947 RUBY_DEBUG_LOG(
"r:%"PRI_SERIALT_PREFIX
"u", r->pub.id);
949 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
950 r->verbose = cr->verbose;
951 r->debug = cr->debug;
955 r->objspace = rb_gc_objspace_alloc();
956 rb_gc_objspace_set_ractor(r->objspace, r);
958 rb_thread_create_ractor(r, args, block);
969 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
974ractor_atexit(rb_execution_context_t *ec, rb_ractor_t *cr,
VALUE result,
bool exc)
976 ractor_notify_exit(ec, cr, result, exc);
984 ractor_postmortem_collect(th, pf);
985 ractor_send_exit_tokens(th->ec, th->ractor);
989rb_ractor_atexit(rb_execution_context_t *ec,
VALUE result)
991 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
992 ractor_atexit(ec, cr, result,
false);
996rb_ractor_atexit_exception(rb_execution_context_t *ec)
998 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
999 ractor_atexit(ec, cr, ec->errinfo,
true);
1002static void ractor_shareable_p_close(rb_ractor_t *cr);
1005rb_ractor_teardown(rb_execution_context_t *ec)
1007 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
1010 ractor_shareable_p_close(cr);
1014 VM_ASSERT(cr->threads.main != NULL);
1015 cr->threads.main = NULL;
1020rb_ractor_receive_parameters(rb_execution_context_t *ec, rb_ractor_t *r,
int len,
VALUE *ptr)
1022 for (
int i=0; i<
len; i++) {
1023 ptr[i] = ractor_receive(ec, ractor_default_port(r), NULL);
1028rb_ractor_send_parameters(rb_execution_context_t *ec, rb_ractor_t *r,
VALUE args)
1031 for (
int i=0; i<
len; i++) {
1032 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
1037rb_ractor_main_p_(
void)
1039 VM_ASSERT(rb_multi_ractor_p());
1040 rb_execution_context_t *ec = GET_EC();
1041 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
1045rb_ractor_living_thread_num(
const rb_ractor_t *r)
1047 return r->threads.cnt;
1052rb_ractor_thread_list(
void)
1054 rb_ractor_t *r = GET_RACTOR();
1055 rb_thread_t *th = 0;
1058 ccan_list_for_each(&r->threads.set, th, lt_node) {
1059 switch (th->status) {
1060 case THREAD_RUNNABLE:
1061 case THREAD_STOPPED:
1062 case THREAD_STOPPED_FOREVER:
1073rb_ractor_living_threads_insert(rb_ractor_t *r, rb_thread_t *th)
1075 VM_ASSERT(th != NULL);
1079 RUBY_DEBUG_LOG(
"r(%"PRI_SERIALT_PREFIX
"u)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
1080 ccan_list_add_tail(&r->threads.set, &th->lt_node);
1086 if (r->threads.cnt == 1) {
1087 VM_ASSERT(ractor_status_p(r, ractor_created));
1088 vm_insert_ractor(th->vm, r);
1093vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *r,
const char *file,
int line)
1095 ractor_status_set(r, ractor_blocking);
1097 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
1098 vm->ractor.blocking_cnt++;
1099 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
1103rb_vm_ractor_blocking_cnt_inc(rb_vm_t *vm, rb_ractor_t *cr,
const char *file,
int line)
1105 ASSERT_vm_locking();
1106 VM_ASSERT(GET_RACTOR() == cr);
1107 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
1111rb_vm_ractor_blocking_cnt_dec(rb_vm_t *vm, rb_ractor_t *cr,
const char *file,
int line)
1113 ASSERT_vm_locking();
1114 VM_ASSERT(GET_RACTOR() == cr);
1116 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
1117 VM_ASSERT(vm->ractor.blocking_cnt > 0);
1118 vm->ractor.blocking_cnt--;
1120 ractor_status_set(cr, ractor_running);
1123static void ractor_shareable_p_cancel(rb_ractor_t *r);
1129rb_ractor_cancel_creation(rb_ractor_t *r, rb_thread_t *th)
1133 ccan_list_del(&th->lt_node);
1140 rb_vm_t *vm = th->vm;
1141 VM_ASSERT(vm->ractor.cnt > 1);
1142 ccan_list_del(&r->vmlr_node);
1147 VM_ASSERT(r->status_ == ractor_blocking);
1148 VM_ASSERT(vm->ractor.blocking_cnt > 0);
1149 vm->ractor.blocking_cnt--;
1151 rb_gc_ractor_cache_free(r->newobj_cache);
1152 r->newobj_cache = NULL;
1155 rb_gc_objspace_disown(r->objspace);
1158 ractor_shareable_p_cancel(r);
1159 r->status_ = ractor_terminated;
1165rb_ractor_living_threads_remove(rb_ractor_t *cr, rb_thread_t *th)
1167 VM_ASSERT(cr == GET_RACTOR());
1168 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
1170 if (cr->threads.cnt == 1) {
1171 vm_remove_ractor(th->vm, cr);
1176 ccan_list_del(&th->lt_node);
1186rb_ractor_blocking_threads_inc(rb_ractor_t *cr,
const char *file,
int line)
1188 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
1190 VM_ASSERT(cr->threads.cnt > 0);
1191 VM_ASSERT(cr == GET_RACTOR());
1193 cr->threads.blocking_cnt++;
1197rb_ractor_blocking_threads_dec(rb_ractor_t *cr,
const char *file,
int line)
1199 RUBY_DEBUG_LOG2(file, line,
1200 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
1201 cr->threads.blocking_cnt, cr->threads.cnt);
1203 VM_ASSERT(cr == GET_RACTOR());
1205 cr->threads.blocking_cnt--;
1209rb_ractor_vm_barrier_interrupt_running_thread(rb_ractor_t *r)
1211 VM_ASSERT(r != GET_RACTOR());
1212 ASSERT_ractor_unlocking(r);
1213 ASSERT_vm_locking();
1217 if (ractor_status_p(r, ractor_running)) {
1218 rb_execution_context_t *ec = r->threads.running_ec;
1220 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
1228rb_ractor_terminate_interrupt_main_thread(rb_ractor_t *r)
1230 VM_ASSERT(r != GET_RACTOR());
1231 ASSERT_ractor_unlocking(r);
1232 ASSERT_vm_locking();
1234 rb_thread_t *main_th = r->threads.main;
1236 if (main_th->status != THREAD_KILLED) {
1237 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
1238 rb_threadptr_interrupt(main_th);
1241 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
1246void rb_thread_terminate_all(rb_thread_t *th);
1249ractor_terminal_interrupt_all(rb_vm_t *vm)
1251 if (vm->ractor.cnt > 1) {
1254 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1255 if (r != vm->ractor.main_ractor) {
1256 RUBY_DEBUG_LOG(
"r:%"PRI_SERIALT_PREFIX
"u", rb_ractor_id(r));
1257 rb_ractor_terminate_interrupt_main_thread(r);
1263void rb_add_running_thread(rb_thread_t *th);
1264void rb_del_running_thread(rb_thread_t *th);
1267rb_ractor_terminate_all(
void)
1269 rb_vm_t *vm = GET_VM();
1270 rb_ractor_t *cr = vm->ractor.main_ractor;
1272 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
1274 VM_ASSERT(cr == GET_RACTOR());
1278 ractor_terminal_interrupt_all(vm);
1281 rb_thread_terminate_all(GET_THREAD());
1285 while (vm->ractor.cnt > 1) {
1286 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
1287 vm->ractor.sync.terminate_waiting =
true;
1290 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
1291 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
1292 rb_ractor_sched_wait_terminate(vm, &vm->ractor.sync.terminate_cond, 1000 );
1293 while (vm->ractor.sched.barrier_is_waiting) {
1300 RB_VM_LOCK_ENTER_LEV_NB(&lev);
1302 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
1303 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
1305 ractor_terminal_interrupt_all(vm);
1312 rb_gc_objspace_absorb_all_zombies();
1315rb_execution_context_t *
1316rb_vm_main_ractor_ec(rb_vm_t *vm)
1332 rb_execution_context_t *running_ec = vm->ractor.main_ractor->threads.running_ec;
1333 if (running_ec) {
return running_ec; }
1334 return vm->ractor.main_thread->ec;
1338ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
1340 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
1435static unsigned int shareable_p_pjob;
1436static void ractor_shareable_p_drain(
void *);
1446 rb_eRactorIsolationError = rb_define_class_under(
rb_cRactor,
"IsolationError", rb_eRactorError);
1447 rb_eRactorRemoteError = rb_define_class_under(
rb_cRactor,
"RemoteError", rb_eRactorError);
1448 rb_eRactorMovedError = rb_define_class_under(
rb_cRactor,
"MovedError", rb_eRactorError);
1450 rb_eRactorUnsafeError = rb_define_class_under(
rb_cRactor,
"UnsafeError", rb_eRactorError);
1454 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
1457 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
1461 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
1462 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
1463 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
1464 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1479 rb_vm_t *vm = GET_VM();
1482 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1483 if (r != vm->ractor.main_ractor) {
1484 fprintf(stderr,
"r:%"PRI_SERIALT_PREFIX
"u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1492 if (rb_ractor_main_p()) {
1496 rb_ractor_t *cr = GET_RACTOR();
1497 if (UNLIKELY(cr->r_stdin == 0)) {
1498 cr->r_stdin = rb_io_prep_stdin();
1507 if (rb_ractor_main_p()) {
1511 rb_ractor_t *cr = GET_RACTOR();
1512 if (UNLIKELY(cr->r_stdout == 0)) {
1513 cr->r_stdout = rb_io_prep_stdout();
1515 return cr->r_stdout;
1522 if (rb_ractor_main_p()) {
1526 rb_ractor_t *cr = GET_RACTOR();
1527 if (UNLIKELY(cr->r_stderr == 0)) {
1528 cr->r_stderr = rb_io_prep_stderr();
1530 return cr->r_stderr;
1537 if (rb_ractor_main_p()) {
1541 rb_ractor_t *cr = GET_RACTOR();
1549 if (rb_ractor_main_p()) {
1553 rb_ractor_t *cr = GET_RACTOR();
1561 if (rb_ractor_main_p()) {
1565 rb_ractor_t *cr = GET_RACTOR();
1572rb_ractor_targeted_hooks(rb_ractor_t *cr)
1574 return &cr->pub.targeted_hooks;
1578rb_obj_set_shareable_no_assert(
VALUE obj)
1585 rb_gc_obj_became_shareable(obj);
1589 bool froze_ivars =
false;
1593 RBASIC_SET_SHAPE_ID(obj, rb_shape_transition_frozen(RBASIC_SHAPE_ID(obj)));
1604 VALUE fields = rb_obj_fields_no_ractor_check(obj);
1605 if (imemo_type_p(fields, imemo_fields)) {
1608 rb_gc_obj_became_shareable(fields);
1610 if (froze_ivars) RBASIC_SET_SHAPE_ID(fields, RBASIC_SHAPE_ID(obj));
1614 rb_imemo_fields_record_shrefs(fields);
1619#ifndef STRICT_VERIFY_SHAREABLE
1620#define STRICT_VERIFY_SHAREABLE 0
1624rb_ractor_verify_shareable(
VALUE obj)
1626#if STRICT_VERIFY_SHAREABLE
1627 rb_gc_verify_shareable(obj);
1637 rb_obj_set_shareable_no_assert(obj);
1649enum obj_traverse_iterator_result {
1655typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1656typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1657typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1659static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1662 rb_obj_traverse_enter_func enter_func;
1663 rb_obj_traverse_leave_func leave_func;
1682 if (obj_traverse_i(key, d->data)) {
1687 if (obj_traverse_i(val, d->data)) {
1697zombie_writable_p(
VALUE obj)
1699 return RB_VM_LOCKED_P() && rb_gc_obj_in_zombie_objspace_p(obj);
1703#define ASSERT_traversable(obj) \
1704 VM_ASSERT(!rb_objspace_foreign_object_p(obj) || zombie_writable_p(obj), "%s", rb_obj_info(obj))
1707traverse_child_p(
VALUE obj)
1710 return rb_objspace_live_object_p(obj) ||
1711 (!
SPECIAL_CONST_P(obj) && RB_VM_LOCKED_P() && rb_gc_obj_live_in_zombie_objspace_p(obj));
1715obj_traverse_reachable_i(
VALUE obj,
void *ptr)
1722 if (!traverse_child_p(obj)) {
1728 if (obj_traverse_i(obj, d->data)) {
1741 if (RB_VM_LOCKED_P()) {
1742 rb_objspace_reachable_objects_from_locked(obj, obj_traverse_reachable_i, &d);
1745 rb_objspace_reachable_objects_from_local(obj, obj_traverse_reachable_i, &d);
1750static struct st_table *
1753 if (UNLIKELY(!data->rec)) {
1754 data->rec_hash = rb_ident_hash_new();
1756 data->rec = RHASH_ST_TABLE(data->rec_hash);
1762obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t ptr)
1766 if (obj_traverse_i(val, d->data)) {
1779 switch (data->enter_func(obj)) {
1780 case traverse_cont:
break;
1781 case traverse_skip:
return 0;
1782 case traverse_stop:
return 1;
1785 ASSERT_traversable(obj);
1787 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1793 if (rb_obj_shape_has_ivars(obj)) {
1799 if (d.stop)
return 1;
1819 if (obj_traverse_i(e, data))
return 1;
1833 if (d.stop)
return 1;
1840 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1843 if (obj_traverse_i(ptr[i], data))
return 1;
1849 if (obj_traverse_i(
RMATCH(obj)->str, data))
return 1;
1853 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1854 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1857 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1858 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1863 void *
const ptr = RTYPEDDATA_GET_DATA(obj);
1866 if (!ptr || !
type->function.dmark) {
1869 else if (
type->flags & RUBY_TYPED_DECL_MARKING) {
1870 const size_t *offsets = (
const size_t *)(uintptr_t)
type->function.dmark;
1871 for (; *offsets != RUBY_REF_END; offsets++) {
1872 VALUE ref = *(
VALUE *)((
char *)ptr + *offsets);
1873 if (obj_traverse_i(ref, data))
return 1;
1877 if (obj_traverse_reachable(obj, data))
return 1;
1884 if (obj_traverse_reachable(obj, data))
return 1;
1893 rb_bug(
"unreachable");
1896 if (data->leave_func(obj) == traverse_stop) {
1905 rb_obj_traverse_final_func final_func;
1910obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1913 if (data->final_func(key)) {
1923rb_obj_traverse(
VALUE obj,
1924 rb_obj_traverse_enter_func enter_func,
1925 rb_obj_traverse_leave_func leave_func,
1926 rb_obj_traverse_final_func final_func)
1929 .enter_func = enter_func,
1930 .leave_func = leave_func,
1934 if (obj_traverse_i(obj, &data))
return 1;
1935 if (final_func && data.rec) {
1937 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1944allow_frozen_shareable_p(
VALUE obj)
1954 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1963make_shareable_freeze(
VALUE obj)
1966 if (klass ==
rb_cString && BASIC_OP_UNREDEFINED_P(BOP_FREEZE, STRING_REDEFINED_OP_FLAG)) {
1969 else if (klass ==
rb_cArray && BASIC_OP_UNREDEFINED_P(BOP_FREEZE, ARRAY_REDEFINED_OP_FLAG)) {
1972 else if (klass ==
rb_cHash && BASIC_OP_UNREDEFINED_P(BOP_FREEZE, HASH_REDEFINED_OP_FLAG)) {
1973 rb_hash_freeze(obj);
1980static enum obj_traverse_iterator_result
1981make_shareable_check_shareable_freeze(
VALUE obj,
enum obj_traverse_iterator_result result)
1984 make_shareable_freeze(obj);
1987 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1991 return traverse_skip;
1998static int obj_refer_only_shareables_p(
VALUE obj);
2000static enum obj_traverse_iterator_result
2001make_shareable_check_shareable(
VALUE obj)
2006 return traverse_skip;
2008 else if (rb_objspace_foreign_object_p(obj)) {
2009 rb_raise(rb_eRactorIsolationError,
"can not make shareable an object owned by another Ractor");
2011 else if (!allow_frozen_shareable_p(obj)) {
2013 rb_raise(rb_eRactorError,
2014 "can not make shareable object for %+"PRIsVALUE, obj);
2016 else if (
RTYPEDDATA_TYPE(obj)->flags & RUBY_TYPED_FROZEN_SHAREABLE_NO_REC) {
2017 if (obj_refer_only_shareables_p(obj)) {
2018 make_shareable_check_shareable_freeze(obj, traverse_skip);
2020 return traverse_skip;
2023 rb_raise(rb_eRactorError,
2024 "can not make shareable object for %+"PRIsVALUE
" because it refers unshareable objects", obj);
2028 rb_proc_ractor_make_shareable(obj,
Qundef);
2029 return traverse_cont;
2032 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
2036 switch (
TYPE(obj)) {
2038 return traverse_skip;
2045 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
2046 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
2047 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
2048 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
2057 return make_shareable_check_shareable_freeze(obj, traverse_cont);
2060static enum obj_traverse_iterator_result
2061mark_shareable(
VALUE obj)
2064 rb_str_make_independent(obj);
2067 rb_ary_cancel_sharing(obj);
2070 rb_obj_set_shareable_no_assert(obj);
2071 return traverse_cont;
2077 rb_obj_traverse(obj,
2078 make_shareable_check_shareable,
2079 null_leave, mark_shareable);
2088 VALUE copy = ractor_copy(obj);
2093rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
2096 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
2104rb_ractor_ensure_main_ractor(
const char *msg)
2106 if (!rb_ractor_main_p()) {
2107 rb_raise(rb_eRactorIsolationError,
"%s", msg);
2111static enum obj_traverse_iterator_result
2112shareable_p_enter(
VALUE obj)
2115 return traverse_skip;
2121 ASSERT_traversable(obj);
2122 mark_shareable(obj);
2123 return traverse_skip;
2125 else if (rb_objspace_foreign_object_p(obj) && !zombie_writable_p(obj)) {
2127 return traverse_stop;
2130 allow_frozen_shareable_p(obj)) {
2131 return traverse_cont;
2139 if (obj_refer_only_shareables_p(obj)) {
2140 mark_shareable(obj);
2141 return traverse_skip;
2145 return traverse_stop;
2149rb_ractor_shareable_p_continue(
VALUE obj)
2151 if (rb_obj_traverse(obj,
2152 shareable_p_enter, null_leave,
2161static enum obj_traverse_iterator_result
2162null_leave(
VALUE obj)
2164 return traverse_cont;
2180 rb_obj_traverse_replace_enter_func enter_func;
2181 rb_obj_traverse_replace_leave_func leave_func;
2187 VALUE rec_keepalive;
2200obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
2206obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t ptr,
int exists)
2211 if (obj_traverse_replace_i(*key, data)) {
2215 else if (*key != data->replacement) {
2216 VALUE v = *key = data->replacement;
2220 if (obj_traverse_replace_i(*val, data)) {
2224 else if (*val != data->replacement) {
2225 VALUE v = *val = data->replacement;
2233obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
2239obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t ptr,
int exists)
2244 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
2248 else if (*(
VALUE *)val != data->replacement) {
2256static struct st_table *
2259 if (UNLIKELY(!data->rec)) {
2260 data->rec = st_init_numtable();
2267obj_refer_only_shareables_p_i(
VALUE obj,
void *ptr)
2269 int *pcnt = (
int *)ptr;
2271 if (!traverse_child_p(obj)) {
2281obj_refer_only_shareables_p(
VALUE obj)
2284 if (RB_VM_LOCKED_P()) {
2285 rb_objspace_reachable_objects_from_locked(obj, obj_refer_only_shareables_p_i, &cnt);
2288 rb_objspace_reachable_objects_from_local(obj, obj_refer_only_shareables_p_i, &cnt);
2296 st_data_t replacement;
2299 data->replacement = obj;
2306 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
2307 data->replacement = (
VALUE)replacement;
2311 switch (data->enter_func(obj, data)) {
2312 case traverse_cont:
break;
2313 case traverse_skip:
return 0;
2314 case traverse_stop:
return 1;
2317 replacement = (st_data_t)data->replacement;
2318 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
2327#define CHECK_AND_REPLACE(parent_obj, v) do { \
2329 if (obj_traverse_replace_i(_val, data)) { return 1; } \
2330 else if (data->replacement != _val) { RB_OBJ_WRITE(parent_obj, &v, data->replacement); } \
2333 if (UNLIKELY(rb_obj_gen_fields_p(obj))) {
2334 VALUE fields_obj = rb_obj_fields_no_ractor_check(obj);
2336 if (UNLIKELY(rb_obj_shape_complex_p(obj))) {
2342 rb_st_foreach_with_replace(
2343 rb_imemo_fields_complex_tbl(fields_obj),
2344 obj_iv_hash_traverse_replace_foreach_i,
2345 obj_iv_hash_traverse_replace_i,
2348 if (d.stop)
return 1;
2351 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
2352 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
2353 for (uint32_t i = 0; i < fields_count; i++) {
2354 CHECK_AND_REPLACE(fields_obj, fields[i]);
2368 rb_str_make_independent(obj);
2373 VALUE fields_obj = ROBJECT_FIELDS_OBJ(obj);
2374 shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
2375 if (rb_shape_complex_p(shape_id)) {
2381 rb_st_foreach_with_replace(
2382 rb_imemo_fields_complex_tbl(fields_obj),
2383 obj_iv_hash_traverse_replace_foreach_i,
2384 obj_iv_hash_traverse_replace_i,
2387 if (d.stop)
return 1;
2390 attr_index_t
len = RSHAPE_LEN(shape_id);
2391 VALUE *ptr = rb_imemo_fields_ptr(fields_obj);
2393 for (attr_index_t i = 0; i <
len; i++) {
2394 CHECK_AND_REPLACE(obj, ptr[i]);
2402 rb_ary_cancel_sharing(obj);
2407 if (obj_traverse_replace_i(e, data)) {
2410 else if (e != data->replacement) {
2424 rb_hash_stlike_foreach_with_replace(obj,
2425 obj_hash_traverse_replace_foreach_i,
2426 obj_hash_traverse_replace_i,
2428 if (d.stop)
return 1;
2432 if (obj_traverse_replace_i(ifnone, data)) {
2435 else if (ifnone != data->replacement) {
2444 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
2447 CHECK_AND_REPLACE(obj, ptr[i]);
2453 CHECK_AND_REPLACE(obj,
RMATCH(obj)->str);
2457 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->num);
2458 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->den);
2461 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->real);
2462 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->imag);
2466 if (!data->move && obj_refer_only_shareables_p(obj)) {
2470 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
2484 rb_bug(
"unreachable");
2487 data->replacement = (
VALUE)replacement;
2489 if (data->leave_func(obj, data) == traverse_stop) {
2500rb_obj_traverse_replace(
VALUE obj,
2501 rb_obj_traverse_replace_enter_func enter_func,
2502 rb_obj_traverse_replace_leave_func leave_func,
2506 .enter_func = enter_func,
2507 .leave_func = leave_func,
2514 int stopped = obj_traverse_replace_i(obj, &data);
2518 if (data.rec) st_free_table(data.rec);
2525 return data.replacement;
2535enum courier_node_kind {
2537 COURIER_KIND_BACKTRACE,
2538 COURIER_KIND_STRING,
2541 COURIER_KIND_OBJECT,
2542 COURIER_KIND_STRUCT,
2545 COURIER_KIND_REGEXP,
2546 COURIER_KIND_HOOKED,
2553 COURIER_HOOK_MARSHAL_DUMP,
2555 COURIER_HOOK_COMPAT,
2556 COURIER_HOOK_DUMP_DATA,
2560static enum courier_hook
2561courier_hook_of(
VALUE obj)
2563 if (
rb_obj_respond_to(obj, id_marshal_dump, TRUE))
return COURIER_HOOK_MARSHAL_DUMP;
2565 if (rb_marshal_compat_lookup(
CLASS_OF(obj), NULL, NULL))
return COURIER_HOOK_COMPAT;
2567 return COURIER_HOOK_NONE;
2571 enum courier_node_kind kind;
2580 struct {
char *ptr;
rb_len_t len, capa;
int encidx;
VALUE klass; } str;
2582 struct {
long size; uint32_t *kv; uint32_t ifnone_id;
bool compare_by_id;
bool proc_default;
VALUE klass; } hash;
2583 struct {
VALUE klass; } obj;
2584 struct {
rb_len_t len; uint32_t *elems;
VALUE klass; } strct;
2585 struct { uint32_t regexp_id, str_id;
int num_regs;
void *regs;
VALUE klass; } match;
2586 struct {
void *blob;
int size; } bt;
2587 struct {
VALUE src;
int options;
VALUE klass; } re;
2588 struct {
VALUE klass; uint32_t payload_id;
enum courier_hook hook; } hooked;
2595 uint32_t pathv_id, ecopts_id, wc_pre_ecopts_id, wc_asciicompat_id, timeout_id;
2603#define COURIER_ID_REF_BIT 0x80000000u
2611 uint32_t refs_count;
2639 uint32_t
capa = c->capa ? c->capa * 2 : 8;
2645 ruby_xfree(old_nodes);
2652 uint32_t
capa = c->refs_capa ? c->refs_capa * 2 : 8;
2654 if (c->refs_count > 0)
MEMCPY(refs, c->refs,
VALUE, c->refs_count);
2655 VALUE *old_refs = c->refs;
2657 c->refs_capa =
capa;
2658 ruby_xfree(old_refs);
2664 if (RB_UNLIKELY(c->count == c->capa)) courier_grow_nodes(c);
2669 n->kind = COURIER_KIND_REF;
2685 c->order =
ALLOC_N(uint32_t, nodes);
2690 c->refs_capa = refs;
2702 if (RB_UNLIKELY(c->refs_count == c->refs_capa)) courier_grow_refs(c);
2703 c->refs[c->refs_count] = v;
2704 return COURIER_ID_REF_BIT | c->refs_count++;
2711 if (
id & COURIER_ID_REF_BIT)
return c->refs[
id & ~COURIER_ID_REF_BIT];
2718move_neutralize_source(
VALUE obj)
2723 shape_id_t shape_id = (RBASIC_SHAPE_ID(obj) & SHAPE_ID_CAPACITY_MASK) |
2724 ROOT_SHAPE_ID | SHAPE_ID_LAYOUT_ROBJECT | SHAPE_ID_FL_FROZEN;
2734 bool wipe_body =
true;
2737 if (!STR_EMBED_P(obj) && !rb_str_reembeddable_p(obj)) {
2742 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
2744 RBASIC_SET_FULL_SHAPE_ID(obj, (shape_id & ~SHAPE_ID_LAYOUT_MASK) | SHAPE_ID_LAYOUT_OTHER);
2748 wipe_body = !rb_str_embedded_shared_root_p(obj);
2751 if (!ARY_EMBED_P(obj) && !ARY_SHARED_P(obj) && (ARY_SHARED_ROOT_P(obj) ||
OBJ_FROZEN(obj))) {
2756 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
2758 RBASIC_SET_FULL_SHAPE_ID(obj, (shape_id & ~SHAPE_ID_LAYOUT_MASK) | SHAPE_ID_LAYOUT_OTHER);
2759 if (!ARY_SHARED_ROOT_P(obj)) {
2762 RARRAY(obj)->as.heap.len = 0;
2766 wipe_body = !rb_ary_embedded_shared_root_p(obj);
2778 size_t slot_size = rb_gc_obj_slot_size(obj);
2779 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
2780 RBASIC(obj)->flags = flags;
2781 RBASIC_SET_FULL_SHAPE_ID(obj, shape_id);
2799courier_capture_hash_i(st_data_t key, st_data_t val, st_data_t arg)
2802 uint32_t kid = courier_capture(hc->b, (
VALUE)key);
2803 uint32_t vid = courier_capture(hc->b, (
VALUE)val);
2804 hc->kv[hc->i++] = kid;
2805 hc->kv[hc->i++] = vid;
2818courier_capture_ivar_i(
ID name,
VALUE val, st_data_t arg)
2821 if (oc->n == oc->capa) {
2822 oc->capa = oc->capa ? oc->capa * 2 : 4;
2824 REALLOC_N(oc->vals, uint32_t, oc->capa);
2826 uint32_t vid = courier_capture(oc->b, val);
2827 oc->ids[oc->n] = name;
2828 oc->vals[oc->n] = vid;
2840 rb_ivar_foreach_buffered(obj, courier_capture_ivar_i, (st_data_t)&oc);
2841 b->c->nodes[id].niv = (uint32_t)oc.n;
2842 b->c->nodes[id].iv_ids = oc.ids;
2843 b->c->nodes[id].iv_vals = oc.vals;
2851courier_capture_hooked(
struct courier_build *b,
VALUE obj, uint32_t
id,
enum courier_hook hook)
2857 case COURIER_HOOK_DUMP: {
2866 case COURIER_HOOK_MARSHAL_DUMP:
2867 payload =
rb_funcallv(obj, id_marshal_dump, 0, 0);
2869 case COURIER_HOOK_DUMP_DATA:
2872 case COURIER_HOOK_COMPAT: {
2874 rb_marshal_compat_lookup(klass, &dumper, NULL);
2875 payload = dumper(obj);
2879 rb_bug(
"courier_capture_hooked: no dump protocol");
2882 uint32_t payload_id = courier_capture(b, payload);
2884 b->c->nodes[id].kind = COURIER_KIND_HOOKED;
2885 b->c->nodes[id].u.hooked.klass = klass;
2886 b->c->nodes[id].u.hooked.hook = hook;
2887 b->c->nodes[id].u.hooked.payload_id = payload_id;
2907 return courier_alloc_ref(b->c, obj);
2915 if (st_lookup(b->c->seen, (st_data_t)obj, &existing)) {
2916 return (uint32_t)existing - 1;
2920 return courier_alloc_ref(b->c, obj);
2923 ASSERT_traversable(obj);
2924 uint32_t
id = courier_alloc_node(b->c);
2925 st_insert(b->c->seen, (st_data_t)obj, (st_data_t)(uintptr_t)(
id + 1));
2929 rb_raise(rb_eRactorError,
"can not move an uninitialized IO");
2933 b->c->nodes[id].frozen = frozen;
2934 courier_capture_ivars(b, obj,
id);
2941 if (!b->copy) rb_str_make_independent(obj);
2946 const int termlen = rb_enc_mbminlen(rb_enc_from_index(encidx));
2949 if (!b->copy && !STR_EMBED_P(obj) && rb_str_reembeddable_p(obj)) {
2952 ptr =
RSTRING(obj)->as.heap.ptr;
2960 if (
len) memcpy(ptr, RSTRING_PTR(obj),
len);
2961 memset(ptr +
len, 0, termlen);
2964 b->c->nodes[id].kind = COURIER_KIND_STRING;
2965 b->c->nodes[id].u.str.klass = courier_klass(b, obj);
2966 b->c->nodes[id].u.str.ptr = ptr;
2967 b->c->nodes[id].u.str.len =
len;
2968 b->c->nodes[id].u.str.capa =
capa;
2969 b->c->nodes[id].u.str.encidx = encidx;
2977 elems[i] = courier_capture(b,
RARRAY_AREF(obj, i));
2979 b->c->nodes[id].kind = COURIER_KIND_ARRAY;
2980 b->c->nodes[id].u.ary.klass = courier_klass(b, obj);
2981 b->c->nodes[id].u.ary.len =
len;
2982 b->c->nodes[id].u.ary.elems = elems;
2986 if (!b->copy && !ARY_EMBED_P(obj) && !ARY_SHARED_P(obj) && !ARY_SHARED_ROOT_P(obj) && !
OBJ_FROZEN(obj)) {
2993 uint32_t ifnone_id = courier_capture(b,
RHASH_IFNONE(obj));
2996 uint32_t *kv = size ?
ALLOC_N(uint32_t, size * 2) : NULL;
2998 rb_hash_stlike_foreach(obj, courier_capture_hash_i, (st_data_t)&hc);
2999 b->c->nodes[id].kind = COURIER_KIND_HASH;
3000 b->c->nodes[id].u.hash.klass = courier_klass(b, obj);
3001 b->c->nodes[id].u.hash.size = size;
3002 b->c->nodes[id].u.hash.kv = kv;
3003 b->c->nodes[id].u.hash.ifnone_id = ifnone_id;
3004 b->c->nodes[id].u.hash.compare_by_id =
RTEST(rb_hash_compare_by_id_p(obj));
3005 b->c->nodes[id].u.hash.proc_default =
FL_TEST_RAW(obj, RHASH_PROC_DEFAULT) != 0;
3007 if (!b->copy) rb_hash_free(obj);
3012 b->c->nodes[id].kind = COURIER_KIND_OBJECT;
3013 b->c->nodes[id].u.obj.klass = courier_klass(b, obj);
3020 elems[i] = courier_capture(b,
RSTRUCT_GET(obj, (
int)i));
3022 b->c->nodes[id].kind = COURIER_KIND_STRUCT;
3023 b->c->nodes[id].u.strct.len =
len;
3024 b->c->nodes[id].u.strct.elems = elems;
3025 b->c->nodes[id].u.strct.klass = courier_klass(b, obj);
3027 if (!b->copy && RSTRUCT_EMBED_LEN(obj) == 0) {
3028 ruby_xfree((
void *)RSTRUCT_CONST_PTR(obj));
3038 void *regs = rb_match_blob_dump(obj, &re, &st, &nregs, !b->copy);
3039 uint32_t rid = courier_capture(b, re);
3040 uint32_t sid = courier_capture(b, st);
3041 b->c->nodes[id].kind = COURIER_KIND_MATCH;
3042 b->c->nodes[id].u.match.regexp_id = rid;
3043 b->c->nodes[id].u.match.str_id = sid;
3044 b->c->nodes[id].u.match.num_regs = nregs;
3045 b->c->nodes[id].u.match.regs = regs;
3046 b->c->nodes[id].u.match.klass = courier_klass(b, obj);
3052 VM_ASSERT(!b->copy);
3058 uint32_t pathv_id = courier_capture(b, fptr->
pathv);
3059 uint32_t ecopts_id = courier_capture(b, fptr->
encs.
ecopts);
3062 uint32_t timeout_id = courier_capture(b, fptr->
timeout);
3070 fptr->wakeup_mutex =
Qnil;
3072 b->c->nodes[id].kind = COURIER_KIND_IO;
3073 b->c->nodes[id].u.io.fptr = fptr;
3074 b->c->nodes[id].u.io.klass = courier_klass(b, obj);
3075 b->c->nodes[id].u.io.pathv_id = pathv_id;
3076 b->c->nodes[id].u.io.ecopts_id = ecopts_id;
3077 b->c->nodes[id].u.io.wc_pre_ecopts_id = wc_pre_id;
3078 b->c->nodes[id].u.io.wc_asciicompat_id = wc_ac_id;
3079 b->c->nodes[id].u.io.timeout_id = timeout_id;
3090 b->c->nodes[id].kind = COURIER_KIND_REGEXP;
3091 b->c->nodes[id].u.re.klass = courier_klass(b, obj);
3092 b->c->nodes[id].u.re.src = src;
3100 if (b->copy && rb_backtrace_p(obj)) {
3102 void *blob = rb_backtrace_blob_dump(obj, &size);
3103 b->c->nodes[id].kind = COURIER_KIND_BACKTRACE;
3104 b->c->nodes[id].u.bt.blob = blob;
3105 b->c->nodes[id].u.bt.size = size;
3112 enum courier_hook hook = b->copy ? courier_hook_of(obj) : COURIER_HOOK_NONE;
3113 if (hook == COURIER_HOOK_NONE) {
3114 rb_raise(rb_eRactorError,
"can not %s a %"PRIsVALUE
" object",
3117 courier_capture_hooked(b, obj,
id, hook);
3122 if (!b->copy) move_neutralize_source(obj);
3124 b->c->order[b->ordered++] = id;
3131 uint32_t nodes, refs;
3137move_preflight_ivar_i(
ID name,
VALUE val, st_data_t arg)
3144move_preflight_hash_i(st_data_t key, st_data_t val, st_data_t arg)
3157 st_table *
const seen = ctx->seen;
3163 if (st_lookup(seen, (st_data_t)obj, NULL))
return;
3164 ASSERT_traversable(obj);
3165 st_insert(seen, (st_data_t)obj, 0);
3172 rb_class_check_singleton_movable(klass);
3181 move_preflight(rm->
regexp, ctx);
3182 move_preflight(rm->
str, ctx);
3191 rb_hash_stlike_foreach(obj, move_preflight_hash_i, (st_data_t)ctx);
3202 rb_raise(rb_eRactorError,
"can not move an uninitialized IO");
3207 rb_raise(rb_eRactorError,
"can not move an IO tied to a writer IO");
3209 if (
RTEST(fptr->wakeup_mutex)) {
3211 rb_raise(rb_eRactorError,
"can not move an IO that is being closed");
3213 move_preflight(fptr->
pathv, ctx);
3217 move_preflight(fptr->
timeout, ctx);
3221 rb_raise(rb_eRactorError,
"can not move a %"PRIsVALUE
" object",
3233 uint32_t nodes, refs;
3240copy_support_val_i(st_data_t val, st_data_t arg)
3243 if (!copy_courier_supported_p((
VALUE)val, ctx)) {
3251copy_support_ivar_i(
ID name,
VALUE val, st_data_t arg)
3253 return copy_support_val_i((st_data_t)val, arg);
3257copy_support_hash_i(st_data_t key, st_data_t val, st_data_t arg)
3259 if (copy_support_val_i(key, arg) == ST_STOP)
return ST_STOP;
3260 return copy_support_val_i(val, arg);
3267 st_table *
const seen = ctx->seen;
3273 if (st_lookup(seen, (st_data_t)obj, NULL))
return true;
3274 ASSERT_traversable(obj);
3275 st_insert(seen, (st_data_t)obj, 0);
3287 if (!copy_courier_supported_p(rm->
regexp, ctx))
return false;
3288 if (!copy_courier_supported_p(rm->
str, ctx))
return false;
3293 if (!rb_backtrace_p(obj) && courier_hook_of(obj) == COURIER_HOOK_NONE)
return false;
3297 if (!copy_courier_supported_p(
RARRAY_AREF(obj, i), ctx))
return false;
3301 rb_hash_stlike_foreach(obj, copy_support_hash_i, (st_data_t)ctx);
3302 if (!ctx->ok)
return false;
3303 if (!copy_courier_supported_p(
RHASH_IFNONE(obj), ctx))
return false;
3307 if (!copy_courier_supported_p(
RSTRUCT_GET(obj, (
int)i), ctx))
return false;
3314 if (courier_hook_of(obj) == COURIER_HOOK_NONE)
return false;
3329 bool ok = copy_courier_supported_p(obj, &scan);
3330 st_free_table(scan.seen);
3331 if (!ok)
return NULL;
3335 courier_reserve(c, scan.nodes, scan.refs);
3336 c->seen = st_init_numtable();
3343 enum ruby_tag_type state;
3344 rb_execution_context_t *ec = GET_EC();
3346 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
3347 c->root = courier_capture(&b, obj);
3350 st_free_table(c->seen);
3353 if (state != TAG_NONE) EC_JUMP_TAG(ec, state);
3366 enum ruby_tag_type state;
3367 rb_execution_context_t *ec = GET_EC();
3369 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
3370 move_preflight(obj, &scan);
3373 st_free_table(scan.seen);
3374 if (state != TAG_NONE) EC_JUMP_TAG(ec, state);
3378 courier_reserve(c, scan.nodes, scan.refs);
3379 c->seen = st_init_numtable();
3387 enum ruby_tag_type state;
3388 rb_execution_context_t *ec = GET_EC();
3390 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
3391 c->root = courier_capture(&b, obj);
3394 st_free_table(c->seen);
3396 if (state != TAG_NONE) {
3400 EC_JUMP_TAG(ec, state);
3412 RBASIC_SET_CLASS(shell, klass);
3417 rb_class_take_ownership(klass);
3430 for (uint32_t i = 0; i < c->count; i++) {
3434 case COURIER_KIND_REF:
3437 case COURIER_KIND_STRING:
3441 shell = rb_str_new_owned(n->u.str.ptr, n->u.str.len, n->u.str.capa, n->u.str.encidx);
3442 n->u.str.ptr = NULL;
3443 courier_apply_klass(shell, n->u.str.klass);
3445 case COURIER_KIND_ARRAY:
3447 courier_apply_klass(shell, n->u.ary.klass);
3449 case COURIER_KIND_HASH:
3450 shell = n->u.hash.compare_by_id ? rb_ident_hash_new() : rb_hash_new();
3451 courier_apply_klass(shell, n->u.hash.klass);
3453 case COURIER_KIND_OBJECT:
3457 courier_apply_klass(shell, n->u.obj.klass);
3459 case COURIER_KIND_STRUCT:
3461 courier_apply_klass(shell, n->u.strct.klass);
3463 case COURIER_KIND_MATCH:
3464 shell = rb_match_blob_alloc(
rb_class_real(n->u.match.klass), n->u.match.num_regs);
3465 courier_apply_klass(shell, n->u.match.klass);
3467 case COURIER_KIND_BACKTRACE:
3468 shell = rb_backtrace_blob_load(n->u.bt.blob, n->u.bt.size);
3470 case COURIER_KIND_REGEXP:
3473 shell = rb_reg_init_str(rb_reg_s_alloc(
rb_class_real(n->u.re.klass)), n->u.re.src, n->u.re.options);
3474 courier_apply_klass(shell, n->u.re.klass);
3476 case COURIER_KIND_HOOKED:
3477 if (n->u.hooked.hook == COURIER_HOOK_DUMP) {
3484 courier_apply_klass(shell, n->u.hooked.klass);
3486 case COURIER_KIND_IO:
3488 courier_apply_klass(shell, n->u.io.klass);
3489 RFILE(shell)->fptr = n->u.io.fptr;
3490 n->u.io.fptr->
self = shell;
3491 n->u.io.fptr = NULL;
3494 rb_bug(
"rb_ractor_courier_materialize: bad node kind");
3505 for (uint32_t k = 0; k < c->count; k++) {
3506 uint32_t i = c->order[k];
3510 case COURIER_KIND_ARRAY: {
3517 RARRAY_ASET(shell, j, courier_child(c, shells, n->u.ary.elems[j]));
3522 case COURIER_KIND_HASH:
3523 for (
long j = 0; j < n->u.hash.size; j++) {
3524 rb_hash_aset(shell, courier_child(c, shells, n->u.hash.kv[2 * j]),
3525 courier_child(c, shells, n->u.hash.kv[2 * j + 1]));
3528 VALUE ifnone = courier_child(c, shells, n->u.hash.ifnone_id);
3529 if (n->u.hash.proc_default) {
3530 rb_hash_set_default_proc(shell, ifnone);
3532 else if (ifnone !=
Qnil) {
3533 rb_hash_set_default(shell, ifnone);
3536 case COURIER_KIND_HOOKED: {
3537 VALUE payload = courier_child(c, shells, n->u.hooked.payload_id);
3538 VALUE klass = n->u.hooked.klass;
3540 switch (n->u.hooked.hook) {
3541 case COURIER_HOOK_DUMP:
3543 rb_raise(
rb_eTypeError,
"class %"PRIsVALUE
" needs to have method '_load'", klass);
3551 case COURIER_HOOK_MARSHAL_DUMP:
3552 case COURIER_HOOK_DUMP_DATA:
3553 mid = n->u.hooked.hook == COURIER_HOOK_MARSHAL_DUMP ? id_marshal_load : id_load_data;
3555 rb_raise(
rb_eTypeError,
"instance of %"PRIsVALUE
" needs to have method '%"PRIsVALUE
"'",
3556 klass, rb_id2str(mid));
3560 case COURIER_HOOK_COMPAT: {
3562 rb_marshal_compat_lookup(klass, NULL, &loader);
3563 loader(shell, payload);
3567 rb_bug(
"rb_ractor_courier_materialize: no dump protocol");
3571 case COURIER_KIND_STRUCT:
3572 for (
rb_len_t j = 0; j < n->u.strct.len; j++) {
3573 RSTRUCT_SET(shell, (
int)j, courier_child(c, shells, n->u.strct.elems[j]));
3576 case COURIER_KIND_MATCH:
3577 rb_match_blob_load(shell, courier_child(c, shells, n->u.match.regexp_id),
3578 courier_child(c, shells, n->u.match.str_id),
3579 n->u.match.num_regs, n->u.match.regs);
3581 case COURIER_KIND_IO: {
3596 for (uint32_t j = 0; j < n->niv; j++) {
3597 rb_ivar_set(shell, n->iv_ids[j], courier_child(c, shells, n->iv_vals[j]));
3602 for (uint32_t i = 0; i < c->count; i++) {
3609 VALUE root = (c->count || c->refs_count) ? courier_child(c, shells, c->root) :
Qnil;
3617 for (uint32_t i = 0; i < c->count; i++) {
3619 ruby_xfree(n->iv_ids);
3620 ruby_xfree(n->iv_vals);
3622 case COURIER_KIND_STRING:
3623 ruby_xfree(n->u.str.ptr);
3625 case COURIER_KIND_ARRAY:
3626 ruby_xfree(n->u.ary.elems);
3628 case COURIER_KIND_HASH:
3629 ruby_xfree(n->u.hash.kv);
3631 case COURIER_KIND_STRUCT:
3632 ruby_xfree(n->u.strct.elems);
3634 case COURIER_KIND_MATCH:
3635 rb_match_blob_free(n->u.match.regs);
3637 case COURIER_KIND_BACKTRACE:
3638 ruby_xfree(n->u.bt.blob);
3640 case COURIER_KIND_IO:
3646 n->u.io.fptr = NULL;
3653 ruby_xfree(c->nodes);
3654 ruby_xfree(c->order);
3655 ruby_xfree(c->refs);
3664rb_ractor_courier_mark(
const struct rb_gc_mark_ctx *ctx,
struct rb_ractor_courier *c)
3667 if (c->seen) rb_mark_set(c->seen);
3668 for (uint32_t i = 0; i < c->refs_count; i++) {
3669 rb_gc_mark_ctx(ctx, c->refs[i]);
3671 for (uint32_t i = 0; i < c->count; i++) {
3673 if (n->kind == COURIER_KIND_REF) {
3674 rb_gc_mark_ctx(ctx, n->u.ref);
3676 else if (n->kind == COURIER_KIND_OBJECT) {
3677 rb_gc_mark_ctx(ctx, n->u.obj.klass);
3679 else if (n->kind == COURIER_KIND_STRUCT) {
3680 rb_gc_mark_ctx(ctx, n->u.strct.klass);
3682 else if (n->kind == COURIER_KIND_MATCH) {
3683 rb_gc_mark_ctx(ctx, n->u.match.klass);
3685 else if (n->kind == COURIER_KIND_IO) {
3686 rb_gc_mark_ctx(ctx, n->u.io.klass);
3688 else if (n->kind == COURIER_KIND_STRING) {
3689 rb_gc_mark_ctx(ctx, n->u.str.klass);
3691 else if (n->kind == COURIER_KIND_BACKTRACE) {
3692 rb_backtrace_blob_mark_ctx(ctx, n->u.bt.blob, n->u.bt.size);
3694 else if (n->kind == COURIER_KIND_ARRAY) {
3695 rb_gc_mark_ctx(ctx, n->u.ary.klass);
3697 else if (n->kind == COURIER_KIND_HASH) {
3698 rb_gc_mark_ctx(ctx, n->u.hash.klass);
3700 else if (n->kind == COURIER_KIND_REGEXP) {
3701 rb_gc_mark_ctx(ctx, n->u.re.src);
3702 rb_gc_mark_ctx(ctx, n->u.re.klass);
3704 else if (n->kind == COURIER_KIND_HOOKED) {
3705 rb_gc_mark_ctx(ctx, n->u.hooked.klass);
3714ractor_native_shallow_copy(
VALUE obj)
3728 rb_obj_copy_ivar(copy, obj);
3731 copy = rb_enc_str_new(RSTRING_PTR(obj), RSTRING_LEN(obj), rb_enc_get(obj));
3737 copy = rb_hash_dup(obj);
3741 rb_struct_init_copy(copy, obj);
3745 rb_match_init_copy(copy, obj);
3750 if (rb_backtrace_p(obj)) {
3751 copy = rb_backtrace_dup(obj);
3763 UNLIKELY(rb_obj_gen_fields_p(obj))) {
3773 RBASIC_SET_SHAPE_ID(copy, rb_obj_shape_transition_frozen(copy));
3778static enum obj_traverse_iterator_result
3782 data->replacement = obj;
3783 return traverse_skip;
3786 VALUE copy = ractor_native_shallow_copy(obj);
3787 if (UNDEF_P(copy))
return traverse_stop;
3788 data->replacement = copy;
3789 return traverse_cont;
3793static enum obj_traverse_iterator_result
3796 return traverse_cont;
3802ractor_copy_native_try(
VALUE obj)
3804 return rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
3810ractor_copy(
VALUE obj)
3812 VALUE copy = ractor_copy_native_try(obj);
3813 if (UNDEF_P(copy)) {
3815 ractor_marshal_dump_rescue, obj,
3832} freed_ractor_local_keys;
3836ractor_local_keys_purge(st_table *local_storage)
3838 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
3840 st_data_t val, k = (st_data_t)key;
3841 if (st_delete(local_storage, &k, &val) &&
3843 (*key->type->free)((
void *)val);
3850ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
3853 if (k->type->
mark) (*k->type->
mark)((
void *)val);
3857static enum rb_id_table_iterator_result
3858idkey_local_storage_mark_i(
VALUE val,
void *dmy)
3861 return ID_TABLE_CONTINUE;
3865ractor_local_storage_mark(rb_ractor_t *r)
3867 if (r->local_storage) {
3868 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
3873 if (rb_gc_single_objspace_p() || rb_gc_during_global_gc_p()) {
3874 ractor_local_keys_purge(r->local_storage);
3878 if (r->idkey_local_storage) {
3879 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
3882 rb_gc_mark(r->local_storage_store_lock);
3886ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
3889 if (k->type->
free) (*k->type->
free)((
void *)val);
3894ractor_local_storage_free(rb_ractor_t *r)
3896 if (r->local_storage) {
3897 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
3898 st_free_table(r->local_storage);
3901 if (r->idkey_local_storage) {
3902 rb_id_table_free(r->idkey_local_storage);
3907rb_ractor_local_storage_value_mark(
void *ptr)
3909 rb_gc_mark((
VALUE)ptr);
3923 rb_ractor_local_storage_value_mark,
3931 key->type =
type ?
type : &ractor_local_storage_type_null;
3932 key->main_cache = (
void *)
Qundef;
3946 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
3947 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
3948 SIZED_REALLOC_N(freed_ractor_local_keys.keys,
rb_ractor_local_key_t, freed_ractor_local_keys.capa, freed_ractor_local_keys.cnt);
3950 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
3957 if (rb_ractor_main_p()) {
3958 if (!UNDEF_P((
VALUE)key->main_cache)) {
3959 *pret = key->main_cache;
3967 rb_ractor_t *cr = GET_RACTOR();
3969 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
3981 rb_ractor_t *cr = GET_RACTOR();
3983 if (cr->local_storage == NULL) {
3984 cr->local_storage = st_init_numtable();
3987 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)ptr);
3989 if (rb_ractor_main_p()) {
3990 key->main_cache = ptr;
3998 if (ractor_local_ref(key, &val)) {
4009 if (ractor_local_ref(key, (
void **)val)) {
4020 ractor_local_set(key, (
void *)val);
4027 if (ractor_local_ref(key, &ret)) {
4038 ractor_local_set(key, ptr);
4041#define DEFAULT_KEYS_CAPA 0x10
4044rb_ractor_finish_marking(
bool full_mark)
4049 if (!(rb_gc_single_objspace_p() || rb_gc_during_global_gc_p())) {
4056 rb_vm_t *vm = GET_VM();
4059 for (
size_t zi = 0; zi < vm->gc.zombie_objspaces_count; zi++) {
4060 rb_ractor_t *owner = vm->gc.zombie_objspaces[zi].owner;
4061 if (owner == NULL || owner->local_storage == NULL)
continue;
4062 ractor_local_keys_purge(owner->local_storage);
4065 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
4066 SIZED_FREE(freed_ractor_local_keys.keys[i]);
4068 freed_ractor_local_keys.cnt = 0;
4069 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
4070 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
4071 SIZED_REALLOC_N(freed_ractor_local_keys.keys,
rb_ractor_local_key_t, DEFAULT_KEYS_CAPA, freed_ractor_local_keys.capa);
4076 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
4077 rb_ractor_reap_dead_ports(r);
4079 if (vm->ractor.cnt == 0 && vm->ractor.main_ractor) {
4080 rb_ractor_reap_dead_ports(vm->ractor.main_ractor);
4086ractor_local_value(rb_execution_context_t *ec,
VALUE self,
VALUE sym)
4088 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
4090 struct rb_id_table *tbl = cr->idkey_local_storage;
4093 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
4102ractor_local_value_set(rb_execution_context_t *ec,
VALUE self,
VALUE sym,
VALUE val)
4104 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
4106 struct rb_id_table *tbl = cr->idkey_local_storage;
4109 tbl = cr->idkey_local_storage = rb_id_table_create(2);
4111 rb_id_table_insert(tbl,
id, val);
4116 rb_execution_context_t *ec;
4123ractor_local_value_store_i(
VALUE ptr)
4128 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
4133 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
4139ractor_local_value_store_if_absent(rb_execution_context_t *ec,
VALUE self,
VALUE sym)
4141 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
4146 .tbl = cr->idkey_local_storage,
4150 if (data.tbl == NULL) {
4151 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
4153 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
4158 if (!cr->local_storage_store_lock) {
4168ractor_shareable_proc(rb_execution_context_t *ec,
VALUE replace_self,
bool is_lambda)
4171 rb_raise(rb_eRactorIsolationError,
"self should be shareable: %" PRIsVALUE, replace_self);
4175 return rb_proc_ractor_make_shareable(rb_proc_dup(proc), replace_self);
4200RUBY_REFERENCES(cross_ractor_require_refs) = {
4207 "ractor/cross_ractor_require",
4209 RUBY_REFS_LIST_PTR(cross_ractor_require_refs),
4214 0, 0, RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_DECL_MARKING | RUBY_TYPED_EMBEDDABLE
4218require_body(
VALUE crr_obj)
4222 VALUE feature = crr->as.require.feature;
4228 int rb_require_internal_silent(
VALUE fname);
4229 return INT2NUM(rb_require_internal_silent(feature));
4246require_result_send_body(
VALUE ary)
4253 ractor_reply_send_value(GET_EC(), RACTOR_PTR(crr->reader), crr->port_id, results);
4258require_result_send_resuce(
VALUE crr_obj,
VALUE errinfo)
4263 ractor_reply_send_value(GET_EC(), RACTOR_PTR(crr->reader), crr->port_id, errinfo);
4273 const bool silent = crr->silent;
4275 VALUE debug, errinfo;
4286 rb_set_errinfo(errinfo);
4291 rb_ary_new_from_args(2, crr_obj, rb_ary_new_from_args(2, result, crr->raised ?
Qtrue :
Qfalse)),
4299ractor_require_func(
void *crr_obj)
4301 return ractor_require_protect((
VALUE)crr_obj, require_body);
4310cross_ractor_require_wait_body(
VALUE arg)
4313 w->results = ractor_reply_port_receive(GET_EC(), w->port);
4318cross_ractor_require_wait_release(
VALUE arg)
4321 rb_execution_context_t *
const ec = GET_EC();
4322 ractor_reply_port_release(ec, rb_ec_ractor_ptr(ec), w->port, UNDEF_P(w->results));
4330 rb_ractor_t *
const cr = GET_RACTOR();
4333 crr->port_id = ractor_port_id(RACTOR_PORT_PTR(w.port));
4335 rb_ractor_interrupt_exec(GET_VM()->ractor.main_ractor, func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
4336 rb_ensure(cross_ractor_require_wait_body, (
VALUE)&w, cross_ractor_require_wait_release, (
VALUE)&w);
4337 if (UNDEF_P(w.results)) rb_raise(rb_eRactorClosedError,
"The ractor has terminated");
4339 VALUE results = w.results;
4345rb_ractor_require(
VALUE feature,
bool silent)
4348 ASSERT_vm_unlocking();
4352 if (rb_feature_provided_ractor_safe(feature)) {
4360 RB_OBJ_WRITE(crr_obj, &crr->as.require.feature, feature);
4361 crr->raised =
false;
4362 crr->silent = silent;
4364 VALUE results = cross_ractor_require_on_main(crr_obj, crr, ractor_require_func);
4379#define SHAREABLE_P_CLOSED ((struct class_field_shareable_p *)1)
4385 struct ccan_list_node inflight;
4397enum { SHAREABLE_P_PENDING, SHAREABLE_P_DONE, SHAREABLE_P_WAITING, SHAREABLE_P_ABANDONED };
4399static rb_nativethread_lock_t shareable_p_inflight_lock;
4400static CCAN_LIST_HEAD(shareable_p_inflight);
4403shareable_p_init(
void)
4410shareable_p_new(rb_ractor_t *cr,
VALUE val)
4413 if (!c) rb_bug(
"shareable_p_new: out of memory");
4415 c->reader = cr->pub.self;
4416 c->state = SHAREABLE_P_PENDING;
4418 ccan_list_add(&shareable_p_inflight, &c->inflight);
4427 ccan_list_del(&c->inflight);
4434rb_ractor_mark_shareable_p_inflight(
const struct rb_gc_mark_ctx *ctx)
4438 ccan_list_for_each(&shareable_p_inflight, c, inflight) {
4439 rb_gc_mark_ctx(ctx, c->val);
4440 rb_gc_mark_ctx(ctx, c->reader);
4447shareable_p_here(
VALUE val)
4454shareable_p_requests_atfork(rb_ractor_t *r)
4458 ccan_list_for_each_safe(&shareable_p_inflight, c, next, inflight) {
4459 if (c->state != SHAREABLE_P_DONE && c->reply) ractor_basket_free(c->reply);
4460 shareable_p_free(c);
4462 r->shareable_p_requests = NULL;
4467shareable_p_pop(rb_ractor_t *cr)
4472 if (!head || head == SHAREABLE_P_CLOSED)
return NULL;
4481 VALUE val = c->val, reader = c->reader;
4483 const VALUE result = rb_protect(shareable_p_here, val, &state);
4485 if (state) rb_set_errinfo(
Qnil);
4486 c->shareable = !state && !UNDEF_P(result);
4489 if (st == SHAREABLE_P_WAITING) {
4491 const st_data_t port_id = c->port_id;
4492 st =
RUBY_ATOMIC_CAS(c->state, SHAREABLE_P_WAITING, SHAREABLE_P_DONE);
4494 if (st == SHAREABLE_P_WAITING) ractor_reply_send(GET_EC(), RACTOR_PTR(reader), port_id, reply);
4496 if (st == SHAREABLE_P_ABANDONED) {
4497 if (c->reply) ractor_basket_free(c->reply);
4498 shareable_p_free(c);
4506ractor_shareable_p_drain(
void *
_)
4508 rb_ractor_t *
const cr = GET_RACTOR();
4510 while ((c = shareable_p_pop(cr)) != NULL) ractor_shareable_p_one(c);
4515ractor_shareable_p_close(rb_ractor_t *cr)
4517 bool closed =
false;
4519 ractor_shareable_p_drain(NULL);
4529ractor_shareable_p_cancel(rb_ractor_t *r)
4531 ASSERT_vm_locking();
4532 VM_ASSERT(r->shareable_p_requests == NULL);
4533 r->shareable_p_requests = SHAREABLE_P_CLOSED;
4541 rb_thread_t *
const main_th = r->threads.main;
4542 if (!main_th)
return false;
4546 if (head == SHAREABLE_P_CLOSED)
return false;
4553 rb_postponed_job_trigger_for_ractor(shareable_p_pjob, r->pub.self);
4556 RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(main_th->ec);
4557 rb_threadptr_interrupt(main_th);
4576shareable_p_wait_body(
VALUE arg)
4580 rb_ractor_t *
const cr = GET_RACTOR();
4581 if (cr->sync.ports) {
4583 w->port = ractor_reply_port_acquire(cr);
4584 c->reply = ractor_reply_basket_new();
4585 c->port_id = ractor_port_id(RACTOR_PORT_PTR(w->port));
4587 if (
RUBY_ATOMIC_CAS(c->state, SHAREABLE_P_PENDING, SHAREABLE_P_WAITING) == SHAREABLE_P_PENDING) {
4588 if (UNDEF_P(ractor_reply_port_receive(GET_EC(), w->port))) shareable_p_poll(c, SHAREABLE_P_WAITING);
4591 ractor_basket_free(c->reply);
4596 shareable_p_poll(c, SHAREABLE_P_PENDING);
4603shareable_p_wait_release(
VALUE arg)
4606 rb_execution_context_t *
const ec = GET_EC();
4607 bool pending =
false;
4613 if (st == SHAREABLE_P_DONE) {
4614 shareable_p_free(c);
4618 if (
RUBY_ATOMIC_CAS(c->state, st, SHAREABLE_P_ABANDONED) == st)
break;
4621 if (
RTEST(w->port)) ractor_reply_port_release(ec, rb_ec_ractor_ptr(ec), w->port, pending);
4633 const bool shareable = c->shareable;
4634 shareable_p_free(c);
4639shareable_p_sleep(
VALUE _)
4647ractor_living_by_id(rb_serial_t
id)
4649 ASSERT_vm_locking();
4650 VM_ASSERT(!rb_gc_multi_objspace_p());
4651 rb_vm_t *
const vm = GET_VM();
4652 if (
id == 0)
return vm->ractor.main_ractor;
4654 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
4655 if (rb_ractor_id(r) ==
id)
return r;
4664rb_class_field_shareable_p(
VALUE klass,
VALUE val)
4669 VM_ASSERT(!rb_class_owned_p(klass));
4670 ASSERT_vm_unlocking();
4672 rb_ractor_t *
const cr = GET_RACTOR();
4675 const bool multi_objspace = rb_gc_multi_objspace_p();
4678 rb_ractor_t *
const main_r = GET_VM()->ractor.main_ractor;
4679 if (multi_objspace && rb_gc_obj_in_objspace_p(main_r->objspace, val)) {
4681 shareable_p_free(c);
4687 enum { HERE, DONE, PUSHED, RETRY } st;
4692 rb_ractor_t *
const r = multi_objspace ? rb_gc_obj_ractor(val) : ractor_living_by_id(RCLASS_OWNER_RACTOR_ID(klass));
4700 result = rb_protect(shareable_p_here, val, &state);
4704 st = shareable_p_push(r, c) ? PUSHED : RETRY;
4708 case HERE: shareable_p_free(c);
return !UNDEF_P(shareable_p_here(val));
4710 shareable_p_free(c);
4711 if (state) rb_jump_tag(state);
4712 return !UNDEF_P(result);
4717 rb_protect(shareable_p_sleep,
Qnil, &state);
4719 shareable_p_free(c);
4726ractor_require(rb_execution_context_t *ec,
VALUE self,
VALUE feature)
4728 return rb_ractor_require(feature,
false);
4732autoload_load_body(
VALUE crr_obj)
4740ractor_autoload_load_func(
void *crr_obj)
4742 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
4746rb_ractor_autoload_load(
VALUE module,
ID name)
4752 RB_OBJ_WRITE(crr_obj, &crr->as.autoload.module, module);
4755 VALUE results = cross_ractor_require_on_main(crr_obj, crr, ractor_autoload_load_func);
4768rb_builtin_shareable_proc(rb_execution_context_t *ec,
VALUE self,
VALUE arg_self)
4770 return ractor_shareable_proc(ec, arg_self,
false);
4774rb_builtin_shareable_lambda(rb_execution_context_t *ec,
VALUE self,
VALUE arg_self)
4776 return ractor_shareable_proc(ec, arg_self,
true);
4779#include "ractor.rbinc"
#define RUBY_ATOMIC_PTR_LOAD(var)
Identical to RUBY_ATOMIC_LOAD, except it expects its arguments are void*.
#define RUBY_ATOMIC_PTR_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are void*.
#define RUBY_ATOMIC_CAS(var, oldval, newval)
Atomic compare-and-swap.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_LOAD(var)
Atomic load.
#define RUBY_ATOMIC_PTR_SET(var, val)
Identical to RUBY_ATOMIC_SET, except it expects its arguments are void*.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
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 ...
static VALUE RB_OBJ_FROZEN_RAW(VALUE obj)
This is an implementation detail of RB_OBJ_FROZEN().
static void RB_FL_SET_RAW(VALUE obj, VALUE flags)
This is an implementation detail of RB_FL_SET().
@ RUBY_FL_FREEZE
This flag has something to do with data immutability.
void rb_singleton_class_attached(VALUE klass, VALUE obj)
Attaches a singleton class to its corresponding object.
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
#define TYPE(_)
Old name of rb_type.
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
#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 INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#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 ZALLOC
Old name of RB_ZALLOC.
#define FL_SHAREABLE
Old name of RUBY_FL_SHAREABLE.
#define CLASS_OF
Old name of rb_class_of.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define FL_FINALIZE
Old name of RUBY_FL_FINALIZE.
#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 ALLOC_N
Old name of RB_ALLOC_N.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#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 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.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eTypeError
TypeError exception.
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_errinfo(void)
This is the same as $! in Ruby.
VALUE rb_cArray
Array class.
VALUE rb_cObject
Object class.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_cRactor
Ractor class.
VALUE rb_stdin
STDIN constant.
VALUE rb_cHash
Hash class.
VALUE rb_stderr
STDERR constant.
static VALUE rb_class_of(VALUE obj)
Object to class mapping function.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
VALUE rb_obj_freeze(VALUE obj)
Same as RB_OBJ_FREEZE(), but returns the given object.
VALUE rb_stdout
STDOUT constant.
VALUE rb_cString
String class.
#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.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcall(), except it takes the method arguments as a C array.
VALUE rb_ary_new_capa(rb_len_t capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_resize(VALUE ary, rb_len_t len)
Expands or shrinks the passed array to the passed length.
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_hidden_new(rb_len_t capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_freeze(VALUE obj)
Freeze an array, preventing further modifications.
VALUE rb_ary_new_from_values(rb_len_t n, const VALUE *elts)
Identical to rb_ary_new_from_args(), except how objects are passed.
VALUE rb_marshal_load(VALUE port)
Deserialises a previous output of rb_marshal_dump() into a network of objects.
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.
int rb_reg_options(VALUE re)
Queries the options of the passed regular expression.
VALUE rb_str_new_frozen(VALUE str)
Creates a frozen copy of the string, if necessary.
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
VALUE rb_mutex_new(void)
Creates a mutex.
void rb_thread_wait_for(struct timeval time)
Identical to rb_thread_sleep(), except it takes struct timeval instead.
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_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_autoload_load(VALUE space, ID name)
Kicks the autoload procedure as if it was "touched".
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
void rb_free_generic_ivar(VALUE obj)
Frees the list of instance variables.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
int rb_obj_respond_to(VALUE obj, ID mid, int private_p)
Identical to rb_respond_to(), except it additionally takes the visibility parameter.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
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.
int capa
Designed capacity of the buffer.
int rb_io_fptr_finalize(rb_io_t *fptr)
Destroys the given IO.
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_stderr(void)
Queries the standard error of the current Ractor that is calling this function.
#define RB_OBJ_SET_SHAREABLE(obj)
Wrapper of rb_obj_set_shareable().
VALUE rb_ractor_stdin(void)
Queries the standard input of the current Ractor that is calling this function.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
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.
VALUE rb_ractor_stdout(void)
Queries the standard output of the current Ractor that is calling this function.
#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.
VALUE rb_obj_set_shareable(VALUE obj)
Marks the passed object as shareable, without any check.
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 MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#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.
int st_foreach(st_table *q, int_type *w, st_data_t e)
Iteration over the given table.
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
void rb_ivar_foreach(VALUE q, int_type *w, VALUE e)
Iteration over each instance variable of the object.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
VALUE rb_ensure(type *q, VALUE w, type *e, VALUE r)
An equivalent of ensure clause.
void rb_copy_generic_ivar(VALUE clone, VALUE obj)
Copies the list of instance variables.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY(obj)
Convenient casting macro.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
References an object in an array.
static void RARRAY_ASET(VALUE ary, rb_len_t i, VALUE v)
Assigns an object in an array.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define RUBY_DEFAULT_FREE
This is a value you can set to RData::dfree.
#define RFILE(obj)
Convenient casting macro.
#define RHASH_SET_IFNONE(h, ifnone)
Destructively updates the default value of the hash.
#define RHASH_SIZE(h)
Queries the size of the hash.
#define RMATCH(obj)
Convenient casting macro.
static VALUE RREGEXP_SRC(VALUE rexp)
Convenient getter function.
#define RSTRING(obj)
Convenient casting macro.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
static VALUE RSTRUCT_SET(VALUE st, int k, VALUE v)
Resembles Struct#[]=.
static VALUE RSTRUCT_GET(VALUE st, int k)
Resembles Struct#[].
static rb_len_t RSTRUCT_LEN(VALUE st)
Returns the number of struct members.
#define RUBY_TYPED_FREE_IMMEDIATELY
Macros to see if each corresponding flag is defined.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
#define DATA_PTR(obj)
Convenient casting macro for backward compatibility.
static const rb_data_type_t * RTYPEDDATA_TYPE(VALUE obj)
Queries for the type of given 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.
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.
#define _(args)
This was a transition path from K&R to ANSI.
Ruby object's base components.
Regular expression execution context.
VALUE regexp
The expression of this match.
VALUE str
The target string that the match was made against.
VALUE ecopts
Flags as Ruby hash.
Ruby's IO, metadata and buffers.
struct rb_io_encoding encs
Decomposed encoding flags.
VALUE self
The IO's Ruby level counterpart.
VALUE write_lock
This is a Ruby level mutex.
VALUE timeout
The timeout associated with this IO when performing blocking operations.
VALUE writeconv_pre_ecopts
Value of rb_io_t::rb_io_enc_t::ecopts stored right before initialising rb_io_t::writeconv.
VALUE tied_io_for_writing
Duplex IO object, if set.
VALUE writeconv_asciicompat
This is, when set, an instance of rb_cString which holds the "common" encoding.
VALUE pathv
pathname for file
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_initialize(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_initialize.
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_signal(rb_nativethread_cond_t *cond)
Signals a condition variable.
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
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.