uringmachine 0.31.0 → 0.33.0

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 connection_get_request_line(conn, buf)
-  line = conn.read_line(0)
+def io_get_request_line(io, buf)
+  line = io.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(conn, buf)
-  headers = connection_get_request_line(conn, buf)
+def get_headers(io, buf)
+  headers = io_get_request_line(io, buf)
   return nil if !headers
 
   while true
-    line = conn.read_line(0)
+    line =  io.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)
-  conn = UM::Connection.new(machine, fd)
+  io = UM::IO.new(machine, fd)
   buf = String.new(capacity: 65536)
 
   while true
-    headers = get_headers(conn, buf)
+    headers = get_headers(io, buf)
     break if !headers
 
     send_response(machine, fd)
@@ -77,4 +77,4 @@ machine.bind(fd, '127.0.0.1', PORT)
 machine.listen(fd, 128)
 
 puts "Listening on localhost:#{PORT}"
-machine.accept_each(fd) { |conn| machine.spin { handle_connection(machine, conn) } }
+machine.accept_each(fd) { | io| machine.spin { handle_connection(machine,  io) } }

data/benchmark/openssl.rb

@@ -81,7 +81,7 @@ end
 @um.ssl_set_bio(@ssl_conn)
 @ssl_conn.connect
 
-@conn = @um.connection(@ssl_conn, :ssl)
+@io = @um.io(@ssl_conn)
 
 @msg = 'abc' * 1000
 @msg_newline = @msg + "\n"
@@ -91,15 +91,15 @@ def do_io(ssl)
   ssl.gets
 end
 
-def do_io_connection(ssl, um, conn)
+def do_io_io(ssl, um, io)
   um.ssl_write(ssl, @msg_newline, 0)
-  conn.read_line(0)
+  io.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.report('UM::IO') { do_io_io(@ssl_conn, @um, @io) }
 
   x.compare!(order: :baseline)
 end

data/docs/um_api.md

@@ -43,26 +43,21 @@
 - `pop(queue)` - removes and returns a value off the end of the given queue.
 - `prep_timeout(interval)` - returns a timeout AsyncOp with the given interval.
 - `push(queue, value)` - adds the given value to the end of the given queue.
-- `read_each(fd, bgid) { |data| ... }` - reads repeatedly from the given fd
-  using the given buffer group id, yielding each chunk of data to the given
-  block.
+- `read_each(fd) { |data| ... }` - reads repeatedly from the given fd, yielding
+  each chunk of data to the given block.
 - `read(fd, buffer[, maxlen[, buffer_offset[, file_offset]]])` - reads from the
   given fd int o the given buffer (String or IO::Buffer).
-- `recv_each(fd, bgid, flags)` - receives from the given fd using the given
-  buffer group id, with the given flags.
+- `recv_each(fd, flags)` - receives repeatedly from the given fd with the given
+  flags.
 - `recv(fd, buffer, maxlen, flags)` - receives from the given fd into the given
   buffer.
 - `schedule(fiber, value)` - adds the given fiber to the runqueue with the given
   resume value.
 - `select(rfds, wfds, efds)` - selects ready fds from the given readable,
   writable and exeptable fds.
-- `send_bundle(fd, bgid, *strings)` - sends a bundle of buffers to the given fd
-  using the given buffer group id.
 - `send(fd, buffer, len, flags)` - sends to the given fd from the given buffer.
 - `sendv(fd, *buffers)` - sends multiple buffers to the given fd.
 - `setsockopt(fd, level, opt, value)` - sets a socket option.
-- `setup_buffer_ring(size, count)` - sets up a buffer ring and returns the
-  buffer group id.
 - `shift(queue)` - removes and returns a value from the head of given queue.
 - `shutdown_async(fd, how)` - shuts down the given socket fd without blocking.
 - `shutdown(fd, how)` - shuts down the given socket fd.

data/examples/fiber_concurrency_io.rb

@@ -4,7 +4,7 @@
 def fiber_switch
   while true
     next_fiber, value = @runqueue.shift
-    return next_fiber.transfer value if next_fiber
+    return next_fiber.transfer(value) if next_fiber
 
     process_events
   end

data/examples/fiber_concurrency_um.rb

