uringmachine 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dea49e5d6f13c7919ccaa9765428bfc81058ad1fab0b3f1df07d0fd60a5b1cd3
-  data.tar.gz: 3cd06ca52b40e891807b589bc7d7f97cfc67be2d491e5855a9624de959f160a1
+  metadata.gz: 1c37bb6e6971036cefa78d76efbb4425f843087b4b4f5e24fe16e695920746b8
+  data.tar.gz: 144e109b5dfa199adda69387c7229c78393f3ee8b0a45f545db76934f896ef2c
 SHA512:
-  metadata.gz: 06ef57453cc0986a0b047b9d91ab5add06cf64145d5fd17ba5d85edf1b01f1bde0cea060d3a54bc87cadc9fc4c0137350ad704b0f0c1421f51c9ef9158eed8c5
-  data.tar.gz: 65a8701e871902c7e726cdaebacebef4bde5c111b6a3393b92d40a9b5a3005535f240cb30574f34fa41048206430b8faa41203d23a2fab603285c88eb9e766b4
+  metadata.gz: 3d19ae0d9c4056c691a8b9c93901f759e2b149ebd275d8a5d1e0dcfc33e2308eef0e583541b2ce90b69d55efc20b4ab0c7415f4e44d0c9753b07e733bc965e90
+  data.tar.gz: 697653d6d9120bcbece655bf530e1e87e9fc461e2052bd20b8666f344440ee11898b569c3d98a7477c39dd11bdf6ff03fc6b1e08f953c257a84fb0aea58a882f

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.0.6 2026-10-01
+
+- Add `UM#file_read` convenience method
+
+# 1.0.5 2026-10-01
+
+- Add support for regular files in UM::IO with :file mode
+
 # 1.0.4 2026-08-24
 
 - Add `IO#read_uint_be` method

data/TODO.md

@@ -1,4 +1,46 @@
-## immediate
+## Character scanning in UM::IO
+
+- Refactor character scanning
+  - functions/macros for iterating over segments
+
+  - SIMD?
+    - prep work for SIMD character scanning
+    - we'll probably need a bit of helper code for dealing with SIMD
+    - a good overview here: https://mitchellh.com/writing/everyone-should-know-simd
+    - SIMD prep work should be done once before iterating over segments
+
+```c
+// bitmaps for character types can be generated with a bit of Ruby:
+//
+// def t(r); (0..255).map { [it].pack('c') =~ r ? 1 : 0 }; end
+// def tn(r); (0..255).map { [it].pack('c') =~ r ? 0 : 1 }; end
+// def u64(bits); bits.reverse.join.to_i(2); end
+// def p(a); a.each_slice(64).map { u64(it) }; end
+
+// usage:
+//
+//   p(t(/[a-zA-Z0-9]/)).map { format('%016X', it) }
+
+
+// /[a-zA-Z0-9]/
+uint64_t alpha_numeric[] = [
+  0x000000000000FFC0,
+  0x7FFFFFE07FFFFFE0,
+  0x0000000000000000,
+  0x0000000000000000
+];
+
+// HTTP method: /[a-zA-Z]/    (3-12 characters)
+// header-key:  /[a-zA-Z\-]/  ()
+// path:        /^($/
+
+// check if character is in bitmap
+inline int test_char(char c, uint64 *bitmap) {
+  return bitmap[c / 64] & (1UL << (c % 64));
+}
+```
+
+## IO methods
 
 - IO methods:
   ```ruby
@@ -23,30 +65,20 @@
   raise if stream_id &  0x80000000
   ```
 
-- SSL kTLS:
-  - discussion: https://share.gemini.google/tPWiFpr3bWeF
-  - API:
-
-    ```ruby
-    machine.ssl_setup_ktls(fd)
-
-    # then we can just use normal send/recv
-    machine.send(fd, "foo!")
-    ```
-
-- SSL custom BIO:
-  - release GVL before calling `SSL_read`, `SSL_write`
-  - reacquire GVL (`rb_thread_call_with_gvl`) in `um_bio_read`, `um_bio_write`
-
-- Add `IO#http_xxx` methods
-  - `#http_read_request_headers()`
-  - `#http_read_body(content_length)` (-1 means chunked TE)
+- Add `IO#http1_xxx` methods
+  - `#http1_read_request_headers()`
+  - `#http1_read_body(content_length)` (-1 means chunked TE)
 
 - Add tests for support for Set in `machine#await`
 - Add tests for support for Set, Array in `machine#join`
-- Add `UM#read_file` for reading entire file
+  - Add `UM#read_file` for reading entire file
 - Add `UM#write_file` for writing entire file
 
+## SSL custom BIO:
+
+- release GVL before calling `SSL_read`, `SSL_write`
+- reacquire GVL (`rb_thread_call_with_gvl`) in `um_bio_read`, `um_bio_write`
+
 ## Balancing I/O with the runqueue
 
 - in some cases where there are many entries in the runqueue, this can
@@ -109,6 +141,7 @@
 - select on fibers:
   - select fibers that are done
   - select first done fiber
