polyphony 0.81.1 → 0.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4584f87975e018fe58887f4c6786bfe8c631a7d2fed3717e6822d72741fcc92
-  data.tar.gz: 9353ed759d256a035619d0b18dc53569fba6fdbb0709d79defb585fbf5f63f5a
+  metadata.gz: 8f80cdfe71dec5b03bd98ffb4150beec84fd6e35b70b6e099fb223a1c78706bc
+  data.tar.gz: 8a245a57849a917814d5b8dbb563315e42291c0063f5fc353578af16002209bb
 SHA512:
-  metadata.gz: c4d2d6e7457e49b4803b44e2125b54465a1104635b3d0a1d127538335401eeca6612095a2dcde9b6e149d939d15c6de2a1cbdf892a114535a5f0bd00ea1936e8
-  data.tar.gz: 5f4eb0a66dec6614d542d2c89cad791e2eb7e27ab9ae74f6bf60c8d4bd9831a098f531be6a619d4f13662631e86f1ac6ddc7bf5bf5f005b8926a4dfc3c7e43ef
+  metadata.gz: 0450fcbbe868c731f2e0b41bb196522f33487700eaf2636bb65d65def95af81d341057c071271aa726934008e19969a36a4e8e97e4775d9bb2660f5750708dc3
+  data.tar.gz: b789f4ad289136b91a24c3f68ddfc4864dbc2ede4989d7dafec09393527f6f93e44362843a406599a8d38f6f6f8e99626cffb88eb7395fdc99c1cbeafead87dc

data/.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ${{matrix.os}}
 
     env:
-      POLYPHONY_USE_LIBEV: "1"
+      POLYPHONY_LIBEV: "1"
 
     steps:
     - name: Setup machine

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.82 2022-03-04
+
+- Use `POLYPHONY_LIBEV` instead of `POLYPHONY_USE_LIBEV` environment variable
+- Add support for working with raw buffers (#78)
+
 ## 0.81.1 2022-03-03
 
 - Fix `Backend_recv` regression

data/Gemfile.lock

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

data/bin/test

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 set -e
-clear && POLYPHONY_USE_LIBEV=1 rake recompile && ruby test/run.rb
+clear && POLYPHONY_LIBEV=1 rake recompile && ruby test/run.rb
 clear && rake recompile && ruby test/run.rb

data/ext/polyphony/backend_common.c

@@ -470,3 +470,21 @@ int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr) {
   *ai_addr = addrinfo_result->ai_addr;
   return addrinfo_result->ai_addrlen;
 }
+
+struct io_buffer get_io_buffer(VALUE in) {
+  if (FIXNUM_P(in)) {
+    struct raw_buffer *raw = FIX2PTR(in);
+    return (struct io_buffer){ raw->ptr, raw->len, 1 };
+  }
+  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+}
+
+VALUE coerce_io_string_or_buffer(VALUE buf) {
+  switch (TYPE(buf)) {
+    case T_STRING:
+    case T_FIXNUM:
+      return buf;
+    default:
+      return StringValue(buf);
+  }
+}

data/ext/polyphony/backend_common.h

@@ -55,7 +55,24 @@ struct backend_stats backend_base_stats(struct Backend_base *base);
 }
 #define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
 
+// raw buffers
 
+struct raw_buffer {
+  char *ptr;
+  int len;
+};
+
+struct io_buffer {
+  char *ptr;
+  int len;
+  int raw;
+};
+
+#define FIX2PTR(v) ((void *)(FIX2LONG(v)))
+#define PTR2FIX(p) LONG2FIX((long)p)
+
+struct io_buffer get_io_buffer(VALUE in);
+VALUE coerce_io_string_or_buffer(VALUE buf);
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 int pidfd_open(pid_t pid, unsigned int flags);

data/ext/polyphony/backend_io_uring.c

@@ -102,24 +102,6 @@ static VALUE Backend_initialize(VALUE self) {
   return self;
 }
 
-static inline struct io_buffer get_io_buffer(VALUE in) {
-  if (FIXNUM_P(in)) {
-    struct raw_buffer *raw = (struct raw_buffer *)(FIX2LONG(in));
-    return (struct io_buffer){ raw->base, raw->size, 1 };
-  }
-  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
-}
-
-static inline VALUE coerce_io_string_or_buffer(VALUE buf) {
-  switch (TYPE(buf)) {
-    case T_STRING:
-    case T_FIXNUM:
-      return buf;
-    default:
-      return StringValue(buf);
-  }
-}
-
 VALUE Backend_finalize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -359,26 +341,26 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
   if (buffer.raw) {
-    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
-    buffer.base += buf_pos;
-    buffer.size -= buf_pos;
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= buf_pos;
   }
   else {
     expandable_buffer = length == Qnil;
     long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
     long string_cap = rb_str_capacity(str);
-    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
 
     if (string_cap < expected_read_length + buf_pos) {
       shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
-      buffer.base = RSTRING_PTR(str) + buf_pos;
-      buffer.size = expected_read_length;
+      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.len = expected_read_length;
     }
     else {
-      buffer.base += buf_pos;
-      buffer.size = string_cap - buf_pos;
-      if (buffer.size > expected_read_length)
-        buffer.size = expected_read_length;
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
     }
   }
 
@@ -396,7 +378,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
     int result;
     int completed;
     
-    io_uring_prep_read(sqe, fptr->fd, buffer.base, buffer.size, -1);
+    io_uring_prep_read(sqe, fptr->fd, buffer.ptr, buffer.len, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -415,20 +397,20 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       total += result;
       if (!read_to_eof) break;
 
-      if (result == buffer.size) {
+      if (result == buffer.len) {
         if (!expandable_buffer) break;
 
         // resize buffer to double its capacity
         rb_str_resize(str, total + buf_pos);
         rb_str_modify_expand(str, rb_str_capacity(str));
         shrinkable_string = 0;
-        buffer.base = RSTRING_PTR(str) + total + buf_pos;
-        buffer.size = rb_str_capacity(str) - total - buf_pos;
+        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
-        buffer.base += result;
-        buffer.size -= result;
-        if (!buffer.size) break;
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) break;
       }
     }
   }
@@ -437,7 +419,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
     io_set_read_length(str, buf_pos + total, shrinkable_string);
     io_enc_str(str, fptr);
   }
-
   if (!total) return Qnil;
 
   return buffer.raw ? INT2FIX(total) : str;
@@ -554,7 +535,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   VALUE underlying_io;
 
   struct io_buffer buffer = get_io_buffer(str);
-  long left = buffer.size;
+  long left = buffer.len;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -570,7 +551,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fptr->fd, buffer.base, left, 0);
+    io_uring_prep_write(sqe, fptr->fd, buffer.ptr, left, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -584,13 +565,12 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buffer.base += result;
-      buffer.size -= result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(buffer.size);
+  return INT2NUM(buffer.len);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
@@ -677,21 +657,36 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  int shrinkable;
-  char *buf;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= buf_pos;
+  }
+  else {
+    expandable_buffer = length == Qnil;
+    long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(str);
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+
+    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.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
+    }
   }
-  else buf_pos = 0;
-  shrinkable = io_setstrbuf(&str, buf_pos + len);
-  buf = RSTRING_PTR(str) + buf_pos;
 
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
@@ -707,7 +702,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     int result;
     int completed;
 
-    io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
+    io_uring_prep_recv(sqe, fptr->fd, buffer.ptr, buffer.len, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -726,12 +721,13 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
-
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    io_enc_str(str, fptr);
+  }
   if (!total) return Qnil;
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 }
 
 VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
@@ -841,10 +837,10 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE underlying_io;
-  char *buf;
-  long len;
-  long left;
-  int flags_int;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
+  int flags_int = NUM2INT(flags);
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -853,11 +849,6 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   GetOpenFile(io, fptr);
   io_unset_nonblock(fptr, io);
 
-  buf = StringValuePtr(str);
-  len = RSTRING_LEN(str);
-  left = len;
-  flags_int = NUM2INT(flags);
-
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
@@ -865,7 +856,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     int result;
     int completed;
 
-    io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
+    io_uring_prep_send(sqe, fptr->fd, buffer.ptr, left, flags_int);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -879,12 +870,12 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 }
 
 VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {

data/ext/polyphony/backend_libev.c

@@ -270,21 +270,40 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
+
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
-  }
-  else buf_pos = 0;
-  int shrinkable = io_setstrbuf(&str, buf_pos + len);
-  char *buf = RSTRING_PTR(str) + buf_pos;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
   VALUE switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= buf_pos;
