uringmachine 0.15 → 0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b3778bbf3b35b2f0855c5fdbe441df909a43866c56ceed16cacf502956566ba
-  data.tar.gz: 82b580cb610c11d5d05e69ab868ba70265fec92851cbdca7cf340bbde09c0b2c
+  metadata.gz: 18144dad22716ba83fde0f2ec1d3bffbb1a13684044f99f279eba183a70e7181
+  data.tar.gz: 0e742fa4e8ac06475fa7bfab120239863b76f47f5ca33c2a9cc3d0c26ef27bc8
 SHA512:
-  metadata.gz: 82fbdc455e76bd1adaf4668ae0d43c8c1e84f9c168c1d3e2f7a4924e672d5b77617ce720ac6fcb9257cc8e8edcf419f4267acdd7128d72a5d03c0b808f85ab4b
-  data.tar.gz: d56ba947a2d6ba974faa7e0594b506e0f7520815a995e263a7a9acf0658b73c057bd7d13f32e035376a4871dea6ff7824d04a621957707cb56a6f7e92581af1d
+  metadata.gz: fe981430bc6dace32cb166e3e8177ab5b4cf90f86021ee14990fa01b573459fbace2f17484e2307a9cf8ee83b59b547ae5e2c051774fcb8a444297293214d1e4
+  data.tar.gz: 8cc7d29d54de95ab70d197db9c1a035d6302750ca86d2ecfb94599e9bed5e3b4f1119eefc8e4804f89f09a20242cd35c0fe277b1a214f2742fce7642b6b83c97

data/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: noteflakes

data/.gitmodules

@@ -1,3 +1,7 @@
 [submodule "vendor/liburing"]
 	path = vendor/liburing
 	url = https://github.com/axboe/liburing
+
+[submodule "vendor/libressl"]
+	path = vendor/libressl
+	url = https://github.com/libressl/portable

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.18 2025-08-30
+
+- Fix `#write_async` to properly mark the given string
+
+# 0.17 2025-07-15
+
+- Add `#send_bundle` method
+
+# 2025-07-06 Version 0.16
+
+- Load UM version on require
+
 # 2025-06-24 Version 0.15
 
 - Add support for sleeping forever when sleep duration is lte 0

data/TODO.md

@@ -1,9 +1,18 @@
-# ops
+## useful concurrency tools
+
+- debounce
+
+  ```ruby
+  debouncer = UM.debounce { }
+  ```
+
+## ops
 
 - [ ] multishot timeout
   - [v] machine.periodically(interval) { ... }
   - [ ] machine.prep_timeout_multishot(interval)
 
+- writev
 - splice / - tee
 - sendto
 - recvfrom
@@ -17,12 +26,12 @@
 - getxattr / setxattr
 - send_bundle / recv_bundle (kernel >= 6.10)
 
-# actors
+## actors
 
 When doing a `call`, we need to provide a mailbox for the response. can this be
 automatic?
 
-# streams
+## streams
 
 We're still missing:
 

data/examples/bm_send.rb

@@ -0,0 +1,86 @@
+# 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'
+
+@machine = UM.new
+
+make_socket_pair = -> do
+  port = 10000 + rand(30000)
+  server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+  @machine.bind(server_fd, '127.0.0.1', port)
+  @machine.listen(server_fd, UM::SOMAXCONN)
+
+  client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+  server_conn_fd = @machine.accept(server_fd)
+
+  @machine.close(server_fd)
+  [client_conn_fd, server_conn_fd]
+end
+
+@client_fd, @server_fd = make_socket_pair.()
+
+@read_buf = +''
+@read_fiber = @machine.spin do
+  while true
+    @machine.read(@client_fd, @read_buf, 65536, 0)
+  end
+end
+
+STR_COUNT = ARGV[0]&.to_i || 3
+STR_SIZE = ARGV[1]&.to_i || 100
+
+@parts = ['*' * STR_SIZE] * STR_COUNT
+
+@server_io = IO.new(@server_fd)
+@server_io.sync = true
+def io_write
+  @server_io.write(*@parts)
+  @machine.snooze
+end
+
+def um_write
+  str = @parts.join
+  len = str.bytesize
+
+  while len > 0
+    ret = @machine.write(@server_fd, str, len)
+    len -= ret
+    str = str[ret..-1] if len > 0
+  end
+end
+
+def um_send
+  str = @parts.join
+  @machine.send(@server_fd, str, str.bytesize, UM::MSG_WAITALL)
+end
+
+@bgid = @machine.setup_buffer_ring(0, 8)
+def um_send_bundle
+  @machine.send_bundle(@server_fd, @bgid, @parts)
+end
+
+# um_send_bundle
+# 10.times { @machine.snooze }
+# exit
+
+p(STR_COUNT:, STR_SIZE:)
+
+Benchmark.ips do |x|
+  x.report('IO#write')       { io_write }
+  x.report('UM#write')       { um_write }
+  x.report('UM#send')        { um_send }
+  x.report('UM#send_bundle') { um_send_bundle }
+  x.compare!
+end

