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_hook_list_mark(&r->pub.hooks);
221 if (r->threads.cnt > 0) {
223 ccan_list_for_each(&r->threads.set, th, lt_node) {
224 VM_ASSERT(th != NULL);
225 rb_gc_mark(th->self);
229 ractor_local_storage_mark(r);
233ractor_free(
void *ptr)
236 RUBY_DEBUG_LOG(
"free r:%d", rb_ractor_id(r));
238#ifdef RUBY_THREAD_WIN32_H
241 ractor_local_storage_free(r);
242 rb_hook_list_free(&r->pub.hooks);
244 if (r->newobj_cache) {
247 rb_gc_ractor_cache_free(r->newobj_cache);
248 r->newobj_cache = NULL;
256ractor_memsize(
const void *ptr)
261 return sizeof(
rb_ractor_t) + ractor_sync_memsize(r);
272 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
287RACTOR_PTR(
VALUE self)
289 VM_ASSERT(rb_ractor_p(self));
296#if RACTOR_CHECK_MODE > 0
298rb_ractor_current_id(
void)
300 if (GET_THREAD()->ractor == NULL) {
304 return rb_ractor_id(GET_RACTOR());
309#include "ractor_sync.c"
326 RUBY_DEBUG_LOG(
"r:%u ractor.cnt:%u++", r->pub.id, vm->ractor.cnt);
327 VM_ASSERT(single_ractor_mode || RB_VM_LOCKED_P());
329 ccan_list_add_tail(&vm->ractor.set, &r->vmlr_node);
332 if (r->newobj_cache) {
333 VM_ASSERT(r == ruby_single_main_ractor);
336 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
341cancel_single_ractor_mode(
void)
344 RUBY_DEBUG_LOG(
"enable multi-ractor mode");
346 ruby_single_main_ractor = NULL;
353 VM_ASSERT(ractor_status_p(r, ractor_created));
355 if (rb_multi_ractor_p()) {
358 vm_insert_ractor0(vm, r,
false);
359 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
364 if (vm->ractor.cnt == 0) {
366 vm_insert_ractor0(vm, r,
true);
367 ractor_status_set(r, ractor_blocking);
368 ractor_status_set(r, ractor_running);
371 cancel_single_ractor_mode();
372 vm_insert_ractor0(vm, r,
true);
373 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
381 VM_ASSERT(ractor_status_p(cr, ractor_running));
382 VM_ASSERT(vm->ractor.cnt > 1);
383 VM_ASSERT(cr->threads.cnt == 1);
387 RUBY_DEBUG_LOG(
"ractor.cnt:%u-- terminate_waiting:%d",
388 vm->ractor.cnt, vm->ractor.sync.terminate_waiting);
390 VM_ASSERT(vm->ractor.cnt > 0);
391 ccan_list_del(&cr->vmlr_node);
393 if (vm->ractor.cnt <= 2 && vm->ractor.sync.terminate_waiting) {
398 rb_gc_ractor_cache_free(cr->newobj_cache);
399 cr->newobj_cache = NULL;
401 ractor_status_set(cr, ractor_terminated);
407ractor_alloc(
VALUE klass)
413 VM_ASSERT(ractor_status_p(r, ractor_created));
418rb_ractor_main_alloc(
void)
422 fprintf(stderr,
"[FATAL] failed to allocate memory for main ractor\n");
425 r->pub.id = ++ractor_last_id;
429 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
430 ruby_single_main_ractor = r;
435#if defined(HAVE_WORKING_FORK)
443 vm->ractor.blocking_cnt = 0;
444 ruby_single_main_ractor = th->ractor;
445 th->ractor->status_ = ractor_created;
447 rb_ractor_living_threads_init(th->ractor);
448 rb_ractor_living_threads_insert(th->ractor, th);
450 VM_ASSERT(vm->ractor.blocking_cnt == 0);
451 VM_ASSERT(vm->ractor.cnt == 1);
457 rb_gc_ractor_cache_free(r->newobj_cache);
458 r->newobj_cache = NULL;
459 r->status_ = ractor_terminated;
460 ractor_sync_terminate_atfork(vm, r);
469 ccan_list_head_init(&r->threads.set);
471 r->threads.blocking_cnt = 0;
480 rb_thread_sched_init(&r->threads.sched,
false);
481 rb_ractor_living_threads_init(r);
487 enc = rb_enc_get(name);
488 if (!rb_enc_asciicompat(enc)) {
489 rb_raise(rb_eArgError,
"ASCII incompatible encoding (%s)",
504 r->threads.main = th;
505 rb_ractor_living_threads_insert(r, th);
513 VALUE rv = ractor_alloc(self);
515 ractor_init(r, name, loc);
517 r->pub.id = ractor_next_id();
518 RUBY_DEBUG_LOG(
"r:%u", r->pub.id);
521 r->verbose = cr->verbose;
522 r->debug = cr->debug;
524 rb_yjit_before_ractor_spawn();
525 rb_zjit_before_ractor_spawn();
526 rb_thread_create_ractor(r, args, block);
537 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
544 ractor_notify_exit(ec, cr, result, exc);
551 ractor_atexit(ec, cr, result,
false);
558 ractor_atexit(ec, cr, ec->errinfo,
true);
568 VM_ASSERT(cr->threads.main != NULL);
569 cr->threads.main = NULL;
576 for (
int i=0; i<
len; i++) {
577 ptr[i] = ractor_receive(ec, ractor_default_port(r));
585 for (
int i=0; i<
len; i++) {
586 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
591rb_ractor_main_p_(
void)
593 VM_ASSERT(rb_multi_ractor_p());
595 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
601 return r->threads.cnt;
606rb_ractor_thread_list(
void)
612 ccan_list_for_each(&r->threads.set, th, lt_node) {
613 switch (th->status) {
614 case THREAD_RUNNABLE:
616 case THREAD_STOPPED_FOREVER:
629 VM_ASSERT(th != NULL);
633 RUBY_DEBUG_LOG(
"r(%d)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
634 ccan_list_add_tail(&r->threads.set, &th->lt_node);
640 if (r->threads.cnt == 1) {
641 VM_ASSERT(ractor_status_p(r, ractor_created));
642 vm_insert_ractor(th->vm, r);
649 ractor_status_set(r, ractor_blocking);
651 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
652 vm->ractor.blocking_cnt++;
653 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
657rb_vm_ractor_blocking_cnt_inc(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
660 VM_ASSERT(GET_RACTOR() == cr);
661 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
665rb_vm_ractor_blocking_cnt_dec(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
668 VM_ASSERT(GET_RACTOR() == cr);
670 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
671 VM_ASSERT(vm->ractor.blocking_cnt > 0);
672 vm->ractor.blocking_cnt--;
674 ractor_status_set(cr, ractor_running);
678ractor_check_blocking(
rb_ractor_t *cr,
unsigned int remained_thread_cnt,
const char *file,
int line)
680 VM_ASSERT(cr == GET_RACTOR());
682 RUBY_DEBUG_LOG2(file, line,
683 "cr->threads.cnt:%u cr->threads.blocking_cnt:%u vm->ractor.cnt:%u vm->ractor.blocking_cnt:%u",
684 cr->threads.cnt, cr->threads.blocking_cnt,
685 GET_VM()->ractor.cnt, GET_VM()->ractor.blocking_cnt);
687 VM_ASSERT(cr->threads.cnt >= cr->threads.blocking_cnt + 1);
689 if (remained_thread_cnt > 0 &&
691 cr->threads.cnt == cr->threads.blocking_cnt + 1) {
696 rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);
706 VM_ASSERT(cr == GET_RACTOR());
707 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
708 ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
710 rb_threadptr_remove(th);
712 if (cr->threads.cnt == 1) {
713 vm_remove_ractor(th->vm, cr);
718 ccan_list_del(&th->lt_node);
726rb_ractor_blocking_threads_inc(
rb_ractor_t *cr,
const char *file,
int line)
728 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
730 VM_ASSERT(cr->threads.cnt > 0);
731 VM_ASSERT(cr == GET_RACTOR());
733 ractor_check_blocking(cr, cr->threads.cnt, __FILE__, __LINE__);
734 cr->threads.blocking_cnt++;
738rb_ractor_blocking_threads_dec(
rb_ractor_t *cr,
const char *file,
int line)
740 RUBY_DEBUG_LOG2(file, line,
741 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
742 cr->threads.blocking_cnt, cr->threads.cnt);
744 VM_ASSERT(cr == GET_RACTOR());
746 if (cr->threads.cnt == cr->threads.blocking_cnt) {
750 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
754 cr->threads.blocking_cnt--;
758rb_ractor_vm_barrier_interrupt_running_thread(
rb_ractor_t *r)
760 VM_ASSERT(r != GET_RACTOR());
761 ASSERT_ractor_unlocking(r);
766 if (ractor_status_p(r, ractor_running)) {
769 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
777rb_ractor_terminate_interrupt_main_thread(
rb_ractor_t *r)
779 VM_ASSERT(r != GET_RACTOR());
780 ASSERT_ractor_unlocking(r);
785 if (main_th->status != THREAD_KILLED) {
786 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
787 rb_threadptr_interrupt(main_th);
790 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
798ractor_terminal_interrupt_all(
rb_vm_t *vm)
800 if (vm->ractor.cnt > 1) {
803 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
804 if (r != vm->ractor.main_ractor) {
805 RUBY_DEBUG_LOG(
"r:%d", rb_ractor_id(r));
806 rb_ractor_terminate_interrupt_main_thread(r);
816rb_ractor_terminate_all(
void)
821 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
823 VM_ASSERT(cr == GET_RACTOR());
825 if (vm->ractor.cnt > 1) {
828 ractor_terminal_interrupt_all(vm);
832 rb_thread_terminate_all(GET_THREAD());
836 while (vm->ractor.cnt > 1) {
837 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
838 vm->ractor.sync.terminate_waiting =
true;
841 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
842 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
843 rb_vm_cond_timedwait(vm, &vm->ractor.sync.terminate_cond, 1000 );
844 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
845 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
847 ractor_terminal_interrupt_all(vm);
854rb_vm_main_ractor_ec(
rb_vm_t *vm)
871 if (running_ec) {
return running_ec; }
872 return vm->ractor.main_thread->ec;
876ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
878 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
1008 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
1011 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
1015 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
1016 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
1017 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
1018 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1029 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1030 if (r != vm->ractor.main_ractor) {
1031 fprintf(stderr,
"r:%u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1039 if (rb_ractor_main_p()) {
1049rb_ractor_stdout(
void)
1051 if (rb_ractor_main_p()) {
1056 return cr->r_stdout;
1061rb_ractor_stderr(
void)
1063 if (rb_ractor_main_p()) {
1068 return cr->r_stderr;
1075 if (rb_ractor_main_p()) {
1087 if (rb_ractor_main_p()) {
1099 if (rb_ractor_main_p()) {
1111 return &cr->pub.hooks;
1120enum obj_traverse_iterator_result {
1126typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1127typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1128typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1130static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1133 rb_obj_traverse_enter_func enter_func;
1134 rb_obj_traverse_leave_func leave_func;
1153 if (obj_traverse_i(key, d->data)) {
1158 if (obj_traverse_i(val, d->data)) {
1167obj_traverse_reachable_i(
VALUE obj,
void *ptr)
1171 if (obj_traverse_i(obj, d->data)) {
1179 if (UNLIKELY(!data->rec)) {
1180 data->rec_hash = rb_ident_hash_new();
1181 data->rec = RHASH_ST_TABLE(data->rec_hash);
1187obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t ptr)
1191 if (obj_traverse_i(val, d->data)) {
1204 switch (data->enter_func(obj)) {
1205 case traverse_cont:
break;
1206 case traverse_skip:
return 0;
1207 case traverse_stop:
return 1;
1210 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1221 if (d.stop)
return 1;
1242 if (obj_traverse_i(e, data))
return 1;
1256 if (d.stop)
return 1;
1262 long len = RSTRUCT_LEN(obj);
1263 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1265 for (
long i=0; i<
len; i++) {
1266 if (obj_traverse_i(ptr[i], data))
return 1;
1272 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1273 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1276 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1277 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1287 RB_VM_LOCKING_NO_BARRIER() {
1288 rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);
1290 if (d.stop)
return 1;
1300 rb_bug(
"unreachable");
1303 if (data->leave_func(obj) == traverse_stop) {
1312 rb_obj_traverse_final_func final_func;
1317obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1320 if (data->final_func(key)) {
1330rb_obj_traverse(
VALUE obj,
1331 rb_obj_traverse_enter_func enter_func,
1332 rb_obj_traverse_leave_func leave_func,
1333 rb_obj_traverse_final_func final_func)
1336 .enter_func = enter_func,
1337 .leave_func = leave_func,
1341 if (obj_traverse_i(obj, &data))
return 1;
1342 if (final_func && data.rec) {
1344 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1351allow_frozen_shareable_p(
VALUE obj)
1358 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1366static enum obj_traverse_iterator_result
1367make_shareable_check_shareable(
VALUE obj)
1372 return traverse_skip;
1374 else if (!allow_frozen_shareable_p(obj)) {
1376 rb_proc_ractor_make_shareable(obj,
Qundef);
1377 return traverse_cont;
1380 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
1384 switch (
TYPE(obj)) {
1386 return traverse_skip;
1393 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1394 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1395 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
1396 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
1409 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1413 return traverse_skip;
1417 return traverse_cont;
1420static enum obj_traverse_iterator_result
1421mark_shareable(
VALUE obj)
1424 return traverse_cont;
1430 rb_obj_traverse(obj,
1431 make_shareable_check_shareable,
1432 null_leave, mark_shareable);
1439 VALUE copy = ractor_copy(obj);
1444rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
1447 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
1455rb_ractor_ensure_main_ractor(
const char *msg)
1457 if (!rb_ractor_main_p()) {
1458 rb_raise(rb_eRactorIsolationError,
"%s", msg);
1462static enum obj_traverse_iterator_result
1463shareable_p_enter(
VALUE obj)
1466 return traverse_skip;
1472 mark_shareable(obj);
1473 return traverse_skip;
1476 allow_frozen_shareable_p(obj)) {
1477 return traverse_cont;
1480 return traverse_stop;
1484rb_ractor_shareable_p_continue(
VALUE obj)
1486 if (rb_obj_traverse(obj,
1487 shareable_p_enter, null_leave,
1496#if RACTOR_CHECK_MODE > 0
1498rb_ractor_setup_belonging(
VALUE obj)
1500 rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
1503static enum obj_traverse_iterator_result
1504reset_belonging_enter(
VALUE obj)
1507 return traverse_skip;
1510 rb_ractor_setup_belonging(obj);
1511 return traverse_cont;
1516static enum obj_traverse_iterator_result
1517null_leave(
VALUE obj)
1519 return traverse_cont;
1523ractor_reset_belonging(
VALUE obj)
1525#if RACTOR_CHECK_MODE > 0
1526 rb_obj_traverse(obj, reset_belonging_enter, null_leave, NULL);
1544 rb_obj_traverse_replace_enter_func enter_func;
1545 rb_obj_traverse_replace_leave_func leave_func;
1561obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
1567obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t ptr,
int exists)
1572 if (obj_traverse_replace_i(*key, data)) {
1576 else if (*key != data->replacement) {
1577 VALUE v = *key = data->replacement;
1581 if (obj_traverse_replace_i(*val, data)) {
1585 else if (*val != data->replacement) {
1586 VALUE v = *val = data->replacement;
1594obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
1600obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t ptr,
int exists)
1605 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
1609 else if (*(
VALUE *)val != data->replacement) {
1620 if (UNLIKELY(!data->rec)) {
1621 data->rec_hash = rb_ident_hash_new();
1622 data->rec = RHASH_ST_TABLE(data->rec_hash);
1628obj_refer_only_shareables_p_i(
VALUE obj,
void *ptr)
1630 int *pcnt = (
int *)ptr;
1638obj_refer_only_shareables_p(
VALUE obj)
1641 RB_VM_LOCKING_NO_BARRIER() {
1642 rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);
1650 st_data_t replacement;
1653 data->replacement = obj;
1657 switch (data->enter_func(obj, data)) {
1658 case traverse_cont:
break;
1659 case traverse_skip:
return 0;
1660 case traverse_stop:
return 1;
1663 replacement = (st_data_t)data->replacement;
1665 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
1666 data->replacement = (
VALUE)replacement;
1670 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
1679#define CHECK_AND_REPLACE(parent_obj, v) do { \
1681 if (obj_traverse_replace_i(_val, data)) { return 1; } \
1682 else if (data->replacement != _val) { RB_OBJ_WRITE(parent_obj, &v, data->replacement); } \
1685 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1686 VALUE fields_obj = rb_obj_fields_no_ractor_check(obj);
1688 if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {
1694 rb_st_foreach_with_replace(
1695 rb_imemo_fields_complex_tbl(fields_obj),
1696 obj_iv_hash_traverse_replace_foreach_i,
1697 obj_iv_hash_traverse_replace_i,
1700 if (d.stop)
return 1;
1703 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
1704 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
1705 for (uint32_t i = 0; i < fields_count; i++) {
1706 CHECK_AND_REPLACE(fields_obj, fields[i]);
1721 rb_str_make_independent(obj);
1726 if (rb_shape_obj_too_complex_p(obj)) {
1732 rb_st_foreach_with_replace(
1733 ROBJECT_FIELDS_HASH(obj),
1734 obj_iv_hash_traverse_replace_foreach_i,
1735 obj_iv_hash_traverse_replace_i,
1738 if (d.stop)
return 1;
1741 uint32_t
len = ROBJECT_FIELDS_COUNT(obj);
1744 for (uint32_t i = 0; i <
len; i++) {
1745 CHECK_AND_REPLACE(obj, ptr[i]);
1753 rb_ary_cancel_sharing(obj);
1758 if (obj_traverse_replace_i(e, data)) {
1761 else if (e != data->replacement) {
1775 rb_hash_stlike_foreach_with_replace(obj,
1776 obj_hash_traverse_replace_foreach_i,
1777 obj_hash_traverse_replace_i,
1779 if (d.stop)
return 1;
1783 if (obj_traverse_replace_i(ifnone, data)) {
1786 else if (ifnone != data->replacement) {
1794 long len = RSTRUCT_LEN(obj);
1795 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1797 for (
long i=0; i<
len; i++) {
1798 CHECK_AND_REPLACE(obj, ptr[i]);
1804 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->num);
1805 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->den);
1808 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->real);
1809 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->imag);
1813 if (!data->move && obj_refer_only_shareables_p(obj)) {
1817 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
1831 rb_bug(
"unreachable");
1834 data->replacement = (
VALUE)replacement;
1836 if (data->leave_func(obj, data) == traverse_stop) {
1847rb_obj_traverse_replace(
VALUE obj,
1848 rb_obj_traverse_replace_enter_func enter_func,
1849 rb_obj_traverse_replace_leave_func leave_func,
1853 .enter_func = enter_func,
1854 .leave_func = leave_func,
1860 if (obj_traverse_replace_i(obj, &data)) {
1864 return data.replacement;
1868static const bool wb_protected_types[
RUBY_T_MASK] = {
1881static enum obj_traverse_iterator_result
1885 data->replacement = obj;
1886 return traverse_skip;
1891 NEWOBJ_OF(moved,
struct RBasic, 0,
type, rb_gc_obj_slot_size(obj), 0);
1892 data->replacement = (
VALUE)moved;
1893 return traverse_cont;
1897static enum obj_traverse_iterator_result
1902 RBASIC(data->replacement)->flags = (
RBASIC(obj)->flags & ~ignored_flags) | (
RBASIC(data->replacement)->flags & ignored_flags);
1905 (
char *)data->replacement +
sizeof(
VALUE),
1906 (
char *)obj +
sizeof(
VALUE),
1907 rb_gc_obj_slot_size(obj) -
sizeof(
VALUE)
1911 rb_gc_writebarrier_remember(data->replacement);
1913 void rb_replace_generic_ivar(
VALUE clone,
VALUE obj);
1915 rb_gc_obj_id_moved(data->replacement);
1917 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1918 rb_replace_generic_ivar(data->replacement, obj);
1925 RBASIC(obj)->flags = flags;
1926 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
1927 return traverse_cont;
1931ractor_move(
VALUE obj)
1933 VALUE val = rb_obj_traverse_replace(obj, move_enter, move_leave,
true);
1934 if (!UNDEF_P(val)) {
1938 rb_raise(rb_eRactorError,
"can not move the object");
1942static enum obj_traverse_iterator_result
1946 data->replacement = obj;
1947 return traverse_skip;
1951 return traverse_cont;
1955static enum obj_traverse_iterator_result
1958 return traverse_cont;
1962ractor_copy(
VALUE obj)
1964 VALUE val = rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
1965 if (!UNDEF_P(val)) {
1969 rb_raise(rb_eRactorError,
"can not copy the object");
1984} freed_ractor_local_keys;
1987ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1990 if (k->type->
mark) (*k->type->
mark)((
void *)val);
1994static enum rb_id_table_iterator_result
1995idkey_local_storage_mark_i(
VALUE val,
void *dmy)
1998 return ID_TABLE_CONTINUE;
2004 if (r->local_storage) {
2005 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
2007 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2009 st_data_t val, k = (st_data_t)key;
2010 if (st_delete(r->local_storage, &k, &val) &&
2012 (*key->type->free)((
void *)val);
2017 if (r->idkey_local_storage) {
2018 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
2021 rb_gc_mark(r->local_storage_store_lock);
2025ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
2028 if (k->type->
free) (*k->type->
free)((
void *)val);
2035 if (r->local_storage) {
2036 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
2037 st_free_table(r->local_storage);
2040 if (r->idkey_local_storage) {
2041 rb_id_table_free(r->idkey_local_storage);
2046rb_ractor_local_storage_value_mark(
void *ptr)
2048 rb_gc_mark((
VALUE)ptr);
2062 rb_ractor_local_storage_value_mark,
2070 key->type =
type ?
type : &ractor_local_storage_type_null;
2071 key->main_cache = (
void *)
Qundef;
2085 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
2086 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
2089 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
2096 if (rb_ractor_main_p()) {
2097 if (!UNDEF_P((
VALUE)key->main_cache)) {
2098 *pret = key->main_cache;
2108 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
2122 if (cr->local_storage == NULL) {
2123 cr->local_storage = st_init_numtable();
2126 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)ptr);
2128 if (rb_ractor_main_p()) {
2129 key->main_cache = ptr;
2137 if (ractor_local_ref(key, &val)) {
2148 if (ractor_local_ref(key, (
void **)val)) {
2159 ractor_local_set(key, (
void *)val);
2166 if (ractor_local_ref(key, &ret)) {
2177 ractor_local_set(key, ptr);
2180#define DEFAULT_KEYS_CAPA 0x10
2183rb_ractor_finish_marking(
void)
2185 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2186 ruby_xfree(freed_ractor_local_keys.keys[i]);
2188 freed_ractor_local_keys.cnt = 0;
2189 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
2190 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
2200 struct rb_id_table *tbl = cr->idkey_local_storage;
2203 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
2216 struct rb_id_table *tbl = cr->idkey_local_storage;
2219 tbl = cr->idkey_local_storage = rb_id_table_create(2);
2221 rb_id_table_insert(tbl,
id, val);
2233ractor_local_value_store_i(
VALUE ptr)
2238 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
2243 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
2256 .tbl = cr->idkey_local_storage,
2260 if (data.tbl == NULL) {
2261 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
2263 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
2268 if (!cr->local_storage_store_lock) {
2281 rb_raise(rb_eRactorIsolationError,
"self should be shareable: %" PRIsVALUE, replace_self);
2285 return rb_proc_ractor_make_shareable(proc, replace_self);
2310RUBY_REFERENCES(cross_ractor_require_refs) = {
2319 "ractor/cross_ractor_require",
2321 RUBY_REFS_LIST_PTR(cross_ractor_require_refs),
2326 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_DECL_MARKING | RUBY_TYPED_EMBEDDABLE
2330require_body(
VALUE crr_obj)
2339 int rb_require_internal_silent(
VALUE fname);
2341 RB_OBJ_WRITE(crr_obj, &crr->result,
INT2NUM(rb_require_internal_silent(crr->as.require.feature)));
2344 RB_OBJ_WRITE(crr_obj, &crr->result, rb_funcallv(
Qnil, require, 1, &crr->as.require.feature));
2362require_result_copy_body(
VALUE crr_obj)
2367 if (crr->exception !=
Qundef) {
2368 VM_ASSERT(crr->result ==
Qundef);
2369 RB_OBJ_WRITE(crr_obj, &crr->exception, ractor_copy(crr->exception));
2372 VM_ASSERT(crr->result !=
Qundef);
2373 RB_OBJ_WRITE(crr_obj, &crr->result, ractor_copy(crr->result));
2380require_result_copy_resuce(
VALUE crr_obj,
VALUE errinfo)
2396 const bool silent = crr->silent;
2397 VALUE debug, errinfo;
2400 errinfo = rb_errinfo();
2409 rb_set_errinfo(errinfo);
2412 rb_rescue2(require_result_copy_body, crr_obj,
2415 ractor_port_send(GET_EC(), crr->port,
Qtrue,
Qfalse);
2421ractor_require_func(
void *crr_obj)
2423 return ractor_require_protect((
VALUE)crr_obj, require_body);
2427rb_ractor_require(
VALUE feature,
bool silent)
2430 ASSERT_vm_unlocking();
2438 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2441 crr->silent = silent;
2444 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2445 rb_ractor_interrupt_exec(main_r, ractor_require_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2448 ractor_port_receive(ec, crr->port);
2449 ractor_port_close(ec, crr->port);
2451 VALUE exc = crr->exception;
2452 VALUE result = crr->result;
2456 ractor_reset_belonging(exc);
2461 ractor_reset_belonging(result);
2469 return rb_ractor_require(feature,
false);
2473autoload_load_body(
VALUE crr_obj)
2484ractor_autoload_load_func(
void *crr_obj)
2486 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
2490rb_ractor_autoload_load(
VALUE module,
ID name)
2495 RB_OBJ_WRITE(crr_obj, &crr->as.autoload.module, module);
2497 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2502 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2503 rb_ractor_interrupt_exec(main_r, ractor_autoload_load_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2506 ractor_port_receive(ec, crr->port);
2507 ractor_port_close(ec, crr->port);
2509 VALUE exc = crr->exception;
2510 VALUE result = crr->result;
2521#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.