Monitor: avoid repeated calls to rb_fiber_current()

That call is surprisingly expensive, so trying doing it once
in `#synchronize` and then passing the fiber to enter and exit
saves quite a few cycles.

Author: byroot

ext/monitor/monitor.c

@@ -50,10 +50,10 @@ monitor_ptr(VALUE monitor)
     return mc;
 }
 
-static int
-mc_owner_p(struct rb_monitor *mc)
+static bool
+mc_owner_p(struct rb_monitor *mc, VALUE current_fiber)
 {
-    return mc->owner == rb_fiber_current();
+    return mc->owner == current_fiber;
 }
 
 /*
@@ -67,17 +67,44 @@ monitor_try_enter(VALUE monitor)
 {
     struct rb_monitor *mc = monitor_ptr(monitor);
 
-    if (!mc_owner_p(mc)) {
+    VALUE current_fiber = rb_fiber_current();
+    if (!mc_owner_p(mc, current_fiber)) {
         if (!rb_mutex_trylock(mc->mutex)) {
             return Qfalse;
         }
-        RB_OBJ_WRITE(monitor, &mc->owner, rb_fiber_current());
+        RB_OBJ_WRITE(monitor, &mc->owner, current_fiber);
         mc->count = 0;
     }
     mc->count += 1;
     return Qtrue;
 }
 
+
+struct monitor_args {
+    VALUE monitor;
+    struct rb_monitor *mc;
+    VALUE current_fiber;
+};
+
+static inline void
+monitor_args_init(struct monitor_args *args, VALUE monitor)
+{
+    args->monitor = monitor;
+    args->mc = monitor_ptr(monitor);
+    args->current_fiber = rb_fiber_current();
+}
+
+static void
+monitor_enter0(struct monitor_args *args)
+{
+    if (!mc_owner_p(args->mc, args->current_fiber)) {
+        rb_mutex_lock(args->mc->mutex);
+        RB_OBJ_WRITE(args->monitor, &args->mc->owner, args->current_fiber);
+        args->mc->count = 0;
+    }
+    args->mc->count++;
+}
+
 /*
  * call-seq:
  *   enter -> nil
@@ -87,27 +114,44 @@ monitor_try_enter(VALUE monitor)
 static VALUE
 monitor_enter(VALUE monitor)
 {
-    struct rb_monitor *mc = monitor_ptr(monitor);
-    if (!mc_owner_p(mc)) {
-        rb_mutex_lock(mc->mutex);
-        RB_OBJ_WRITE(monitor, &mc->owner, rb_fiber_current());
-        mc->count = 0;
-    }
-    mc->count++;
+    struct monitor_args args;
+    monitor_args_init(&args, monitor);
+    monitor_enter0(&args);
     return Qnil;
 }
 
+static inline void
+monitor_check_owner0(struct monitor_args *args)
+{
+    if (!mc_owner_p(args->mc, args->current_fiber)) {
+        rb_raise(rb_eThreadError, "current fiber not owner");
+    }
+}
+
 /* :nodoc: */
 static VALUE
 monitor_check_owner(VALUE monitor)
 {
-    struct rb_monitor *mc = monitor_ptr(monitor);
-    if (!mc_owner_p(mc)) {
-        rb_raise(rb_eThreadError, "current fiber not owner");
-    }
+    struct monitor_args args;
+    monitor_args_init(&args, monitor);
+    monitor_check_owner0(&args);
     return Qnil;
 }
 