data/ext/um/um.c

@@ -74,6 +74,9 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
   // );
 
   if (op->flags & OP_F_FREE_ON_COMPLETE) {
+    if (op->flags & OP_F_TRANSIENT)
+      um_op_transient_remove(machine, op);
+
     um_op_free(machine, op);
     return;
   }
@@ -396,11 +399,13 @@ VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
 
 VALUE um_write_async(struct um *machine, int fd, VALUE str) {
   struct um_op *op = um_op_alloc(machine);
-  um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_FREE_ON_COMPLETE);
+  um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_TRANSIENT | OP_F_FREE_ON_COMPLETE);
   RB_OBJ_WRITE(machine->self, &op->value, str);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_write(sqe, fd, RSTRING_PTR(str), RSTRING_LEN(str), -1);
+  um_op_transient_add(machine, op);
+
   return str;
 }
 
@@ -485,6 +490,28 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
   return raise_if_exception(ret);
 }
 
+VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
+  um_add_strings_to_buffer_ring(machine, bgid, strings);
+
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SEND_BUNDLE, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+
+	io_uring_prep_send_bundle(sqe, fd, 0, MSG_WAITALL);
+	sqe->flags |= IOSQE_BUFFER_SELECT;
+	sqe->buf_group = bgid;
+
+  VALUE ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op))
+    ret = INT2NUM(op.result.res);
+
+  RB_GC_GUARD(ret);
+  return raise_if_exception(ret);
+
+
+  return ret;
+}
+
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
   struct um_op op;
   um_prep_op(machine, &op, OP_RECV, 0);

data/ext/um/um.h

@@ -36,6 +36,7 @@ enum op_kind {
   OP_ACCEPT,
   OP_RECV,
   OP_SEND,
+  OP_SEND_BUNDLE,
   OP_SOCKET,
   OP_CONNECT,
   OP_BIND,
@@ -210,6 +211,7 @@ void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
 void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags);
 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);
+void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
 
 struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
@@ -242,6 +244,7 @@ VALUE um_accept_each(struct um *machine, int fd);
 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, int len, int flags);
+VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags);
 VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);

data/ext/um/um_class.c

@@ -193,6 +193,22 @@ VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
   return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
 }
 
+VALUE UM_send_bundle(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = um_get_machine(self);
+  VALUE fd;
+  VALUE bgid;
+  VALUE strings;
+  rb_scan_args(argc, argv, "2*", &fd, &bgid, &strings);
+
+  if (RARRAY_LEN(strings) == 1) {
+    VALUE first = rb_ary_entry(strings, 0);
+    if (TYPE(first) == T_ARRAY)
+      strings = first;
+  }
+
+  return um_send_bundle(machine, NUM2INT(fd), NUM2INT(bgid), strings);
+}
+
 VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
   struct um *machine = um_get_machine(self);
   return um_recv(machine, NUM2INT(fd), buffer, NUM2INT(maxlen), NUM2INT(flags));
@@ -377,6 +393,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "recv", UM_recv, 4);
   rb_define_method(cUM, "recv_each", UM_recv_each, 3);
   rb_define_method(cUM, "send", UM_send, 4);
+  rb_define_method(cUM, "send_bundle", UM_send_bundle, -1);
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
   rb_define_method(cUM, "socket", UM_socket, 4);
   rb_define_method(cUM, "shutdown", UM_shutdown, 2);

data/ext/um/um_stream_class.c

@@ -93,6 +93,5 @@ void Init_Stream(void) {
   rb_define_method(cStream, "get_string", Stream_get_string, 2);
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
-  
   rb_define_singleton_method(cStream, "resp_encode", Stream_resp_encode, 2);
 }

