uringmachine 0.5 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2067cd0f88d6dbc341410ca6911916f510132ee23ce3f6d5fb5978259eeaef11
-  data.tar.gz: f816a9478f714a3a9770740bc14fc03ae2687f2fe7d0e29cbc0b8632994bad1f
+  metadata.gz: 0b063db46fac29472c42866eb1864c731b24fc0846fe424eec06213bba8fde0a
+  data.tar.gz: a535fabf5d16107de8d3823766d9ff0d7d22d0702c5401e263eb925eb222dd5d
 SHA512:
-  metadata.gz: 6e0a9ed6e6f131bf6d67a56622786893532a525f4427e134670499997c0461a4df6de3ca1cb9e70851769c1135575986468a83edfd9b5d75c7d592e41bb0ca8c
-  data.tar.gz: 2c73ed9a3268ea96b3a167064251d16279c531ee50e5f9c6de9aa2c56f6a70973ef04ce5d6c44f46e39309f7bf8cb3f3ff5e61bf1512ca07cc5f35b91f7303dc
+  metadata.gz: 94ad9e942e84e87f0acbd75007962c3df5ea259de77ef4e590ff91dc4ea614dcd22e7db3da1954be05b11951e621f0cf58858391b677e109e97590bb0f8e3dee
+  data.tar.gz: 4c77e826fb33fc879de748b877eec9a6d49f6927b8167377b4191c30b9aa2b638dbd0cc76a77ec0a17daec648d2587ca4357f367501391aad06c7532606e85b2

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+- Add `#prep_timeout` and `AsyncOp`
+
 # 2024-11-14 Version 0.5
 
 - Add `#waitpid`

data/examples/bm_sqlite.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'extralite'
+  gem 'benchmark-ips'
+end
+
+require 'uringmachine'
+require 'extralite'
+
+class UM::Actor < Fiber
+  def initialize(machine, target)
+    @machine = machine
+    @target = target
+    @mailbox = UM::Queue.new
+    super { act }
+  end
+
+  def act
+    while (sym, a, k, peer = @machine.shift(@mailbox))
+
+      begin
+        ret = @target.send(sym, *a, **k)
+        @machine.schedule(peer, ret)
+      rescue => e
+        @machine.schedule(peer, e)
+      end
+    end
+  rescue Exception => e
+    # handle unhandled exceptions
+  ensure
+    @machine.fiber_map.delete(self)
+    @machine.yield
+  end
+
+  def method_missing(sym, *a, **k)
+    @machine.push(@mailbox, [sym, a, k, Fiber.current])
+    ret = @machine.yield
+    raise(ret) if ret.is_a?(Exception)
+    ret
+  end
+end
+
+class UM
+  def spin_actor(target)
+    f = UM::Actor.new(self, target)
+    schedule(f, nil)
+    @@fiber_map[f] = true
+    f
+  end
+end
+
+class Locker
+  def initialize(machine, target)
+    @machine = machine
+    @target = target
+    @mutex = UM::Mutex.new
+  end
+
+  def method_missing(sym, *a, **k)
+    @machine.synchronize(@mutex) { @target.send(sym, *a, **k) }
+  end
+end
+
+
+PATH = '/tmp/foo'
+
+$machine = UM.new
+$raw_db = Extralite::Database.new(PATH)
+$actor_db = $machine.spin_actor(Extralite::Database.new(PATH))
+$locker_db = Locker.new($machine, Extralite::Database.new(PATH))
+
+[$raw_db, $actor_db, $locker_db].each do |db|
+  p db.query('select 1')
+end
+
+bm = Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("raw")     { $raw_db.query('select 1') }
+  x.report("actor")   { $actor_db.query('select 1') }
+  x.report("locker")  { $locker_db.query('select 1') }
+
+  x.compare!
+end

data/examples/http_server.rb

@@ -35,7 +35,7 @@ end
 
 server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
 @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-@machine.bind(server_fd, '127.0.0.1', 1234)
+@machine.bind(server_fd, '0.0.0.0', 1234)
 @machine.listen(server_fd, UM::SOMAXCONN)
 puts 'Listening on port 1234'
 

