uringmachine 0.28.3 → 0.29.0

data/ext/um/um_stream_class.c

@@ -3,21 +3,68 @@
 VALUE cStream;
 VALUE eStreamRESPError;
 
+VALUE SYM_bp_read;
+VALUE SYM_bp_recv;
+VALUE SYM_ssl;
+
+inline int stream_has_target_obj_p(struct um_stream *stream) {
+  switch (stream->mode) {
+    case STREAM_SSL:
+    case STREAM_STRING:
+    case STREAM_IO_BUFFER:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline void stream_mark_segments(struct um_stream *stream) {
+  struct um_segment *curr = stream->head;
+  while (curr) {
+    // rb_gc_mark_movable(curr->obj);
+    curr = curr->next;
+  }
+}
+
+inline void stream_compact_segments(struct um_stream *stream) {
+  struct um_segment *curr = stream->head;
+  while (curr) {
+    // curr->obj = rb_gc_location(curr->obj);
+    curr = curr->next;
+  }
+}
+
 static void Stream_mark(void *ptr) {
   struct um_stream *stream = ptr;
-  rb_gc_mark_movable(stream->buffer);
+  rb_gc_mark_movable(stream->self);
+  rb_gc_mark_movable(stream->machine->self);
+
+  if (stream_has_target_obj_p(stream)) {
+    rb_gc_mark_movable(stream->target);
+    stream_mark_segments(stream);
+  }
 }
 
 static void Stream_compact(void *ptr) {
   struct um_stream *stream = ptr;
-  stream->buffer = rb_gc_location(stream->buffer);
+  stream->self = rb_gc_location(stream->self);
+
+  if (stream_has_target_obj_p(stream)) {
+    stream->target = rb_gc_location(stream->target);
+    stream_compact_segments(stream);
+  }
+}
+
+static void Stream_free(void *ptr) {
+  struct um_stream *stream = ptr;
+  stream_clear(stream);
 }
 
 static const rb_data_type_t Stream_type = {
   .wrap_struct_name = "UringMachine::Stream",
   .function = {
     .dmark = Stream_mark,
-    .dfree = RUBY_TYPED_DEFAULT_FREE,
+    .dfree = Stream_free,
     .dsize = NULL,
     .dcompact = Stream_compact
   },
@@ -26,67 +73,74 @@ static const rb_data_type_t Stream_type = {
 
 static VALUE Stream_allocate(VALUE klass) {
   struct um_stream *stream;
-  return TypedData_Make_Struct(klass, struct um_stream, &Stream_type, stream);
+  VALUE self = TypedData_Make_Struct(klass, struct um_stream, &Stream_type, stream);
+  return self;
 }
 
-static inline struct um_stream *Stream_data(VALUE self) {
+static inline struct um_stream *um_get_stream(VALUE self) {
   struct um_stream *stream;
   TypedData_Get_Struct(self, struct um_stream, &Stream_type, stream);
   return stream;
 }
 
-VALUE Stream_initialize(VALUE self, VALUE machine, VALUE fd) {
-  struct um_stream *stream = Stream_data(self);
-
-  stream->machine = um_get_machine(machine);
-  stream->fd = NUM2ULONG(fd);
-  stream->buffer = rb_utf8_str_new_literal("");
-  rb_str_resize(stream->buffer, 1 << 16); // 64KB
-  rb_str_set_len(stream->buffer, 0);
-
-  stream->len = 0;
-  stream->pos = 0;
-  stream->eof = 0;
-
-  return self;
+static inline void stream_setup(struct um_stream *stream, VALUE target, VALUE mode) {
+  stream->working_buffer = NULL;
+  if (mode == SYM_bp_read || mode == Qnil) {
+    stream->mode = STREAM_BP_READ;
+    stream->fd = NUM2INT(target);
+  }
+  else if (mode == SYM_bp_recv) {
+    stream->mode = STREAM_BP_RECV;
+    stream->fd = NUM2INT(target);
+  }
+  else if (mode == SYM_ssl) {
+    stream->mode = STREAM_SSL;
+    stream->target = target;
+    um_ssl_set_bio(stream->machine, target);
+  }
+  else
+    rb_raise(eUMError, "Invalid stream mode");
 }
 
-VALUE Stream_machine(VALUE self) {
-  struct um_stream *stream = Stream_data(self);
-  return stream->machine->self;
-}
+VALUE Stream_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE machine;
+  VALUE target;
+  VALUE mode;
+  rb_scan_args(argc, argv, "21", &machine, &target, &mode);
 
-VALUE Stream_fd(VALUE self) {
-  struct um_stream *stream = Stream_data(self);
-  return ULONG2NUM(stream->fd);
-}
+  struct um_stream *stream = um_get_stream(self);
+  memset(stream, 0, sizeof(struct um_stream));
 
-VALUE Stream_get_line(VALUE self, VALUE buf, VALUE limit) {
-  struct um_stream *stream = Stream_data(self);
-  if (unlikely(stream->eof)) return Qnil;
+  RB_OBJ_WRITE(self, &stream->self, self);
+  stream->machine = um_get_machine(machine);
+  stream_setup(stream, target, mode);
 
-  return stream_get_line(stream, buf, NUM2LONG(limit));
+  return self;
 }
 
-VALUE Stream_get_string(VALUE self, VALUE buf, VALUE len) {
-  struct um_stream *stream = Stream_data(self);
-  if (unlikely(stream->eof)) return Qnil;
-
-  return stream_get_string(stream, buf, NUM2LONG(len));
+VALUE Stream_mode(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  switch (stream->mode) {
+    case STREAM_BP_READ:  return SYM_bp_read;
+    case STREAM_BP_RECV:  return SYM_bp_recv;
+    case STREAM_SSL:      return SYM_ssl;
+    default:              return Qnil;
+  }
+  return Qnil;
 }
 
-// skips `len` bytes in the stream. This function returns nil if eof is
-// encountered.
-VALUE Stream_skip(VALUE self, VALUE len) {
-  struct um_stream *stream = Stream_data(self);
+VALUE Stream_get_line(VALUE self, VALUE limit) {
+  struct um_stream *stream = um_get_stream(self);
+  return stream_get_line(stream, Qnil, NUM2ULONG(limit));
+}
 
-  return stream_skip(stream, NUM2LONG(len));
+VALUE Stream_get_string(VALUE self, VALUE len) {
+  struct um_stream *stream = um_get_stream(self);
+  return stream_get_string(stream, Qnil, NUM2LONG(len), 0, false);
 }
 
 VALUE Stream_resp_decode(VALUE self) {
-  struct um_stream *stream = Stream_data(self);
-  if (unlikely(stream->eof)) return Qnil;
-
+  struct um_stream *stream = um_get_stream(self);
   VALUE out_buffer = rb_utf8_str_new_literal("");
   VALUE obj = resp_decode(stream, out_buffer);
   RB_GC_GUARD(out_buffer);
@@ -102,34 +156,36 @@ VALUE Stream_resp_encode(VALUE self, VALUE str, VALUE obj) {
   return str;
 }
 
-VALUE Stream_resp_encode_cmd(int argc, VALUE *argv, VALUE self) {
-  struct um_write_buffer buf;
-  VALUE str;
-  rb_check_arity(argc, 2, UNLIMITED_ARGUMENTS);
-  str = argv[0];
-  write_buffer_init(&buf, str);
-  rb_str_modify(str);
-  resp_encode_cmd(&buf, argc - 1, argv + 1);
-  write_buffer_update_len(&buf);
-  return str;
+VALUE Stream_eof_p(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  return stream->eof ? Qtrue : Qfalse;
+}
+
+VALUE Stream_clear(VALUE self) {
+  struct um_stream *stream = um_get_stream(self);
+  stream_clear(stream);
+  return self;
 }
 
 void Init_Stream(void) {
-  VALUE cStream = rb_define_class_under(cUM, "Stream", rb_cObject);
+  cStream = rb_define_class_under(cUM, "Stream", rb_cObject);
   rb_define_alloc_func(cStream, Stream_allocate);
 
-  rb_define_method(cStream, "initialize", Stream_initialize, 2);
-  rb_define_method(cStream, "machine", Stream_machine, 0);
-  rb_define_method(cStream, "fd", Stream_fd, 0);
+  rb_define_method(cStream, "initialize", Stream_initialize, -1);
+  rb_define_method(cStream, "mode", Stream_mode, 0);
 
-  rb_define_method(cStream, "get_line", Stream_get_line, 2);
-  rb_define_method(cStream, "get_string", Stream_get_string, 2);
-  rb_define_method(cStream, "skip", Stream_skip, 1);
+  rb_define_method(cStream, "get_line", Stream_get_line, 1);
+  rb_define_method(cStream, "get_string", Stream_get_string, 1);
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
-
   rb_define_singleton_method(cStream, "resp_encode", Stream_resp_encode, 2);
-  rb_define_singleton_method(cStream, "resp_encode_cmd", Stream_resp_encode_cmd, -1);
+
+  rb_define_method(cStream, "eof?", Stream_eof_p, 0);
+  rb_define_method(cStream, "clear", Stream_clear, 0);
 
   eStreamRESPError = rb_define_class_under(cStream, "RESPError", rb_eStandardError);
+
+  SYM_bp_read = ID2SYM(rb_intern("bp_read"));
+  SYM_bp_recv = ID2SYM(rb_intern("bp_recv"));
+  SYM_ssl     = ID2SYM(rb_intern("ssl"));
 }

data/ext/um/um_utils.c

@@ -62,16 +62,16 @@ inline void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs) {
     return RSTRING_PTR(buffer) + ofs;
   }
   else if (IO_BUFFER_P(buffer)) {
-    void *base;
+    char *base;
     size_t size;
-    rb_io_buffer_get_bytes_for_writing(buffer, &base, &size); // writing *to* buffer
+    rb_io_buffer_get_bytes_for_writing(buffer, (void *)&base, &size); // writing *to* buffer
     if (len == -1) len = size;
     if (ofs < 0) ofs = size + ofs + 1;
     size_t new_size = len + (size_t)ofs;
 
     if (size < new_size) {
       rb_io_buffer_resize(buffer, new_size);
-      rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
+      rb_io_buffer_get_bytes_for_writing(buffer, (void *)&base, &size);
     }
     return base + ofs;
   }
@@ -148,7 +148,7 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
       um_raise_internal_error("Failed to allocate buffers");
     }
 
-    void *ptr = desc->buf_base;
+    char *ptr = desc->buf_base;
     for (unsigned i = 0; i < desc->buf_count; i++) {
 	  	io_uring_buf_ring_add(desc->br, ptr, desc->buf_size, i, desc->buf_mask, i);
       ptr += desc->buf_size;
@@ -164,7 +164,7 @@ inline VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32
 
   unsigned buf_idx = flags >> IORING_CQE_BUFFER_SHIFT;
   struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
-  char *src = desc->buf_base + desc->buf_size * buf_idx;
+  char *src = (char *)desc->buf_base + desc->buf_size * buf_idx;
   // TODO: add support for UTF8
   // buf = rd->utf8_encoding ? rb_utf8_str_new(src, cqe->res) : rb_str_new(src, cqe->res);
   VALUE buf = rb_str_new(src, result);
@@ -224,7 +224,7 @@ inline struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *
 inline void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv) {
   while (adv) {
     if (adv < (*ptr)->iov_len) {
-      (*ptr)->iov_base += adv;
+      (*ptr)->iov_base = (char *)(*ptr)->iov_base + adv;
       (*ptr)->iov_len -= adv;
       return;
     }

data/grant-2025/tasks.md

@@ -24,15 +24,19 @@
 
     https://www.man7.org/linux/man-pages/man7/inotify.7.html
 
-  - [ ] Better buffer management
+  - [v] Better buffer management
     - [v] Add `UM#sendv` method (see below)
     - [v] Benchmark `#sendv` vs `#send_bundle` (in concurrent situation)
     - [v] Support for `IO::Buffer`?
     - [ ] Benchmark `#read_each` vs `#read` (in concurrent situation)
-    - [ ] Implement automatic buffer pool:
-      - [ ] Automatic buffer allocation,registration and management.
-      - [ ] Support for partial buffer consumption.
-      - [ ] Data processing through a rewritten stream implementation.
+    - [v] Implement automatic buffer pool:
+      - [v] Automatic buffer allocation,registration and management.
+      - [v] Support for partial buffer consumption.
+      - [v] Data processing through a rewritten stream implementation.
+
+  - [ ] More benchmarks
+    - Different reading methods in concurrent setting
+    - SSL vs SSL-custom-BIO vs SSL-stream
 
   - [v] Sidecar mode
     - [v] Convert `UM#initialize` to take kwargs
@@ -147,9 +151,10 @@
   - [ ] docs (similar to papercraft docs)
 
 - [ ] Uma - web server
-  - [ ] Rack 3.0-compatible
+  - [v] Rack 3.0-compatible
         see: https://github.com/socketry/protocol-rack
   - [ ] Rails integration (Railtie)
         see: https://github.com/socketry/falcon
+  - [ ] Hanami?
   - [ ] Benchmarks
-  - [ ] Add to the TechEmpower benchmarks
+  - [ ] Add to the TechEmpower benchmarks?

data/lib/uringmachine/fiber_scheduler.rb

@@ -77,9 +77,11 @@ class UringMachine
   # concurrent applications in Ruby, in tight integration with the standard Ruby
   # I/O and locking APIs.
   class FiberScheduler
+    BLOCKING_OP_SUPPORT = ENV['BLOCKING_OP_SUPPORT']
+
 
     # The blocking operation thread pool is shared by all fiber schedulers.
-    DEFAULT_THREAD_POOL = BlockingOperationThreadPool.new
+    DEFAULT_THREAD_POOL = BLOCKING_OP_SUPPORT && BlockingOperationThreadPool.new
 
     # UringMachine instance associated with scheduler.
     attr_reader :machine
@@ -114,6 +116,7 @@ class UringMachine
     # @param block [Proc] fiber block
     # @return [Fiber]
     def fiber(&block)
+      # p fiber: [block]
       fiber = Fiber.new(blocking: false) { @machine.run(fiber, &block) }
 
       @fiber_map[fiber] = true
@@ -141,16 +144,21 @@ class UringMachine
         @fiber_map = ObjectSpace::WeakMap.new
       end
 
-      @machine.await_fibers(fibers)
+      @machine.await(fibers)
     end
 
-    # Runs the given operation in a separate thread, so as not to block other
-    # fibers.
-    #
-    # @param op [callable] blocking operation
-    # @return [void]
-    def blocking_operation_wait(op)
-      @thread_pool.process(@machine, op)
+    if BLOCKING_OP_SUPPORT
+
+      # Runs the given operation in a separate thread, so as not to block other
+      # fibers.
+      #
+      # @param op [callable] blocking operation
+      # @return [void]
+      def blocking_operation_wait(op)
+        # p blocking_operation_wait: [op]
+        @thread_pool.process(@machine, op)
+      end
+
     end
 
     # Blocks the current fiber by yielding to the machine. This hook is called
@@ -160,6 +168,7 @@ class UringMachine
     # @param timeout [Number, nil] optional timeout
     # @return [bool] was the operation successful
     def block(blocker, timeout = nil)
+      # p block: [blocker, timeout]
       if timeout
         @machine.timeout(timeout, Timeout::Error) { @machine.yield }
       else
@@ -178,6 +187,7 @@ class UringMachine
     # @param fiber [Fiber] fiber to resume
     # @return [void]
     def unblock(blocker, fiber)
+      # p unblock: [blocker, fiber]
       @machine.schedule(fiber, nil)
       @machine.wakeup if Thread.current != @thread
     end
@@ -187,11 +197,13 @@ class UringMachine
     # @param duration [Number, nil] sleep duration
     # @return [void]
     def kernel_sleep(duration = nil)
+      # p kernel_sleep: duration
       duration ? @machine.sleep(duration) : @machine.yield
     end
 
     # Yields to the next runnable fiber.
     def yield
+      # p yield: []
       @machine.snooze
     end
 
@@ -202,6 +214,7 @@ class UringMachine
     # @param timeout [Number, nil] optional timeout
     # @return [void]
     def io_wait(io, events, timeout = nil)
+      # p io_wait: [io, events, timeout]
       timeout ||= io.timeout
       if timeout
         @machine.timeout(timeout, Timeout::Error) {
@@ -219,6 +232,7 @@ class UringMachine
     # @param eios [Array<IO>] exceptable IOs
     # @param timeout [Number, nil] optional timeout
     def io_select(rios, wios, eios, timeout = nil)
+      # p io_select: [rios, wios, eios, timeout]
       map_r = map_fds(rios)
       map_w = map_fds(wios)
       map_e = map_fds(eios)
@@ -243,6 +257,7 @@ class UringMachine
     # @param offset [Integer] buffer offset
     # @return [Integer] bytes read
     def io_read(io, buffer, length, offset)
+      # p io_read: [io, buffer, length, offset]
       length = buffer.size if length == 0
 
       if (timeout = io.timeout)
@@ -269,6 +284,7 @@ class UringMachine
     # @param offset [Integer] buffer offset
     # @return [Integer] bytes read
     def io_pread(io, buffer, from, length, offset)
+      # p io_pread: [io, buffer, from, length, offset]
       length = buffer.size if length == 0
 
       if (timeout = io.timeout)
@@ -294,6 +310,7 @@ class UringMachine
     # @param offset [Integer] write offset
     # @return [Integer] bytes written
     def io_write(io, buffer, length, offset)
+      # p io_write: [io, buffer, length, offset]
       length = buffer.size if length == 0
       buffer = buffer.slice(offset) if offset > 0
 
@@ -321,6 +338,7 @@ class UringMachine
     # @param offset [Integer] buffer offset
     # @return [Integer] bytes written
     def io_pwrite(io, buffer, from, length, offset)
+      # p io_pwrite: [io, buffer, from, length, offset]
       length = buffer.size if length == 0
       buffer = buffer.slice(offset) if offset > 0
 
@@ -344,6 +362,7 @@ class UringMachine
     # @param fd [Integer] file descriptor
     # @return [Integer] file descriptor
     def io_close(fd)
+      # p io_close: [fd]
       @machine.close_async(fd)
     rescue Errno => e
       -e.errno
@@ -368,6 +387,7 @@ class UringMachine
     # @param exception [Exception] Exception
     # @return [void]
     def fiber_interrupt(fiber, exception)
+      # p fiber_interrupt: [fiber, exception]
       @machine.schedule(fiber, exception)
       @machine.wakeup
     end
@@ -377,6 +397,7 @@ class UringMachine
     # @param hostname [String] hostname to resolve
     # @return [Array<Addrinfo>] array of resolved addresses
     def address_resolve(hostname)
+      # p address_resolve: [hostname]
       Resolv.getaddresses(hostname)
     end
 
@@ -388,6 +409,7 @@ class UringMachine
     # @param block [Proc] block to run
     # @return [any] block return value
     def timeout_after(duration, exception, message, &block)
+      # p timeout_after:  [duration, exception, message, block]
       @machine.timeout(duration, exception, &block)
     end
 
@@ -397,7 +419,11 @@ class UringMachine
     #
     # @param o [any]
     # @return [void]
-    def p(o) = UM.debug(o.inspect)
+    def p(o)
+      UM.debug(o.inspect)
+      UM.debug(caller[2..12].inspect)
+      UM.debug("")
+    end
 
     # Maps the given ios to fds.
     #

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -46,7 +46,7 @@ class UringMachine
   def terminate(*fibers)
     fibers = fibers.first if fibers.size == 1 && fibers.first.is_a?(Enumerable)
 
-    fibers.each { schedule(it, TERMINATE_EXCEPTION) }
+    fibers.each { schedule(it, TERMINATE_EXCEPTION) unless it.done? }
   end
 
   # Runs the given block in the given fiber. This method is used to run fibers
@@ -62,24 +62,49 @@ class UringMachine
     fiber
   end
 
-  # Waits for the given fibers to terminate.
+  # Waits for the given fibers to terminate, returning the return value for each
+  # given fiber. This method also accepts procs instead of fibers. When a proc
+  # is given, it is ran in a separate fiber which will be joined.
   #
-  # @return [Array<any>] return values of the given fibers
+  #     machine.join(
+  #       -> { machine.sleep(0.01); :f1 },
+  #       -> { machine.sleep(0.02); :f2 },
+  #       -> { machine.sleep(0.03); :f3 }
+  #     ) #=> [:f1, :f2, :f3]
+  #
+  # @param *fibers [Array<Fiber, Proc>] fibers @return [Array<any>] return
+  # values of the given fibers
   def join(*fibers)
-    fibers = fibers.first if fibers.size == 1 && fibers.first.is_a?(Enumerable)
+    queue = Fiber.current.mailbox
+
+    if fibers.size == 1
+      first = fibers.first
+      case first
+      when Enumerable
+        fibers = first
+      when Fiber
+        first = proc_spin(first) if first.is_a?(Proc)
+        if !first.done?
+          first.add_done_listener(queue)
+          self.shift(queue)
+        end
+        return first.result
+      end
+    end
 
-    results = fibers.inject({}) { |h, f| h[f] = nil; h }
-    queue = nil
+    results = {}
     pending = nil
     fibers.each do |f|
+      f = proc_spin(f) if f.is_a?(Proc)
       if f.done?
         results[f] = f.result
       else
+        results[f] = nil
         (pending ||= []) << f
-        queue ||= Fiber.current.mailbox
         f.add_done_listener(queue)
       end
     end
+
     if pending
       while !pending.empty?
         f = self.shift(queue)
@@ -96,23 +121,29 @@ class UringMachine
   #
   # @param fibers [Fiber, Array<Fiber>] fibers to wait for
   # @return [Integer] number of fibers
-  def await_fibers(fibers)
-    if fibers.is_a?(Fiber)
-      f = fibers
-      if !f.done?
-        queue = Fiber.current.mailbox
-        f.add_done_listener(queue)
-        self.shift(queue)
+  def await(*fibers)
+    queue = Fiber.current.mailbox
+
+    if fibers.size == 1
+      first = fibers.first
+      case first
+      when Enumerable
+        fibers = first
+      when Fiber
+        first = proc_spin(first) if first.is_a?(Proc)
+        if !first.done?
+          first.add_done_listener(queue)
+          self.shift(queue)
+        end
+        return 1
       end
-      return 1
     end
 
-    queue = nil
     pending = nil
     fibers.each do |f|
+      f = proc_spin(f) if f.is_a?(Proc)
       if !f.done?
         (pending ||= []) << f
-        queue ||= Fiber.current.mailbox
         f.add_done_listener(queue)
       end
     end
@@ -176,11 +207,11 @@ class UringMachine
     fiber.set_result(e)
   ensure
     fiber.mark_as_done
-    # cleanup
     fiber_set.delete(fiber)
     self.notify_done_listeners(fiber)
 
-    # switch away to a different fiber
+    # finally switch away to a different fiber, the current fiber should not be
+    # resumed after this.
     self.switch
   end
 
@@ -215,6 +246,16 @@ class UringMachine
     }
   end
 
+  # @param proc [Proc]
+  # @return [Fiber]
+  def proc_spin(proc)
+    if proc.arity == 0
+      spin { proc.call }
+    else
+      spin(&proc)
+    end
+  end
+
   # Fiber extensions
   module FiberExtensions
     attr_reader :result, :done, :done_listeners

data/test/helper.rb

@@ -68,6 +68,8 @@ class UMBaseTest < Minitest::Test
   def teardown
     return if !@machine
 
+    @machine = nil
+
     # pending_fibers = @machine.pending_fibers
     # raise "leaked fibers: #{pending_fibers}" if pending_fibers.size > 0