uringmachine 0.29.2 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6151ac8411facd0ef37fa66a7cae623d2137f335bbe1e178529cb0a76c9f56c3
-  data.tar.gz: 5918fde9ea4ba936760a3d402207bd6fd5806337b005cd3633ab1cf0f8584ed0
+  metadata.gz: a97099f1d89b2333b8be056c91acabad63fad122ce4c802a666e4abb10aca93b
+  data.tar.gz: '095878ee7df374be5dc87b74ea636b3def2b611006c76c7d86ae7c00ad064f47'
 SHA512:
-  metadata.gz: 0d77a7f37251930db32ec8023b1cb60e5595348544b279b175d39a528dbe782a703c75f6ebde5b2dd84379ec12ae83decf47f11f0b692e4975a36f146b4bc975
-  data.tar.gz: 190d3d88d32f91241c3c9ed3fc674d5318fcf630e64d5d5fdecdc7a86b6e62f03786190a021f4828e6a40022ccbf301a3cffdf0311ff35bc747889d9f00fbb9b
+  metadata.gz: 339349fd4116011334517f124201a1cf425762c1bafe33ba61fa3eaf175fa5064512f780f8354f8fc317515bab6c4914cb41fba2022d23c17aac7e08d18cad7b
+  data.tar.gz: 02c7b30e4143f07382f2788a9f242e6f051f57b438fc3ecc63153a13f318bbbab69e5239add2af31e277c68b21483be60bd542863c8f7aa358d7fa1b0c0793e9

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.30.0 2026-03-23
+
+- Add `Stream#each`
+- Add `UM#splice`, `UM#tee`, `UM#fsync`
+- Add `UM#tcp_listen`, `UM#tcp_connect`
+
 # 0.29.2 2026-03-15
 
 - Add `Stream#consumed`, `Stream#pending`

data/TODO.md

@@ -1,67 +1,10 @@
 ## immediate
 
-- Add support for returning a value on timeout
-
-  Since to do this safely we need to actually raise an exception that wraps the
-  value, rescue it and return the value, we might want a separate method that
-  wraps `#timeout`:
-
-  ```ruby
-  TimeoutValueError < StandardError
-
-  def timeout_with_value(interval, value, &block)
-    timeout_error = TimeoutValueError
-    timeout(interval, timeout_error, &block)
-  rescue TimeoutValueError => e
-    raise if e != timeout_error
-
-    value
-  end
-  ```
-
 - Add tests for support for Set in `machine#await`
 - Add tests for support for Set, Array in `machine#join`
 - Add `#read_file` for reading entire file
 - Add `#write_file` for writing entire file
 
-- (?) Fix all futex value (Queue, Mutex) to be properly aligned
-
-<<<<<<< HEAD
-=======
-## Buffer rings - automatic management
-
-- Take the buffer_pool branch, rewrite it
-- Allow multiple stream modes:
-  - :buffer_pool - uses buffer rings
-  - :ssl - read from an SSL connection (`SSLSocket`)
-  - :io - read from an `IO`
-
-The API will look something like:
-
-```ruby
-# The mode is selected automatically according to the given target
-
-stream = UM::Stream.new(machine, fd) # buffer_pool mode (read)
-stream = UM::Stream.new(machine, fd, :recv) # buffer_pool mode (recv)
-stream = UM::Stream.new(machine, ssl_sock) # SSLSocket mode
-stream = UM::Stream.new(machine, conn) # IO mode
-stream = UM::Stream.new(machine, str) # string mode
-stream = UM::Stream.new(machine, io_buf) # IO:Buffer mode
-```
-
-This can be very useful in testing of stuff such as protocol implementations:
-
-```ruby
-stream = UM::Stream.new(machine, "GET /foo HTTP/1.1\r\nHost: bar.com\r\n")
-```
-
-So basically the stream is tied to a machine, and that means it can only be used
-on the thread with which the machine is associated. It is not thread-safe. (This
-is incidentally true also for most of the UringMachine instance methods!)
-
-Continued discussion in docs/design/buffer_pool.md
-
->>>>>>> 04d9eb7 (Docs)
 ## Balancing I/O with the runqueue
 
 - in some cases where there are many entries in the runqueue, this can
