polyphony 0.84 → 0.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce9742f5b50581c5569df4ad3e2232c7c32392a92e7ab23960373c8a4e3b0de4
-  data.tar.gz: a695f3191cc7cefb7d720565c3564b24784beb836528342e8d4fd9e8d0231dda
+  metadata.gz: b87dae4e2c17055e8206c820a4281774cdf3127195173948c97df4eb09a2bd13
+  data.tar.gz: 2e7bd958ec7435569423398069223eda41e9c2d89f580627bc22e9054276dd1c
 SHA512:
-  metadata.gz: 041cb949e600ef328ed6d1c92badcaa9ef502e4776043d6a7786a811d5935de450f933b8eff4dd6100db6e55ff19878186bd9ef6bb840ac1cdcdb8c53341f51c
-  data.tar.gz: fc0542606c3ee5ab044cc5e8175a60fb3fa6a8466422643ff1446fb0271a6db09236b5c0dbc7a632fa47853ae0ac3a2007fa4644a85283b4225f453f6155dbce
+  metadata.gz: 48f6489939da965463735c83acb4372263eb44b48b5a16da1e704a15e3af971a5d43abd7da5e44f2455b40d880413c6fa8159794e663176c83a11eddebdebc7d
+  data.tar.gz: 3ada5f9041041e91b6b2a7f31ec609352752317e87c51df090517c9e2b556d9ef69ef8842babd15f25b2257c4226431520ff15df505748cb38bb4a1d5a19063c

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.86 2022-03-14
+
+- Fix gemspec
+
+## 0.85 2022-03-13
+
+- Reduce write ops in `IO.gzip` (#77)
+- Add support for read/write method detection for compression/decompression
+  methods (#77)
+- Improve `Fiber#shutdown_all_children`
+- Improve io_uring `wait_event` implementation (share single I/O poll across
+  multiple fibers)
+- Fix io_uring `write` file offset
+
 ## 0.84 2022-03-11
 
 - Implement `IO.tee` (#82)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.84)
+    polyphony (0.86)
 
 GEM
   remote: https://rubygems.org/

data/Rakefile

@@ -33,7 +33,7 @@ task :release do
   `gem build polyphony.gemspec`
 
   puts "Pushing polyphony #{version}..."
-  `gem push extralite-#{version}.gem`
+  `gem push polyphony-#{version}.gem`
 
   puts "Cleaning up..."
   `rm *.gem`

data/examples/core/multi_suspend.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+
+  def monotonic_clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
+end
+
+count = 10000
+
+count.times do
+  spin { Polyphony.backend_wait_event(true) }
+end
+
+trace 'sleeping...'
+sleep 1
+
+trace 'shutting down children...'
+Fiber.current.shutdown_all_children
+trace 'done'

data/examples/core/shutdown_all_children.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+
+  def monotonic_clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
+end
+
+count = 10
+
+f = spin do
+  count.times { spin { suspend } }
+  suspend
+end
+
+snooze
+trace children_alive: f.children.size
+
+trace 'shutting down children...'
+f.shutdown_all_children
+
+trace children_alive: f.children.size

data/examples/io/gzip.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+require 'polyphony'
+
+IO.gzip(STDIN, STDOUT)

data/examples/io/splice_echo_server.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+require 'polyphony'
+
+def handle_echo_client(conn)
+  buffer = Polyphony.pipe
+  spin { buffer.splice_to_eof_from(conn) }
+  spin { conn.splice_to_eof_from(buffer) }
+end
+
+puts "Serving echo on port 1234..."
+TCPServer.new('127.0.0.1', 1234).accept_loop { |c| handle_echo_client(c) }

data/ext/polyphony/backend_io_uring.c

@@ -41,8 +41,10 @@ typedef struct Backend_t {
   op_context_store_t  store;
   unsigned int        pending_sqes;
   unsigned int        prepared_limit;
-  int                 event_fd;
   int                 ring_initialized;
+
+  int                 event_fd;
+  op_context_t        *event_fd_ctx;
 } Backend_t;
 
 static void Backend_mark(void *ptr) {
@@ -83,6 +85,7 @@ static VALUE Backend_initialize(VALUE self) {
   backend->pending_sqes = 0;
   backend->ring_initialized = 0;
   backend->event_fd = -1;
+  backend->event_fd_ctx = NULL;
 
   context_store_initialize(&backend->store);
 
@@ -183,13 +186,21 @@ done:
   return;
 }
 
+inline void io_uring_backend_immediate_submit(Backend_t *backend) {
+  backend->pending_sqes = 0;
+  io_uring_submit(&backend->ring);
+}
+
+inline void io_uring_backend_defer_submit(Backend_t *backend) {
+  backend->pending_sqes += 1;
+  if (backend->pending_sqes >= backend->prepared_limit)
+    io_uring_backend_immediate_submit(backend);
+}
+
 void io_uring_backend_poll(Backend_t *backend) {
   poll_context_t poll_ctx;
   poll_ctx.ring = &backend->ring;
-  if (backend->pending_sqes) {
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
-  }
+  if (backend->pending_sqes) io_uring_backend_immediate_submit(backend);
 
 wait_cqe:
   backend->base.currently_polling = 1;
@@ -211,10 +222,7 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
 
   backend->base.poll_count++;
 
-  if (!is_blocking && backend->pending_sqes) {
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
-  }
+  if (!is_blocking && backend->pending_sqes) io_uring_backend_immediate_submit(backend);
 
   COND_TRACE(&backend->base, 2, SYM_enter_poll, rb_fiber_current());
   
@@ -263,8 +271,7 @@ VALUE Backend_wakeup(VALUE self) {
     // NOP which would cause the io_uring_enter syscall to return
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_nop(sqe);
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
+    io_uring_backend_immediate_submit(backend);
 
     return Qtrue;
   }
@@ -272,14 +279,6 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
-inline void io_uring_backend_defer_submit(Backend_t *backend) {
-  backend->pending_sqes += 1;
-  if (backend->pending_sqes >= backend->prepared_limit) {
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
-  }
-}
-
 int io_uring_backend_defer_submit_and_await(
   Backend_t *backend,
   struct io_uring_sqe *sqe,
@@ -305,8 +304,7 @@ int io_uring_backend_defer_submit_and_await(
     ctx->result = -ECANCELED;
     sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
+    io_uring_backend_immediate_submit(backend);
   }
 
   if (value_ptr) (*value_ptr) = switchpoint_result;
@@ -552,7 +550,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fd, buffer.ptr, left, 0);
+    io_uring_prep_write(sqe, fd, buffer.ptr, left, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -1161,8 +1159,7 @@ VALUE Backend_timeout_ensure(VALUE arg) {
     // op was not completed, so we need to cancel it
     sqe = io_uring_get_sqe(&timeout_ctx->backend->ring);
     io_uring_prep_cancel(sqe, (__u64)timeout_ctx->ctx, 0);
-    timeout_ctx->backend->pending_sqes = 0;
-    io_uring_submit(&timeout_ctx->backend->ring);
+    io_uring_backend_immediate_submit(timeout_ctx->backend);
   }
   context_store_release(&timeout_ctx->backend->store, timeout_ctx->ctx);
   return Qnil;
@@ -1237,6 +1234,13 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 
+/*
+Blocks a fiber indefinitely. This is accomplished by using an eventfd that will
+never be signalled. The eventfd is needed so we could do a blocking polling for
+completions even when no other I/O operations are pending.
+
+The eventfd is refcounted in order to allow multiple fibers to be blocked.
+*/
 VALUE Backend_wait_event(VALUE self, VALUE raise) {
   Backend_t *backend;
   VALUE resume_value;
@@ -1251,7 +1255,32 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
     }
   }
 
-  resume_value = io_uring_backend_wait_fd(backend, backend->event_fd, 0);
+  if (!backend->event_fd_ctx) {
+    struct io_uring_sqe *sqe;
+
+    backend->event_fd_ctx = context_store_acquire(&backend->store, OP_POLL);
+    sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_poll_add(sqe, backend->event_fd, POLLIN);
+    backend->base.op_count++;
+    io_uring_sqe_set_data(sqe, backend->event_fd_ctx);
+    io_uring_backend_defer_submit(backend);
+  }
+  else
+    backend->event_fd_ctx->ref_count += 1;
+
+  resume_value = backend_await((struct Backend_base *)backend);
+  context_store_release(&backend->store, backend->event_fd_ctx);
+
+  if (backend->event_fd_ctx->ref_count == 1) {
+
+    // last fiber to use the eventfd, so we cancel the ongoing poll
+    struct io_uring_sqe *sqe;
+    sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_cancel(sqe, (__u64)backend->event_fd_ctx, 0);
+    io_uring_backend_immediate_submit(backend);
+    backend->event_fd_ctx = NULL;
+  }
+
   if (RTEST(raise)) RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
   return resume_value;
@@ -1354,8 +1383,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
         ctx->result = -ECANCELED;
         sqe = io_uring_get_sqe(&backend->ring);
         io_uring_prep_cancel(sqe, (__u64)ctx, 0);
-        backend->pending_sqes = 0;
-        io_uring_submit(&backend->ring);
+        io_uring_backend_immediate_submit(backend);
       }
       else {
         ctx->ref_count = 1;
@@ -1385,8 +1413,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     ctx->result = -ECANCELED;
     sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
-    backend->pending_sqes = 0;
-    io_uring_submit(&backend->ring);
+    io_uring_backend_immediate_submit(backend);
     RAISE_IF_EXCEPTION(resume_value);
     return resume_value;
   }
@@ -1452,8 +1479,7 @@ static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
   ctx->result = -ECANCELED;
   sqe = io_uring_get_sqe(&backend->ring);
   io_uring_prep_cancel(sqe, (__u64)ctx, 0);
-  backend->pending_sqes = 0;
-  io_uring_submit(&backend->ring);
+  io_uring_backend_immediate_submit(backend);
 }
 
 static inline int splice_chunks_await_ops(

data/ext/polyphony/io_extensions.c

@@ -13,24 +13,68 @@
 
 ID ID_at;
 ID ID_read_method;
+ID ID_readpartial;
 ID ID_to_i;
 ID ID_write_method;
+ID ID_write;
 
+VALUE SYM_backend_read;
+VALUE SYM_backend_recv;
+VALUE SYM_backend_send;
+VALUE SYM_backend_write;
+VALUE SYM_call;
+VALUE SYM_comment;
 VALUE SYM_mtime;
 VALUE SYM_orig_name;
-VALUE SYM_comment;
+VALUE SYM_readpartial;
 
 enum read_method {
   RM_BACKEND_READ,
-  RM_BACKEND_RECV
+  RM_BACKEND_RECV,
+  RM_READPARTIAL,
+  RM_CALL
 };
 
 enum write_method {
   WM_BACKEND_WRITE,
-  WM_BACKEND_SEND
+  WM_BACKEND_SEND,
+  WM_WRITE,
+  WM_CALL
 };
 
-#define print_buffer(prefix, ptr, len) { \
+static enum read_method detect_read_method(VALUE io) {
+  if (rb_respond_to(io, ID_read_method)) {
+    VALUE method = rb_funcall(io, ID_read_method, 0);
+    if (method == SYM_readpartial)  return RM_READPARTIAL;
+    if (method == SYM_backend_read) return RM_BACKEND_READ;
+    if (method == SYM_backend_recv) return RM_BACKEND_RECV;
+    if (method == SYM_call)         return RM_CALL;
+
+    rb_raise(rb_eRuntimeError, "Given io instance uses unsupported read method");
+  }
+  else if (rb_respond_to(io, ID_call))
+    return RM_CALL;
+  else
+    rb_raise(rb_eRuntimeError, "Given io instance should be a callable or respond to #__read_method__");
+}
+
+static enum write_method detect_write_method(VALUE io) {
+  if (rb_respond_to(io, ID_write_method)) {
+    VALUE method = rb_funcall(io, ID_write_method, 0);
+    if (method == SYM_readpartial)    return WM_WRITE;
+    if (method == SYM_backend_write)  return WM_BACKEND_WRITE;
+    if (method == SYM_backend_send)   return WM_BACKEND_SEND;
+    if (method == SYM_call)           return WM_CALL;
+
+    rb_raise(rb_eRuntimeError, "Given io instance uses unsupported write method");
+  }
+  else if (rb_respond_to(io, ID_call))
+    return WM_CALL;
+  else
+    rb_raise(rb_eRuntimeError, "Given io instance should be a callable or respond to #__write_method__");
+}
+
+#define PRINT_BUFFER(prefix, ptr, len) { \
   printf("%s buffer (%d): ", prefix, (int)len); \
   for (int i = 0; i < len; i++) printf("%02X ", ptr[i]); \
   printf("\n"); \
@@ -40,6 +84,7 @@ enum write_method {
 #define MAX_WRITE_STR_LEN 16384
 #define DEFAULT_LEVEL 9
 #define DEFAULT_MEM_LEVEL 8
+#define GZIP_FOOTER_LEN 8
 
 /* from zutil.h */
 #define OS_MSDOS    0x00
@@ -63,14 +108,64 @@ enum write_method {
 #define OS_CODE  OS_UNIX
 #endif
 
+
 static inline int read_to_raw_buffer(VALUE backend, VALUE io, enum read_method method, struct raw_buffer *buffer) {
-  VALUE len = Backend_read(backend, io, PTR2FIX(buffer), Qnil, Qfalse, INT2FIX(0));
-  return (len == Qnil) ? 0 : FIX2INT(len);
+  switch (method) {
+    case RM_BACKEND_READ: {
+      VALUE len = Backend_read(backend, io, PTR2FIX(buffer), Qnil, Qfalse, INT2FIX(0));
+      return (len == Qnil) ? 0 : FIX2INT(len);
+    }
+    case RM_BACKEND_RECV: {
+      VALUE len = Backend_recv(backend, io, PTR2FIX(buffer), Qnil, INT2FIX(0));
+      return (len == Qnil) ? 0 : FIX2INT(len);
+    }
+    case RM_READPARTIAL: {
+      VALUE str = rb_funcall(io, ID_readpartial, 1, INT2FIX(buffer->len));
+      int len = RSTRING_LEN(str);
+      if (len) memcpy(buffer->ptr, RSTRING_PTR(str), len);
+      RB_GC_GUARD(str);
+      return len;
+    }
+    case RM_CALL: {
+      VALUE str = rb_funcall(io, ID_call, INT2FIX(buffer->len));
+      if (TYPE(str) != T_STRING)
+        rb_raise(rb_eRuntimeError, "io#call must return a string");
+      int len = RSTRING_LEN(str);
+      if (len > buffer->len) len = buffer->len;
+      if (len) memcpy(buffer->ptr, RSTRING_PTR(str), len);
+      RB_GC_GUARD(str);
+      return len;
+    }
+  }
 }
 
 static inline int write_from_raw_buffer(VALUE backend, VALUE io, enum write_method method, struct raw_buffer *buffer) {
-  VALUE len = Backend_write(backend, io, PTR2FIX(buffer));
-  return FIX2INT(len);
+  switch (method) {
+    case WM_BACKEND_WRITE: {
+      VALUE len = Backend_write(backend, io, PTR2FIX(buffer));
+      return FIX2INT(len);
+    }
+    case WM_BACKEND_SEND: {
+      VALUE len = Backend_send(backend, io, PTR2FIX(buffer), INT2FIX(0));
+      return FIX2INT(len);
+    }
+    case WM_WRITE: {
+      VALUE str = rb_str_new(0, buffer->len);
+      memcpy(RSTRING_PTR(str), buffer->ptr, buffer->len);
+      rb_str_modify_expand(str, buffer->len);
+      rb_funcall(io, ID_write, 1, str);
+      RB_GC_GUARD(str);
+      return buffer->len;
+    }
+    case WM_CALL: {
+      VALUE str = rb_str_new(0, buffer->len);
+      memcpy(RSTRING_PTR(str), buffer->ptr, buffer->len);
+      rb_str_modify_expand(str, buffer->len);
+      rb_funcall(io, ID_call, 1, str);
+      RB_GC_GUARD(str);
+      return buffer->len;
+    }
+  }
 }
 
 static inline int write_c_string_from_str(VALUE str, struct raw_buffer *buffer) {
@@ -165,12 +260,12 @@ int gzip_prepare_header(struct gzip_header_ctx *ctx, char *buffer, int maxlen) {
 }
 
 int gzip_prepare_footer(unsigned long crc32, unsigned long total_in, char *buffer, int maxlen) {
-  assert(maxlen >= 8);
+  assert(maxlen >= GZIP_FOOTER_LEN);
 
   gzfile_set32(crc32, buffer);
   gzfile_set32(total_in, buffer + 4);
 
-  return 8;
+  return GZIP_FOOTER_LEN;
 }
 
 enum stream_mode {
@@ -183,7 +278,11 @@ struct z_stream_ctx {
   VALUE src;
   VALUE dest;
 
+  enum read_method src_read_method;
+  enum write_method dest_write_method;
+
   enum stream_mode mode;
+  int f_gzip_footer; // should a gzip footer be generated
   z_stream strm;
 
   unsigned char in[CHUNK];
@@ -216,11 +315,11 @@ void gzip_read_header(struct z_stream_ctx *ctx, struct gzip_header_ctx *header_c
   int flags;
 
   while (ctx->in_total < 10) {
-    int read = read_to_raw_buffer(ctx->backend, ctx->src, RM_BACKEND_READ, &in_buffer);
+    int read = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
     if (read == 0) goto error;
     ctx->in_total += read;
   }
-  // print_buffer("read gzip header", ctx->in, ctx->in_total);
+  // PRINT_BUFFER("read gzip header", ctx->in, ctx->in_total);
   if (ctx->in[0] != GZ_MAGIC1) goto error;
   if (ctx->in[1] != GZ_MAGIC2) goto error;
   if (ctx->in[2] != GZ_METHOD_DEFLATE) goto error;
@@ -245,9 +344,6 @@ error:
   rb_raise(rb_eRuntimeError, "Invalid gzip header");
 }
 
-// void gzip_read_footer(struct z_stream_ctx *ctx, struct gzip_footer_ctx *footer_ctx) {  
-// }
-
 static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, int eof) {
   int ret;
   int written;
@@ -260,8 +356,14 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
   written = avail_out_pre - ctx->strm.avail_out;
   out_buffer.ptr = ctx->out;
   out_buffer.len = ctx->out_pos + written;
+
+  if (eof && ctx->f_gzip_footer && (CHUNK - out_buffer.len >= GZIP_FOOTER_LEN)) {
+    gzip_prepare_footer(ctx->crc32, ctx->in_total, out_buffer.ptr + out_buffer.len, 8);
+    out_buffer.len += GZIP_FOOTER_LEN;
+  }
+
   if (out_buffer.len) {
-    ret = write_from_raw_buffer(ctx->backend, ctx->dest, WM_BACKEND_WRITE, &out_buffer);
+    ret = write_from_raw_buffer(ctx->backend, ctx->dest, ctx->dest_write_method, &out_buffer);
     if (ctx->mode == SM_INFLATE)
       ctx->crc32 = crc32(ctx->crc32, out_buffer.ptr + ctx->out_pos, written);
     ctx->out_total += ret - ctx->out_pos;
@@ -271,7 +373,7 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
 }
 
 void z_stream_io_loop(struct z_stream_ctx *ctx) {
-  zlib_func fun = (ctx->mode == SM_DEFLATE) ? deflate : inflate;  
+  zlib_func fun = (ctx->mode == SM_DEFLATE) ? deflate : inflate;
 
   if (ctx->in_total > ctx->in_pos) {
     // In bytes already read for parsing gzip header, so we need to process the
@@ -289,7 +391,7 @@ void z_stream_io_loop(struct z_stream_ctx *ctx) {
   while (1) {
     struct raw_buffer in_buffer = {ctx->in, CHUNK};
     ctx->strm.next_in = ctx->in;
-    int read_len = ctx->strm.avail_in = read_to_raw_buffer(ctx->backend, ctx->src, RM_BACKEND_READ, &in_buffer);
+    int read_len = ctx->strm.avail_in = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
     if (!read_len) break;
     int eof = read_len < CHUNK;
 
@@ -297,7 +399,7 @@ void z_stream_io_loop(struct z_stream_ctx *ctx) {
       ctx->crc32 = crc32(ctx->crc32, ctx->in, read_len);
     ctx->in_total += read_len;
 
-    // print_buffer("read stream", ctx->in, read_len);
+    // PRINT_BUFFER("read stream", ctx->in, read_len);
 
     while (1) {
       // z_stream_write_out returns strm.avail_out. If there's still room in the
@@ -318,7 +420,10 @@ static inline void setup_ctx(struct z_stream_ctx *ctx, enum stream_mode mode, VA
   ctx->backend = BACKEND();
   ctx->src = src;
   ctx->dest = dest;
+  ctx->src_read_method = detect_read_method(src);
+  ctx->dest_write_method = detect_write_method(dest);
   ctx->mode = mode;
+  ctx->f_gzip_footer = 0;
   ctx->strm.zalloc = Z_NULL;
   ctx->strm.zfree = Z_NULL;
   ctx->strm.opaque = Z_NULL;
@@ -349,14 +454,12 @@ VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   int ret;
 
   setup_ctx(&ctx, SM_DEFLATE, src, dest);
+  ctx.f_gzip_footer = 1; // write gzip footer
   ctx.out_pos = gzip_prepare_header(&header_ctx, ctx.out, sizeof(ctx.out));
 
   ret = deflateInit2(&ctx.strm, level, Z_DEFLATED, -MAX_WBITS, DEFAULT_MEM_LEVEL, Z_DEFAULT_STRATEGY);
   if (ret != Z_OK) return INT2FIX(ret);
   z_stream_io_loop(&ctx);
-  int footer_len = gzip_prepare_footer(ctx.crc32, ctx.in_total, ctx.out, sizeof(ctx.out));
-  struct raw_buffer footer_buffer = {ctx.out, footer_len};
-  write_from_raw_buffer(ctx.backend, dest, WM_BACKEND_WRITE, &footer_buffer);
   deflateEnd(&ctx.strm);
  
   return INT2FIX(ctx.out_total);
@@ -431,10 +534,18 @@ void Init_IOExtensions() {
 
   ID_at           = rb_intern("at");
   ID_read_method  = rb_intern("__read_method__");
+  ID_readpartial  = rb_intern("readpartial");
   ID_to_i         = rb_intern("to_i");
   ID_write_method = rb_intern("__write_method__");
-
-  SYM_mtime     = ID2SYM(rb_intern("mtime"));
-  SYM_orig_name = ID2SYM(rb_intern("orig_name"));
-  SYM_comment   = ID2SYM(rb_intern("comment"));
+  ID_write        = rb_intern("write");
+
+  SYM_backend_read  = ID2SYM(rb_intern("backend_read"));
+  SYM_backend_recv  = ID2SYM(rb_intern("backend_recv"));
+  SYM_backend_send  = ID2SYM(rb_intern("backend_send"));
+  SYM_backend_write = ID2SYM(rb_intern("backend_write"));
+  SYM_call          = ID2SYM(rb_intern("call"));
+  SYM_comment       = ID2SYM(rb_intern("comment"));
+  SYM_mtime         = ID2SYM(rb_intern("mtime"));
+  SYM_orig_name     = ID2SYM(rb_intern("orig_name"));
+  SYM_readpartial   = ID2SYM(rb_intern("readpartial"));
 }

data/lib/polyphony/extensions/fiber.rb

@@ -390,12 +390,14 @@ module Polyphony
     def shutdown_all_children(graceful = false)
       return self unless @children
 
+      pending = []
       @children.keys.each do |c|
         next if c.dead?
 
         c.terminate(graceful)
-        c.await
+        pending << c
       end
+      Fiber.await(*pending)
       self
     end
 

data/lib/polyphony/extensions/io.rb

@@ -96,6 +96,10 @@ class ::IO
     :backend_read
   end
 
+  def __write_method__
+    :backend_write
+  end
+
   # def each(sep = $/, limit = nil, chomp: nil)
   #   sep, limit = $/, sep if sep.is_a?(Integer)
   # end

data/lib/polyphony/extensions/pipe.rb

@@ -6,6 +6,10 @@ class Polyphony::Pipe
     :backend_read
   end
 
+  def __write_method__
+    :backend_write
+  end
+
   def getbyte
     char = getc
     char ? char.getbyte(0) : nil

data/lib/polyphony/extensions/socket.rb

@@ -14,6 +14,10 @@ class BasicSocket
   def __read_method__
     :backend_recv
   end
+
+  def __write_method__
+    :backend_send
+  end
 end
 
 # Socket extensions # TODO: rewrite in C