uringmachine 0.23.1 → 0.25.0

data/examples/fiber_scheduler_file_io.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'uringmachine'
+require 'uringmachine/fiber_scheduler'
+require 'securerandom'
+
+$machine = UringMachine.new
+scheduler = UM::FiberScheduler.new($machine)
+Fiber.set_scheduler scheduler
+
+fn = "/tmp/file_io_#{SecureRandom.hex}"
+
+r, w = IO.pipe
+
+f1 = Fiber.schedule do
+  File.open(fn, 'w') {
+    it.sync = true
+    UM.debug "writing..."
+    it << 'foobar'
+    # w.close
+  }
+
+  File.open(fn, 'r') {
+    UM.debug "reading..."
+    buf = it.read
+    UM.debug "read: #{buf}"
+  }
+rescue => e
+  p e
+  p e.backtrace
+end
+scheduler.join

data/examples/fiber_scheduler_file_io_async.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'io-event'
+  gem 'async'
+end
+
+
+require 'async'
+require 'securerandom'
+
+selector ||= IO::Event::Selector::URing.new(Fiber.current)
+scheduler = Async::Scheduler.new(selector:)
+Fiber.set_scheduler scheduler
+
+fn = "/tmp/file_io_#{SecureRandom.hex}"
+
+scheduler.run do
+  Fiber.schedule do
+    File.open(fn, 'w') {
+      it << 'foo'
+      p pre_flush: IO.read(fn)
+      it.flush
+      it << 'bar'
+      p post_flush: IO.read(fn)
+
+    }
+    p post_close: IO.read(fn)
+  end
+end

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]}"

data/ext/um/um.c

@@ -18,7 +18,7 @@ inline void prepare_io_uring_params(struct io_uring_params *params, uint sqpoll_
     params->flags |= IORING_SETUP_COOP_TASKRUN;
 }
 
-void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec) {
+void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec, int sidecar_mode) {
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
@@ -27,16 +27,26 @@ void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_mse
   machine->size = (size > 0) ? size : DEFAULT_SIZE;
   machine->sqpoll_mode = !!sqpoll_timeout_msec;
 
+  // sidecar handling
+  machine->sidecar_mode = sidecar_mode;
+  machine->sidecar_signal = aligned_alloc(4, sizeof(uint32_t));
+  memset(machine->sidecar_signal, 0, sizeof(uint32_t));
+
   struct io_uring_params params;
   prepare_io_uring_params(&params, sqpoll_timeout_msec);
   int ret = io_uring_queue_init_params(machine->size, &machine->ring, &params);
   if (ret) rb_syserr_fail(-ret, strerror(-ret));
   machine->ring_initialized = 1;
+
+  if (machine->sidecar_mode) um_sidecar_setup(machine);
 }
 
 inline void um_teardown(struct um *machine) {
   if (!machine->ring_initialized) return;
 
+  if (machine->sidecar_mode) um_sidecar_teardown(machine);
+  if (machine->sidecar_signal) free(machine->sidecar_signal);
+
   for (unsigned i = 0; i < machine->buffer_ring_count; i++) {
     struct buf_ring_descriptor *desc = machine->buffer_rings + i;
     io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, i);
@@ -59,8 +69,7 @@ inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
   sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
 
-  fprintf(stderr, "!!!Failed to get SQE\n");
-  um_raise_internal_error("Failed to get SQE");
+  um_raise_internal_error("Submission queue full. Consider raising the machine size.");
 
   // TODO: retry getting SQE?
 
@@ -271,37 +280,60 @@ inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0,
   // machine->metrics.time_last_cpu = time_cpu;
 }
 