@@ -89,6 +32,8 @@ Continued discussion in docs/design/buffer_pool.md
   debouncer = machine.debounce { }
   ```
 
+- happy eyeballs algo for TCP connect
+
 - read multiple files
 
   ```ruby
@@ -99,12 +44,31 @@ Continued discussion in docs/design/buffer_pool.md
   machine.read_files(*fns) #=> { fn1:, fn2:, fn3:, ...}
   ```
 
+- more generally, a DSL for expressing batch operations:
+
+  ```ruby
+  result = machine.batch do |b|
+    fns.each { b[it] = read_file(b, it) }
+  end
+  #=> { fn1 => data1, fn2 => data2, ... }
+
+  # we can also imagine performing operations in sequence using linking:
+  result = machine.batch {
+    m.
+  }
+
+  end
+  ```
+
 ## polyvalent select
 
 - select on multiple queues (ala Go)
 - select on mixture of queues and fds
+- select on fibers:
+  - select fibers that are done
+  - select first done fiber
 
-## ops
+## ops still not implemented
 
 - splice / - tee
 - sendto
@@ -123,31 +87,7 @@ Continued discussion in docs/design/buffer_pool.md
 When doing a `call`, we need to provide a mailbox for the response. can this be
 automatic?
 
-## streams
-
-We're still missing:
-
-- limit on line length in `get_line`
-- ability to supply buffer to `get_line` and `get_string`
-- allow read to eof, maybe with `read_to_eof`
-
-For the sake of performance, simplicity and explicitness, we change the API as
-follows:
-
-```ruby
-stream.get_line(buf, limit)
-# the defaults:
-stream.get_line(nil, -1)
-
-stream.get_string(len, buf)
-# defaults:
-stream.get_string(len, nil)
-
-# and
-stream.read_to_eof(buf)
-# defaults:
-stream.read_to_eof(nil)
-```
+##
 
 ## Syntax / pattern for launching/supervising multiple operations
 
@@ -166,6 +106,5 @@ machine.shift_select(*queues) #=> [result, queue]
   ```ruby
   # addrs: [['1.1.1.1', 80], ['2.2.2.2', 80]]
   #        ['1.1.1.1:80', '2.2.2.2:80']