data/ext/um/um_utils.c

@@ -65,11 +65,11 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   struct buf_ring_descriptor *desc = machine->buffer_rings + machine->buffer_ring_count;
   desc->buf_count = count;
   desc->buf_size = size;
-
   desc->br_size = sizeof(struct io_uring_buf) * desc->buf_count;
+  desc->buf_mask = io_uring_buf_ring_mask(desc->buf_count);
+
 	void *mapped = mmap(
-    NULL, desc->br_size, PROT_READ | PROT_WRITE,
-		MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
+    NULL, desc->br_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
   );
   if (mapped == MAP_FAILED)
     rb_raise(rb_eRuntimeError, "Failed to allocate buffer ring");
@@ -82,21 +82,22 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   desc->br = io_uring_setup_buf_ring(&machine->ring, count, bg_id, 0, &ret);
   if (!desc->br) {
     munmap(desc->br, desc->br_size);
-    rb_syserr_fail(ret, strerror(ret));
+    rb_syserr_fail(-ret, strerror(-ret));
   }
 
-  if (posix_memalign(&desc->buf_base, 4096, desc->buf_count * desc->buf_size)) {
-    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
-    rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
+  if (size > 0) {
+    if (posix_memalign(&desc->buf_base, 4096, desc->buf_count * desc->buf_size)) {
+      io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
+      rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
+    }
+
+    void *ptr = desc->buf_base;
+    for (unsigned i = 0; i < desc->buf_count; i++) {
+	  	io_uring_buf_ring_add(desc->br, ptr, desc->buf_size, i, desc->buf_mask, i);
+      ptr += desc->buf_size;
+	  }
+	  io_uring_buf_ring_advance(desc->br, desc->buf_count);
   }
-
-  desc->buf_mask = io_uring_buf_ring_mask(desc->buf_count);
-  void *ptr = desc->buf_base;
-  for (unsigned i = 0; i < desc->buf_count; i++) {
-		io_uring_buf_ring_add(desc->br, ptr, desc->buf_size, i, desc->buf_mask, i);
-    ptr += desc->buf_size;
-	}
-	io_uring_buf_ring_advance(desc->br, desc->buf_count);
   machine->buffer_ring_count++;
   return bg_id;
 }
@@ -120,3 +121,25 @@ inline VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32
   RB_GC_GUARD(buf);
   return buf;
 }
+
+inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings) {
+  static ID ID_to_s = 0;
+
+  struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
+  ulong count = RARRAY_LEN(strings);
+  VALUE str = Qnil;
+  VALUE converted = Qnil;
+  
+  for (ulong i = 0; i < count; i++) {
+    str = rb_ary_entry(strings, i);
+    if (TYPE(str) != T_STRING) {
+      if (!ID_to_s) ID_to_s = rb_intern("to_s");
+      if (NIL_P(converted)) converted = rb_ary_new();
+      str = rb_funcall(str, ID_to_s, 0);
+      rb_ary_push(converted, str);
+    }
+    io_uring_buf_ring_add(desc->br, RSTRING_PTR(str), RSTRING_LEN(str), i, desc->buf_mask, i);
+  }
+  RB_GC_GUARD(converted);
+  io_uring_buf_ring_advance(desc->br, count);
+}

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.15'
+  VERSION = '0.18'
 end

data/lib/uringmachine.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative './um_ext'
-require_relative 'uringmachine/dns_resolver'
+require 'um_ext'
+require 'uringmachine/version'
+require 'uringmachine/dns_resolver'
 
 UM = UringMachine
 
@@ -63,7 +64,7 @@ class UringMachine
     # cleanup
     @@fiber_map.delete(fiber)
     self.notify_done_listeners(fiber)
-    
+
     # transfer control to UM scheduler
     self.yield
   end

data/test/test_um.rb

@@ -565,6 +565,22 @@ class WriteAsyncTest < UMBaseTest
     assert_equal 'foo', r.readpartial(3)
   end
 
+  def test_write_async_dynamic_string
+    r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    str = "foo#{123}#{'bar' * 48}"
+    len = str.bytesize
+    machine.write_async(w.fileno, str)
+    str = nil
+    GC.start
+    assert_equal 1, machine.pending_count
+
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal "foo#{123}#{'bar' * 48}", r.readpartial(len)
+  end
+
   def test_write_async_bad_fd
     r, _w = IO.pipe
 
