polyphony 0.99 → 0.99.1

data/ext/polyphony/backend_io_uring.c

@@ -90,8 +90,16 @@ static VALUE Backend_initialize(VALUE self) {
   context_store_initialize(&backend->store);
 
   backend->prepared_limit = 1024;
+  int flags = 0;
+  #ifdef HAVE_IORING_SETUP_SUBMIT_ALL
+  flags |= IORING_SETUP_SUBMIT_ALL;
+  #endif
+  #ifdef HAVE_IORING_SETUP_COOP_TASKRUN
+  flags |= IORING_SETUP_COOP_TASKRUN;
+  #endif
+
   while (1) {
-    int ret = io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
+    int ret = io_uring_queue_init(backend->prepared_limit, &backend->ring, flags);
     if (!ret) break;
     
     // if ENOMEM is returned, use a smaller limit
@@ -141,23 +149,53 @@ void *io_uring_backend_poll_without_gvl(void *ptr) {
   return NULL;
 }
 
-// copied from queue.c
+// copied from liburing/queue.c
 static inline bool cq_ring_needs_flush(struct io_uring *ring) {
   return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
 }
 
+static void handle_multishot_accept_completion(op_context_t *ctx, struct io_uring_cqe *cqe, Backend_t *backend) {
+  // printf("handle_multishot_accept_completion result: %d\n", ctx->result);
+  if (ctx->result == -ECANCELED) {
+    context_store_release(&backend->store, ctx);
+    rb_ivar_set(ctx->resume_value, ID_ivar_multishot_accept_queue, Qnil);
+  }
+  else {
+    if (!(cqe->flags & IORING_CQE_F_MORE)) {
+      context_store_release(&backend->store, ctx);
+    }
+    VALUE queue = rb_ivar_get(ctx->resume_value, ID_ivar_multishot_accept_queue);
+    if (queue != Qnil)
+      Queue_push(queue, INT2NUM(ctx->result));
+  }
+}
+
+static void handle_multishot_completion(op_context_t *ctx, struct io_uring_cqe *cqe, Backend_t *backend) {
+  switch (ctx->type) {
+    case OP_MULTISHOT_ACCEPT:
+      return handle_multishot_accept_completion(ctx, cqe, backend);
+    default:
+      printf("Unexpected multishot completion for op type %d\n", ctx->type);
+  }
+}
+
 static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
   op_context_t *ctx = io_uring_cqe_get_data(cqe);
   if (!ctx) return;
 
   // printf("cqe ctx %p id: %d result: %d (%s, ref_count: %d)\n", ctx, ctx->id, cqe->res, op_type_to_str(ctx->type), ctx->ref_count);
   ctx->result = cqe->res;
-  if (ctx->ref_count == 2 && ctx->result != -ECANCELED && ctx->fiber)
-    Fiber_make_runnable(ctx->fiber, ctx->resume_value);
-  context_store_release(&backend->store, ctx);
+  if (ctx->ref_count == MULTISHOT_REFCOUNT) {
+    handle_multishot_completion(ctx, cqe, backend);
+  }
+  else {
+    if (ctx->ref_count == 2 && ctx->result != -ECANCELED && ctx->fiber)
+      Fiber_make_runnable(ctx->fiber, ctx->resume_value);
+    context_store_release(&backend->store, ctx);
+  }
 }
 
-// adapted from io_uring_peek_batch_cqe in queue.c
+// adapted from io_uring_peek_batch_cqe in liburing/queue.c
 // this peeks at cqes and handles each available cqe
 void io_uring_backend_handle_ready_cqes(Backend_t *backend) {
   struct io_uring *ring = &backend->ring;
@@ -701,7 +739,7 @@ VALUE Backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE po
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECVMSG);
     struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
@@ -904,7 +942,7 @@ VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE buffer, VALUE flags, VALUE des
 
   while (left > 0) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SENDMSG);
     struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
