uringmachine 0.4 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a9efd4af7de9fdb8db6888b9f6347e9dbc63aae9e26fa0f81d43984d265bd90
-  data.tar.gz: 5289699ce1e3e173d3766e0211fc77b57f3c123e2a6e041e9e751a3bf5ce07b2
+  metadata.gz: 0b063db46fac29472c42866eb1864c731b24fc0846fe424eec06213bba8fde0a
+  data.tar.gz: a535fabf5d16107de8d3823766d9ff0d7d22d0702c5401e263eb925eb222dd5d
 SHA512:
-  metadata.gz: 3cf02bbaae5a9e19b9ea994d1c2bf4b327a96121b083ca6756eca70629738f6c24aca10096bb49a0400678542232062969889ed3f0773591f5dc71f718707fef
-  data.tar.gz: 67b368097ddecd6c9ca9ce360cc918d8e7de91ec83a00d617765c2026fbe08f16f5009b78323e9f314cd1df63a1baaa39e8887b4a90fff0cb8010d810276df7d
+  metadata.gz: 94ad9e942e84e87f0acbd75007962c3df5ea259de77ef4e590ff91dc4ea614dcd22e7db3da1954be05b11951e621f0cf58858391b677e109e97590bb0f8e3dee
+  data.tar.gz: 4c77e826fb33fc879de748b877eec9a6d49f6927b8167377b4191c30b9aa2b638dbd0cc76a77ec0a17daec648d2587ca4357f367501391aad06c7532606e85b2

data/.github/workflows/test.yml

@@ -32,4 +32,5 @@ jobs:
     - name: Compile C-extension
       run: bundle exec rake compile
     - name: Run tests
-      run:  bundle exec rake test
+      # run: bundle exec ruby test/test_um.rb --name test_read_each_raising_2
+      run: bundle exec rake test

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+- Add `#prep_timeout` and `AsyncOp`
+
+# 2024-11-14 Version 0.5
+
+- Add `#waitpid`
+- Add `UM.pipe`, `UM.kernel_version`
+- Add `#open`
+- Fix `#spin`
+- Fix handling of signal interruption.
+- Reimplement and simplify um_op
+- Add `UM::Queue`, `#push`, `#pop`, `#shift`, `#unshift`
+- Add `UM::Mutex`, `#synchronize`
+- Add `#recv_each`
+- Add `#getsockopt`, `#setsockopt`
+- Simplify and improve op management
+
 # 2024-10-06 Version 0.4
 
 - Add socket constants

data/README.md

