uringmachine 0.29.2 → 0.31.0

data/benchmark/http_parse.rb

@@ -62,10 +62,10 @@ end
 
 require 'stringio'
 
-RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/1\.1)/i
 RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
 
-def get_line(fd, sio, buffer)
+def read_line(fd, sio, buffer)
   while true
     line = sio.gets(chomp: true)
     return line if line
@@ -76,7 +76,7 @@ def get_line(fd, sio, buffer)
 end
 
 def get_request_line(fd, sio, buffer)
-  line = get_line(fd, sio, buffer)
+  line = read_line(fd, sio, buffer)
 
   m = line.match(RE_REQUEST_LINE)
   return nil if !m
@@ -96,7 +96,7 @@ def parse_headers(fd)
   return nil if !headers
 
   while true
-    line = get_line(fd, sio, buffer)
+    line = read_line(fd, sio, buffer)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -129,15 +129,15 @@ ensure
   ($machine.close(wfd) rescue nil) if wfd
 end
 
-def stream_parse_headers(fd)
-  stream = UM::Stream.new($machine, fd)
+def connection_parse_headers(fd)
+  conn = UM::Connection.new($machine, fd)
 
   buf = String.new(capacity: 65536)
-  headers = stream_get_request_line(stream, buf)
+  headers = connection_get_request_line(conn, buf)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = conn.read_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -149,8 +149,8 @@ def stream_parse_headers(fd)
   headers
 end
 
-def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+def connection_get_request_line(conn, buf)
+  line = conn.read_line(0)
 
   m = line.match(RE_REQUEST_LINE)
   return nil if !m
@@ -162,12 +162,12 @@ def stream_get_request_line(stream, buf)
   }
 end
 
-def parse_http_stream
+def parse_http_connection
   rfd, wfd = UM.pipe
   queue = UM::Queue.new
 
   $machine.spin do
-    headers = stream_parse_headers(rfd)
+    headers = connection_parse_headers(rfd)
     $machine.push(queue, headers)
   rescue Exception => e
     p e
@@ -188,7 +188,7 @@ def compare_allocs
   p(
     alloc_http_parser:  alloc_count { x.times { parse_http_parser } },
     alloc_stringio:     alloc_count { x.times { parse_http_stringio } },
-    alloc_stream:       alloc_count { x.times { parse_http_stream } }
+    alloc_connection:   alloc_count { x.times { parse_http_connection } }
   )
 ensure
   GC.enable
@@ -213,8 +213,8 @@ def benchmark
     x.config(:time => 5, :warmup => 3)
 
     x.report("http_parser") { parse_http_parser }
-    x.report("stringio") { parse_http_stringio }
-    x.report("stream") { parse_http_stream }
+    x.report("stringio")    { parse_http_stringio }
+    x.report("connection")  { parse_http_connection }
 
     x.compare!
   end

data/benchmark/http_server_accept_queue.rb

@@ -12,8 +12,8 @@ require 'uringmachine'
 RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
 RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
 
-def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+def connection_get_request_line(conn, buf)
+  line = conn.read_line(0)
   m = line&.match(RE_REQUEST_LINE)
   return nil if !m
 
@@ -26,12 +26,12 @@ end
 
 class InvalidHeadersError < StandardError; end
 
-def get_headers(stream, buf)
-  headers = stream_get_request_line(stream, buf)
+def get_headers(conn, buf)
+  headers = connection_get_request_line(conn, buf)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = conn.read_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -51,17 +51,21 @@ def send_response(machine, fd)
 end
 
 def handle_connection(machine, fd)
-  stream = UM::Stream.new(machine, fd)
+  conn = UM::Connection.new(machine, fd)
   buf = String.new(capacity: 65536)
 
   while true
-    headers = get_headers(stream, buf)
+    headers = get_headers(conn, buf)
     break if !headers
 
     send_response(machine, fd)
   end
 rescue InvalidHeadersError, SystemCallError => e
   # ignore
+rescue => e
+  p e
+  p e.backtrace
+  exit!
 ensure
   machine.close_async(fd)
 end

data/benchmark/http_server_multi_accept.rb

