uringmachine 0.24.0 → 0.25.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/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

@@ -530,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);
 
   }
@@ -580,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) {
@@ -805,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);
   }
 

data/ext/um/um.h

@@ -170,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;
@@ -268,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);
@@ -297,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);
@@ -368,4 +369,8 @@ 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);