polyphony 0.61 → 0.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7056ec954b2264a15f88934d2b1e65f53c76c301453851ceadf60715570e474
-  data.tar.gz: 1cd5835b7a5a3d4036e1eabf45ded2e09efdc7cacb207fc0a1a60ac67da02d90
+  metadata.gz: 3ffef1fb2b3d081c388c32219346ace5c99b689c73549fed65be882ff1f9e1eb
+  data.tar.gz: 20f2a26377b984f23c427f65fb6f776fe6cfda504667cc710fa3152ec63c920d
 SHA512:
-  metadata.gz: b5e32edc6bc22ba580e7c6d7d42a73982803080e9a9782326cb7b8796aa62ad6b75bccb1e6607879f0d3e5a5c4db8e5597d8407b76014f08f3945d1d8ad0097a
-  data.tar.gz: b8fe0f9419061295f830ed12ae9c8ea089a966686388cff580ddb6e1f7cd8c17a04928f9af41083019a5a11e8cccce25af404959db30a730a2ade2359a7e07ef
+  metadata.gz: 31223abf79dad98bfa68c43159474756e1a5e4c713b54239117ec8a57e540ce2914fcfac244b598d36ff3bed49e6efb0b979efc775fdd0a1a8b9e5e1cbe2d25e
+  data.tar.gz: d126c5da62b17a96ae915304c291e520662030dcabe856bcbe4a18d22f2f9c5dfde913a3d89b09a0ad00562ae949aa26a25942163a2decdf2f3184cae0df4a7b

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.65 2021-07-29
+
+- Add `#__polyphony_read_method__` method for read method detection
+
+## 0.64 2021-07-26
+
+- Add optional raise_on_eof argument to `#readpartial`
+
+## 0.63 2021-07-26
+
+- Add support for specifying buf and buf_pos in `IO#read`
+- Fix `Socket#read` to work and conform to `IO#read` interface
+
+## 0.62 2021-07-21
+
+- Add `runqueue_size` to backend stats
+
 ## 0.61 2021-07-20
 
 - Add more statistics, move stats to `Backend#stats`

data/Gemfile.lock

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

data/Rakefile

@@ -9,8 +9,8 @@ Rake::ExtensionTask.new("polyphony_ext") do |ext|
 end
 
 task :recompile => [:clean, :compile]
-
 task :default => [:compile, :test]
+
 task :test do
   exec 'ruby test/run.rb'
 end

data/ext/polyphony/backend_common.c

@@ -112,22 +112,6 @@ inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
   rb_funcallv(base->trace_proc, ID_call, argc, argv);
 }
 
-inline struct backend_stats backend_base_stats(struct Backend_base *base) {
-  struct backend_stats stats = {
-    .runqueue_length = runqueue_len(&base->runqueue),
-    .runqueue_max_length = runqueue_max_len(&base->runqueue),
-    .op_count = base->op_count,
-    .switch_count = base->switch_count,
-    .poll_count = base->poll_count,
-    .pending_ops = base->pending_count
-  };
-
-  base->op_count = 0;
-  base->switch_count = 0;
-  base->poll_count = 0;
-  return stats;
-}
-
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 #ifndef __NR_pidfd_open
 #define __NR_pidfd_open 434   /* System call # on most architectures */
@@ -312,6 +296,24 @@ inline void backend_run_idle_tasks(struct Backend_base *base) {
   rb_gc_disable();
 }
 
+inline struct backend_stats backend_base_stats(struct Backend_base *base) {
+  struct backend_stats stats = {
+    .runqueue_size = runqueue_size(&base->runqueue),
+    .runqueue_length = runqueue_len(&base->runqueue),
+    .runqueue_max_length = runqueue_max_len(&base->runqueue),
+    .op_count = base->op_count,
+    .switch_count = base->switch_count,
+    .poll_count = base->poll_count,
+    .pending_ops = base->pending_count
+  };
+
+  base->op_count = 0;
+  base->switch_count = 0;
+  base->poll_count = 0;
+  return stats;
+}
+
+VALUE SYM_runqueue_size;
 VALUE SYM_runqueue_length;
 VALUE SYM_runqueue_max_length;
 VALUE SYM_op_count;
