async 1.26.1 → 1.26.2

data/benchmark/thread_count.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-threads = []
-
-(1..).each do |i|
-	threads << Thread.new{sleep}
-	puts i
-end
-

data/benchmark/thread_vs_fiber.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# 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 'benchmark/ips'
-
-GC.disable
-
-Benchmark.ips do |benchmark|
-	benchmark.time = 1
-	benchmark.warmup = 1
-	
-	benchmark.report("Thread.new{}") do |count|
-		while count > 0
-			Thread.new{count -= 1}.join
-		end
-	end
-	
-	benchmark.report("Fiber.new{}") do |count|
-		while count > 0
-			Fiber.new{count -= 1}.resume
-		end
-	end
-	
-	benchmark.compare!
-end

data/examples/async_method.rb

@@ -1,60 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative '../lib/async'
-
-module Async::Methods
-	def sleep(*args)
-		Async::Task.current.sleep(*args)
-	end
-
-	def async(name)
-		original_method = self.method(name)
-		
-		define_method(name) do |*args|
-			Async::Reactor.run do |task|
-				original_method.call(*args)
-			end
-		end
-	end
-
-	def await(&block)
-		block.call.wait
-	end
-	
-	def barrier!
-		Async::Task.current.children.each(&:wait)
-	end
-end
-
-include Async::Methods
-
-async def count_chickens(area_name)
-	3.times do |i|
-		sleep rand
-		
-		puts "Found a chicken in the #{area_name}!"
-	end
-end
-
-async def find_chicken(areas)
-	puts "Searching for chicken..."
-	
-	sleep rand * 5
-	
-	return areas.sample
-end
-
-async def count_all_chckens
-	# These methods all run at the same time.
-	count_chickens("garden")
-	count_chickens("house")
-	count_chickens("tree")
-	
-	# Wait for all previous async work to complete...
-	barrier!
-	
-	puts "There was a chicken in the #{find_chicken(["garden", "house", "tree"]).wait}"
-end
-
-count_all_chckens

data/examples/callback/loop.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'async/reactor'
-
-class Callback
-	def initialize
-		@reactor = Async::Reactor.new
-	end
-	
-	def close
-		@reactor.close
-	end
-	
-	# If duration is 0, it will happen immediately after the task is started.
-	def run(duration = 0)
-		@reactor.run do |task|
-			@reactor.after(duration) do
-				@reactor.stop
-			end
-			
-			yield(task) if block_given?
-		end
-	end
-end
-
-
-callback = Callback.new
-
-begin
-	callback.run do |task|
-		while true
-			task.sleep(2)
-			puts "Hello from task!"
-		end
-	end
-	
-	while true
-		callback.run(0)
-		puts "Sleeping for 1 second"
-		sleep(1)
-	end
-ensure
-	callback.close
-end

data/examples/capture/README.md

@@ -1,59 +0,0 @@
-# Capture
-
-## Falcon
-
-```
-% wrk -t 8 -c 32 http://localhost:9292/
-Running 10s test @ http://localhost:9292/
-  8 threads and 32 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency   106.31ms   10.20ms 211.79ms   98.00%
-    Req/Sec    37.94      5.43    40.00     84.24%
-  3003 requests in 10.01s, 170.16KB read
-Requests/sec:    299.98
-Transfer/sec:     17.00KB
-```
-
-```
-0.0s: Process 28065 start times:
-    | #<struct Process::Tms utime=2.38, stime=0.0, cutime=0.0, cstime=0.2>
-^C15.11s: strace -p 28065
-    | ["sendto", {:"% time"=>57.34, :seconds=>0.595047, :"usecs/call"=>14, :calls=>39716, :errors=>32, :syscall=>"sendto"}]
-    | ["recvfrom", {:"% time"=>42.58, :seconds=>0.441867, :"usecs/call"=>12, :calls=>36718, :errors=>70, :syscall=>"recvfrom"}]
-    | ["read", {:"% time"=>0.07, :seconds=>0.000723, :"usecs/call"=>7, :calls=>98, :errors=>nil, :syscall=>"read"}]
-    | ["write", {:"% time"=>0.01, :seconds=>0.000112, :"usecs/call"=>56, :calls=>2, :errors=>nil, :syscall=>"write"}]
-    | [:total, {:"% time"=>100.0, :seconds=>1.037749, :"usecs/call"=>nil, :calls=>76534, :errors=>102, :syscall=>"total"}]
-15.11s: Process 28065 end times:
-    | #<struct Process::Tms utime=3.93, stime=0.0, cutime=0.0, cstime=0.2>
-15.11s: Process Waiting: 1.0377s out of 1.55s
-    | Wait percentage: 66.95%
-```
-
-## Puma
-
-```
-wrk -t 8 -c 32 http://localhost:9292/
-Running 10s test @ http://localhost:9292/
-  8 threads and 32 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency   108.83ms    3.50ms 146.38ms   86.58%
-    Req/Sec    34.43      6.70    40.00     92.68%
-  1371 requests in 10.01s, 81.67KB read
-Requests/sec:    136.94
-Transfer/sec:      8.16KB
-```
-
-```
-0.0s: Process 28448 start times:
-    | #<struct Process::Tms utime=0.63, stime=0.0, cutime=0.0, cstime=0.2>
-^C24.89s: strace -p 28448
-    | ["recvfrom", {:"% time"=>64.65, :seconds=>0.595275, :"usecs/call"=>13, :calls=>44476, :errors=>27769, :syscall=>"recvfrom"}]
-    | ["sendto", {:"% time"=>30.68, :seconds=>0.282467, :"usecs/call"=>18, :calls=>15288, :errors=>nil, :syscall=>"sendto"}]
-    | ["write", {:"% time"=>4.66, :seconds=>0.042921, :"usecs/call"=>15, :calls=>2772, :errors=>nil, :syscall=>"write"}]
-    | ["read", {:"% time"=>0.02, :seconds=>0.000157, :"usecs/call"=>8, :calls=>19, :errors=>1, :syscall=>"read"}]
-    | [:total, {:"% time"=>100.0, :seconds=>0.92082, :"usecs/call"=>nil, :calls=>62555, :errors=>27770, :syscall=>"total"}]
-24.89s: Process 28448 end times:
-    | #<struct Process::Tms utime=3.19, stime=0.0, cutime=0.0, cstime=0.2>
-24.89s: Process Waiting: 0.9208s out of 2.56s
-    | Wait percentage: 35.97%
-```