+inline void *um_wait_for_sidecar_signal(void *ptr) {
+  struct um *machine = ptr;
+  um_sidecar_signal_wait(machine);
+  return NULL;
+}
+
 // Waits for the given minimum number of completion entries. The wait_nr is
 // either 1 - where we wait for at least one CQE to be ready, or 0, where we
 // don't wait, and just process any CQEs that already ready.
 static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wait_nr) {
   struct wait_for_cqe_ctx ctx = { .machine = machine, .cqe = NULL, .wait_nr = wait_nr };
   machine->metrics.total_waits++;
-  double time_monotonic0 = 0.0;
-  VALUE fiber;
-  if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
-  rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
-  if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
-
-  if (unlikely(ctx.result < 0)) {
-    // the internal calls to (maybe submit) and wait for cqes may fail with:
-    // -EINTR (interrupted by signal)
-    // -EAGAIN (apparently can be returned when wait_nr = 0)
-    // both should not raise an exception.
-    switch (ctx.result) {
-      case -EINTR:
-      case -EAGAIN:
-        // do nothing
-        break;
-      default:
-        rb_syserr_fail(-ctx.result, strerror(-ctx.result));
-    }
-  }
 
-  if (ctx.cqe) {
-    um_process_cqe(machine, ctx.cqe);
-    io_uring_cq_advance(&machine->ring, 1);
+  if (machine->sidecar_mode) {
+    // fprintf(stderr, ">> sidecar wait cqes (unsubmitted: %d)\n", machine->metrics.ops_unsubmitted);
+    if (machine->metrics.ops_unsubmitted) {
+      io_uring_submit(&machine->ring);
+      machine->metrics.ops_unsubmitted = 0;
+    }
+    if (wait_nr) {
+      // fprintf(stderr, ">> um_wait_for_sidecar_signal\n");
+      // rb_thread_call_without_gvl(um_wait_for_sidecar_signal, (void *)machine, RUBY_UBF_PROCESS, 0);
+      // fprintf(stderr, "<< um_wait_for_sidecar_signal\n");
+      um_sidecar_signal_wait(machine);
+    }
     um_process_ready_cqes(machine);
+    // fprintf(stderr, "<< sidecar wait cqes\n");
+  }
+  else {
+    double time_monotonic0 = 0.0;
+    VALUE fiber;
+    if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
+    rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+    if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
+
+    if (unlikely(ctx.result < 0)) {
+      // the internal calls to (maybe submit) and wait for cqes may fail with:
+      // -EINTR (interrupted by signal)
+      // -EAGAIN (apparently can be returned when wait_nr = 0)
+      // both should not raise an exception.
+      switch (ctx.result) {
+        case -EINTR:
+        case -EAGAIN:
+          // do nothing
+          break;
+        default:
+          rb_syserr_fail(-ctx.result, strerror(-ctx.result));
+      }
+    }
+    if (ctx.cqe) {
+      um_process_cqe(machine, ctx.cqe);
+      io_uring_cq_advance(&machine->ring, 1);
+      um_process_ready_cqes(machine);
+    }
   }
 }
 
@@ -336,30 +368,15 @@ inline VALUE um_switch(struct um *machine) {
     &machine->ring, machine->metrics.ops_unsubmitted, machine->metrics.ops_pending,
     machine->metrics.total_ops
   );
+
   while (true) {
     struct um_op *op = um_runqueue_shift(machine);
     if (op) {
       if (unlikely(op->flags & OP_F_RUNQUEUE_SKIP)) continue;
 
-      // in case of a snooze, we need to prevent a situation where completions
-      // are not processed because the runqueue is never empty. Theoretically,
-      // we can still have a situation where multiple fibers are all doing a
-      // snooze repeatedly, which can prevent completions from being processed.
-
-      // is the op a snooze op and is this the same fiber as the current one?
-      if (unlikely(op->kind == OP_SCHEDULE && op->fiber == rb_fiber_current())) {
-        //  are there any pending ops (i.e. waiting for completion)?
-        if (machine->metrics.ops_pending > 0) {
-          // if yes, process completions, get runqueue head, put original op
-          // back on runqueue.
-          // um_process_ready_cqes(machine);
-          um_wait_for_and_process_ready_cqes(machine, 0);
-          struct um_op *op2 = um_runqueue_shift(machine);
-          if (likely(op2 && op2 != op)) {
-            um_runqueue_push(machine, op);
-            op = op2;
-          }
-        }
+      // in test mode we want to process I/O on each snooze
+      if (unlikely(machine->test_mode && (op->kind == OP_SCHEDULE))) {
+        um_wait_for_and_process_ready_cqes(machine, 0);
       }
       return process_runqueue_op(machine, op);
     }
@@ -513,7 +530,7 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
   VALUE ret = um_yield(machine);
 
   if (um_check_completion(machine, &op)) {
-    um_update_read_buffer(machine, buffer, buffer_offset, op.result.res, op.result.flags);
+    um_update_read_buffer(buffer, buffer_offset, op.result.res);
     ret = INT2NUM(op.result.res);
 
   }
@@ -563,6 +580,22 @@ VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_
   return ret;
 }
 
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t maxlen) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_WRITE, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  io_uring_prep_write(sqe, fd, buffer, maxlen, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (um_check_completion(machine, &op))
+    return op.result.res;
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return 0;
+}
+
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv) {
   __u64 file_offset = -1;
   if (TYPE(argv[argc - 1]) == T_FIXNUM) {
@@ -592,10 +625,10 @@ VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv) {
 
     int completed = um_op_completed_p(&op);
     if (unlikely(!completed)) goto cancelled;
-  
+
     writev_res = op.result.res;
     if (unlikely(writev_res < 0)) goto done;
-      
+
     len -= writev_res;
     if (len) {
       um_advance_iovecs_for_writing(&iovecs_ptr, &iovecs_len, (size_t)writev_res);
@@ -788,7 +821,7 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags
   VALUE ret = um_yield(machine);
 
   if (um_check_completion(machine, &op)) {
-    um_update_read_buffer(machine, buffer, 0, op.result.res, op.result.flags);
+    um_update_read_buffer(buffer, 0, op.result.res);
     ret = INT2NUM(op.result.res);
   }
 
@@ -1016,7 +1049,7 @@ VALUE um_select(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds) {
   }
 
   while (pending) {
-    um_wait_for_and_process_ready_cqes(machine, 0);
+    um_wait_for_and_process_ready_cqes(machine, 1);
 
     for (uint i = 0; i < total_len; i++) {
       struct um_op *op = ops + i;

data/ext/um/um.h

@@ -156,7 +156,11 @@ struct um {
   uint mark; // used to mark instances for debugging
 
   struct um_metrics metrics;
+  int test_mode;
   int profile_mode;
+  int sidecar_mode;
+  pthread_t sidecar_thread;
+  uint32_t *sidecar_signal;
 
   uint buffer_ring_count; // number of registered buffer rings
 
@@ -166,7 +170,7 @@ struct um {
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
 
   struct um_op *transient_head; // list of pending transient ops
-  VALUE pending_fibers; // hash containing pending fibers
+  VALUE pending_fibers; // set containing pending fibers
 
   struct um_op *runqueue_head;
   struct um_op *runqueue_tail;
@@ -227,7 +231,7 @@ extern VALUE cAsyncOp;
 extern VALUE eStreamRESPError;
 
 struct um *um_get_machine(VALUE self);
-void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec);
+void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec, int sidecar_mode);
 void um_teardown(struct um *machine);
 
 VALUE um_metrics(struct um *machine, struct um_metrics *metrics);
@@ -264,7 +268,7 @@ void um_prep_op(struct um *machine, struct um_op *op, enum um_op_kind kind, unsi
 void um_raise_on_error_result(int result);
 void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size);
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
-void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offset, __s32 result, __u32 flags);
+void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result);
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
 VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
 void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
@@ -293,6 +297,7 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t maxlen);
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 VALUE um_close(struct um *machine, int fd);
@@ -350,6 +355,7 @@ VALUE stream_get_line(struct um_stream *stream, VALUE buf, ssize_t maxlen);
 VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
+void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);
 
 __attribute__((noreturn)) void um_raise_internal_error(const char *msg);
 
@@ -358,4 +364,13 @@ void write_buffer_update_len(struct um_write_buffer *buf);
 
 void um_define_net_constants(VALUE mod);
 
+void um_sidecar_setup(struct um *machine);
+void um_sidecar_teardown(struct um *machine);
+void um_sidecar_signal_wait(struct um *machine);
+void um_sidecar_signal_wake(struct um *machine);
+
+void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
+int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, int maxlen);
+int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, int len);
+
 #endif // UM_H

