crystalruby 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41e8370627d23725b55bb1916254b88690e93b384c94692d59d73b0cf5ceda03
-  data.tar.gz: 7d7192ea627331a30f6cd9ff9dcc7482ed2b1e373f115cc0e3cfa19edd5db506
+  metadata.gz: 49ff0856e24d9a62e6dda014115652431074d4a45e1cb4270c92beeae2baa7ea
+  data.tar.gz: adaa86c18d254bf07704997050133db592dd60dda5ca9aed9f4c2bc34edfd7a9
 SHA512:
-  metadata.gz: 56d644c482b04bb8f5b39b6626dda93079578f3f95809294a441e0fd1707aeb71eb253da7a549c351fe448750f6dd2acfdbda3782b37e5aaebb4019332c64d0c
-  data.tar.gz: c529c61b9564f6d23dc551209ac7ce426d56a02424a970b57825f5e993953c376fa57afb3880db0647d581391e7d88881775cd0e2284408997fbaf4e8b37a690
+  metadata.gz: 599c397e9710bb7dfe528e3ec49b64cfbf61f0d73089dc3476d85587317c894367b09f8b47e062d5cc98646575512421f28860aadeceac62f05588a80830726b
+  data.tar.gz: 60b9896f92cf41389933c80bb21e5c4e899e54648575ca778dcea2ba881876ef3f2539bdc46ab1c22b3f234f1237019454f8726957f5858c83ba59a2065e406f

data/README.md

@@ -43,33 +43,49 @@ E.g.
 require 'crystalruby'
 require 'benchmark'
 
-module Fibonnaci
+module PrimeCounter
   crystalize [n: :int32] => :int32
-  def fib_cr(n)
-    a = 0
-    b = 1
-    n.times { a, b = b, a + b }
-    a
+  def count_primes_upto_cr(n)
+    primes = 0
+    (2..n).each do |i|
+      is_prime = true
+      (2..Math.sqrt(i).to_i).each do |j|
+        if i % j == 0
+          is_prime = false
+          break
+        end
+      end
+      primes += 1
+    end
+    primes
   end
 
   module_function
 
-  def fib_rb(n)
-    a = 0
-    b = 1
-    n.times { a, b = b, a + b }
-    a
+  def count_primes_upto_rb(n)
+    primes = 0
+    (2..n).each do |i|
+      is_prime = true
+      (2..Math.sqrt(i).to_i).each do |j|
+        if i % j == 0
+          is_prime = false
+          break
+        end
+      end
+      primes += 1
+    end
+    primes
   end
 end
 
-puts(Benchmark.realtime { 1_000_000.times { Fibonnaci.fib_rb(30) } })
-puts(Benchmark.realtime { 1_000_000.times { Fibonnaci.fib_cr(30) } })
-
+include PrimeCounter
+puts(Benchmark.realtime { count_primes_upto_rb(1000_000) })
+puts(Benchmark.realtime { count_primes_upto_cr(1000_000) })
 ```
 
 ```bash
-3.193121999996947 # Ruby
-0.29086600001028273 # Crystal
+2.8195170001126826 # Ruby
+0.3402599999681115 # Crystal
 ```
 
 _Note_: The first run of the Crystal code will be slower, as it needs to compile the code first. The subsequent runs will be much faster.
@@ -121,10 +137,10 @@ end
 ### Crystal Compatible
 
 Some Crystal syntax is not valid Ruby, for methods of this form, we need to
-define our functions using a :raw parameter.
+define our functions using a raw: true option
 
 ```ruby
-crystalize :raw, [a: :int, b: :int] => :int
+crystalize [a: :int, b: :int] => :int, raw: true
 def add(a, b)
   <<~CRYSTAL
     c = 0_u64
@@ -453,6 +469,51 @@ CrystalRuby.compile!
 
 Then you can run this file as part of your build step, to ensure all Crystal code is compiled ahead of time.
 
+## Concurrency
+
+While Ruby programs allow multi-threading, Crystal by default uses only a single thread, while utilising Fiber based cooperative-multitasking to allow for concurrent execution. This means that by default, Crystal libraries can not safely be invoked in parallel across multiple Ruby threads.
+
+To safely expose this behaviour, `crystalruby` implements a Reactor, which multiplexes all Ruby calls to Crystal across a single thread. This way you can safely use `crystalruby` in a multi-threaded Ruby environment.
+
+By default `crystalruby` methods are blocking/synchronous, this means that for blocking operations, a single crystalruby call can block the entire reactor.
+
+To allow you to benefit from Crystal's fiber based concurrency, you can use use the `async` option on crystalized ruby methods. This allows several Ruby threads to invoke Crystal code simultaneously.
+
+E.g.
+
+```ruby
+module Sleeper
+  crystalize [] => :void
+  def sleep_sync
+    sleep 2
+  end
+
+  crystalize [] => :void, async: true
+  def sleep_async
+    sleep 2
+  end
+end
+```
+
+```ruby
+5.times.map{ Thread.new{ Sleeper.sleep_sync } }.each(&:join) # Will take 10 seconds
+5.times.map{ Thread.new{ Sleeper.sleep_async } }.each(&:join) # Will take 2 seconds (the sleeps are processed concurrently)
+```
+
+### Reactor performance
+
+There is a small amount of overhead to multiplexing calls across a single thread. Ad-hoc testing amounts this to be around 10 nanoseconds per call.
+For most use-cases this overhead is negligible, especially if the bulk of your CPU heavy task occurs exclusively in Crystal code. However, if you are invoking very fast Crystal code from Ruby in a tight loop (e.g. a simple 1 + 2)
+then the overhead of the reactor can become significant.
+
+In this case you can use the `crystalruby` in a single-threaded mode to avoid the reactor overhead and greatly increase performance, with the caveat that _all_ calls to Crystal must occur from a single thread. If you Ruby program is already single-threaded this is not a problem.
+
+```ruby
+CrystalRuby.configure do |config|
+  config.single_thread_mode = true
+end
+```
+
 ## Troubleshooting
 
 The logic to detect when to JIT recompile is not robust and can end up in an inconsistent state. To remedy this it is useful to clear out all generated assets and build from scratch.
