async 1.21.0 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c9a081ed81fc6b4b0b34ebb5282063574994045189a9544b968c7729543cf1
-  data.tar.gz: df9d9266a02ff86895cfc9934fbafbeeb7159cb1b964f10705323d9f4798ae34
+  metadata.gz: 4fa7e7ae29e8bff86757e97d1f63bb5fd297caa79f97b5e4ccdc1f4568d65609
+  data.tar.gz: 17239cfec1b3b5062fdf6745b7708ebbdd9f39c63199dc33cc6495362da016ca
 SHA512:
-  metadata.gz: 1f5014904c26006fd50462c9161f3ae24f867ed995569bc1faecebe67d3a1b8799eb4a91896121a07885512ae21361be18f9f9ea3614825140cb3596239cc13b
-  data.tar.gz: 26c13f37945ceb4d2542a2ef0736b6fe04cc9515d90053d4b2a00888a5501c008ce614849462b006216a94a1eece3fc781cf378f25f369ae65bceeede12dbfe6
+  metadata.gz: 18566e7d62eca30c72491cc06f633baa1f2b027fbb474f7bb226d0c5ea09cc095e06b3f2943470f378d98a2174ff8e0b4d7875643f3abba751fe69c76e3f6657
+  data.tar.gz: 12aed7ad107c756e90292a2179336441205d66a4f457dcf1d55e5655d9bc361753a9b4deb48c644104ca5d349610a1eb33773e995c91a7e2b92a71c97df3a0cd

data/benchmark/rubies/README.md

