uringmachine 0.25.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 162f747c9286305e5bba72e0ab5c3d0d89c9a0ff42e1480b4c247a05dab0c2f3
-  data.tar.gz: 41ebc4a248a204f898d6d4cc954405b441c533109f08cae2806a0204bd1726aa
+  metadata.gz: 1211434f5b2f4aad1e47d1bd166204cce6792a80e3ef845ae4dee097d8e1ea45
+  data.tar.gz: eff370b4564c88c3daf57cbed3d8b165113ddee697ee1b16aa63ad3452a38c02
 SHA512:
-  metadata.gz: d99daa2b45df0c28f9d087e19ce92678f78b76c551d47a5c55d93188a881b347a3d87f49cb93dc10686c5c89726fbc97b40e656cbcb09becbd53eeccc790e435
-  data.tar.gz: ba9f0408ac9157e82dfd34595d73d5e924a58cf8db0ee76971c5675b44c89a1ace5219e569c3a21ceff6e51439d39814f9a1f2a0314a2506bbde9169679c6707
+  metadata.gz: cdb26cf58a41a9f7ad2d025ccc473b0088f4c3e622a65058b1ee6e0aeb95c0eb3775f980cccb60e81b2213ed8fb49263c6500b2c05fbbb71abb156be00dca636
+  data.tar.gz: 06f509928387d2812578c143dfb96ed031be10994c7b43908babfef02d72d149b8f2a3932dee7a4d3577150b5512addb8b7c44d5b7ea2e63dddb7f2b427df604

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.27.0 2026-02-15
+
+- Add `.pr_set_child_subreaper` method
+- Add `#send_fd`, `#recv_fd` methods
+
+# 0.26.0 2026-02-13
+
+- Reimplement um_op lifecycle tracking
+
 # 0.25.0 2026-02-10
 
 - Add Yard docs

data/TODO.md

@@ -1,15 +1,25 @@
 ## immediate
 
-- Fix all futex value (Queue, Mutex) to be aligned
+- Fix all futex value (Queue, Mutex) to be properly aligned
 
 ## Buffer rings - automatic management
 
+- Take the buffer_pool branch, rewrite it
+- Allow multiple stream modes:
+  - :buffer_pool - uses buffer rings
+  - :ssl - read from an SSL connection (`SSLSocket`)
+  - :io - read from an `IO`
+
+The API will look something like:
+
 ```ruby
-# completely hands off
-machine.read_each(fd) { |str| ... }
+# The mode is selected automatically according to the given target
+
+stream = UM::Stream.new(fd) # buffer_pool mode
 
-# what if we want to get IO::Buffer?
-machine.read_each(fd, io_buffer: true) { |iobuff, len| ... }
+stream = UM::Stream.new(ssl_sock) # ssl mode
+
+stream = UM::Stream.new(conn) # io mode
 ```
 
 ## Balancing I/O with the runqueue
@@ -54,19 +64,6 @@ machine.read_each(fd, io_buffer: true) { |iobuff, len| ... }
 - select on multiple queues (ala Go)
 - select on mixture of queues and fds
 
-(see also simplified op management below)
-
-## simplified op management
-
-Op lifecycle management can be much much simpler
-
-- make all ops heap-allocated
-- clear up state transitions:
-
-  - kernel-side state: unsubmitted, submitted, completed, done (for multishot ops)
-  - app-side state: unsubmitted, submitted, ...
-
-
 ## ops
 
 - splice / - tee
@@ -94,7 +91,8 @@ We're still missing:
 - ability to supply buffer to `get_line` and `get_string`
 - allow read to eof, maybe with `read_to_eof`
 
-For the sake of performance, simplicity and explicitness, we change the API as follows:
+For the sake of performance, simplicity and explicitness, we change the API as
+follows:
 
 ```ruby
 stream.get_line(buf, limit)

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