3#include "ractor_core.h"
7static bool vm_barrier_finish_p(
rb_vm_t *vm);
12 return vm->ractor.sync.lock_owner == GET_RACTOR();
17RUBY_ASSERT_vm_locking(
void)
19 if (rb_multi_ractor_p()) {
21 VM_ASSERT(vm_locked(vm));
26RUBY_ASSERT_vm_unlocking(
void)
28 if (rb_multi_ractor_p()) {
30 VM_ASSERT(!vm_locked(vm));
38 return vm_locked(GET_VM());
42vm_lock_enter(
rb_ractor_t *cr,
rb_vm_t *vm,
bool locked,
bool no_barrier,
unsigned int *lev APPEND_LOCATION_ARGS)
44 RUBY_DEBUG_LOG2(file, line,
"start locked:%d", locked);
52 VM_ASSERT(cr->sync.locked_by != rb_ractor_self(cr));
57 VM_ASSERT(vm->ractor.sync.lock_owner == NULL);
58 vm->ractor.sync.lock_owner = cr;
62 while (vm->ractor.sync.barrier_waiting) {
63 unsigned int barrier_cnt = vm->ractor.sync.barrier_cnt;
67 RB_GC_SAVE_MACHINE_CONTEXT(th);
69 if (rb_ractor_status_p(cr, ractor_running)) {
70 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
76 VM_ASSERT(rb_ractor_status_p(cr, ractor_blocking));
78 if (vm_barrier_finish_p(vm)) {
79 RUBY_DEBUG_LOG(
"wakeup barrier owner");
83 RUBY_DEBUG_LOG(
"wait for barrier finish");
87 while (barrier_cnt == vm->ractor.sync.barrier_cnt) {
88 vm->ractor.sync.lock_owner = NULL;
90 VM_ASSERT(vm->ractor.sync.lock_owner == NULL);
91 vm->ractor.sync.lock_owner = cr;
94 RUBY_DEBUG_LOG(
"barrier is released. Acquire vm_lock");
97 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
102 VM_ASSERT(vm->ractor.sync.lock_rec == 0);
103 VM_ASSERT(vm->ractor.sync.lock_owner == cr);
106 vm->ractor.sync.lock_rec++;
107 *lev = vm->ractor.sync.lock_rec;
109 RUBY_DEBUG_LOG2(file, line,
"rec:%u owner:%u", vm->ractor.sync.lock_rec,
110 (
unsigned int)rb_ractor_id(vm->ractor.sync.lock_owner));
114vm_lock_leave(
rb_vm_t *vm,
unsigned int *lev APPEND_LOCATION_ARGS)
116 RUBY_DEBUG_LOG2(file, line,
"rec:%u owner:%u", vm->ractor.sync.lock_rec,
117 (
unsigned int)rb_ractor_id(vm->ractor.sync.lock_owner));
120 VM_ASSERT(vm->ractor.sync.lock_rec > 0);
121 VM_ASSERT(vm->ractor.sync.lock_rec == *lev);
123 vm->ractor.sync.lock_rec--;
124 *lev = vm->ractor.sync.lock_rec;
126 if (vm->ractor.sync.lock_rec == 0) {
127 vm->ractor.sync.lock_owner = NULL;
132MJIT_FUNC_EXPORTED
void
133rb_vm_lock_enter_body(
unsigned int *lev APPEND_LOCATION_ARGS)
137 vm_lock_enter(NULL, vm,
true,
false, lev APPEND_LOCATION_PARAMS);
140 vm_lock_enter(GET_RACTOR(), vm,
false,
false, lev APPEND_LOCATION_PARAMS);
144MJIT_FUNC_EXPORTED
void
145rb_vm_lock_enter_body_nb(
unsigned int *lev APPEND_LOCATION_ARGS)
149 vm_lock_enter(NULL, vm,
true,
true, lev APPEND_LOCATION_PARAMS);
152 vm_lock_enter(GET_RACTOR(), vm,
false,
true, lev APPEND_LOCATION_PARAMS);
156MJIT_FUNC_EXPORTED
void
157rb_vm_lock_enter_body_cr(
rb_ractor_t *cr,
unsigned int *lev APPEND_LOCATION_ARGS)
160 vm_lock_enter(cr, vm, vm_locked(vm),
false, lev APPEND_LOCATION_PARAMS);
163MJIT_FUNC_EXPORTED
void
164rb_vm_lock_leave_body(
unsigned int *lev APPEND_LOCATION_ARGS)
166 vm_lock_leave(GET_VM(), lev APPEND_LOCATION_PARAMS);
170rb_vm_lock_body(LOCATION_ARGS)
173 ASSERT_vm_unlocking();
175 vm_lock_enter(GET_RACTOR(), vm,
false,
false, &vm->ractor.sync.lock_rec APPEND_LOCATION_PARAMS);
179rb_vm_unlock_body(LOCATION_ARGS)
183 VM_ASSERT(vm->ractor.sync.lock_rec == 1);
184 vm_lock_leave(vm, &vm->ractor.sync.lock_rec APPEND_LOCATION_PARAMS);
188vm_cond_wait(
rb_vm_t *vm, rb_nativethread_cond_t *cond,
unsigned long msec)
191 unsigned int lock_rec = vm->ractor.sync.lock_rec;
194 vm->ractor.sync.lock_rec = 0;
195 vm->ractor.sync.lock_owner = NULL;
202 vm->ractor.sync.lock_rec = lock_rec;
203 vm->ractor.sync.lock_owner = cr;
207rb_vm_cond_wait(
rb_vm_t *vm, rb_nativethread_cond_t *cond)
209 vm_cond_wait(vm, cond, 0);
213rb_vm_cond_timedwait(
rb_vm_t *vm, rb_nativethread_cond_t *cond,
unsigned long msec)
215 vm_cond_wait(vm, cond, msec);
219vm_barrier_finish_p(
rb_vm_t *vm)
221 RUBY_DEBUG_LOG(
"cnt:%u living:%u blocking:%u",
222 vm->ractor.sync.barrier_cnt,
224 vm->ractor.blocking_cnt);
226 VM_ASSERT(vm->ractor.blocking_cnt <= vm->ractor.cnt);
227 return vm->ractor.blocking_cnt == vm->ractor.cnt;
233 RB_DEBUG_COUNTER_INC(vm_sync_barrier);
235 if (!rb_multi_ractor_p()) {
241 VM_ASSERT(vm->ractor.sync.barrier_waiting ==
false);
245 VM_ASSERT(cr == GET_RACTOR());
246 VM_ASSERT(rb_ractor_status_p(cr, ractor_running));
248 vm->ractor.sync.barrier_waiting =
true;
250 RUBY_DEBUG_LOG(
"barrier start. cnt:%u living:%u blocking:%u",
251 vm->ractor.sync.barrier_cnt,
253 vm->ractor.blocking_cnt);
255 rb_vm_ractor_blocking_cnt_inc(vm, cr, __FILE__, __LINE__);
259 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
261 rb_ractor_vm_barrier_interrupt_running_thread(r);
266 while (!vm_barrier_finish_p(vm)) {
267 rb_vm_cond_wait(vm, &vm->ractor.sync.barrier_cond);
270 RUBY_DEBUG_LOG(
"cnt:%u barrier success", vm->ractor.sync.barrier_cnt);
272 rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);
274 vm->ractor.sync.barrier_waiting =
false;
275 vm->ractor.sync.barrier_cnt++;
277 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
285 unsigned int recorded_lock_rec,
286 unsigned int current_lock_rec)
288 VM_ASSERT(recorded_lock_rec != current_lock_rec);
290 if (UNLIKELY(recorded_lock_rec > current_lock_rec)) {
291 rb_bug(
"unexpected situation - recordd:%u current:%u",
292 recorded_lock_rec, current_lock_rec);
295 while (recorded_lock_rec < current_lock_rec) {
296 RB_VM_LOCK_LEAVE_LEV(¤t_lock_rec);
300 VM_ASSERT(recorded_lock_rec == rb_ec_vm_lock_rec(ec));
void rb_bug(const char *fmt,...)
Interpreter panic switch.
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_cond_signal(rb_nativethread_cond_t *cond)
Signals a condition variable.
void rb_native_cond_wait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex)
Waits for the passed condition variable to be signalled.
void rb_native_cond_timedwait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex, unsigned long msec)
Identical to rb_native_cond_wait(), except it additionally takes timeout in msec resolution.