@@ -323,6 +325,7 @@ VALUE Backend_stats(VALUE self) {
   struct backend_stats backend_stats = backend_get_stats(self);
 
   VALUE stats = rb_hash_new();
+  rb_hash_aset(stats, SYM_runqueue_size, INT2NUM(backend_stats.runqueue_size));
   rb_hash_aset(stats, SYM_runqueue_length, INT2NUM(backend_stats.runqueue_length));
   rb_hash_aset(stats, SYM_runqueue_max_length, INT2NUM(backend_stats.runqueue_max_length));
   rb_hash_aset(stats, SYM_op_count, INT2NUM(backend_stats.op_count));
@@ -334,13 +337,15 @@ VALUE Backend_stats(VALUE self) {
 }
 
 void backend_setup_stats_symbols() {
-  SYM_runqueue_length = ID2SYM(rb_intern("runqueue_length"));
+  SYM_runqueue_size       = ID2SYM(rb_intern("runqueue_size"));
+  SYM_runqueue_length     = ID2SYM(rb_intern("runqueue_length"));
   SYM_runqueue_max_length = ID2SYM(rb_intern("runqueue_max_length"));
-  SYM_op_count = ID2SYM(rb_intern("op_count"));
-  SYM_switch_count = ID2SYM(rb_intern("switch_count"));
-  SYM_poll_count = ID2SYM(rb_intern("poll_count"));
-  SYM_pending_ops = ID2SYM(rb_intern("pending_ops"));
+  SYM_op_count            = ID2SYM(rb_intern("op_count"));
+  SYM_switch_count        = ID2SYM(rb_intern("switch_count"));
+  SYM_poll_count          = ID2SYM(rb_intern("poll_count"));
+  SYM_pending_ops         = ID2SYM(rb_intern("pending_ops"));
   
+  rb_global_variable(&SYM_runqueue_size);
   rb_global_variable(&SYM_runqueue_length);
   rb_global_variable(&SYM_runqueue_max_length);
   rb_global_variable(&SYM_op_count);

data/ext/polyphony/backend_common.h

@@ -6,6 +6,7 @@
 #include "runqueue.h"
 
 struct backend_stats {
+  unsigned int runqueue_size;
   unsigned int runqueue_length;
   unsigned int runqueue_max_length;
   unsigned int op_count;

data/ext/polyphony/runqueue.c

@@ -44,6 +44,10 @@ inline void runqueue_clear(runqueue_t *runqueue) {
   runqueue_ring_buffer_clear(&runqueue->entries);
 }
 
+inline long runqueue_size(runqueue_t *runqueue) {
+  return runqueue->entries.size;
+}
+
 inline long runqueue_len(runqueue_t *runqueue) {
   return runqueue->entries.count;
 }

data/ext/polyphony/runqueue.h

@@ -19,6 +19,7 @@ runqueue_entry runqueue_shift(runqueue_t *runqueue);
 void runqueue_delete(runqueue_t *runqueue, VALUE fiber);
 int runqueue_index_of(runqueue_t *runqueue, VALUE fiber);
 void runqueue_clear(runqueue_t *runqueue);
+long runqueue_size(runqueue_t *runqueue);
 long runqueue_len(runqueue_t *runqueue);
 long runqueue_max_len(runqueue_t *runqueue);
 int runqueue_empty_p(runqueue_t *runqueue);

data/lib/polyphony/extensions/io.rb

@@ -76,6 +76,10 @@ end
 
 # IO instance method patches
 class ::IO
+  def __polyphony_read_method__
+    :backend_read
+  end
+
   # def each(sep = $/, limit = nil, chomp: nil)
   #   sep, limit = $/, sep if sep.is_a?(Integer)
   # end
@@ -108,7 +112,11 @@ class ::IO
   end
 
   alias_method :orig_read, :read
-  def read(len = nil)
+  def read(len = nil, buf = nil, buf_pos = 0)
+    if buf
+      return Polyphony.backend_read(self, buf, len, true, buf_pos)
+    end
+    
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
     return nil unless result
@@ -119,9 +127,9 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len, str = +'', buffer_pos = 0)
+  def readpartial(len, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_read(self, str, len, false, buffer_pos)
-    raise EOFError unless result
+    raise EOFError if !result && raise_on_eof
 
     result
   end

data/lib/polyphony/extensions/openssl.rb

@@ -5,6 +5,10 @@ require_relative './socket'
 
 # OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
 class ::OpenSSL::SSL::SSLSocket
+  def __polyphony_read_method__
+    :readpartial
+  end
+
   alias_method :orig_initialize, :initialize
   def initialize(socket, context = nil)
     socket = socket.respond_to?(:io) ? socket.io || socket : socket
@@ -64,7 +68,21 @@ class ::OpenSSL::SSL::SSLSocket
     # @sync = osync
   end
 
-  def readpartial(maxlen, buf = +'', buffer_pos = 0)
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return readpartial(maxlen, buf, buf_pos) if buf
+
+    buf = +''
+    return readpartial(maxlen, buf) if maxlen
+
+    while true
+      readpartial(4096, buf, -1)
+    end
+  rescue EOFError
+    buf
+  end
+
+  def readpartial(maxlen, buf = +'', buffer_pos = 0, raise_on_eof = true)
     if buffer_pos != 0
       if (result = sysread(maxlen, +''))
         if buffer_pos == -1
@@ -76,7 +94,9 @@ class ::OpenSSL::SSL::SSLSocket
     else
       result = sysread(maxlen, buf)
     end
-    result || (raise EOFError)
+
+    raise EOFError if !result && raise_on_eof
+    result
   end
 
   def read_loop(maxlen = 8192)

data/lib/polyphony/extensions/socket.rb

@@ -5,6 +5,12 @@ require 'socket'
 require_relative './io'
 require_relative '../core/thread_pool'
 
+class BasicSocket
+  def __polyphony_read_method__
+    :backend_recv
+  end
+end
+
 # Socket overrides (eventually rewritten in C)
 class ::Socket
   def accept
@@ -22,6 +28,23 @@ class ::Socket
     Polyphony.backend_connect(self, addr.ip_address, addr.ip_port)
   end
 
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
     Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
@@ -60,8 +83,9 @@ class ::Socket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0)
-    Polyphony.backend_recv(self, str, maxlen, buffer_pos)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof = true)
+    result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
+    raise EOFError if !result && raise_on_eof
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze
@@ -140,6 +164,23 @@ class ::TCPSocket
     setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
   end
 
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
     Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
@@ -165,11 +206,10 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
-    raise EOFError unless result
-
-    str
+    raise EOFError if !result && raise_on_eof
+    result
   end
 
   def read_nonblock(len, str = nil, exception: true)
@@ -217,6 +257,23 @@ class ::UNIXServer
 end
 
 class ::UNIXSocket
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
     Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
@@ -242,11 +299,10 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
-    raise EOFError unless result
-
-    str
+    raise EOFError if !result && raise_on_eof
+    result
   end
 
   def read_nonblock(len, str = nil, exception: true)

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -98,6 +98,32 @@ class BackendTest < MiniTest::Test
     assert_equal return_value, buf
   end
 
+  def test_read_concat_big
+    i, o = IO.pipe
+
+    body = " " * 4000
+
+    data = "post /?q=time&blah=blah HTTP/1\r\nHost: dev.realiteq.net\r\n\r\n" +
+           "get /?q=time HTTP/1.1\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}" +
+           "get /?q=time HTTP/1.1\r\nCookie: foo\r\nCookie: bar\r\n\r\n"
+
+    o << data
+    o.close
+    
+    buf = +''
+
+    @backend.read(i, buf, 4096, false, -1)
+    assert_equal 4096, buf.bytesize
+    
+    @backend.read(i, buf, 1, false, -1)
+    assert_equal 4097, buf.bytesize
+
+    @backend.read(i, buf, 4096, false, -1)
+
+    assert_equal data.bytesize, buf.bytesize
+    assert_equal data, buf
+  end
+
   def test_waitpid
     pid = fork do
       @backend.post_fork

data/test/test_io.rb

@@ -73,6 +73,26 @@ class IOTest < MiniTest::Test
     assert_equal [:wait_readable, 'foo'], results
   end
 
+  def test_read
+    i, o = IO.pipe
+
+    o << 'hi'
+    assert_equal 'hi', i.read(2)
+
+    o << 'foobarbaz'
+    assert_equal 'foo', i.read(3)
+    assert_equal 'bar', i.read(3)
+
+    buf = +'abc'
+    assert_equal 'baz', i.read(3, buf)
+    assert_equal 'baz', buf
+
+    buf = +'def'
+    o << 'foobar'
+    assert_equal 'deffoobar', i.read(6, buf, -1)
+    assert_equal 'deffoobar', buf
+  end
+
   def test_readpartial
     i, o = IO.pipe
 

data/test/test_socket.rb

@@ -12,7 +12,6 @@ class SocketTest < MiniTest::Test
   def test_tcp
     port = rand(1234..5678)
     server = TCPServer.new('127.0.0.1', port)
-
     server_fiber = spin do
       while (socket = server.accept)
         spin do
@@ -34,6 +33,45 @@ class SocketTest < MiniTest::Test
     server&.close
   end
 
+  def test_read
+    port = rand(1234..5678)
+    server = TCPServer.new('127.0.0.1', port)
+    server_fiber = spin do
+      while (socket = server.accept)
+        spin do
+          while (data = socket.read(8192))
+            socket << data
+          end
+        end
+      end
+    end
+
+    snooze
+    client = TCPSocket.new('127.0.0.1', port)
+
+    client << 'hi'
+    assert_equal 'hi', client.read(2)
+
+    client << 'foobarbaz'
+    assert_equal 'foo', client.read(3)
+    assert_equal 'bar', client.read(3)
+
+    buf = +'abc'
+    assert_equal 'baz', client.read(3, buf)
+    assert_equal 'baz', buf
+
+    buf = +'def'
+    client << 'foobar'
+    assert_equal 'deffoobar', client.read(6, buf, -1)
+    assert_equal 'deffoobar', buf
+
+    client.close
+  ensure
+    server_fiber&.stop
+    server_fiber&.await
+    server&.close
+  end
+
   # sending multiple strings at once
   def test_sendv
     port = rand(1234..5678)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.61'
+  version: '0.65'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-20 00:00:00.000000000 Z
+date: 2021-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler