Rename fiber_serial into ec_serial

Since it now live in the EC.

Author: byroot

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;

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 */

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;

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;

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;
             }
         }

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);
     }

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)
 {