+- we might want to rename `#select` to `#fdselect`
 
 ## ops still not implemented
 
@@ -131,36 +164,3 @@
   #        ['1.1.1.1:80', '2.2.2.2:80']
   tcp_connect_he(*addrs)
   ```
-
-## Character scanning in UM::IO
-
-```c
-// bitmaps for character types can be generated with a bit of Ruby:
-//
-// def t(r); (0..255).map { [it].pack('c') =~ r ? 1 : 0 }; end
-// def tn(r); (0..255).map { [it].pack('c') =~ r ? 0 : 1 }; end
-// def u64(bits); bits.reverse.join.to_i(2); end
-// def p(a); a.each_slice(64).map { u64(it) }; end
-
-// usage:
-//
-//   p(t(/[a-zA-Z0-9]/)).map { format('%016X', it) }
-
-
-// /[a-zA-Z0-9]/
-uint64_t alpha_numeric[] = [
-  0x000000000000FFC0,
-  0x7FFFFFE07FFFFFE0,
-  0x0000000000000000,
-  0x0000000000000000
-];
-
-// HTTP method: /[a-zA-Z]/    (3-12 characters)
-// header-key:  /[a-zA-Z\-]/  ()
-// path:        /^($/
-
-// check if character is in bitmap
-inline int test_char(char c, uint64 *bitmap) {
-  return bitmap[c / 64] & (1UL << (c % 64));
-}
-```

data/ext/um/um.h

@@ -83,6 +83,7 @@ enum um_io_mode {
   IO_FD,
   IO_SOCKET,
   IO_SSL,
+  IO_FILE,
   IO_STRING,
   IO_IO_BUFFER
 };

data/ext/um/um_io.c

@@ -157,7 +157,7 @@ inline void io_handle_enobufs(struct um_io *io) {
   io->op = NULL;
 }
 
-inline void io_await_segments(struct um_io *io) {
+static inline void io_await_segments(struct um_io *io) {
   if (unlikely(!io->op)) io_multishot_op_start(io);
 
   if (!OP_CQE_SEEN_P(io->op)) {
@@ -208,11 +208,54 @@ int io_get_more_segments_ssl(struct um_io *io) {
   return 1;
 }
 
+int io_get_more_segments_file(struct um_io *io) {
+  if (!io->working_buffer)
+    io->working_buffer = bp_buffer_checkout(io->machine);
+
+  char *ptr = io->working_buffer->buf + io->working_buffer->pos;
+  size_t maxlen = io->working_buffer->len - io->working_buffer->pos;
+
+  struct um_op *op = um_op_acquire(io->machine);
+  um_prep_op(io->machine, op, OP_READ, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(io->machine, op);
+  io_uring_prep_read(sqe, io->fd, ptr, maxlen, -1);
+
+  VALUE ret = um_yield(io->machine);
+  int has_more = 0;
+
+  if (likely(um_verify_op_completion(io->machine, op, true))) {
+    int res = op->result.res;
+
+    if (res == 0) {
+      bp_buffer_checkin(io->machine, io->working_buffer);
+      io->working_buffer = NULL;
+      goto done;
+    }
+
+    struct um_segment *segment = bp_buffer_consume(io->machine, io->working_buffer, res);
+    io_add_segment(io, segment);
+
+    if ((size_t)res == maxlen) {
+      bp_buffer_checkin(io->machine, io->working_buffer);
+      io->working_buffer = NULL;
+    }
+    else has_more = 1;
+  }
+  um_op_release(io->machine, op);
+
+done:
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return has_more;
+}
+
 int io_get_more_segments(struct um_io *io) {
   switch (io->mode) {
     case IO_FD:
     case IO_SOCKET:
       return io_get_more_segments_bp(io);
+    case IO_FILE:
+      return io_get_more_segments_file(io);
     case IO_SSL:
       return io_get_more_segments_ssl(io);
     default:
@@ -438,14 +481,15 @@ VALUE io_read(struct um_io *io, VALUE out_buffer, ssize_t len, size_t inc, int s
 
   while (true) {
     size_t segment_len = current->len - pos;
-    if (abs_len && segment_len > remaining_len) {
+    if (abs_len && segment_len > (size_t)remaining_len) {
       segment_len = remaining_len;
     }
     total_len += segment_len;
     if (abs_len) {
       remaining_len -= segment_len;
-      if (!remaining_len)
+      if (!remaining_len) {
         return io_consume_string(io, out_buffer, total_len, inc, safe_inc);
+      }
     }
 
     if (!current->next) {

data/ext/um/um_io_class.c

@@ -4,6 +4,7 @@ VALUE cIO;
 VALUE eIORESPError;
 
 VALUE SYM_fd;
+VALUE SYM_file;
 VALUE SYM_socket;
 VALUE SYM_ssl;
 
@@ -87,6 +88,7 @@ static inline void io_set_target(struct um_io *conn, VALUE target, enum um_io_mo
   conn->mode = mode;
   switch (mode) {
     case IO_FD:
+    case IO_FILE:
     case IO_SOCKET:
       conn->fd = NUM2INT(target);
       return;
@@ -109,6 +111,8 @@ static inline void io_setup(struct um_io *conn, VALUE target, VALUE mode) {
   }
   else if (mode == SYM_fd)
     io_set_target(conn, target, IO_FD);
+  else if (mode == SYM_file)
+    io_set_target(conn, target, IO_FILE);
   else if (mode == SYM_socket)
     io_set_target(conn, target, IO_SOCKET);
   else if (mode == SYM_ssl)
@@ -157,10 +161,11 @@ VALUE IO_initialize(int argc, VALUE *argv, VALUE self) {
 VALUE IO_mode(VALUE self) {
   struct um_io *conn = um_get_io(self);
   switch (conn->mode) {
-    case IO_FD:  return SYM_fd;
-    case IO_SOCKET:  return SYM_socket;
-    case IO_SSL:      return SYM_ssl;
-    default:              return Qnil;
+    case IO_FD:     return SYM_fd;
+    case IO_FILE:   return SYM_file;
+    case IO_SOCKET: return SYM_socket;
+    case IO_SSL:    return SYM_ssl;
+    default:        return Qnil;
   }
   return Qnil;
 }
@@ -427,7 +432,8 @@ void Init_IO(void) {
 
   eIORESPError = rb_define_class_under(cIO, "RESPError", rb_eStandardError);
 
-  SYM_fd = ID2SYM(rb_intern("fd"));
-  SYM_socket = ID2SYM(rb_intern("socket"));
+  SYM_fd      = ID2SYM(rb_intern("fd"));
+  SYM_file    = ID2SYM(rb_intern("file"));
+  SYM_socket  = ID2SYM(rb_intern("socket"));
   SYM_ssl     = ID2SYM(rb_intern("ssl"));
 }

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '1.0.4'
+  VERSION = '1.0.6'
 end

data/lib/uringmachine.rb

@@ -50,7 +50,7 @@ class UringMachine
   end
 
   # Runs the given block in the given fiber. This method is used to run fibers
-  # indirectly.
+  # indirectly. See FiberScheduler#fiber
   #
   # @param fiber [Fiber] fiber
   # @param block [Proc] block to run
@@ -202,9 +202,10 @@ class UringMachine
   # the type of target and how it is read from:
   #
   # - :fd - read from the given fd using the buffer pool (default mode)
+  # - :file - read from a regular file
   # - :socket - receive from the given socket fd using the buffer pool
   # - :ssl - read from the given SSL socket
-  #
+  # 
   # If a block is given, the block will be called with the IO instance as
   # argument and the method will return the block's return value.
   #
@@ -220,6 +221,17 @@ class UringMachine
     res
   end
 
+  # call-seq:
+  #   machine.file_read(fn) -> data
+  #
+  # Reads and returns the content of the given filename, with a maximum length of 1GB.
+  #
+  # @param fn [String] filename
+  # @return [String] file content
+  def file_read(fn)
+    open(fn, O_RDONLY) { io(it, :file).read(-(1 << 30)) }
+  end
+
   # Creates, binds and sets up a TCP socket for listening on the given host and
   # port.
   #

data/test/test_io.rb

@@ -4,6 +4,7 @@ require_relative 'helper'
 require 'securerandom'
 require 'openssl'
 require 'localhost/authority'
+require 'tempfile'
 
 class IOBaseTest < UMBaseTest
   attr_reader :conn
@@ -715,6 +716,23 @@ class IOModeTest < UMBaseTest
     sock2&.close rescue nil
   end
 
+  def test_io_file_mode
+    fn = Tempfile.new('uringmachine_test_io_from_file').path
+    IO.write(fn, (0..9).to_a.join)
+    fd = machine.open(fn, UM::O_RDONLY)
+    io = machine.io(fd, :file)
+    buf = io.read(3)
+    assert_equal '012', buf
+
+    buf = io.read(5)
+    assert_equal '34567', buf
+
+    buf = io.read(-4)
+    assert_equal '89', buf
+  ensure
+    machine.close(fd) if fd
+  end
+
   def test_io_socket_mode_non_socket
     r, w = UM.pipe
     machine.write(w, 'foobar')

data/test/test_um.rb

@@ -2,6 +2,7 @@
 
 require_relative 'helper'
 require 'socket'
+require 'tempfile'
 
 class UringMachineTest < Minitest::Test
   def test_kernel_version
@@ -3520,6 +3521,23 @@ class IOMethodTest < UMBaseTest
   end
 end
 
+class FileHelperMethodsTest < UMBaseTest
+  def setup
+    super
+    @fn = Tempfile.new('uringmachine_test_io_from_file').path
+  end
+
+  def test_file_read
+    IO.write(@fn, 'foobar' * 321)
+    buf = machine.file_read(@fn)
+    assert_equal 'foobar' * 321, buf
+  end
+
+  def test_file_read_bad_fn
+    assert_raises(Errno::ENOENT) { machine.file_read(@fn + '-missing') }
+  end
+end
+
 class TCPHelperMethodsTest < UMBaseTest
   def setup
     super

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors:
 - Sharon Rosner