uringmachine 0.8.2 → 0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24d5dacdb24cc1da4928d753803bd8012502147aaae23c4c7d9e53945550233c
-  data.tar.gz: 783c8359ae60e149944bd7f79ac588c9b85241f5cec66de11eeae60b92e99753
+  metadata.gz: 8297cccb35ae1c8086889c2400db8bb884b0dfccdbef561caa0a4e9f80b21053
+  data.tar.gz: 990e84bb2f975de00739150cff966bbf97a551ba135714eb92bc3b86cd14b5d0
 SHA512:
-  metadata.gz: 84c77a3826b01acd67bfca663d93e8a8e2a093b7415861040087d7bdcac97f34f3ed829c67529e6dd52abdc0ac88ac8395a0a39315f98fb2966f617c9b8f8dcb
-  data.tar.gz: 238b77b0a4d669b3421d8ce26e888dad76d0885b19405017c1ce2c118f5fb0ac022c4ffed7288ae6389dda6f54810e511e77209bcc8f2e8872aee9a4573fa704
+  metadata.gz: f66149736c1cf58f8df65d387b81ff070fd890e99aa7c8aa806a5afcb04b8248b78c95c1673d30b7d3270c81e05bc0b84afdb025d2a0a2f02beca5977196b321
+  data.tar.gz: 7b6e6c31193da3a1e3e9a6fa627c84ae0f4d35c36f5fa636595acf1a013b71cd419073bb78be04130333796bed05e0ce9d1bfa74ab195608346cd689ecf9abaf

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 2025-06-02 Version 0.11
+
+- Implement `UM::Stream` class for read streams
+
+# 2025-05-05 Version 0.10
+
+- Add `Thread#machine`
+- Add `Fiber#mailbox`
+
+# 2025-05-05 Version 0.9
+
+- Add `#statx`
+
 # 2025-05-05 Version 0.8.2
 
 - Correctly deal with -EAGAIN when waiting for CQEs

data/TODO.md

@@ -10,7 +10,6 @@
 - poll_add / poll_remove / poll_multishot / poll_update
 - fsync
 - mkdir / mkdirat
-- statx
 - link / linkat / unlink / unlinkat / symlink
 - rename / renameat
 - fadvise

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);
@@ -521,7 +537,7 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
 
 #ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
-  um_prep_op(machine, &op, OP_GETSOCKOPT);
+  um_prep_op(machine, &op, OP_SETSOCKOPT);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_SETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
@@ -557,7 +573,7 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
 
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_OPEN);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_open(sqe, StringValueCStr(pathname), flags, mode);
 
@@ -571,11 +587,11 @@ VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
 
 VALUE um_waitpid(struct um *machine, int pid, int options) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_WAITPID);
   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))
@@ -587,6 +603,52 @@ VALUE um_waitpid(struct um *machine, int pid, int options) {
   return rb_ary_new_from_args(2, INT2NUM(infop.si_pid), INT2NUM(infop.si_status));
 }
 
+#define hash_set(h, sym, v) rb_hash_aset(h, ID2SYM(rb_intern(sym)), v)
+
+VALUE statx_to_hash(struct statx *stat) {
+  VALUE hash = rb_hash_new();
+
+  hash_set(hash, "dev",         UINT2NUM(stat->stx_dev_major << 8 | stat->stx_dev_minor));
+  hash_set(hash, "rdev",        UINT2NUM(stat->stx_rdev_major << 8 | stat->stx_rdev_minor));
+  hash_set(hash, "blksize",     UINT2NUM(stat->stx_blksize));
+  hash_set(hash, "attributes",  UINT2NUM(stat->stx_attributes));
+  hash_set(hash, "nlink",       UINT2NUM(stat->stx_nlink));
+  hash_set(hash, "uid",         UINT2NUM(stat->stx_uid));
+  hash_set(hash, "gid",         UINT2NUM(stat->stx_gid));
+  hash_set(hash, "mode",        UINT2NUM(stat->stx_mode));
+  hash_set(hash, "ino",         UINT2NUM(stat->stx_ino));
+  hash_set(hash, "size",        UINT2NUM(stat->stx_size));
+  hash_set(hash, "blocks",      UINT2NUM(stat->stx_blocks));
+  hash_set(hash, "atime",       DBL2NUM(um_timestamp_to_double(stat->stx_atime.tv_sec, stat->stx_atime.tv_nsec)));
+  hash_set(hash, "btime",       DBL2NUM(um_timestamp_to_double(stat->stx_btime.tv_sec, stat->stx_btime.tv_nsec)));
+  hash_set(hash, "ctime",       DBL2NUM(um_timestamp_to_double(stat->stx_ctime.tv_sec, stat->stx_ctime.tv_nsec)));
+  hash_set(hash, "mtime",       DBL2NUM(um_timestamp_to_double(stat->stx_mtime.tv_sec, stat->stx_mtime.tv_nsec)));
+  return hash;
+}
+
+VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_STATX);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+
+  struct statx stat;
+  memset(&stat, 0, sizeof(stat));
+
+  if (NIL_P(path))
+    path = rb_str_new_literal("");
+
+  io_uring_prep_statx(sqe, dirfd, StringValueCStr(path), flags, mask, &stat);
+
+  VALUE ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op))
+    ret = INT2NUM(op.result.res);
+
+  RB_GC_GUARD(ret);
+  raise_if_exception(ret);
+
+  return statx_to_hash(&stat);
+}
+
 /*******************************************************************************
                             multishot ops
 *******************************************************************************/