@@ -32,6 +32,8 @@ UringMachine is based on my experience marrying Ruby and io_uring:
 - [IOU](https://github.com/digital-fabric/iou) - a low-level asynchronous API
   for using io_uring from Ruby.
 
+### Learnings
+
 Some important learnings from those two projects, in no particular order:
 
 - Monkey-patching is not a good solution, long term. You need to deal with
@@ -73,7 +75,25 @@ based on the following principles:
 - Do not insist on structured concurrency, just provide the APIs necessary to
   create actors and to supervise the execution of fibers.
 
-## Example
+### Cancellation
+
+When working with io_uring, managing the life cycle of asynchronous operations
+is quite tricky, especially with regards to cancellation. This is due to the
+fact each operation lives on both sides of the userspace-kernel divide. This
+means that when cancelling an operation, we cannot free, or dispose of any
+resources associated with the operation, until we know for sure that the kernel
+side is also done with the operation.
+
+As stated above, working with fibers allows us to keep operation metadata and
+associated data (such as buffers etc) on the stack, which can greatly simplify
+the managing of the operation's lifetime, as well as significantly reduce heap
+allocations.
+
+When a cancellation does occur, UringMachine issues a cancellation (using
+`io_uring_prep_cancel64`), and then waits for the corresponding CQE (with a
+`-ECANCELED` result).
+
+## Short Example
 
 ```ruby
 require 'uringmachine'
@@ -94,3 +114,26 @@ loop do
   end
 end
 ```
+
+## Concurrent Execution
+
+Concurrent execution is done by calling `#spin`, which creates a fiber:
+
+```ruby
+machine = UringMachine.new
+
+rfd, wfd = machine.pipe
+
+f1 = machine.spin do
+  machine.write(wfd, 'hello')
+  machine.write(wfd, 'world')
+  machine.close(wfd)
+end
+
+bgid = machine.setup_buffer_ring(4096, 1024)
+f2 = machine.spin do
+  machine.read_each(rfd, bgid) do |str|
+    puts str
+  end
+end
+```

data/TODO.md

@@ -1,5 +1,14 @@
-- splice
+- splice / - tee
 - sendto
 - recvfrom
-
-- queues
+- poll_add / poll_remove / poll_multishot / poll_update
+- fsync
+- mkdir / mkdirat
+- statx
+- link / linkat / unlink / unlinkat / symlink
+- rename / renameat
+- fadvise
+- madvise
+- getxattr / setxattr
+- shutdown
+- send_bundle / recv_bundle (kernel >= 6.10)

data/examples/bm_snooze.rb

@@ -0,0 +1,89 @@
+# 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'
+
+ITERATIONS = 1000
+
+$machine = UringMachine.new
+
+def run_snooze
+  count = 0
+  main = Fiber.current
+
+  f1 = Fiber.new do
+    loop do
+      count += 1
+      if count == ITERATIONS
+        $machine.schedule(main, nil)
+        break
+      else
+        $machine.snooze
+      end
+    end
+  end
+
+  f2 = Fiber.new do
+    loop do
+      count += 1
+      if count == ITERATIONS
+        $machine.schedule(main, nil)
+        break
+      else
+        $machine.snooze
+      end
+    end
+  end
+
+  $machine.schedule(f1, nil)
+  $machine.schedule(f2, nil)
+  $machine.yield
+end
+
+def run_raw_transfer
+  count = 0
+  main = Fiber.current
+  f2 = nil
+  f1 = Fiber.new do
+    loop do
+      count += 1
+      if count == ITERATIONS
+        main.transfer(nil)
+        break
+      else
+        f2.transfer(nil)
+      end
+    end
+  end
+
+  f2 = Fiber.new do
+    loop do
+      count += 1
+      if count == ITERATIONS
+        main.transfer(nil)
+        break
+      else
+        f1.transfer(nil)
+      end
+    end
+  end
+
+  f1.transfer(nil)
+end
+
+bm = Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("snooze")        { run_snooze }
+  x.report("raw transfer")  { run_raw_transfer }
+
+  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/bm_write.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+end
+
+require 'benchmark'
+require 'uringmachine'
+
+ITERATIONS = 100000
+BUF = ('*' * 8192).freeze
+FN = '/tmp/bm_write'
+
+def run_io_write(num_threads)
+  FileUtils.rm(FN) rescue nil
+  fio = File.open(FN, 'w')
+  
+  threads = num_threads.times.map do |i|
+    Thread.new do
+      ITERATIONS.times { fio.write(BUF) }
+    end
+  end
+  threads.each(&:join)
+ensure
+  fio.close
+end
+
+def run_um_write(num_fibers)
+  FileUtils.rm(FN) rescue nil
+  fio = File.open(FN, 'w')
+  fd = fio.fileno
+  
+  machine = UringMachine.new
+  done = UringMachine::Queue.new
+  num_fibers.times do
+    machine.spin do
+      ITERATIONS.times { machine.write(fd, BUF) }
+      machine.push(done, true) 
+    end
+  end
+  num_fibers.times { machine.pop(done) }
+ensure
+  fio.close
+end
+
+Benchmark.bm do |x|
+  [1, 2, 4, 8].each do |c|
+    x.report("IO (#{c} threads)")     { run_io_write(c) }
+    x.report("UM (#{c} fibers) ")     { run_um_write(c) }
+    puts
+  end
+end

data/examples/dns_client.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+require 'resolv'
+
+machine = UM.new
+
+addrs = machine.resolve('status.realiteq.net')
+
+puts '*' * 40
+puts addrs.join("\n")
+puts

data/examples/http_server.rb

@@ -1,56 +1,55 @@
-require_relative '../lib/iou'
-require 'socket'
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
 require 'http/parser'
 
-def log(msg)
-  # return
-  STDERR.puts msg
-end
+@machine = UM.new
+@bgid = @machine.setup_buffer_ring(4096, 1024)
 
-socket = TCPServer.open('127.0.0.1', 1234)
-log 'Listening on port 1234...'
+def http_handle_connection(fd)
+  # puts "Accepting connection on fd #{fd}"
+  parser = Http::Parser.new
+  done = nil
+  parser.on_message_complete = -> do
+    http_send_response(fd, "Hello, world!\n")
+    done = true
+  end
 
-@ring = IOU::Ring.new
-@bg_id = @ring.setup_buffer_ring(count: 1024, size: 4096)
+  @machine.read_each(fd, @bgid) do
+    parser << _1
+    break if done
+  end
 
-@ring.prep_accept(fd: socket.fileno, multishot: true) do |c|
-  setup_connection(c[:result]) if c[:result] > 0
+  # puts "Connection closed on fd #{fd}"
+rescue => e
+  # puts "Error while handling connection on fd #{fd}: #{e.inspect}"
+ensure
+  @machine.close(fd) rescue nil
 end
 
-def setup_connection(fd)
-  log "Connection accepted fd #{fd}"
-
-  parser = Http::Parser.new
-  parser.on_message_complete = -> {
-    http_send_response(fd, "Hello, world!\n") do
-      @ring.prep_close(fd: fd)
-    end
-  }
-
-  http_prep_read(fd, parser)
+def http_send_response(fd, body)
+  # msg = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: keep-alive\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}"
+  msg = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: close\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}"
+  @machine.write(fd, msg)
 end
 
