From e42bcd7ce76e75601ef3adf35467edf277471af2 Mon Sep 17 00:00:00 2001 From: Jean Boussier Date: Tue, 16 Dec 2025 00:43:41 +0100 Subject: [PATCH] Rename fiber_serial into ec_serial Since it now live in the EC. --- cont.c | 8 +++--- internal/cont.h | 7 ----- ractor.c | 4 +-- ractor_core.h | 2 +- thread.c | 10 +++---- thread_sync.c | 70 ++++++++++++++++++++++++------------------------- vm_core.h | 9 ++++++- 7 files changed, 55 insertions(+), 55 deletions(-) diff --git a/cont.c b/cont.c index 404574e110c..00879947304 100644 --- a/cont.c +++ b/cont.c @@ -1996,9 +1996,9 @@ fiber_alloc(VALUE klass) } static rb_serial_t -next_fiber_serial(rb_ractor_t *cr) +next_ec_serial(rb_ractor_t *cr) { - return cr->next_fiber_serial++; + return cr->next_ec_serial++; } static rb_fiber_t* @@ -2020,7 +2020,7 @@ fiber_t_alloc(VALUE fiber_value, unsigned int blocking) cont_init(&fiber->cont, th); fiber->cont.saved_ec.fiber_ptr = fiber; - fiber->cont.saved_ec.fiber_serial = next_fiber_serial(th->ractor); + fiber->cont.saved_ec.serial = next_ec_serial(th->ractor); rb_ec_clear_vm_stack(&fiber->cont.saved_ec); fiber->prev = NULL; @@ -2567,7 +2567,7 @@ rb_threadptr_root_fiber_setup(rb_thread_t *th) } fiber->cont.type = FIBER_CONTEXT; fiber->cont.saved_ec.fiber_ptr = fiber; - fiber->cont.saved_ec.fiber_serial = next_fiber_serial(th->ractor); + fiber->cont.saved_ec.serial = next_ec_serial(th->ractor); fiber->cont.saved_ec.thread_ptr = th; fiber->blocking = 1; fiber->killed = 0; diff --git a/internal/cont.h b/internal/cont.h index bbcaf0b1882..dcf6f820a38 100644 --- a/internal/cont.h +++ b/internal/cont.h @@ -31,11 +31,4 @@ VALUE rb_fiber_inherit_storage(struct rb_execution_context_struct *ec, struct rb VALUE rb_fiberptr_self(struct rb_fiber_struct *fiber); unsigned int rb_fiberptr_blocking(struct rb_fiber_struct *fiber); struct rb_execution_context_struct * rb_fiberptr_get_ec(struct rb_fiber_struct *fiber); - -static inline rb_serial_t -rb_ec_fiber_serial(struct rb_execution_context_struct *ec) -{ - VM_ASSERT(ec->fiber_serial >= 1); - return ec->fiber_serial; -} #endif /* INTERNAL_CONT_H */ diff --git a/ractor.c b/ractor.c index f65a4f79c1f..5c98196c912 100644 --- a/ractor.c +++ b/ractor.c @@ -422,7 +422,7 @@ ractor_alloc(VALUE klass) VALUE rv = TypedData_Make_Struct(klass, rb_ractor_t, &ractor_data_type, r); FL_SET_RAW(rv, RUBY_FL_SHAREABLE); r->pub.self = rv; - r->next_fiber_serial = 1; + r->next_ec_serial = 1; VM_ASSERT(ractor_status_p(r, ractor_created)); return rv; } @@ -440,7 +440,7 @@ rb_ractor_main_alloc(void) r->name = Qnil; r->pub.self = Qnil; r->newobj_cache = rb_gc_ractor_cache_alloc(r); - r->next_fiber_serial = 1; + r->next_ec_serial = 1; ruby_single_main_ractor = r; return r; diff --git a/ractor_core.h b/ractor_core.h index d6f9d4eda0f..96d22bea29e 100644 --- a/ractor_core.h +++ b/ractor_core.h @@ -91,7 +91,7 @@ struct rb_ractor_struct { // ractor local data - rb_serial_t next_fiber_serial; + rb_serial_t next_ec_serial; st_table *local_storage; struct rb_id_table *idkey_local_storage; diff --git a/thread.c b/thread.c index cea8e7fe75d..3e1bb1dbe7a 100644 --- a/thread.c +++ b/thread.c @@ -453,7 +453,7 @@ rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th) th->keeping_mutexes = mutex->next_mutex; // rb_warn("mutex #<%p> was not unlocked by thread #<%p>", (void *)mutex, (void*)th); - VM_ASSERT(mutex->fiber_serial); + VM_ASSERT(mutex->ec_serial); const char *error_message = rb_mutex_unlock_th(mutex, th, 0); if (error_message) rb_bug("invalid keeping_mutexes: %s", error_message); } @@ -5283,7 +5283,7 @@ rb_thread_shield_owned(VALUE self) rb_mutex_t *m = mutex_ptr(mutex); - return m->fiber_serial == rb_ec_fiber_serial(GET_EC()); + return m->ec_serial == rb_ec_serial(GET_EC()); } /* @@ -5302,7 +5302,7 @@ rb_thread_shield_wait(VALUE self) if (!mutex) return Qfalse; m = mutex_ptr(mutex); - if (m->fiber_serial == rb_ec_fiber_serial(GET_EC())) return Qnil; + if (m->ec_serial == rb_ec_serial(GET_EC())) return Qnil; rb_thread_shield_waiting_inc(self); rb_mutex_lock(mutex); rb_thread_shield_waiting_dec(self); @@ -5820,7 +5820,7 @@ debug_deadlock_check(rb_ractor_t *r, VALUE msg) if (th->locking_mutex) { rb_mutex_t *mutex = mutex_ptr(th->locking_mutex); rb_str_catf(msg, " mutex:%llu cond:%"PRIuSIZE, - (unsigned long long)mutex->fiber_serial, rb_mutex_num_waiting(mutex)); + (unsigned long long)mutex->ec_serial, rb_mutex_num_waiting(mutex)); } { @@ -5860,7 +5860,7 @@ rb_check_deadlock(rb_ractor_t *r) } else if (th->locking_mutex) { rb_mutex_t *mutex = mutex_ptr(th->locking_mutex); - if (mutex->fiber_serial == rb_ec_fiber_serial(th->ec) || (!mutex->fiber_serial && !ccan_list_empty(&mutex->waitq))) { + if (mutex->ec_serial == rb_ec_serial(th->ec) || (!mutex->ec_serial && !ccan_list_empty(&mutex->waitq))) { found = 1; } } diff --git a/thread_sync.c b/thread_sync.c index 5af86c5a3b2..6bff982f31d 100644 --- a/thread_sync.c +++ b/thread_sync.c @@ -7,7 +7,7 @@ static VALUE rb_eClosedQueueError; /* Mutex */ typedef struct rb_mutex_struct { - rb_serial_t fiber_serial; + rb_serial_t ec_serial; VALUE thread; // even if the fiber is collected, we might need access to the thread in mutex_free struct rb_mutex_struct *next_mutex; struct ccan_list_head waitq; /* protected by GVL */ @@ -81,7 +81,7 @@ static void rb_mutex_abandon_all(rb_mutex_t *mutexes); static void rb_mutex_abandon_keeping_mutexes(rb_thread_t *th); static void rb_mutex_abandon_locking_mutex(rb_thread_t *th); #endif -static const char* rb_mutex_unlock_th(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial); +static const char* rb_mutex_unlock_th(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t ec_serial); /* * Document-class: Thread::Mutex @@ -125,7 +125,7 @@ rb_thread_t* rb_fiber_threadptr(const rb_fiber_t *fiber); static bool mutex_locked_p(rb_mutex_t *mutex) { - return mutex->fiber_serial != 0; + return mutex->ec_serial != 0; } static void @@ -221,26 +221,26 @@ thread_mutex_remove(rb_thread_t *thread, rb_mutex_t *mutex) } static void -mutex_set_owner(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial) +mutex_set_owner(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t ec_serial) { mutex->thread = th->self; - mutex->fiber_serial = fiber_serial; + mutex->ec_serial = ec_serial; } static void -mutex_locked(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial) +mutex_locked(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t ec_serial) { - mutex_set_owner(mutex, th, fiber_serial); + mutex_set_owner(mutex, th, ec_serial); thread_mutex_insert(th, mutex); } static inline bool -mutex_trylock(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial) +mutex_trylock(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t ec_serial) { - if (mutex->fiber_serial == 0) { + if (mutex->ec_serial == 0) { RUBY_DEBUG_LOG("%p ok", mutex); - mutex_locked(mutex, th, fiber_serial); + mutex_locked(mutex, th, ec_serial); return true; } else { @@ -252,7 +252,7 @@ mutex_trylock(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial) static VALUE rb_mut_trylock(rb_execution_context_t *ec, VALUE self) { - return RBOOL(mutex_trylock(mutex_ptr(self), ec->thread_ptr, rb_ec_fiber_serial(ec))); + return RBOOL(mutex_trylock(mutex_ptr(self), ec->thread_ptr, rb_ec_serial(ec))); } VALUE @@ -262,9 +262,9 @@ rb_mutex_trylock(VALUE self) } static VALUE -mutex_owned_p(rb_serial_t fiber_serial, rb_mutex_t *mutex) +mutex_owned_p(rb_serial_t ec_serial, rb_mutex_t *mutex) { - return RBOOL(mutex->fiber_serial == fiber_serial); + return RBOOL(mutex->ec_serial == ec_serial); } static VALUE @@ -305,7 +305,7 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) rb_execution_context_t *ec = args->ec; rb_thread_t *th = ec->thread_ptr; rb_fiber_t *fiber = ec->fiber_ptr; - rb_serial_t fiber_serial = rb_ec_fiber_serial(ec); + rb_serial_t ec_serial = rb_ec_serial(ec); rb_mutex_t *mutex = args->mutex; rb_atomic_t saved_ints = 0; @@ -315,13 +315,13 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) rb_raise(rb_eThreadError, "can't be called from trap context"); } - if (!mutex_trylock(mutex, th, fiber_serial)) { - if (mutex->fiber_serial == fiber_serial) { + if (!mutex_trylock(mutex, th, ec_serial)) { + if (mutex->ec_serial == ec_serial) { rb_raise(rb_eThreadError, "deadlock; recursive locking"); } - while (mutex->fiber_serial != fiber_serial) { - VM_ASSERT(mutex->fiber_serial != 0); + while (mutex->ec_serial != ec_serial) { + VM_ASSERT(mutex->ec_serial != 0); VALUE scheduler = rb_fiber_scheduler_current(); if (scheduler != Qnil) { @@ -335,8 +335,8 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) rb_ensure(call_rb_fiber_scheduler_block, self, delete_from_waitq, (VALUE)&sync_waiter); - if (!mutex->fiber_serial) { - mutex_set_owner(mutex, th, fiber_serial); + if (!mutex->ec_serial) { + mutex_set_owner(mutex, th, ec_serial); } } else { @@ -376,8 +376,8 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) ccan_list_del(&sync_waiter.node); // unlocked by another thread while sleeping - if (!mutex->fiber_serial) { - mutex_set_owner(mutex, th, fiber_serial); + if (!mutex->ec_serial) { + mutex_set_owner(mutex, th, ec_serial); } rb_ractor_sleeper_threads_dec(th->ractor); @@ -390,13 +390,13 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) if (interruptible_p) { /* release mutex before checking for interrupts...as interrupt checking * code might call rb_raise() */ - if (mutex->fiber_serial == fiber_serial) { + if (mutex->ec_serial == ec_serial) { mutex->thread = Qfalse; - mutex->fiber_serial = 0; + mutex->ec_serial = 0; } RUBY_VM_CHECK_INTS_BLOCKING(th->ec); /* may release mutex */ - if (!mutex->fiber_serial) { - mutex_set_owner(mutex, th, fiber_serial); + if (!mutex->ec_serial) { + mutex_set_owner(mutex, th, ec_serial); } } else { @@ -415,13 +415,13 @@ do_mutex_lock(struct mutex_args *args, int interruptible_p) } if (saved_ints) th->ec->interrupt_flag = saved_ints; - if (mutex->fiber_serial == fiber_serial) mutex_locked(mutex, th, fiber_serial); + if (mutex->ec_serial == ec_serial) mutex_locked(mutex, th, ec_serial); } RUBY_DEBUG_LOG("%p locked", mutex); // assertion - if (mutex_owned_p(fiber_serial, mutex) == Qfalse) rb_bug("do_mutex_lock: mutex is not owned."); + if (mutex_owned_p(ec_serial, mutex) == Qfalse) rb_bug("do_mutex_lock: mutex is not owned."); return self; } @@ -456,7 +456,7 @@ rb_mutex_lock(VALUE self) static VALUE rb_mut_owned_p(rb_execution_context_t *ec, VALUE self) { - return mutex_owned_p(rb_ec_fiber_serial(ec), mutex_ptr(self)); + return mutex_owned_p(rb_ec_serial(ec), mutex_ptr(self)); } VALUE @@ -466,20 +466,20 @@ rb_mutex_owned_p(VALUE self) } static const char * -rb_mutex_unlock_th(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t fiber_serial) +rb_mutex_unlock_th(rb_mutex_t *mutex, rb_thread_t *th, rb_serial_t ec_serial) { RUBY_DEBUG_LOG("%p", mutex); - if (mutex->fiber_serial == 0) { + if (mutex->ec_serial == 0) { return "Attempt to unlock a mutex which is not locked"; } - else if (fiber_serial && mutex->fiber_serial != fiber_serial) { + else if (ec_serial && mutex->ec_serial != ec_serial) { return "Attempt to unlock a mutex which is locked by another thread/fiber"; } struct sync_waiter *cur = 0, *next; - mutex->fiber_serial = 0; + mutex->ec_serial = 0; thread_mutex_remove(th, mutex); ccan_list_for_each_safe(&mutex->waitq, cur, next, node) { @@ -517,7 +517,7 @@ do_mutex_unlock(struct mutex_args *args) rb_mutex_t *mutex = args->mutex; rb_thread_t *th = rb_ec_thread_ptr(args->ec); - err = rb_mutex_unlock_th(mutex, th, rb_ec_fiber_serial(args->ec)); + err = rb_mutex_unlock_th(mutex, th, rb_ec_serial(args->ec)); if (err) rb_raise(rb_eThreadError, "%s", err); } @@ -583,7 +583,7 @@ rb_mutex_abandon_all(rb_mutex_t *mutexes) while (mutexes) { mutex = mutexes; mutexes = mutex->next_mutex; - mutex->fiber_serial = 0; + mutex->ec_serial = 0; mutex->next_mutex = 0; ccan_list_head_init(&mutex->waitq); } diff --git a/vm_core.h b/vm_core.h index d61686f4b66..c716e001a5f 100644 --- a/vm_core.h +++ b/vm_core.h @@ -1041,7 +1041,7 @@ struct rb_execution_context_struct { rb_fiber_t *fiber_ptr; struct rb_thread_struct *thread_ptr; - rb_serial_t fiber_serial; + rb_serial_t serial; /* storage (ec (fiber) local) */ struct rb_id_table *local_storage; @@ -2037,6 +2037,13 @@ RUBY_EXTERN unsigned int ruby_vm_event_local_num; #define GET_THREAD() rb_current_thread() #define GET_EC() rb_current_execution_context(true) +static inline rb_serial_t +rb_ec_serial(struct rb_execution_context_struct *ec) +{ + VM_ASSERT(ec->serial >= 1); + return ec->serial; +} + static inline rb_thread_t * rb_ec_thread_ptr(const rb_execution_context_t *ec) {