data/examples/capture/capture.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'irb'
-require 'console'
-
-pids = ARGV.collect(&:to_i)
-
-TICKS = Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz).to_f
-
-def getrusage(pid)
-	fields = File.read("/proc/#{pid}/stat").split(/\s+/)
-	
-	return Process::Tms.new(
-		fields[14].to_f / TICKS,
-		fields[15].to_f / TICKS,
-		fields[16].to_f / TICKS,
-		fields[17].to_f / TICKS,
-	)
-end
-
-def parse(value)
-	case value
-	when /^\s*\d+\.\d+/
-		Float(value)
-	when /^\s*\d+/
-		Integer(value)
-	else
-		value = value.strip
-		if value.empty?
-			nil
-		else
-			value
-		end
-	end
-end
-
-def strace(pid, duration = 60)
-	input, output = IO.pipe
-	
-	pid = Process.spawn("strace", "-p", pid.to_s, "-cqf", "-w", "-e", "!futex", err: output)
-	
-	output.close
-	
-	Signal.trap(:INT) do
-		Process.kill(:INT, pid)
-		Signal.trap(:INT, :DEFAULT)
-	end
-	
-	Thread.new do
-		sleep duration
-		Process.kill(:INT, pid)
-	end
-	
-	summary = {}
-	
-	if first_line = input.gets
-		if rule = input.gets # horizontal separator
-			pattern = Regexp.new(
-				rule.split(/\s/).map{|s| "(.{1,#{s.size}})"}.join(' ')
-			)
-			
-			header = pattern.match(first_line).captures.map{|key| key.strip.to_sym}
-		end
-		
-		while line = input.gets
-			break if line == rule
-			row = pattern.match(line).captures.map{|value| parse(value)}
-			fields = header.zip(row).to_h
-			
-			summary[fields[:syscall]] = fields
-		end
-		
-		if line = input.gets
-			row = pattern.match(line).captures.map{|value| parse(value)}
-			fields = header.zip(row).to_h
-			summary[:total] = fields
-		end
-	end
-	
-	_, status = Process.waitpid2(pid)
-	
-	Console.logger.error(status) do |buffer|
-		buffer.puts first_line
-	end unless status.success?
-	
-	return summary
-end
-
-pids.each do |pid|
-	start_times = getrusage(pid)
-	Console.logger.info("Process #{pid} start times:", start_times)
-	
-	# sleep 60
-	summary = strace(pid)
-	
-	Console.logger.info("strace -p #{pid}") do |buffer|
-		summary.each do |fields|
-			buffer.puts fields.inspect
-		end
-	end
-	
-	end_times = getrusage(pid)
-	Console.logger.info("Process #{pid} end times:", end_times)
-	
-	if total = summary[:total]
-		process_duration = end_times.utime - start_times.utime
-		wait_duration = summary[:total][:seconds]
-	
-		Console.logger.info("Process Waiting: #{wait_duration.round(4)}s out of #{process_duration.round(4)}s") do |buffer|
-			buffer.puts "Wait percentage: #{(wait_duration / process_duration * 100.0).round(2)}%"
-		end
-	else
-		Console.logger.warn("No system calls detected.")
-	end
-end