@@ -1417,5 +1433,65 @@ class ForkTest < UMBaseTest
   ensure
     Process.wait(child_pid) rescue Errno::ECHILD
   end
+end
+
+class SendBundleTest < UMBaseTest
+  def setup
+    super
+    @client_fd, @server_fd = make_socket_pair
+  end
+
+  def test_send_bundle_splat
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
+
+    strs = ['foo', 'bar', 'bazzzzz']
+    len = strs.inject(0) { |len, s| len + s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, *strs)
+    assert_equal len, ret
 
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.join, buf
+  end
+
+  def test_send_bundle_array
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
+
+    strs = ['foo', 'bar', 'bazzzzz']
+    len = strs.inject(0) { |len, s| len + s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, strs)
+    assert_equal len, ret
+
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.join, buf
+  end
+
+  def test_send_bundle_non_strings
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
+
+    strs = [42, 'bar', false]
+    len = strs.inject(0) { |len, s| len + s.to_s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, strs)
+    assert_equal len, ret
+
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.map(&:to_s).join, buf
+  end
 end

data/vendor/libressl/.github/scripts/changelog.sh

@@ -0,0 +1,74 @@
+#!/bin/sh
+# Copyright (c) 2023 Joshua Sing <joshua@hypera.dev>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+#
+# Usage: changelog.sh <version>
+#  Reads the changelog for the specified version from the changelog file.
+#  The output will be reformatted for use in GitHub releases.
+#
+#  The changelog file defaults to "ChangeLog", but can be changed by setting
+#  the environment variable $CHANGELOG_FILE
+#
+
+set -e
+
+# Check if the version argument is provided
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <version>" 1>&2
+    exit 1
+fi
+
+version="${1#v}"
+changelog_file="${CHANGELOG_FILE:-ChangeLog}"
+found_version=false
+changelog=""
+
+# Check if the specified changelog file exists
+if [ ! -f "$changelog_file" ]; then
+    echo "Error: Changelog file '$changelog_file' not found" 1>&2
+    exit 1
+fi
+
+# Read the changelog file line by line
+while IFS= read -r line; do
+    # Check for the version line
+    if echo "$line" | grep -Eq "^${version} - "; then
+      found_version=true
+      continue
+    fi
+
+    # Continue reading the changelog until the next version or end of file,
+    # skipping empty lines
+    if $found_version; then
+      echo "$line" | grep -Eq "^\s*$" && continue
+      echo "$line" | grep -Eq "^[0-9]+\.[0-9]+\.[0-9]+ - " && break
+      changelog="${changelog}${line}\n"
+    fi
+done < "$changelog_file"
+
+# If the specified version was not found, print an error
+if ! $found_version; then
+    echo "Error: Version $version was not found in changelog" 1>&2
+    exit 1
+fi
+
+# Tidy up the changelog for displaying on GitHub
+changelog=$(echo "$changelog" | sed -e 's/^\t\*/###/' -e 's/^\t//')
+
+# Print the changelog for the specified version
+echo "$changelog"
+echo
+echo "Full changelog: https://github.com/libressl/portable/blob/master/ChangeLog"
+exit 0

data/vendor/libressl/.github/workflows/android.yml

@@ -0,0 +1,35 @@
+# GitHub Actions workflow to run tests on Android.
+name: "Android"
+
+on: [push, pull_request]
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.number || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: "Test ${{ matrix.name }}"
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: "Android 8-9"
+            min-nal: 26
+            max-nal: 28
+          - name: "Android 10-11"
+            min-nal: 29
+            max-nal: 30
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v4
+
+      - name: "Run CI script"
+        run: ./scripts/test
+        env:
+          ARCH: "android"
+          MIN_NAL: "${{ matrix.min-nal }}"
+          MAX_NAL: "${{ matrix.max-nal }}"

data/vendor/libressl/.github/workflows/cifuzz.yml

@@ -0,0 +1,33 @@
+name: CIFuzz
+
+on:
+  workflow_dispatch:
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.number || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-24.04
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libressl'
+        dry-run: false
+        language: c++
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libressl'
+        fuzz-seconds: 300
+        dry-run: false
+        language: c++
+    - name: Upload Crash
+      uses: actions/upload-artifact@v4
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts