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) {
732 rb_ractor_t *successor = ATOMIC_PTR_CAS(r->sync.successor, NULL, cr);
733 return successor == NULL ? cr : successor;
736 return r->sync.successor;
739static VALUE ractor_reset_belonging(
VALUE obj);
742ractor_make_remote_exception(
VALUE cause,
VALUE sender)
746 rb_ec_setup_exception(NULL, err, cause);
755 rb_ractor_t *sr = ractor_set_successor_once(r, cr);
758 ractor_reset_belonging(r->sync.legacy);
760 if (r->sync.legacy_exc) {
761 rb_exc_raise(ractor_make_remote_exception(r->sync.legacy, self));
763 return r->sync.legacy;
766 rb_raise(rb_eRactorError,
"Only the successor ractor can take a value");
777 case basket_type_ref:
779 case basket_type_move:
780 return ractor_move(obj);
783 *ptype = basket_type_ref;
787 *ptype = basket_type_copy;
788 return ractor_copy(obj);
796 VALUE v = ractor_prepare_payload(ec, obj, &type);
801 b->p.exception = exc;
809 case basket_type_ref:
811 case basket_type_copy:
812 case basket_type_move:
813 ractor_reset_belonging(b->p.v);
826 VALUE v = ractor_basket_value(b);
828 if (b->p.exception) {
829 VALUE err = ractor_make_remote_exception(v, b->sender);
830 ractor_basket_free(b);
834 ractor_basket_free(b);
840enum ractor_wakeup_status {
849 enum ractor_wakeup_status wakeup_status;
851 struct ccan_list_node node;
858 ASSERT_ractor_locking(cr);
862 ccan_list_for_each(&cr->sync.waiters, w, node) {
872#if USE_RUBY_DEBUG_LOG
875wakeup_status_str(
enum ractor_wakeup_status wakeup_status)
877 switch (wakeup_status) {
878 case wakeup_none:
return "none";
879 case wakeup_by_send:
return "by_send";
880 case wakeup_by_interrupt:
return "by_interrupt";
883 rb_bug(
"unreachable");
887basket_type_name(
enum ractor_basket_type type)
890 case basket_type_none:
return "none";
891 case basket_type_ref:
return "ref";
892 case basket_type_copy:
return "copy";
893 case basket_type_move:
return "move";
901#ifdef RUBY_THREAD_PTHREAD_H
910#if RACTOR_CHECK_MODE > 0
911 VALUE locked_by = r->sync.locked_by;
912 r->sync.locked_by =
Qnil;
916#if RACTOR_CHECK_MODE > 0
917 r->sync.locked_by = locked_by;
922ractor_wait_no_gvl(
void *ptr)
927 RACTOR_LOCK_SELF(cr);
929 if (waiter->wakeup_status == wakeup_none) {
930 ractor_cond_wait(cr);
933 RACTOR_UNLOCK_SELF(cr);
944 rb_nogvl(ractor_wait_no_gvl, waiter,
960ractor_wakeup_all(
rb_ractor_t *r,
enum ractor_wakeup_status wakeup_status)
962 ASSERT_ractor_unlocking(r);
964 RUBY_DEBUG_LOG(
"r:%u wakeup:%s", rb_ractor_id(r), wakeup_status_str(wakeup_status));
966 bool wakeup_p =
false;
973 VM_ASSERT(waiter->wakeup_status == wakeup_none);
975 waiter->wakeup_status = wakeup_status;
976 rb_ractor_sched_wakeup(r, waiter->th);
990ubf_ractor_wait(
void *ptr)
998 th->unblock.func = NULL;
999 th->unblock.arg = NULL;
1005 if (waiter->wakeup_status == wakeup_none) {
1006 RUBY_DEBUG_LOG(
"waiter:%p", (
void *)waiter);
1008 waiter->wakeup_status = wakeup_by_interrupt;
1009 ccan_list_del(&waiter->node);
1011 rb_ractor_sched_wakeup(r, waiter->th);
1019static enum ractor_wakeup_status
1025 .wakeup_status = wakeup_none,
1029 RUBY_DEBUG_LOG(
"wait%s",
"");
1031 ASSERT_ractor_locking(cr);
1033 VM_ASSERT(GET_RACTOR() == cr);
1034 VM_ASSERT(!ractor_waiter_included(cr, th));
1036 ccan_list_add_tail(&cr->sync.waiters, &waiter.node);
1039 rb_ractor_sched_wait(ec, cr, ubf_ractor_wait, &waiter);
1041 if (waiter.wakeup_status == wakeup_none) {
1042 ccan_list_del(&waiter.node);
1045 RUBY_DEBUG_LOG(
"wakeup_status:%s", wakeup_status_str(waiter.wakeup_status));
1047 RACTOR_UNLOCK_SELF(cr);
1049 rb_ec_check_ints(ec);
1051 RACTOR_LOCK_SELF(cr);
1053 VM_ASSERT(!ractor_waiter_included(cr, th));
1054 return waiter.wakeup_status;
1060 ASSERT_ractor_locking(cr);
1064 while ((b = ractor_queue_deq(cr, recv_q)) != NULL) {
1065 ractor_queue_enq(cr, ractor_get_queue(cr, b->port_id,
true), b);
1072 struct ractor_queue *received_queue = cr->sync.recv_queue;
1073 bool received =
false;
1075 ASSERT_ractor_locking(cr);
1077 if (ractor_queue_empty_p(cr, received_queue)) {
1078 RUBY_DEBUG_LOG(
"empty");
1084 ractor_queue_init(messages);
1085 ractor_queue_move(messages, received_queue);
1088 VM_ASSERT(ractor_queue_empty_p(cr, received_queue));
1090 RUBY_DEBUG_LOG(
"received:%d", received);
1098 bool deliverred =
false;
1100 RACTOR_LOCK_SELF(cr);
1102 if (ractor_check_received(cr, &messages)) {
1106 ractor_wait(ec, cr);
1109 RACTOR_UNLOCK_SELF(cr);
1112 VM_ASSERT(!ractor_queue_empty_p(cr, &messages));
1115 while ((b = ractor_queue_deq(cr, &messages)) != NULL) {
1116 ractor_queue_enq(cr, ractor_get_queue(cr, b->port_id,
false), b);
1124 struct ractor_queue *rq = ractor_get_queue(cr, ractor_port_id(rp),
false);
1127 rb_raise(rb_eRactorClosedError,
"The port was already closed");
1132 if (rq->closed && ractor_queue_empty_p(cr, rq)) {
1133 ractor_delete_port(cr, ractor_port_id(rp),
false);
1137 return ractor_basket_accept(b);
1148 VM_ASSERT(cr == rp->r);
1150 RUBY_DEBUG_LOG(
"port:%u", (
unsigned int)ractor_port_id(rp));
1153 VALUE v = ractor_try_receive(ec, cr, rp);
1159 ractor_wait_receive(ec, cr);
1169 bool closed =
false;
1171 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);
1175 if (ractor_closed_port_p(ec, rp->r, rp)) {
1179 b->port_id = ractor_port_id(rp);
1180 ractor_queue_enq(rp->r, rp->r->sync.recv_queue, b);
1183 RACTOR_UNLOCK(rp->r);
1188 ractor_wakeup_all(rp->r, wakeup_by_send);
1191 RUBY_DEBUG_LOG(
"closed:%u@r%u", (
unsigned int)ractor_port_id(rp), rb_ractor_id(rp->r));
1193 if (raise_on_error) {
1194 ractor_basket_free(b);
1195 rb_raise(rb_eRactorClosedError,
"The port was already closed");
1203 struct ractor_basket *b = ractor_basket_new(ec, obj,
RTEST(move) ? basket_type_move : basket_type_none, false);
1204 ractor_send_basket(ec, rp, b, raise_on_error);
1206 return rp->r->pub.self;
1212 return ractor_send0(ec, rp, obj, move,
true);
1218 return ractor_send0(ec, rp, obj, move,
false);
1230ractor_selector_mark_i(st_data_t key, st_data_t val, st_data_t dmy)
1232 rb_gc_mark((
VALUE)key);
1238ractor_selector_mark(
void *ptr)
1243 st_foreach(s->ports, ractor_selector_mark_i, 0);
1248ractor_selector_free(
void *ptr)
1251 st_free_table(s->ports);
1256ractor_selector_memsize(
const void *ptr)
1265 ractor_selector_mark,
1266 ractor_selector_free,
1267 ractor_selector_memsize,
1270 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
1274RACTOR_SELECTOR_PTR(
VALUE selv)
1283ractor_selector_create(
VALUE klass)
1287 s->ports = st_init_numtable();
1303 if (!ractor_port_p(rpv)) {
1304 rb_raise(rb_eArgError,
"Not a Ractor::Port object");
1308 const struct ractor_port *rp = RACTOR_PORT_PTR(rpv);
1310 if (st_lookup(s->ports, (st_data_t)rpv, NULL)) {
1311 rb_raise(rb_eArgError,
"already added");
1314 st_insert(s->ports, (st_data_t)rpv, (st_data_t)rp);
1329 if (!ractor_port_p(rpv)) {
1330 rb_raise(rb_eArgError,
"Not a Ractor::Port object");
1335 if (!st_lookup(s->ports, (st_data_t)rpv, NULL)) {
1336 rb_raise(rb_eArgError,
"not added yet");
1339 st_delete(s->ports, (st_data_t *)&rpv, NULL);
1353ractor_selector_clear(
VALUE selv)
1367ractor_selector_empty_p(
VALUE selv)
1370 return s->ports->num_entries == 0 ?
Qtrue :
Qfalse;
1384ractor_selector_wait_i(st_data_t key, st_data_t val, st_data_t data)
1389 VALUE v = ractor_try_receive(p->ec, p->cr, rp);
1394 p->rpv = (
VALUE)key;
1415 st_foreach(s->ports, ractor_selector_wait_i, (st_data_t)&data);
1418 return rb_ary_new_from_args(2, data.rpv, data.v);
1421 ractor_wait_receive(ec, cr);
1432ractor_selector_wait(
VALUE selector)
1434 return ractor_selector__wait(GET_EC(), selector);
1438ractor_selector_new(
int argc,
VALUE *ractors,
VALUE klass)
1440 VALUE selector = ractor_selector_create(klass);
1442 for (
int i=0; i<argc; i++) {
1443 ractor_selector_add(selector, ractors[i]);
1453 VALUE result = ractor_selector__wait(ec, selector);
1460#ifndef USE_RACTOR_SELECTOR
1461#define USE_RACTOR_SELECTOR 0
1464RUBY_SYMBOL_EXPORT_BEGIN
1465void rb_init_ractor_selector(
void);
1466RUBY_SYMBOL_EXPORT_END
1475rb_init_ractor_selector(
void)
1484 rb_define_method(rb_cRactorSelector,
"empty?", ractor_selector_empty_p, 0);
1489Init_RactorPort(
void)
1494 rb_define_method(rb_cRactorPort,
"initialize_copy", ractor_port_initialzie_copy, 1);
1496#if USE_RACTOR_SELECTOR
1497 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.