data/examples/pg.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+@machine = UM.new
+
+class UM::Stream
+  def initialize(machine, fd)
+    @machine, @fd, @bgid = machine, fd
+    @buffer = +''
+    @ofs_head = 0
+    @ofs_tail = 0
+  end
+
+  def feed
+    if (@ofs_head == @ofs_tail) && (@ofs_head >= 4096)
+      @buffer = +''
+      @ofs_head = @ofs_tail = 0
+    end
+    ret = @machine.read(@fd, @buffer, 65536, @ofs_tail)
+    if ret == 0
+      @eof = true
+      return false
+    end
+      
+    @ofs_tail += ret
+    true
+  end
+
+  def read(len)
+    if @ofs_head + len > @ofs_tail
+      feed
+    end
+
+    str = @buffer[@ofs_head, len]
+    @ofs_head += str.bytesize
+    str
+  end
+
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    while true
+      idx = @buffer.index(sep, @ofs_head)
+      if idx
+        str = @buffer[@ofs_head, idx + sep_size]
+        @ofs_head += str.bytesize
+        return str
+      end
+
+      return nil if !feed
+    end
+  end
+end
+
+$machine = UringMachine.new
+
+server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+$machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+$machine.bind(server_fd, '127.0.0.1', 1234)
+$machine.listen(server_fd, UM::SOMAXCONN)
+puts 'Listening on port 1234'
+
+def handle_connection(fd)
+  stream = UM::Stream.new($machine, fd)
+
+  while (l = stream.gets)
+    $machine.write(fd, "You said: #{l}")
+  end
+rescue Exception => e
+  puts "Got error #{e.inspect}, closing connection"
+  $machine.close(fd) rescue nil
+end
+
+main = Fiber.current
+trap('SIGINT') { $machine.spin { $machine.schedule(main, SystemExit.new) } }
+
+$machine.accept_each(server_fd) do |fd|
+  puts "Connection accepted fd #{fd}"
+  $machine.spin(fd) { handle_connection(_1) }
+end

data/examples/stream.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+
+@machine = UM.new
+
+class UM::Stream
+  def initialize(machine, fd)
+    @machine, @fd, @bgid = machine, fd
+    @buffer = +''
+    @ofs_head = 0
+    @ofs_tail = 0
+  end
+
+  def feed
+    if (@ofs_head == @ofs_tail) && (@ofs_head >= 4096)
+      @buffer = +''
+      @ofs_head = @ofs_tail = 0
+    end
+    ret = @machine.read(@fd, @buffer, 65536, @ofs_tail)
+    if ret == 0
+      @eof = true
+      return false
+    end
+      
+    @ofs_tail += ret
+    true
+  end
+
+  def read(len)
+    if @ofs_head + len > @ofs_tail
+      feed
+    end
+
+    str = @buffer[@ofs_head, len]
+    @ofs_head += str.bytesize
+    str
+  end
+
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    while true
+      idx = @buffer.index(sep, @ofs_head)
+      if idx
+        str = @buffer[@ofs_head, idx + sep_size]
+        @ofs_head += str.bytesize
+        return str
+      end
+
+      return nil if !feed
+    end
+  end
+end
+
+$machine = UringMachine.new
+
+server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+$machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+$machine.bind(server_fd, '127.0.0.1', 1234)
+$machine.listen(server_fd, UM::SOMAXCONN)
+puts 'Listening on port 1234'
+
+def handle_connection(fd)
+  stream = UM::Stream.new($machine, fd)
+
+  while (l = stream.gets)
+    $machine.write(fd, "You said: #{l}")
+  end
+rescue Exception => e
+  puts "Got error #{e.inspect}, closing connection"
+  $machine.close(fd) rescue nil
+end
+
+main = Fiber.current
+trap('SIGINT') { $machine.spin { $machine.schedule(main, SystemExit.new) } }
+
+$machine.accept_each(server_fd) do |fd|
+  puts "Connection accepted fd #{fd}"
+  $machine.spin(fd) { handle_connection(_1) }
+end

data/ext/um/extconf.rb

@@ -6,6 +6,61 @@ require 'rbconfig'
 
 dir_config 'um_ext'
 
+def config_ssl
+  # don't use pkg_config('openssl') if '--with-openssl-dir' is used
+  has_openssl_dir = dir_config('openssl').any? ||
+    RbConfig::CONFIG['configure_args']&.include?('openssl')
+
+  found_pkg_config = !has_openssl_dir && pkg_config('openssl')
+
+  found_ssl = if !$mingw && found_pkg_config
+    puts '──── Using OpenSSL pkgconfig (openssl.pc) ────'
+    true
+  elsif have_library('libcrypto', 'BIO_read') && have_library('libssl', 'SSL_CTX_new')
+    true
+  elsif %w'crypto libeay32'.find {|crypto| have_library(crypto, 'BIO_read')} &&
+      %w'ssl ssleay32'.find {|ssl| have_library(ssl, 'SSL_CTX_new')}
+    true
+  else
+    puts '** Puma will be compiled without SSL support'
+    false
+  end
+
+  if found_ssl
+    have_header "openssl/bio.h"
+
+    ssl_h = "openssl/ssl.h".freeze
+
+    puts "\n──── Below are yes for 1.0.2 & later ────"
+    have_func "DTLS_method"                            , ssl_h
+    have_func "SSL_CTX_set_session_cache_mode(NULL, 0)", ssl_h
+
+    puts "\n──── Below are yes for 1.1.0 & later ────"
+    have_func "TLS_server_method"                      , ssl_h
+    have_func "SSL_CTX_set_min_proto_version(NULL, 0)" , ssl_h
+
+    puts "\n──── Below is yes for 1.1.0 and later, but isn't documented until 3.0.0 ────"
+    # https://github.com/openssl/openssl/blob/OpenSSL_1_1_0/include/openssl/ssl.h#L1159
+    have_func "SSL_CTX_set_dh_auto(NULL, 0)"           , ssl_h
+
+    puts "\n──── Below is yes for 1.1.1 & later ────"
+    have_func "SSL_CTX_set_ciphersuites(NULL, \"\")"   , ssl_h
+
+    puts "\n──── Below is yes for 3.0.0 & later ────"
+    have_func "SSL_get1_peer_certificate"              , ssl_h
+
+    puts ''
+
+    # Random.bytes available in Ruby 2.5 and later, Random::DEFAULT deprecated in 3.0
+    if Random.respond_to?(:bytes)
+      $defs.push "-DHAVE_RANDOM_BYTES"
+      puts "checking for Random.bytes... yes"
+    else
+      puts "checking for Random.bytes... no"
+    end
+  end
+end
+
 KERNEL_INFO_RE = /Linux (\d)\.(\d+)(?:\.)?((?:\d+\.?)*)(?:\-)?([\w\-]+)?/
 def get_config
   if RUBY_PLATFORM !~ /linux/
@@ -35,6 +90,8 @@ def get_config
   }
 end
 
+config_ssl
+
 config = get_config
 puts "Building UringMachine (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"
 

data/ext/um/um.c

@@ -5,7 +5,6 @@ void um_setup(VALUE self, struct um *machine) {
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
-  RB_OBJ_WRITE(self, &machine->poll_fiber, Qnil);
 
   unsigned prepared_limit = 4096;
   unsigned flags = IORING_SETUP_SUBMIT_ALL | IORING_SETUP_COOP_TASKRUN;
@@ -76,7 +75,7 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
   if (unlikely((cqe->res == -ECANCELED) && (op->flags & OP_F_IGNORE_CANCELED))) return;
 
   op->flags |= OP_F_COMPLETED;
-  if (unlikely(op->flags & OP_F_TRANSIENT))
+  if (op->flags & OP_F_TRANSIENT)
     um_op_transient_remove(machine, op);
 
   if (op->flags & OP_F_MULTISHOT) {
@@ -89,7 +88,8 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
     op->result.flags  = cqe->flags;
   }
 
-  um_runqueue_push(machine, op);
+  if (!(op->flags & OP_F_ASYNC))
+    um_runqueue_push(machine, op);
 }
 
 // copied from liburing/queue.c
@@ -181,7 +181,7 @@ inline VALUE um_fiber_switch(struct um *machine) {
   }
 }
 
-static inline void um_submit_cancel_op(struct um *machine, struct um_op *op) {
+void um_submit_cancel_op(struct um *machine, struct um_op *op) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
   io_uring_prep_cancel64(sqe, (long long)op, 0);
 }