@@ -517,7 +578,7 @@ crystal_codegen_dir: "generated"
 debug: true
 ```
 
-Alternatively, these can be set programmatically:
+Alternatively, these can be set programmatically, e.g:
 
 ```ruby
 CrystalRuby.configure do |config|
@@ -527,6 +588,9 @@ CrystalRuby.configure do |config|
   config.crystal_lib_name = "crlib"
   config.crystal_codegen_dir = "generated"
   config.debug = true
+  config.verbose = false
+  config.colorize_log_output = false
+  config.log_level = :info
 end
 ```
 

data/exe/crystalruby

@@ -14,6 +14,8 @@ def init
     crystal_main_file: "main.cr"
     crystal_lib_name: "crlib"
     crystal_codegen_dir: "generated"
+    log_level: "info"
+    single_thread_mode: false
     debug: true
   YAML
 

data/lib/crystalruby/adapter.rb

@@ -0,0 +1,105 @@
+module CrystalRuby
+  module Adapter
+    # Define a method to set the @crystalize proc if it doesn't already exist
+    def crystalize(raw: false, async: false, **options, &block)
+      (args,), returns = options.first
+      args ||= {}
+      raise "Arguments should be of the form name: :type. Got #{args}" unless args.is_a?(Hash)
+
+      @crystalize_next = { raw: raw, async: async, args: args, returns: returns, block: block }
+    end
+
+    def crystal(raw: false, &block)
+      inline_crystal_body = Template::InlineChunk.render(
+        {
+          module_name: name,
+          body: block.source.lines[
+            raw ? 2...-2 : 1...-1
+          ].join("\n")
+        }
+      )
+      CrystalRuby.write_chunk(self, body: inline_crystal_body)
+    end
+
+    def crtype(&block)
+      TypeBuilder.with_injected_type_dsl(self) do
+        TypeBuilder.build(&block)
+      end
+    end
+
+    def json(&block)
+      crtype(&block).serialize_as(:json)
+    end
+
+    def method_added(method_name)
+      if @crystalize_next
+        define_crystalized_method(method_name, instance_method(method_name))
+        @crystalize_next = nil
+      end
+      super
+    end
+
+    def singleton_method_added(method_name)
+      if @crystalize_next
+        define_crystalized_method(method_name, singleton_method(method_name))
+        @crystalize_next = nil
+      end
+      super
+    end
+
+    def define_crystalized_method(method_name, method)
+      CrystalRuby.log_debug("Defining crystalized method #{name}.#{method_name}")
+      CrystalRuby.instantiate_crystal_ruby! unless CrystalRuby.instantiated?
+
+      function_body = method.source.lines[
+        @crystalize_next[:raw] ? 2...-2 : 1...-1
+      ].join("\n")
+
+      MethodSource.instance_variable_get(:@lines_for_file).delete(method.source_location[0])
+      lib_fname = "#{name.downcase}_#{method_name}_#{Digest::MD5.hexdigest(function_body)}"
+      args, returns, block, async = @crystalize_next.values_at(:args, :returns, :block, :async)
+      args ||= {}
+      @crystalize_next = nil
+      function = CrystalRuby.build_function(self, lib_fname, method_name, args, returns, function_body)
+      CrystalRuby.write_chunk(self, name: function[:name], body: function[:body]) do
+        CrystalRuby.log_debug("attaching #{lib_fname} to #{name}")
+        extend FFI::Library
+        ffi_lib CrystalRuby.config.crystal_lib_dir / CrystalRuby.config.crystal_lib_name
+        if async
+          attach_function lib_fname, "#{lib_fname}_async", function[:ffi_types] + %i[int pointer], :void,
+                          blocking: true
+        else
+          attach_function lib_fname, function[:ffi_types], function[:ffi_ret_type], blocking: true
+        end
+        if block
+          [self, singleton_class].each do |receiver|
+            receiver.prepend(Module.new do
+              define_method(method_name, &block)
+            end)
+          end
+        end
+      end
+
+      [self, singleton_class].each do |receiver|
+        receiver.define_method(method_name) do |*args|
+          CrystalRuby.build! unless CrystalRuby.compiled?
+          unless CrystalRuby.attached?
+            CrystalRuby.attach!
+            return send(method_name, *args) if block
+          end
+          args.each_with_index do |arg, i|
+            args[i] = function[:arg_maps][i][arg] if function[:arg_maps][i]
+          end
+
+          result = Reactor.schedule_work!(self, lib_fname, *args, function[:ffi_ret_type], async: async)
+
+          if function[:retval_map]
+            function[:retval_map][result]
+          else
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalruby/compilation.rb

@@ -1,29 +1,31 @@
 require "open3"
 require "tmpdir"
+require "shellwords"
 
 module CrystalRuby
   module Compilation
     def self.compile!(
-      src: config.crystal_src_dir_abs / config.crystal_main_file,
-      lib: config.crystal_lib_dir_abs / config.crystal_lib_name,
-      verbose: config.verbose,
-      debug: config.debug
+      src: CrystalRuby.config.crystal_src_dir_abs / CrystalRuby.config.crystal_main_file,
+      lib: CrystalRuby.config.crystal_lib_dir_abs / CrystalRuby.config.crystal_lib_name,
+      verbose: CrystalRuby.config.verbose,
+      debug: CrystalRuby.config.debug
     )
-      Dir.chdir(config.crystal_src_dir_abs) do
+      Dir.chdir(CrystalRuby.config.crystal_src_dir_abs) do
         compile_command = compile_command!(verbose: verbose, debug: debug, lib: lib, src: src)
         link_command = link_cmd!(verbose: verbose, lib: lib, src: src)
 
-        puts "[crystalruby] Compiling Crystal code: #{compile_command}" if verbose
+        CrystalRuby.log_debug "Compiling Crystal code: #{compile_command}"
         unless system(compile_command)
-          puts "Failed to build Crystal object file."
+          CrystalRuby.log_error "Failed to build Crystal object file."
           return false
         end
 
-        puts "[crystalruby] Linking Crystal code: #{link_command}" if verbose
+        CrystalRuby.log_debug "Linking Crystal code: #{link_command}"
         unless system(link_command)
-          puts "Failed to link Crystal library."
+          CrystalRuby.log_error "Failed to link Crystal library."
           return false
         end
+        CrystalRuby.log_info "Compilation successful"
       end
 
       true
@@ -35,6 +37,9 @@ module CrystalRuby
         debug_flag = debug ? "" : "--release --no-debug"
         redirect_output = " > /dev/null " unless verbose
 
+        src = Shellwords.escape(src)
+        lib = Shellwords.escape(lib)
+
         %(crystal build #{verbose_flag} #{debug_flag} --cross-compile -o #{lib} #{src}#{redirect_output})
       end
     end
@@ -48,12 +53,27 @@ module CrystalRuby
         result = nil
 
         Dir.mktmpdir do |tmp|
-          output, status = Open3.capture2("crystal build --verbose #{src} -o #{Pathname.new(tmp) / "main"}")
-          unless status.success?
-            puts "Failed to compile the Crystal code."
-            exit 1
+          CrystalRuby.log_debug "Building link command"
+          src = Shellwords.escape(src)
+          lib_dir = Shellwords.escape(CrystalRuby.config.crystal_src_dir_abs / "lib")
+          escaped_output_path = Shellwords.escape(Pathname.new(tmp) / "main")
+
+          command = "timeout -k 2s 2s bash -c \"export CRYSTAL_PATH=$(crystal env CRYSTAL_PATH):#{lib_dir} && crystal build --verbose #{src} -o #{escaped_output_path} \""
+
+          output = ""
+          pid = nil
+
+          CrystalRuby.log_debug "Running command: #{command}"
+
+          Open3.popen2e(command) do |_stdin, stdout_and_stderr, _wait_thr|
+            while line = stdout_and_stderr.gets
+              puts line if verbose
+              output += line # Capture the output
+            end
           end
 
+          CrystalRuby.log_debug "Parsing link command"
+
           # Parse the output to find the last invocation of the C compiler, which is likely the linking stage
           # and strip off the targets that the crystal compiler added.
           link_command_suffix = output.lines.select { |line| line.strip.start_with?("cc") }.last.strip[/.*(-o.*)/, 1]
@@ -70,6 +90,8 @@ module CrystalRuby
 
         result
       end
+    rescue StandardError
+      ""
     end
   end
 end

data/lib/crystalruby/config.rb

@@ -1,15 +1,24 @@
 require "singleton"
 require "yaml"
+require "logger"
 
 module CrystalRuby
   def self.config
     Config.instance
   end
 
+  %w[debug info warn error].each do |level|
+    define_singleton_method("log_#{level}") do |*msg|
+      prefix = config.colorize_log_output ? "\e[33mcrystalruby\e[0m\e[90m [#{Thread.current.object_id}]\e[0m" : "[crystalruby] #{Thread.current.object_id}"
+
+      config.logger.send(level, "#{prefix} #{msg.join(", ")}")
+    end
+  end
+
   # Define a nested Config class
   class Config
     include Singleton
-    attr_accessor :debug, :verbose
+    attr_accessor :debug, :verbose, :logger, :colorize_log_output, :single_thread_mode
 
     def initialize
       @debug = true
@@ -27,6 +36,11 @@ module CrystalRuby
       @crystal_project_root = config.fetch("crystal_project_root", Pathname.pwd)
       @debug                = config.fetch("debug", true)
       @verbose              = config.fetch("verbose", false)
+      @single_thread_mode   = config.fetch("single_thread_mode", false)
+      @colorize_log_output  = config.fetch("colorize_log_output", false)
+      @log_level            = config.fetch("log_level", ENV.fetch("CRYSTALRUBY_LOG_LEVEL", "info"))
+      @logger               = Logger.new(STDOUT)
+      @logger.level         = Logger.const_get(@log_level.to_s.upcase)
     end
 
     %w[crystal_main_file crystal_lib_name crystal_project_root].each do |method_name|
@@ -56,6 +70,11 @@ module CrystalRuby
         @paths_cache[method_name] ||= Pathname.new instance_variable_get(:"@#{method_name}")
       end
     end
+
+    def log_level=(level)
+      @log_level = level
+      @logger.level = Logger.const_get(level.to_s.upcase)
+    end
   end
 
   def self.configure

data/lib/crystalruby/reactor.rb

@@ -0,0 +1,184 @@
+module CrystalRuby
+  module Reactor
+    module_function
+
+    class ReactorStoppedException < StandardError; end
+    class SingleThreadViolation < StandardError; end
+
+    REACTOR_QUEUE = Queue.new
+
+    # We maintain a map of threads, each with a mutex, condition variable, and result
+    THREAD_MAP = Hash.new do |h, tid_or_thread, tid = tid_or_thread|
+      if tid_or_thread.is_a?(Thread)
+        ObjectSpace.define_finalizer(tid_or_thread) do
+          THREAD_MAP.delete(tid_or_thread)
+          THREAD_MAP.delete(tid_or_thread.object_id)
+        end
+        tid = tid_or_thread.object_id
+      end
+
+      h[tid] = {
+        mux: Mutex.new,
+        cond: ConditionVariable.new,
+        result: nil,
+        thread_id: tid
+      }
+      h[tid_or_thread] = h[tid] if tid_or_thread.is_a?(Thread)
+    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|
+        THREAD_MAP[tid][:error] = nil
+        THREAD_MAP[tid][:result] = ret
+        THREAD_MAP[tid][:cond].signal
+      end
+    end
+
+    ERROR_CALLBACK = FFI::Function.new(:void, %i[string string int]) do |error_type, message, tid|
+      error_type = error_type.to_sym
+      is_exception_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception)
+      error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
+      tid = tid.zero? ? Reactor.current_thread_id : tid
+      THREAD_MAP[tid][:error] = error_type.new(message)
+      THREAD_MAP[tid][:result] = nil
+      THREAD_MAP[tid][:cond].signal
+    end
+
+    def thread_conditions
+      THREAD_MAP[Thread.current]
+    end
+
+    def await_result!
+      mux, cond = thread_conditions.values_at(:mux, :cond)
+      cond.wait(mux)
+      raise THREAD_MAP[thread_id][:error] if THREAD_MAP[thread_id][:error]
+
+      THREAD_MAP[thread_id][:result]
+    end
+
+    def thread_id
+      Thread.current.object_id
+    end
+
+    def yield!(time: 0)
+      Thread.new do
+        sleep time
+        schedule_work!(Reactor, :yield, nil, async: false, blocking: false)
+      end
+    end
+
+    def current_thread_id=(val)
+      @current_thread_id = val
+    end
+
+    def current_thread_id
+      @current_thread_id
+    end
+
+    def schedule_work!(receiver, op_name, *args, return_type, blocking: true, async: true)
+      raise ReactorStoppedException, "Reactor has been terminated, no new work can be scheduled" if @stopped
+
+      if @single_thread_mode
+        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}"
+        end
+
+        return receiver.send(op_name, *args)
+      end
+
+      tvars = thread_conditions
+      tvars[:mux].synchronize do
+        REACTOR_QUEUE.push(
+          case true
+          when async
+            lambda {
+              receiver.send(
+                op_name, *args, tvars[:thread_id],
+                CALLBACKS_MAP[return_type]
+              )
+              yield!(time: 0)
+            }
+          when blocking
+            lambda {
+              tvars[:error] = nil
+              Reactor.current_thread_id = tvars[:thread_id]
+              begin
+                result = receiver.send(op_name, *args)
+              rescue StandardError => e
+                tvars[:error] = e
+              end
+              tvars[:result] = result unless tvars[:error]
+              tvars[:cond].signal
+            }
+          else
+            lambda {
+              outstanding_jobs = receiver.send(op_name, *args)
+              yield!(time: 0.01) unless outstanding_jobs.zero?
+            }
+          end
+        )
+        return await_result! if blocking
+      end
+    end
+
+    def init_single_thread_mode!
+      @single_thread_mode = true
+      @main_thread_id = Thread.current.object_id
+      init_crystal_ruby!
+    end
+
+    def init_crystal_ruby!
+      attach_lib!
+      init(ERROR_CALLBACK)
+    end
+
+    def attach_lib!
+      CrystalRuby.log_debug("Attaching lib")
+      extend FFI::Library
+      ffi_lib CrystalRuby.config.crystal_lib_dir / CrystalRuby.config.crystal_lib_name
+      attach_function :init, [:pointer], :void
+      attach_function :stop, [], :void
+      attach_function :yield, %i[], :int
+    end
+
+    def stop!
+      CrystalRuby.log_debug("Stopping reactor")
+      @stopped = true
+      sleep 1
+      @main_loop&.kill
+      @main_loop = nil
+      CrystalRuby.log_debug("Reactor stopped")
+    end
+
+    def running?
+      @main_loop&.alive?
+    end
+
+    def start!
+      @main_loop ||= begin
+        attach_lib!
+        Thread.new do
+          CrystalRuby.log_debug("Starting reactor")
+          init(ERROR_CALLBACK)
+          CrystalRuby.log_debug("CrystalRuby initialized")
+          loop do
+            REACTOR_QUEUE.pop[]
+            break if @stopped
+          end
+          stop
+          CrystalRuby.log_debug("Stopping reactor")
+        rescue StandardError => e
+          puts "Error: #{e}"
+          puts e.backtrace
+        end
+      end
+    end
+
+    at_exit do
+      @stopped = true
+    end
+  end
+end

data/lib/crystalruby/template.rb

@@ -2,11 +2,12 @@ module CrystalRuby
   module Template
     Dir[File.join(File.dirname(__FILE__), "templates", "*.cr")].each do |file|
       template_name = File.basename(file, File.extname(file)).split("_").map(&:capitalize).join
-      const_set(template_name, File.read(file))
-    end
-
-    def self.render(template, context)
-      template % context
+      template_value = File.read(file)
+      template_value.define_singleton_method(:render) do |context|
+        CrystalRuby.log_debug("Template.render: #{template_name}")
+        self % context
+      end
+      const_set(template_name, template_value)
     end
   end
 end

data/lib/crystalruby/templates/function.cr

@@ -12,7 +12,6 @@ end
 # This function is the entry point for the CrystalRuby code, exposed through FFI.
 # We apply some basic error handling here, and convert the arguments and return values
 # to ensure that we are using Crystal native types.
-
 fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
   begin
     %{convert_lib_args}
@@ -20,10 +19,44 @@ fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
       return_value = %{module_name}.%{fn_name}(%{arg_names})
       return %{convert_return_type}
     rescue ex
-      CrystalRuby.report_error("RuntimeError", ex.message.to_s)
+      CrystalRuby.report_error("RuntimeError", ex.message.to_s, 0)
     end
   rescue ex
-    CrystalRuby.report_error("ArgumentError", ex.message.to_s)
+    CrystalRuby.report_error("ArgumentError", ex.message.to_s, 0)
   end
   return %{error_value}
 end
+
+
+# This function is the async entry point for the CrystalRuby code, exposed through FFI.
+# We apply some basic error handling here, and convert the arguments and return values
+# to ensure that we are using Crystal native types.
+fun %{lib_fn_name}_async(%{lib_fn_args} thread_id: UInt32,  callback : %{callback_type}): Void
+  begin
+    %{convert_lib_args}
+    CrystalRuby.increment_task_counter
+    spawn do
+      begin
+        return_value = %{module_name}.%{fn_name}(%{arg_names})
+        converted = %{convert_return_type}
+        CrystalRuby.queue_callback(->{
+          %{callback_call}
+          CrystalRuby.decrement_task_counter
+        })
+      rescue ex
+        exception = ex.message.to_s
+        CrystalRuby.queue_callback(->{
+          CrystalRuby.error_callback.call("RuntimeError".to_unsafe, exception.to_unsafe, thread_id)
+          CrystalRuby.decrement_task_counter
+        })
+      end
+    end
+  rescue ex
+
+    exception = ex.message.to_s
+    CrystalRuby.queue_callback(->{
+      CrystalRuby.error_callback.call("RuntimeError".to_unsafe, ex.message.to_s.to_unsafe, thread_id)
+      CrystalRuby.decrement_task_counter
+    })
+  end
+end

data/lib/crystalruby/templates/index.cr

@@ -1,16 +1,24 @@
-FAKE_ARG = "crystal"
+alias ErrorCallback = (Pointer(UInt8), Pointer(UInt8), UInt32 -> Void)
 
-alias ErrorCallback = (Pointer(UInt8), Pointer(UInt8) -> Void)
+ARGV1 = "crystalruby"
+CALLBACK_MUX = Mutex.new
 
 module CrystalRuby
   # Initializing Crystal Ruby invokes init on the Crystal garbage collector.
   # We need to be sure to only do this once.
   @@initialized = false
 
-  # We won't natively handle Crystal Exceptions in Ruby
-  # Instead, we'll catch them in Crystal, and explicitly expose them to Ruby via
-  # the error_callback.
-  @@error_callback
+  # Our Ruby <-> Crystal Reactor uses Fibers, with callbacks to allow
+  # multiple concurrent Crystal operations to be queued
+  @@callbacks = [] of Proc(Nil)
+
+  # We only continue to yield to the Crystal scheduler from Ruby
+  # while there are outstanding tasks.
+  @@task_counter : Atomic(Int32) = Atomic.new(0)
+
+  # We can override the error callback to catch errors in Crystal,
+  # and explicitly expose them to Ruby.
+  @@error_callback : ErrorCallback = ->(t : UInt8* , s : UInt8*, tid : UInt32){ puts "Error: #{t}:#{s}" }
 
   # This is the entry point for instantiating CrystalRuby
   # We:
@@ -19,25 +27,91 @@ module CrystalRuby
   # 3. Call the Crystal main function
   def self.init(error_callback : ErrorCallback)
     return if @@initialized
+    @@initialized = true
     GC.init
-    @@initialized    = true
+    argv_ptr = ARGV1.to_unsafe
+    Crystal.main(0, pointerof(argv_ptr))
     @@error_callback = error_callback
-    ptr = FAKE_ARG.to_unsafe
-    LibCrystalMain.__crystal_main(1, pointerof(ptr))
   end
 
   # Explicit error handling (triggers exception within Ruby on the same thread)
-  def self.report_error(error_type : String, str : String)
-    if handler = @@error_callback
-      handler.call(error_type.to_unsafe, str.to_unsafe)
+  def self.report_error(error_type : String, str : String, thread_id : UInt32, )
+    @@error_callback.call(error_type.to_unsafe, str.to_unsafe, thread_id)
+  end
+
+  def self.error_callback : ErrorCallback
+    @@error_callback
+  end
+
+  # New async task started
+  def self.increment_task_counter
+    @@task_counter.add(1)
+  end
+
+  # Async task finished
+  def self.decrement_task_counter
+    @@task_counter.sub(1)
+  end
+
+  # Get number of outstanding tasks
+  def self.get_task_counter : Int32
+    @@task_counter.get()
+  end
+
+  # Queue a callback for an async task
+  def self.queue_callback(callback : Proc(Nil))
+    CALLBACK_MUX.synchronize do
+      @@callbacks << callback
+    end
+  end
+
+  # Get number of queued callbacks
+  def self.count_callbacks : Int32
+    @@callbacks.size
+  end
+
+  # Flush all callbacks
+  def self.flush_callbacks : Int32
+    CALLBACK_MUX.synchronize do
+      count = @@callbacks.size
+      @@callbacks.each do |callback|
+        result = callback.call()
+      end
+      @@callbacks.clear
     end
+    get_task_counter
   end
 end
 
+# Initialize CrystalRuby
 fun init(cb : ErrorCallback): Void
   CrystalRuby.init(cb)
 end
 
+fun stop(): Void
+  GC.disable
+end
+
+# Yield to the Crystal scheduler from Ruby
+# If there's callbacks to process, we flush them
+# Otherwise, we yield to the Crystal scheduler and let Ruby know
+# how many outstanding tasks still remain (it will stop yielding to Crystal
+# once this figure reaches 0).
+fun yield() : Int32
+  if CrystalRuby.count_callbacks == 0
+
+    Fiber.yield
+
+    # TODO: We should apply backpressure here to prevent busy waiting if the number of outstanding tasks is not decreasing.
+    # Use a simple exponential backoff strategy, to increase the time between each yield up to a maximum of 1 second.
+
+    CrystalRuby.get_task_counter
+  else
+    CrystalRuby.flush_callbacks()
+  end
+end
+
+
 # This is where we define all our Crystal modules and types
 # derived from their Ruby counterparts.
 %{type_modules}

data/lib/crystalruby/typemaps.rb

@@ -52,14 +52,19 @@ module CrystalRuby
       string: '"".to_unsafe' # String type
     }
 
-    C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge({
-                                          string: "UInt8*"
-                                        })
+    C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge(
+      {
+        string: "Pointer(UInt8)"
+      }
+    )
 
     C_TYPE_CONVERSIONS = {
       string: {
         from: "String.new(%s)",
         to: "%s.to_unsafe"
+      },
+      void: {
+        to: "nil"
       }
     }
   end

data/lib/crystalruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crystalruby
-  VERSION = "0.1.12"
+  VERSION = "0.1.13"
 end

data/lib/crystalruby.rb

@@ -13,115 +13,37 @@ require_relative "crystalruby/types"
 require_relative "crystalruby/typebuilder"
 require_relative "crystalruby/template"
 require_relative "crystalruby/compilation"
+require_relative "crystalruby/adapter"
+require_relative "crystalruby/reactor"
 
 module CrystalRuby
   CR_SRC_FILES_PATTERN = "./**/*.cr"
-  # Define a method to set the @crystalize proc if it doesn't already exist
-  def crystalize(type = :src, **options, &block)
-    (args,), returns = options.first
-    args ||= {}
-    raise "Arguments should be of the form name: :type. Got #{args}" unless args.is_a?(Hash)
-
-    @crystalize_next = { raw: type.to_sym == :raw, args: args, returns: returns, block: block }
-  end
-
-  def crystal(type = :src, &block)
-    inline_crystal_body = Template.render(
-      Template::InlineChunk,
-      {
-        module_name: name,
-        body: block.source.lines[
-          type == :raw ? 2...-2 : 1...-1
-        ].join("\n")
-      }
-    )
-    CrystalRuby.write_chunk(self, body: inline_crystal_body)
-  end
-
-  def crtype(&block)
-    TypeBuilder.with_injected_type_dsl(self) do
-      TypeBuilder.build(&block)
-    end
-  end
-
-  def json(&block)
-    crtype(&block).serialize_as(:json)
-  end
-
-  def method_added(method_name)
-    if @crystalize_next
-      attach_crystalized_method(method_name)
-      @crystalize_next = nil
-    end
-    super
-  end
-
-  def config
-    CrystalRuby.config
-  end
-
-  def attach_crystalized_method(method_name)
-    CrystalRuby.instantiate_crystal_ruby! unless CrystalRuby.instantiated?
-
-    function_body = instance_method(method_name).source.lines[
-      @crystalize_next[:raw] ? 2...-2 : 1...-1
-    ].join("\n")
-
-    fname = "#{name.downcase}_#{method_name}"
-    args, returns, block = @crystalize_next.values_at(:args, :returns, :block)
-    args ||= {}
-    @crystalize_next = nil
-    function = build_function(self, method_name, args, returns, function_body)
-    CrystalRuby.write_chunk(self, name: function[:name], body: function[:body]) do
-      extend FFI::Library
-      ffi_lib config.crystal_lib_dir / config.crystal_lib_name
-      attach_function method_name, fname, function[:ffi_types], function[:return_ffi_type]
-      if block
-        [singleton_class, self].each do |receiver|
-          receiver.prepend(Module.new do
-            define_method(method_name, &block)
-          end)
-        end
-      end
-    end
-
-    [singleton_class, self].each do |receiver|
-      receiver.prepend(Module.new do
-        define_method(method_name) do |*args|
-          CrystalRuby.build! unless CrystalRuby.compiled?
-          unless CrystalRuby.attached?
-            CrystalRuby.attach!
-            return send(method_name, *args) if block
-          end
-          args.each_with_index do |arg, i|
-            args[i] = function[:arg_maps][i][arg] if function[:arg_maps][i]
-          end
-          result = super(*args)
-          if function[:retval_map]
-            function[:retval_map][result]
-          else
-            result
-          end
-        end
-      end)
-    end
-  end
+  CR_COMPILE_MUX = Mutex.new
 
   module_function
 
-  def build_function(owner, name, args, returns, body)
+  def build_function(owner, lib_fn_name, name, args, returns, body)
+    log_debug(".build_function #{{ owner: owner, name: name, args: args, returns: returns, body: body[0..50] }}")
+
     arg_types = args.transform_values(&method(:build_type_map))
     return_type = build_type_map(returns)
-    function_body = Template.render(
-      Template::Function,
+    lib_fn_args = arg_types.map { |k, arg_type| "_#{k} : #{arg_type[:lib_type]}" }.join(",")
+    lib_fn_args += ", " unless lib_fn_args.empty?
+    lib_fn_arg_names = arg_types.map { |k, _arg_type| "_#{k}" }.join(",")
+    lib_fn_arg_names += ", " unless lib_fn_args.empty?
+
+    function_body = Template::Function.render(
       {
         module_name: owner.name,
-        lib_fn_name: "#{owner.name.downcase}_#{name}",
+        lib_fn_name: lib_fn_name,
         fn_name: name,
         fn_body: body,
+        callback_call: returns == :void ? "callback.call(thread_id)" : "callback.call(thread_id, converted)",
+        callback_type: return_type[:ffi_type] == :void ? "UInt32 -> Void" : " UInt32, #{return_type[:lib_type]} -> Void",
         fn_args: arg_types.map { |k, arg_type| "#{k} : #{arg_type[:crystal_type]}" }.join(","),
         fn_ret_type: return_type[:crystal_type],
-        lib_fn_args: arg_types.map { |k, arg_type| "_#{k}: #{arg_type[:lib_type]}" }.join(","),
+        lib_fn_args: lib_fn_args,
+        lib_fn_arg_names: lib_fn_arg_names,
         lib_fn_ret_type: return_type[:lib_type],
         convert_lib_args: arg_types.map do |k, arg_type|
           "#{k} = #{arg_type[:convert_lib_to_crystal_type]["_#{k}"]}"
@@ -137,7 +59,7 @@ module CrystalRuby
       retval_map: returns.is_a?(Types::TypeSerializer) ? ->(rv) { returns.prepare_retval(rv) } : nil,
       ffi_types: arg_types.map { |_k, arg_type| arg_type[:ffi_type] },
       arg_maps: arg_types.map { |_k, arg_type| arg_type[:mapper] },
-      return_ffi_type: return_type[:return_ffi_type]
+      ffi_ret_type: return_type[:ffi_ret_type]
     }
   end
 
@@ -148,7 +70,7 @@ module CrystalRuby
 
     {
       ffi_type: ffi_type(crystalruby_type),
-      return_ffi_type: ffi_type(crystalruby_type),
+      ffi_ret_type: ffi_type(crystalruby_type),
       crystal_type: crystal_type(crystalruby_type),
       lib_type: lib_type(crystalruby_type),
       error_value: error_value(crystalruby_type),
@@ -232,8 +154,6 @@ module CrystalRuby
       )
     end
 
-    attach_crystal_ruby_lib! if compiled?
-
     return if File.exist?(config.crystal_src_dir / "shard.yml")
 
     IO.write("#{config.crystal_src_dir}/shard.yml", <<~YAML)
@@ -242,20 +162,6 @@ module CrystalRuby
     YAML
   end
 
-  def attach_crystal_ruby_lib!
-    extend FFI::Library
-    ffi_lib config.crystal_lib_dir / config.crystal_lib_name
-    attach_function "init!", :init, [:pointer], :void
-    send(:remove_const, :ErrorCallback) if defined?(ErrorCallback)
-    const_set(:ErrorCallback, FFI::Function.new(:void, %i[string string]) do |error_type, message|
-      error_type = error_type.to_sym
-      is_exception_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception)
-      error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
-      raise error_type.new(message)
-    end)
-    init!(ErrorCallback)
-  end
-
   def self.instantiated?
     @instantiated
   end
@@ -297,27 +203,38 @@ module CrystalRuby
   end
 
   def self.build!
-    File.write config.crystal_codegen_dir_abs / "index.cr", Template.render(
-      Template::Index,
-      type_modules: type_modules,
-      requires: requires
-    )
-    if @compiled = CrystalRuby::Compilation.compile!(
-      verbose: config.verbose,
-      debug: config.debug
-    )
-      IO.write(digest_file_name, get_cr_src_files_digest)
-      attach_crystal_ruby_lib!
-    else
-      File.delete(digest_file_name) if File.exist?(digest_file_name)
-      raise "Error compiling crystal code"
+    log_debug(".build!")
+
+    CR_COMPILE_MUX.synchronize do
+      return if @compiled
+
+      File.write config.crystal_codegen_dir_abs / "index.cr", Template::Index.render(
+        type_modules: type_modules,
+        requires: requires
+      )
+      if @compiled = CrystalRuby::Compilation.compile!(
+        verbose: config.verbose,
+        debug: config.debug
+      )
+        IO.write(digest_file_name, get_cr_src_files_digest)
+      else
+        File.delete(digest_file_name) if File.exist?(digest_file_name)
+        raise "Error compiling crystal code"
+      end
     end
   end
 
   def self.attach!
+    log_debug(".attach!")
     @chunk_store.each do |function|
       function[:compile_callback]&.call
     end
+    log_debug(".attach_crystal_ruby_lib. Single thread mode: #{config.single_thread_mode}")
+    if config.single_thread_mode
+      Reactor.init_single_thread_mode!
+    else
+      Reactor.start!
+    end
     @attached = true
   end
 
@@ -342,19 +259,24 @@ module CrystalRuby
   end
 
   def self.write_chunk(owner, body:, name: Digest::MD5.hexdigest(body), &compile_callback)
+    log_debug(".write_chunk!")
+    chunk_store.delete_if { |chnk| chnk[:owner].name == owner.name && chnk[:name] == name }
     chunk_store << { owner: owner, name: name, body: body, compile_callback: compile_callback }
     FileUtils.mkdir_p(config.crystal_codegen_dir_abs)
     existing = Dir.glob("#{config.crystal_codegen_dir_abs}/**/*.cr")
     chunk_store.each do |function|
+      log_debug(".processing_chunk", function[0..60])
       owner_name = function[:owner].name
       FileUtils.mkdir_p(config.crystal_codegen_dir_abs / owner_name)
       function_data = function[:body]
       fname = function[:name]
       file_digest = Digest::MD5.hexdigest function_data
       filename = config.crystal_codegen_dir_abs / owner_name / "#{fname}_#{file_digest}.cr"
+
       unless existing.delete(filename.to_s)
-        @compiled = false
+        log_debug("Chunk invalidated", filename.to_s)
         @attached = false
+        @compiled = false
         File.write(filename, function_data)
       end
       existing.select do |f|

data/lib/module.rb

@@ -1,3 +1,3 @@
 class Module
-  prepend CrystalRuby
+  prepend CrystalRuby::Adapter
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-12 00:00:00.000000000 Z
+date: 2024-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -85,8 +85,10 @@ files:
 - examples/adder/adder.rb
 - exe/crystalruby
 - lib/crystalruby.rb
+- lib/crystalruby/adapter.rb
 - lib/crystalruby/compilation.rb
 - lib/crystalruby/config.rb
+- lib/crystalruby/reactor.rb
 - lib/crystalruby/template.rb
 - lib/crystalruby/templates/function.cr
 - lib/crystalruby/templates/index.cr