uringmachine 0.5 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2067cd0f88d6dbc341410ca6911916f510132ee23ce3f6d5fb5978259eeaef11
-  data.tar.gz: f816a9478f714a3a9770740bc14fc03ae2687f2fe7d0e29cbc0b8632994bad1f
+  metadata.gz: dc849d9467e24fa296a104e5b1caf71907495a3ed9cc68370bc6eb134a474cbf
+  data.tar.gz: 4fcdf5cd6055321f37375094aa11b56696c894d6a2c47ed9f756fb9a40d79753
 SHA512:
-  metadata.gz: 6e0a9ed6e6f131bf6d67a56622786893532a525f4427e134670499997c0461a4df6de3ca1cb9e70851769c1135575986468a83edfd9b5d75c7d592e41bb0ca8c
-  data.tar.gz: 2c73ed9a3268ea96b3a167064251d16279c531ee50e5f9c6de9aa2c56f6a70973ef04ce5d6c44f46e39309f7bf8cb3f3ff5e61bf1512ca07cc5f35b91f7303dc
+  metadata.gz: 3d83d7419000bd434bac101d72c6850274a71dd0324bd1732043cbdb08ef659b683e1010dc31093fe7a77e37368698db56592685bf7fe8a2f76ee4cd70cee52f
+  data.tar.gz: dcb79682bbdc20b99bd312aad22145642c4479009250f01f2e0c83f506026218d973b5c6e8b0aecff4e993acbe3998822bccbdf1de7c77a025b7560b5860ca77

data/.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
       matrix:
         # macos-latest uses arm64, macos-13 uses x86
         os: [ubuntu-latest]
-        ruby: ['3.3', 'head']
+        ruby: ['3.3', '3.4', 'head']
 
     name: ${{matrix.os}}, ${{matrix.ruby}}
 

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 2025-04-23 Version 0.6
+
+- Add `#periodically` for multishot timeout
+- Add `UM::Actor` class
+- Add `#prep_timeout` and `AsyncOp`
+
 # 2024-11-14 Version 0.5
 
 - Add `#waitpid`

data/TODO.md

@@ -1,3 +1,7 @@
+- [ ] multishot timeout
+  - [v] machine.periodically(interval) { ... }
+  - [ ] machine.prep_timeout_multishot(interval)
+
 - splice / - tee
 - sendto
 - recvfrom

data/examples/bm_http_parse.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+  gem 'http_parser.rb'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+require 'http/parser'
+
+$machine = UM.new
+
+HTTP_MSG = "GET /foo/bar HTTP/1.1\r\nServer: foobar.com\r\nFoo: bar\r\n\r\n"
+
+$count = 0
+
+def parse_http_parser
+  current_fiber = Fiber.current
+  $count += 1
+  r, w = IO.pipe
+  parser = Http::Parser.new
+  $machine.spin do
+    buffer = +''
+    loop do
+      res = $machine.read(r.fileno, buffer, 512)
+      break if res == 0
+      parser << buffer
+    end
+  rescue Exception => e
+    $machine.schedule(current_fiber, e)
+    # puts e.backtrace.join("\n")
+    # exit!
+  end
+  parser.on_message_complete = -> do
+    headers = parser.headers
+    headers['method'] = parser.http_method.downcase
+    headers['path'] = parser.request_url
+    headers['protocol'] = parser.http_version
+    $machine.schedule(current_fiber, headers)
+  end
+  
+  $machine.write(w.fileno, HTTP_MSG)
+  $machine.yield
+ensure
+  $machine.close(r.fileno)
+  $machine.close(w.fileno)
+end
+
+require 'stringio'
+
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+def get_line(fd, sio, buffer)
+  while true
+    line = sio.gets(chomp: true)
+    return line if line
+
+    res = $machine.read(fd, buffer, 1024, -1)
+    return nil if res == 0
+  end
+end
+
+def get_request_line(fd, sio, buffer)
+  line = get_line(fd, sio, buffer)
+
+  m = line.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+def parse_headers(fd)
+  buffer = String.new('', capacity: 4096)
+  sio = StringIO.new(buffer)
+
+  headers = get_request_line(fd, sio, buffer)
+  return nil if !headers
+
+  while true
+    line = get_line(fd, sio, buffer)
+    break if line.empty?
+    
+    m = line.match(RE_HEADER_LINE)
+    raise "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
+end
+
+def parse_http_stringio
+  current_fiber = Fiber.current
+  r, w = IO.pipe
+
+  $machine.spin do
+    headers = parse_headers(r.fileno)
+    $machine.schedule(current_fiber, headers)
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+    exit!
+  end
+  
+  $machine.write(w.fileno, HTTP_MSG)
+  $machine.yield
+ensure
+  $machine.close(r.fileno)
+  $machine.close(w.fileno)
+end
+
+# p parse_http_parser
+# p parse_http_stringio
+# exit
+
+GC.disable
+
+def alloc_count
+  count0 = ObjectSpace.count_objects[:TOTAL]
+  yield
+  count1 = ObjectSpace.count_objects[:TOTAL]
+  count1 - count0
+end
+
+X = 100
+p(
+  alloc_http_parser: alloc_count { X.times { parse_http_parser } },
+  alloc_stringio: alloc_count { X.times { parse_http_stringio } }
+)
+exit
+
+Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 3)
+
+  x.report("http_parser") { parse_http_parser }
+  x.report("homegrown") { parse_http_stringio }
+
+  x.compare!
+end