@@ -12,8 +12,8 @@ require 'uringmachine'
 RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
 RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
 
-def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+def connection_get_request_line(conn, buf)
+  line = conn.read_line(0)
   m = line&.match(RE_REQUEST_LINE)
   return nil if !m
 
@@ -26,12 +26,12 @@ end
 
 class InvalidHeadersError < StandardError; end
 
-def get_headers(stream, buf)
-  headers = stream_get_request_line(stream, buf)
+def get_headers(conn, buf)
+  headers = connection_get_request_line(conn, buf)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = conn.read_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -51,11 +51,11 @@ def send_response(machine, fd)
 end
 
 def handle_connection(machine, fd)
-  stream = UM::Stream.new(machine, fd)
+  conn = UM::Connection.new(machine, fd)
   buf = String.new(capacity: 65536)
 
   while true
-    headers = get_headers(stream, buf)
+    headers = get_headers(conn, buf)
     break if !headers
 
     send_response(machine, fd)

data/benchmark/http_server_multi_ractor.rb

@@ -12,8 +12,8 @@ require 'uringmachine'
 RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
 RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
 
-def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+def connection_get_request_line(conn, buf)
+  line = conn.read_line(0)
   m = line&.match(RE_REQUEST_LINE)
   return nil if !m
 
@@ -26,12 +26,12 @@ end
 
 class InvalidHeadersError < StandardError; end
 
-def get_headers(stream, buf)
-  headers = stream_get_request_line(stream, buf)
+def get_headers(conn, buf)
+  headers = connection_get_request_line(conn, buf)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = conn.read_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -53,11 +53,11 @@ end
 
 def handle_connection(machine, fd)
   machine.setsockopt(fd, UM::IPPROTO_TCP, UM::TCP_NODELAY, true)
-  stream = UM::Stream.new(machine, fd)
+  conn = UM::Connection.new(machine, fd)
   buf = String.new(capacity: 65536)
 
   while true
-    headers = get_headers(stream, buf)
+    headers = get_headers(conn, buf)
     break if !headers
 
     send_response(machine, fd)

data/benchmark/http_server_single_thread.rb

@@ -12,8 +12,8 @@ require 'uringmachine'
 RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
 RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
 
-def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+def connection_get_request_line(conn, buf)
+  line = conn.read_line(0)
   m = line&.match(RE_REQUEST_LINE)
   return nil if !m
 
@@ -26,12 +26,12 @@ end
 
 class InvalidHeadersError < StandardError; end
 
-def get_headers(stream, buf)
-  headers = stream_get_request_line(stream, buf)
+def get_headers(conn, buf)
+  headers = connection_get_request_line(conn, buf)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = conn.read_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -52,11 +52,11 @@ end
 
 def handle_connection(machine, fd)
   machine.setsockopt(fd, UM::IPPROTO_TCP, UM::TCP_NODELAY, true)
-  stream = UM::Stream.new(machine, fd)
+  conn = UM::Connection.new(machine, fd)
   buf = String.new(capacity: 65536)
 
   while true
-    headers = get_headers(stream, buf)
+    headers = get_headers(conn, buf)
     break if !headers
 
     send_response(machine, fd)

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)
 
@@ -1285,6 +1302,57 @@ VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned in
   return statx_to_hash(&stat);
 }
 
+VALUE um_splice(struct um *machine, int in_fd, int out_fd, uint nbytes) {
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_SPLICE, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_splice(sqe, in_fd, -1, out_fd, -1, nbytes, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, false))) ret = INT2NUM(op->result.res);
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+
+  return ret;
+}
+
+VALUE um_tee(struct um *machine, int in_fd, int out_fd, uint nbytes) {
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_TEE, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_tee(sqe, in_fd, out_fd, nbytes, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, false))) ret = INT2NUM(op->result.res);
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+
+  return ret;
+}
+
+VALUE um_fsync(struct um *machine, int fd) {
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_FSYNC, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_fsync(sqe, fd, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, false))) ret = INT2NUM(op->result.res);
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+
+  return ret;
+}
+
 /*******************************************************************************
                             multishot ops
 *******************************************************************************/
@@ -1427,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);