uringmachine 0.30.0 → 0.31.0

data/benchmark/openssl.rb

@@ -24,54 +24,82 @@ Socket.do_not_reverse_lookup = true
 tcps = TCPServer.new("127.0.0.1", 0)
 port = tcps.connect_address.ip_port
 
-ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
-
-Thread.new do
-  Thread.current.report_on_exception = false
-  loop do
-    begin
-      ssl = ssls.accept
-    rescue OpenSSL::SSL::SSLError, IOError, Errno::EBADF, Errno::EINVAL,
-           Errno::ECONNABORTED, Errno::ENOTSOCK, Errno::ECONNRESET
-      retry
-    end
-
-    Thread.new do
-      Thread.current.report_on_exception = false
+pid = fork do
+  ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
 
+  Thread.new do
+    Thread.current.report_on_exception = false
+    loop do
       begin
-        while line = ssl.gets
-          ssl.write(line)
+        ssl = ssls.accept
+      rescue OpenSSL::SSL::SSLError, IOError, Errno::EBADF, Errno::EINVAL,
+             Errno::ECONNABORTED, Errno::ENOTSOCK, Errno::ECONNRESET
+        retry
+      end
+
+      Thread.new do
+        Thread.current.report_on_exception = false
+
+        begin
+          while line = ssl.gets
+            ssl.write(line)
+          end
+        ensure
+          ssl.close
         end
-      ensure
-        ssl.close
+        true
       end
-      true
     end
   end
+  sleep
+rescue Interrupt
 end
 
-@ssl_stock = OpenSSL::SSL::SSLSocket.open("127.0.0.1", port)
+at_exit {
+  Process.kill('SIGINT', pid)
+  Process.wait(pid)
+}
+
+begin
+  @ssl_stock = OpenSSL::SSL::SSLSocket.open("127.0.0.1", port)
+rescue => e
+  p e
+  exit!
+end
 @ssl_stock.sync_close = true
 @ssl_stock.connect
 
-um = UM.new
+@um = UM.new
 
 @ssl_um = OpenSSL::SSL::SSLSocket.open("127.0.0.1", port)
 @ssl_um.sync_close = true
-um.ssl_set_bio(@ssl_um)
+@um.ssl_set_bio(@ssl_um)
 @ssl_um.connect
 
+@ssl_conn = OpenSSL::SSL::SSLSocket.open("127.0.0.1", port)
+@ssl_conn.sync_close = true
+@um.ssl_set_bio(@ssl_conn)
+@ssl_conn.connect
+
+@conn = @um.connection(@ssl_conn, :ssl)
+
 @msg = 'abc' * 1000
+@msg_newline = @msg + "\n"
 
 def do_io(ssl)
   ssl.puts @msg
   ssl.gets
 end
 
+def do_io_connection(ssl, um, conn)
+  um.ssl_write(ssl, @msg_newline, 0)
+  conn.read_line(0)
+end
+
 Benchmark.ips do |x|
   x.report('stock') { do_io(@ssl_stock) }
   x.report('UM BIO') { do_io(@ssl_um) }
+  x.report('UM Stream') { do_io_connection(@ssl_conn, @um, @conn) }
 
   x.compare!(order: :baseline)
 end

data/docs/design/buffer_pool.md

@@ -78,7 +78,7 @@ buffers, to using managed buffers from the buffer pool.
   ```ruby
   machine.stream_recv(fd) do |stream|
     loop do
-      line = stream.get_line(max: 60)
+      line = stream.read_line(max: 60)
       if (size = parse_size(line))
         data = stream.read(size)
         process_data(data)

data/examples/fiber_concurrency_io.rb

@@ -0,0 +1,52 @@
+@runqueue = []
+@active_reads = {}; @active_timers = {}
+
+def fiber_switch
+  while true
+    next_fiber, value = @runqueue.shift
+    return next_fiber.transfer value if next_fiber
+
+    process_events
+  end
+end
+
+def process_events
+  shortest_timeout = @active_timers.values.min - Time.now
+  process_reads(shortest_timeout)
+  now = Time.now
+  @active_timers.select { |_, t| t <= now }.keys.each {
+    @runqueue << it
+    @active_timers.delete(it)
+  }
+end
+
+def process_reads(timeout)
+  r, _ = IO.select(@active_reads.keys, [], [], timeout)
+  r&.each { |io|
+    @runqueue << [@active_reads[io], io.readpartial(256)]
+    @active_reads.delete(io)
+  }
+end
+
+def do_read(io)
+  @active_reads[io] = Fiber.current
+  fiber_switch
+end
+
+def do_sleep(time)
+  fiber = Fiber.current
+  @active_timers[fiber] = Time.now + time
+  fiber_switch
+end
+
+@runqueue << Fiber.new {
+  input = do_read(STDIN)
+  puts "Got: #{input}"
+}
+
+@runqueue << Fiber.new {
+  do_sleep(5)
+  puts "5 seconds have elapsed!"
+}
+
+fiber_switch

data/examples/fiber_concurrency_naive.rb

@@ -0,0 +1,26 @@
+@fiber1 = Fiber.new {
+  count = 0
+  # read from STDIN
+  while true
+    count += 1
+    input = STDIN.read_nonblock(256, exception: false)
+    if input == :wait_readable
+      @fiber2.transfer
+    else
+      break
+    end
+  end
+  puts "Got: #{input} after #{count} tries"
+}
+
+@fiber2 = Fiber.new {
+  last = Time.now
+
+  # sleep
+  while Time.now < last + 5
+    @fiber1.transfer
+  end
+  STDOUT << "5 seconds have elapsed!\n"
+}
+
+@fiber1.transfer

data/examples/fiber_concurrency_runqueue.rb

@@ -0,0 +1,33 @@
+@runqueue = []
+def fiber_switch
+  next_fiber = @runqueue.shift
+  @runqueue << Fiber.current
+  next_fiber.transfer
+end
+
+@runqueue << Fiber.new {
+  count = 0
+  # read from STDIN
+  while true
+    count += 1
+    input = STDIN.read_nonblock(256, exception: false)
+    if input == :wait_readable
+      fiber_switch
+    else
+      break
+    end
+  end
+  puts "Got: #{input} after #{count} tries"
+}
+
+@runqueue << Fiber.new {
+  last = Time.now
+
+  # sleep
+  while Time.now < last + 10
+    fiber_switch
+  end
+  STDOUT << "10 seconds have elapsed!\n"
+}
+
+@runqueue.shift.transfer

data/examples/io_uring_simple.c

@@ -0,0 +1,24 @@
+#include <liburing.h>
+
+struct io_uring ring;
+struct io_uring_sqe *sqe;
+struct io_uring_cqe *cqe;
+int ret;
+char buf[100];
+
+ret = io_uring_queue_init(8, &ring, 0);
+sqe = io_uring_get_sqe(&ring);
+io_uring_prep_read(sqe, STDIN_FILENO, buf, 100, 0);
+sqe->user_data = 42;
+io_uring_submit(&ring);
+
+...
+
+ret = io_uring_wait_cqe(&ring, &cqe);
+if (!ret) {
+  if (cqe->user_data == 42) {
+    int len = cqe->res;
+    printf("Got: %d\n", len);
+  }
+  io_uring_cqe_seen(&ring, cqe);
+}

data/examples/pg.rb

@@ -66,9 +66,9 @@ $machine.listen(server_fd, UM::SOMAXCONN)
 puts 'Listening on port 1234'
 
 def handle_connection(fd)
-  stream = UM::Stream.new($machine, fd)
+  conn = UM::Connection.new($machine, fd)
 
-  while (l = stream.gets)
+  while (l = conn.gets)
     $machine.write(fd, "You said: #{l}")
   end
 rescue Exception => e

data/examples/stream.rb

@@ -66,9 +66,9 @@ $machine.listen(server_fd, UM::SOMAXCONN)
 puts 'Listening on port 1234'
 
 def handle_connection(fd)
-  stream = UM::Stream.new($machine, fd)
+  conn = UM::Stream.new($machine, fd)
 
-  while (l = stream.gets)
+  while (l = conn.gets)
     $machine.write(fd, "You said: #{l}")
   end
 rescue Exception => e

data/ext/um/um.c

@@ -652,11 +652,11 @@ 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) {
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t len) {
   struct um_op *op = um_op_acquire(machine);
   um_prep_op(machine, op, OP_WRITE, 2, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_write(sqe, fd, buffer, maxlen, 0);
+  io_uring_prep_write(sqe, fd, buffer, len, 0);
 
   int res = 0;
   VALUE ret = um_yield(machine);
@@ -831,6 +831,23 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags) {
   return ret;
 }
 
+size_t um_send_raw(struct um *machine, int fd, const char *buffer, size_t len, int flags) {
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_SEND, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_send(sqe, fd, buffer, len, flags);
+
+  int res = 0;
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, true))) res = op->result.res;
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return res;
+}
+
 // for some reason we don't get this define from liburing/io_uring.h
 #define IORING_SEND_VECTORIZED		(1U << 5)
 
@@ -1478,7 +1495,7 @@ int read_recv_each_multishot_process_result(struct op_ctx *ctx, struct um_op_res
     return false;
 
   *total += result->res;
-  VALUE buf = um_get_string_from_buffer_ring(ctx->machine, ctx->bgid, result->res, result->flags);
+  VALUE buf = um_read_from_buffer_ring(ctx->machine, ctx->bgid, result->res, result->flags);
   rb_yield(buf);
   RB_GC_GUARD(buf);
 

data/ext/um/um.h

@@ -80,12 +80,12 @@ enum um_op_kind {
   OP_TIMEOUT_MULTISHOT,
 };
 
-enum um_stream_mode {
-  STREAM_BP_READ,
-  STREAM_BP_RECV,
-  STREAM_SSL,
-  STREAM_STRING,
-  STREAM_IO_BUFFER
+enum um_connection_mode {
+  CONNECTION_FD,
+  CONNECTION_SOCKET,
+  CONNECTION_SSL,
+  CONNECTION_STRING,
+  CONNECTION_IO_BUFFER
 };
 
 #define OP_F_CQE_SEEN       (1U << 0) // CQE has been seen
@@ -272,11 +272,11 @@ struct um_async_op {
   struct um_op *op;
 };
 
-struct um_stream {
+struct um_connection {
   VALUE self;
   struct um *machine;
 
-  enum um_stream_mode mode;
+  enum um_connection_mode mode;
   union {
     int fd;
     VALUE target;
@@ -304,7 +304,7 @@ extern VALUE eUMError;
 extern VALUE cMutex;
 extern VALUE cQueue;
 extern VALUE cAsyncOp;
-extern VALUE eStreamRESPError;
+extern VALUE eConnectionRESPError;
 
 struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec, int sidecar_mode);
@@ -352,7 +352,7 @@ int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *siz
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
 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);
+VALUE um_read_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);
 struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *total_len);
 void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv);
@@ -378,7 +378,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);
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t len);
 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);
@@ -403,6 +403,7 @@ VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue);
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags);
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen);
 VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags);
+size_t um_send_raw(struct um *machine, int fd, const char *buffer, size_t len, int flags);
 VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags);
@@ -437,13 +438,16 @@ VALUE um_queue_pop(struct um *machine, struct um_queue *queue);
 VALUE um_queue_unshift(struct um *machine, struct um_queue *queue, VALUE value);
 VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
-void stream_teardown(struct um_stream *stream);
-void stream_clear(struct um_stream *stream);
-VALUE stream_get_line(struct um_stream *stream, VALUE buf, size_t maxlen);
-VALUE stream_get_string(struct um_stream *stream, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
-void stream_skip(struct um_stream *stream, size_t inc, int safe_inc);
-void stream_each(struct um_stream *stream);
-VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
+void connection_teardown(struct um_connection *conn);
+void connection_clear(struct um_connection *conn);
+VALUE connection_read_line(struct um_connection *conn, VALUE out_buffer, size_t maxlen);
+VALUE connection_read(struct um_connection *conn, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
+VALUE connection_read_to_delim(struct um_connection *conn, VALUE out_buffer, VALUE delim, ssize_t maxlen);
+void connection_skip(struct um_connection *conn, size_t inc, int safe_inc);
+void connection_read_each(struct um_connection *conn);
+size_t connection_write_raw(struct um_connection *conn, const char *buffer, size_t len);
+VALUE connection_writev(struct um_connection *conn, int argc, VALUE *argv);
+VALUE resp_read(struct um_connection *conn, 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);
 
@@ -463,6 +467,8 @@ void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
 int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, size_t maxlen);
 int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, size_t maxlen);
 int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, size_t len);
+int um_ssl_write_raw(struct um *machine, VALUE ssl, const char *buffer, size_t len);
+int um_ssl_writev(struct um *machine, VALUE ssl, int argc, VALUE *argv);
 
 void bp_setup(struct um *machine);
 void bp_teardown(struct um *machine);