data/examples/bm_queue.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+
+COUNT = 1000
+NUM_PRODUCERS = 2
+NUM_CONSUMERS = 10
+
+def run_threads
+  queue = Queue.new
+  done = Queue.new
+  
+  NUM_PRODUCERS.times do
+    Thread.new do
+      COUNT.times { queue << rand(1000) }
+      done << true
+    end
+  end
+  
+  total = 0
+  NUM_CONSUMERS.times do
+    Thread.new do
+      loop do
+        item = queue.shift
+        break if item.nil?
+
+        total += item
+      end
+      done << true
+    end
+  end
+
+  # wait for producers
+  NUM_PRODUCERS.times { done.shift }
+
+  # stop and wait for consumers
+  NUM_CONSUMERS.times do
+    queue << nil
+    done.shift
+  end
+
+  total
+end
+
+def run_um
+  machine = UM.new
+  queue = UM::Queue.new
+  done = UM::Queue.new
+
+  NUM_PRODUCERS.times do
+    machine.spin do
+      COUNT.times { machine.push(queue, rand(1000)) }
+      machine.push(done, true)
+    end
+  end
+
+  total = 0
+  NUM_CONSUMERS.times do
+    machine.spin do
+      loop do
+        item = machine.shift(queue)
+        break if item.nil?
+
+        total += item
+      end
+      machine.push(done, true)
+    end
+  end
+
+  # wait for producers
+  NUM_PRODUCERS.times { machine.shift(done) }
+
+  # stop and wait for consumers
+  NUM_CONSUMERS.times do
+    machine.push(queue, nil)
+    machine.shift(done)
+  end
+
+  total
+end
+
+
+# puts "running"
+# res = run_threads
+# p threads: res
+
+# 100.times {
+#   res = run_um
+#   p fibers: res
+# }
+
+
+# __END__
+
+Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("threads") { run_threads }
+  x.report("UM")      { run_um }
+
+  x.compare!
+end

data/examples/bm_sqlite.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'extralite'
+  gem 'benchmark-ips'
+end
+
+require 'uringmachine'
+require 'extralite'
+
+class UM::Actor < Fiber
+  def initialize(machine, target)
+    @machine = machine
+    @target = target
+    @mailbox = UM::Queue.new
+    super { act }
+  end
+
+  def act
+    while (sym, a, k, peer = @machine.shift(@mailbox))
+
+      begin
+        ret = @target.send(sym, *a, **k)
+        @machine.schedule(peer, ret)
+      rescue => e
+        @machine.schedule(peer, e)
+      end
+    end
+  rescue Exception => e
+    # handle unhandled exceptions
+  ensure
+    @machine.fiber_map.delete(self)
+    @machine.yield
+  end
+
+  def method_missing(sym, *a, **k)
+    @machine.push(@mailbox, [sym, a, k, Fiber.current])
+    ret = @machine.yield
+    raise(ret) if ret.is_a?(Exception)
+    ret
+  end
+end
+
+class UM
+  def spin_actor(target)
+    f = UM::Actor.new(self, target)
+    schedule(f, nil)
+    @@fiber_map[f] = true
+    f
+  end
+end
+
+class Locker
+  def initialize(machine, target)
+    @machine = machine
+    @target = target
+    @mutex = UM::Mutex.new
+  end
+
+  def method_missing(sym, *a, **k)
+    @machine.synchronize(@mutex) { @target.send(sym, *a, **k) }
+  end
+end
+
+
+PATH = '/tmp/foo'
+
+$machine = UM.new
+$raw_db = Extralite::Database.new(PATH)
+$actor_db = $machine.spin_actor(Extralite::Database.new(PATH))
+$locker_db = Locker.new($machine, Extralite::Database.new(PATH))
+
+[$raw_db, $actor_db, $locker_db].each do |db|
+  p db.query('select 1')
+end
+
+bm = Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("raw")     { $raw_db.query('select 1') }
+  x.report("actor")   { $actor_db.query('select 1') }
+  x.report("locker")  { $locker_db.query('select 1') }
+
+  x.compare!
+end

