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"
24static VALUE rb_cRactorSelector;
26VALUE rb_eRactorUnsafeError;
27VALUE rb_eRactorIsolationError;
28static VALUE rb_eRactorError;
29static VALUE rb_eRactorRemoteError;
30static VALUE rb_eRactorMovedError;
31static VALUE rb_eRactorClosedError;
32static VALUE rb_cRactorMovedObject;
34static void vm_ractor_blocking_cnt_inc(
rb_vm_t *vm,
rb_ractor_t *r,
const char *file,
int line);
37#if RACTOR_CHECK_MODE > 0
38bool rb_ractor_ignore_belonging_flag =
false;
46#if RACTOR_CHECK_MODE > 0
48 if (ec != NULL && r->sync.locked_by == rb_ractor_self(rb_ec_ractor_ptr(ec))) {
49 rb_bug(
"recursive ractor locking");
57#if RACTOR_CHECK_MODE > 0
59 if (ec != NULL && r->sync.locked_by != rb_ractor_self(rb_ec_ractor_ptr(ec))) {
60 rp(r->sync.locked_by);
61 rb_bug(
"ractor lock is not acquired.");
67ractor_lock(
rb_ractor_t *r,
const char *file,
int line)
69 RUBY_DEBUG_LOG2(file, line,
"locking r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
71 ASSERT_ractor_unlocking(r);
74#if RACTOR_CHECK_MODE > 0
75 if (rb_current_execution_context(
false) != NULL) {
77 r->sync.locked_by = cr ? rb_ractor_self(cr) :
Qundef;
81 RUBY_DEBUG_LOG2(file, line,
"locked r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
85ractor_lock_self(
rb_ractor_t *cr,
const char *file,
int line)
87 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
88#if RACTOR_CHECK_MODE > 0
89 VM_ASSERT(cr->sync.locked_by != cr->pub.self);
91 ractor_lock(cr, file, line);
95ractor_unlock(
rb_ractor_t *r,
const char *file,
int line)
97 ASSERT_ractor_locking(r);
98#if RACTOR_CHECK_MODE > 0
99 r->sync.locked_by =
Qnil;
103 RUBY_DEBUG_LOG2(file, line,
"r:%u%s", r->pub.id, rb_current_ractor_raw(
false) == r ?
" (self)" :
"");
107ractor_unlock_self(
rb_ractor_t *cr,
const char *file,
int line)
109 VM_ASSERT(cr == rb_ec_ractor_ptr(rb_current_ec_noinline()));
110#if RACTOR_CHECK_MODE > 0
111 VM_ASSERT(cr->sync.locked_by == cr->pub.self);
113 ractor_unlock(cr, file, line);
116#define RACTOR_LOCK(r) ractor_lock(r, __FILE__, __LINE__)
117#define RACTOR_UNLOCK(r) ractor_unlock(r, __FILE__, __LINE__)
118#define RACTOR_LOCK_SELF(r) ractor_lock_self(r, __FILE__, __LINE__)
119#define RACTOR_UNLOCK_SELF(r) ractor_unlock_self(r, __FILE__, __LINE__)
130 RACTOR_UNLOCK_SELF(r);
136ractor_status_str(
enum ractor_status status)
139 case ractor_created:
return "created";
140 case ractor_running:
return "running";
141 case ractor_blocking:
return "blocking";
142 case ractor_terminated:
return "terminated";
144 rb_bug(
"unreachable");
148ractor_status_set(
rb_ractor_t *r,
enum ractor_status status)
150 RUBY_DEBUG_LOG(
"r:%u [%s]->[%s]", r->pub.id, ractor_status_str(r->status_), ractor_status_str(status));
153 if (r->status_ != ractor_created) {
154 VM_ASSERT(r == GET_RACTOR());
159 switch (r->status_) {
161 VM_ASSERT(status == ractor_blocking);
164 VM_ASSERT(status == ractor_blocking||
165 status == ractor_terminated);
167 case ractor_blocking:
168 VM_ASSERT(status == ractor_running);
170 case ractor_terminated:
171 rb_bug(
"unreachable");
179ractor_status_p(
rb_ractor_t *r,
enum ractor_status status)
181 return rb_ractor_status_p(r, status);
186static void ractor_local_storage_mark(
rb_ractor_t *r);
187static void ractor_local_storage_free(
rb_ractor_t *r);
191static size_t ractor_sync_memsize(
const rb_ractor_t *r);
195ractor_mark(
void *ptr)
204 rb_gc_mark(r->r_stdin);
205 rb_gc_mark(r->r_stdout);
206 rb_gc_mark(r->r_stderr);
207 rb_hook_list_mark(&r->pub.hooks);
209 if (r->threads.cnt > 0) {
211 ccan_list_for_each(&r->threads.set, th, lt_node) {
212 VM_ASSERT(th != NULL);
213 rb_gc_mark(th->self);
217 ractor_local_storage_mark(r);
221ractor_free(
void *ptr)
224 RUBY_DEBUG_LOG(
"free r:%d", rb_ractor_id(r));
226#ifdef RUBY_THREAD_WIN32_H
229 ractor_local_storage_free(r);
230 rb_hook_list_free(&r->pub.hooks);
232 if (r->newobj_cache) {
235 rb_gc_ractor_cache_free(r->newobj_cache);
236 r->newobj_cache = NULL;
244ractor_memsize(
const void *ptr)
249 return sizeof(
rb_ractor_t) + ractor_sync_memsize(r);
260 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
275RACTOR_PTR(
VALUE self)
277 VM_ASSERT(rb_ractor_p(self));
284#if RACTOR_CHECK_MODE > 0
286rb_ractor_current_id(
void)
288 if (GET_THREAD()->ractor == NULL) {
292 return rb_ractor_id(GET_RACTOR());
297#include "ractor_sync.c"
314 RUBY_DEBUG_LOG(
"r:%u ractor.cnt:%u++", r->pub.id, vm->ractor.cnt);
315 VM_ASSERT(single_ractor_mode || RB_VM_LOCKED_P());
317 ccan_list_add_tail(&vm->ractor.set, &r->vmlr_node);
320 if (r->newobj_cache) {
321 VM_ASSERT(r == ruby_single_main_ractor);
324 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
329cancel_single_ractor_mode(
void)
332 RUBY_DEBUG_LOG(
"enable multi-ractor mode");
334 ruby_single_main_ractor = NULL;
341 VM_ASSERT(ractor_status_p(r, ractor_created));
343 if (rb_multi_ractor_p()) {
346 vm_insert_ractor0(vm, r,
false);
347 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
352 if (vm->ractor.cnt == 0) {
354 vm_insert_ractor0(vm, r,
true);
355 ractor_status_set(r, ractor_blocking);
356 ractor_status_set(r, ractor_running);
359 cancel_single_ractor_mode();
360 vm_insert_ractor0(vm, r,
true);
361 vm_ractor_blocking_cnt_inc(vm, r, __FILE__, __LINE__);
369 VM_ASSERT(ractor_status_p(cr, ractor_running));
370 VM_ASSERT(vm->ractor.cnt > 1);
371 VM_ASSERT(cr->threads.cnt == 1);
375 RUBY_DEBUG_LOG(
"ractor.cnt:%u-- terminate_waiting:%d",
376 vm->ractor.cnt, vm->ractor.sync.terminate_waiting);
378 VM_ASSERT(vm->ractor.cnt > 0);
379 ccan_list_del(&cr->vmlr_node);
381 if (vm->ractor.cnt <= 2 && vm->ractor.sync.terminate_waiting) {
386 rb_gc_ractor_cache_free(cr->newobj_cache);
387 cr->newobj_cache = NULL;
389 ractor_status_set(cr, ractor_terminated);
395ractor_alloc(
VALUE klass)
401 VM_ASSERT(ractor_status_p(r, ractor_created));
406rb_ractor_main_alloc(
void)
410 fprintf(stderr,
"[FATAL] failed to allocate memory for main ractor\n");
413 r->pub.id = ++ractor_last_id;
417 r->newobj_cache = rb_gc_ractor_cache_alloc(r);
418 ruby_single_main_ractor = r;
423#if defined(HAVE_WORKING_FORK)
431 vm->ractor.blocking_cnt = 0;
432 ruby_single_main_ractor = th->ractor;
433 th->ractor->status_ = ractor_created;
435 rb_ractor_living_threads_init(th->ractor);
436 rb_ractor_living_threads_insert(th->ractor, th);
438 VM_ASSERT(vm->ractor.blocking_cnt == 0);
439 VM_ASSERT(vm->ractor.cnt == 1);
445 rb_gc_ractor_cache_free(r->newobj_cache);
446 r->newobj_cache = NULL;
447 r->status_ = ractor_terminated;
448 ractor_sync_terminate_atfork(vm, r);
457 ccan_list_head_init(&r->threads.set);
459 r->threads.blocking_cnt = 0;
468 rb_thread_sched_init(&r->threads.sched,
false);
469 rb_ractor_living_threads_init(r);
475 enc = rb_enc_get(name);
476 if (!rb_enc_asciicompat(enc)) {
477 rb_raise(rb_eArgError,
"ASCII incompatible encoding (%s)",
492 r->threads.main = th;
493 rb_ractor_living_threads_insert(r, th);
501 VALUE rv = ractor_alloc(self);
503 ractor_init(r, name, loc);
506 r->pub.id = ractor_next_id();
507 RUBY_DEBUG_LOG(
"r:%u", r->pub.id);
510 r->verbose = cr->verbose;
511 r->debug = cr->debug;
513 rb_yjit_before_ractor_spawn();
514 rb_thread_create_ractor(r, args, block);
525 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
532 ractor_notify_exit(ec, cr, result, exc);
539 ractor_atexit(ec, cr, result,
false);
546 ractor_atexit(ec, cr, ec->errinfo,
true);
556 VM_ASSERT(cr->threads.main != NULL);
557 cr->threads.main = NULL;
564 for (
int i=0; i<
len; i++) {
565 ptr[i] = ractor_receive(ec, ractor_default_port(r));
573 for (
int i=0; i<
len; i++) {
574 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
579rb_ractor_main_p_(
void)
581 VM_ASSERT(rb_multi_ractor_p());
583 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
587rb_obj_is_main_ractor(
VALUE gv)
589 if (!rb_ractor_p(gv))
return false;
591 return r == GET_VM()->ractor.main_ractor;
597 return r->threads.cnt;
602rb_ractor_thread_list(
void)
608 ccan_list_for_each(&r->threads.set, th, lt_node) {
609 switch (th->status) {
610 case THREAD_RUNNABLE:
612 case THREAD_STOPPED_FOREVER:
625 VM_ASSERT(th != NULL);
629 RUBY_DEBUG_LOG(
"r(%d)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
630 ccan_list_add_tail(&r->threads.set, &th->lt_node);
636 if (r->threads.cnt == 1) {
637 VM_ASSERT(ractor_status_p(r, ractor_created));
638 vm_insert_ractor(th->vm, r);
645 ractor_status_set(r, ractor_blocking);
647 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
648 vm->ractor.blocking_cnt++;
649 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
653rb_vm_ractor_blocking_cnt_inc(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
656 VM_ASSERT(GET_RACTOR() == cr);
657 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
661rb_vm_ractor_blocking_cnt_dec(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
664 VM_ASSERT(GET_RACTOR() == cr);
666 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
667 VM_ASSERT(vm->ractor.blocking_cnt > 0);
668 vm->ractor.blocking_cnt--;
670 ractor_status_set(cr, ractor_running);
674ractor_check_blocking(
rb_ractor_t *cr,
unsigned int remained_thread_cnt,
const char *file,
int line)
676 VM_ASSERT(cr == GET_RACTOR());
678 RUBY_DEBUG_LOG2(file, line,
679 "cr->threads.cnt:%u cr->threads.blocking_cnt:%u vm->ractor.cnt:%u vm->ractor.blocking_cnt:%u",
680 cr->threads.cnt, cr->threads.blocking_cnt,
681 GET_VM()->ractor.cnt, GET_VM()->ractor.blocking_cnt);
683 VM_ASSERT(cr->threads.cnt >= cr->threads.blocking_cnt + 1);
685 if (remained_thread_cnt > 0 &&
687 cr->threads.cnt == cr->threads.blocking_cnt + 1) {
692 rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);
702 VM_ASSERT(cr == GET_RACTOR());
703 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
704 ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
706 rb_threadptr_remove(th);
708 if (cr->threads.cnt == 1) {
709 vm_remove_ractor(th->vm, cr);
714 ccan_list_del(&th->lt_node);
722rb_ractor_blocking_threads_inc(
rb_ractor_t *cr,
const char *file,
int line)
724 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
726 VM_ASSERT(cr->threads.cnt > 0);
727 VM_ASSERT(cr == GET_RACTOR());
729 ractor_check_blocking(cr, cr->threads.cnt, __FILE__, __LINE__);
730 cr->threads.blocking_cnt++;
734rb_ractor_blocking_threads_dec(
rb_ractor_t *cr,
const char *file,
int line)
736 RUBY_DEBUG_LOG2(file, line,
737 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
738 cr->threads.blocking_cnt, cr->threads.cnt);
740 VM_ASSERT(cr == GET_RACTOR());
742 if (cr->threads.cnt == cr->threads.blocking_cnt) {
746 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
750 cr->threads.blocking_cnt--;
754rb_ractor_vm_barrier_interrupt_running_thread(
rb_ractor_t *r)
756 VM_ASSERT(r != GET_RACTOR());
757 ASSERT_ractor_unlocking(r);
762 if (ractor_status_p(r, ractor_running)) {
765 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
773rb_ractor_terminate_interrupt_main_thread(
rb_ractor_t *r)
775 VM_ASSERT(r != GET_RACTOR());
776 ASSERT_ractor_unlocking(r);
781 if (main_th->status != THREAD_KILLED) {
782 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
783 rb_threadptr_interrupt(main_th);
786 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
794ractor_terminal_interrupt_all(
rb_vm_t *vm)
796 if (vm->ractor.cnt > 1) {
799 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
800 if (r != vm->ractor.main_ractor) {
801 RUBY_DEBUG_LOG(
"r:%d", rb_ractor_id(r));
802 rb_ractor_terminate_interrupt_main_thread(r);
812rb_ractor_terminate_all(
void)
817 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
819 VM_ASSERT(cr == GET_RACTOR());
821 if (vm->ractor.cnt > 1) {
824 ractor_terminal_interrupt_all(vm);
828 rb_thread_terminate_all(GET_THREAD());
832 while (vm->ractor.cnt > 1) {
833 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
834 vm->ractor.sync.terminate_waiting =
true;
837 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
838 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
839 rb_vm_cond_timedwait(vm, &vm->ractor.sync.terminate_cond, 1000 );
840 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
841 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
843 ractor_terminal_interrupt_all(vm);
850rb_vm_main_ractor_ec(
rb_vm_t *vm)
867 if (running_ec) {
return running_ec; }
868 return vm->ractor.main_thread->ec;
872ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
874 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
985 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
988 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
992 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
993 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
994 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
995 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1006 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1007 if (r != vm->ractor.main_ractor) {
1008 fprintf(stderr,
"r:%u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1016 if (rb_ractor_main_p()) {
1026rb_ractor_stdout(
void)
1028 if (rb_ractor_main_p()) {
1033 return cr->r_stdout;
1038rb_ractor_stderr(
void)
1040 if (rb_ractor_main_p()) {
1045 return cr->r_stderr;
1052 if (rb_ractor_main_p()) {
1064 if (rb_ractor_main_p()) {
1076 if (rb_ractor_main_p()) {
1088 return &cr->pub.hooks;
1097enum obj_traverse_iterator_result {
1103typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1104typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1105typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1107static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1110 rb_obj_traverse_enter_func enter_func;
1111 rb_obj_traverse_leave_func leave_func;
1130 if (obj_traverse_i(key, d->data)) {
1135 if (obj_traverse_i(val, d->data)) {
1144obj_traverse_reachable_i(
VALUE obj,
void *ptr)
1148 if (obj_traverse_i(obj, d->data)) {
1156 if (UNLIKELY(!data->rec)) {
1157 data->rec_hash = rb_ident_hash_new();
1158 data->rec = RHASH_ST_TABLE(data->rec_hash);
1164obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t ptr)
1168 if (obj_traverse_i(val, d->data)) {
1181 switch (data->enter_func(obj)) {
1182 case traverse_cont:
break;
1183 case traverse_skip:
return 0;
1184 case traverse_stop:
return 1;
1187 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1198 if (d.stop)
return 1;
1219 if (obj_traverse_i(e, data))
return 1;
1233 if (d.stop)
return 1;
1239 long len = RSTRUCT_LEN(obj);
1240 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1242 for (
long i=0; i<
len; i++) {
1243 if (obj_traverse_i(ptr[i], data))
return 1;
1249 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1250 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1253 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1254 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1264 RB_VM_LOCKING_NO_BARRIER() {
1265 rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);
1267 if (d.stop)
return 1;
1277 rb_bug(
"unreachable");
1280 if (data->leave_func(obj) == traverse_stop) {
1289 rb_obj_traverse_final_func final_func;
1294obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1297 if (data->final_func(key)) {
1307rb_obj_traverse(
VALUE obj,
1308 rb_obj_traverse_enter_func enter_func,
1309 rb_obj_traverse_leave_func leave_func,
1310 rb_obj_traverse_final_func final_func)
1313 .enter_func = enter_func,
1314 .leave_func = leave_func,
1318 if (obj_traverse_i(obj, &data))
return 1;
1319 if (final_func && data.rec) {
1321 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1328allow_frozen_shareable_p(
VALUE obj)
1335 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1343static enum obj_traverse_iterator_result
1344make_shareable_check_shareable(
VALUE obj)
1349 return traverse_skip;
1351 else if (!allow_frozen_shareable_p(obj)) {
1353 rb_proc_ractor_make_shareable(obj);
1354 return traverse_cont;
1357 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
1361 switch (
TYPE(obj)) {
1363 return traverse_skip;
1370 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1371 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1372 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
1373 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
1386 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1390 return traverse_skip;
1394 return traverse_cont;
1397static enum obj_traverse_iterator_result
1398mark_shareable(
VALUE obj)
1401 return traverse_cont;
1407 rb_obj_traverse(obj,
1408 make_shareable_check_shareable,
1409 null_leave, mark_shareable);
1416 VALUE copy = ractor_copy(obj);
1421rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
1424 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
1432rb_ractor_ensure_main_ractor(
const char *msg)
1434 if (!rb_ractor_main_p()) {
1435 rb_raise(rb_eRactorIsolationError,
"%s", msg);
1439static enum obj_traverse_iterator_result
1440shareable_p_enter(
VALUE obj)
1443 return traverse_skip;
1449 mark_shareable(obj);
1450 return traverse_skip;
1453 allow_frozen_shareable_p(obj)) {
1454 return traverse_cont;
1457 return traverse_stop;
1461rb_ractor_shareable_p_continue(
VALUE obj)
1463 if (rb_obj_traverse(obj,
1464 shareable_p_enter, null_leave,
1473#if RACTOR_CHECK_MODE > 0
1475rb_ractor_setup_belonging(
VALUE obj)
1477 rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
1480static enum obj_traverse_iterator_result
1481reset_belonging_enter(
VALUE obj)
1484 return traverse_skip;
1487 rb_ractor_setup_belonging(obj);
1488 return traverse_cont;
1493static enum obj_traverse_iterator_result
1494null_leave(
VALUE obj)
1496 return traverse_cont;
1500ractor_reset_belonging(
VALUE obj)
1502#if RACTOR_CHECK_MODE > 0
1503 rb_obj_traverse(obj, reset_belonging_enter, null_leave, NULL);
1521 rb_obj_traverse_replace_enter_func enter_func;
1522 rb_obj_traverse_replace_leave_func leave_func;
1538obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
1544obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t ptr,
int exists)
1549 if (obj_traverse_replace_i(*key, data)) {
1553 else if (*key != data->replacement) {
1554 VALUE v = *key = data->replacement;
1558 if (obj_traverse_replace_i(*val, data)) {
1562 else if (*val != data->replacement) {
1563 VALUE v = *val = data->replacement;
1571obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
1577obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t ptr,
int exists)
1582 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
1586 else if (*(
VALUE *)val != data->replacement) {
1597 if (UNLIKELY(!data->rec)) {
1598 data->rec_hash = rb_ident_hash_new();
1599 data->rec = RHASH_ST_TABLE(data->rec_hash);
1605obj_refer_only_shareables_p_i(
VALUE obj,
void *ptr)
1607 int *pcnt = (
int *)ptr;
1615obj_refer_only_shareables_p(
VALUE obj)
1618 RB_VM_LOCKING_NO_BARRIER() {
1619 rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);
1627 st_data_t replacement;
1630 data->replacement = obj;
1634 switch (data->enter_func(obj, data)) {
1635 case traverse_cont:
break;
1636 case traverse_skip:
return 0;
1637 case traverse_stop:
return 1;
1640 replacement = (st_data_t)data->replacement;
1642 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
1643 data->replacement = (
VALUE)replacement;
1647 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
1656#define CHECK_AND_REPLACE(v) do { \
1658 if (obj_traverse_replace_i(_val, data)) { return 1; } \
1659 else if (data->replacement != _val) { RB_OBJ_WRITE(obj, &v, data->replacement); } \
1662 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1664 rb_ivar_generic_fields_tbl_lookup(obj, &fields_obj);
1666 if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {
1672 rb_st_foreach_with_replace(
1673 rb_imemo_fields_complex_tbl(fields_obj),
1674 obj_iv_hash_traverse_replace_foreach_i,
1675 obj_iv_hash_traverse_replace_i,
1678 if (d.stop)
return 1;
1681 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
1682 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
1683 for (uint32_t i = 0; i < fields_count; i++) {
1684 CHECK_AND_REPLACE(fields[i]);
1699 rb_str_make_independent(obj);
1704 if (rb_shape_obj_too_complex_p(obj)) {
1710 rb_st_foreach_with_replace(
1711 ROBJECT_FIELDS_HASH(obj),
1712 obj_iv_hash_traverse_replace_foreach_i,
1713 obj_iv_hash_traverse_replace_i,
1716 if (d.stop)
return 1;
1719 uint32_t
len = ROBJECT_FIELDS_COUNT(obj);
1722 for (uint32_t i = 0; i <
len; i++) {
1723 CHECK_AND_REPLACE(ptr[i]);
1731 rb_ary_cancel_sharing(obj);
1736 if (obj_traverse_replace_i(e, data)) {
1739 else if (e != data->replacement) {
1753 rb_hash_stlike_foreach_with_replace(obj,
1754 obj_hash_traverse_replace_foreach_i,
1755 obj_hash_traverse_replace_i,
1757 if (d.stop)
return 1;
1761 if (obj_traverse_replace_i(ifnone, data)) {
1764 else if (ifnone != data->replacement) {
1772 long len = RSTRUCT_LEN(obj);
1773 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1775 for (
long i=0; i<
len; i++) {
1776 CHECK_AND_REPLACE(ptr[i]);
1782 CHECK_AND_REPLACE(RRATIONAL(obj)->num);
1783 CHECK_AND_REPLACE(RRATIONAL(obj)->den);
1786 CHECK_AND_REPLACE(RCOMPLEX(obj)->real);
1787 CHECK_AND_REPLACE(RCOMPLEX(obj)->imag);
1791 if (!data->move && obj_refer_only_shareables_p(obj)) {
1795 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
1809 rb_bug(
"unreachable");
1812 data->replacement = (
VALUE)replacement;
1814 if (data->leave_func(obj, data) == traverse_stop) {
1825rb_obj_traverse_replace(
VALUE obj,
1826 rb_obj_traverse_replace_enter_func enter_func,
1827 rb_obj_traverse_replace_leave_func leave_func,
1831 .enter_func = enter_func,
1832 .leave_func = leave_func,
1838 if (obj_traverse_replace_i(obj, &data)) {
1842 return data.replacement;
1846static const bool wb_protected_types[
RUBY_T_MASK] = {
1859static enum obj_traverse_iterator_result
1863 data->replacement = obj;
1864 return traverse_skip;
1869 NEWOBJ_OF(moved,
struct RBasic, 0,
type, rb_gc_obj_slot_size(obj), 0);
1870 data->replacement = (
VALUE)moved;
1871 return traverse_cont;
1875static enum obj_traverse_iterator_result
1880 RBASIC(data->replacement)->flags = (
RBASIC(obj)->flags & ~ignored_flags) | (
RBASIC(data->replacement)->flags & ignored_flags);
1883 (
char *)data->replacement +
sizeof(
VALUE),
1884 (
char *)obj +
sizeof(
VALUE),
1885 rb_gc_obj_slot_size(obj) -
sizeof(
VALUE)
1889 rb_gc_writebarrier_remember(data->replacement);
1891 void rb_replace_generic_ivar(
VALUE clone,
VALUE obj);
1893 rb_gc_obj_id_moved(data->replacement);
1895 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1896 rb_replace_generic_ivar(data->replacement, obj);
1903 RBASIC(obj)->flags = flags;
1904 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
1905 return traverse_cont;
1909ractor_move(
VALUE obj)
1911 VALUE val = rb_obj_traverse_replace(obj, move_enter, move_leave,
true);
1912 if (!UNDEF_P(val)) {
1916 rb_raise(rb_eRactorError,
"can not move the object");
1920static enum obj_traverse_iterator_result
1924 data->replacement = obj;
1925 return traverse_skip;
1929 return traverse_cont;
1933static enum obj_traverse_iterator_result
1936 return traverse_cont;
1940ractor_copy(
VALUE obj)
1942 VALUE val = rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
1943 if (!UNDEF_P(val)) {
1947 rb_raise(rb_eRactorError,
"can not copy the object");
1962} freed_ractor_local_keys;
1965ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1968 if (k->type->
mark) (*k->type->
mark)((
void *)val);
1972static enum rb_id_table_iterator_result
1973idkey_local_storage_mark_i(
VALUE val,
void *dmy)
1976 return ID_TABLE_CONTINUE;
1982 if (r->local_storage) {
1983 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
1985 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
1987 st_data_t val, k = (st_data_t)key;
1988 if (st_delete(r->local_storage, &k, &val) &&
1990 (*key->type->free)((
void *)val);
1995 if (r->idkey_local_storage) {
1996 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
1999 rb_gc_mark(r->local_storage_store_lock);
2003ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
2006 if (k->type->
free) (*k->type->
free)((
void *)val);
2013 if (r->local_storage) {
2014 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
2015 st_free_table(r->local_storage);
2018 if (r->idkey_local_storage) {
2019 rb_id_table_free(r->idkey_local_storage);
2024rb_ractor_local_storage_value_mark(
void *ptr)
2026 rb_gc_mark((
VALUE)ptr);
2040 rb_ractor_local_storage_value_mark,
2048 key->type =
type ?
type : &ractor_local_storage_type_null;
2049 key->main_cache = (
void *)
Qundef;
2063 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
2064 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
2067 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
2074 if (rb_ractor_main_p()) {
2075 if (!UNDEF_P((
VALUE)key->main_cache)) {
2076 *pret = key->main_cache;
2086 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
2100 if (cr->local_storage == NULL) {
2101 cr->local_storage = st_init_numtable();
2104 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)ptr);
2106 if (rb_ractor_main_p()) {
2107 key->main_cache = ptr;
2115 if (ractor_local_ref(key, &val)) {
2126 if (ractor_local_ref(key, (
void **)val)) {
2137 ractor_local_set(key, (
void *)val);
2144 if (ractor_local_ref(key, &ret)) {
2155 ractor_local_set(key, ptr);
2158#define DEFAULT_KEYS_CAPA 0x10
2161rb_ractor_finish_marking(
void)
2163 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2164 ruby_xfree(freed_ractor_local_keys.keys[i]);
2166 freed_ractor_local_keys.cnt = 0;
2167 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
2168 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
2178 struct rb_id_table *tbl = cr->idkey_local_storage;
2181 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
2194 struct rb_id_table *tbl = cr->idkey_local_storage;
2197 tbl = cr->idkey_local_storage = rb_id_table_create(2);
2199 rb_id_table_insert(tbl,
id, val);
2211ractor_local_value_store_i(
VALUE ptr)
2216 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
2221 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
2234 .tbl = cr->idkey_local_storage,
2238 if (data.tbl == NULL) {
2239 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
2241 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
2246 if (!cr->local_storage_store_lock) {
2269cross_ractor_require_mark(
void *ptr)
2272 rb_gc_mark(crr->port);
2273 rb_gc_mark(crr->result);
2274 rb_gc_mark(crr->exception);
2275 rb_gc_mark(crr->feature);
2276 rb_gc_mark(crr->module);
2280 "ractor/cross_ractor_require",
2282 cross_ractor_require_mark,
2287 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
2291require_body(
VALUE data)
2297 crr->result = rb_funcallv(
Qnil, require, 1, &crr->feature);
2306 crr->exception = errinfo;
2311require_result_copy_body(
VALUE data)
2315 if (crr->exception !=
Qundef) {
2316 VM_ASSERT(crr->result ==
Qundef);
2317 crr->exception = ractor_copy(crr->exception);
2320 VM_ASSERT(crr->result !=
Qundef);
2321 crr->result = ractor_copy(crr->result);
2328require_result_copy_resuce(
VALUE data,
VALUE errinfo)
2331 crr->exception = errinfo;
2348 ractor_port_send(GET_EC(), crr->port,
Qtrue,
Qfalse);
2354ractor_require_func(
void *crr_obj)
2356 return ractor_require_protect((
VALUE)crr_obj, require_body);
2360rb_ractor_require(
VALUE feature)
2368 crr->port = ractor_port_new(GET_RACTOR());
2373 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2374 rb_ractor_interrupt_exec(main_r, ractor_require_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2377 ractor_port_receive(ec, crr->port);
2378 ractor_port_close(ec, crr->port);
2380 VALUE exc = crr->exception;
2381 VALUE result = crr->result;
2385 ractor_reset_belonging(exc);
2390 ractor_reset_belonging(result);
2398 return rb_ractor_require(feature);
2402autoload_load_body(
VALUE data)
2410ractor_autoload_load_func(
void *crr_obj)
2412 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
2416rb_ractor_autoload_load(
VALUE module,
ID name)
2421 crr->module =
module;
2423 crr->port = ractor_port_new(GET_RACTOR());
2428 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2429 rb_ractor_interrupt_exec(main_r, ractor_autoload_load_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2432 ractor_port_receive(ec, crr->port);
2433 ractor_port_close(ec, crr->port);
2435 VALUE exc = crr->exception;
2436 VALUE result = crr->result;
2447#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 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.
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_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.