polyphony 0.87 → 0.91

data/ext/polyphony/backend_libev.c

@@ -291,7 +291,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   rb_io_t *fptr;
 
   struct io_buffer buffer = get_io_buffer(str);
-  long buf_pos = NUM2INT(pos);
+  long buf_pos = FIX2INT(pos);
   int shrinkable_string = 0;
   int expandable_buffer = 0;
   long total = 0;
@@ -311,7 +311,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
     if (string_cap < expected_read_length + buf_pos) {
       shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
-      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -353,7 +353,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
         rb_str_resize(str, total + buf_pos);
         rb_str_modify_expand(str, rb_str_capacity(str));
         shrinkable_string = 0;
-        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.ptr = (unsigned char *)RSTRING_PTR(str) + total + buf_pos;
         buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
@@ -389,7 +389,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = NUM2INT(maxlen);
+  long len = FIX2INT(maxlen);
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
@@ -519,7 +519,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(buffer.len);
+  return INT2FIX(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -590,7 +590,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   RB_GC_GUARD(switchpoint_result);
 
   free(iov);
-  return INT2NUM(total_written);
+  return INT2FIX(total_written);
 error:
   free(iov);
   return RAISE_EXCEPTION(switchpoint_result);
@@ -763,7 +763,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   struct io_buffer buffer = get_io_buffer(str);
   long left = buffer.len;
-  int flags_int = NUM2INT(flags);
+  int flags_int = FIX2INT(flags);
 
   GetBackend(self, backend);
   fd = fd_from_io(io, &fptr, 1, 0);
@@ -795,7 +795,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(buffer.len);
+  return INT2FIX(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -868,7 +868,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (1) {
     backend->base.op_count++;
-    len = splice(src_fd, 0, dest_fd, 0, NUM2INT(maxlen), 0);
+    len = splice(src_fd, 0, dest_fd, 0, FIX2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
@@ -889,7 +889,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2FIX(len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -912,7 +912,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (1) {
     backend->base.op_count++;
-    len = splice(src_fd, 0, dest_fd, 0, NUM2INT(maxlen), 0);
+    len = splice(src_fd, 0, dest_fd, 0, FIX2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
@@ -936,7 +936,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(total);
+  return INT2FIX(total);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -958,7 +958,7 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (1) {
     backend->base.op_count++;
-    len = tee(src_fd, dest_fd, NUM2INT(maxlen), 0);
+    len = tee(src_fd, dest_fd, FIX2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
@@ -979,7 +979,7 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2FIX(len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -994,7 +994,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
-  int len = NUM2INT(maxlen);
+  int len = FIX2INT(maxlen);
   VALUE str = rb_str_new(0, len);
   char *buf = RSTRING_PTR(str);
   int left = 0;
@@ -1047,7 +1047,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   RB_GC_GUARD(switchpoint_result);
   RB_GC_GUARD(str);
 
-  return INT2NUM(total);
+  return INT2FIX(total);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -1060,7 +1060,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
-  int len = NUM2INT(maxlen);
+  int len = FIX2INT(maxlen);
   VALUE str = rb_str_new(0, len);
   char *buf = RSTRING_PTR(str);
   int left = 0;
@@ -1118,7 +1118,7 @@ done:
   RB_GC_GUARD(switchpoint_result);
   RB_GC_GUARD(str);
 
-  return INT2NUM(total);
+  return INT2FIX(total);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -1263,7 +1263,7 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  int pid_int = NUM2INT(pid);
+  int pid_int = FIX2INT(pid);
   int fd = pidfd_open(pid_int, 0);
   if (fd >= 0) {
     Backend_t *backend;
@@ -1286,7 +1286,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     int e = errno;
     rb_syserr_fail(e, strerror(e));
   }
-  return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
+  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(WEXITSTATUS(status)));
 }
 #else
 struct libev_child {
@@ -1299,7 +1299,7 @@ void Backend_child_callback(EV_P_ ev_child *w, int revents) {
   int exit_status = WEXITSTATUS(w->rstatus);
   VALUE status;
 
-  status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
+  status = rb_ary_new_from_args(2, INT2FIX(w->rpid), INT2FIX(exit_status));
   Fiber_make_runnable(watcher->fiber, status);
 }
 
@@ -1310,7 +1310,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   GetBackend(self, backend);
 
   watcher.fiber = rb_fiber_current();
-  ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
+  ev_child_init(&watcher.child, Backend_child_callback, FIX2INT(pid), 0);
   ev_child_start(backend->ev_loop, &watcher.child);
   backend->base.op_count++;
 
@@ -1491,7 +1491,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
   struct libev_rw_io watcher;
   watcher.ctx.fiber = Qnil;
-  int maxlen = NUM2INT(chunk_size);
+  int maxlen = FIX2INT(chunk_size);
   VALUE str = Qnil;
   VALUE chunk_len_value = Qnil;
 
@@ -1515,7 +1515,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     if (chunk_len == 0) break;
 
     total += chunk_len;
-    chunk_len_value = INT2NUM(chunk_len);
+    chunk_len_value = INT2FIX(chunk_len);
 
     if (chunk_prefix != Qnil) {
       VALUE str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
@@ -1553,7 +1553,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   RB_GC_GUARD(result);
   if (pipefd[0] != -1) close(pipefd[0]);
   if (pipefd[1] != -1) close(pipefd[1]);
-  return INT2NUM(total);
+  return INT2FIX(total);
 syscallerror:
   if (pipefd[0] != -1) close(pipefd[0]);
   if (pipefd[1] != -1) close(pipefd[1]);

data/ext/polyphony/extconf.rb

@@ -47,6 +47,7 @@ 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/
   $CFLAGS << " -Wno-pointer-arith"
 else
@@ -70,7 +71,8 @@ $defs << '-DPOLYPHONY_PLAYGROUND' if ENV['POLYPHONY_PLAYGROUND']
 
 CONFIG['optflags'] << ' -fno-strict-aliasing' unless RUBY_PLATFORM =~ /mswin/
 
-have_func('rb_fiber_transfer', 'ruby.h')
-
+if RUBY_VERSION >= '3.1'
+  have_func('rb_fiber_transfer', 'ruby.h')
+end
 
 create_makefile 'polyphony_ext'

data/ext/polyphony/io_extensions.c

@@ -10,6 +10,7 @@
 #include "polyphony.h"
 #include "zlib.h"
 #include "assert.h"
+#include "ruby/thread.h"
 
 ID ID_at;
 ID ID_read_method;
@@ -29,6 +30,7 @@ VALUE SYM_orig_name;
 VALUE SYM_readpartial;
 
 enum read_method {
+  RM_STRING,
   RM_BACKEND_READ,
   RM_BACKEND_RECV,
   RM_READPARTIAL,
@@ -36,13 +38,15 @@ enum read_method {
 };
 
 enum write_method {
+  WM_STRING,
   WM_BACKEND_WRITE,
   WM_BACKEND_SEND,
   WM_WRITE,
   WM_CALL
 };
 
-static enum read_method detect_read_method(VALUE io) {
+static inline enum read_method detect_read_method(VALUE io) {
+  if (TYPE(io) == T_STRING) return RM_STRING;
   if (rb_respond_to(io, ID_read_method)) {
     VALUE method = rb_funcall(io, ID_read_method, 0);
     if (method == SYM_readpartial)  return RM_READPARTIAL;
@@ -58,7 +62,8 @@ static enum read_method detect_read_method(VALUE io) {
     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) {
+static inline enum write_method detect_write_method(VALUE io) {
+  if (TYPE(io) == T_STRING) return WM_STRING;
   if (rb_respond_to(io, ID_write_method)) {
     VALUE method = rb_funcall(io, ID_write_method, 0);
     if (method == SYM_readpartial)    return WM_WRITE;
@@ -136,11 +141,18 @@ static inline int read_to_raw_buffer(VALUE backend, VALUE io, enum read_method m
       RB_GC_GUARD(str);
       return len;
     }
+    default: {
+      rb_raise(rb_eRuntimeError, "Invalid read method");
+    }
   }
 }
 
 static inline int write_from_raw_buffer(VALUE backend, VALUE io, enum write_method method, struct raw_buffer *buffer) {
   switch (method) {
+    case WM_STRING: {
+      rb_str_buf_cat(io, (char *)buffer->ptr, buffer->len);
+      return buffer->len;
+    }
     case WM_BACKEND_WRITE: {
       VALUE len = Backend_write(backend, io, PTR2FIX(buffer));
       return FIX2INT(len);
@@ -165,6 +177,9 @@ static inline int write_from_raw_buffer(VALUE backend, VALUE io, enum write_meth
       RB_GC_GUARD(str);
       return buffer->len;
     }
+    default: {
+      rb_raise(rb_eRuntimeError, "Invalid write method");
+    }
   }
 }
 
@@ -228,7 +243,7 @@ static inline time_t time_from_object(VALUE o) {
   return FIX2INT(rb_funcall(o, rb_intern("to_i"), 0));
 }
 
-int gzip_prepare_header(struct gzip_header_ctx *ctx, char *buffer, int maxlen) {
+int gzip_prepare_header(struct gzip_header_ctx *ctx, unsigned char *buffer, int maxlen) {
   int len = 0;
   unsigned char flags = 0, extraflags = 0;
 
@@ -259,7 +274,7 @@ int gzip_prepare_header(struct gzip_header_ctx *ctx, char *buffer, int maxlen) {
   return len;
 }
 
-int gzip_prepare_footer(unsigned long crc32, unsigned long total_in, char *buffer, int maxlen) {
+static inline int gzip_prepare_footer(unsigned long crc32, unsigned long total_in, unsigned char *buffer, int maxlen) {
   assert(maxlen >= GZIP_FOOTER_LEN);
 
   gzfile_set32(crc32, buffer);
@@ -287,8 +302,8 @@ struct z_stream_ctx {
 
   unsigned char in[CHUNK];
   unsigned char out[CHUNK];
-  int in_pos;
-  int out_pos;
+  unsigned int in_pos;
+  unsigned int out_pos;
   unsigned long in_total;
   unsigned long out_total;
 
@@ -297,8 +312,8 @@ struct z_stream_ctx {
 
 typedef int (*zlib_func)(z_streamp, int);
 
-void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, int *in_pos, unsigned long *total_read) {
-  int null_pos;
+void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, unsigned int *in_pos, unsigned long *total_read) {
+  unsigned long null_pos;
   // find null terminator
   for (null_pos = *in_pos; null_pos < *total_read; null_pos++) {
     if (!buffer->ptr[null_pos]) break;
@@ -306,28 +321,37 @@ void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, int *in_pos, un
   if (null_pos == *total_read)
     rb_raise(rb_eRuntimeError, "Invalid gzip header");
   
-  *str = rb_str_new_cstr(buffer->ptr + *in_pos);
+  *str = rb_str_new_cstr((char *)buffer->ptr + *in_pos);
   *in_pos = null_pos + 1;
 }
 
 void gzip_read_header(struct z_stream_ctx *ctx, struct gzip_header_ctx *header_ctx) {
-  struct raw_buffer in_buffer = { ctx->in, CHUNK };
+  struct raw_buffer in_buffer;
   int flags;
 
-  while (ctx->in_total < 10) {
-    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;
+  if (ctx->src_read_method == RM_STRING) {
+    in_buffer.ptr = (unsigned char *)RSTRING_PTR(ctx->src);
+    in_buffer.len = RSTRING_LEN(ctx->src);
+    ctx->in_total = in_buffer.len;
+  }
+  else {
+    in_buffer.ptr = ctx->in;
+    in_buffer.len = CHUNK;
+    while (ctx->in_total < 10) {
+      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);
-  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;
-  flags = ctx->in[3];
+  if (in_buffer.ptr[0] != GZ_MAGIC1) goto error;
+  if (in_buffer.ptr[1] != GZ_MAGIC2) goto error;
+  if (in_buffer.ptr[2] != GZ_METHOD_DEFLATE) goto error;
+  flags = in_buffer.ptr[3];
 
-  unsigned long mtime = gzfile_get32(ctx->in + 4);
+  unsigned long mtime = gzfile_get32(in_buffer.ptr + 4);
   header_ctx->mtime = INT2FIX(mtime);
-
   ctx->in_pos = 10;
 
   if (flags & GZ_FLAG_ORIG_NAME)
@@ -344,6 +368,26 @@ error:
   rb_raise(rb_eRuntimeError, "Invalid gzip header");
 }
 
+struct process_z_stream_ctx {
+  z_stream *strm;
+  int flags;
+  zlib_func fun;
+  int ret;
+};
+
+void *do_process_z_stream_without_gvl(void *ptr) {
+  struct process_z_stream_ctx *ctx = (struct process_z_stream_ctx *)ptr;
+
+  ctx->ret = (ctx->fun)(ctx->strm, ctx->flags);
+  return NULL;
+}
+
+static inline int process_without_gvl(zlib_func fun, z_stream *strm, int flags) {
+  struct process_z_stream_ctx ctx = { strm, flags, fun, 0 };
+  rb_thread_call_without_gvl2(do_process_z_stream_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  return ctx.ret;
+}
+
 static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, int eof) {
   int ret;
   int written;
@@ -351,7 +395,7 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
 
   int avail_out_pre = ctx->strm.avail_out = CHUNK - ctx->out_pos;
   ctx->strm.next_out = ctx->out + ctx->out_pos;
-  ret = fun(&ctx->strm, eof ? Z_FINISH : Z_NO_FLUSH);
+  ret = process_without_gvl(fun, &ctx->strm, eof ? Z_FINISH : Z_NO_FLUSH);
   assert(ret != Z_STREAM_ERROR);
   written = avail_out_pre - ctx->strm.avail_out;
   out_buffer.ptr = ctx->out;
@@ -372,12 +416,13 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
   return ctx->strm.avail_out;
 }
 
-void z_stream_io_loop(struct z_stream_ctx *ctx) {
+VALUE z_stream_io_loop(struct z_stream_ctx *ctx) {
   zlib_func fun = (ctx->mode == SM_DEFLATE) ? deflate : inflate;
 
-  if (ctx->in_total > ctx->in_pos) {
+  if ((ctx->src_read_method != RM_STRING) && (ctx->in_total > ctx->in_pos)) {
     // In bytes already read for parsing gzip header, so we need to process the
     // rest.
+
     ctx->strm.next_in = ctx->in + ctx->in_pos;
     ctx->strm.avail_in = ctx->in_total -= ctx->in_pos;
 
@@ -389,14 +434,27 @@ 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, ctx->src_read_method, &in_buffer);
-    if (!read_len) break;
-    int eof = read_len < CHUNK;
-
-    if (ctx->mode == SM_DEFLATE)
-      ctx->crc32 = crc32(ctx->crc32, ctx->in, read_len);
+    int eof;
+    int read_len;
+    if (ctx->src_read_method == RM_STRING) {
+      struct raw_buffer in_buffer = {
+        (unsigned char *)RSTRING_PTR(ctx->src) + ctx->in_pos,
+        RSTRING_LEN(ctx->src) - ctx->in_pos
+      };
+      ctx->strm.next_in = in_buffer.ptr;
+      read_len = ctx->strm.avail_in = in_buffer.len;
+      eof = 1;
+      if (ctx->mode == SM_DEFLATE) ctx->crc32 = crc32(ctx->crc32, in_buffer.ptr, read_len);
+    }
+    else {
+      struct raw_buffer in_buffer = {ctx->in, CHUNK};
+      ctx->strm.next_in = ctx->in;
+      read_len = ctx->strm.avail_in = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
+      if (!read_len) break;
+      eof = read_len < CHUNK;
+      if (ctx->mode == SM_DEFLATE) ctx->crc32 = crc32(ctx->crc32, ctx->in, read_len);
+    }
+
     ctx->in_total += read_len;
 
     // PRINT_BUFFER("read stream", ctx->in, read_len);
@@ -407,13 +465,15 @@ void z_stream_io_loop(struct z_stream_ctx *ctx) {
       if (z_stream_write_out(ctx, fun, eof)) break;
     }
 
-    if (eof) return;
+    if (eof) goto done;
   }
 
   //flush
   ctx->strm.avail_in = 0;
   ctx->strm.next_in = ctx->in;
   z_stream_write_out(ctx, fun, 1);
+done:
+  return Qnil;
 }
 
 static inline void setup_ctx(struct z_stream_ctx *ctx, enum stream_mode mode, VALUE src, VALUE dest) {
@@ -434,6 +494,17 @@ static inline void setup_ctx(struct z_stream_ctx *ctx, enum stream_mode mode, VA
   ctx->crc32 = 0;
 }
 
+static inline VALUE z_stream_cleanup(struct z_stream_ctx *ctx) {
+  if (ctx->mode == SM_DEFLATE)
+    deflateEnd(&ctx->strm);
+  else
+    inflateEnd(&ctx->strm);
+  return Qnil;
+}
+
+#define Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx) \
+  rb_ensure(SAFE(z_stream_io_loop), (VALUE)&ctx, SAFE(z_stream_cleanup), (VALUE)&ctx)
+
 VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   VALUE src;
   VALUE dest;
@@ -450,18 +521,16 @@ VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   };
 
   struct z_stream_ctx ctx;
-  int level = DEFAULT_LEVEL;
   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));
+  ctx.out_total = 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);
-  deflateEnd(&ctx.strm);
- 
+  ret = deflateInit2(&ctx.strm, DEFAULT_LEVEL, Z_DEFLATED, -MAX_WBITS, DEFAULT_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx); 
   return INT2FIX(ctx.out_total);
 }
 
@@ -482,21 +551,25 @@ VALUE IO_gunzip(int argc, VALUE *argv, VALUE self) {
   setup_ctx(&ctx, SM_INFLATE, src, dest);
   gzip_read_header(&ctx, &header_ctx);
 
+  ret = inflateInit2(&ctx.strm, -MAX_WBITS);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
+
+  // gzip_read_footer(&ctx, &footer_ctx);
+  // TODO: verify crc32
+  // TODO: verify total length
+
   if (info != Qnil) {
     rb_hash_aset(info, SYM_mtime, FIX2TIME(header_ctx.mtime));
     rb_hash_aset(info, SYM_orig_name, header_ctx.orig_name);
     rb_hash_aset(info, SYM_comment, header_ctx.comment);
   }
+  RB_GC_GUARD(header_ctx.orig_name);
+  RB_GC_GUARD(header_ctx.comment);
 
-  ret = inflateInit2(&ctx.strm, -MAX_WBITS);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  inflateEnd(&ctx.strm);
-
-  // gzip_read_footer(&ctx, &footer_ctx);
-  // TODO: verify crc32
-  // TODO: verify total length
-  return self;
+  return INT2FIX(ctx.out_total);
 }
 
 VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
@@ -506,9 +579,10 @@ VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
 
   setup_ctx(&ctx, SM_DEFLATE, src, dest);
   ret = deflateInit(&ctx.strm, level);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  deflateEnd(&ctx.strm);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
  
   return INT2FIX(ctx.out_total);
 }
@@ -519,9 +593,10 @@ VALUE IO_inflate(VALUE self, VALUE src, VALUE dest) {
 
   setup_ctx(&ctx, SM_INFLATE, src, dest);
   ret = inflateInit(&ctx.strm);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  inflateEnd(&ctx.strm);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
  
   return INT2FIX(ctx.out_total);
 }
@@ -538,16 +613,16 @@ VALUE IO_http1_splice_chunked(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     if (!len) break;
 
     // write chunk header
-    buffer.len += sprintf(buffer.ptr + buffer.len, "%x\r\n", len);
+    buffer.len += sprintf((char *)buffer.ptr + buffer.len, "%x\r\n", len);
     write_from_raw_buffer(backend, dest, method, &buffer);
     buffer.len = 0;
     while (len) {
       int spliced = FIX2INT(Backend_splice(backend, pipe, dest, INT2FIX(len)));
       len -= spliced;
     }
-    buffer.len += sprintf(buffer.ptr + buffer.len, "\r\n");
+    buffer.len += sprintf((char *)buffer.ptr + buffer.len, "\r\n");
   }
-  buffer.len += sprintf(buffer.ptr + buffer.len, "0\r\n\r\n");
+  buffer.len += sprintf((char *)buffer.ptr + buffer.len, "0\r\n\r\n");
   write_from_raw_buffer(backend, dest, method, &buffer);
 
   Pipe_close(pipe);

data/ext/polyphony/polyphony.c

@@ -94,6 +94,12 @@ VALUE Polyphony_backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE c
   return Backend_splice_to_eof(BACKEND(), src, dest, chunksize);
 }
 
+#ifdef POLYPHONY_BACKEND_LIBURING
+VALUE Polyphony_backend_double_splice_to_eof(VALUE self, VALUE src, VALUE dest) {
+  return Backend_double_splice_to_eof(BACKEND(), src, dest);
+}
+#endif
+
 #ifdef POLYPHONY_LINUX
 VALUE Polyphony_backend_tee(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
   return Backend_tee(BACKEND(), src, dest, chunksize);
@@ -126,7 +132,7 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
 
 VALUE Polyphony_with_raw_buffer(VALUE self, VALUE size) {
   struct raw_buffer buffer;
-  buffer.len = NUM2INT(size);
+  buffer.len = FIX2INT(size);
   buffer.ptr = malloc(buffer.len);
   if (!buffer.ptr)
     rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
@@ -145,7 +151,7 @@ VALUE Polyphony_raw_buffer_get(int argc, VALUE *argv, VALUE self) {
   int length = (len == Qnil) ? buffer->len : FIX2INT(len);
   
   if (length > buffer->len) length = buffer->len;
-  return rb_utf8_str_new(buffer->ptr, length);
+  return rb_utf8_str_new((char *)buffer->ptr, length);
 }
 
 VALUE Polyphony_raw_buffer_set(VALUE self, VALUE buf, VALUE str) {
@@ -164,12 +170,6 @@ VALUE Polyphony_raw_buffer_size(VALUE self, VALUE buf) {
   return INT2FIX(buffer->len);
 }
 
-VALUE Polyphony_backend_test(VALUE self, VALUE io, VALUE str) {
-  struct raw_buffer buffer = { RSTRING_PTR(str), RSTRING_LEN(str) };
-  VALUE args[2] = { io, PTR2FIX(&buffer) };
-  return Polyphony_backend_write(2, args, self);
-}
-
 // VALUE Polyphony_backend_close(VALUE self, VALUE io) {
 //   return Backend_close(BACKEND(), io);
 // }
@@ -193,6 +193,10 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);
   rb_define_singleton_method(mPolyphony, "backend_splice_to_eof", Polyphony_backend_splice_to_eof, 3);
  
+  #ifdef POLYPHONY_BACKEND_LIBURING
+  rb_define_singleton_method(mPolyphony, "backend_double_splice_to_eof", Polyphony_backend_double_splice_to_eof, 2);
+  #endif
+
   #ifdef POLYPHONY_LINUX
   rb_define_singleton_method(mPolyphony, "backend_tee", Polyphony_backend_tee, 3);
   #endif
@@ -210,7 +214,6 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "__raw_buffer_get__", Polyphony_raw_buffer_get, -1);
   rb_define_singleton_method(mPolyphony, "__raw_buffer_set__", Polyphony_raw_buffer_set, 2);
   rb_define_singleton_method(mPolyphony, "__raw_buffer_size__", Polyphony_raw_buffer_size, 1);
-  rb_define_singleton_method(mPolyphony, "backend_test", Polyphony_backend_test, 2);
 
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);