+static void
+monitor_exit0(struct monitor_args *args)
+{
+    monitor_check_owner(args->monitor);
+
+    if (args->mc->count <= 0) rb_bug("monitor_exit: count:%d", (int)args->mc->count);
+    args->mc->count--;
+
+    if (args->mc->count == 0) {
+        RB_OBJ_WRITE(args->monitor, &args->mc->owner, Qnil);
+        rb_mutex_unlock(args->mc->mutex);
+    }
+}
+
 /*
  * call-seq:
  *   exit -> nil
@@ -117,17 +161,9 @@ monitor_check_owner(VALUE monitor)
 static VALUE
 monitor_exit(VALUE monitor)
 {
-    monitor_check_owner(monitor);
-
-    struct rb_monitor *mc = monitor_ptr(monitor);
-
-    if (mc->count <= 0) rb_bug("monitor_exit: count:%d", (int)mc->count);
-    mc->count--;
-
-    if (mc->count == 0) {
-        RB_OBJ_WRITE(monitor, &mc->owner, Qnil);
-        rb_mutex_unlock(mc->mutex);
-    }
+    struct monitor_args args;
+    monitor_args_init(&args, monitor);
+    monitor_exit0(&args);
     return Qnil;
 }
 
@@ -144,7 +180,7 @@ static VALUE
 monitor_owned_p(VALUE monitor)
 {
     struct rb_monitor *mc = monitor_ptr(monitor);
-    return (rb_mutex_locked_p(mc->mutex) && mc_owner_p(mc)) ? Qtrue : Qfalse;
+    return rb_mutex_locked_p(mc->mutex) && mc_owner_p(mc, rb_fiber_current()) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -210,9 +246,10 @@ monitor_sync_body(VALUE monitor)
 }
 
 static VALUE
-monitor_sync_ensure(VALUE monitor)
+monitor_sync_ensure(VALUE v_args)
 {
-    return monitor_exit(monitor);
+    monitor_exit0((struct monitor_args *)v_args);
+    return Qnil;
 }
 
 /*
@@ -226,8 +263,10 @@ monitor_sync_ensure(VALUE monitor)
 static VALUE
 monitor_synchronize(VALUE monitor)
 {
-    monitor_enter(monitor);
-    return rb_ensure(monitor_sync_body, monitor, monitor_sync_ensure, monitor);
+    struct monitor_args args;
+    monitor_args_init(&args, monitor);
+    monitor_enter0(&args);
+    return rb_ensure(monitor_sync_body, (VALUE)&args, monitor_sync_ensure, (VALUE)&args);
 }
 
 void

thread_sync.c

@@ -239,23 +239,34 @@ thread_mutex_remove(rb_thread_t *thread, rb_mutex_t *mutex)
 }
 
 static void
-mutex_set_owner(VALUE self, rb_thread_t *th, rb_fiber_t *fiber)
+mutex_set_owner(rb_mutex_t *mutex, rb_thread_t *th, rb_fiber_t *fiber)
 {
-    rb_mutex_t *mutex = mutex_ptr(self);
-
     mutex->thread = th->self;
     mutex->fiber_serial = rb_fiber_serial(fiber);
 }
 
 static void
-mutex_locked(rb_thread_t *th, rb_fiber_t *fiber, VALUE self)
+mutex_locked(rb_mutex_t *mutex, rb_thread_t *th, rb_fiber_t *fiber)
 {
-    rb_mutex_t *mutex = mutex_ptr(self);
-
-    mutex_set_owner(self, th, fiber);
+    mutex_set_owner(mutex, th, fiber);
     thread_mutex_insert(th, mutex);
 }
 
+static inline bool
+mutex_trylock(rb_mutex_t *mutex, rb_thread_t *th, rb_fiber_t *fiber)
+{
+    if (mutex->fiber_serial == 0) {
+        RUBY_DEBUG_LOG("%p ok", mutex);
+
+        mutex_locked(mutex, th, fiber);
+        return true;
+    }
+    else {
+        RUBY_DEBUG_LOG("%p ng", mutex);
+        return false;
+    }
+}
+
 /*
  * call-seq:
  *    mutex.try_lock  -> true or false
@@ -266,21 +277,7 @@ mutex_locked(rb_thread_t *th, rb_fiber_t *fiber, VALUE self)
 VALUE
 rb_mutex_trylock(VALUE self)
 {
-    rb_mutex_t *mutex = mutex_ptr(self);
-
-    if (mutex->fiber_serial == 0) {
-        RUBY_DEBUG_LOG("%p ok", mutex);
-
-        rb_fiber_t *fiber = GET_EC()->fiber_ptr;
-        rb_thread_t *th = GET_THREAD();
-
-        mutex_locked(th, fiber, self);
-        return Qtrue;
-    }
-    else {
-        RUBY_DEBUG_LOG("%p ng", mutex);
-        return Qfalse;
-    }
+    return RBOOL(mutex_trylock(mutex_ptr(self), GET_THREAD(), GET_EC()->fiber_ptr));
 }
 
 static VALUE
@@ -321,7 +318,7 @@ do_mutex_lock(VALUE self, int interruptible_p)
         rb_raise(rb_eThreadError, "can't be called from trap context");
     }
 
-    if (rb_mutex_trylock(self) == Qfalse) {
+    if (!mutex_trylock(mutex, th, fiber)) {
         if (mutex->fiber_serial == rb_fiber_serial(fiber)) {
             rb_raise(rb_eThreadError, "deadlock; recursive locking");
         }
@@ -342,7 +339,7 @@ do_mutex_lock(VALUE self, int interruptible_p)
                 rb_ensure(call_rb_fiber_scheduler_block, self, delete_from_waitq, (VALUE)&sync_waiter);
 
                 if (!mutex->fiber_serial) {
-                    mutex_set_owner(self, th, fiber);
+                    mutex_set_owner(mutex, th, fiber);
                 }
             }
             else {
@@ -383,7 +380,7 @@ do_mutex_lock(VALUE self, int interruptible_p)
 
                 // unlocked by another thread while sleeping
                 if (!mutex->fiber_serial) {
-                    mutex_set_owner(self, th, fiber);
+                    mutex_set_owner(mutex, th, fiber);
                 }
 
                 rb_ractor_sleeper_threads_dec(th->ractor);
@@ -402,7 +399,7 @@ do_mutex_lock(VALUE self, int interruptible_p)
                 }
                 RUBY_VM_CHECK_INTS_BLOCKING(th->ec); /* may release mutex */
                 if (!mutex->fiber_serial) {
-                    mutex_set_owner(self, th, fiber);
+                    mutex_set_owner(mutex, th, fiber);
                 }
             }
             else {
@@ -421,7 +418,7 @@ do_mutex_lock(VALUE self, int interruptible_p)
         }
 
         if (saved_ints) th->ec->interrupt_flag = saved_ints;
-        if (mutex->fiber_serial == rb_fiber_serial(fiber)) mutex_locked(th, fiber, self);
+        if (mutex->fiber_serial == rb_fiber_serial(fiber)) mutex_locked(mutex, th, fiber);
     }
 
     RUBY_DEBUG_LOG("%p locked", mutex);