polyphony 0.43.4 → 0.43.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9481b252526ebc3f8e0f5a0121eebb68492bc0c1502cfed447da7b0648e6095b
-  data.tar.gz: dfd2d5d0415833f14f9ebe2cc6336e87d0951ce86f07ebcdec0ad892f71fb74c
+  metadata.gz: 55e44a81e7358528fabd37e1d48b6387957bc6001e4d947bf6c881d2425953d9
+  data.tar.gz: 45af7e485891927a1e9f88e8a6342692c25f306aa60e40fa8a74c0ca8494d3d4
 SHA512:
-  metadata.gz: 652633b1fc27623edb2e87b5657322ba4826ec176e8eb5131a43249e08340f793ba426743be343bfe0fce02fc60b73cb790afef816a4153585d68bdfeaa9c55d
-  data.tar.gz: 946abb7526324cae5f1d6b62e25c8410129b07ca75c82a6b7285d6269ed1911e161a6030a394ef29ba238a80da6f96787dd94fdbd5c05bd2a643379252ce80d0
+  metadata.gz: 444675baf3131ffc843b61649b92ce5ca7d77773277db750d8c8ac80a88ccd133e6f60d61282fa38ffb91de59eaf2304ea9b0fca196a7eb61c7a53becaa1fe46
+  data.tar.gz: f21e26a41c8dfeea0d803b5b9bc82b1e648bf0ca588225f721560c432f363020b37561c59daeefbe2d434b012f1f5f767460557939a22d04e78e40471813a8ca

data/.github/workflows/test.yml