+  }
+  else {
+    expandable_buffer = length == Qnil;
+    long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(str);
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+
+    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.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
+    }
+  }
+
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
@@ -295,8 +314,8 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(fptr->fd, buf, len - total);
-    if (n < 0) {
+    ssize_t result = read(fptr->fd, buffer.ptr, buffer.len);
+    if (result < 0) {
       int e = errno;
       if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
 
@@ -308,32 +327,39 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       switchpoint_result = backend_snooze(&backend->base);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
-      if (n == 0) break; // EOF
-      total = total + n;
+      if (!result) break; // EOF
+
+      total += result;
       if (!read_to_eof) break;
 
-      if (total == len) {
-        if (!dynamic_len) break;
+      if (result == buffer.len) {
+        if (!expandable_buffer) break;
 
-        rb_str_resize(str, buf_pos + total);
-        rb_str_modify_expand(str, len);
-        buf = RSTRING_PTR(str) + buf_pos + total;
-        shrinkable = 0;
-        len += len;
+        // resize buffer to double its capacity
+        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.len = rb_str_capacity(str) - total - buf_pos;
+      }
+      else {
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) break;
       }
-      else buf += n;
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
-
-  if (total == 0) return Qnil;
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    io_enc_str(str, fptr);
+  }
+  if (!total) return Qnil;
 
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -453,9 +479,9 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -467,8 +493,8 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = write(fptr->fd, buf, left);
-    if (n < 0) {
+    ssize_t result = write(fptr->fd, buffer.ptr, left);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
@@ -477,8 +503,8 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -491,7 +517,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -743,9 +769,9 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
   int flags_int = NUM2INT(flags);
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
@@ -758,8 +784,8 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = send(fptr->fd, buf, left, flags_int);
-    if (n < 0) {
+    ssize_t result = send(fptr->fd, buffer.ptr, left, flags_int);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
@@ -768,8 +794,8 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -782,7 +808,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }

data/ext/polyphony/extconf.rb

@@ -16,7 +16,7 @@ def get_config
   version, major_revision, distribution = m[1].to_i, m[2].to_i, m[3]
   config[:pidfd_open] = (version == 5) && (major_revision >= 3)
 
-  force_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+  force_libev = ENV['POLYPHONY_LIBEV'] != nil
   config[:io_uring] = !force_libev &&
     (version == 5) && (major_revision >= 6) && (distribution != 'linuxkit')
   config

data/ext/polyphony/polyphony.c

@@ -118,9 +118,49 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_with_raw_buffer(VALUE self, VALUE size) {
+  struct raw_buffer buffer;
+  buffer.len = NUM2INT(size);
+  buffer.ptr = malloc(buffer.len);
+  if (!buffer.ptr)
+    rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
+
+  VALUE return_value = rb_yield(PTR2FIX(&buffer));
+  free(buffer.ptr);
+  return return_value;
+}
+
+VALUE Polyphony_raw_buffer_get(int argc, VALUE *argv, VALUE self) {
+  VALUE buf = Qnil;
+  VALUE len = Qnil;
+  rb_scan_args(argc, argv, "11", &buf, &len);
+
+  struct raw_buffer *buffer = FIX2PTR(buf);
+  int length = (len == Qnil) ? buffer->len : FIX2INT(len);
+  
+  if (length > buffer->len) length = buffer->len;
+  return rb_utf8_str_new(buffer->ptr, length);
+}
+
+VALUE Polyphony_raw_buffer_set(VALUE self, VALUE buf, VALUE str) {
+  struct raw_buffer *buffer = FIX2PTR(buf);
+  int len = RSTRING_LEN(str);
+  if (len > buffer->len)
+    rb_raise(rb_eRuntimeError, "Given string does not fit in given buffer");
+  
+  memcpy(buffer->ptr, RSTRING_PTR(str), len);
+  buffer->len = len;
+  return self;
+}
+
+VALUE Polyphony_raw_buffer_size(VALUE self, VALUE buf) {
+  struct raw_buffer *buffer = FIX2PTR(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, LONG2FIX((long)&buffer) };
+  VALUE args[2] = { io, PTR2FIX(&buffer) };
   return Polyphony_backend_write(2, args, self);
 }
 
@@ -155,6 +195,10 @@ void Init_Polyphony() {
   // rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
   rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Backend_verify_blocking_mode, 2);
 
+  rb_define_singleton_method(mPolyphony, "__with_raw_buffer__", Polyphony_with_raw_buffer, 1);
+  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);

data/ext/polyphony/polyphony.h

@@ -135,15 +135,4 @@ VALUE Thread_switch_fiber(VALUE thread);
 
 VALUE Polyphony_snooze(VALUE self);
 
-struct raw_buffer {
-  char *base;
-  int size;
-};
-
-struct io_buffer {
-  char *base;
-  int size;
-  int raw;
-};
-
 #endif /* POLYPHONY_H */

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.81.1'
+  VERSION = '0.82'
 end

data/test/test_io.rb

@@ -281,6 +281,41 @@ class IOTest < MiniTest::Test
   end
 end
 
+class IOWithRawBufferTest < MiniTest::Test
+  def setup
+    super
+    @i, @o = IO.pipe
+  end
+
+  def test_write_with_raw_buffer
+    Polyphony.__with_raw_buffer__(64) do |b|
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      @o << b
+      @o.close
+    end
+
+    str = @i.read
+    assert_equal 'foobar', str
+  end
+
+  def test_read_with_raw_buffer
+    @o << '*' * 65
+    @o.close
+    chunks = []
+    Polyphony.__with_raw_buffer__(64) do |b|
+      res = @i.read(64, b)
+      assert_equal 64, res
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.read(64, b)
+      assert_equal 1, res
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+    end
+    assert_equal ['*' * 64, '*'], chunks
+  end
+end
+
 class IOClassMethodsTest < MiniTest::Test
   def test_binread
     s = IO.binread(__FILE__)

data/test/test_raw_buffer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'msgpack'
+
+class RawBufferTest < MiniTest::Test
+  def test_with_raw_buffer
+    result = Polyphony.__with_raw_buffer__(64) do |b|
+      assert_kind_of Integer, b
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      :foo
+    end
+    assert_equal :foo, result
+  end
+
+  def test_raw_buffer_get_set
+    Polyphony.__with_raw_buffer__(64) do |b|
+      # should raise if buffer not big enough
+      assert_raises { Polyphony.__raw_buffer_set__(b, '*' * 65) }
+
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      assert_equal 6, Polyphony.__raw_buffer_size__(b)
+
+      str = Polyphony.__raw_buffer_get__(b)
+      assert_equal 'foobar', str
+
+      str = Polyphony.__raw_buffer_get__(b, 3)
+      assert_equal 'foo', str
+
+      Polyphony.__raw_buffer_set__(b, '')
+      assert_equal 0, Polyphony.__raw_buffer_size__(b)
+
+      str = Polyphony.__raw_buffer_get__(b)
+      assert_equal '', str
+    end
+  end
+end

data/test/test_socket.rb

@@ -193,6 +193,55 @@ class SocketTest < MiniTest::Test
   end
 end
 
+class SocketWithRawBufferTest < MiniTest::Test
+  def start_tcp_server_on_random_port(host = '127.0.0.1')
+    port = rand(1100..60000)
+    server = TCPServer.new(host, port)
+    [port, server]
+  rescue Errno::EADDRINUSE
+    retry
+  end  
+
+  def setup
+    super
+
+    port, server = start_tcp_server_on_random_port
+    connector = spin { @o = TCPSocket.new('127.0.0.1', port) }
+    @i = server.accept
+  end
+
+  def test_send_with_raw_buffer
+    Polyphony.__with_raw_buffer__(64) do |b|
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      @o << b
+      @o.close
+    end
+
+    str = @i.read
+    assert_equal 'foobar', str
+  end
+
+  def test_recv_with_raw_buffer
+    @o << '*' * 65
+    @o.close
+    chunks = []
+    Polyphony.__with_raw_buffer__(64) do |b|
+      res = @i.recv(64, 0, b)
+      assert_equal 64, res
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.recv(64, 0, b)
+      assert_equal 1, res
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.recv(64, 0, b)
+      assert_nil res
+    end
+    assert_equal ['*' * 64, '*'], chunks
+  end
+end
+
 if IS_LINUX
   class HTTPClientTest < MiniTest::Test
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.81.1
+  version: '0.82'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-03 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -399,6 +399,7 @@ files:
 - test/test_kernel.rb
 - test/test_process_supervision.rb
 - test/test_queue.rb
+- test/test_raw_buffer.rb
 - test/test_resource_pool.rb
 - test/test_signal.rb
 - test/test_socket.rb