-  tcp_connect_happy_eyeballs(*addrs)
+  tcp_connect_he(*addrs)
   ```
-

data/benchmark/bm_io_ssl.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative './common'
+require 'socket'
+require 'openssl'
+require 'localhost/authority'
+
+GROUPS = 48
+ITERATIONS = 5000
+
+SIZE = 1 << 14
+DATA = '*' * SIZE
+
+class UMBenchmark
+  def server_ctx
+    @server_ctx ||= Localhost::Authority.fetch.server_context
+  end
+
+  def ssl_wrap(sock, ctx)
+    OpenSSL::SSL::SSLSocket.new(sock, ctx).tap { it.sync_close = true }
+  end
+
+  def ssl_socketpair(machine)
+    sock1, sock2 = Socket.socketpair(:AF_UNIX, :SOCK_STREAM, 0)
+    ssl1 = ssl_wrap(sock1, server_ctx)
+    ssl2 = ssl_wrap(sock2, OpenSSL::SSL::SSLContext.new)
+
+    if !machine
+      t = Thread.new { ssl1.accept rescue nil }
+      ssl2.connect
+      t.join
+    else
+      machine.ssl_set_bio(ssl1)
+      machine.ssl_set_bio(ssl2)
+      f = machine.spin { ssl1.accept rescue nil }
+      ssl2.connect
+      machine.join(f)
+    end
+    [ssl1, ssl2]
+  end
+
+  def do_threads(threads, ios)
+    GROUPS.times do
+      r, w = ssl_socketpair(nil)
+      threads << Thread.new do
+        ITERATIONS.times { w.write(DATA) }
+        w.close
+      end
+      threads << Thread.new do
+        ITERATIONS.times { r.readpartial(SIZE) }
+        r.close
+      end
+    end
+  end
+
+  def do_thread_pool(thread_pool, ios)
+    GROUPS.times do
+      r, w = ssl_socketpair(nil)
+      r.sync = true
+      w.sync = true
+      ios << r << w
+      ITERATIONS.times {
+        thread_pool.queue { w.write(DATA) }
+        thread_pool.queue { r.readpartial(SIZE) }
+      }
+    end
+  end
+
+  def do_scheduler(scheduler, ios)
+    GROUPS.times do
+      r, w = ssl_socketpair(nil)
+      r.sync = true
+      w.sync = true
+      Fiber.schedule do
+        ITERATIONS.times { w.write(DATA) }
+        w.close
+      end
+      Fiber.schedule do
+        ITERATIONS.times { r.readpartial(SIZE) }
+        r.close
+      end
+    end
+  end
+
+  def do_scheduler_x(div, scheduler, ios)
+    (GROUPS/div).times do
+      r, w = ssl_socketpair(nil)
+      r.sync = true
+      w.sync = true
+      Fiber.schedule do
+        ITERATIONS.times { w.write(DATA) }
+        w.close
+      end
+      Fiber.schedule do
+        ITERATIONS.times { r.readpartial(SIZE) }
+        r.close
+      end
+    end
+  end
+
+  def do_um(machine, fibers, fds)
+    GROUPS.times do
+      r, w = ssl_socketpair(machine)
+      fibers << machine.spin do
+        ITERATIONS.times { machine.ssl_write(w, DATA, SIZE) }
+        machine.close_async(w)
+      end
+      fibers << machine.spin do
+        ITERATIONS.times { machine.ssl_read(r, +'', SIZE) }
+        machine.close_async(r)
+      end
+    end
+  end
+
+  def do_um_x(div, machine, fibers, fds)
+    (GROUPS/div).times do
+      r, w = ssl_socketpair(machine)
+      fibers << machine.spin do
+        ITERATIONS.times { machine.ssl_write(w, DATA, SIZE) }
+        machine.close_async(w)
+      end
+      fibers << machine.spin do
+        ITERATIONS.times { machine.ssl_read(r, +'', SIZE) }
+        machine.close_async(r)
+      end
+    end
+  end
+end

data/benchmark/bm_redis_client.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative './common'
+require 'securerandom'
+
+C = ENV['C']&.to_i || 50
+I = 10
+puts "C=#{C}"
+
+class UMBenchmark
+  CONTAINER_NAME = "redis-#{SecureRandom.hex}"
+
+  def start_redis_server
+    `docker run --name #{CONTAINER_NAME} -d -p 6379:6379 redis:latest`
+  end
+
+  def stop_redis_server
+    `docker stop #{CONTAINER_NAME}`
+  end
+
+  def create_redis_conn(retries = 0)
+    Redis.new
+  rescue
+    if retries < 3
+      sleep 0.5
+      create_redis_conn(retries + 1)
+    else
+    raise
+    end
+  end
+
+  def query_redis(conn)
+    conn.set('abc', 'def')
+    p conn.get('abc')
+  end
+
+  def with_container
+    start_redis_server
+    sleep 0.5
+    yield
+  rescue Exception => e
+    p e
+    p e.backtrace
+  ensure
+  stop_redis_server
+  end
+
+  def benchmark
+    with_container {
+      Benchmark.bm { run_benchmarks(it) }
+    }
+  end
+
+  # def do_threads(threads, ios)
+  #   C.times.map do
+  #     threads << Thread.new do
+  #       conn = create_redis_conn
+  #       I.times { query_redis(conn) }
+  #     ensure
+  #       conn.close
+  #     end
+  #   end
+  # end
+
+  def do_scheduler(scheduler, ios)
+    return if !scheduler.is_a?(UM::FiberScheduler)
+    C.times do
+      Fiber.schedule do
+        conn = create_redis_conn
+        I.times { query_redis(conn) }
+      ensure
+        conn.close
+      end
+    end
+  end
+end

data/benchmark/common.rb

@@ -9,6 +9,7 @@ gemfile do
   gem 'io-event'
   gem 'async'
   gem 'pg'
+  gem 'redis'
   gem 'gvltools'
   gem 'openssl'
   gem 'localhost'

data/benchmark/http_parse.rb

@@ -62,7 +62,7 @@ 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)
@@ -137,7 +137,7 @@ def stream_parse_headers(fd)
   return nil if !headers
 
   while true