@@ -1,6 +1,6 @@
 name: Tests
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.43.5 2020-07-13
+
+* Fix `#read_nonblock`, `#write_nonblock` for `IO` and `Socket` (#27)
+* Patch `Kernel#p`, `IO#puts` to issue single write call
+* Add support for multiple arguments in `IO#write` and `LibevAgent#write`
+* Use LibevQueue for fiber run queue
+* Reimplement LibevQueue as ring buffer
+
 ## 0.43.4 2020-07-09
 
 * Reimplement Kernel#trap

data/Gemfile.lock

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

data/docs/index.md

@@ -18,9 +18,8 @@ implements a comprehensive
 using [libev](https://github.com/enki/libev) as a high-performance event reactor
 for I/O, timers, and other asynchronous events.
 
+[Overview](getting-started/overview){: .btn .btn-green .text-gamma }
 [Take the tutorial](getting-started/tutorial){: .btn .btn-blue .text-gamma }
-[Main Concepts](main-concepts/concurrency/){: .btn .btn-green .text-gamma }
-[FAQ](faq){: .btn .btn-green .text-gamma }
 [Source code](https://github.com/digital-fabric/polyphony){: .btn .btn-purple .text-gamma target="_blank" }
 {: .mt-6 .h-align-center }
 

data/docs/main-concepts/design-principles.md

@@ -6,7 +6,7 @@ parent: Main Concepts
 permalink: /main-concepts/design-principles/
 prev_title: Extending Polyphony
 ---
-# The Design of Polyphony 
+# The Design of Polyphony
 
 Polyphony is a new gem that aims to enable developing high-performance
 concurrent applications in Ruby using a fluent, compact syntax and API.
@@ -47,7 +47,7 @@ Nevertheless, while work is being done to harness fibers for providing a better
 way to do concurrency in Ruby, fibers remain a mistery for most Ruby
 programmers, a perplexing unfamiliar corner right at the heart of Ruby.
 
-## Design Principles
+## The History of Polyphony
 
 Polyphony started as an experiment, but over about two years of slow, jerky
 evolution turned into something I'm really excited to share with the Ruby
@@ -58,31 +58,24 @@ Polyphony today as nothing like the way it began. A careful examination of the
 [CHANGELOG](https://github.com/digital-fabric/polyphony/blob/master/CHANGELOG.md)
 would show how Polyphony explored not only different event reactor designs, but
 also different API designs incorporating various concurrent paradigms such as
-promises, async/await, fibers, and finally structured concurrency. 
-
-While Polyphony, like nio4r or EventMachine, uses an event reactor to turn
-blocking operations into non-blocking ones, it completely embraces fibers and in
-fact does not provide any callback-based APIs. Furthermore, Polyphony provides
-fullblown fiber-aware implementations of blocking operations, such as
-`read/write`, `sleep` or `waitpid`, instead of just event watching primitives.
+promises, async/await, fibers, and finally structured concurrency.
 
 Throughout the development process, it was my intention to create a programming
-interface that would make highly-concurrent 
-
-
-
-
+interface that would make it easy to author highly-concurrent Ruby programs.
 
+## Design Principles
 
+While Polyphony, like nio4r or EventMachine, uses an event reactor to turn
+blocking operations into non-blocking ones, it completely embraces fibers and in
+fact does not provide any callback-based APIs.
 
-a single Ruby process may spin up millions of
-concurrent fibers.
+Furthermore, Polyphony provides fullblown fiber-aware implementations of
+blocking operations, such as `read/write`, `sleep` or `waitpid`, instead of just
+event watching primitives.
 
-, by utilizing Ruby fibers together with the
-[libev](http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod) event reactor
-library. Polyphony's design is based on the following principles:
+Polyphony's design is based on the following principles:
 
-- Polyphony's concurrency model should feel "baked-in". The API should allow
+- The concurrency model should feel "baked-in". The API should allow
   concurrency with minimal effort. Polyphony should facilitate writing both
   large apps and small scripts with as little boilerplate code as possible.
   There should be no calls to initialize the event reactor, or other ceremonial
@@ -91,8 +84,8 @@ library. Polyphony's design is based on the following principles:
   ```ruby
   require 'polyphony'
 
-  # start 10 fibers, each sleeping for 1 second
-  10.times { spin { sleep 1 } }
+  # start 10 fibers, each sleeping for 3 seconds
+  10.times { spin { sleep 3 } }
 
   puts 'going to sleep now'
   # wait for other fibers to terminate
@@ -106,14 +99,14 @@ library. Polyphony's design is based on the following principles:
   ```ruby
   # in Polyphony, I/O ops might block the current fiber, but implicitly yield to
   # other concurrent fibers:
-  clients.each { |client|
+  clients.each do |client|
     spin { client.puts 'Elvis has left the chatroom' }
-  }
+  end
   ```
 
 - Concurrency primitives should be accessible using idiomatic Ruby techniques
   (blocks, method chaining...) and should feel as much as possible "part of the
-  language". The resulting API is based more on methods and less on classes,
+  language". The resulting API is fundamentally based on methods rather than classes,
   for example `spin` or `move_on_after`, leading to a coding style that is both
   more compact and more legible:
 
@@ -125,8 +118,6 @@ library. Polyphony's design is based on the following principles:
   }
   ```
 
-- Breaking up operations into 
-
 - Polyphony should embrace Ruby's standard `raise/rescue/ensure` exception
   handling mechanism. Exception handling in a highly concurrent environment
   should be robust and foolproof:
@@ -147,7 +138,8 @@ library. Polyphony's design is based on the following principles:
   constructs through composition.
 
 - The entire design should embrace fibers. There should be no callback-based
-  asynchronous APIs.
+  asynchronous APIs. The library and its ecosystem will foster the development
+  of techniques and tools for converting callback-based APIs to fiber-based ones.
 
 - Use of extensive monkey patching of Ruby core modules and classes such as
   `Kernel`, `Fiber`, `IO` and `Timeout`. This allows porting over non-Polyphony
@@ -160,13 +152,10 @@ library. Polyphony's design is based on the following principles:
   # use TCPServer from Ruby's stdlib
   server = TCPServer.open('127.0.0.1', 1234)
   while (client = server.accept)
-    spin do
+    spin {
       while (data = client.gets)
-        client.write('you said: ', data.chomp, "!\n")
+        client.write("you said: #{ data.chomp }\n")
       end
-    end
+    }
   end
   ```
-
-- Development of techniques and tools for converting callback-based APIs to
-  fiber-based ones.

data/docs/main-concepts/fiber-scheduling.md

@@ -44,7 +44,7 @@ pong = Fiber.new { loop { puts "pong"; ping.transfer } }
 ping.transfer
 ```
 
-`Fiber#transform` also allows using the main fiber as a general purpose
+`Fiber#transfer` also allows using the main fiber as a general purpose
 resumable execution context. For that reason, Polyphony uses `Fiber#transfer`
 exclusively for scheduling fibers. Normally, however, applications based on
 Polyphony will not use this API directly.

data/examples/performance/messaging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+X = 1_000_000
+
+GC.disable
+
+count = 0
+
+pong = spin_loop do
+  msg, ping = receive
+  count += 1
+  ping << 'pong'
+end
+
+ping = spin do
+  X.times do
+    pong << ['ping', Fiber.current]
+    msg = receive
+    count += 1
+  end
+end
+
+t0 = Time.now
+ping.await
+dt = Time.now - t0
+puts format('message rate: %d/s', (X / dt))

data/examples/performance/multi_snooze.rb

@@ -5,19 +5,20 @@ require 'polyphony'
 
 def bm(fibers, iterations)
   count = 0
-  t0 = Time.now
-  supervise do |s|
-    fibers.times do
-      s.spin do
-        iterations.times do
-          snooze
-          count += 1
-        end
+  t_pre = Time.now
+  fibers.times do
+    spin do
+      iterations.times do
+        snooze
+        count += 1
       end
     end
   end
+  t0 = Time.now
+  Fiber.current.await_all_children
   dt = Time.now - t0
-  puts "#{[fibers, iterations].inspect} count: #{count} #{count / dt.to_f}/s"
+  puts "#{[fibers, iterations].inspect} setup: #{t0 - t_pre}s count: #{count} #{count / dt.to_f}/s"
+  Thread.current.run_queue_trace
 end
 
 GC.disable
@@ -27,5 +28,6 @@ bm(10, 100_000)
 bm(100, 10_000)
 bm(1_000, 1_000)
 bm(10_000, 100)
+
 # bm(100_000,    10)
 # bm(1_000_000,   1)

data/ext/polyphony/libev_agent.c

@@ -130,7 +130,7 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   GetLibevAgent(self, agent);
 
   if (is_nowait) {
-    long runnable_count = RARRAY_LEN(queue);
+    long runnable_count = LibevQueue_len(queue);
     agent->run_no_wait_count++;
     if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
       return self;
@@ -413,45 +413,60 @@ error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
-VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
+VALUE LibevAgent_write(int argc, VALUE *argv, VALUE self) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
+  VALUE io;
+  VALUE underlying_io;
+  long total_written = 0;
+  int arg_idx = 1;
 
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
-
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  if (argc < 2)
+    rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
+  
+  io = argv[0];
+  underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
   GetLibevAgent(self, agent);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
   watcher.fiber = Qnil;
 
-  while (left > 0) {
-    ssize_t n = write(fptr->fd, buf, left);
-    if (n < 0) {
-      int e = errno;
-      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+  while (arg_idx < argc) {
+    VALUE str = argv[arg_idx];
+    char *buf = StringValuePtr(str);
+    long len = RSTRING_LEN(str);
+    long left = len;
 
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
-    }
-    else {
-      switchpoint_result = libev_snooze();
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    while (left > 0) {
+      ssize_t n = write(fptr->fd, buf, left);
+      if (n < 0) {
+        int e = errno;
+        if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      buf += n;
-      left -= n;
+        switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+        if (TEST_EXCEPTION(switchpoint_result)) goto error;
+      }
+      else {
+        buf += n;
+        left -= n;
+      }
     }
+    total_written += len;
+    arg_idx++;
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = libev_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(total_written);
 error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
@@ -723,7 +738,7 @@ void Init_LibevAgent() {
 
   rb_define_method(cLibevAgent, "read", LibevAgent_read, 4);
   rb_define_method(cLibevAgent, "read_loop", LibevAgent_read_loop, 1);
-  rb_define_method(cLibevAgent, "write", LibevAgent_write, 2);
+  rb_define_method(cLibevAgent, "write", LibevAgent_write, -1);
   rb_define_method(cLibevAgent, "accept", LibevAgent_accept, 1);
   rb_define_method(cLibevAgent, "accept_loop", LibevAgent_accept_loop, 1);
   // rb_define_method(cLibevAgent, "connect", LibevAgent_accept, 3);

data/ext/polyphony/libev_queue.c

@@ -1,4 +1,5 @@
 #include "polyphony.h"
+#include "ring_buffer.h"
 
 struct async_watcher {
   ev_async async;
@@ -6,48 +7,65 @@ struct async_watcher {
   VALUE fiber;
 };
 
-struct async_queue {
+struct async_watcher_queue {
   struct async_watcher **queue;
-  unsigned int len;
+  unsigned int length;
   unsigned int count;
   unsigned int push_idx;
-  unsigned int pop_idx;
+  unsigned int shift_idx;
 };
 
-void async_queue_init(struct async_queue *queue) {
-  queue->len = 4;
+void async_watcher_queue_init(struct async_watcher_queue *queue) {
+  queue->length = 1;
   queue->count = 0;
-  queue->queue = malloc(sizeof(struct async_watcher *) * queue->len);
+  queue->queue = malloc(sizeof(struct async_watcher *) * queue->length);
   queue->push_idx = 0;
-  queue->pop_idx = 0;
+  queue->shift_idx = 0;
 }
 
-void async_queue_free(struct async_queue *queue) {
+void async_watcher_queue_free(struct async_watcher_queue *queue) {
   free(queue->queue);
 }
 
-void async_queue_push(struct async_queue *queue, struct async_watcher *watcher) {
-  if (queue->push_idx == queue->len) {
-    queue->len = queue->len * 2;
-    queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->len);
-  }
+void async_watcher_queue_realign(struct async_watcher_queue *queue) {
+  memmove(
+    queue->queue,
+    queue->queue + queue->shift_idx,
+    queue->count * sizeof(struct async_watcher *)
+  );
+  queue->push_idx = queue->push_idx - queue->shift_idx;
+  queue->shift_idx = 0;
+}
+
+#define QUEUE_REALIGN_THRESHOLD 32
+
+void async_watcher_queue_push(struct async_watcher_queue *queue, struct async_watcher *watcher) {
   if (queue->count == 0) {
     queue->push_idx = 0;
-    queue->pop_idx = 0;
+    queue->shift_idx = 0;
+  }
+  if (queue->push_idx == queue->length) {
+    // prevent shift idx moving too much away from zero
+    if (queue->length >= QUEUE_REALIGN_THRESHOLD && queue->shift_idx >= (queue->length / 2))
+      async_watcher_queue_realign(queue);
+    else {
+      queue->length = (queue->length == 1) ? 4 : queue->length * 2;
+      queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->length);
+    }
   }
   queue->count++;
   queue->queue[queue->push_idx++] = watcher;
 }
 
-struct async_watcher *async_queue_pop(struct async_queue *queue) {
+struct async_watcher *async_watcher_queue_shift(struct async_watcher_queue *queue) {
   if (queue->count == 0) return 0;
 
   queue->count--;
 
-  return queue->queue[queue->pop_idx++];
+  return queue->queue[queue->shift_idx++];
 }
 
-void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_idx) {
+void async_watcher_queue_remove_at_idx(struct async_watcher_queue *queue, unsigned int remove_idx) {
   queue->count--;
   queue->push_idx--;
   if (remove_idx < queue->push_idx)
@@ -58,33 +76,33 @@ void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_id
     );
 }
 
-void async_queue_remove_by_fiber(struct async_queue *queue, VALUE fiber) {
+void async_watcher_queue_remove_by_fiber(struct async_watcher_queue *queue, VALUE fiber) {
   if (queue->count == 0) return;
 
-  for (unsigned idx = queue->pop_idx; idx < queue->push_idx; idx++) {
+  for (unsigned idx = queue->shift_idx; idx < queue->push_idx; idx++) {
     if (queue->queue[idx]->fiber == fiber) {
-      async_queue_remove_at_idx(queue, idx);
+      async_watcher_queue_remove_at_idx(queue, idx);
       return; 
     }
   }
 }
 
 typedef struct queue {
-  VALUE items;
-  struct async_queue shift_queue;
+  ring_buffer values;
+  struct async_watcher_queue shift_queue;
 } LibevQueue_t;
 
-
 VALUE cLibevQueue = Qnil;
 
 static void LibevQueue_mark(void *ptr) {
   LibevQueue_t *queue = ptr;
-  rb_gc_mark(queue->items);
+  ring_buffer_mark(&queue->values);
 }
 
 static void LibevQueue_free(void *ptr) {
   LibevQueue_t *queue = ptr;
-  async_queue_free(&queue->shift_queue);
+  ring_buffer_free(&queue->values);
+  async_watcher_queue_free(&queue->shift_queue);
   xfree(ptr);
 }
 
@@ -112,8 +130,8 @@ static VALUE LibevQueue_initialize(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  queue->items = rb_ary_new();
-  async_queue_init(&queue->shift_queue);
+  ring_buffer_init(&queue->values);
+  async_watcher_queue_init(&queue->shift_queue);
 
   return self;
 }
@@ -122,18 +140,31 @@ VALUE LibevQueue_push(VALUE self, VALUE value) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
   if (queue->shift_queue.count > 0) {
-    struct async_watcher *watcher = async_queue_pop(&queue->shift_queue);
+    struct async_watcher *watcher = async_watcher_queue_shift(&queue->shift_queue);
+    if (watcher) {
+      ev_async_send(watcher->ev_loop, &watcher->async);
+    }
+  }
+  ring_buffer_push(&queue->values, value);
+  return self;
+}
+
+VALUE LibevQueue_unshift(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+  if (queue->shift_queue.count > 0) {
+    struct async_watcher *watcher = async_watcher_queue_shift(&queue->shift_queue);
     if (watcher) {
       ev_async_send(watcher->ev_loop, &watcher->async);
     }
   }
-  rb_ary_push(queue->items, value);
+  ring_buffer_unshift(&queue->values, value);
   return self;
 }
 
 struct ev_loop *LibevAgent_ev_loop(VALUE self);
 
-void async_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+void async_watcher_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
   struct async_watcher *watcher = (struct async_watcher *)ev_async;
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
@@ -144,22 +175,22 @@ VALUE LibevQueue_shift(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  if (RARRAY_LEN(queue->items) == 0) {
+  if (queue->values.count == 0) {
     struct async_watcher watcher;
     VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
     VALUE switchpoint_result = Qnil;
 
     watcher.ev_loop = LibevAgent_ev_loop(agent);
     watcher.fiber = rb_fiber_current();    
-    async_queue_push(&queue->shift_queue, &watcher);
-    ev_async_init(&watcher.async, async_queue_callback);
+    async_watcher_queue_push(&queue->shift_queue, &watcher);
+    ev_async_init(&watcher.async, async_watcher_queue_callback);
     ev_async_start(watcher.ev_loop, &watcher.async);
     
     switchpoint_result = libev_agent_await(agent);
     ev_async_stop(watcher.ev_loop, &watcher.async);
 
     if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
-      async_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
+      async_watcher_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
       return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
     }
     RB_GC_GUARD(watcher.fiber);
@@ -167,36 +198,72 @@ VALUE LibevQueue_shift(VALUE self) {
     RB_GC_GUARD(switchpoint_result);
   }
 
-  return rb_ary_shift(queue->items);
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE LibevQueue_shift_no_wait(VALUE self) {
+    LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE LibevQueue_delete(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_delete(&queue->values, value);
+  return self;
+}
+
+VALUE LibevQueue_clear(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_clear(&queue->values);
+  return self;
+}
+
+long LibevQueue_len(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->values.count;
 }
 
 VALUE LibevQueue_shift_each(VALUE self) {
   LibevQueue_t *queue;
-  VALUE old_queue;
   GetQueue(self, queue);
-  old_queue = queue->items;
-  queue->items = rb_ary_new();
-
-  if (rb_block_given_p()) {
-    long len = RARRAY_LEN(old_queue);
-    long i;
-    for (i = 0; i < len; i++) {
-      rb_yield(RARRAY_AREF(old_queue, i));
-    }
-    RB_GC_GUARD(old_queue);
-    return self;
-  }
-  else {
-    RB_GC_GUARD(old_queue);
-    return old_queue;
-  }
+
+  ring_buffer_shift_each(&queue->values);
+  return self;
+}
+
+VALUE LibevQueue_shift_all(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift_all(&queue->values);
 }
 
 VALUE LibevQueue_empty_p(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
+  return (queue->values.count == 0) ? Qtrue : Qfalse;
+}
+
+void LibevQueue_trace(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  printf(
+    "queue size: %d count: %d head: %d tail: %d\n",
+    queue->values.size,
+    queue->values.count,
+    queue->values.head,
+    queue->values.tail
+  );
 }
 
 void Init_LibevQueue() {
@@ -206,11 +273,15 @@ void Init_LibevQueue() {
   rb_define_method(cLibevQueue, "initialize", LibevQueue_initialize, 0);
   rb_define_method(cLibevQueue, "push", LibevQueue_push, 1);
   rb_define_method(cLibevQueue, "<<", LibevQueue_push, 1);
+  rb_define_method(cLibevQueue, "unshift", LibevQueue_unshift, 1);
 
-  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
   rb_define_method(cLibevQueue, "shift", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "shift_no_wait", LibevQueue_shift_no_wait, 0);
+  rb_define_method(cLibevQueue, "delete", LibevQueue_delete, 1);
 
   rb_define_method(cLibevQueue, "shift_each", LibevQueue_shift_each, 0);
+  rb_define_method(cLibevQueue, "shift_all", LibevQueue_shift_all, 0);
   rb_define_method(cLibevQueue, "empty?", LibevQueue_empty_p, 0);
 }
 

data/ext/polyphony/polyphony.h

@@ -1,5 +1,5 @@
-#ifndef RUBY_EV_H
-#define RUBY_EV_H
+#ifndef POLYPHONY_H
+#define POLYPHONY_H
 
 #include "ruby.h"
 #include "ruby/io.h"
@@ -76,9 +76,16 @@ VALUE LibevAgent_unref(VALUE self);
 int LibevAgent_ref_count(VALUE self);
 void LibevAgent_reset_ref_count(VALUE self);
 
-VALUE Polyphony_snooze(VALUE self);
+VALUE LibevQueue_push(VALUE self, VALUE value);
+VALUE LibevQueue_unshift(VALUE self, VALUE value);
+VALUE LibevQueue_shift(VALUE self);
+VALUE LibevQueue_shift_no_wait(VALUE self);
+VALUE LibevQueue_clear(VALUE self);
+VALUE LibevQueue_delete(VALUE self, VALUE value);
+long LibevQueue_len(VALUE self);
+void LibevQueue_trace(VALUE self);
 
-VALUE Polyphony_Queue_push(VALUE self, VALUE value);
+VALUE Polyphony_snooze(VALUE self);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
@@ -87,4 +94,4 @@ int io_setstrbuf(VALUE *str, long len);
 void io_set_read_length(VALUE str, long n, int shrinkable);
 VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
-#endif /* RUBY_EV_H */
+#endif /* POLYPHONY_H */

data/ext/polyphony/ring_buffer.c

@@ -0,0 +1,120 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+void ring_buffer_init(ring_buffer *buffer) {
+  buffer->size = 1;
+  buffer->count = 0;
+  buffer->entries = malloc(buffer->size * sizeof(VALUE));
+  buffer->head = 0;
+  buffer->tail = 0;
+}
+
+void ring_buffer_free(ring_buffer *buffer) {
+  free(buffer->entries);
+}
+
+int ring_buffer_empty_p(ring_buffer *buffer) {
+  return buffer->count == 0;
+}
+
+#define TRACE_RING_BUFFER(func, buffer) printf( \
+  "%s size: %d count: %d head: %d tail: %d\n", \
+  func, \
+  buffer->size, \
+  buffer->count, \
+  buffer->head, \
+  buffer->tail \
+)
+
+VALUE ring_buffer_shift(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_shift", buffer);
+
+  VALUE value;
+  if (buffer->count == 0) return Qnil;
+
+  value = buffer->entries[buffer->head];
+  buffer->head = (buffer->head + 1) % buffer->size;
+  buffer->count--;
+  // INSPECT(value);
+  return value;
+}
+
+void ring_buffer_resize(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_resize", buffer);
+
+  unsigned int old_size = buffer->size;
+  buffer->size = old_size == 1 ? 4 : old_size * 2;
+  // printf("new size: %d\n", buffer->size);
+  buffer->entries = realloc(buffer->entries, buffer->size * sizeof(VALUE));
+  for (unsigned int idx = 0; idx < buffer->head && idx < buffer->tail; idx++)
+    buffer->entries[old_size + idx] = buffer->entries[idx];
+  buffer->tail = buffer->head + buffer->count;
+}
+
+void ring_buffer_unshift(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_unshift", buffer);
+  // INSPECT(value);
+
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->head = (buffer->head - 1) % buffer->size;
+  buffer->entries[buffer->head] = value;
+  buffer->count++;
+}
+
+void ring_buffer_push(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_push", buffer);
+  // INSPECT(value);
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->entries[buffer->tail] = value;
+  buffer->tail = (buffer->tail + 1) % buffer->size;
+  buffer->count++;
+}
+
+void ring_buffer_mark(ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size]);
+}
+
+void ring_buffer_shift_each(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_shift_each", buffer);
+
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_yield(buffer->entries[(buffer->head + i) % buffer->size]);
+
+  buffer->count = buffer->head = buffer->tail = 0;
+}
+
+VALUE ring_buffer_shift_all(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_all", buffer);
+  VALUE array = rb_ary_new_capa(buffer->count);
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_ary_push(array, buffer->entries[(buffer->head + i) % buffer->size]);
+  buffer->count = buffer->head = buffer->tail = 0;
+  return array;
+}
+
+void ring_buffer_delete_at(ring_buffer *buffer, unsigned int idx) {
+  for (unsigned int idx2 = idx; idx2 != buffer->tail; idx2 = (idx2 + 1) % buffer->size) {
+    buffer->entries[idx2] = buffer->entries[(idx2 + 1) % buffer->size];
+  }
+  buffer->count--;
+  buffer->tail = (buffer->tail - 1) % buffer->size;
+}
+
+void ring_buffer_delete(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_delete", buffer);
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx] == value) {
+      ring_buffer_delete_at(buffer, idx);
+      return;
+    }
+  }
+}
+
+void ring_buffer_clear(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_clear", buffer);
+  buffer->count = buffer->head = buffer->tail = 0;
+}

data/ext/polyphony/ring_buffer.h

@@ -0,0 +1,28 @@
+#ifndef RING_BUFFER_H
+#define RING_BUFFER_H
+
+#include "ruby.h"
+
+typedef struct ring_buffer {
+  VALUE *entries;
+  unsigned int size;
+  unsigned int count;
+  unsigned int head;
+  unsigned int tail;
+} ring_buffer;
+
+void ring_buffer_init(ring_buffer *buffer);
+void ring_buffer_free(ring_buffer *buffer);
+void ring_buffer_mark(ring_buffer *buffer);
+int ring_buffer_empty_p(ring_buffer *buffer);
+void ring_buffer_clear(ring_buffer *buffer);
+
+VALUE ring_buffer_shift(ring_buffer *buffer);
+void ring_buffer_unshift(ring_buffer *buffer, VALUE value);
+void ring_buffer_push(ring_buffer *buffer, VALUE value);
+
+void ring_buffer_shift_each(ring_buffer *buffer);
+VALUE ring_buffer_shift_all(ring_buffer *buffer);
+void ring_buffer_delete(ring_buffer *buffer, VALUE value);
+
+#endif /* RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -11,10 +11,9 @@ ID ID_runnable_next;
 ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  VALUE queue;
+  VALUE queue = rb_funcall(cLibevQueue, ID_new, 0);
   
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  queue = rb_ary_new();
   rb_ivar_set(self, ID_run_queue, queue);
 
   return self;
@@ -61,7 +60,7 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   }
 
   queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_push(queue, fiber);
+  LibevQueue_push(queue, fiber);
   rb_ivar_set(fiber, ID_runnable, Qtrue);
 
   if (rb_thread_current() != self) {
@@ -88,13 +87,13 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 
   // if fiber is already scheduled, remove it from the run queue
   if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    rb_ary_delete(queue, fiber);
+    LibevQueue_delete(queue, fiber);
   } else {
     rb_ivar_set(fiber, ID_runnable, Qtrue);
   }
 
   // the fiber is given priority by putting it at the front of the run queue
-  rb_ary_unshift(queue, fiber);
+  LibevQueue_unshift(queue, fiber);
 
   if (rb_thread_current() != self) {
     // if the fiber scheduling is done across threads, we need to make sure the
@@ -124,7 +123,7 @@ VALUE Thread_switch_fiber(VALUE self) {
 
   ref_count = LibevAgent_ref_count(agent);
   while (1) {
-    next_fiber = rb_ary_shift(queue);
+    next_fiber = LibevQueue_shift_no_wait(queue);
     if (next_fiber != Qnil) {
       if (ref_count > 0) {
         // this mechanism prevents event starvation in case the run queue never
@@ -151,9 +150,15 @@ VALUE Thread_switch_fiber(VALUE self) {
     value : rb_funcall(next_fiber, ID_transfer, 1, value);
 }
 
+VALUE Thread_run_queue_trace(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  LibevQueue_trace(queue);
+  return self;
+}
+
 VALUE Thread_reset_fiber_scheduling(VALUE self) {
   VALUE queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_clear(queue);
+  LibevQueue_clear(queue);
   Thread_fiber_reset_ref_count(self);
   return self;
 }
@@ -182,6 +187,7 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "schedule_fiber_with_priority",
     Thread_schedule_fiber_with_priority, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
+  rb_define_method(rb_cThread, "run_queue_trace", Thread_run_queue_trace, 0);
 
   ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
   ID_ivar_agent               = rb_intern("@agent");

data/lib/polyphony/core/thread_pool.rb

@@ -49,7 +49,7 @@ module Polyphony
     end
 
     def run_queued_task
-      (block, watcher) = @task_queue.pop
+      (block, watcher) = @task_queue.shift
       result = block.()
       watcher&.signal(result)
     rescue Exception => e

data/lib/polyphony/extensions/core.rb

@@ -107,6 +107,15 @@ module ::Kernel
     $stdin.gets
   end
 
+  alias_method :orig_p, :p
+  def p(*args)
+    strs = args.inject([]) do |m, a|
+      m << a.inspect << "\n"
+    end
+    STDOUT.write *strs
+    args.size == 1 ? args.first : args
+  end
+
   alias_method :orig_system, :system
   def system(*args)
     Open3.popen2(*args) do |i, o, _t|

data/lib/polyphony/extensions/fiber.rb

@@ -189,7 +189,7 @@ module Polyphony
     end
 
     def receive_pending
-      @mailbox.shift_each
+      @mailbox.shift_all
     end
   end
 
@@ -221,6 +221,13 @@ module Polyphony
     def await_all_children
       return unless @children && !@children.empty?
 
+      # @results = @children.dup
+      # @on_child_done = proc do |c, r|
+      #   @results[c] = r
+      #   self.schedule if @children.empty?
+      # end
+      # suspend
+      # @results.values
       Fiber.await(*@children.keys)
     end
 

data/lib/polyphony/extensions/io.rb

@@ -108,19 +108,23 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len)
+  def readpartial(len, str = nil)
     @read_buffer ||= +''
     result = Thread.current.agent.read(self, @read_buffer, len, false)
     raise EOFError unless result
 
-    already_read = @read_buffer
+    if str
+      str << @read_buffer
+    else
+      str = @read_buffer
+    end
     @read_buffer = +''
-    already_read
+    str
   end
 
   alias_method :orig_write, :write
-  def write(str)
-    Thread.current.agent.write(self, str)
+  def write(str, *args)
+    Thread.current.agent.write(self, str, *args)
   end
 
   alias_method :orig_write_chevron, :<<
@@ -166,16 +170,13 @@ class ::IO
       return
     end
 
-    s = args.each_with_object(+'') do |a, str|
-      if a.is_a?(Array)
-        a.each { |a2| str << a2.to_s << "\n" }
-      else
-        a = a.to_s
-        str << a
-        str << "\n" unless a =~ /\n$/
-      end
+    strs = args.inject([]) do |m, a|
+      a = a.to_s
+      m << a
+      m << "\n" unless a =~ /\n$/
+      m
     end
-    write s
+    write *strs
     nil
   end
 
@@ -193,7 +194,7 @@ class ::IO
 
   alias_method :orig_write_nonblock, :write_nonblock
   def write_nonblock(string, _options = {})
-    write(string, 0)
+    write(string)
   end
 
   alias_method :orig_read_nonblock, :read_nonblock

data/lib/polyphony/extensions/socket.rb

@@ -5,6 +5,16 @@ require 'socket'
 require_relative './io'
 require_relative '../core/thread_pool'
 
+class ::BasicSocket
+  def write_nonblock(string, _options = {})
+    write(string)
+  end
+
+  def read_nonblock(maxlen, str = nil, _options = {})
+    readpartial(maxlen, str)
+  end
+end
+
 # Socket overrides (eventually rewritten in C)
 class ::Socket
   def accept

data/lib/polyphony/version.rb

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

data/test/q.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'fiber'
+require_relative '../lib/polyphony_ext'
+
+queue = Polyphony::LibevQueue.new
+
+queue.push :a
+queue.push :b
+queue.push :c
+p [queue.shift_no_wait]
+queue.push :d
+p [queue.shift_no_wait]
+p [queue.shift_no_wait]
+p [queue.shift_no_wait]
+p [queue.shift_no_wait]
+
+queue.unshift :e
+p [queue.shift_no_wait]
+
+queue.push :f
+queue.push :g
+p [queue.shift_no_wait]

data/test/test_global_api.rb

@@ -211,13 +211,13 @@ class SpinLoopTest < MiniTest::Test
 
   def test_spin_loop_location
     location = /^#{__FILE__}:#{__LINE__ + 1}/
-    f = spin_loop {}
+    f = spin_loop { snooze }
     
     assert_match location, f.location
   end
 
   def test_spin_loop_tag
-    f = spin_loop(:my_loop) {}
+    f = spin_loop(:my_loop) { snooze }
 
     assert_equal :my_loop, f.tag
   end

data/test/test_io.rb

@@ -30,6 +30,14 @@ class IOTest < MiniTest::Test
     assert_equal 'hello', msg
   end
 
+  def test_write_multiple_arguments
+    i, o = IO.pipe
+    count = o.write('a', 'b', "\n", 'c')
+    assert_equal 4, count
+    o.close
+    assert_equal "ab\nc", i.read
+  end
+
   def test_that_double_chevron_method_returns_io
     assert_equal @o, @o << 'foo'
 
@@ -121,7 +129,7 @@ class IOClassMethodsTest < MiniTest::Test
     assert_equal "end\n", lines[-1]
   end
 
-  def test_read
+  def test_read_class_method
     s = IO.read(__FILE__)
     assert_kind_of String, s
     assert(!s.empty?)
@@ -144,7 +152,7 @@ class IOClassMethodsTest < MiniTest::Test
 
   WRITE_DATA = "foo\nbar קוקו"
 
-  def test_write
+  def test_write_class_method
     fn = '/tmp/test_write'
     FileUtils.rm(fn) rescue nil
 

data/test/test_queue.rb

@@ -8,7 +8,7 @@ class QueueTest < MiniTest::Test
     @queue = Polyphony::Queue.new
   end
 
-  def test_pop
+  def test_push_shift
     spin {
       @queue << 42
     }
@@ -21,6 +21,18 @@ class QueueTest < MiniTest::Test
     assert_equal [1, 2, 3, 4], buf
   end
 
+  def test_unshift
+    @queue.push 1
+    @queue.push 2
+    @queue.push 3
+    @queue.unshift 4
+
+    buf = []
+    buf << @queue.shift while !@queue.empty?
+
+    assert_equal [4, 1, 2, 3], buf
+  end
+
   def test_multiple_waiters
     a = spin { @queue.shift }
     b = spin { @queue.shift }
@@ -41,6 +53,19 @@ class QueueTest < MiniTest::Test
     buf = []
     @queue.shift_each { |i| buf << i }
     assert_equal [1, 2, 3, 4], buf
+
+    buf = []
+    @queue.shift_each { |i| buf << i }
+    assert_equal [], buf
+  end
+
+  def test_shift_all
+    (1..4).each { |i| @queue << i }
+    buf = @queue.shift_all
+    assert_equal [1, 2, 3, 4], buf
+
+    buf = @queue.shift_all
+    assert_equal [], buf
   end
 
   def test_empty?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.43.4
+  version: 0.43.5
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-09 00:00:00.000000000 Z
+date: 2020-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -353,6 +353,7 @@ files:
 - examples/io/xx-tcpsocket.rb
 - examples/performance/fs_read.rb
 - examples/performance/mem-usage.rb
+- examples/performance/messaging.rb
 - examples/performance/multi_snooze.rb
 - examples/performance/snooze.rb
 - examples/performance/snooze_raw.rb
@@ -391,6 +392,8 @@ files:
 - ext/polyphony/polyphony.c
 - ext/polyphony/polyphony.h
 - ext/polyphony/polyphony_ext.c
+- ext/polyphony/ring_buffer.c
+- ext/polyphony/ring_buffer.h
 - ext/polyphony/thread.c
 - ext/polyphony/tracing.c
 - lib/polyphony.rb
@@ -420,6 +423,7 @@ files:
 - test/coverage.rb
 - test/eg.rb
 - test/helper.rb
+- test/q.rb
 - test/run.rb
 - test/stress.rb
 - test/test_agent.rb