polyphony 0.43 → 0.43.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eb88a97bf07f85f50aa46923883fce2fe1bbd253407021a6f5bb246e0fdcfdc
-  data.tar.gz: c707861eb93f709661aa90abb33519004df5ff5db16f2d3da00387b292234027
+  metadata.gz: 55e44a81e7358528fabd37e1d48b6387957bc6001e4d947bf6c881d2425953d9
+  data.tar.gz: 45af7e485891927a1e9f88e8a6342692c25f306aa60e40fa8a74c0ca8494d3d4
 SHA512:
-  metadata.gz: b554716ed26188fec86606198cdca669253d921017748ef0d9231db9f01e08e046b62fc38c0c6c3595a42f1976771db8b42c352c0431cc73f4b1ed64f7edf3c9
-  data.tar.gz: 3ba74e7427fab47a65cd466e9bbe14e48176f737f6fd7fca21b3143d75d1dd9fa2ddef24b723d83f26f321949171359d946cfd4281b3b96c33bf43593199adce
+  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,32 @@
+## 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
+* Dynamically allocate read buffer if length not given (#23)
+* Prevent CPU saturation on infinite sleep (#24)
+
+## 0.43.3 2020-07-08
+
+* Fix behaviour after call to `Process.daemon` (#8)
+* Replace core `Queue` class with `Polyphony::Queue` (#22)
+* Make `ResourcePool` reentrant (#1)
+* Accept `:with_exception` argument in `cancel_after` (#16)
+
+## 0.43.2 2020-07-07
+
+* Fix sending Redis commands with array arguments (#21)
+
+## 0.43.1 2020-06
+
+* Fix compiling C-extension on MacOS (#20)
+
 ## 0.43 2020-07-05
 
 * Add IO#read_loop

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.43)
+    polyphony (0.43.5)
 
 GEM
   remote: https://rubygems.org/
@@ -12,7 +12,7 @@ GEM
     ast (2.4.0)
     builder (3.2.4)
     colorator (1.1.0)
-    concurrent-ruby (1.1.5)
+    concurrent-ruby (1.1.6)
     docile (1.3.2)
     em-websocket (0.5.1)
       eventmachine (>= 0.12.9)

data/README.md

@@ -1,6 +1,5 @@
 # Polyphony - Fine-Grained Concurrency for Ruby
 
-
 [![Gem Version](https://badge.fury.io/rb/polyphony.svg)](http://rubygems.org/gems/polyphony)
 [![Modulation Test](https://github.com/digital-fabric/polyphony/workflows/Tests/badge.svg)](https://github.com/digital-fabric/polyphony/actions?query=workflow%3ATests)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/polyphony/blob/master/LICENSE)

data/docs/_sass/custom/custom.scss

@@ -0,0 +1,10 @@
+
+h1.logo-title {
+  font-size: 42px !important;
+  font-weight: bold;
+}
+
+h2.logo-title {
+  margin-top: 0.25em;
+  margin-bottom: 1em;
+}

data/docs/getting-started/overview.md

@@ -279,7 +279,7 @@ def chat_user_handler(user_name, connection)
   while command = connection.gets
     case command
     when /^connect (.+)/
-      room&.send [:unsubscribe, message_subscriber]
+      room&.send [:subscribe, message_subscriber]
       room = CHAT_ROOMS[$1]
     when "disconnect"
       room&.send [:unsubscribe, message_subscriber]
@@ -483,4 +483,4 @@ reach version 1.0. Here are some of the exciting directions we're working on.
 - Support for more core and stdlib APIs
 - More adapters for gems with C-extensions, such as `mysql`, `sqlite3` etc
 - Use `io_uring` agent as alternative to the libev agent 
-- More concurrency constructs for building highly concurrent applications
+- More concurrency constructs for building highly concurrent applications

data/docs/index.md

@@ -6,7 +6,11 @@ permalink: /
 next_title: Installing Polyphony
 ---
 
-# Polyphony - fine-grained concurrency for Ruby
+# Polyphony
+{:.text-center .logo-title}
+
+## Fine-grained concurrency for Ruby
+{:.text-center .logo-title}
 
 Polyphony is a library for building concurrent applications in Ruby. Polyphony
 implements a comprehensive
@@ -14,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/adapters/concurrent-ruby.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'concurrent'
+
+puts "Hello, concurrent-ruby"
+
+# this program should not hang with concurrent-ruby 1.1.6 (see issue #22)

data/examples/adapters/redis_blpop.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+# require 'redis'
+
+redis = Redis.new(host: ENV['REDISHOST'] || 'localhost')
+
+redis.lpush("queue_key", "omgvalue")
+puts "len: #{redis.llen("queue_key")}"
+result = redis.blpop("queue_key")
+puts result.inspect

data/examples/core/xx-daemon.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "pid: #{Process.pid}"
+
+Process.daemon(true, true)
+
+Polyphony::ThreadPool.process do
+  puts "Hello world from pid #{Process.pid}"
+end

data/examples/performance/mem-usage.rb

@@ -4,47 +4,53 @@ def mem_usage
   `ps -o rss #{$$}`.split.last.to_i
 end
 
-def calculate_fiber_memory_cost(count)
+def calculate_memory_cost(name, count, &block)
+  GC.enable
+  ObjectSpace.garbage_collect
+  sleep 0.5
   GC.disable
   rss0 = mem_usage
-  count.times { Fiber.new { sleep 1 } }
+  count0 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  a = []
+  count.times { a << block.call }
   rss1 = mem_usage
-  GC.start
+  count1 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  p [count0, count1]
+  # sleep 0.5
   cost = (rss1 - rss0).to_f / count
+  count_delta = (count1 - count0) / count
 
-  puts "fiber memory cost: #{cost}KB"
+  puts "#{name} rss cost: #{cost}KB     object count: #{count_delta}"
 end
 
-calculate_fiber_memory_cost(10000)
-
-def calculate_thread_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { Thread.new { sleep 1 } }
-  sleep 0.5
-  rss1 = mem_usage
-  sleep 0.5
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = Fiber.new { |f| f.transfer }
+f.transfer Fiber.current
 
-  puts "thread memory cost: #{cost}KB"
+calculate_memory_cost('fiber', 10000) do
+  f = Fiber.new { |f| f.transfer :foo }
+  f.transfer Fiber.current
+  f
 end
 
-calculate_thread_memory_cost(500)
+t = Thread.new { sleep 1}
+t.kill
+t.join
+
+calculate_memory_cost('thread', 500) do
+  t = Thread.new { sleep 1 }
+  sleep 0.001
+  t
+end
+(Thread.list - [Thread.current]).each(&:kill).each(&:join)
 
 require 'bundler/setup'
 require 'polyphony'
 
-def calculate_extended_fiber_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { spin { :foo } }
-  snooze
-  rss1 = mem_usage
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = spin { sleep 0.1 }
+f.await
 
-  puts "extended fiber memory cost: #{cost}KB"
+calculate_memory_cost('polyphony fiber', 10000) do
+  f = spin { :foo }
+  f.await
+  f
 end
-
-calculate_extended_fiber_memory_cost(10000)

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)