-    line = stream.get_line(buf, 0)
+    line = stream.get_line(0)
     break if line.empty?
 
     m = line.match(RE_HEADER_LINE)
@@ -150,7 +150,7 @@ def stream_parse_headers(fd)
 end
 
 def stream_get_request_line(stream, buf)
-  line = stream.get_line(buf, 0)
+  line = stream.get_line(0)
 
   m = line.match(RE_REQUEST_LINE)
   return nil if !m

data/ext/um/um.c

@@ -1285,6 +1285,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
 *******************************************************************************/

data/ext/um/um.h

@@ -48,6 +48,9 @@ enum um_op_kind {
   OP_CLOSE,
   OP_CLOSE_ASYNC,
   OP_STATX,
+  OP_SPLICE,
+  OP_TEE,
+  OP_FSYNC,
 
   OP_ACCEPT,
   OP_RECV,
@@ -161,7 +164,7 @@ struct um_op {
     struct iovec *iovecs; // used for vectorized write/send
     siginfo_t siginfo; // used for waitid
     int int_value; // used for getsockopt
-    size_t bp_commit_level; // buffer pool commit threshold
+    size_t bp_commit_level; // buffer pool commit level
   };
 };
 
@@ -325,7 +328,6 @@ void um_op_list_compact(struct um *machine, struct um_op *head);
 void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags);
 void um_op_multishot_results_clear(struct um *machine, struct um_op *op);
 
-struct um_segment *um_segment_alloc(struct um *machine);
 void um_segment_free(struct um *machine, struct um_segment *segment);
 
 void um_runqueue_push(struct um *machine, struct um_op *op);
@@ -391,6 +393,9 @@ VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
 #endif
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
+VALUE um_splice(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_tee(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_fsync(struct um *machine, int fd);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -437,6 +442,7 @@ 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 resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);
@@ -454,9 +460,9 @@ void um_sidecar_signal_wait(struct um *machine);
 void um_sidecar_signal_wake(struct um *machine);
 
 void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
-int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, int maxlen);
-int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, int maxlen);
-int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, int len);
+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);
 
 void bp_setup(struct um *machine);
 void bp_teardown(struct um *machine);

data/ext/um/um_buffer_pool.c

@@ -18,7 +18,7 @@ inline struct um_buffer *buffer_alloc(struct um *machine) {
   return buffer;
 }
 