@@ -985,12 +1023,114 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
 }
 
 VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
+#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
+  VALUE accept_queue = rb_ivar_get(server_socket, ID_ivar_multishot_accept_queue);
+  if (accept_queue != Qnil) {
+    VALUE next = Queue_shift(0, 0, accept_queue);
+    int fd = NUM2INT(next);
+    if (fd < 0)
+      rb_syserr_fail(-fd, strerror(-fd));
+    else {
+      rb_io_t *fp;
+
+      VALUE socket = rb_obj_alloc(socket_class);
+      MakeOpenFile(socket, fp);
+      rb_update_max_fd(fd);
+      fp->fd = fd;
+      fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
+      rb_io_ascii8bit_binmode(socket);
+      rb_io_synchronized(fp);
+      return socket;
+    }
+  }
+#endif
+
   Backend_t *backend;
   GetBackend(self, backend);
   return io_uring_backend_accept(backend, server_socket, socket_class, 0);
 }
 
+#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
+
+struct multishot_accept_ctx {
+  Backend_t *backend;
+  VALUE server_socket;
+  op_context_t *op_ctx;
+};
+
+VALUE multishot_accept_start(struct multishot_accept_ctx *ctx) {
+  int server_fd;
+  rb_io_t *server_fptr;
+  server_fd = fd_from_io(ctx->server_socket, &server_fptr, 0, 0);
+  VALUE accept_queue = rb_funcall(cQueue, ID_new, 0);
+  rb_ivar_set(ctx->server_socket, ID_ivar_multishot_accept_queue, accept_queue);
+
+  ctx->op_ctx = context_store_acquire(&ctx->backend->store, OP_MULTISHOT_ACCEPT);
+  ctx->op_ctx->ref_count = -1;
+  ctx->op_ctx->resume_value = ctx->server_socket;
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(ctx->backend);
+  io_uring_prep_multishot_accept(sqe, server_fd, 0, 0, 0);
+  io_uring_sqe_set_data(sqe, ctx->op_ctx);
+  io_uring_backend_defer_submit(ctx->backend);
+
+  rb_yield(ctx->server_socket);
+
+  return Qnil;
+}
+
+VALUE multishot_accept_cleanup(struct multishot_accept_ctx *ctx) {
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(ctx->backend);
+  io_uring_prep_cancel(sqe, ctx->op_ctx, 0);
+  io_uring_sqe_set_data(sqe, NULL);
+  io_uring_backend_defer_submit(ctx->backend);
+
+  rb_ivar_set(ctx->server_socket, ID_ivar_multishot_accept_queue, Qnil);
+
+  return Qnil;
+}
+
+VALUE Backend_multishot_accept(VALUE self, VALUE server_socket) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  struct multishot_accept_ctx ctx;
+  ctx.backend = backend;
+  ctx.server_socket = server_socket;
+
+  return rb_ensure(
+    SAFE(multishot_accept_start), (VALUE)&ctx,
+    SAFE(multishot_accept_cleanup), (VALUE)&ctx
+  );
+}
+
+#endif
+
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
+#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
+  VALUE accept_queue = rb_ivar_get(server_socket, ID_ivar_multishot_accept_queue);
+  if (accept_queue != Qnil) {
+    while (true) {
+      VALUE next = Queue_shift(0, 0, accept_queue);
+      int fd = NUM2INT(next);
+      if (fd < 0)
+        rb_syserr_fail(-fd, strerror(-fd));
+      else {
+        rb_io_t *fp;
+
+        VALUE socket = rb_obj_alloc(socket_class);
+        MakeOpenFile(socket, fp);
+        rb_update_max_fd(fd);
+        fp->fd = fd;
+        fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
+        rb_io_ascii8bit_binmode(socket);
+        rb_io_synchronized(fp);
+        rb_yield(socket);
+      }
+    }
+    return self;
+  }
+#endif
+
   Backend_t *backend;
   GetBackend(self, backend);
   io_uring_backend_accept(backend, server_socket, socket_class, 1);
