uringmachine 0.10 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85de1c3c67da5ef2a64b64a0370312208009683e9a42504bfbd7577bb6bee9f7
-  data.tar.gz: 13a34495c1987c85891ee5db9c196fbf09b6ebcd9a2221026341023e63e5a8e8
+  metadata.gz: ccb8488c3f313b7a3890ae110fc5cebc7ac0062bbaa9ef362fb7ff5b02c680b9
+  data.tar.gz: 41f2c23a9427609c4d01a6eef319cbd40d029cf85918fd6c8d00e5b502f83ef6
 SHA512:
-  metadata.gz: 7b10f6a2c6e4d0bccaebb75c50e702ca0126eeb712a25ac32631b21ddcafd550dcceab2028a4f1a9b380538aa19067e0fa08346137a760307193af0acef64ed1
-  data.tar.gz: 0dc3949e9256f139cc1caab14b2de6b63e16af61c569de59b761153d8d05a2030bad0e299ca9044452cc628fd25accff8fe3e89c59e6d4c053f049339ddce2c3
+  metadata.gz: 9bd08ebae21a7a10407ff04102d9cbf491bfab65ebe601b6ab3a6b7790632c946873415af4f45321e959bd39e875ff386e8c85f74329743204a9c0c047ce5da0
+  data.tar.gz: 3cd63222c0b990ef83f2b324aa46b36bd142a7b43a1a273428a9b70a95cfe25e0a1b06a2985a7463fe51a995c78e82838e34ee20d3c332cc46278ffd738652dd

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2025-06-02 Version 0.11.1
+
+- Fix `UM::Stream` behaviour on GC
+
+# 2025-06-02 Version 0.11
+
+- Implement `UM::Stream` class for read streams
+
 # 2025-05-05 Version 0.10
 
 - Add `Thread#machine`

data/examples/bm_http_parse.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'bundler/inline'
+# require 'bundler/inline'
 
-gemfile do
-  source 'https://rubygems.org'
-  gem 'uringmachine', path: '..'
-  gem 'benchmark-ips'
-  gem 'http_parser.rb'
-end
+# gemfile do
+#   source 'https://rubygems.org'
+#   gem 'uringmachine', path: '..'
+#   gem 'benchmark-ips'
+#   gem 'http_parser.rb'
+# end
 
-require 'benchmark/ips'
+require 'bundler/setup'
 require 'uringmachine'
+require 'benchmark/ips'
 require 'http/parser'
 
 $machine = UM.new
@@ -19,6 +20,8 @@ HTTP_MSG = "GET /foo/bar HTTP/1.1\r\nServer: foobar.com\r\nFoo: bar\r\n\r\n"
 
 $count = 0
 
+STDOUT.sync = true
+
 def parse_http_parser
   current_fiber = Fiber.current
   $count += 1
@@ -45,10 +48,16 @@ def parse_http_parser
   end
 
   $machine.write(w.fileno, HTTP_MSG)
-  $machine.yield
+  ret = $machine.yield
+  ret
+rescue Exception => e
+  p e: e
+  exit
 ensure
-  $machine.close(r.fileno)
-  $machine.close(w.fileno)
+  r.close rescue nil
+  w.close rescue nil
+  # $machine.close(r.fileno) rescue nil
+  # $machine.close(w.fileno) rescue nil
 end
 
 require 'stringio'
@@ -100,50 +109,114 @@ def parse_headers(fd)
 end
 
 def parse_http_stringio
-  current_fiber = Fiber.current
-  r, w = IO.pipe
+  rfd, wfd = UM.pipe
+  queue = UM::Queue.new
 
   $machine.spin do
-    headers = parse_headers(r.fileno)
-    $machine.schedule(current_fiber, headers)
+    headers = parse_headers(rfd)
+    $machine.push(queue, headers)
   rescue Exception => e
     p e
     puts e.backtrace.join("\n")
     exit!
   end
 
-  $machine.write(w.fileno, HTTP_MSG)
-  $machine.yield
+  $machine.write(wfd, HTTP_MSG)
+  $machine.close(wfd)
+  $machine.shift(queue)
 ensure
-  $machine.close(r.fileno)
-  $machine.close(w.fileno)
+  ($machine.close(rfd) rescue nil) if rfd
+  ($machine.close(wfd) rescue nil) if wfd
 end
 
-# p parse_http_parser
-# p parse_http_stringio
-# exit
+def stream_parse_headers(fd)
+  stream = UM::Stream.new($machine, fd)
 
-GC.disable
+  headers = stream_get_request_line(stream)
+  return nil if !headers
 
-def alloc_count
-  count0 = ObjectSpace.count_objects[:TOTAL]
-  yield
-  count1 = ObjectSpace.count_objects[:TOTAL]
-  count1 - count0
+  while true
+    line = stream.get_line()
+    break if line.empty?
+
+    m = line.match(RE_HEADER_LINE)
+    raise "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
 end
 
-X = 100
-p(
-  alloc_http_parser: alloc_count { X.times { parse_http_parser } },
-  alloc_stringio: alloc_count { X.times { parse_http_stringio } }
-)
-exit
+def stream_get_request_line(stream)
+  line = stream.get_line()
+
+  m = line.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+def parse_http_stream
+  rfd, wfd = UM.pipe
+  queue = UM::Queue.new
+
+  $machine.spin do
+    headers = stream_parse_headers(rfd)
+    $machine.push(queue, headers)
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+    exit!
+  end
+
+  $machine.write(wfd, HTTP_MSG)
+  $machine.shift(queue)
+ensure
+  ($machine.close(rfd) rescue nil) if rfd
+  ($machine.close(wfd) rescue nil) if wfd
+end
+
+# 10000.times { parse_http_parser }
+# 10000.times { parse_http_stringio }
+# 10000.times { parse_http_stream }
+# exit
+
+# GC.disable
+
+# OS = ObjectSpace
+
+# def object_count
+#   counts = ObjectSpace.count_objects
+#   counts[:TOTAL] - counts[:FREE]
+# end
+
+# def alloc_count
+#   GC.start
+#   count0 = object_count
+#   yield
+#   count1 = object_count
+#   count1 - count0
+# end
+
+# X = 100
+# 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 } }
+# )
+# exit
 
 Benchmark.ips do |x|
   x.config(:time => 5, :warmup => 3)
 
   x.report("http_parser") { parse_http_parser }
-  x.report("homegrown") { parse_http_stringio }
+  x.report("stringio") { parse_http_stringio }
+  x.report("stream") { parse_http_stream }
 
   x.compare!
 end

data/examples/bm_side_running.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+
+def consume_from_queue(queue)
+  m = UM.new
+  while true
+    response_mailbox, closure = m.shift(queue)
+    result = closure.call
+    m.push(response_mailbox, result)
+  end
+# rescue UM::Terminate
+#   # We can also add a timeout here
+#   t0 = Time.now
+#   while !queue.empty? && (Time.now - t0) < 10
+#     response_mailbox, closure = m.shift(queue)
+#     result = closure.call
+#     m.push(response_mailbox, result)
+#   end
+end
+
+N = 8
+
+$machine = UM.new
+@queue = UM::Queue.new
+@threads = N.times.map { Thread.new { consume_from_queue(@queue) } }
+
+def side_run(&block)
+  mailbox = Fiber.current.mailbox
+  $machine.push(@queue, [mailbox, block])
+  Thread.pass
+  $machine.shift(mailbox)
+end
+
+@rqueue = Queue.new
+@rthreads = N.times.map { Thread.new { r_consume_from_queue(@rqueue) }}
+
+def r_consume_from_queue(queue)
+  m = UM.new
+  while true
+    response_mailbox, closure = @rqueue.shift
+    result = closure.call
+    m.push(response_mailbox, result)
+  end
+# rescue UM::Terminate
+#   # We can also add a timeout here
+#   t0 = Time.now
+#   while !queue.empty? && (Time.now - t0) < 10
+#     response_mailbox, closure = m.shift(queue)
+#     result = closure.call
+#     m.push(response_mailbox, result)
+#   end
+end
+
+def r_side_run(&block)
+  mailbox = Fiber.current.mailbox
+  @rqueue.push([mailbox, block])
+  Thread.pass
+  $machine.shift(mailbox)
+end
+
+# puts '*' * 40
+# p r_side_run { }
+# exit!
+
+Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("side-run") { side_run { } }
+  x.report("r-side-run") { r_side_run { } }
+  # x.report("snoozing") { $machine.snooze }
+
+  x.compare!
+end

