15static VALUE rb_cRactorPort;
20static void ractor_add_port(
rb_ractor_t *r, st_data_t
id);
23ractor_port_mark(
void *ptr)
28 rb_gc_mark(rp->r->pub.self);
33ractor_port_free(
void *ptr)
39ractor_port_memsize(
const void *ptr)
52 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
59 return cr->sync.next_port_id++;
63RACTOR_PORT_PTR(
VALUE self)
71ractor_port_alloc(
VALUE klass)
85 rp->id_ = ractor_genid_for_port(r);
87 ractor_add_port(r, ractor_port_id(rp));
95ractor_port_initialzie(
VALUE self)
97 return ractor_port_init(self, GET_RACTOR());
101ractor_port_initialzie_copy(
VALUE self,
VALUE orig)
107 dst->id_ = ractor_port_id(src);
115 VALUE rpv = ractor_port_alloc(rb_cRactorPort);
116 ractor_port_init(rpv, r);
121ractor_port_p(
VALUE self)
129 const struct ractor_port *rp = RACTOR_PORT_PTR(self);
131 if (rp->r != rb_ec_ractor_ptr(ec)) {
132 rb_raise(rb_eRactorError,
"only allowed from the creator Ractor of this port");
135 return ractor_receive(ec, rp);
141 const struct ractor_port *rp = RACTOR_PORT_PTR(self);
142 ractor_send(ec, rp, obj,
RTEST(move));
152 const struct ractor_port *rp = RACTOR_PORT_PTR(self);
154 if (ractor_closed_port_p(ec, rp->r, rp)) {
165 const struct ractor_port *rp = RACTOR_PORT_PTR(self);
169 rb_raise(rb_eRactorError,
"closing port by other ractors is not allowed");
172 ractor_close_port(ec, cr, rp);
180enum ractor_basket_type {
191 enum ractor_basket_type type;
200 struct ccan_list_node node;
205ractor_basket_type_p(
const struct ractor_basket *b,
enum ractor_basket_type type)
207 return b->type == type;
213 return ractor_basket_type_p(b, basket_type_none);
230ractor_basket_alloc(
void)
239 struct ccan_list_head set;
246 ccan_list_head_init(&rq->set);
251ractor_queue_new(
void)
254 ractor_queue_init(rq);
263 ccan_list_for_each(&rq->set, b, node) {
264 ractor_basket_mark(b);
273 ccan_list_for_each_safe(&rq->set, b, nxt, node) {
274 ccan_list_del_init(&b->node);
275 ractor_basket_free(b);
278 VM_ASSERT(ccan_list_empty(&rq->set));
290 ccan_list_for_each(&rq->set, b, node) {
305 struct ccan_list_head *src = &src_rq->set;
306 struct ccan_list_head *dst = &dst_rq->set;
308 dst->n.next = src->n.next;
309 dst->n.prev = src->n.prev;
310 dst->n.next->prev = &dst->n;
311 dst->n.prev->next = &dst->n;
312 ccan_list_head_init(src);
326 return ccan_list_empty(&rq->set);
332 VM_ASSERT(GET_RACTOR() == r);
340 ccan_list_add_tail(&rq->set, &basket->node);
349 ccan_list_for_each(&rq->set, b, node) {
350 fprintf(stderr,
"%d type:%s %p\n", i, basket_type_name(b->type), (
void *)b);
356static void ractor_delete_port(
rb_ractor_t *cr, st_data_t
id,
bool locked);
359ractor_get_queue(
rb_ractor_t *cr, st_data_t
id,
bool locked)
361 VM_ASSERT(cr == GET_RACTOR());
365 if (cr->sync.ports && st_lookup(cr->sync.ports,
id, (st_data_t *)&rq)) {
366 if (rq->closed && ractor_queue_empty_p(cr, rq)) {
367 ractor_delete_port(cr,
id, locked);
385 ASSERT_ractor_unlocking(r);
387 RUBY_DEBUG_LOG(
"id:%u", (
unsigned int)
id);
392 st_insert(r->sync.ports,
id, (st_data_t)rq);
398ractor_delete_port_locked(
rb_ractor_t *cr, st_data_t
id)
400 ASSERT_ractor_locking(cr);
402 RUBY_DEBUG_LOG(
"id:%u", (
unsigned int)
id);
406 if (st_delete(cr->sync.ports, &
id, (st_data_t *)&rq)) {
407 ractor_queue_free(rq);
415ractor_delete_port(
rb_ractor_t *cr, st_data_t
id,
bool locked)
418 ractor_delete_port_locked(cr,
id);
421 RACTOR_LOCK_SELF(cr);
423 ractor_delete_port_locked(cr,
id);
425 RACTOR_UNLOCK_SELF(cr);
432 return RACTOR_PORT_PTR(r->sync.default_port_value);
438 return r->sync.default_port_value;
444 VM_ASSERT(rb_ec_ractor_ptr(ec) == rp->r ? 1 : (ASSERT_ractor_locking(rp->r), 1));
448 if (rp->r->sync.ports && st_lookup(rp->r->sync.ports, ractor_port_id(rp), (st_data_t *)&rq)) {
462 VM_ASSERT(cr == rp->r);
465 RACTOR_LOCK_SELF(cr);
467 ractor_deliver_incoming_messages(ec, cr);
469 if (st_lookup(rp->r->sync.ports, ractor_port_id(rp), (st_data_t *)&rq)) {
470 ractor_queue_close(rq);
472 if (ractor_queue_empty_p(cr, rq)) {
474 ractor_delete_port(cr, ractor_port_id(rp),
true);
480 RACTOR_UNLOCK_SELF(cr);
486ractor_free_all_ports_i(st_data_t port_id, st_data_t val, st_data_t dat)
491 ractor_queue_free(rq);
498 if (cr->sync.ports) {
499 st_foreach(cr->sync.ports, ractor_free_all_ports_i, (st_data_t)cr);
500 st_free_table(cr->sync.ports);
501 cr->sync.ports = NULL;
504 if (cr->sync.recv_queue) {
505 ractor_queue_free(cr->sync.recv_queue);
506 cr->sync.recv_queue = NULL;
510#if defined(HAVE_WORKING_FORK)
514 ractor_free_all_ports(r);
515 r->sync.legacy =
Qnil;
523 struct ccan_list_node node;
530 ccan_list_for_each(&r->sync.monitors, rm, node) {
531 rb_gc_mark(rm->port.r->pub.self);
536ractor_exit_token(
bool exc)
539 RUBY_DEBUG_LOG(
"aborted");
543 RUBY_DEBUG_LOG(
"exited");
552 bool terminated =
false;
553 const struct ractor_port *rp = RACTOR_PORT_PTR(port);
559 if (UNDEF_P(r->sync.legacy)) {
560 RUBY_DEBUG_LOG(
"OK/r:%u -> port:%u@r%u", (
unsigned int)rb_ractor_id(r), (
unsigned int)ractor_port_id(&rm->port), (
unsigned int)rb_ractor_id(rm->port.r));
561 ccan_list_add_tail(&r->sync.monitors, &rm->node);
564 RUBY_DEBUG_LOG(
"NG/r:%u -> port:%u@r%u", (
unsigned int)rb_ractor_id(r), (
unsigned int)ractor_port_id(&rm->port), (
unsigned int)rb_ractor_id(rm->port.r));
572 ractor_port_send(ec, port, ractor_exit_token(r->sync.legacy_exc),
Qfalse);
585 const struct ractor_port *rp = RACTOR_PORT_PTR(port);
589 if (UNDEF_P(r->sync.legacy)) {
592 ccan_list_for_each_safe(&r->sync.monitors, rm, nxt, node) {
593 if (ractor_port_id(&rm->port) == ractor_port_id(rp)) {
594 RUBY_DEBUG_LOG(
"r:%u -> port:%u@r%u",
595 (
unsigned int)rb_ractor_id(r),
596 (
unsigned int)ractor_port_id(&rm->port),
597 (
unsigned int)rb_ractor_id(rm->port.r));
598 ccan_list_del(&rm->node);
612 RUBY_DEBUG_LOG(
"exc:%d", exc);
613 VM_ASSERT(!UNDEF_P(legacy));
614 VM_ASSERT(cr->sync.legacy ==
Qundef);
616 RACTOR_LOCK_SELF(cr);
618 ractor_free_all_ports(cr);
620 cr->sync.legacy = legacy;
621 cr->sync.legacy_exc = exc;
623 RACTOR_UNLOCK_SELF(cr);
627 VALUE token = ractor_exit_token(exc);
630 ccan_list_for_each_safe(&cr->sync.monitors, rm, nxt, node)
632 RUBY_DEBUG_LOG(
"port:%u@r%u", (
unsigned int)ractor_port_id(&rm->port), (
unsigned int)rb_ractor_id(rm->port.r));
634 ractor_try_send(ec, &rm->port, token,
false);
636 ccan_list_del(&rm->node);
640 VM_ASSERT(ccan_list_empty(&cr->sync.monitors));
646ractor_mark_ports_i(st_data_t key, st_data_t val, st_data_t data)
650 ractor_queue_mark(rq);
657 rb_gc_mark(r->sync.default_port_value);
660 ractor_queue_mark(r->sync.recv_queue);
661 st_foreach(r->sync.ports, ractor_mark_ports_i, 0);
664 ractor_mark_monitors(r);
668ractor_sync_free_ports_i(st_data_t _key, st_data_t val, st_data_t _args)
672 ractor_queue_free(queue);
680 if (r->sync.recv_queue) {
681 ractor_queue_free(r->sync.recv_queue);
686 st_foreach(r->sync.ports, ractor_sync_free_ports_i, 0);
687 st_free_table(r->sync.ports);
688 r->sync.ports = NULL;
695 return st_table_size(r->sync.ports);
705 ccan_list_head_init(&r->sync.monitors);
708 ccan_list_head_init(&r->sync.waiters);
711 r->sync.recv_queue = ractor_queue_new();
714 r->sync.ports = st_init_numtable();
715 r->sync.default_port_value = ractor_port_new(r);
721#ifndef RUBY_THREAD_PTHREAD_H
731 if (r->sync.successor == NULL) {
734 if (r->sync.successor != NULL) {
738 r->sync.successor = cr;
744 VM_ASSERT(r->sync.successor != NULL);
746 return r->sync.successor;
749static VALUE ractor_reset_belonging(
VALUE obj);
752ractor_make_remote_exception(
VALUE cause,
VALUE sender)
756 rb_ec_setup_exception(NULL, err, cause);
765 rb_ractor_t *sr = ractor_set_successor_once(r, cr);
768 ractor_reset_belonging(r->sync.legacy);
770 if (r->sync.legacy_exc) {
771 rb_exc_raise(ractor_make_remote_exception(r->sync.legacy, self));
773 return r->sync.legacy;
776 rb_raise(rb_eRactorError,
"Only the successor ractor can take a value");
787 case basket_type_ref:
789 case basket_type_move:
790 return ractor_move(obj);
793 *ptype = basket_type_ref;
797 *ptype = basket_type_copy;
798 return ractor_copy(obj);
806 VALUE v = ractor_prepare_payload(ec, obj, &type);
811 b->p.exception = exc;
819 case basket_type_ref:
821 case basket_type_copy:
822 case basket_type_move:
823 ractor_reset_belonging(b->p.v);
836 VALUE v = ractor_basket_value(b);
838 if (b->p.exception) {
839 VALUE err = ractor_make_remote_exception(v, b->sender);
840 ractor_basket_free(b);
844 ractor_basket_free(b);
850enum ractor_wakeup_status {
859 enum ractor_wakeup_status wakeup_status;
861 struct ccan_list_node node;
868 ASSERT_ractor_locking(cr);
872 ccan_list_for_each(&cr->sync.waiters, w, node) {
882#if USE_RUBY_DEBUG_LOG
885wakeup_status_str(
enum ractor_wakeup_status wakeup_status)
887 switch (wakeup_status) {
888 case wakeup_none:
return "none";
889 case wakeup_by_send:
return "by_send";
890 case wakeup_by_interrupt:
return "by_interrupt";
893 rb_bug(
"unreachable");
897basket_type_name(
enum ractor_basket_type type)
900 case basket_type_none:
return "none";
901 case basket_type_ref:
return "ref";
902 case basket_type_copy:
return "copy";
903 case basket_type_move:
return "move";
911#ifdef RUBY_THREAD_PTHREAD_H
920#if RACTOR_CHECK_MODE > 0
921 VALUE locked_by = r->sync.locked_by;
922 r->sync.locked_by =
Qnil;
926#if RACTOR_CHECK_MODE > 0
927 r->sync.locked_by = locked_by;
932ractor_wait_no_gvl(
void *ptr)
937 RACTOR_LOCK_SELF(cr);
939 if (waiter->wakeup_status == wakeup_none) {
940 ractor_cond_wait(cr);
943 RACTOR_UNLOCK_SELF(cr);
954 rb_nogvl(ractor_wait_no_gvl, waiter,
970ractor_wakeup_all(
rb_ractor_t *r,
enum ractor_wakeup_status wakeup_status)
972 ASSERT_ractor_unlocking(r);
974 RUBY_DEBUG_LOG(
"r:%u wakeup:%s", rb_ractor_id(r), wakeup_status_str(wakeup_status));
976 bool wakeup_p =
false;
983 VM_ASSERT(waiter->wakeup_status == wakeup_none);
985 waiter->wakeup_status = wakeup_status;
986 rb_ractor_sched_wakeup(r, waiter->th);
1000ubf_ractor_wait(
void *ptr)
1008 th->unblock.func = NULL;
1009 th->unblock.arg = NULL;
1015 if (waiter->wakeup_status == wakeup_none) {
1016 RUBY_DEBUG_LOG(
"waiter:%p", (
void *)waiter);
1018 waiter->wakeup_status = wakeup_by_interrupt;
1019 ccan_list_del(&waiter->node);
1021 rb_ractor_sched_wakeup(r, waiter->th);
1029static enum ractor_wakeup_status
1035 .wakeup_status = wakeup_none,
1039 RUBY_DEBUG_LOG(
"wait%s",
"");
1041 ASSERT_ractor_locking(cr);
1043 VM_ASSERT(GET_RACTOR() == cr);
1044 VM_ASSERT(!ractor_waiter_included(cr, th));
1046 ccan_list_add_tail(&cr->sync.waiters, &waiter.node);
1049 rb_ractor_sched_wait(ec, cr, ubf_ractor_wait, &waiter);
1051 if (waiter.wakeup_status == wakeup_none) {
1052 ccan_list_del(&waiter.node);
1055 RUBY_DEBUG_LOG(
"wakeup_status:%s", wakeup_status_str(waiter.wakeup_status));
1057 RACTOR_UNLOCK_SELF(cr);
1059 rb_ec_check_ints(ec);
1061 RACTOR_LOCK_SELF(cr);
1063 VM_ASSERT(!ractor_waiter_included(cr, th));
1064 return waiter.wakeup_status;
1070 ASSERT_ractor_locking(cr);
1074 while ((b = ractor_queue_deq(cr, recv_q)) != NULL) {
1075 ractor_queue_enq(cr, ractor_get_queue(cr, b->port_id,
true), b);
1082 struct ractor_queue *received_queue = cr->sync.recv_queue;
1083 bool received =
false;
1085 ASSERT_ractor_locking(cr);
1087 if (ractor_queue_empty_p(cr, received_queue)) {
1088 RUBY_DEBUG_LOG(
"empty");
1094 ractor_queue_init(messages);
1095 ractor_queue_move(messages, received_queue);
1098 VM_ASSERT(ractor_queue_empty_p(cr, received_queue));
1100 RUBY_DEBUG_LOG(
"received:%d", received);
1108 bool deliverred =
false;
1110 RACTOR_LOCK_SELF(cr);
1112 if (ractor_check_received(cr, &messages)) {
1116 ractor_wait(ec, cr);
1119 RACTOR_UNLOCK_SELF(cr);
1122 VM_ASSERT(!ractor_queue_empty_p(cr, &messages));
1125 while ((b = ractor_queue_deq(cr, &messages)) != NULL) {
1126 ractor_queue_enq(cr, ractor_get_queue(cr, b->port_id,
false), b);
1134 struct ractor_queue *rq = ractor_get_queue(cr, ractor_port_id(rp),
false);
1137 rb_raise(rb_eRactorClosedError,
"The port was already closed");
1142 if (rq->closed && ractor_queue_empty_p(cr, rq)) {
1143 ractor_delete_port(cr, ractor_port_id(rp),
false);
1147 return ractor_basket_accept(b);
1158 VM_ASSERT(cr == rp->r);
1160 RUBY_DEBUG_LOG(
"port:%u", (
unsigned int)ractor_port_id(rp));
1163 VALUE v = ractor_try_receive(ec, cr, rp);
1169 ractor_wait_receive(ec, cr);
1179 bool closed =
false;
1181 RUBY_DEBUG_LOG(
"port:%u@r%u b:%s v:%p", (
unsigned int)ractor_port_id(rp), rb_ractor_id(rp->r), basket_type_name(b->type), (
void *)b->p.v);
1185 if (ractor_closed_port_p(ec, rp->r, rp)) {
1189 b->port_id = ractor_port_id(rp);
1190 ractor_queue_enq(rp->r, rp->r->sync.recv_queue, b);
1193 RACTOR_UNLOCK(rp->r);
1198 ractor_wakeup_all(rp->r, wakeup_by_send);
1201 RUBY_DEBUG_LOG(
"closed:%u@r%u", (
unsigned int)ractor_port_id(rp), rb_ractor_id(rp->r));
1203 if (raise_on_error) {
1204 ractor_basket_free(b);
1205 rb_raise(rb_eRactorClosedError,
"The port was already closed");
1213 struct ractor_basket *b = ractor_basket_new(ec, obj,
RTEST(move) ? basket_type_move : basket_type_none, false);
1214 ractor_send_basket(ec, rp, b, raise_on_error);
1216 return rp->r->pub.self;
1222 return ractor_send0(ec, rp, obj, move,
true);
1228 return ractor_send0(ec, rp, obj, move,
false);
1240ractor_selector_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1242 rb_gc_mark((
VALUE)key);
1248ractor_selector_mark(
void *ptr)
1253 st_foreach(s->ports, ractor_selector_mark_i, 0);
1258ractor_selector_free(
void *ptr)
1261 st_free_table(s->ports);
1266ractor_selector_memsize(
const void *ptr)
1275 ractor_selector_mark,
1276 ractor_selector_free,
1277 ractor_selector_memsize,
1280 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
1284RACTOR_SELECTOR_PTR(
VALUE selv)
1293ractor_selector_create(
VALUE klass)
1297 s->ports = st_init_numtable();
1313 if (!ractor_port_p(rpv)) {
1314 rb_raise(rb_eArgError,
"Not a Ractor::Port object");
1318 const struct ractor_port *rp = RACTOR_PORT_PTR(rpv);
1320 if (st_lookup(s->ports, (st_data_t)rpv, NULL)) {
1321 rb_raise(rb_eArgError,
"already added");
1324 st_insert(s->ports, (st_data_t)rpv, (st_data_t)rp);
1339 if (!ractor_port_p(rpv)) {
1340 rb_raise(rb_eArgError,
"Not a Ractor::Port object");
1345 if (!st_lookup(s->ports, (st_data_t)rpv, NULL)) {
1346 rb_raise(rb_eArgError,
"not added yet");
1349 st_delete(s->ports, (st_data_t *)&rpv, NULL);
1363ractor_selector_clear(
VALUE selv)
1377ractor_selector_empty_p(
VALUE selv)
1380 return s->ports->num_entries == 0 ?
Qtrue :
Qfalse;
1394ractor_selector_wait_i(st_data_t key, st_data_t val, st_data_t data)
1399 VALUE v = ractor_try_receive(p->ec, p->cr, rp);
1404 p->rpv = (
VALUE)key;
1425 st_foreach(s->ports, ractor_selector_wait_i, (st_data_t)&data);
1428 return rb_ary_new_from_args(2, data.rpv, data.v);
1431 ractor_wait_receive(ec, cr);
1442ractor_selector_wait(
VALUE selector)
1444 return ractor_selector__wait(GET_EC(), selector);
1448ractor_selector_new(
int argc,
VALUE *ractors,
VALUE klass)
1450 VALUE selector = ractor_selector_create(klass);
1452 for (
int i=0; i<argc; i++) {
1453 ractor_selector_add(selector, ractors[i]);
1463 VALUE result = ractor_selector__wait(ec, selector);
1470#ifndef USE_RACTOR_SELECTOR
1471#define USE_RACTOR_SELECTOR 0
1474RUBY_SYMBOL_EXPORT_BEGIN
1475void rb_init_ractor_selector(
void);
1476RUBY_SYMBOL_EXPORT_END
1485rb_init_ractor_selector(
void)
1494 rb_define_method(rb_cRactorSelector,
"empty?", ractor_selector_empty_p, 0);
1499Init_RactorPort(
void)
1504 rb_define_method(rb_cRactorPort,
"initialize_copy", ractor_port_initialzie_copy, 1);
1506#if USE_RACTOR_SELECTOR
1507 rb_init_ractor_selector();
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
@ RUBY_FL_SHAREABLE
This flag has something to do with Ractor.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
#define ALLOC
Old name of RB_ALLOC.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_NONE
Old name of RUBY_T_NONE.
#define Qtrue
Old name of RUBY_Qtrue.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
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_cRactor
Ractor class.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
#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_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
void rb_unblock_function_t(void *)
This is the type of UBFs.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define RB_NOGVL_UBF_ASYNC_SAFE
Passing this flag to rb_nogvl() indicates that the passed UBF is async-signal-safe.
#define RB_NOGVL_INTR_FAIL
Passing this flag to rb_nogvl() prevents it from checking interrupts.
void * rb_nogvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2, int flags)
Identical to rb_thread_call_without_gvl(), except it additionally takes "flags" that change the behav...
#define RBIMPL_ATTR_MAYBE_UNUSED()
Wraps (or simulates) [[maybe_unused]]
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define DATA_PTR(obj)
Convenient getter macro.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
#define RTEST
This is an old name of RB_TEST.
This is the struct that holds necessary info for a struct.
void rb_native_mutex_lock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_lock.
void rb_native_cond_initialize(rb_nativethread_cond_t *cond)
Fills the passed condition variable with an initial value.
void rb_native_cond_broadcast(rb_nativethread_cond_t *cond)
Signals a condition variable.
void rb_native_mutex_initialize(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_initialize.
void rb_native_mutex_unlock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_unlock.
void rb_native_cond_wait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex)
Waits for the passed condition variable to be signalled.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.