Process.clock_gettimeの代替として、Delayer内で一貫した時刻を得るDelayer.ticksを実装

lib/delayer/delayed_procedure.rb

@@ -10,9 +10,9 @@ def initialize(delayer, delay:, &proc)
       @proc = proc
       case delay
       when Time
-        @reserve_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay.to_f - Time.now.to_f
+        @reserve_at = delayer.class.ticks + delay.to_f - Time.now.to_f
       else
-        @reserve_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + delay.to_f
+        @reserve_at = delayer.class.ticks + delay.to_f
       end
       @cancel = nil
       @procedure = nil

lib/delayer/extend.rb

@@ -65,7 +65,7 @@ def self.extended(klass)
       end
     end
 
-    def pop_reserve(start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC))
+    def pop_reserve(start_time = ticks)
       if @last_reserve&.reserve_at&.<=(start_time)
         lock.synchronize do
           while @last_reserve&.reserve_at&.<=(start_time)
@@ -83,13 +83,13 @@ def pop_reserve(start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC))
     # ==== Return
     # self
     def run(current_expire = @expire)
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      start_time = ticks
       pop_reserve(start_time)
       if current_expire == 0
         run_once_without_pop_reserve until empty?
       else
         @end_time = start_time + @expire
-        run_once_without_pop_reserve while !empty? && (@end_time >= Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        run_once_without_pop_reserve while !empty? && (@end_time >= ticks)
         @end_time = nil
       end
       if @remain_hook

src/delayer.c

@@ -1,31 +1,27 @@
 #include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/error.h>
 #include <time.h>
 #include <errno.h>
 
-static mrb_value process_clock_gettime(mrb_state *mrb, mrb_value self) {
-  mrb_value clock_id = mrb_get_arg1(mrb);
-  if (!mrb_fixnum_p(clock_id)) {
-    return mrb_nil_value();
-  }
-
+static mrb_value delayer_extend_ticks(mrb_state *mrb, mrb_value self) {
   struct timespec ts = {};
-  if (clock_gettime(mrb_fixnum(clock_id), &ts) == 0) {
+  if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
 #ifdef MRB_WITHOUT_FLOAT
     return mrb_fixnum_value(ts.tv_sec);
 #else
     return mrb_float_value(mrb, (mrb_float) ts.tv_sec + (mrb_float) ts.tv_nsec/1.0e9);
 #endif
   } else {
-    mrb_raisef(mrb, E_RUNTIME_ERROR, "clock_gettime() error %d", errno);
+    mrb_sys_fail(mrb, mrb_string_cstr(mrb, mrb_format(mrb, "clock_gettime failed (%d)", errno)));
   }
 }
 
 void mrb_mruby_delayer_gem_init(mrb_state *mrb) {
   struct RClass *mod_delayer = mrb_define_module(mrb, "Delayer");
 
-  struct RClass *mod_process = mrb_define_module_under(mrb, mod_delayer, "Process");
-  mrb_define_module_function(mrb, mod_process, "clock_gettime", process_clock_gettime, MRB_ARGS_ARG(1, 1));
-  mrb_define_const(mrb, mod_process, "CLOCK_MONOTONIC", mrb_fixnum_value(CLOCK_MONOTONIC));
+  struct RClass *mod_delayer_extend = mrb_define_module_under(mrb, mod_delayer, "Extend");
+  mrb_define_module_function(mrb, mod_delayer_extend, "ticks", delayer_extend_ticks, MRB_ARGS_NONE());
 }
 
 void mrb_mruby_delayer_gem_final(mrb_state *mrb) {