8#include "eval_intern.h"
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;
47#if RACTOR_CHECK_MODE > 0
49 if (ec != NULL && r->sync.locked_by == rb_ractor_self(rb_ec_ractor_ptr(ec))) {
50 rb_bug(
"recursive ractor locking");
58#if RACTOR_CHECK_MODE > 0
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 if (rb_current_execution_context(
false)) {
76 VM_ASSERT(!GET_RACTOR()->malloc_gc_disabled);
77 GET_RACTOR()->malloc_gc_disabled =
true;
80#if RACTOR_CHECK_MODE > 0
81 if (rb_current_execution_context(
false) != NULL) {
83 r->sync.locked_by = cr ? rb_ractor_self(cr) :
Qundef;
87 RUBY_DEBUG_LOG2(file, line,
"locked r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
91ractor_lock_self(
rb_ractor_t *cr,
const char *file,
int line)
93 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
94#if RACTOR_CHECK_MODE > 0
95 VM_ASSERT(cr->sync.locked_by != cr->pub.self);
97 ractor_lock(cr, file, line);
101ractor_unlock(
rb_ractor_t *r,
const char *file,
int line)
103 ASSERT_ractor_locking(r);
104#if RACTOR_CHECK_MODE > 0
105 r->sync.locked_by =
Qnil;
108 if (rb_current_execution_context(
false)) {
109 VM_ASSERT(GET_RACTOR()->malloc_gc_disabled);
110 GET_RACTOR()->malloc_gc_disabled =
false;
115 RUBY_DEBUG_LOG2(file, line,
"r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
119ractor_unlock_self(
rb_ractor_t *cr,
const char *file,
int line)
121 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
122#if RACTOR_CHECK_MODE > 0
123 VM_ASSERT(cr->sync.locked_by == cr->pub.self);
125 ractor_unlock(cr, file, line);
128#define RACTOR_LOCK(r) ractor_lock(r, __FILE__, __LINE__)
129#define RACTOR_UNLOCK(r) ractor_unlock(r, __FILE__, __LINE__)
130#define RACTOR_LOCK_SELF(r) ractor_lock_self(r, __FILE__, __LINE__)
131#define RACTOR_UNLOCK_SELF(r) ractor_unlock_self(r, __FILE__, __LINE__)
142 RACTOR_UNLOCK_SELF(r);
148ractor_status_str(
enum ractor_status status)
151 case ractor_created:
return "created";
152 case ractor_running:
return "running";
153 case ractor_blocking:
return "blocking";
154 case ractor_terminated:
return "terminated";
156 rb_bug(
"unreachable");
160ractor_status_set(
rb_ractor_t *r,
enum ractor_status status)
162 RUBY_DEBUG_LOG(
"r:%u [%s]->[%s]", r->pub.id, ractor_status_str(r->status_), ractor_status_str(status));
165 if (r->status_ != ractor_created) {
166 VM_ASSERT(r == GET_RACTOR());
171 switch (r->status_) {
173 VM_ASSERT(status == ractor_blocking);
176 VM_ASSERT(status == ractor_blocking||
177 status == ractor_terminated);
179 case ractor_blocking:
180 VM_ASSERT(status == ractor_running);
182 case ractor_terminated:
183 rb_bug(
"unreachable");
191ractor_status_p(
rb_ractor_t *r,
enum ractor_status status)
193 return rb_ractor_status_p(r, status);
198static void ractor_local_storage_mark(
rb_ractor_t *r);
199static void ractor_local_storage_free(
rb_ractor_t *r);
203static size_t ractor_sync_memsize(
const rb_ractor_t *r);
207ractor_mark(
void *ptr)
216 rb_gc_mark(r->r_stdin);
217 rb_gc_mark(r->r_stdout);
218 rb_gc_mark(r->r_stderr);
219 rb_gc_mark(r->verbose);
220 rb_gc_mark(r->debug);
221 rb_hook_list_mark(&r->pub.hooks);
223 if (r->threads.cnt > 0) {
225 ccan_list_for_each(&r->threads.set, th, lt_node) {
226 VM_ASSERT(th != NULL);
227 rb_gc_mark(th->self);
231 ractor_local_storage_mark(r);
235ractor_free(
void *ptr)
238 RUBY_DEBUG_LOG(
"free r:%d", rb_ractor_id(r));
240#ifdef RUBY_THREAD_WIN32_H
243 ractor_local_storage_free(r);
244 rb_hook_list_free(&r->pub.hooks);
246 if (r->newobj_cache) {
249 rb_gc_ractor_cache_free(r->newobj_cache);
250 r->newobj_cache = NULL;
258ractor_memsize(
const void *ptr)
263 return sizeof(
rb_ractor_t) + ractor_sync_memsize(r);
274 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
289RACTOR_PTR(
VALUE self)
291 VM_ASSERT(rb_ractor_p(self));
298#if RACTOR_CHECK_MODE > 0
300rb_ractor_current_id(
void)
302 if (GET_THREAD()->ractor == NULL) {
306 return rb_ractor_id(GET_RACTOR());
311#include "ractor_sync.c"
328 RUBY_DEBUG_LOG(
"r:%u ractor.cnt:%u++", r->pub.id, vm->ractor.cnt);
329 VM_ASSERT(single_ractor_mode || RB_VM_LOCKED_P());
331 ccan_list_add_tail(&vm->ractor.set, &r->vmlr_node);
334 if (r->newobj_cache) {
335 VM_ASSERT(r == ruby_single_main_ractor);
338 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
343cancel_single_ractor_mode(
void)
346 RUBY_DEBUG_LOG(
"enable multi-ractor mode");
348 ruby_single_main_ractor = NULL;
355 VM_ASSERT(ractor_status_p(r, ractor_created));
357 if (rb_multi_ractor_p()) {
360 vm_insert_ractor0(vm, r,
false);
361 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
366 if (vm->ractor.cnt == 0) {
368 vm_insert_ractor0(vm, r,
true);
369 ractor_status_set(r, ractor_blocking);
370 ractor_status_set(r, ractor_running);
373 cancel_single_ractor_mode();
374 vm_insert_ractor0(vm, r,
true);
375 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
383 VM_ASSERT(ractor_status_p(cr, ractor_running));
384 VM_ASSERT(vm->ractor.cnt > 1);
385 VM_ASSERT(cr->threads.cnt == 1);
389 RUBY_DEBUG_LOG(
"ractor.cnt:%u-- terminate_waiting:%d",
390 vm->ractor.cnt, vm->ractor.sync.terminate_waiting);
392 VM_ASSERT(vm->ractor.cnt > 0);
393 ccan_list_del(&cr->vmlr_node);
395 if (vm->ractor.cnt <= 2 && vm->ractor.sync.terminate_waiting) {
400 rb_gc_ractor_cache_free(cr->newobj_cache);
401 cr->newobj_cache = NULL;
403 ractor_status_set(cr, ractor_terminated);
409ractor_alloc(
VALUE klass)
415 VM_ASSERT(ractor_status_p(r, ractor_created));
420rb_ractor_main_alloc(
void)
424 fprintf(stderr,
"[FATAL] failed to allocate memory for main ractor\n");
427 r->pub.id = ++ractor_last_id;
431 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
432 ruby_single_main_ractor = r;
437#if defined(HAVE_WORKING_FORK)
445 vm->ractor.blocking_cnt = 0;
446 ruby_single_main_ractor = th->ractor;
447 th->ractor->status_ = ractor_created;
449 rb_ractor_living_threads_init(th->ractor);
450 rb_ractor_living_threads_insert(th->ractor, th);
452 VM_ASSERT(vm->ractor.blocking_cnt == 0);
453 VM_ASSERT(vm->ractor.cnt == 1);
459 rb_gc_ractor_cache_free(r->newobj_cache);
460 r->newobj_cache = NULL;
461 r->status_ = ractor_terminated;
462 ractor_sync_terminate_atfork(vm, r);
471 ccan_list_head_init(&r->threads.set);
473 r->threads.blocking_cnt = 0;
482 rb_thread_sched_init(&r->threads.sched,
false);
483 rb_ractor_living_threads_init(r);
489 enc = rb_enc_get(name);
490 if (!rb_enc_asciicompat(enc)) {
491 rb_raise(rb_eArgError,
"ASCII incompatible encoding (%s)",
506 r->threads.main = th;
507 rb_ractor_living_threads_insert(r, th);
515 VALUE rv = ractor_alloc(self);
517 ractor_init(r, name, loc);
519 r->pub.id = ractor_next_id();
520 RUBY_DEBUG_LOG(
"r:%u", r->pub.id);
523 r->verbose = cr->verbose;
524 r->debug = cr->debug;
526 rb_yjit_before_ractor_spawn();
527 rb_zjit_before_ractor_spawn();
528 rb_thread_create_ractor(r, args, block);
539 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
546 ractor_notify_exit(ec, cr, result, exc);
553 ractor_atexit(ec, cr, result,
false);
560 ractor_atexit(ec, cr, ec->errinfo,
true);
570 VM_ASSERT(cr->threads.main != NULL);
571 cr->threads.main = NULL;
578 for (
int i=0; i<
len; i++) {
579 ptr[i] = ractor_receive(ec, ractor_default_port(r));
587 for (
int i=0; i<
len; i++) {
588 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
593rb_ractor_main_p_(
void)
595 VM_ASSERT(rb_multi_ractor_p());
597 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
603 return r->threads.cnt;
608rb_ractor_thread_list(
void)
614 ccan_list_for_each(&r->threads.set, th, lt_node) {
615 switch (th->status) {
616 case THREAD_RUNNABLE:
618 case THREAD_STOPPED_FOREVER:
631 VM_ASSERT(th != NULL);
635 RUBY_DEBUG_LOG(
"r(%d)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
636 ccan_list_add_tail(&r->threads.set, &th->lt_node);
642 if (r->threads.cnt == 1) {
643 VM_ASSERT(ractor_status_p(r, ractor_created));
644 vm_insert_ractor(th->vm, r);
651 ractor_status_set(r, ractor_blocking);
653 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
654 vm->ractor.blocking_cnt++;
655 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
659rb_vm_ractor_blocking_cnt_inc(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
662 VM_ASSERT(GET_RACTOR() == cr);
663 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
667rb_vm_ractor_blocking_cnt_dec(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
670 VM_ASSERT(GET_RACTOR() == cr);
672 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
673 VM_ASSERT(vm->ractor.blocking_cnt > 0);
674 vm->ractor.blocking_cnt--;
676 ractor_status_set(cr, ractor_running);
680ractor_check_blocking(
rb_ractor_t *cr,
unsigned int remained_thread_cnt,
const char *file,
int line)
682 VM_ASSERT(cr == GET_RACTOR());
684 RUBY_DEBUG_LOG2(file, line,
685 "cr->threads.cnt:%u cr->threads.blocking_cnt:%u vm->ractor.cnt:%u vm->ractor.blocking_cnt:%u",
686 cr->threads.cnt, cr->threads.blocking_cnt,
687 GET_VM()->ractor.cnt, GET_VM()->ractor.blocking_cnt);
689 VM_ASSERT(cr->threads.cnt >= cr->threads.blocking_cnt + 1);
691 if (remained_thread_cnt > 0 &&
693 cr->threads.cnt == cr->threads.blocking_cnt + 1) {
698 rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);
708 VM_ASSERT(cr == GET_RACTOR());
709 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
710 ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
712 rb_threadptr_remove(th);
714 if (cr->threads.cnt == 1) {
715 vm_remove_ractor(th->vm, cr);
720 ccan_list_del(&th->lt_node);
728rb_ractor_blocking_threads_inc(
rb_ractor_t *cr,
const char *file,
int line)
730 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
732 VM_ASSERT(cr->threads.cnt > 0);
733 VM_ASSERT(cr == GET_RACTOR());
735 ractor_check_blocking(cr, cr->threads.cnt, __FILE__, __LINE__);
736 cr->threads.blocking_cnt++;
740rb_ractor_blocking_threads_dec(
rb_ractor_t *cr,
const char *file,
int line)
742 RUBY_DEBUG_LOG2(file, line,
743 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
744 cr->threads.blocking_cnt, cr->threads.cnt);
746 VM_ASSERT(cr == GET_RACTOR());
748 if (cr->threads.cnt == cr->threads.blocking_cnt) {
752 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
756 cr->threads.blocking_cnt--;
760rb_ractor_vm_barrier_interrupt_running_thread(
rb_ractor_t *r)
762 VM_ASSERT(r != GET_RACTOR());
763 ASSERT_ractor_unlocking(r);
768 if (ractor_status_p(r, ractor_running)) {
771 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
779rb_ractor_terminate_interrupt_main_thread(
rb_ractor_t *r)
781 VM_ASSERT(r != GET_RACTOR());
782 ASSERT_ractor_unlocking(r);
787 if (main_th->status != THREAD_KILLED) {
788 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
789 rb_threadptr_interrupt(main_th);
792 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
800ractor_terminal_interrupt_all(
rb_vm_t *vm)
802 if (vm->ractor.cnt > 1) {
805 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
806 if (r != vm->ractor.main_ractor) {
807 RUBY_DEBUG_LOG(
"r:%d", rb_ractor_id(r));
808 rb_ractor_terminate_interrupt_main_thread(r);
818rb_ractor_terminate_all(
void)
823 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
825 VM_ASSERT(cr == GET_RACTOR());
827 if (vm->ractor.cnt > 1) {
830 ractor_terminal_interrupt_all(vm);
834 rb_thread_terminate_all(GET_THREAD());
838 while (vm->ractor.cnt > 1) {
839 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
840 vm->ractor.sync.terminate_waiting =
true;
843 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
844 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
845 rb_vm_cond_timedwait(vm, &vm->ractor.sync.terminate_cond, 1000 );
846 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
847 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
849 ractor_terminal_interrupt_all(vm);
856rb_vm_main_ractor_ec(
rb_vm_t *vm)
873 if (running_ec) {
return running_ec; }
874 return vm->ractor.main_thread->ec;
878ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
880 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
1010 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
1013 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
1017 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
1018 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
1019 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
1020 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1031 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1032 if (r != vm->ractor.main_ractor) {
1033 fprintf(stderr,
"r:%u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1041 if (rb_ractor_main_p()) {
1051rb_ractor_stdout(
void)
1053 if (rb_ractor_main_p()) {
1058 return cr->r_stdout;
1063rb_ractor_stderr(
void)
1065 if (rb_ractor_main_p()) {
1070 return cr->r_stderr;
1077 if (rb_ractor_main_p()) {
1089 if (rb_ractor_main_p()) {
1101 if (rb_ractor_main_p()) {
1113 return &cr->pub.hooks;
1122enum obj_traverse_iterator_result {
1128typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1129typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1130typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1132static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1135 rb_obj_traverse_enter_func enter_func;
1136 rb_obj_traverse_leave_func leave_func;
1155 if (obj_traverse_i(key, d->data)) {
1160 if (obj_traverse_i(val, d->data)) {
1169obj_traverse_reachable_i(
VALUE obj,
void *ptr)
1173 if (obj_traverse_i(obj, d->data)) {
1181 if (UNLIKELY(!data->rec)) {
1182 data->rec_hash = rb_ident_hash_new();
1183 data->rec = RHASH_ST_TABLE(data->rec_hash);
1189obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t ptr)
1193 if (obj_traverse_i(val, d->data)) {
1206 switch (data->enter_func(obj)) {
1207 case traverse_cont:
break;
1208 case traverse_skip:
return 0;
1209 case traverse_stop:
return 1;
1212 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1223 if (d.stop)
return 1;
1244 if (obj_traverse_i(e, data))
return 1;
1258 if (d.stop)
return 1;
1264 long len = RSTRUCT_LEN(obj);
1265 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1267 for (
long i=0; i<
len; i++) {
1268 if (obj_traverse_i(ptr[i], data))
return 1;
1274 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1275 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1278 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1279 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1289 RB_VM_LOCKING_NO_BARRIER() {
1290 rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);
1292 if (d.stop)
return 1;
1302 rb_bug(
"unreachable");
1305 if (data->leave_func(obj) == traverse_stop) {
1314 rb_obj_traverse_final_func final_func;
1319obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1322 if (data->final_func(key)) {
1332rb_obj_traverse(
VALUE obj,
1333 rb_obj_traverse_enter_func enter_func,
1334 rb_obj_traverse_leave_func leave_func,
1335 rb_obj_traverse_final_func final_func)
1338 .enter_func = enter_func,
1339 .leave_func = leave_func,
1343 if (obj_traverse_i(obj, &data))
return 1;
1344 if (final_func && data.rec) {
1346 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1353allow_frozen_shareable_p(
VALUE obj)
1360 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1368static enum obj_traverse_iterator_result
1369make_shareable_check_shareable(
VALUE obj)
1374 return traverse_skip;
1376 else if (!allow_frozen_shareable_p(obj)) {
1378 rb_proc_ractor_make_shareable(obj,
Qundef);
1379 return traverse_cont;
1382 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
1386 switch (
TYPE(obj)) {
1388 return traverse_skip;
1395 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1396 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1397 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
1398 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
1411 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1415 return traverse_skip;
1419 return traverse_cont;
1422static enum obj_traverse_iterator_result
1423mark_shareable(
VALUE obj)
1426 return traverse_cont;
1432 rb_obj_traverse(obj,
1433 make_shareable_check_shareable,
1434 null_leave, mark_shareable);
1441 VALUE copy = ractor_copy(obj);
1446rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
1449 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
1457rb_ractor_ensure_main_ractor(
const char *msg)
1459 if (!rb_ractor_main_p()) {
1460 rb_raise(rb_eRactorIsolationError,
"%s", msg);
1464static enum obj_traverse_iterator_result
1465shareable_p_enter(
VALUE obj)
1468 return traverse_skip;
1474 mark_shareable(obj);
1475 return traverse_skip;
1478 allow_frozen_shareable_p(obj)) {
1479 return traverse_cont;
1482 return traverse_stop;
1486rb_ractor_shareable_p_continue(
VALUE obj)
1488 if (rb_obj_traverse(obj,
1489 shareable_p_enter, null_leave,
1498#if RACTOR_CHECK_MODE > 0
1500rb_ractor_setup_belonging(
VALUE obj)
1502 rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
1505static enum obj_traverse_iterator_result
1506reset_belonging_enter(
VALUE obj)
1509 return traverse_skip;
1512 rb_ractor_setup_belonging(obj);
1513 return traverse_cont;
1518static enum obj_traverse_iterator_result
1519null_leave(
VALUE obj)
1521 return traverse_cont;
1525ractor_reset_belonging(
VALUE obj)
1527#if RACTOR_CHECK_MODE > 0
1528 rb_obj_traverse(obj, reset_belonging_enter, null_leave, NULL);
1546 rb_obj_traverse_replace_enter_func enter_func;
1547 rb_obj_traverse_replace_leave_func leave_func;
1563obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
1569obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t ptr,
int exists)
1574 if (obj_traverse_replace_i(*key, data)) {
1578 else if (*key != data->replacement) {
1579 VALUE v = *key = data->replacement;
1583 if (obj_traverse_replace_i(*val, data)) {
1587 else if (*val != data->replacement) {
1588 VALUE v = *val = data->replacement;
1596obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
1602obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t ptr,
int exists)
1607 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
1611 else if (*(
VALUE *)val != data->replacement) {
1622 if (UNLIKELY(!data->rec)) {
1623 data->rec_hash = rb_ident_hash_new();
1624 data->rec = RHASH_ST_TABLE(data->rec_hash);
1630obj_refer_only_shareables_p_i(
VALUE obj,
void *ptr)
1632 int *pcnt = (
int *)ptr;
1640obj_refer_only_shareables_p(
VALUE obj)
1643 RB_VM_LOCKING_NO_BARRIER() {
1644 rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);
1652 st_data_t replacement;
1655 data->replacement = obj;
1659 switch (data->enter_func(obj, data)) {
1660 case traverse_cont:
break;
1661 case traverse_skip:
return 0;
1662 case traverse_stop:
return 1;
1665 replacement = (st_data_t)data->replacement;
1667 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
1668 data->replacement = (
VALUE)replacement;
1672 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
1681#define CHECK_AND_REPLACE(parent_obj, v) do { \
1683 if (obj_traverse_replace_i(_val, data)) { return 1; } \
1684 else if (data->replacement != _val) { RB_OBJ_WRITE(parent_obj, &v, data->replacement); } \
1687 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1688 VALUE fields_obj = rb_obj_fields_no_ractor_check(obj);
1690 if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {
1696 rb_st_foreach_with_replace(
1697 rb_imemo_fields_complex_tbl(fields_obj),
1698 obj_iv_hash_traverse_replace_foreach_i,
1699 obj_iv_hash_traverse_replace_i,
1702 if (d.stop)
return 1;
1705 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
1706 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
1707 for (uint32_t i = 0; i < fields_count; i++) {
1708 CHECK_AND_REPLACE(fields_obj, fields[i]);
1723 rb_str_make_independent(obj);
1728 if (rb_shape_obj_too_complex_p(obj)) {
1734 rb_st_foreach_with_replace(
1735 ROBJECT_FIELDS_HASH(obj),
1736 obj_iv_hash_traverse_replace_foreach_i,
1737 obj_iv_hash_traverse_replace_i,
1740 if (d.stop)
return 1;
1743 uint32_t
len = ROBJECT_FIELDS_COUNT(obj);
1746 for (uint32_t i = 0; i <
len; i++) {
1747 CHECK_AND_REPLACE(obj, ptr[i]);
1755 rb_ary_cancel_sharing(obj);
1760 if (obj_traverse_replace_i(e, data)) {
1763 else if (e != data->replacement) {
1777 rb_hash_stlike_foreach_with_replace(obj,
1778 obj_hash_traverse_replace_foreach_i,
1779 obj_hash_traverse_replace_i,
1781 if (d.stop)
return 1;
1785 if (obj_traverse_replace_i(ifnone, data)) {
1788 else if (ifnone != data->replacement) {
1796 long len = RSTRUCT_LEN(obj);
1797 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1799 for (
long i=0; i<
len; i++) {
1800 CHECK_AND_REPLACE(obj, ptr[i]);
1806 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->num);
1807 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->den);
1810 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->real);
1811 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->imag);
1815 if (!data->move && obj_refer_only_shareables_p(obj)) {
1819 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
1833 rb_bug(
"unreachable");
1836 data->replacement = (
VALUE)replacement;
1838 if (data->leave_func(obj, data) == traverse_stop) {
1849rb_obj_traverse_replace(
VALUE obj,
1850 rb_obj_traverse_replace_enter_func enter_func,
1851 rb_obj_traverse_replace_leave_func leave_func,
1855 .enter_func = enter_func,
1856 .leave_func = leave_func,
1862 if (obj_traverse_replace_i(obj, &data)) {
1866 return data.replacement;
1870static const bool wb_protected_types[
RUBY_T_MASK] = {
1883static enum obj_traverse_iterator_result
1887 data->replacement = obj;
1888 return traverse_skip;
1893 NEWOBJ_OF(moved,
struct RBasic, 0,
type, rb_gc_obj_slot_size(obj), 0);
1894 data->replacement = (
VALUE)moved;
1895 return traverse_cont;
1899static enum obj_traverse_iterator_result
1904 RBASIC(data->replacement)->flags = (
RBASIC(obj)->flags & ~ignored_flags) | (
RBASIC(data->replacement)->flags & ignored_flags);
1907 (
char *)data->replacement +
sizeof(
VALUE),
1908 (
char *)obj +
sizeof(
VALUE),
1909 rb_gc_obj_slot_size(obj) -
sizeof(
VALUE)
1913 rb_gc_writebarrier_remember(data->replacement);
1915 void rb_replace_generic_ivar(
VALUE clone,
VALUE obj);
1917 rb_gc_obj_id_moved(data->replacement);
1919 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1920 rb_replace_generic_ivar(data->replacement, obj);
1927 RBASIC(obj)->flags = flags;
1928 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
1929 return traverse_cont;
1933ractor_move(
VALUE obj)
1935 VALUE val = rb_obj_traverse_replace(obj, move_enter, move_leave,
true);
1936 if (!UNDEF_P(val)) {
1940 rb_raise(rb_eRactorError,
"can not move the object");
1944static enum obj_traverse_iterator_result
1948 data->replacement = obj;
1949 return traverse_skip;
1953 return traverse_cont;
1957static enum obj_traverse_iterator_result
1960 return traverse_cont;
1964ractor_copy(
VALUE obj)
1966 VALUE val = rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
1967 if (!UNDEF_P(val)) {
1971 rb_raise(rb_eRactorError,
"can not copy the object");
1986} freed_ractor_local_keys;
1989ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1992 if (k->type->
mark) (*k->type->
mark)((
void *)val);
1996static enum rb_id_table_iterator_result
1997idkey_local_storage_mark_i(
VALUE val,
void *dmy)
2000 return ID_TABLE_CONTINUE;
2006 if (r->local_storage) {
2007 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
2009 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2011 st_data_t val, k = (st_data_t)key;
2012 if (st_delete(r->local_storage, &k, &val) &&
2014 (*key->type->free)((
void *)val);
2019 if (r->idkey_local_storage) {
2020 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
2023 rb_gc_mark(r->local_storage_store_lock);
2027ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
2030 if (k->type->
free) (*k->type->
free)((
void *)val);
2037 if (r->local_storage) {
2038 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
2039 st_free_table(r->local_storage);
2042 if (r->idkey_local_storage) {
2043 rb_id_table_free(r->idkey_local_storage);
2048rb_ractor_local_storage_value_mark(
void *ptr)
2050 rb_gc_mark((
VALUE)ptr);
2064 rb_ractor_local_storage_value_mark,
2072 key->type =
type ?
type : &ractor_local_storage_type_null;
2073 key->main_cache = (
void *)
Qundef;
2087 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
2088 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
2091 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
2098 if (rb_ractor_main_p()) {
2099 if (!UNDEF_P((
VALUE)key->main_cache)) {
2100 *pret = key->main_cache;
2110 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
2124 if (cr->local_storage == NULL) {
2125 cr->local_storage = st_init_numtable();
2128 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)ptr);
2130 if (rb_ractor_main_p()) {
2131 key->main_cache = ptr;
2139 if (ractor_local_ref(key, &val)) {
2150 if (ractor_local_ref(key, (
void **)val)) {
2161 ractor_local_set(key, (
void *)val);
2168 if (ractor_local_ref(key, &ret)) {
2179 ractor_local_set(key, ptr);
2182#define DEFAULT_KEYS_CAPA 0x10
2185rb_ractor_finish_marking(
void)
2187 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2188 ruby_xfree(freed_ractor_local_keys.keys[i]);
2190 freed_ractor_local_keys.cnt = 0;
2191 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
2192 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
2202 struct rb_id_table *tbl = cr->idkey_local_storage;
2205 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
2218 struct rb_id_table *tbl = cr->idkey_local_storage;
2221 tbl = cr->idkey_local_storage = rb_id_table_create(2);
2223 rb_id_table_insert(tbl,
id, val);
2235ractor_local_value_store_i(
VALUE ptr)
2240 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
2245 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
2258 .tbl = cr->idkey_local_storage,
2262 if (data.tbl == NULL) {
2263 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
2265 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
2270 if (!cr->local_storage_store_lock) {
2283 rb_raise(rb_eRactorIsolationError,
"self should be shareable: %" PRIsVALUE, replace_self);
2287 return rb_proc_ractor_make_shareable(proc, replace_self);
2312RUBY_REFERENCES(cross_ractor_require_refs) = {
2321 "ractor/cross_ractor_require",
2323 RUBY_REFS_LIST_PTR(cross_ractor_require_refs),
2328 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_DECL_MARKING | RUBY_TYPED_EMBEDDABLE
2332require_body(
VALUE crr_obj)
2341 int rb_require_internal_silent(
VALUE fname);
2343 RB_OBJ_WRITE(crr_obj, &crr->result,
INT2NUM(rb_require_internal_silent(crr->as.require.feature)));
2346 RB_OBJ_WRITE(crr_obj, &crr->result, rb_funcallv(
Qnil, require, 1, &crr->as.require.feature));
2364require_result_copy_body(
VALUE crr_obj)
2369 if (crr->exception !=
Qundef) {
2370 VM_ASSERT(crr->result ==
Qundef);
2371 RB_OBJ_WRITE(crr_obj, &crr->exception, ractor_copy(crr->exception));
2374 VM_ASSERT(crr->result !=
Qundef);
2375 RB_OBJ_WRITE(crr_obj, &crr->result, ractor_copy(crr->result));
2382require_result_copy_resuce(
VALUE crr_obj,
VALUE errinfo)
2398 const bool silent = crr->silent;
2399 VALUE debug, errinfo;
2402 errinfo = rb_errinfo();
2411 rb_set_errinfo(errinfo);
2414 rb_rescue2(require_result_copy_body, crr_obj,
2417 ractor_port_send(GET_EC(), crr->port,
Qtrue,
Qfalse);
2423ractor_require_func(
void *crr_obj)
2425 return ractor_require_protect((
VALUE)crr_obj, require_body);
2429rb_ractor_require(
VALUE feature,
bool silent)
2432 ASSERT_vm_unlocking();
2440 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2443 crr->silent = silent;
2446 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2447 rb_ractor_interrupt_exec(main_r, ractor_require_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2450 ractor_port_receive(ec, crr->port);
2451 ractor_port_close(ec, crr->port);
2453 VALUE exc = crr->exception;
2454 VALUE result = crr->result;
2458 ractor_reset_belonging(exc);
2463 ractor_reset_belonging(result);
2471 return rb_ractor_require(feature,
false);
2475autoload_load_body(
VALUE crr_obj)
2486ractor_autoload_load_func(
void *crr_obj)
2488 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
2492rb_ractor_autoload_load(
VALUE module,
ID name)
2497 RB_OBJ_WRITE(crr_obj, &crr->as.autoload.module, module);
2499 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2504 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2505 rb_ractor_interrupt_exec(main_r, ractor_autoload_load_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2508 ractor_port_receive(ec, crr->port);
2509 ractor_port_close(ec, crr->port);
2511 VALUE exc = crr->exception;
2512 VALUE result = crr->result;
2523#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.
static VALUE RB_OBJ_FROZEN_RAW(VALUE obj)
This is an implementation detail of RB_OBJ_FROZEN().
@ 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 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.
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.
static VALUE rb_class_of(VALUE obj)
Object to class mapping function.
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_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.
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.
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.
#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_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.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
static void RARRAY_ASET(VALUE ary, long i, VALUE v)
Assigns an object in an array.
#define RARRAY_AREF(a, i)
#define RBASIC(obj)
Convenient casting macro.
#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.
static VALUE * ROBJECT_FIELDS(VALUE obj)
Queries the instance variables.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
static bool RTYPEDDATA_P(VALUE obj)
Checks whether the passed object is RTypedData or RData.
#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.
#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...
static const struct rb_data_type_struct * RTYPEDDATA_TYPE(VALUE obj)
Queries for the type of given object.
#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.
Ruby object's base components.
This is the struct that holds necessary info for a struct.
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.
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.
@ RUBY_T_MASK
Bitmask of ruby_value_type.