uringmachine 0.24.0 → 0.26.0

data/benchmark/openssl_socketpair.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'io-event'
+  gem 'async'
+  gem 'pg'
+  gem 'gvltools'
+  gem 'openssl'
+  gem 'localhost'
+end
+
+require 'uringmachine/fiber_scheduler'
+require 'socket'
+require 'openssl'
+require 'localhost/authority'
+
+GROUPS = 48
+ITERATIONS = 10000
+
+SIZE = 1 << 14
+DATA = '*' * SIZE
+
+AUTHORITY = Localhost::Authority.fetch
+
+def do_io(um)
+  GROUPS.times do
+    r, w = Socket.socketpair(:AF_UNIX, :SOCK_STREAM, 0)
+    r.sync = true
+    w.sync = true
+    ctx = AUTHORITY.server_context
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    s1 = OpenSSL::SSL::SSLSocket.new(r, ctx)
+    s1.sync_close = true
+    um.ssl_set_bio(s1) if um
+    Fiber.schedule do
+      s1.accept
+      ITERATIONS.times { s1.readpartial(SIZE) }
+      s1.close rescue nil
+    rescue => e
+      p e
+      p e.backtrace
+    end
+
+    s2 = OpenSSL::SSL::SSLSocket.new(w, OpenSSL::SSL::SSLContext.new)
+    s2.sync_close = true
+    um.ssl_set_bio(s2) if um
+    Fiber.schedule do
+      s2.connect
+      ITERATIONS.times { s2.write(DATA) }
+      s2.close rescue nil
+    rescue => e
+      p e
+      p e.backtrace
+    end
+  end
+end
+
+def do_um_io(um)
+  GROUPS.times do
+    r, w = Socket.socketpair(:AF_UNIX, :SOCK_STREAM, 0)
+    r.sync = true
+    w.sync = true
+    ctx = AUTHORITY.server_context
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    s1 = OpenSSL::SSL::SSLSocket.new(r, ctx)
+    s1.sync_close = true
+    um.ssl_set_bio(s1)
+    Fiber.schedule do
+      s1.accept
+      ITERATIONS.times { um.ssl_read(s1, +'', SIZE) }
+      s1.close rescue nil
+    rescue => e
+      p e
+      p e.backtrace
+    end
+
+    s2 = OpenSSL::SSL::SSLSocket.new(w, OpenSSL::SSL::SSLContext.new)
+    s2.sync_close = true
+    um.ssl_set_bio(s2)
+    Fiber.schedule do
+      s2.connect
+      ITERATIONS.times { um.ssl_write(s2, DATA, DATA.bytesize) }
+      s2.close rescue nil
+    rescue => e
+      p e
+      p e.backtrace
+    end
+  end
+end
+
+def run(custom_bio, um_io)
+  machine = UM.new
+  scheduler = UM::FiberScheduler.new(machine)
+  Fiber.set_scheduler(scheduler)
+  if um_io
+    do_um_io(machine)
+  else
+    do_io(custom_bio ? machine : nil)
+  end
+  scheduler.join
+end
+
+Benchmark.bm do |b|
+  b.report("stock") { run(false, false) }
+  b.report("UM BIO") { run(true, false) }
+  b.report("UM I/O") { run(true, true) }
+end

data/benchmark/sqlite.rb

@@ -36,7 +36,7 @@ class DBActor2
   rescue Exception => e
     # handle unhandled exceptions
   ensure
-    @machine.fiber_map.delete(self)
+    @machine.fiber_set.delete(self)
     @machine.yield
   end
 

data/docs/design/buffer_pool.md

@@ -37,7 +37,7 @@ buffers, to using managed buffers from the buffer pool.
   is used to interact with the data read/received as it becomes available. The
   stream instance methods may block until enough data is available in the
   relevant buffers.
-  
+
    Example:
 
   ```ruby

data/docs/wroclove.rb.md

@@ -0,0 +1,52 @@
+# UringMachine - High Performance Concurrency for Ruby Using io_uring
+
+https://www.papercall.io/talks/413880/children/413881
+
+## Structure
+
+- Introduction: the name (1)
+- What is io_uring (2)
+- How UringMachine works (4)
+  - The liburing API
+  - Submitting an operation
+  - Fiber switching and the runqueue
+  - Waiting for and processing CQEs
+  - The UringMachine model:
+    - exhaust all CPU-bound work, submit I/O work to kernel
+    - Wait for and process completions
+    - repeat
+- The UringMachine API (7)
+  - More or less equivalent to the Unix I/O API
+  - Synchronization: `UM::Mutex`, `UM::Queue`
+  - Useful abstractions for multishot operations
+  - OpenSSL support
+    - Custom BIO
+  - Streams / Automatic buffer management
+  - Utilities and advanced usage: `.inotify`, `.pipe`, `#splice`
+- Timeouts and cancellations (4)
+  - Timeout - the basic design
+  - The challenges of cancellation
+    - double life cycle
+    - holding on to buffers
+    - ensuring the lifetime of relevant objects when doing an async operation.
+      - the TRANSIENT list of ops, for async operations (e.g. `#write_async` -
+        how to do we hold on to the write buffer.)
+      - how in general we mark the objects involved in async
+- Integration with the Ruby ecosystem (6)
+  - The Fiber::Scheduler interface: the good, the bad and the ugly
+  - Dealing with CPU-bound workloads
+    - SQLite and Extralite in particular (`on_progress` handler)
+- Performance (3)
+  - Benchmarks
+  - CPU-bound / IO-bound: how UringMachine deals with mixed workloads
+- Applications (3)
+  - TP2 / Syntropy
+  - Uma - Rack-compatible app server
+    - Compare performance of a Rails app on Uma / Falcon / Puma
+- Future directions (3)
+  - Further contributions to Ruby:
+    - Support for Socket I/O in Fiber::Scheduler
+  - More stress testing, prove stability
+  - More performance research
+  - Make Uma into a first-class app server for Ruby
+  - Introduce higher-level

data/ext/um/extconf.rb

@@ -54,6 +54,21 @@ if !find_library('uring', nil, File.join(liburing_path, 'src'))
   raise "Couldn't find liburing.a"
 end
 
+if !have_header("openssl/ssl.h")
+  raise "Couldn't find OpenSSL headers"
+end
+
+if !have_library("ssl", "SSL_new")
+  raise "Couldn't find OpenSSL library"
+end
+
+version_ok = checking_for("OpenSSL version >= 1.1.1") {
+  try_static_assert("OPENSSL_VERSION_NUMBER >= 0x10101000L", "openssl/opensslv.h")
+}
+unless version_ok
+  raise "OpenSSL >= 1.1.1 or LibreSSL >= 3.9.0 is required"
+end
+
 have_func("&rb_process_status_new")
 
 $defs << "-DUM_KERNEL_VERSION=#{config[:kernel_version]}"