data/ext/um/um_async_op_class.c

@@ -1,6 +1,13 @@
 #include "um.h"
 #include <stdlib.h>
 
+/*
+ * Document-class: UringMachine::AsyncOp
+ *
+ * Encapsulates an asynchronous operation. Currently the only asynchronous
+ * operation supported is a timeout operation.
+ */
+
 VALUE cAsyncOp;
 
 VALUE SYM_timeout;
@@ -59,6 +66,10 @@ inline int async_op_is_done(struct um_async_op *async_op) {
   return (async_op->op->flags & OP_F_COMPLETED);
 }
 
+/* Returns the kind of asynchronous operation.
+ *
+ * @return [Symbol] operation kind
+ */
 VALUE AsyncOp_kind(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -71,6 +82,10 @@ VALUE AsyncOp_kind(VALUE self) {
   }
 }
 
+/* Returns true if the operation has completed.
+ *
+ * @return [bool] is the operation done
+ */
 VALUE AsyncOp_done_p(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -78,6 +93,10 @@ VALUE AsyncOp_done_p(VALUE self) {
   return async_op_is_done(async_op) ? Qtrue : Qfalse;
 }
 
+/* Returns the operation result. If the operation is not completed, returns nil.
+ *
+ * @return [Integer, nil] operation result
+ */
 VALUE AsyncOp_result(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -85,6 +104,10 @@ VALUE AsyncOp_result(VALUE self) {
   return async_op_is_done(async_op) ? INT2NUM(async_op->op->result.res) : Qnil;
 }
 
+/* Returns true if the operation has been cancelled.
+ *
+ * @return [bool] is the operation cancelled
+ */
 VALUE AsyncOp_cancelled_p(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -94,6 +117,10 @@ VALUE AsyncOp_cancelled_p(VALUE self) {
   return (async_op->op->result.res == -ECANCELED) ? Qtrue : Qfalse;
 }
 
+/* Waits for the operation to complete.
+ *
+ * @return [Integer] operation result
+ */
 VALUE AsyncOp_await(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);
@@ -104,6 +131,10 @@ VALUE AsyncOp_await(VALUE self) {
   return um_async_op_await(async_op);
 }
 
+/* Cancels the operation.
+ *
+ * @return [UringMachine::AsyncOp] self
+ */
 VALUE AsyncOp_cancel(VALUE self) {
   struct um_async_op *async_op = AsyncOp_data(self);
   raise_on_missing_op(async_op);