-inline struct um_buffer *bp_buffer_checkout(struct um *machine) {
+struct um_buffer *bp_buffer_checkout(struct um *machine) {
   struct um_buffer *buffer = machine->bp_buffer_freelist;
   if (buffer) {
     struct um_buffer *next = buffer->next;
@@ -50,13 +50,13 @@ inline void buffer_free(struct um *machine, struct um_buffer *buffer) {
   }
 }
 
-inline void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
+void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
   assert(buffer->ref_count > 0);
   buffer->ref_count--;
   if (!buffer->ref_count) buffer_free(machine, buffer);
 }
 
-inline void bp_discard_buffer_freelist(struct um *machine) {
+void bp_discard_buffer_freelist(struct um *machine) {
   while (machine->bp_buffer_freelist) {
     struct um_buffer *buffer = machine->bp_buffer_freelist;
     struct um_buffer *next = buffer->next;
@@ -69,7 +69,7 @@ inline void bp_discard_buffer_freelist(struct um *machine) {
   }
 }
 
-inline void bp_setup(struct um *machine) {
+void bp_setup(struct um *machine) {
   int ret;
   machine->bp_br = io_uring_setup_buf_ring(&machine->ring, BP_BR_ENTRIES, BP_BGID, IOU_PBUF_RING_INC, &ret);
   if (unlikely(!machine->bp_br)) rb_syserr_fail(ret, strerror(ret));
@@ -85,7 +85,7 @@ inline void bp_setup(struct um *machine) {
   machine->bp_total_commited = 0;
 }
 
-inline void bp_teardown(struct um *machine) {
+void bp_teardown(struct um *machine) {
   bp_discard_buffer_freelist(machine);
   for (int i = 0; i < BP_BR_ENTRIES; i++) {
     struct um_buffer *buffer = machine->bp_commited_buffers[i];
@@ -162,7 +162,7 @@ inline int should_commit_more_p(struct um *machine) {
          (machine->bp_total_commited < machine->bp_commit_level);
 }
 
-inline void bp_ensure_commit_level(struct um *machine) {
+void bp_ensure_commit_level(struct um *machine) {
   if (machine->bp_total_commited > (machine->bp_commit_level / 2))
     return;
 
@@ -179,7 +179,7 @@ inline void bp_ensure_commit_level(struct um *machine) {
   // size.
 }
 
-inline void bp_handle_enobufs(struct um *machine) {
+void bp_handle_enobufs(struct um *machine) {
   if (unlikely(machine->bp_commit_level >= BP_MAX_COMMIT_LEVEL))
     rb_raise(eUMError, "Buffer starvation");
 
@@ -189,7 +189,7 @@ inline void bp_handle_enobufs(struct um *machine) {
   bp_discard_buffer_freelist(machine);
 }
 
-inline struct um_segment *um_segment_alloc(struct um *machine) {
+inline struct um_segment *segment_alloc(struct um *machine) {
   if (machine->segment_freelist) {
     struct um_segment *segment = machine->segment_freelist;
     machine->segment_freelist = segment->next;
@@ -208,14 +208,14 @@ inline struct um_segment *um_segment_alloc(struct um *machine) {
   return batch;
 }
 
-inline void um_segment_free(struct um *machine, struct um_segment *segment) {
+void um_segment_free(struct um *machine, struct um_segment *segment) {
   segment->next = machine->segment_freelist;
   machine->segment_freelist = segment;
   machine->metrics.segments_free++;
 }
 
-inline struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
-  struct um_segment *segment = um_segment_alloc(machine);
+struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
+  struct um_segment *segment = segment_alloc(machine);
   segment->ptr = buffer->buf + buffer->pos;
   segment->len = len;
   segment->buffer = buffer;

data/ext/um/um_class.c

@@ -534,6 +534,60 @@ VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
   return um_statx(machine, NUM2INT(dirfd), path, NUM2INT(flags), NUM2UINT(mask));
 }
 
+/* call-seq:
+ *   machine.splice(in_fd, out_fd, nbytes) -> len
+ *
+ * Splices bytes from in_fd to out_fd. At least one of the given fds must be a
+ * pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/splice.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_splice.3.html
+ *
+ * @param in_fd [Integer] fd to splice from
+ * @param out_fd [Integer] fd to splice to
+ * @param nbytes [Integer] number of bytes to splice
+ * @return [Integer] number of bytes spliced
+ */
+VALUE UM_splice(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_splice(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.tee(in_fd, out_fd, nbytes) -> len
+ *
+ * Duplicates bytes from in_fd to out_fd. At least one of the given fds must be
+ * a pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/tee.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_tee.3.html
+ *
+ * @param in_fd [Integer] fd to copy from
+ * @param out_fd [Integer] fd to copy to
+ * @param nbytes [Integer] number of bytes to duplicate
+ * @return [Integer] number of bytes duplicated
+ */
+VALUE UM_tee(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_tee(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.fsync(fd) -> 0
+ *
+ * Flushes all modified file data to the storage device.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/fsync.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_fsync.3.html
+ *
+ * @param fd [Integer] fd
+ * @return [Integer] 0 if successful
+ */
+VALUE UM_fsync(VALUE self, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_fsync(machine, NUM2INT(fd));
+}
+
 /* call-seq:
  *   machine.close(fd) -> 0
  *
@@ -1480,6 +1534,9 @@ void Init_UM(void) {
   rb_define_method(cUM, "writev", UM_writev, -1);
   rb_define_method(cUM, "write_async", UM_write_async, -1);
   rb_define_method(cUM, "statx", UM_statx, 4);
+  rb_define_method(cUM, "splice", UM_splice, 3);
+  rb_define_method(cUM, "tee", UM_tee, 3);
+  rb_define_method(cUM, "fsync", UM_fsync, 1);
 
   rb_define_method(cUM, "poll", UM_poll, 2);
   rb_define_method(cUM, "select", UM_select, 3);