data/examples/fibers.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require 'fiber'
-
-class IO
-	READABLE = 1
-	WRITABLE = 2
-	
-	# rb_wait_for_single_fd (int fd, int events, struct timeval *tv)
-	def self.wait(descriptor, events, duration)
-		fiber = Fiber.current
-		reactor = fiber.reactor
-		
-		monitor = reactor.add_io(fiber, descriptor, state)
-		
-		fiber.with_timeout(duration) do
-			result = Fiber.yield
-			raise result if result.is_a? Exception
-		end
-		
-		return result
-	ensure
-		reactor.remove_io(monitor)
-	end
-	
-	def wait_readable(duration = nil)
-		wait_any(READABLE)
-	end
-	
-	def wait_writable(duration = nil)
-		wait_any(WRITABLE)
-	end
-	
-	def wait_until(events = READABLE|WRITABLE, duration = nil)
-		IO.wait_for_io(self.fileno, events, duration)
-	end
-end
-
-class Fiber
-	# Raised when a task times out.
-	class TimeoutError < RuntimeError
-	end
-	
-	# This should be inherited by nested fibers.
-	attr :reactor
-	
-	def timeout(duration)
-		reactor = self.reactor
-		backtrace = caller
-		
-		timer = reactor.add_timer(duration) do
-			if self.alive?
-				error = Fiber::TimeoutError.new("execution expired")
-				error.set_backtrace backtrace
-				self.resume error
-			end
-		end
-		
-		yield
-	ensure
-		reactor.cancel_timer(timer)
-	end
-end
-
-# Can be standard implementation, but could also be provided by external gem/library.
-class Fiber::Reactor
-	# Add IO to the reactor. The reactor will call `fiber.resume` when the event is triggered.
-	# Returns an opaque monitor object which can be passed to `remove_io` to stop waiting for events.
-	def add_io(fiber, io, state)
-		# The motivation for add_io and remove_io is that it's how a lot of the underlying APIs work, where remove_io just takes the file descriptor.
-		# It also avoids the need for any memory allocation, and maps well to how it's typically used (i.e. in an implementation of `IO#read`).
-		# An efficient implementation might do it's job and then just:
-		return io
-	end
-	
-	def remove_io(monitor)
-	end
-	
-	# The reactor will call the block at some point after duration time has elapsed.
-	# Returns an opaque timer object which can be passed to `cancel_timer` to avoid this happening.
-	def add_timer(duration, &block)
-	end
-	
-	def cancel_timer(timer)
-	end
-	
-	# Run until idle (no registered io/timers), or duration time has passed if specified.
-	def run(duration = nil)
-	end
-	
-	# Stop the reactor as soon as possible. Can be called from another thread.
-	def stop
-	end
-	
-	def close
-		# Close the reactor so it can no longer be used.
-	end
-end
-
-# Basic non-blocking task:
-reactor = Fiber::Reactor.new
-
-# User could provide their own reactor, it might even do other things, but the basic interface above should continue to work.
-
-Fiber.new(reactor: reactor) do
-	# Blocking operations call Fiber.yield, which goes to...
-end.resume
-
-# ...here, which starts running the reactor which can also be controlled (e.g. duration, stopping)
-reactor.run
-
-# Here is a rough outline of the reactor concept implementation using NIO4R
-# Can be standard implementation, but could also be provided by external gem/library.
-class NIO::Reactor
-	def initialize
-		@selector = NIO::Selector.new
-		@timers = Timers::Group.new
-		
-		@stopped = true
-	end
-	
-	EVENTS = [
-		:r,
-		:w,
-		:rw
-	]
-	
-	def add_io(fiber, io, event)
-		monitor = @selector.register(io, EVENTS[event])
-		monitor.value = fiber
-	end
-	
-	def remove_io(monitor)
-		monitor.cancel
-	end
-	
-	# The reactor will call `fiber.resume(Fiber::TimeoutError)` at some point after duration time has elapsed.
-	# Returns an opaque timer object which can be passed to `cancel_timer` to avoid this happening.
-	def add_timer(fiber, duration)
-		@timers.after(duration, &block)
-	end
-	
-	def cancel_timer(timer)
-		timer.cancel
-	end
-	
-	# Run until idle (no registered io/timers), or duration time has passed if specified.
-	def run(duration = nil)
-		@timers.wait do |interval|
-			# - nil: no timers
-			# - -ve: timers expired already
-			# -   0: timers ready to fire
-			# - +ve: timers waiting to fire
-			interval = 0 if interval && interval < 0
-			
-			# If there is nothing to do, then finish:
-			return if @fibers.empty? && interval.nil?
-			
-			if monitors = @selector.select(interval)
-				monitors.each do |monitor|
-					if fiber = monitor.value
-						fiber.resume
-					end
-				end
-			end
-		end until @stopped
-	end
-	
-	def stop
-		@stopped = true
-		@selector.wakeup
-	end
-	
-	def close
-		@seletor.close
-	end
-end
-