data/ext/um/um.h

@@ -25,9 +25,12 @@ enum op_kind {
   OP_SCHEDULE,
 
   OP_SLEEP,
+  OP_OPEN,
   OP_READ,
   OP_WRITE,
   OP_CLOSE,
+  OP_STATX,
+
   OP_ACCEPT,
   OP_RECV,
   OP_SEND,
@@ -38,6 +41,8 @@ enum op_kind {
   OP_GETSOCKOPT,
   OP_SETSOCKOPT,
   OP_SHUTDOWN,
+  
+  OP_WAITPID,
 
   OP_FUTEX_WAIT,
   OP_FUTEX_WAKE,
@@ -148,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;
@@ -176,6 +199,7 @@ void um_buffer_checkin(struct um *machine, struct um_buffer *buffer);
 void um_free_buffer_linked_list(struct um *machine);
 
 struct __kernel_timespec um_double_to_timespec(double value);
+double um_timestamp_to_double(__s64 tv_sec, __u32 tv_nsec);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
 
@@ -204,11 +228,13 @@ 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);
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
 VALUE um_waitpid(struct um *machine, int pid, int options);
+VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -244,6 +270,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);
 
+int stream_read_more(struct um_stream *stream);
+
+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_class.c

@@ -130,6 +130,11 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   return um_write(machine, NUM2INT(fd), buffer, bytes);
 }
 
+VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
+  struct um *machine = um_get_machine(self);
+  return um_statx(machine, NUM2INT(dirfd), path, NUM2INT(flags), NUM2UINT(mask));
+}
+
 VALUE UM_close(VALUE self, VALUE fd) {
   struct um *machine = um_get_machine(self);
   return um_close(machine, NUM2INT(fd));
@@ -342,6 +347,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
+  rb_define_method(cUM, "statx", UM_statx, 4);
 
   rb_define_method(cUM, "waitpid", UM_waitpid, 2);
 

data/ext/um/um_const.c

@@ -1,6 +1,7 @@
 #include "ruby.h"
 
 #include <fcntl.h>
+#include <sys/stat.h>
 #include <sys/wait.h>
 
 #include <arpa/inet.h>
@@ -16,6 +17,41 @@
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
 void um_define_net_constants(VALUE mod) {
+  DEF_CONST_INT(mod, AT_FDCWD);
+  DEF_CONST_INT(mod, AT_EMPTY_PATH);
+  DEF_CONST_INT(mod, AT_NO_AUTOMOUNT);
+  DEF_CONST_INT(mod, AT_SYMLINK_NOFOLLOW);
+  DEF_CONST_INT(mod, AT_STATX_SYNC_AS_STAT);
+  DEF_CONST_INT(mod, AT_STATX_FORCE_SYNC);
+  DEF_CONST_INT(mod, AT_STATX_DONT_SYNC);
+
+  DEF_CONST_INT(mod, STATX_TYPE);
+  DEF_CONST_INT(mod, STATX_MODE);
+  DEF_CONST_INT(mod, STATX_NLINK);
+  DEF_CONST_INT(mod, STATX_UID);
+  DEF_CONST_INT(mod, STATX_GID);
+  DEF_CONST_INT(mod, STATX_ATIME);
+  DEF_CONST_INT(mod, STATX_MTIME);
+  DEF_CONST_INT(mod, STATX_CTIME);
+  DEF_CONST_INT(mod, STATX_INO);
+  DEF_CONST_INT(mod, STATX_SIZE);
+  DEF_CONST_INT(mod, STATX_BLOCKS);
+  DEF_CONST_INT(mod, STATX_BASIC_STATS);
+  DEF_CONST_INT(mod, STATX_BTIME);
+  DEF_CONST_INT(mod, STATX_ALL);
+  DEF_CONST_INT(mod, STATX_MNT_ID);
+  DEF_CONST_INT(mod, STATX_DIOALIGN);
+  DEF_CONST_INT(mod, STATX_MNT_ID_UNIQUE);
+#ifdef STATX_SUBVOL
+  DEF_CONST_INT(mod, STATX_SUBVOL);
+#endif
+#ifdef STATX_WRITE_ATOMIC
+  DEF_CONST_INT(mod, STATX_WRITE_ATOMIC);
+#endif
+#ifdef STATX_DIO_READ_ALIGN
+  DEF_CONST_INT(mod, STATX_DIO_READ_ALIGN);
+#endif
+
   DEF_CONST_INT(mod, MSG_CONFIRM);
   DEF_CONST_INT(mod, MSG_DONTROUTE);
   DEF_CONST_INT(mod, MSG_DONTWAIT);

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();
 }