async 1.26.1 → 1.26.2

data/Rakefile

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:test)
-
-task :default => :test
-
-def clone_and_test(name)
-	path = "external/#{name}"
-	FileUtils.rm_rf path
-	FileUtils.mkdir_p path
-	
-	sh("git clone https://git@github.com/socketry/#{name} #{path}")
-	
-	# I tried using `bundle config --local local.async ../` but it simply doesn't work.
-	# system("bundle", "config", "--local", "local.async", __dir__, chdir: path)
-	
-	File.open("#{path}/Gemfile", "a") do |file| 
-		file.puts('gem "async", path: "../../"')
-	end
-	
-	sh("cd #{path} && bundle install && bundle exec rspec")
-end
-
-task :external do
-	Bundler.with_clean_env do
-		clone_and_test("async-io")
-		clone_and_test("async-websocket")
-		clone_and_test("async-dns")
-		clone_and_test("async-http")
-		clone_and_test("falcon")
-		clone_and_test("async-rest")
-	end
-end
-
-task :coverage do
-	ENV['COVERAGE'] = 'y'
-end

data/async.gemspec

@@ -1,34 +0,0 @@
-
-require_relative 'lib/async/version'
-
-Gem::Specification.new do |spec|
-	spec.name = "async"
-	spec.version = Async::VERSION
-	spec.authors = ["Samuel Williams"]
-	spec.email = ["samuel.williams@oriontransfer.co.nz"]
-	spec.description = <<-EOF
-		Async is a modern concurrency framework for Ruby. It implements the
-		reactor pattern, providing both non-blocking I/O and timer events.
-	EOF
-	spec.summary = "Async is a concurrency framework for Ruby."
-	spec.homepage = "https://github.com/socketry/async"
-	spec.license = "MIT"
-	
-	spec.files = `git ls-files`.split($/)
-	spec.executables = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-	spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
-	spec.require_paths = ["lib"]
-	
-	spec.required_ruby_version = ">= 2.5.0"
-	
-	spec.add_runtime_dependency "nio4r", "~> 2.3"
-	spec.add_runtime_dependency "timers", "~> 4.1"
-	spec.add_runtime_dependency "console", "~> 1.0"
-	
-	spec.add_development_dependency "async-rspec", "~> 1.1"
-	
-	spec.add_development_dependency "covered", "~> 0.10"
-	spec.add_development_dependency "bundler"
-	spec.add_development_dependency "rspec", "~> 3.6"
-	spec.add_development_dependency "bake-bundler"
-end

data/bake.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-def external
-	require 'bundler'
-	
-	Bundler.with_clean_env do
-		clone_and_test("async-io")
-		clone_and_test("async-websocket")
-		clone_and_test("async-dns")
-		clone_and_test("async-http")
-		clone_and_test("falcon")
-		clone_and_test("async-rest")
-	end
-end
-
-private
-
-def clone_and_test(name)
-	path = "external/#{name}"
-	FileUtils.rm_rf path
-	FileUtils.mkdir_p path
-	
-	system("git clone https://git@github.com/socketry/#{name} #{path}")
-	
-	# I tried using `bundle config --local local.async ../` but it simply doesn't work.
-	# system("bundle", "config", "--local", "local.async", __dir__, chdir: path)
-	
-	File.open("#{path}/Gemfile", "a") do |file| 
-		file.puts('gem "async", path: "../../"')
-	end
-	
-	system("cd #{path} && bundle install && bundle exec rspec")
-end

data/benchmark/async_vs_lightio.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'async'
-require 'lightio'
-
-require 'benchmark/ips'
-
-#
-# It's hard to know exactly how to interpret these results. When running parallel
-# instances, resource contention is more likely to be a problem, and yet with
-# async, the performance between a single task and several tasks is roughly the
-# same, while in the case of lightio, there is an obvious performance gap.
-# 
-# The main takeaway is that contention causes issues and if systems are not
-# designed with that in mind, it will impact performance.
-#
-# $ ruby async_vs_lightio.rb
-# Warming up --------------------------------------
-# lightio (synchronous)
-#                          2.439k i/100ms
-#  async (synchronous)     2.115k i/100ms
-#   lightio (parallel)   211.000  i/100ms
-#     async (parallel)   449.000  i/100ms
-# Calculating -------------------------------------
-# lightio (synchronous)
-#                          64.502k (± 3.9%) i/s -    643.896k in  10.002151s
-#  async (synchronous)    161.195k (± 1.6%) i/s -      1.612M in  10.000976s
-#   lightio (parallel)     49.827k (±17.5%) i/s -    477.704k in   9.999579s
-#     async (parallel)    166.862k (± 6.2%) i/s -      1.662M in  10.000365s
-# 
-# Comparison:
-#     async (parallel):   166862.3 i/s
-#  async (synchronous):   161194.6 i/s - same-ish: difference falls within error
-# lightio (synchronous):   64502.5 i/s - 2.59x  slower
-#   lightio (parallel):    49827.3 i/s - 3.35x  slower
-
-
-DURATION = 0.000001
-
-def run_async(count, repeats = 10000)
-	Async::Reactor.run do |task|
-		count.times.map do
-			task.async do |subtask|
-				repeats.times do
-					subtask.sleep(DURATION)
-				end
-			end
-		end.each(&:wait)
-	end
-end
-
-def run_lightio(count, repeats = 10000)
-	count.times.map do
-		LightIO::Beam.new do
-			repeats.times do
-				LightIO.sleep(DURATION)
-			end
-		end
-	end.each(&:join)
-end
-
-Benchmark.ips do |benchmark|
-	benchmark.time = 10
-	benchmark.warmup = 2
-	
-	benchmark.report("lightio (synchronous)") do |count|
-		run_lightio(1, count)
-	end
-	
-	benchmark.report("async (synchronous)") do |count|
-		run_async(1, count)
-	end
-	
-	benchmark.report("lightio (parallel)") do |count|
-		run_lightio(32, count/32)
-	end
-	
-	benchmark.report("async (parallel)") do |count|
-		run_async(32, count/32)
-	end
-	
-	benchmark.compare!
-end

data/benchmark/fiber_count.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-fibers = []
-
-(1..).each do |i|
-	fibers << Fiber.new{}
-	fibers.last.resume
-	puts i
-end
-

data/benchmark/rubies/README.md

@@ -1,51 +0,0 @@
-# (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

@@ -1,220 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-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