@@ -0,0 +1,51 @@
+# (All) Rubies Benchmark
+
+This is a simple benchmark, which reads and writes data over a pipe.
+
+It is designed to work as far back as Ruby 1.9.3 at the expense of code clarity. It also works on JRuby and TruffleRuby.
+
+## Usage
+
+The simplest way is to use RVM.
+
+	rvm all do ./benchmark.rb
+
+## Results
+
+General improvements.
+
+	ruby 1.9.3p551 (2014-11-13 revision 48407) [x86_64-linux]
+	#<struct Struct::Tms utime=63.41, stime=7.15, cutime=0.0, cstime=0.0>
+
+	ruby 2.0.0p648 (2015-12-16 revision 53162) [x86_64-linux]
+	#<struct Struct::Tms utime=59.5, stime=6.57, cutime=0.0, cstime=0.0>
+
+	ruby 2.1.10p492 (2016-04-01 revision 54464) [x86_64-linux]
+	#<struct Process::Tms utime=40.53, stime=6.87, cutime=0.0, cstime=0.0>
+
+	ruby 2.2.10p489 (2018-03-28 revision 63023) [x86_64-linux]
+	#<struct Process::Tms utime=41.26, stime=6.62, cutime=0.0, cstime=0.0>
+
+	ruby 2.3.8p459 (2018-10-18 revision 65136) [x86_64-linux]
+	#<struct Process::Tms utime=31.85, stime=6.55, cutime=0.0, cstime=0.0>
+
+	ruby 2.4.6p354 (2019-04-01 revision 67394) [x86_64-linux]
+	#<struct Process::Tms utime=41.89, stime=6.72, cutime=0.0, cstime=0.0>
+
+	ruby 2.5.3p105 (2018-10-18 revision 65156) [x86_64-linux]
+	#<struct Process::Tms utime=26.446285, stime=6.549777, cutime=0.0, cstime=0.0>
+
+Native fiber implementation & reduced syscalls (https://bugs.ruby-lang.org/issues/14739).
+
+	ruby 2.6.3p62 (2019-04-16 revision 67580) [x86_64-linux]
+	#<struct Process::Tms utime=20.045192, stime=5.5941600000000005, cutime=0.0, cstime=0.0>
+
+Performance regression (https://bugs.ruby-lang.org/issues/16009).
+
+	ruby 2.7.0preview1 (2019-05-31 trunk c55db6aa271df4a689dc8eb0039c929bf6ed43ff) [x86_64-linux]
+	#<struct Process::Tms utime=25.193268, stime=5.808202, cutime=0.0, cstime=0.0>
+
+Improve fiber performance using pool alloation strategy (https://bugs.ruby-lang.org/issues/15997).
+
+	ruby 2.7.0dev (2019-10-02T08:19:14Z trunk 9759e3c9f0) [x86_64-linux]
+	#<struct Process::Tms utime=19.110835, stime=5.738776, cutime=0.0, cstime=0.0>

data/benchmark/rubies/benchmark.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'fiber'
+
+puts
+puts RUBY_DESCRIPTION
+
+if RUBY_VERSION < "2.0"
+	class String
+		def b
+			self
+		end
+	end
+end
+
+# TODO: make these much larger, see if we're effectively batching
+# even if we don't mean to...
+QUERY_TEXT = "STATUS".freeze
+RESPONSE_TEXT = "OK".freeze
+
+NUM_WORKERS = (ARGV[0] || 10_000).to_i
+NUM_REQUESTS = (ARGV[1] || 100).to_i
+
+# Fiber reactor code taken from
+# https://www.codeotaku.com/journal/2018-11/fibers-are-the-right-solution/index
+class Reactor
+		def initialize
+				@readable = {}
+				@writable = {}
+		end
+
+		def run
+				while @readable.any? or @writable.any?
+						readable, writable = IO.select(@readable.keys, @writable.keys, [])
+
+						readable.each do |io|
+								@readable[io].resume
+						end
+
+						writable.each do |io|
+								@writable[io].resume
+						end
+				end
+		end
+
+		def wait_readable(io)
+				@readable[io] = Fiber.current
+				Fiber.yield
+				@readable.delete(io)
+		end
+
+		def wait_writable(io)
+				@writable[io] = Fiber.current
+				Fiber.yield
+				@writable.delete(io)
+		end
+end
+
+class Wrapper
+	def initialize(io, reactor)
+		@io = io
+		@reactor = reactor
+	end
+	
+	if RUBY_VERSION >= "2.3"
+		def read_nonblock(length, buffer)
+			while true
+				case result = @io.read_nonblock(length, buffer, exception: false)
+				when :wait_readable
+					@reactor.wait_readable(@io)
+				when :wait_writable
+					@reactor.wait_writable(@io)
+				else
+					return result
+				end
+			end
+
+		end
+		
+		def write_nonblock(buffer)
+			while true
+				case result = @io.write_nonblock(buffer, exception: false)
+				when :wait_readable
+					@reactor.wait_readable(@io)
+				when :wait_writable
+					@reactor.wait_writable(@io)
+				else
+					return result
+				end
+			end
+		end
+	else
+		def read_nonblock(length, buffer)
+			while true
+				begin
+					return @io.read_nonblock(length, buffer)
+				rescue IO::WaitReadable
+					@reactor.wait_readable(@io)
+				rescue IO::WaitWritable
+					@reactor.wait_writable(@io)
+				end
+			end
+		end
+		
+		def write_nonblock(buffer)
+			while true
+				begin
+					return @io.write_nonblock(buffer)
+				rescue IO::WaitReadable
+					@reactor.wait_readable(@io)
+				rescue IO::WaitWritable
+					@reactor.wait_writable(@io)
+				end
+			end
+		end
+	end
+	
+	def read(length, buffer = nil)
+		if buffer
+			buffer.clear
+		else
+			buffer = String.new.b
+		end
+		
+		result = self.read_nonblock(length - buffer.bytesize, buffer)
+		
+		if result == length
+			return result
+		end
+		
+		chunk = String.new.b
+		while chunk = self.read_nonblock(length - buffer.bytesize, chunk)
+			buffer << chunk
+			
+			break if buffer.bytesize == length
+		end
+		
+		return buffer
+	end
+	
+	def write(buffer)
+		remaining = buffer.dup
+		
+		while true
+			result = self.write_nonblock(remaining)
+			
+			if result == remaining.bytesize
+				return buffer.bytesize
+			else
+				remaining = remaining.byteslice(result, remaining.bytesize - result)
+			end
+		end
+	end
+end
+
+reactor = Reactor.new
+
+worker_read = []
+worker_write = []
+
+master_read = []
+master_write = []
+
+workers = []
+
+# puts "Setting up pipes..."
+NUM_WORKERS.times do |i|
+	r, w = IO.pipe
+	worker_read.push Wrapper.new(r, reactor)
+	master_write.push Wrapper.new(w, reactor)
+
+	r, w = IO.pipe
+	worker_write.push Wrapper.new(w, reactor)
+	master_read.push Wrapper.new(r, reactor)
+end
+
+# puts "Setting up fibers..."
+NUM_WORKERS.times do |i|
+	f = Fiber.new do
+		# Worker code
+		NUM_REQUESTS.times do |req_num|
+			q = worker_read[i].read(QUERY_TEXT.size)
+			if q != QUERY_TEXT
+				raise "Fail! Expected #{QUERY_TEXT.inspect} but got #{q.inspect} on request #{req_num.inspect}!"
+			end
+			worker_write[i].write(RESPONSE_TEXT)
+		end
+	end
+	workers.push f
+end
+
+workers.each { |f| f.resume }
+
+master_fiber = Fiber.new do
+	NUM_WORKERS.times do |worker_num|
+		f = Fiber.new do
+			NUM_REQUESTS.times do |req_num|
+				master_write[worker_num].write(QUERY_TEXT)
+				buffer = master_read[worker_num].read(RESPONSE_TEXT.size)
+				if buffer != RESPONSE_TEXT
+					raise "Error! Fiber no. #{worker_num} on req #{req_num} expected #{RESPONSE_TEXT.inspect} but got #{buf.inspect}!"
+				end
+			end
+		end
+		f.resume
+	end
+end
+
+master_fiber.resume
+
+# puts "Starting reactor..."
+reactor.run
+
+# puts "Done, finished all reactor Fibers!"
+
+puts Process.times
+
+# Exit

data/lib/async/barrier.rb

@@ -0,0 +1,51 @@
+# Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'task'
+
+module Async
+	# A semaphore is used to control access to a common resource in a concurrent system. A useful way to think of a semaphore as used in the real-world systems is as a record of how many units of a particular resource are available, coupled with operations to adjust that record safely (i.e. to avoid race conditions) as units are required or become free, and, if necessary, wait until a unit of the resource becomes available.
+	class Barrier
+		def initialize
+			@tasks = []
+		end
+		
+		# All tasks which have been invoked into the barrier.
+		attr :tasks
+		
+		def async(*args, parent: Task.current, **options, &block)
+			task = parent.async(*args, **options, &block)
+			
+			@tasks << task
+			
+			return task
+		end
+		
+		def empty?
+			@tasks.empty?
+		end
+		
+		def wait
+			while task = @tasks.pop
+				task.wait
+			end
+		end
+	end
+end

data/lib/async/reactor.rb

@@ -116,9 +116,9 @@ module Async
 			# When calling an async block, we deterministically execute it until the
 			# first blocking operation. We don't *have* to do this - we could schedule
 			# it for later execution, but it's useful to:
-			# - Fail at the point of call where possible.
+			# - Fail at the point of the method call where possible.
 			# - Execute determinstically where possible.
-			# - Avoid overhead if no blocking operation is performed.
+			# - Avoid scheduler overhead if no blocking operation is performed.
 			task.run(*args)
 			
 			# logger.debug "Initial execution of task #{fiber} complete (#{result} -> #{fiber.alive?})..."
@@ -168,7 +168,7 @@ module Async
 			
 			initial_task = self.async(*args, &block) if block_given?
 			
-			@timers.wait do |interval|
+			until @stopped
 				# logger.debug(self) {"@ready = #{@ready} @running = #{@running}"}
 				
 				if @ready.any?
@@ -180,17 +180,16 @@ module Async
 					end
 					
 					@running.clear
-					
-					# if there are tasks ready to execute, don't sleep.
-					if @ready.any?
-						interval = 0
-					else
-						# The above tasks may schedule, cancel or affect timers in some way. We need to compute a new wait interval for the blocking selector call below:
-						interval = @timers.wait_interval
-					end
 				end
 				
-				# As timeouts may have been updated, and caused fibers to complete, we should check this.
+				if @ready.empty?
+					interval = @timers.wait_interval
+				else
+					# if there are tasks ready to execute, don't sleep:
+					interval = 0
+				end
+				
+				# If there is no interval to wait (thus no timers), and no tasks, we could be done:
 				if interval.nil?
 					if self.finished?
 						# If there is nothing to do, then finish:
@@ -207,7 +206,9 @@ module Async
 						monitor.value.resume
 					end
 				end
-			end until @stopped
+				
+				@timers.fire
+			end
 			
 			return initial_task
 		ensure

data/lib/async/semaphore.rb

@@ -47,12 +47,10 @@ module Async
 		end
 		
 		# Run an async task. Will wait until the semaphore is ready until spawning and running the task.
-		def async(*args)
-			parent = Task.current
-			
+		def async(*args, parent: Task.current, **options)
 			wait
 			
-			parent.async do |task|
+			parent.async(**options) do |task|
 				@count += 1
 				
 				begin

data/lib/async/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Async
-	VERSION = "1.21.0"
+	VERSION = "1.22.0"
 end

data/spec/async/barrier_spec.rb

@@ -0,0 +1,77 @@
+# Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'async/barrier'
+require 'async/clock'
+require 'async/rspec'
+
+RSpec.describe Async::Barrier do
+	include_context Async::RSpec::Reactor
+	
+	context '#async' do
+		let(:repeats) {40}
+		let(:delay) {0.1}
+		
+		it 'should wait for all jobs to complete' do
+			finished = 0
+			
+			repeats.times.map do |i|
+				subject.async do |task|
+					task.sleep(delay)
+					finished += 1
+					
+					# This task is a child task but not part of the barrier.
+					task.async do
+						task.sleep(delay*3)
+					end
+				end
+			end
+			
+			expect(subject).to_not be_empty
+			expect(finished).to be < repeats
+			
+			duration = Async::Clock.measure{subject.wait}
+			
+			expect(duration).to be < (delay * 2)
+			expect(finished).to be == repeats
+			expect(subject).to be_empty
+		end
+	end
+	
+	context '#wait' do
+		it 'should wait for tasks even after exceptions' do
+			task1 = subject.async do
+				raise "Boom"
+			end
+			
+			task2 = subject.async do
+			end
+			
+			expect(task1).to be_failed
+			expect(task2).to be_finished
+			
+			expect{subject.wait}.to raise_exception(/Boom/)
+			
+			subject.wait until subject.empty?
+			
+			expect(subject).to be_empty
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 1.21.0
+  version: 1.22.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-17 00:00:00.000000000 Z
+date: 2019-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -144,6 +144,8 @@ files:
 - async.gemspec
 - benchmark/async_vs_lightio.rb
 - benchmark/fiber_count.rb
+- benchmark/rubies/README.md
+- benchmark/rubies/benchmark.rb
 - benchmark/thread_count.rb
 - benchmark/thread_vs_fiber.rb
 - examples/async_method.rb
@@ -157,6 +159,7 @@ files:
 - examples/stop/sleep.rb
 - gems/event.gemfile
 - lib/async.rb
+- lib/async/barrier.rb
 - lib/async/clock.rb
 - lib/async/condition.rb
 - lib/async/debug/monitor.rb
@@ -176,6 +179,7 @@ files:
 - logo.svg
 - papers/1982 Grossman.pdf
 - papers/1987 ODell.pdf
+- spec/async/barrier_spec.rb
 - spec/async/clock_spec.rb
 - spec/async/condition_examples.rb
 - spec/async/condition_spec.rb
@@ -218,6 +222,7 @@ signing_key:
 specification_version: 4
 summary: Async is an asynchronous I/O framework based on nio4r.
 test_files:
+- spec/async/barrier_spec.rb
 - spec/async/clock_spec.rb
 - spec/async/condition_examples.rb
 - spec/async/condition_spec.rb