data/examples/bm_sqlite.rb

@@ -49,7 +49,7 @@ class UM
   def spin_actor(target)
     f = UM::Actor.new(self, target)
     schedule(f, nil)
-    @@fiber_map[f] = true
+    @@fiber_map[f] = f
     f
   end
 end

data/ext/um/um.c

@@ -356,6 +356,22 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
   return raise_if_exception(ret);
 }
 
+inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_READ);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  io_uring_prep_read(sqe, fd, buffer, maxlen, -1);
+
+  VALUE ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op)) {
+    return op.result.res;
+
+  }
+
+  raise_if_exception(ret);
+  return 0;
+}
+
 VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
   struct um_op op;
   um_prep_op(machine, &op, OP_WRITE);
@@ -575,7 +591,7 @@ VALUE um_waitpid(struct um *machine, int pid, int options) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   siginfo_t infop;
-  io_uring_prep_waitid(sqe, P_PID, pid, &infop, options, 0);
+  io_uring_prep_waitid(sqe, pid == 0 ? P_ALL : P_PID, pid, &infop, options, 0);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))

data/ext/um/um.h

@@ -153,6 +153,24 @@ struct um_async_op {
   struct um_op *op;
 };
 
+struct um_stream {
+  VALUE self;
+
+  struct um *machine;
+  int fd;
+  VALUE buffer;
+  ulong len;
+  ulong pos;
+  int eof;
+};
+
+struct um_write_buffer {
+  VALUE str;
+  size_t capa;
+  size_t len;
+  char *ptr;
+};
+
 extern VALUE cUM;
 extern VALUE cMutex;
 extern VALUE cQueue;
@@ -210,6 +228,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 VALUE um_sleep(struct um *machine, double duration);
 VALUE um_periodically(struct um *machine, double interval);
 VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset);
+size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE str, int len);
 VALUE um_close(struct um *machine, int fd);
@@ -251,6 +270,17 @@ 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);
 
+int stream_read_more(struct um_stream *stream);
+VALUE stream_get_line(struct um_stream *stream);
+VALUE stream_get_string(struct um_stream *stream, ulong len);
+VALUE resp_get_line(struct um_stream *stream, VALUE out_buffer);
+VALUE resp_get_string(struct um_stream *stream, ulong len, VALUE out_buffer);
+VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
+void resp_encode(struct um_write_buffer *buf, VALUE obj);
+
+void write_buffer_init(struct um_write_buffer *buf, VALUE str);
+void write_buffer_update_len(struct um_write_buffer *buf);
+
 void um_define_net_constants(VALUE mod);
 
 #endif // UM_H

data/ext/um/um_ext.c

@@ -3,6 +3,7 @@ void Init_Mutex();
 void Init_Queue();
 void Init_AsyncOp();
 void Init_SSL();
+void Init_Stream();
 
 void Init_um_ext(void) {
   Init_UM();
@@ -10,4 +11,5 @@ void Init_um_ext(void) {
   Init_Queue();
   Init_AsyncOp();
   // Init_SSL();
+  Init_Stream();
 }