@@ -0,0 +1,16 @@
+require 'uringmachine'
+
+machine = UM.new
+
+reader = machine.spin {
+  input = +''
+  machine.read(UM::STDIN_FILENO, input, 256)
+  machine.write(UM::STDOUT_FILENO, "Got: #{input}")
+}
+
+sleeper = machine.spin {
+  machine.sleep(5)
+  machine.write(UM::STDOUT_FILENO, "5 seconds have elapsed!")
+}
+
+machine.join(reader, sleeper)

data/examples/io_uring_simple.c

@@ -7,6 +7,7 @@ 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;
@@ -14,11 +15,19 @@ io_uring_submit(&ring);
 
 ...
 
-ret = io_uring_wait_cqe(&ring, &cqe);
-if (!ret) {
+sqe = io_uring_get_sqe(&ring);
+io_uring_prep_cancel(sqe, 42, IORING_ASYNC_CANCEL_USERDATA);
+sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
+io_uring_submit(&ring);
+
+if (!io_uring_wait_cqe(&ring, &cqe)) {
   if (cqe->user_data == 42) {
-    int len = cqe->res;
-    printf("Got: %d\n", len);
+    if (cqe->res == -ECANCELED)
+      printf("Cancelled!\n");
+    else {
+      int len = cqe->res;
+      printf("Got %d bytes\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)
-  conn = UM::Connection.new($machine, fd)
+  io = UM::IO.new($machine, fd)
 
-  while (l = conn.gets)
+  while (l = io.gets)
     $machine.write(fd, "You said: #{l}")
   end
 rescue Exception => e

data/examples/um_cancellation.rb

@@ -0,0 +1,20 @@
+f = machine.spin do
+  buf = +''
+  machine.read(fd, buf, 256)
+  machine.write(UM::STDOUT_FILENO, "Got: #{buf}")
+rescue UM::Terminate
+  machine.write(UM::STDOUT_FILENO, "Cancelled")
+end
+
+machine.sleep(0.1)
+machine.schedule(f, UM::Terminate.new)
+
+
+
+
+# read with timeout
+input = +''
+machine.timeout(timeout, TimeoutError) {
+  machine.read(fd, input, 256)
+}
+

data/examples/um_fiber_scheduler.rb

@@ -0,0 +1,10 @@
+machine = UM.new
+scheduler = UM::FiberScheduler.new(machine)
+Fiber.set_scheduler(scheduler)
+
+Fiber.schedule {
+  # UringMachine-driven I/O!
+  puts "What's your favorite color?"
+  color = gets
+  puts "Wrong answer: #{color}!"
+}

data/examples/um_io.rb

@@ -0,0 +1,19 @@
+io = machine.io(fd)
+
+# parse an incoming HTTP request
+line = io.read_line(4096)
+m = line.match(/^([a-z]+)\s+([^\s]+)\s+(http\/1\.1)/i)
+headers = {
+  ':method'   => m[1].downcase,
+  ':path'     => m[2],
+  ':protocol' => m[3].downcase
+}
+while true
+  line = io.read_line(4096)
+  break if line.empty?
+
+  m = line.match(/^([a-z0-9\-]+)\:\s+(.+)/i)
+  headers[m[1].downcase] = m[2]
+end
+
+io.write("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo")

data/examples/um_mo.c

@@ -0,0 +1,32 @@
+VALUE um_sleep(struct um *machine, double duration) {
+  struct um_op *op = um_op_acquire(machine);
+  op->fiber = rb_fiber_current();
+  op->ts = um_double_to_timespec(duration);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
+
+  VALUE ret = um_switch(machine);
+  if (um_verify_op_completion(machine, op)) ret = DBL2NUM(duration);
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  return ret;
+}
+
+VALUE um_switch(struct um *machine) {
+  while (true) {
+    struct um_op *op = um_runqueue_shift(machine);
+    if (op) return rb_fiber_transfer(op->fiber, 1, &op->value);
+
+    um_wait_for_and_process_ready_cqes(machine);
+  }
+}
+
+void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe) {
+  struct um_op *op = (struct um_op *)cqe->user_data;
+  if (op) {
+    op->result.res    = cqe->res;
+    op->result.flags  = cqe->flags;
+    um_runqueue_push(machine, op);
+  }
+}

data/examples/um_multishot.rb

@@ -0,0 +1,15 @@
+# singleshot accept
+while (fd = machine.accept(server_fd))
+  handle_connection(fd)
+end
+
+# multishot accept
+machine.accept_each(server_fd) { handle_connection(it) }
+
+# multishot timeout
+machine.periodically(5) { ... }
+
+# multishot recv
+machine.recv_each(fd, 0) { |data|
+  machine.write(UM::STDOUT_FILENO, "Got: #{data}\n")
+}

data/examples/um_ssl.rb

@@ -0,0 +1,11 @@
+ssl = OpenSSL::SSL::SSLSocket.new(IO.for_fd(server_fd), server_ctx)
+machine.ssl_set_bio(ssl)
+ssl.accept
+
+ssl.write('Hello!')
+# also:
+machine.ssl_write(ssl, 'Hello!')
+
+io = machine.io(ssl)
+line = io.read_line(4096)
+...

data/ext/um/um.c

@@ -49,12 +49,6 @@ inline void um_teardown(struct um *machine) {
   if (machine->sidecar_mode) um_sidecar_teardown(machine);
   if (machine->sidecar_signal) free(machine->sidecar_signal);
 
-  for (unsigned i = 0; i < machine->buffer_ring_count; i++) {
-    struct buf_ring_descriptor *desc = machine->buffer_rings + i;
-    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, i);
-    free(desc->buf_base);
-  }
-  machine->buffer_ring_count = 0;
   io_uring_queue_exit(&machine->ring);
   machine->ring_initialized = 0;
 
@@ -523,7 +517,6 @@ struct op_ctx {
   struct um *machine;
   struct um_op *op;
   int fd;
-  int bgid;
 
   struct um_queue *queue;
   void *read_buf;
@@ -870,25 +863,6 @@ VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv) {
   return 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_op_acquire(machine);
-  um_prep_op(machine, op, OP_SEND_BUNDLE, 2, 0);
-  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-	io_uring_prep_send_bundle(sqe, fd, 0, MSG_NOSIGNAL | MSG_WAITALL);
-	sqe->flags |= IOSQE_BUFFER_SELECT;
-	sqe->buf_group = bgid;
-
-  VALUE ret = um_yield(machine);
-
-  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(op->result.res);
-  um_op_release(machine, op);
-
-  RAISE_IF_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags) {
   void *ptr = um_prepare_read_buffer(buffer, maxlen, 0);
   struct um_op *op = um_op_acquire(machine);
@@ -1461,72 +1435,44 @@ VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue) {
   return rb_ensure(accept_into_queue_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
-int um_read_each_singleshot_loop(struct op_ctx *ctx) {
-  struct buf_ring_descriptor *desc = ctx->machine->buffer_rings + ctx->bgid;
-  ctx->read_maxlen = desc->buf_size;
-  ctx->read_buf = malloc(desc->buf_size);
-  int total = 0;
-
-  while (1) {
-    um_prep_op(ctx->machine, ctx->op, OP_READ, 2, 0);
-    struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
-    io_uring_prep_read(sqe, ctx->fd, ctx->read_buf, ctx->read_maxlen, -1);
-
-    VALUE ret = um_yield(ctx->machine);
-
-    if (likely(um_verify_op_completion(ctx->machine, ctx->op, true))) {
-      VALUE buf = rb_str_new(ctx->read_buf, ctx->op->result.res);
-      total += ctx->op->result.res;
-      rb_yield(buf);
-      RB_GC_GUARD(buf);
-    }
-    else {
-      RAISE_IF_EXCEPTION(ret);
-      return 0;
-    }
-    RB_GC_GUARD(ret);
-  }
-  return 0;
-}
-
 // // returns true if more results are expected
-int read_recv_each_multishot_process_result(struct op_ctx *ctx, struct um_op_result *result, int *total) {
+inline int read_recv_each_multishot_process_result(struct op_ctx *ctx, struct um_op_result *result, int *total) {
   if (result->res == 0)
     return false;
 
   *total += result->res;
-  VALUE buf = um_read_from_buffer_ring(ctx->machine, ctx->bgid, result->res, result->flags);
-  rb_yield(buf);
-  RB_GC_GUARD(buf);
-
-  // TTY devices might not support multishot reads:
-  // https://github.com/axboe/liburing/issues/1185. We detect this by checking
-  // if the F_MORE flag is absent, then switch to single shot mode.
-  if (unlikely(!(result->flags & IORING_CQE_F_MORE))) {
-    *total += um_read_each_singleshot_loop(ctx);
-    return false;
+  if (likely(result->segment)) {
+    VALUE buf = rb_str_new(result->segment->ptr, result->segment->len);
+    um_segment_checkin(ctx->machine, result->segment);
+    result->segment = NULL;
+    rb_yield(buf);
+    RB_GC_GUARD(buf);
   }
 
   return true;
 }
 
-void read_recv_each_prep(struct io_uring_sqe *sqe, struct op_ctx *ctx) {
+static inline void read_recv_each_prep(struct io_uring_sqe *sqe, struct op_ctx *ctx) {
+  bp_ensure_commit_level(ctx->machine);
+  ctx->op->bp_commit_level = ctx->machine->bp_commit_level;
+
   switch (ctx->op->kind) {
     case OP_READ_MULTISHOT:
-      io_uring_prep_read_multishot(sqe, ctx->fd, 0, -1, ctx->bgid);
+      io_uring_prep_read_multishot(sqe, ctx->fd, 0, -1, BP_BGID);
       return;
     case OP_RECV_MULTISHOT:
       io_uring_prep_recv_multishot(sqe, ctx->fd, NULL, 0, 0);
-	    sqe->buf_group = ctx->bgid;
+	    sqe->buf_group = BP_BGID;
 	    sqe->flags |= IOSQE_BUFFER_SELECT;
       return;
     default:
-      return;
+      um_raise_internal_error("Invalid multishot op");
   }
 }
 
 VALUE read_recv_each_start(VALUE arg) {
   struct op_ctx *ctx = (struct op_ctx *)arg;
+
   struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
   read_recv_each_prep(sqe, ctx);
   int total = 0;
@@ -1558,19 +1504,19 @@ VALUE read_recv_each_start(VALUE arg) {
   return Qnil;
 }
 
-VALUE um_read_each(struct um *machine, int fd, int bgid) {
+VALUE um_read_each(struct um *machine, int fd) {
   struct um_op *op = um_op_acquire(machine);
-  um_prep_op(machine, op, OP_READ_MULTISHOT, 2, OP_F_MULTISHOT);
+  um_prep_op(machine, op, OP_READ_MULTISHOT, 2, OP_F_MULTISHOT | OP_F_BUFFER_POOL);
 
-  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .bgid = bgid, .read_buf = NULL };
+  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .read_buf = NULL };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
-VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
+VALUE um_recv_each(struct um *machine, int fd, int flags) {
   struct um_op *op = um_op_acquire(machine);
-  um_prep_op(machine, op, OP_RECV_MULTISHOT, 2, OP_F_MULTISHOT);
+  um_prep_op(machine, op, OP_RECV_MULTISHOT, 2, OP_F_MULTISHOT | OP_F_BUFFER_POOL);
 
-  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
+  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
@@ -1623,7 +1569,6 @@ extern VALUE SYM_ops_free;
 extern VALUE SYM_ops_transient;
 extern VALUE SYM_time_total_cpu;
 extern VALUE SYM_time_total_wait;
-extern VALUE SYM_buffer_groups;
 extern VALUE SYM_buffers_allocated;
 extern VALUE SYM_buffers_free;
 extern VALUE SYM_segments_free;

data/ext/um/um.h

@@ -56,7 +56,6 @@ enum um_op_kind {
   OP_RECV,
   OP_RECVMSG,
   OP_SEND,
-  OP_SEND_BUNDLE,
   OP_SENDMSG,
   OP_SENDV,
   OP_SOCKET,
@@ -80,12 +79,12 @@ enum um_op_kind {
   OP_TIMEOUT_MULTISHOT,
 };
 
-enum um_connection_mode {
-  CONNECTION_FD,
-  CONNECTION_SOCKET,
-  CONNECTION_SSL,
-  CONNECTION_STRING,
-  CONNECTION_IO_BUFFER
+enum um_io_mode {
+  IO_FD,
+  IO_SOCKET,
+  IO_SSL,
+  IO_STRING,
+  IO_IO_BUFFER
 };
 
 #define OP_F_CQE_SEEN       (1U << 0) // CQE has been seen
@@ -168,15 +167,6 @@ struct um_op {
   };
 };
 
-struct buf_ring_descriptor {
-  struct io_uring_buf_ring *br;
-  size_t br_size;
-  unsigned buf_count;
-  unsigned buf_size;
-  unsigned buf_mask;
-	void *buf_base;
-};
-
 struct um_metrics {
   ulong total_ops;                // total ops submitted
   ulong total_switches;           // total fiber switches
@@ -199,8 +189,6 @@ struct um_metrics {
   double time_first_cpu;          // last seen time stamp
 };
 
-#define BUFFER_RING_MAX_COUNT 10
-
 struct um {
   VALUE self;
 
@@ -216,13 +204,9 @@ struct um {
   pthread_t sidecar_thread;
   uint32_t *sidecar_signal;
 
-  uint buffer_ring_count; // number of registered buffer rings
-
   uint size; // size of SQ
   uint sqpoll_mode; // SQPOLL mode enabled
 
-  struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
-
   struct um_op *transient_head; // list of pending transient ops
   VALUE pending_fibers; // set containing pending fibers
 
@@ -272,11 +256,11 @@ struct um_async_op {
   struct um_op *op;
 };
 
-struct um_connection {
+struct um_io {
   VALUE self;
   struct um *machine;
 
-  enum um_connection_mode mode;
+  enum um_io_mode mode;
   union {
     int fd;
     VALUE target;
@@ -304,7 +288,7 @@ extern VALUE eUMError;
 extern VALUE cMutex;
 extern VALUE cQueue;
 extern VALUE cAsyncOp;
-extern VALUE eConnectionRESPError;
+extern VALUE eIORESPError;
 
 struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec, int sidecar_mode);
@@ -351,9 +335,7 @@ void um_raise_on_error_result(int result);
 int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size, int raise_on_bad_buffer);
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
 void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result);
-int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
-VALUE um_read_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 iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *total_len);
 void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv);
 
@@ -376,7 +358,7 @@ 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, size_t maxlen, ssize_t buffer_offset, __u64 file_offset);
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
-VALUE um_read_each(struct um *machine, int fd, int bgid);
+VALUE um_read_each(struct um *machine, int fd);
 VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t len);
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
@@ -405,9 +387,8 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
 VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags);
 size_t um_send_raw(struct um *machine, int fd, const char *buffer, size_t len, int flags);
 VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv);
-VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags);
-VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
+VALUE um_recv_each(struct um *machine, int fd, int flags);
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);
 VALUE um_listen(struct um *machine, int fd, int backlog);
 VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
@@ -438,16 +419,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);
 
-void connection_teardown(struct um_connection *conn);
-void connection_clear(struct um_connection *conn);
-VALUE connection_read_line(struct um_connection *conn, VALUE out_buffer, size_t maxlen);
-VALUE connection_read(struct um_connection *conn, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
-VALUE connection_read_to_delim(struct um_connection *conn, VALUE out_buffer, VALUE delim, ssize_t maxlen);
-void connection_skip(struct um_connection *conn, size_t inc, int safe_inc);
-void connection_read_each(struct um_connection *conn);
-size_t connection_write_raw(struct um_connection *conn, const char *buffer, size_t len);
-VALUE connection_writev(struct um_connection *conn, int argc, VALUE *argv);
-VALUE resp_read(struct um_connection *conn, VALUE out_buffer);
+void io_teardown(struct um_io *io);
+void io_clear(struct um_io *io);
+VALUE io_read_line(struct um_io *io, VALUE out_buffer, size_t maxlen);
+VALUE io_read(struct um_io *io, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
+VALUE io_read_to_delim(struct um_io *io, VALUE out_buffer, VALUE delim, ssize_t maxlen);
+void io_skip(struct um_io *io, size_t inc, int safe_inc);
+void io_read_each(struct um_io *io);
+size_t io_write_raw(struct um_io *io, const char *buffer, size_t len);
+VALUE io_writev(struct um_io *io, int argc, VALUE *argv);
+VALUE resp_read(struct um_io *io, 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);