-def http_prep_read(fd, parser)
-  buffer = +''
-  @ring.prep_read(fd: fd, buffer: buffer, len: 4096) do |c|
-    if c[:result] > 0
-      http_prep_read(fd, parser)
-      parser << buffer
-    elsif c[:result] == 0
-      log "Connection closed by client on fd #{fd}"
-    else
-      log "Got error #{c[:result]} on fd #{fd}, closing connection..."
-      @ring.prep_close(fd: fd) do |c|
-        log "Connection closed on fd #{fd}, result #{c[:result]}"
-      end
-    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, '0.0.0.0', 1234)
+@machine.listen(server_fd, UM::SOMAXCONN)
+puts 'Listening on port 1234'
+
+@machine.spin do
+  @machine.accept_each(server_fd) do |fd|
+    @machine.spin(fd) { http_handle_connection _1 }
   end
 end
 
-def http_send_response(fd, body)
-  msg = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: keep-alive\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}"
-  @ring.prep_write(fd: fd, buffer: msg)
-end
+main = Fiber.current
+trap('SIGINT') { @machine.schedule(main, nil) }
+trap('SIGTERM') { @machine.schedule(main, nil) }
 
-trap('SIGINT') { exit! }
-@ring.process_completions_loop
+@machine.yield
+puts "Closing server FD"
+@machine.close(server_fd) rescue nil
+puts "done!"

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/server_client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+PORT = 1234
+
+@machine = UM.new
+@bgid = @machine.setup_buffer_ring(4096, 1024)
+
+@counter = 0
+
+def handle_connection(fd)
+  buf = +''
+  loop do
+    res = @machine.recv(fd, buf, 8192, 0)
+    break if res == 0
+
+    @machine.write(fd, buf)
+    @counter += 2
+  end
+ensure
+  @machine.close(fd) rescue nil
+end
+
+def run_client
+  fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.connect(fd, '127.0.0.1', PORT)
+  msg = 'foo' * 30
+  buf = +''
+  loop do
+    @machine.send(fd, msg, msg.bytesize, 0)
+    res = @machine.recv(fd, buf, 8192, 0)
+    @counter += 2
+    
+    break if res == 0
+    raise "Got #{res} bytes instead of #{msg.bytesize}" if res != msg.bytesize
+  end
+end
+
+trap('SIGINT') { exit }
+
+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', PORT)
+@machine.listen(server_fd, UM::SOMAXCONN)
+puts "Listening on port #{PORT}"
+
+at_exit { @machine.close(server_fd) rescue nil }
+
+20.times do
+  @machine.spin { run_client }
+end
+
+@machine.spin do
+  @machine.accept_each(server_fd) do |fd|
+    @machine.spin(fd) { handle_connection _1 }
+  end
+end
+
+t0 = Time.now
+@machine.sleep 3
+t1 = Time.now  
+elapsed = t1 - t0
+puts "Did #{@counter} ops in #{elapsed} seconds (#{(@counter / elapsed)} ops/s)"

data/examples/snooze.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+@machine = UM.new
+
+@counter = 0
+@fiber_count = 0
+
+def start_fiber
+  @fiber_count += 1
+  @machine.spin do
+    max_count = @counter + rand(1000)
+    puts "Start #{Fiber.current} #{max_count - @counter}"
+    loop do
+      @machine.sleep 0.001
+      @counter += 1
+      break if @counter >= max_count
+    end
+    puts "Stop #{Fiber.current}"
+  ensure
+    @fiber_count -= 1
+  end
+end
+
+t0 = Time.now
+MAX_FIBERS = 20
+MAX_TIME = 10
+loop do
+  @machine.sleep 0.1
+  puts "pending: #{@machine.pending_count}"
+  break if (Time.now - t0) > MAX_TIME
+  start_fiber while @fiber_count < MAX_FIBERS
+end
+t1 = Time.now  
+elapsed = t1 - t0
+rate = @counter / elapsed
+puts "Did #{@counter} ops in #{elapsed} seconds (#{rate} ops/s)"
+
+puts "Waiting for fibers... (#{@fiber_count})"
+while @fiber_count > 0
+  @machine.sleep 0.1
+end
+puts "Done"