data/examples/http_server.rb

@@ -35,7 +35,7 @@ end
 
 server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
 @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-@machine.bind(server_fd, '127.0.0.1', 1234)
+@machine.bind(server_fd, '0.0.0.0', 1234)
 @machine.listen(server_fd, UM::SOMAXCONN)
 puts 'Listening on port 1234'
 

data/examples/pg.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+@machine = UM.new
+
+class UM::Stream
+  def initialize(machine, fd)
+    @machine, @fd, @bgid = machine, fd
+    @buffer = +''
+    @ofs_head = 0
+    @ofs_tail = 0
+  end
+
+  def feed
+    if (@ofs_head == @ofs_tail) && (@ofs_head >= 4096)
+      @buffer = +''
+      @ofs_head = @ofs_tail = 0
+    end
+    ret = @machine.read(@fd, @buffer, 65536, @ofs_tail)
+    if ret == 0
+      @eof = true
+      return false
+    end
+      
+    @ofs_tail += ret
+    true
+  end
+
+  def read(len)
+    if @ofs_head + len > @ofs_tail
+      feed
+    end
+
+    str = @buffer[@ofs_head, len]
+    @ofs_head += str.bytesize
+    str
+  end
+
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    while true
+      idx = @buffer.index(sep, @ofs_head)
+      if idx
+        str = @buffer[@ofs_head, idx + sep_size]
+        @ofs_head += str.bytesize
+        return str
+      end
+
+      return nil if !feed
+    end
+  end
+end
+
+$machine = UringMachine.new
+
+server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+$machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+$machine.bind(server_fd, '127.0.0.1', 1234)
+$machine.listen(server_fd, UM::SOMAXCONN)
+puts 'Listening on port 1234'
+
+def handle_connection(fd)
+  stream = UM::Stream.new($machine, fd)
+
+  while (l = stream.gets)
+    $machine.write(fd, "You said: #{l}")
+  end
+rescue Exception => e
+  puts "Got error #{e.inspect}, closing connection"
+  $machine.close(fd) rescue nil
+end
+
+main = Fiber.current
+trap('SIGINT') { $machine.spin { $machine.schedule(main, SystemExit.new) } }
+
+$machine.accept_each(server_fd) do |fd|
+  puts "Connection accepted fd #{fd}"
+  $machine.spin(fd) { handle_connection(_1) }
+end

