2#include "ccan/list/list.h"
5static VALUE rb_cMutex, rb_cQueue, rb_cSizedQueue, rb_cConditionVariable;
6static VALUE rb_eClosedQueueError;
12 struct ccan_list_head waitq;
20 struct ccan_list_node node;
26 if (rb_fiberptr_blocking(fiber)) {
39#define MUTEX_ALLOW_TRAP FL_USER1
42sync_wakeup(
struct ccan_list_head *head,
long max)
46 ccan_list_for_each_safe(head, cur, next, node) {
47 ccan_list_del_init(&cur->node);
49 if (cur->th->status != THREAD_KILLED) {
50 if (cur->th->scheduler !=
Qnil && cur->fiber) {
54 rb_threadptr_interrupt(cur->th);
55 cur->th->status = THREAD_RUNNABLE;
58 if (--max == 0)
return;
64wakeup_one(
struct ccan_list_head *head)
70wakeup_all(
struct ccan_list_head *head)
72 sync_wakeup(head, LONG_MAX);
75#if defined(HAVE_WORKING_FORK)
76static void rb_mutex_abandon_all(
rb_mutex_t *mutexes);
77static void rb_mutex_abandon_keeping_mutexes(
rb_thread_t *th);
78static void rb_mutex_abandon_locking_mutex(
rb_thread_t *th);
106#define mutex_mark ((void(*)(void*))0)
114 ccan_list_for_each(&mutex->waitq, w, node) {
129 const char *err = rb_mutex_unlock_th(mutex, rb_fiber_threadptr(mutex->fiber), mutex->fiber);
130 if (err)
rb_bug(
"%s", err);
136mutex_memsize(
const void *ptr)
143 {mutex_mark, mutex_free, mutex_memsize,},
144 0, 0, RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
158rb_obj_is_mutex(
VALUE obj)
164mutex_alloc(
VALUE klass)
171 ccan_list_head_init(&mutex->waitq);
182mutex_initialize(
VALUE self)
190 return mutex_alloc(rb_cMutex);
204 return RBOOL(mutex->fiber);
210 if (thread->keeping_mutexes) {
211 mutex->next_mutex = thread->keeping_mutexes;
214 thread->keeping_mutexes = mutex;
220 rb_mutex_t **keeping_mutexes = &thread->keeping_mutexes;
222 while (*keeping_mutexes && *keeping_mutexes != mutex) {
224 keeping_mutexes = &(*keeping_mutexes)->next_mutex;
227 if (*keeping_mutexes) {
228 *keeping_mutexes = mutex->next_mutex;
229 mutex->next_mutex = NULL;
238 thread_mutex_insert(th, mutex);
253 if (mutex->fiber == 0) {
256 mutex->fiber = fiber;
258 mutex_locked(th, self);
275 return RBOOL(mutex->fiber == fiber);
279call_rb_fiber_scheduler_block(
VALUE mutex)
285delete_from_waitq(
VALUE value)
294do_mutex_lock(
VALUE self,
int interruptible_p)
303 th->ec->interrupt_mask & TRAP_INTERRUPT_MASK) {
308 if (mutex->fiber == fiber) {
312 while (mutex->fiber != fiber) {
314 if (scheduler !=
Qnil) {
318 .fiber = nonblocking_fiber(fiber)
321 ccan_list_add_tail(&mutex->waitq, &
sync_waiter.node);
326 mutex->fiber = fiber;
330 if (!th->vm->thread_ignore_deadlock && rb_fiber_threadptr(mutex->fiber) == th) {
334 enum rb_thread_status prev_status = th->status;
335 rb_hrtime_t *timeout = 0;
336 rb_hrtime_t rel = rb_msec2hrtime(100);
338 th->status = THREAD_STOPPED_FOREVER;
339 th->locking_mutex = self;
340 rb_ractor_sleeper_threads_inc(th->ractor);
346 if ((rb_ractor_living_thread_num(th->ractor) == rb_ractor_sleeper_thread_num(th->ractor)) &&
355 .fiber = nonblocking_fiber(fiber)
358 ccan_list_add_tail(&mutex->waitq, &
sync_waiter.node);
360 native_sleep(th, timeout);
365 mutex->fiber = fiber;
368 if (patrol_thread == th)
369 patrol_thread = NULL;
371 th->locking_mutex =
Qfalse;
372 if (mutex->fiber && timeout && !RUBY_VM_INTERRUPTED(th->ec)) {
373 rb_check_deadlock(th->ractor);
375 if (th->status == THREAD_STOPPED_FOREVER) {
376 th->status = prev_status;
378 rb_ractor_sleeper_threads_dec(th->ractor);
381 if (interruptible_p) {
384 if (mutex->fiber == fiber) mutex->fiber = 0;
385 RUBY_VM_CHECK_INTS_BLOCKING(th->ec);
387 mutex->fiber = fiber;
392 if (mutex->fiber == fiber) mutex_locked(th, self);
396 if (mutex_owned_p(fiber, mutex) ==
Qfalse)
rb_bug(
"do_mutex_lock: mutex is not owned.");
402mutex_lock_uninterruptible(
VALUE self)
404 return do_mutex_lock(self, 0);
417 return do_mutex_lock(self, 1);
427rb_mutex_owned_p(
VALUE self)
432 return mutex_owned_p(fiber, mutex);
438 const char *err = NULL;
440 if (mutex->fiber == 0) {
441 err =
"Attempt to unlock a mutex which is not locked";
443 else if (mutex->fiber != fiber) {
444 err =
"Attempt to unlock a mutex which is locked by another thread/fiber";
450 ccan_list_for_each_safe(&mutex->waitq, cur, next, node) {
451 ccan_list_del_init(&cur->node);
453 if (cur->th->scheduler !=
Qnil && cur->fiber) {
458 switch (cur->th->status) {
459 case THREAD_RUNNABLE:
460 case THREAD_STOPPED_FOREVER:
461 rb_threadptr_interrupt(cur->th);
464 rb_bug(
"unexpected THREAD_STOPPED");
467 rb_bug(
"unexpected THREAD_KILLED");
474 thread_mutex_remove(th, mutex);
494 err = rb_mutex_unlock_th(mutex, th, GET_EC()->fiber_ptr);
500#if defined(HAVE_WORKING_FORK)
504 rb_mutex_abandon_all(th->keeping_mutexes);
505 th->keeping_mutexes = NULL;
511 if (th->locking_mutex) {
512 rb_mutex_t *mutex = mutex_ptr(th->locking_mutex);
514 ccan_list_head_init(&mutex->waitq);
515 th->locking_mutex =
Qfalse;
526 mutexes = mutex->next_mutex;
528 mutex->next_mutex = 0;
529 ccan_list_head_init(&mutex->waitq);
535rb_mutex_sleep_forever(
VALUE self)
537 rb_thread_sleep_deadly_allow_spurious_wakeup(self,
Qnil, 0);
542rb_mutex_wait_for(
VALUE time)
544 rb_hrtime_t *rel = (rb_hrtime_t *)time;
546 return RBOOL(sleep_hrtime(GET_THREAD(), *rel, 0));
555 if (!
NIL_P(timeout)) {
560 time_t beg = time(0);
563 if (scheduler !=
Qnil) {
565 mutex_lock_uninterruptible(self);
568 if (
NIL_P(timeout)) {
569 rb_ensure(rb_mutex_sleep_forever, self, mutex_lock_uninterruptible, self);
572 rb_hrtime_t rel = rb_timeval2hrtime(&t);
573 woken =
rb_ensure(rb_mutex_wait_for, (
VALUE)&rel, mutex_lock_uninterruptible, self);
577 RUBY_VM_CHECK_INTS_BLOCKING(GET_EC());
578 if (!woken)
return Qnil;
579 time_t end = time(0) - beg;
580 return TIMET2NUM(end);
631rb_mutex_synchronize_m(
VALUE self)
641rb_mutex_allow_trap(
VALUE self,
int val)
653#define queue_waitq(q) UNALIGNED_MEMBER_PTR(q, waitq)
654PACKED_STRUCT_UNALIGNED(
struct rb_queue {
655 struct ccan_list_head waitq;
656 rb_serial_t fork_gen;
661#define szqueue_waitq(sq) UNALIGNED_MEMBER_PTR(sq, q.waitq)
662#define szqueue_pushq(sq) UNALIGNED_MEMBER_PTR(sq, pushq)
665 int num_waiting_push;
666 struct ccan_list_head pushq;
680queue_memsize(
const void *ptr)
688 0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
692queue_alloc(
VALUE klass)
698 ccan_list_head_init(queue_waitq(q));
705 rb_serial_t fork_gen = GET_VM()->fork_gen;
707 if (q->fork_gen == fork_gen) {
711 q->fork_gen = fork_gen;
712 ccan_list_head_init(queue_waitq(q));
728#define QUEUE_CLOSED FL_USER5
731queue_timeout2hrtime(
VALUE timeout)
733 if (
NIL_P(timeout)) {
734 return (rb_hrtime_t)0;
738 rel = rb_sec2hrtime(NUM2TIMET(timeout));
743 return rb_hrtime_add(rel, rb_hrtime_now());
747szqueue_mark(
void *ptr)
755szqueue_memsize(
const void *ptr)
763 0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
767szqueue_alloc(
VALUE klass)
771 &szqueue_data_type, sq);
772 ccan_list_head_init(szqueue_waitq(sq));
773 ccan_list_head_init(szqueue_pushq(sq));
778szqueue_ptr(
VALUE obj)
783 if (queue_fork_check(&sq->q)) {
784 ccan_list_head_init(szqueue_pushq(sq));
785 sq->num_waiting_push = 0;
794 return rb_ary_hidden_new(1);
813queue_closed_p(
VALUE self)
825NORETURN(
static void raise_closed_queue_error(
VALUE self));
828raise_closed_queue_error(
VALUE self)
830 rb_raise(rb_eClosedQueueError,
"queue closed");
836 assert(queue_length(self, q) == 0);
901rb_queue_initialize(
int argc,
VALUE *argv,
VALUE self)
904 struct rb_queue *q = queue_ptr(self);
905 if ((argc =
rb_scan_args(argc, argv,
"01", &initial)) == 1) {
906 initial = rb_to_array(initial);
909 ccan_list_head_init(queue_waitq(q));
911 rb_ary_concat(q->que, initial);
919 if (queue_closed_p(self)) {
920 raise_closed_queue_error(self);
922 rb_ary_push(check_array(self, q->que), obj);
923 wakeup_one(queue_waitq(q));
961rb_queue_close(
VALUE self)
963 struct rb_queue *q = queue_ptr(self);
965 if (!queue_closed_p(self)) {
966 FL_SET(self, QUEUE_CLOSED);
968 wakeup_all(queue_waitq(q));
982rb_queue_closed_p(
VALUE self)
984 return RBOOL(queue_closed_p(self));
1000 return queue_do_push(self, queue_ptr(self), obj);
1004queue_sleep(
VALUE _args)
1007 rb_thread_sleep_deadly_allow_spurious_wakeup(args->self, args->timeout, args->end);
1020queue_sleep_done(
VALUE p)
1024 ccan_list_del(&qw->w.node);
1025 qw->as.q->num_waiting--;
1031szqueue_sleep_done(
VALUE p)
1035 ccan_list_del(&qw->w.node);
1036 qw->as.sq->num_waiting_push--;
1044 check_array(self, q->que);
1046 if (!should_block) {
1055 rb_hrtime_t end = queue_timeout2hrtime(timeout);
1057 if (queue_closed_p(self)) {
1058 return queue_closed_result(self, q);
1064 assert(queue_closed_p(self) == 0);
1067 .w = {.self = self, .th = ec->thread_ptr, .fiber = nonblocking_fiber(ec->fiber_ptr)},
1071 struct ccan_list_head *waitq = queue_waitq(q);
1083 if (!
NIL_P(timeout) && (rb_hrtime_now() >= end))
1088 return rb_ary_shift(q->que);
1094 return queue_do_pop(self, queue_ptr(self), !
RTEST(non_block), timeout);
1105rb_queue_empty_p(
VALUE self)
1107 return RBOOL(queue_length(self, queue_ptr(self)) == 0);
1117rb_queue_clear(
VALUE self)
1119 struct rb_queue *q = queue_ptr(self);
1121 rb_ary_clear(check_array(self, q->que));
1135rb_queue_length(
VALUE self)
1137 return LONG2NUM(queue_length(self, queue_ptr(self)));
1147rb_queue_num_waiting(
VALUE self)
1149 struct rb_queue *q = queue_ptr(self);
1151 return INT2NUM(q->num_waiting);
1182 ccan_list_head_init(szqueue_waitq(sq));
1183 ccan_list_head_init(szqueue_pushq(sq));
1202rb_szqueue_close(
VALUE self)
1204 if (!queue_closed_p(self)) {
1207 FL_SET(self, QUEUE_CLOSED);
1208 wakeup_all(szqueue_waitq(sq));
1209 wakeup_all(szqueue_pushq(sq));
1221rb_szqueue_max_get(
VALUE self)
1223 return LONG2NUM(szqueue_ptr(self)->max);
1243 if (max > sq->max) {
1244 diff = max - sq->max;
1247 sync_wakeup(szqueue_pushq(sq), diff);
1256 if (queue_length(self, &sq->q) >= sq->max) {
1257 if (
RTEST(non_block)) {
1266 rb_hrtime_t end = queue_timeout2hrtime(timeout);
1267 while (queue_length(self, &sq->q) >= sq->max) {
1268 if (queue_closed_p(self)) {
1269 raise_closed_queue_error(self);
1274 .w = {.self = self, .th = ec->thread_ptr, .fiber = nonblocking_fiber(ec->fiber_ptr)},
1278 struct ccan_list_head *pushq = szqueue_pushq(sq);
1281 sq->num_waiting_push++;
1289 if (!
NIL_P(timeout) && rb_hrtime_now() >= end) {
1295 return queue_do_push(self, &sq->q,
object);
1299szqueue_do_pop(
VALUE self,
int should_block,
VALUE timeout)
1302 VALUE retval = queue_do_pop(self, &sq->q, should_block, timeout);
1304 if (queue_length(self, &sq->q) < sq->max) {
1305 wakeup_one(szqueue_pushq(sq));
1313 return szqueue_do_pop(self, !
RTEST(non_block), timeout);
1323rb_szqueue_clear(
VALUE self)
1327 rb_ary_clear(check_array(self, sq->q.que));
1328 wakeup_all(szqueue_pushq(sq));
1342rb_szqueue_length(
VALUE self)
1346 return LONG2NUM(queue_length(self, &sq->q));
1356rb_szqueue_num_waiting(
VALUE self)
1360 return INT2NUM(sq->q.num_waiting + sq->num_waiting_push);
1371rb_szqueue_empty_p(
VALUE self)
1375 return RBOOL(queue_length(self, &sq->q) == 0);
1381 struct ccan_list_head waitq;
1382 rb_serial_t fork_gen;
1414condvar_memsize(
const void *ptr)
1422 0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
1426condvar_ptr(
VALUE self)
1429 rb_serial_t fork_gen = GET_VM()->fork_gen;
1434 if (cv->fork_gen != fork_gen) {
1435 cv->fork_gen = fork_gen;
1436 ccan_list_head_init(&cv->waitq);
1443condvar_alloc(
VALUE klass)
1449 ccan_list_head_init(&cv->waitq);
1461rb_condvar_initialize(
VALUE self)
1464 ccan_list_head_init(&cv->waitq);
1479 return rb_funcallv(p->mutex, id_sleep, 1, &p->timeout);
1495rb_condvar_wait(
int argc,
VALUE *argv,
VALUE self)
1502 rb_scan_args(argc, argv,
"11", &args.mutex, &args.timeout);
1506 .th = ec->thread_ptr,
1507 .fiber = nonblocking_fiber(ec->fiber_ptr)
1510 ccan_list_add_tail(&cv->waitq, &
sync_waiter.node);
1521rb_condvar_signal(
VALUE self)
1524 wakeup_one(&cv->waitq);
1535rb_condvar_broadcast(
VALUE self)
1538 wakeup_all(&cv->waitq);
1545undumpable(
VALUE obj)
1552define_thread_class(
VALUE outer,
const ID name,
VALUE super)
1560Init_thread_sync(
void)
1563#if defined(TEACH_RDOC) && TEACH_RDOC == 42
1570#define DEFINE_CLASS(name, super) \
1571 rb_c##name = define_thread_class(rb_cThread, rb_intern(#name), rb_c##super)
1574 DEFINE_CLASS(Mutex, Object);
1586 DEFINE_CLASS(Queue, Object);
1606 DEFINE_CLASS(SizedQueue, Queue);
1616 rb_define_method(rb_cSizedQueue,
"num_waiting", rb_szqueue_num_waiting, 0);
1620 DEFINE_CLASS(ConditionVariable, Object);
1625 rb_define_method(rb_cConditionVariable,
"initialize", rb_condvar_initialize, 0);
1630 rb_define_method(rb_cConditionVariable,
"broadcast", rb_condvar_broadcast, 0);
1635#include "thread_sync.rbinc"
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
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.
VALUE rb_define_class_id_under(VALUE outer, ID id, VALUE super)
Identical to rb_define_class_under(), except it takes the name in ID instead of C's string.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define FL_SET
Old name of RB_FL_SET.
#define LONG2NUM
Old name of RB_LONG2NUM.
#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 NIL_P
Old name of RB_NIL_P.
#define Check_TypedStruct(v, t)
Old name of rb_check_typeddata.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eStopIteration
StopIteration exception.
VALUE rb_eArgError
ArgumentError exception.
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
VALUE rb_eThreadError
ThreadError exception.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cThread
Thread class.
double rb_num2dbl(VALUE num)
Converts an instance of rb_cNumeric into C's double.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_provide(const char *feature)
Declares that the given feature is already provided by someone else.
VALUE rb_mutex_new(void)
Creates a mutex.
VALUE rb_mutex_trylock(VALUE mutex)
Attempts to lock the mutex, without waiting for other threads to unlock it.
VALUE rb_mutex_locked_p(VALUE mutex)
Queries if there are any threads that holds the lock.
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_mutex_sleep(VALUE self, VALUE timeout)
Releases the lock held in the mutex and waits for the period of time; reacquires the lock on wakeup.
VALUE rb_mutex_unlock(VALUE mutex)
Releases the mutex.
VALUE rb_mutex_lock(VALUE mutex)
Attempts to lock the mutex.
struct timeval rb_time_interval(VALUE num)
Creates a "time interval".
void rb_const_set(VALUE space, ID name, VALUE val)
Names a constant.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
ID rb_intern(const char *name)
Finds or creates a symbol of the given name.
VALUE rb_yield(VALUE val)
Yields the block.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper 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...
VALUE rb_fiber_scheduler_current(void)
Identical to rb_fiber_scheduler_get(), except it also returns RUBY_Qnil in case of a blocking fiber.
VALUE rb_fiber_scheduler_block(VALUE scheduler, VALUE blocker, VALUE timeout)
Non-blocking wait for the passed "blocker", which is for instance Thread.join or Mutex....
VALUE rb_fiber_scheduler_kernel_sleep(VALUE scheduler, VALUE duration)
Non-blocking sleep.
VALUE rb_fiber_scheduler_unblock(VALUE scheduler, VALUE blocker, VALUE fiber)
Wakes up a fiber previously blocked using rb_fiber_scheduler_block().
#define RTEST
This is an old name of RB_TEST.
This is the struct that holds necessary info for a struct.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
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.