@@ -1801,7 +1941,7 @@ VALUE Backend_snooze(VALUE self) {
   GetBackend(self, backend);
 
   Fiber_make_runnable(fiber, Qnil);
-  ret = Thread_switch_fiber(rb_thread_current());
+  ret = backend_base_switch_fiber(self, &backend->base);
 
   COND_TRACE(&backend->base, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
 
@@ -1847,6 +1987,11 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
+
+  #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
+  rb_define_method(cBackend, "multishot_accept", Backend_multishot_accept, 1);
+  #endif
+
   rb_define_method(cBackend, "read", Backend_read, 5);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv", Backend_recv, 4);

data/ext/polyphony/backend_io_uring_context.c

@@ -6,18 +6,21 @@
 
 const char *op_type_to_str(enum op_type type) {
   switch (type) {
-  case OP_READ: return "READ";
-  case OP_WRITEV: return "WRITEV";
-  case OP_WRITE: return "WRITE";
-  case OP_RECV: return "RECV";
-  case OP_SEND: return "SEND";
-  case OP_SPLICE: return "SPLICE";
-  case OP_TIMEOUT: return "TIMEOUT";
-  case OP_POLL: return "POLL";
-  case OP_ACCEPT: return "ACCEPT";
-  case OP_CONNECT: return "CONNECT";
-  case OP_CHAIN: return "CHAIN";
-  case OP_CLOSE: return "CLOSE";
+  case OP_ACCEPT:   return "ACCEPT";
+  case OP_CHAIN:    return "CHAIN";
+  case OP_CLOSE:    return "CLOSE";
+  case OP_CONNECT:  return "CONNECT";
+  case OP_POLL:     return "POLL";
+  case OP_READ:     return "READ";
+  case OP_RECV:     return "RECV";
+  case OP_RECVMSG:  return "RECVMSG";
+  case OP_SEND:     return "SEND";
+  case OP_SENDMSG:  return "SENDMSG";
+  case OP_SPLICE:   return "SPLICE";
+  case OP_TIMEOUT:  return "TIMEOUT";
+  case OP_WRITEV:   return "WRITEV";
+  case OP_WRITE:    return "WRITE";
+
   default: return "";
   };
 }
@@ -66,6 +69,12 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
 
   assert(ctx->ref_count);
 
+  // If a multishot ctx is released, we pretend its ref count is 1, so it will
+  // be returned to the store.
+  if (ctx->ref_count == MULTISHOT_REFCOUNT) {
+    ctx->ref_count = 1;
+  }
+
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 

data/ext/polyphony/backend_io_uring_context.h

@@ -4,21 +4,26 @@
 #include "ruby.h"
 
 enum op_type {
+  OP_ACCEPT,
+  OP_CHAIN,
+  OP_CLOSE,
+  OP_CONNECT,
+  OP_MULTISHOT_ACCEPT,
   OP_NONE,
+  OP_POLL,
   OP_READ,
-  OP_WRITEV,
-  OP_WRITE,
   OP_RECV,
+  OP_RECVMSG,
   OP_SEND,
+  OP_SENDMSG,
   OP_SPLICE,
   OP_TIMEOUT,
-  OP_POLL,
-  OP_ACCEPT,
-  OP_CONNECT,
-  OP_CHAIN,
-  OP_CLOSE
+  OP_WRITEV,
+  OP_WRITE
 };
 
+#define MULTISHOT_REFCOUNT 0xFFFF
+
 typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;

data/ext/polyphony/backend_libev.c

@@ -1584,7 +1584,7 @@ VALUE Backend_snooze(VALUE self) {
   GetBackend(self, backend);
 
   Fiber_make_runnable(fiber, Qnil);
-  ret = Thread_switch_fiber(rb_thread_current());
+  ret = backend_base_switch_fiber(self, &backend->base);
 
   COND_TRACE(&backend->base, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
 

data/ext/polyphony/extconf.rb

@@ -18,7 +18,12 @@ def get_config
 
   combined_version = version.to_i * 100 + major_revision.to_i
 
-  config[:pidfd_open] = combined_version > 503
+  config[:pidfd_open]         = combined_version > 503
+  config[:multishot_recv]     = combined_version >= 600
+  config[:multishot_recvmsg]  = combined_version >= 600
+  config[:multishot_accept]   = combined_version >= 519
+  config[:submit_all_flag]    = combined_version >= 518
+  config[:coop_taskrun_flag]  = combined_version >= 519
 
   force_libev = ENV['POLYPHONY_LIBEV'] != nil
   config[:io_uring] = !force_libev && (combined_version >= 506) && (distribution != 'linuxkit')
@@ -46,24 +51,35 @@ if config[:io_uring]
   $LDFLAGS << " -L#{File.expand_path('../../vendor/liburing/src', __dir__)} -l uring"
 end
 
+def define_bool(name, value)
+  $defs << "-D#{name}=#{value ? 1 : 0 }"
+end
+
 $defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if config[:pidfd_open]
 if config[:io_uring]
   $defs << "-DPOLYPHONY_BACKEND_LIBURING"
   $defs << "-DPOLYPHONY_LINUX"
   $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
+  $defs << "-DHAVE_IO_URING_PREP_MULTISHOT_ACCEPT" if config[:multishot_accept]
+  $defs << "-DHAVE_IO_URING_PREP_RECV_MULTISHOT" if config[:multishot_recv]
+  $defs << "-DHAVE_IO_URING_PREP_RECVMSG_MULTISHOT" if config[:multishot_recvmsg]
+  $defs << "-DHAVE_IORING_SETUP_SUBMIT_ALL" if config[:submit_all_flag]
+  $defs << "-DHAVE_IORING_SETUP_COOP_TASKRUN" if config[:coop_taskrun_flag]
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
   $defs << "-DPOLYPHONY_LINUX" if config[:linux]
 
   $defs << "-DEV_STANDALONE" # prevent libev from assuming "config.h" exists
-  $defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
-  $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
-  $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
-  $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
-  $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
-  $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
-  
+
+  define_bool('EV_USE_EPOLL', have_header('sys/epoll.h'))
+  define_bool('EV_USE_KQUEUE', have_header('sys/event.h') && have_header('sys/queue.h'))
+  define_bool('EV_USE_LINUXAIO', have_header('linux/aio_abi.h'))
+  define_bool('EV_USE_POLL', have_type('port_event_t', 'poll.h'))
+  define_bool('EV_USE_PORT', have_type('port_event_t', 'port.h'))
+  define_bool('EV_USE_SELECT', have_header('sys/select.h'))
+  define_bool('EV_USE_IOCP', false)
+
   $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
   $CFLAGS << " -Wno-comment"

data/ext/polyphony/fiber.c

@@ -18,6 +18,8 @@ VALUE SYM_schedule;
 VALUE SYM_block;
 VALUE SYM_terminate;
 
+/* @!visibility private */
+
 static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
   VALUE arg = (argc == 0) ? Qnil : argv[0];
   VALUE ret = FIBER_TRANSFER(self, arg);
@@ -27,6 +29,8 @@ static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
   return ret;
 }
 
+/* @!visibility private */
+
 inline VALUE Fiber_auto_watcher(VALUE self) {
   VALUE watcher;
 
@@ -38,6 +42,8 @@ inline VALUE Fiber_auto_watcher(VALUE self) {
   return watcher;
 }
 
+/* @!visibility private */
+
 inline void Fiber_make_runnable(VALUE fiber, VALUE value) {
   VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
   if (thread == Qnil) rb_raise(rb_eRuntimeError, "No thread set for fiber");
@@ -45,6 +51,8 @@ inline void Fiber_make_runnable(VALUE fiber, VALUE value) {
   Thread_schedule_fiber(thread, fiber, value);
 }
 
+/* @!visibility private */
+
 inline void Fiber_make_runnable_with_priority(VALUE fiber, VALUE value) {
   VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
   if (thread == Qnil) rb_raise(rb_eRuntimeError, "No thread set for fiber");
@@ -52,18 +60,46 @@ inline void Fiber_make_runnable_with_priority(VALUE fiber, VALUE value) {
   Thread_schedule_fiber_with_priority(thread, fiber, value);
 }
 
+/* call-seq:
+ *   fiber.schedule
+ *   fiber.schedule(value)
+ * 
+ * Adds the fiber to the runqueue with the given resume value or `nil`.
+ * 
+ * @return [void]
+ */
+
 static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
   VALUE value = (argc == 0) ? Qnil : argv[0];
   Fiber_make_runnable(self, value);
   return self;
 }
 
+/* call-seq:
+ *   fiber.schedule_with_priority
+ *   fiber.schedule_with_priority(value)
+ * 
+ * Adds the fiber to the head of the runqueue with the given resume value or
+ * `nil`.
+ * 
+ * @return [void]
+ */
+
 static VALUE Fiber_schedule_with_priority(int argc, VALUE *argv, VALUE self) {
   VALUE value = (argc == 0) ? Qnil : argv[0];
   Fiber_make_runnable_with_priority(self, value);
   return self;
 }
 
+/* call-seq:
+ *   fiber.state -> sym
+ * 
+ * Returns the current state for the fiber, one of `:running`, `:runnable`,
+ * `:waiting`, `:dead`.
+ * 
+ * @return [Symbol]
+ */
+
 static VALUE Fiber_state(VALUE self) {
   if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
     return SYM_dead;
@@ -73,16 +109,35 @@ static VALUE Fiber_state(VALUE self) {
   return SYM_waiting;
 }
 
-VALUE Fiber_send(VALUE self, VALUE value) {
+/* call-seq:
+ *   fiber.send(msg)
+ * 
+ * Sends a message to the given fiber. The message will be added to the fiber's
+ * mailbox.
+ * 
+ * @param msg [any]
+ * @return [void]
+ */
+
+VALUE Fiber_send(VALUE self, VALUE msg) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   if (mailbox == Qnil) {
     mailbox = rb_funcall(cQueue, ID_new, 0);
     rb_ivar_set(self, ID_ivar_mailbox, mailbox);
   }
-  Queue_push(mailbox, value);
+  Queue_push(mailbox, msg);
   return self;
 }
 
+/* call-seq:
+ *   fiber.receive -> msg
+ * 
+ * Receive's a message from the fiber's mailbox. If no message is available,
+ * waits for a message to be sent to it.
+ * 
+ * @return [any] received message
+ */
+
 VALUE Fiber_receive(VALUE self) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   if (mailbox == Qnil) {
@@ -92,6 +147,14 @@ VALUE Fiber_receive(VALUE self) {
   return Queue_shift(0, 0, mailbox);
 }
 
+/* call-seq:
+ *   fiber.mailbox -> queue
+ * 
+ * Returns the fiber's mailbox.
+ * 
+ * @return [Queue]
+ */
+
 VALUE Fiber_mailbox(VALUE self) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   if (mailbox == Qnil) {
@@ -101,23 +164,37 @@ VALUE Fiber_mailbox(VALUE self) {
   return mailbox;
 }
 
+/* call-seq:
+ *   fiber.receive_all_pending -> ary
+ * 
+ * Receives all messages currently in the fiber's mailbox.
+ * 
+ * @return [Array]
+ */
+
 VALUE Fiber_receive_all_pending(VALUE self) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   return (mailbox == Qnil) ? rb_ary_new() : Queue_shift_all(mailbox);
 }
 
+/* @!visibility private */
+
 VALUE Fiber_park(VALUE self) {
   rb_ivar_set(self, ID_ivar_parked, Qtrue);
   Backend_park_fiber(BACKEND(), self);
   return self;
 }
 
+/* @!visibility private */
+
 VALUE Fiber_unpark(VALUE self) {
   rb_ivar_set(self, ID_ivar_parked, Qnil);
   Backend_unpark_fiber(BACKEND(), self);
   return self;
 }
 
+/* @!visibility private */
+
 VALUE Fiber_parked_p(VALUE self) {
   return rb_ivar_get(self, ID_ivar_parked);
 }

data/ext/polyphony/io_extensions.c

@@ -507,6 +507,16 @@ static inline VALUE z_stream_cleanup(struct z_stream_ctx *ctx) {
 #define Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx) \
   rb_ensure(SAFE(z_stream_io_loop), (VALUE)&ctx, SAFE(z_stream_cleanup), (VALUE)&ctx)
 
+/* call-seq:
+ *   IO.gzip(src, dest) -> bytes_written
+ *   IO.gzip(src, dest, opt) -> bytes_written
+ *
+ * Gzips data from the source IO to the destination IO, returning the number
+ * bytes written to the destination IO.
+ * 
+ * @return [Integer]
+ */
+
 VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   VALUE src;
   VALUE dest;
@@ -538,6 +548,16 @@ VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
 
 # define FIX2TIME(v) (rb_funcall(rb_cTime, ID_at, 1, v))
 
+/* call-seq:
+ *   IO.gunzip(src, dest) -> bytes_written
+ *   IO.gunzip(src, dest, opt) -> bytes_written
+ *
+ * Gunzips data from the source IO to the destination IO, returning the number
+ * bytes written to the destination IO.
+ * 
+ * @return [Integer]
+ */
+
 VALUE IO_gunzip(int argc, VALUE *argv, VALUE self) {
   VALUE src;
   VALUE dest;
@@ -574,6 +594,16 @@ VALUE IO_gunzip(int argc, VALUE *argv, VALUE self) {
   return INT2FIX(ctx.out_total);
 }
 
+/* call-seq:
+ *   IO.deflate(src, dest) -> bytes_written
+ *   IO.deflate(src, dest, opt) -> bytes_written
+ *
+ * Defaltes data from the source IO to the destination IO, returning the number
+ * bytes written to the destination IO.
+ * 
+ * @return [Integer]
+ */
+
 VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
   struct z_stream_ctx ctx;
   int level = DEFAULT_LEVEL;
@@ -589,6 +619,16 @@ VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
   return INT2FIX(ctx.out_total);
 }
 
+/* call-seq:
+ *   IO.inflate(src, dest) -> bytes_written
+ *   IO.inflate(src, dest, opt) -> bytes_written
+ *
+ * Inflates data from the source IO to the destination IO, returning the number
+ * bytes written to the destination IO.
+ * 
+ * @return [Integer]
+ */
+
 VALUE IO_inflate(VALUE self, VALUE src, VALUE dest) {
   struct z_stream_ctx ctx;
   int ret;
@@ -603,6 +643,19 @@ VALUE IO_inflate(VALUE self, VALUE src, VALUE dest) {
   return INT2FIX(ctx.out_total);
 }
 
+/* call-seq:
+ *   IO.http1_splice_chunked(src, dest, maxlen)
+ *
+ * Splices data from the source IO to the destination IO, writing it in HTTP1
+ * chunked encoding. A pipe is automatically created to buffer data between
+ * source and destination.
+ * 
+ * @param src [IO] source
+ * @param dest [IO] destination
+ * @param maxlen [Integer] maximum bytes to splice
+ * @return [Integer] bytes spliced
+ */
+
 VALUE IO_http1_splice_chunked(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   enum write_method method = detect_write_method(dest);
   VALUE backend = BACKEND();