Setup Github Action

Author: miry

.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: Test
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+  schedule:
+    - cron: 13 7 * * 6
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby_version:
+          - 3.3.8
+          - 3.4.3
+        experimental: [false]
+        include:
+          - ruby_version: head
+            experimental: true
+    name: Ruby ${{ matrix.ruby_version }}
+    continue-on-error: ${{ matrix.experimental }}
+    steps:
+      - name: "[Git] Checkout code"
+        uses: actions/checkout@v4
+
+      - uses: crystal-lang/install-crystal@v1
+        with:
+          crystal: 1.15.1
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby_version }}
+          bundler-cache: true
+
+      - name: "[Test] Run tests"
+        run: |
+          bundle exec crystalruby clean
+          bundle exec rake test
+        env:
+          CRYSTAL_RUBY_SINGLE_THREAD_MODE: true
+
+      - name: "[Test] Validate examples"
+        run: |
+          for example in examples/**/*.rb; do
+            echo " > Processing $example..."
+            bundle exec ruby $example
+          done

lib/crystalruby/reactor.rb

@@ -10,8 +10,10 @@ module Reactor
     module_function
 
     class SingleThreadViolation < StandardError; end
+
     class StopReactor < StandardError; end
 
+    @op_count = 0
     @single_thread_mode = false
 
     REACTOR_QUEUE = Queue.new
@@ -44,7 +46,7 @@ class StopReactor < StandardError; end
 
     # We memoize callbacks, once per return type
     CALLBACKS_MAP = Hash.new do |h, rt|
-      h[rt] = FFI::Function.new(:void, [:int, *(rt == :void ? [] : [rt])]) do |tid, ret|
+      h[rt] = FFI::Function.new(:void, [:int, *((rt == :void) ? [] : [rt])]) do |tid, ret|
         THREAD_MAP[tid][:error] = nil
         THREAD_MAP[tid][:result] = ret
         THREAD_MAP[tid][:cond].signal
@@ -104,12 +106,13 @@ def start!
         CrystalRuby.log_debug("CrystalRuby initialized")
         while true
           handler, *args, lib = REACTOR_QUEUE.pop
+          puts "\n\n\n======================="
           send(handler, *args, lib)
           @op_count += 1
           invoke_gc_if_due!(lib)
         end
-      rescue StopReactor => e
-      rescue StandardError => e
+      rescue StopReactor
+      rescue => e
         CrystalRuby.log_error "Error: #{e}"
         CrystalRuby.log_error e.backtrace
       end
@@ -123,20 +126,21 @@ def gc_due?
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       # Initialize state variables if not already set.
-      @last_gc_time       ||= now
-      @last_gc_op_count   ||= @op_count
+      @last_gc_time ||= now
+      @op_count ||= 0
+      @last_gc_op_count ||= @op_count
       @last_mem_check_time ||= now
 
       # Calculate differences based on ops and time.
-      ops_since_last_gc  = @op_count - @last_gc_op_count
+      ops_since_last_gc = @op_count - @last_gc_op_count
       time_since_last_gc = now - @last_gc_time
 
       # Start with our two “cheap” conditions.
       due = (ops_since_last_gc >= GC_OP_THRESHOLD) || (time_since_last_gc >= GC_INTERVAL) || Types::Allocator.gc_bytes_seen > GC_BYTES_SEEN_THRESHOLD
 
       if due
         # Update the baseline values after GC is scheduled.
-        @last_gc_time     = now
+        @last_gc_time = now
         # If we just did a memory check, use that value; otherwise, fetch one now.
         @last_gc_op_count = @op_count
         Types::Allocator.gc_hint_reset!
@@ -173,10 +177,10 @@ def invoke_blocking!(receiver, op_name, *args, tvars, _lib)
       tvars[:error] = nil
       begin
         tvars[:result] = receiver.send(op_name, *args)
-      rescue StopReactor => e
+      rescue StopReactor
         tvars[:cond].signal
         raise
-      rescue StandardError => e
+      rescue => e
         tvars[:error] = e
       end
       tvars[:cond].signal
@@ -191,8 +195,8 @@ def schedule_work!(receiver, op_name, *args, return_type, blocking: true, async:
       if @single_thread_mode || (Thread.current.object_id == @main_thread_id && op_name != :yield)
         unless Thread.current.object_id == @main_thread_id
           raise SingleThreadViolation,
-                "Single thread mode is enabled, cannot run in multi-threaded mode. " \
-                "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
+            "Single thread mode is enabled, cannot run in multi-threaded mode. " \
+            "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
         end
         invoke_gc_if_due!(lib)
         return receiver.send(op_name, *args)