@@ -261,7 +261,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   static ID ID_new = 0;
   if (!ID_new) ID_new = rb_intern("new");
 
-  struct um_op *op = malloc(sizeof(struct um_op));
+  struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_TIMEOUT);
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());

data/ext/um/um.h

@@ -1,7 +1,7 @@
 #ifndef UM_H
 #define UM_H
 
-#include "ruby.h"
+#include <ruby.h>
 #include <liburing.h>
 
 // debugging
@@ -48,8 +48,9 @@ enum op_kind {
 
 #define OP_F_COMPLETED        (1U << 0)
 #define OP_F_TRANSIENT        (1U << 1)
-#define OP_F_IGNORE_CANCELED  (1U << 2)
-#define OP_F_MULTISHOT        (1U << 3)
+#define OP_F_ASYNC            (1U << 2)
+#define OP_F_IGNORE_CANCELED  (1U << 3)
+#define OP_F_MULTISHOT        (1U << 4)
 
 struct um_op_result {
   __s32 res;
@@ -66,6 +67,7 @@ struct um_op {
 
   VALUE fiber;
   VALUE value;
+  VALUE async_op;
 
   struct um_op_result result;
   struct um_op_result *multishot_result_tail;
@@ -93,7 +95,6 @@ struct buf_ring_descriptor {
 
 struct um {
   VALUE self;
-  VALUE poll_fiber;
 
   struct um_buffer *buffer_freelist;
 
@@ -137,10 +138,19 @@ struct um_queue {
   uint32_t count;
 };
 
+struct um_async_op {
+  VALUE self;
+
+  struct um *machine;
+  struct um_op *op;
+};
+
 extern VALUE cUM;
 extern VALUE cMutex;
 extern VALUE cQueue;
+extern VALUE cAsyncOp;
 
+struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine);
 void um_teardown(struct um *machine);
 
@@ -179,6 +189,7 @@ struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
+void um_submit_cancel_op(struct um *machine, struct um_op *op);
 void um_cancel_and_wait(struct um *machine, struct um_op *op);
 int um_check_completion(struct um *machine, struct um_op *op);
 
@@ -207,6 +218,12 @@ VALUE um_listen(struct um *machine, int fd, int backlog);
 VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
 VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value);
 
+void um_async_op_set(VALUE self, struct um *machine, struct um_op *op);
+VALUE um_async_op_await(struct um_async_op *async_op);
+void um_async_op_cancel(struct um_async_op *async_op);
+
+VALUE um_prep_timeout(struct um *machine, double interval);
+
 struct um_mutex *Mutex_data(VALUE self);
 struct um_queue *Queue_data(VALUE self);
 
@@ -224,4 +241,6 @@ VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
 void um_define_net_constants(VALUE mod);
 
+// void Init_micro_ssl(VALUE mod);
+
 #endif // UM_H

data/ext/um/um_async_op.c

@@ -0,0 +1,40 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE um_prep_timeout(struct um *machine, double interval) {
+  static ID ID_new = 0;
+  if (!ID_new) ID_new = rb_intern("new");
+
+  struct um_op *op = malloc(sizeof(struct um_op));
+  um_prep_op(machine, op, OP_TIMEOUT);
+  op->ts = um_double_to_timespec(interval);
+  op->flags = OP_F_TRANSIENT | OP_F_ASYNC;
+
+  VALUE obj = rb_funcall(cAsyncOp, rb_intern_const("new"), 0);
+  um_async_op_set(obj, machine, op);
+
+  RB_OBJ_WRITE(machine->self, &op->async_op, obj);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
+
+  um_op_transient_add(machine, op);
+
+  return obj;
+}
+
+VALUE um_async_op_await(struct um_async_op *async_op) {
+  RB_OBJ_WRITE(async_op->machine->self, &async_op->op->fiber, rb_fiber_current());
+  async_op->op->flags &= ~OP_F_ASYNC;
+
+  VALUE ret = um_fiber_switch(async_op->machine);
+  if (!um_op_completed_p(async_op->op))
+    um_cancel_and_wait(async_op->machine, async_op->op);
+
+  raise_if_exception(ret);
+  return INT2NUM(async_op->op->result.res);
+}
+
+void um_async_op_cancel(struct um_async_op *async_op) {
+  um_submit_cancel_op(async_op->machine, async_op->op);
+}

data/ext/um/um_async_op_class.c

@@ -0,0 +1,136 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE cAsyncOp;
+
+VALUE SYM_timeout;
+
+static void AsyncOp_mark(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  rb_gc_mark_movable(async_op->self);
+  rb_gc_mark_movable(async_op->machine->self);
+}
+
+static void AsyncOp_compact(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  async_op->self = rb_gc_location(async_op->self);
+}
+
+static size_t AsyncOp_size(const void *ptr) {
+  return sizeof(struct um_async_op);
+}
+
+static void AsyncOp_free(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  um_op_free(async_op->machine, async_op->op);
+  free(ptr);
+}
+
+static const rb_data_type_t AsyncOp_type = {
+    "UringMachine::AsyncOp",
+    {AsyncOp_mark, AsyncOp_free, AsyncOp_size, AsyncOp_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE AsyncOp_allocate(VALUE klass) {
+  struct um_async_op *async_op = malloc(sizeof(struct um_async_op));
+  return TypedData_Wrap_Struct(klass, &AsyncOp_type, async_op);
+}
+
+inline struct um_async_op *AsyncOp_data(VALUE self) {
+  return RTYPEDDATA_DATA(self);
+}
+
+VALUE AsyncOp_initialize(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  memset(async_op, 0, sizeof(struct um_async_op));
+  async_op->self = self;
+  return self;
+}
+
+void um_async_op_set(VALUE self, struct um *machine, struct um_op *op) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  async_op->machine = machine;
+  async_op->op = op;
+}
+
+inline void raise_on_missing_op(struct um_async_op *async_op) {
+  if (!async_op->op)
+    rb_raise(rb_eRuntimeError, "Missing op");
+}
+
+inline int async_op_is_done(struct um_async_op *async_op) {
+  return (async_op->op->flags & OP_F_COMPLETED);
+}
+
+VALUE AsyncOp_kind(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  switch(async_op->op->kind) {
+    case OP_TIMEOUT:
+      return SYM_timeout;
+    default:
+      rb_raise(rb_eRuntimeError, "Invalid op kind");
+  }
+}
+
+VALUE AsyncOp_done_p(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  return async_op_is_done(async_op) ? Qtrue : Qfalse;
+}
+
+VALUE AsyncOp_result(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  return async_op_is_done(async_op) ? INT2NUM(async_op->op->result.res) : Qnil;
+}
+
+VALUE AsyncOp_cancelled_p(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (!async_op_is_done(async_op)) return Qnil;
+
+  return (async_op->op->result.res == -ECANCELED) ? Qtrue : Qfalse;
+}
+
+VALUE AsyncOp_await(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (async_op_is_done(async_op))
+    return INT2NUM(async_op->op->result.res);
+
+  return um_async_op_await(async_op);
+}
+
+VALUE AsyncOp_cancel(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (!async_op_is_done(async_op))
+    um_async_op_cancel(async_op);
+
+  return self;
+}
+
+void Init_AsyncOp(void) {
+  cAsyncOp = rb_define_class_under(cUM, "AsyncOp", rb_cObject);
+  rb_define_alloc_func(cAsyncOp, AsyncOp_allocate);
+
+  rb_define_method(cAsyncOp, "initialize", AsyncOp_initialize, 0);
+  rb_define_method(cAsyncOp, "kind", AsyncOp_kind, 0);
+  rb_define_method(cAsyncOp, "done?", AsyncOp_done_p, 0);
+  rb_define_method(cAsyncOp, "result", AsyncOp_result, 0);
+  rb_define_method(cAsyncOp, "cancelled?", AsyncOp_cancelled_p, 0);
+
+  rb_define_method(cAsyncOp, "await", AsyncOp_await, 0);
+  rb_define_method(cAsyncOp, "join", AsyncOp_await, 0);
+  rb_define_method(cAsyncOp, "cancel", AsyncOp_cancel, 0);
+
+  SYM_timeout = ID2SYM(rb_intern("timeout"));
+}