data/examples/stream.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+@machine = UM.new
+
+class UM::Stream
+  def initialize(machine, fd)
+    @machine, @fd, @bgid = machine, fd
+    @buffer = +''
+    @ofs_head = 0
+    @ofs_tail = 0
+  end
+
+  def feed
+    if (@ofs_head == @ofs_tail) && (@ofs_head >= 4096)
+      @buffer = +''
+      @ofs_head = @ofs_tail = 0
+    end
+    ret = @machine.read(@fd, @buffer, 65536, @ofs_tail)
+    if ret == 0
+      @eof = true
+      return false
+    end
+      
+    @ofs_tail += ret
+    true
+  end
+
+  def read(len)
+    if @ofs_head + len > @ofs_tail
+      feed
+    end
+
+    str = @buffer[@ofs_head, len]
+    @ofs_head += str.bytesize
+    str
+  end
+
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    while true
+      idx = @buffer.index(sep, @ofs_head)
+      if idx
+        str = @buffer[@ofs_head, idx + sep_size]
+        @ofs_head += str.bytesize
+        return str
+      end
+
+      return nil if !feed
+    end
+  end
+end
+
+$machine = UringMachine.new
+
+server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+$machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+$machine.bind(server_fd, '127.0.0.1', 1234)
+$machine.listen(server_fd, UM::SOMAXCONN)
+puts 'Listening on port 1234'
+
+def handle_connection(fd)
+  stream = UM::Stream.new($machine, fd)
+
+  while (l = stream.gets)
+    $machine.write(fd, "You said: #{l}")
+  end
+rescue Exception => e
+  puts "Got error #{e.inspect}, closing connection"
+  $machine.close(fd) rescue nil
+end
+
+main = Fiber.current
+trap('SIGINT') { $machine.spin { $machine.schedule(main, SystemExit.new) } }
+
+$machine.accept_each(server_fd) do |fd|
+  puts "Connection accepted fd #{fd}"
+  $machine.spin(fd) { handle_connection(_1) }
+end

data/ext/um/extconf.rb

@@ -6,6 +6,61 @@ require 'rbconfig'
 
 dir_config 'um_ext'
 
+def config_ssl
+  # don't use pkg_config('openssl') if '--with-openssl-dir' is used
+  has_openssl_dir = dir_config('openssl').any? ||
+    RbConfig::CONFIG['configure_args']&.include?('openssl')
+
+  found_pkg_config = !has_openssl_dir && pkg_config('openssl')
+
+  found_ssl = if !$mingw && found_pkg_config
+    puts '──── Using OpenSSL pkgconfig (openssl.pc) ────'
+    true
+  elsif have_library('libcrypto', 'BIO_read') && have_library('libssl', 'SSL_CTX_new')
+    true
+  elsif %w'crypto libeay32'.find {|crypto| have_library(crypto, 'BIO_read')} &&
+      %w'ssl ssleay32'.find {|ssl| have_library(ssl, 'SSL_CTX_new')}
+    true
+  else
+    puts '** Puma will be compiled without SSL support'
+    false
+  end
+
+  if found_ssl
+    have_header "openssl/bio.h"
+
+    ssl_h = "openssl/ssl.h".freeze
+
+    puts "\n──── Below are yes for 1.0.2 & later ────"
+    have_func "DTLS_method"                            , ssl_h
+    have_func "SSL_CTX_set_session_cache_mode(NULL, 0)", ssl_h
+
+    puts "\n──── Below are yes for 1.1.0 & later ────"
+    have_func "TLS_server_method"                      , ssl_h
+    have_func "SSL_CTX_set_min_proto_version(NULL, 0)" , ssl_h
+
+    puts "\n──── Below is yes for 1.1.0 and later, but isn't documented until 3.0.0 ────"
+    # https://github.com/openssl/openssl/blob/OpenSSL_1_1_0/include/openssl/ssl.h#L1159
+    have_func "SSL_CTX_set_dh_auto(NULL, 0)"           , ssl_h
+
+    puts "\n──── Below is yes for 1.1.1 & later ────"
+    have_func "SSL_CTX_set_ciphersuites(NULL, \"\")"   , ssl_h
+
+    puts "\n──── Below is yes for 3.0.0 & later ────"
+    have_func "SSL_get1_peer_certificate"              , ssl_h
+
+    puts ''
+
+    # Random.bytes available in Ruby 2.5 and later, Random::DEFAULT deprecated in 3.0
+    if Random.respond_to?(:bytes)
+      $defs.push "-DHAVE_RANDOM_BYTES"
+      puts "checking for Random.bytes... yes"
+    else
+      puts "checking for Random.bytes... no"
+    end
+  end
+end
+
 KERNEL_INFO_RE = /Linux (\d)\.(\d+)(?:\.)?((?:\d+\.?)*)(?:\-)?([\w\-]+)?/
 def get_config
   if RUBY_PLATFORM !~ /linux/
@@ -35,6 +90,8 @@ def get_config
   }
 end
 
+# config_ssl
+
 config = get_config
 puts "Building UringMachine (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"