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);
518 r->pub.id = ractor_next_id();
519 RUBY_DEBUG_LOG(
"r:%u", r->pub.id);
522 r->verbose = cr->verbose;
523 r->debug = cr->debug;
525 rb_yjit_before_ractor_spawn();
526 rb_zjit_before_ractor_spawn();
527 rb_thread_create_ractor(r, args, block);
538 return ractor_create(rb_current_ec_noinline(), klass, loc, name, args, block);
545 ractor_notify_exit(ec, cr, result, exc);
552 ractor_atexit(ec, cr, result,
false);
559 ractor_atexit(ec, cr, ec->errinfo,
true);
569 VM_ASSERT(cr->threads.main != NULL);
570 cr->threads.main = NULL;
577 for (
int i=0; i<
len; i++) {
578 ptr[i] = ractor_receive(ec, ractor_default_port(r));
586 for (
int i=0; i<
len; i++) {
587 ractor_send(ec, ractor_default_port(r),
RARRAY_AREF(args, i),
false);
592rb_ractor_main_p_(
void)
594 VM_ASSERT(rb_multi_ractor_p());
596 return rb_ec_ractor_ptr(ec) == rb_ec_vm_ptr(ec)->ractor.main_ractor;
602 return r->threads.cnt;
607rb_ractor_thread_list(
void)
613 ccan_list_for_each(&r->threads.set, th, lt_node) {
614 switch (th->status) {
615 case THREAD_RUNNABLE:
617 case THREAD_STOPPED_FOREVER:
630 VM_ASSERT(th != NULL);
634 RUBY_DEBUG_LOG(
"r(%d)->threads.cnt:%d++", r->pub.id, r->threads.cnt);
635 ccan_list_add_tail(&r->threads.set, &th->lt_node);
641 if (r->threads.cnt == 1) {
642 VM_ASSERT(ractor_status_p(r, ractor_created));
643 vm_insert_ractor(th->vm, r);
650 ractor_status_set(r, ractor_blocking);
652 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d++", vm->ractor.blocking_cnt);
653 vm->ractor.blocking_cnt++;
654 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
658rb_vm_ractor_blocking_cnt_inc(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
661 VM_ASSERT(GET_RACTOR() == cr);
662 vm_ractor_blocking_cnt_inc(vm, cr, file, line);
666rb_vm_ractor_blocking_cnt_dec(
rb_vm_t *vm,
rb_ractor_t *cr,
const char *file,
int line)
669 VM_ASSERT(GET_RACTOR() == cr);
671 RUBY_DEBUG_LOG2(file, line,
"vm->ractor.blocking_cnt:%d--", vm->ractor.blocking_cnt);
672 VM_ASSERT(vm->ractor.blocking_cnt > 0);
673 vm->ractor.blocking_cnt--;
675 ractor_status_set(cr, ractor_running);
679ractor_check_blocking(
rb_ractor_t *cr,
unsigned int remained_thread_cnt,
const char *file,
int line)
681 VM_ASSERT(cr == GET_RACTOR());
683 RUBY_DEBUG_LOG2(file, line,
684 "cr->threads.cnt:%u cr->threads.blocking_cnt:%u vm->ractor.cnt:%u vm->ractor.blocking_cnt:%u",
685 cr->threads.cnt, cr->threads.blocking_cnt,
686 GET_VM()->ractor.cnt, GET_VM()->ractor.blocking_cnt);
688 VM_ASSERT(cr->threads.cnt >= cr->threads.blocking_cnt + 1);
690 if (remained_thread_cnt > 0 &&
692 cr->threads.cnt == cr->threads.blocking_cnt + 1) {
697 rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);
707 VM_ASSERT(cr == GET_RACTOR());
708 RUBY_DEBUG_LOG(
"r->threads.cnt:%d--", cr->threads.cnt);
709 ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
711 rb_threadptr_remove(th);
713 if (cr->threads.cnt == 1) {
714 vm_remove_ractor(th->vm, cr);
719 ccan_list_del(&th->lt_node);
727rb_ractor_blocking_threads_inc(
rb_ractor_t *cr,
const char *file,
int line)
729 RUBY_DEBUG_LOG2(file, line,
"cr->threads.blocking_cnt:%d++", cr->threads.blocking_cnt);
731 VM_ASSERT(cr->threads.cnt > 0);
732 VM_ASSERT(cr == GET_RACTOR());
734 ractor_check_blocking(cr, cr->threads.cnt, __FILE__, __LINE__);
735 cr->threads.blocking_cnt++;
739rb_ractor_blocking_threads_dec(
rb_ractor_t *cr,
const char *file,
int line)
741 RUBY_DEBUG_LOG2(file, line,
742 "r->threads.blocking_cnt:%d--, r->threads.cnt:%u",
743 cr->threads.blocking_cnt, cr->threads.cnt);
745 VM_ASSERT(cr == GET_RACTOR());
747 if (cr->threads.cnt == cr->threads.blocking_cnt) {
751 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
755 cr->threads.blocking_cnt--;
759rb_ractor_vm_barrier_interrupt_running_thread(
rb_ractor_t *r)
761 VM_ASSERT(r != GET_RACTOR());
762 ASSERT_ractor_unlocking(r);
767 if (ractor_status_p(r, ractor_running)) {
770 RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec);
778rb_ractor_terminate_interrupt_main_thread(
rb_ractor_t *r)
780 VM_ASSERT(r != GET_RACTOR());
781 ASSERT_ractor_unlocking(r);
786 if (main_th->status != THREAD_KILLED) {
787 RUBY_VM_SET_TERMINATE_INTERRUPT(main_th->ec);
788 rb_threadptr_interrupt(main_th);
791 RUBY_DEBUG_LOG(
"killed (%p)", (
void *)main_th);
799ractor_terminal_interrupt_all(
rb_vm_t *vm)
801 if (vm->ractor.cnt > 1) {
804 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
805 if (r != vm->ractor.main_ractor) {
806 RUBY_DEBUG_LOG(
"r:%d", rb_ractor_id(r));
807 rb_ractor_terminate_interrupt_main_thread(r);
817rb_ractor_terminate_all(
void)
822 RUBY_DEBUG_LOG(
"ractor.cnt:%d", (
int)vm->ractor.cnt);
824 VM_ASSERT(cr == GET_RACTOR());
826 if (vm->ractor.cnt > 1) {
829 ractor_terminal_interrupt_all(vm);
833 rb_thread_terminate_all(GET_THREAD());
837 while (vm->ractor.cnt > 1) {
838 RUBY_DEBUG_LOG(
"terminate_waiting:%d", vm->ractor.sync.terminate_waiting);
839 vm->ractor.sync.terminate_waiting =
true;
842 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
843 rb_del_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
844 rb_vm_cond_timedwait(vm, &vm->ractor.sync.terminate_cond, 1000 );
845 rb_add_running_thread(rb_ec_thread_ptr(cr->threads.running_ec));
846 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
848 ractor_terminal_interrupt_all(vm);
855rb_vm_main_ractor_ec(
rb_vm_t *vm)
872 if (running_ec) {
return running_ec; }
873 return vm->ractor.main_thread->ec;
877ractor_moved_missing(
int argc,
VALUE *argv,
VALUE self)
879 rb_raise(rb_eRactorMovedError,
"can not send any methods to a moved object");
1009 rb_define_method(rb_cRactorMovedObject,
"method_missing", ractor_moved_missing, -1);
1012 rb_define_method(rb_cRactorMovedObject,
"__send__", ractor_moved_missing, -1);
1016 rb_define_method(rb_cRactorMovedObject,
"__id__", ractor_moved_missing, -1);
1017 rb_define_method(rb_cRactorMovedObject,
"equal?", ractor_moved_missing, -1);
1018 rb_define_method(rb_cRactorMovedObject,
"instance_eval", ractor_moved_missing, -1);
1019 rb_define_method(rb_cRactorMovedObject,
"instance_exec", ractor_moved_missing, -1);
1030 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
1031 if (r != vm->ractor.main_ractor) {
1032 fprintf(stderr,
"r:%u (%s)\n", r->pub.id, ractor_status_str(r->status_));
1040 if (rb_ractor_main_p()) {
1050rb_ractor_stdout(
void)
1052 if (rb_ractor_main_p()) {
1057 return cr->r_stdout;
1062rb_ractor_stderr(
void)
1064 if (rb_ractor_main_p()) {
1069 return cr->r_stderr;
1076 if (rb_ractor_main_p()) {
1088 if (rb_ractor_main_p()) {
1100 if (rb_ractor_main_p()) {
1112 return &cr->pub.hooks;
1121enum obj_traverse_iterator_result {
1127typedef enum obj_traverse_iterator_result (*rb_obj_traverse_enter_func)(
VALUE obj);
1128typedef enum obj_traverse_iterator_result (*rb_obj_traverse_leave_func)(
VALUE obj);
1129typedef enum obj_traverse_iterator_result (*rb_obj_traverse_final_func)(
VALUE obj);
1131static enum obj_traverse_iterator_result null_leave(
VALUE obj);
1134 rb_obj_traverse_enter_func enter_func;
1135 rb_obj_traverse_leave_func leave_func;
1154 if (obj_traverse_i(key, d->data)) {
1159 if (obj_traverse_i(val, d->data)) {
1168obj_traverse_reachable_i(
VALUE obj,
void *ptr)
1172 if (obj_traverse_i(obj, d->data)) {
1180 if (UNLIKELY(!data->rec)) {
1181 data->rec_hash = rb_ident_hash_new();
1182 data->rec = RHASH_ST_TABLE(data->rec_hash);
1188obj_traverse_ivar_foreach_i(
ID key,
VALUE val, st_data_t ptr)
1192 if (obj_traverse_i(val, d->data)) {
1205 switch (data->enter_func(obj)) {
1206 case traverse_cont:
break;
1207 case traverse_skip:
return 0;
1208 case traverse_stop:
return 1;
1211 if (UNLIKELY(st_insert(obj_traverse_rec(data), obj, 1))) {
1222 if (d.stop)
return 1;
1243 if (obj_traverse_i(e, data))
return 1;
1257 if (d.stop)
return 1;
1263 long len = RSTRUCT_LEN(obj);
1264 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1266 for (
long i=0; i<
len; i++) {
1267 if (obj_traverse_i(ptr[i], data))
return 1;
1273 if (obj_traverse_i(RRATIONAL(obj)->num, data))
return 1;
1274 if (obj_traverse_i(RRATIONAL(obj)->den, data))
return 1;
1277 if (obj_traverse_i(RCOMPLEX(obj)->real, data))
return 1;
1278 if (obj_traverse_i(RCOMPLEX(obj)->imag, data))
return 1;
1288 RB_VM_LOCKING_NO_BARRIER() {
1289 rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);
1291 if (d.stop)
return 1;
1301 rb_bug(
"unreachable");
1304 if (data->leave_func(obj) == traverse_stop) {
1313 rb_obj_traverse_final_func final_func;
1318obj_traverse_final_i(st_data_t key, st_data_t val, st_data_t arg)
1321 if (data->final_func(key)) {
1331rb_obj_traverse(
VALUE obj,
1332 rb_obj_traverse_enter_func enter_func,
1333 rb_obj_traverse_leave_func leave_func,
1334 rb_obj_traverse_final_func final_func)
1337 .enter_func = enter_func,
1338 .leave_func = leave_func,
1342 if (obj_traverse_i(obj, &data))
return 1;
1343 if (final_func && data.rec) {
1345 st_foreach(data.rec, obj_traverse_final_i, (st_data_t)&f);
1352allow_frozen_shareable_p(
VALUE obj)
1359 if (
type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
1367static enum obj_traverse_iterator_result
1368make_shareable_check_shareable(
VALUE obj)
1373 return traverse_skip;
1375 else if (!allow_frozen_shareable_p(obj)) {
1377 rb_proc_ractor_make_shareable(obj);
1378 return traverse_cont;
1381 rb_raise(rb_eRactorError,
"can not make shareable object for %+"PRIsVALUE, obj);
1385 switch (
TYPE(obj)) {
1387 return traverse_skip;
1394 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1395 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1396 attr_index_t free_capacity = capacity - RSHAPE_LEN(shape_id);
1397 if (!rb_shape_has_object_id(shape_id) && capacity && !free_capacity) {
1410 rb_raise(rb_eRactorError,
"#freeze does not freeze object correctly");
1414 return traverse_skip;
1418 return traverse_cont;
1421static enum obj_traverse_iterator_result
1422mark_shareable(
VALUE obj)
1425 return traverse_cont;
1431 rb_obj_traverse(obj,
1432 make_shareable_check_shareable,
1433 null_leave, mark_shareable);
1440 VALUE copy = ractor_copy(obj);
1445rb_ractor_ensure_shareable(
VALUE obj,
VALUE name)
1448 VALUE message = rb_sprintf(
"cannot assign unshareable object to %"PRIsVALUE,
1456rb_ractor_ensure_main_ractor(
const char *msg)
1458 if (!rb_ractor_main_p()) {
1459 rb_raise(rb_eRactorIsolationError,
"%s", msg);
1463static enum obj_traverse_iterator_result
1464shareable_p_enter(
VALUE obj)
1467 return traverse_skip;
1473 mark_shareable(obj);
1474 return traverse_skip;
1477 allow_frozen_shareable_p(obj)) {
1478 return traverse_cont;
1481 return traverse_stop;
1485rb_ractor_shareable_p_continue(
VALUE obj)
1487 if (rb_obj_traverse(obj,
1488 shareable_p_enter, null_leave,
1497#if RACTOR_CHECK_MODE > 0
1499rb_ractor_setup_belonging(
VALUE obj)
1501 rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
1504static enum obj_traverse_iterator_result
1505reset_belonging_enter(
VALUE obj)
1508 return traverse_skip;
1511 rb_ractor_setup_belonging(obj);
1512 return traverse_cont;
1517static enum obj_traverse_iterator_result
1518null_leave(
VALUE obj)
1520 return traverse_cont;
1524ractor_reset_belonging(
VALUE obj)
1526#if RACTOR_CHECK_MODE > 0
1527 rb_obj_traverse(obj, reset_belonging_enter, null_leave, NULL);
1545 rb_obj_traverse_replace_enter_func enter_func;
1546 rb_obj_traverse_replace_leave_func leave_func;
1562obj_hash_traverse_replace_foreach_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
1568obj_hash_traverse_replace_i(st_data_t *key, st_data_t *val, st_data_t ptr,
int exists)
1573 if (obj_traverse_replace_i(*key, data)) {
1577 else if (*key != data->replacement) {
1578 VALUE v = *key = data->replacement;
1582 if (obj_traverse_replace_i(*val, data)) {
1586 else if (*val != data->replacement) {
1587 VALUE v = *val = data->replacement;
1595obj_iv_hash_traverse_replace_foreach_i(st_data_t _key, st_data_t _val, st_data_t _data,
int _x)
1601obj_iv_hash_traverse_replace_i(st_data_t * _key, st_data_t * val, st_data_t ptr,
int exists)
1606 if (obj_traverse_replace_i(*(
VALUE *)val, data)) {
1610 else if (*(
VALUE *)val != data->replacement) {
1621 if (UNLIKELY(!data->rec)) {
1622 data->rec_hash = rb_ident_hash_new();
1623 data->rec = RHASH_ST_TABLE(data->rec_hash);
1629obj_refer_only_shareables_p_i(
VALUE obj,
void *ptr)
1631 int *pcnt = (
int *)ptr;
1639obj_refer_only_shareables_p(
VALUE obj)
1642 RB_VM_LOCKING_NO_BARRIER() {
1643 rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);
1651 st_data_t replacement;
1654 data->replacement = obj;
1658 switch (data->enter_func(obj, data)) {
1659 case traverse_cont:
break;
1660 case traverse_skip:
return 0;
1661 case traverse_stop:
return 1;
1664 replacement = (st_data_t)data->replacement;
1666 if (UNLIKELY(st_lookup(obj_traverse_replace_rec(data), (st_data_t)obj, &replacement))) {
1667 data->replacement = (
VALUE)replacement;
1671 st_insert(obj_traverse_replace_rec(data), (st_data_t)obj, replacement);
1680#define CHECK_AND_REPLACE(parent_obj, v) do { \
1682 if (obj_traverse_replace_i(_val, data)) { return 1; } \
1683 else if (data->replacement != _val) { RB_OBJ_WRITE(parent_obj, &v, data->replacement); } \
1686 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1687 VALUE fields_obj = rb_obj_fields_no_ractor_check(obj);
1689 if (UNLIKELY(rb_shape_obj_too_complex_p(obj))) {
1695 rb_st_foreach_with_replace(
1696 rb_imemo_fields_complex_tbl(fields_obj),
1697 obj_iv_hash_traverse_replace_foreach_i,
1698 obj_iv_hash_traverse_replace_i,
1701 if (d.stop)
return 1;
1704 uint32_t fields_count = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
1705 VALUE *fields = rb_imemo_fields_ptr(fields_obj);
1706 for (uint32_t i = 0; i < fields_count; i++) {
1707 CHECK_AND_REPLACE(fields_obj, fields[i]);
1722 rb_str_make_independent(obj);
1727 if (rb_shape_obj_too_complex_p(obj)) {
1733 rb_st_foreach_with_replace(
1734 ROBJECT_FIELDS_HASH(obj),
1735 obj_iv_hash_traverse_replace_foreach_i,
1736 obj_iv_hash_traverse_replace_i,
1739 if (d.stop)
return 1;
1742 uint32_t
len = ROBJECT_FIELDS_COUNT(obj);
1745 for (uint32_t i = 0; i <
len; i++) {
1746 CHECK_AND_REPLACE(obj, ptr[i]);
1754 rb_ary_cancel_sharing(obj);
1759 if (obj_traverse_replace_i(e, data)) {
1762 else if (e != data->replacement) {
1776 rb_hash_stlike_foreach_with_replace(obj,
1777 obj_hash_traverse_replace_foreach_i,
1778 obj_hash_traverse_replace_i,
1780 if (d.stop)
return 1;
1784 if (obj_traverse_replace_i(ifnone, data)) {
1787 else if (ifnone != data->replacement) {
1795 long len = RSTRUCT_LEN(obj);
1796 const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
1798 for (
long i=0; i<
len; i++) {
1799 CHECK_AND_REPLACE(obj, ptr[i]);
1805 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->num);
1806 CHECK_AND_REPLACE(obj, RRATIONAL(obj)->den);
1809 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->real);
1810 CHECK_AND_REPLACE(obj, RCOMPLEX(obj)->imag);
1814 if (!data->move && obj_refer_only_shareables_p(obj)) {
1818 rb_raise(rb_eRactorError,
"can not %s %"PRIsVALUE
" object.",
1832 rb_bug(
"unreachable");
1835 data->replacement = (
VALUE)replacement;
1837 if (data->leave_func(obj, data) == traverse_stop) {
1848rb_obj_traverse_replace(
VALUE obj,
1849 rb_obj_traverse_replace_enter_func enter_func,
1850 rb_obj_traverse_replace_leave_func leave_func,
1854 .enter_func = enter_func,
1855 .leave_func = leave_func,
1861 if (obj_traverse_replace_i(obj, &data)) {
1865 return data.replacement;
1869static const bool wb_protected_types[
RUBY_T_MASK] = {
1882static enum obj_traverse_iterator_result
1886 data->replacement = obj;
1887 return traverse_skip;
1892 NEWOBJ_OF(moved,
struct RBasic, 0,
type, rb_gc_obj_slot_size(obj), 0);
1893 data->replacement = (
VALUE)moved;
1894 return traverse_cont;
1898static enum obj_traverse_iterator_result
1903 RBASIC(data->replacement)->flags = (
RBASIC(obj)->flags & ~ignored_flags) | (
RBASIC(data->replacement)->flags & ignored_flags);
1906 (
char *)data->replacement +
sizeof(
VALUE),
1907 (
char *)obj +
sizeof(
VALUE),
1908 rb_gc_obj_slot_size(obj) -
sizeof(
VALUE)
1912 rb_gc_writebarrier_remember(data->replacement);
1914 void rb_replace_generic_ivar(
VALUE clone,
VALUE obj);
1916 rb_gc_obj_id_moved(data->replacement);
1918 if (UNLIKELY(rb_obj_exivar_p(obj))) {
1919 rb_replace_generic_ivar(data->replacement, obj);
1926 RBASIC(obj)->flags = flags;
1927 RBASIC_SET_CLASS_RAW(obj, rb_cRactorMovedObject);
1928 return traverse_cont;
1932ractor_move(
VALUE obj)
1934 VALUE val = rb_obj_traverse_replace(obj, move_enter, move_leave,
true);
1935 if (!UNDEF_P(val)) {
1939 rb_raise(rb_eRactorError,
"can not move the object");
1943static enum obj_traverse_iterator_result
1947 data->replacement = obj;
1948 return traverse_skip;
1952 return traverse_cont;
1956static enum obj_traverse_iterator_result
1959 return traverse_cont;
1963ractor_copy(
VALUE obj)
1965 VALUE val = rb_obj_traverse_replace(obj, copy_enter, copy_leave,
false);
1966 if (!UNDEF_P(val)) {
1970 rb_raise(rb_eRactorError,
"can not copy the object");
1985} freed_ractor_local_keys;
1988ractor_local_storage_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1991 if (k->type->
mark) (*k->type->
mark)((
void *)val);
1995static enum rb_id_table_iterator_result
1996idkey_local_storage_mark_i(
VALUE val,
void *dmy)
1999 return ID_TABLE_CONTINUE;
2005 if (r->local_storage) {
2006 st_foreach(r->local_storage, ractor_local_storage_mark_i, 0);
2008 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2010 st_data_t val, k = (st_data_t)key;
2011 if (st_delete(r->local_storage, &k, &val) &&
2013 (*key->type->free)((
void *)val);
2018 if (r->idkey_local_storage) {
2019 rb_id_table_foreach_values(r->idkey_local_storage, idkey_local_storage_mark_i, NULL);
2022 rb_gc_mark(r->local_storage_store_lock);
2026ractor_local_storage_free_i(st_data_t key, st_data_t val, st_data_t dmy)
2029 if (k->type->
free) (*k->type->
free)((
void *)val);
2036 if (r->local_storage) {
2037 st_foreach(r->local_storage, ractor_local_storage_free_i, 0);
2038 st_free_table(r->local_storage);
2041 if (r->idkey_local_storage) {
2042 rb_id_table_free(r->idkey_local_storage);
2047rb_ractor_local_storage_value_mark(
void *ptr)
2049 rb_gc_mark((
VALUE)ptr);
2063 rb_ractor_local_storage_value_mark,
2071 key->type =
type ?
type : &ractor_local_storage_type_null;
2072 key->main_cache = (
void *)
Qundef;
2086 if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {
2087 freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;
2090 freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;
2097 if (rb_ractor_main_p()) {
2098 if (!UNDEF_P((
VALUE)key->main_cache)) {
2099 *pret = key->main_cache;
2109 if (cr->local_storage && st_lookup(cr->local_storage, (st_data_t)key, (st_data_t *)pret)) {
2123 if (cr->local_storage == NULL) {
2124 cr->local_storage = st_init_numtable();
2127 st_insert(cr->local_storage, (st_data_t)key, (st_data_t)ptr);
2129 if (rb_ractor_main_p()) {
2130 key->main_cache = ptr;
2138 if (ractor_local_ref(key, &val)) {
2149 if (ractor_local_ref(key, (
void **)val)) {
2160 ractor_local_set(key, (
void *)val);
2167 if (ractor_local_ref(key, &ret)) {
2178 ractor_local_set(key, ptr);
2181#define DEFAULT_KEYS_CAPA 0x10
2184rb_ractor_finish_marking(
void)
2186 for (
int i=0; i<freed_ractor_local_keys.cnt; i++) {
2187 ruby_xfree(freed_ractor_local_keys.keys[i]);
2189 freed_ractor_local_keys.cnt = 0;
2190 if (freed_ractor_local_keys.capa > DEFAULT_KEYS_CAPA) {
2191 freed_ractor_local_keys.capa = DEFAULT_KEYS_CAPA;
2201 struct rb_id_table *tbl = cr->idkey_local_storage;
2204 if (
id && tbl && rb_id_table_lookup(tbl,
id, &val)) {
2217 struct rb_id_table *tbl = cr->idkey_local_storage;
2220 tbl = cr->idkey_local_storage = rb_id_table_create(2);
2222 rb_id_table_insert(tbl,
id, val);
2234ractor_local_value_store_i(
VALUE ptr)
2239 if (rb_id_table_lookup(data->tbl, data->id, &val)) {
2244 ractor_local_value_set(data->ec,
Qnil, data->sym, val);
2257 .tbl = cr->idkey_local_storage,
2261 if (data.tbl == NULL) {
2262 data.tbl = cr->idkey_local_storage = rb_id_table_create(2);
2264 else if (rb_id_table_lookup(data.tbl, data.id, &val)) {
2269 if (!cr->local_storage_store_lock) {
2293RUBY_REFERENCES(cross_ractor_require_refs) = {
2303 "ractor/cross_ractor_require",
2305 RUBY_REFS_LIST_PTR(cross_ractor_require_refs),
2310 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_DECL_MARKING | RUBY_TYPED_EMBEDDABLE
2314require_body(
VALUE crr_obj)
2323 int rb_require_internal_silent(
VALUE fname);
2328 RB_OBJ_WRITE(crr_obj, &crr->result, rb_funcallv(
Qnil, require, 1, &crr->feature));
2346require_result_copy_body(
VALUE crr_obj)
2351 if (crr->exception !=
Qundef) {
2352 VM_ASSERT(crr->result ==
Qundef);
2353 RB_OBJ_WRITE(crr_obj, &crr->exception, ractor_copy(crr->exception));
2356 VM_ASSERT(crr->result !=
Qundef);
2357 RB_OBJ_WRITE(crr_obj, &crr->result, ractor_copy(crr->result));
2364require_result_copy_resuce(
VALUE crr_obj,
VALUE errinfo)
2380 const bool silent = crr->silent;
2381 VALUE debug, errinfo;
2384 errinfo = rb_errinfo();
2393 rb_set_errinfo(errinfo);
2396 rb_rescue2(require_result_copy_body, crr_obj,
2399 ractor_port_send(GET_EC(), crr->port,
Qtrue,
Qfalse);
2405ractor_require_func(
void *crr_obj)
2407 return ractor_require_protect((
VALUE)crr_obj, require_body);
2411rb_ractor_require(
VALUE feature,
bool silent)
2414 ASSERT_vm_unlocking();
2422 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2425 crr->silent = silent;
2428 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2429 rb_ractor_interrupt_exec(main_r, ractor_require_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;
2440 ractor_reset_belonging(exc);
2445 ractor_reset_belonging(result);
2453 return rb_ractor_require(feature,
false);
2457autoload_load_body(
VALUE crr_obj)
2468ractor_autoload_load_func(
void *crr_obj)
2470 return ractor_require_protect((
VALUE)crr_obj, autoload_load_body);
2474rb_ractor_autoload_load(
VALUE module,
ID name)
2481 RB_OBJ_WRITE(crr_obj, &crr->port, ractor_port_new(GET_RACTOR()));
2486 rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
2487 rb_ractor_interrupt_exec(main_r, ractor_autoload_load_func, (
void *)crr_obj, rb_interrupt_exec_flag_value_data);
2490 ractor_port_receive(ec, crr->port);
2491 ractor_port_close(ec, crr->port);
2493 VALUE exc = crr->exception;
2494 VALUE result = crr->result;
2505#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_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.