async-io 1.12.3 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c10de5ece88f5f8366c2560647ab2cc061c12d49790cf1f3aafb6516d0fd7ad4
-  data.tar.gz: c970a916f8e637098bf85a842d27709cb34dae68ded5386451be3f433673d12e
+  metadata.gz: 71c04e110e0ca7bf28d0066c8ea5d9efc5286a61533a8d713a0b27ce2721af57
+  data.tar.gz: 675aa3d7916f0da52fffb46d2d36879501b060bb4e362a3d4bdbd12a9b196044
 SHA512:
-  metadata.gz: ab731c4a8ec3e2f9a3b459e62391a5294b2234ca0a62cf066f435ba33324f174f60676660924cba2ef25c8fae00fb85bb2b4556c4c96cecdbdd1bd7e9c798f35
-  data.tar.gz: 12c30f60cc9e1859664a79d9d6378c690d0756234410699ae79d5fbd837f014ccc10811ff4feb7ec38cda025fe300cac95051aaff5015808ec595a7107c2d426
+  metadata.gz: ca06ea7ac6ccc5d9f957789dee7f6d5ba4d87a727123ae9b57d676ab1d921658e1657cb10362adcba2fd749249d8be419369b49213e17af329acc6aaecbd2d3a
+  data.tar.gz: 59bc63d72e63db1f555d5753f3f3d7c497749a619b0acc1e42c32e926ffc4125409571d9f3cad249f2f69a34cdaf3bdf8366efc94b2f0084e479a8fd5b2797a6

data/async-io.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 	spec.has_rdoc      = "yard"
 
 	spec.add_dependency "async", "~> 1.3"
-	spec.add_development_dependency "async-rspec", "~> 1.7"
+	spec.add_development_dependency "async-rspec", "~> 1.10"
 
 	spec.required_ruby_version = '~> 2.3'
 

data/examples/allocations/byteslice.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require_relative 'memory'
+
+string = nil
+
+measure_memory("Initial allocation") do
+	string = "a" * 5*1024*1024
+	string.freeze
+end # => 5.0 MB
+
+measure_memory("Byteslice from start to middle") do
+	# Why does this need to allocate memory? Surely it can share the original allocation?
+	x = string.byteslice(0, string.bytesize / 2)
+end # => 2.5 MB
+
+measure_memory("Byteslice from middle to end") do
+	string.byteslice(string.bytesize / 2, string.bytesize)
+end # => 0.0 MB
+
+measure_memory("Slice! from start to middle") do
+	string.dup.slice!(0, string.bytesize / 2)
+end # => 7.5 MB
+
+measure_memory("Byte slice into two halves") do
+	head = string.byteslice(0, string.bytesize / 2) # 2.5 MB
+	remainder = string.byteslice(string.bytesize / 2, string.bytesize) # Shared
+end # 2.5 MB

data/examples/allocations/memory.rb

@@ -0,0 +1,15 @@
+
+def measure_memory(annotation = "Memory allocated")
+	GC.disable
+	
+	start_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
+
+	yield
+	
+ensure
+	end_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
+	memory_usage = (end_memory - start_memory).to_f / 1024
+	
+	puts "#{memory_usage.round(1)} MB: #{annotation}"
+	GC.enable
+end

data/examples/allocations/read_chunks.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require_relative 'memory'
+
+require_relative "../../lib/async/io/stream"
+require "stringio"
+
+measure_memory("Stream setup") do
+	@io = StringIO.new("a" * (50*1024*1024))
+	@stream = Async::IO::Stream.new(@io)
+end # 50.0 MB
+
+measure_memory("Read all chunks") do
+	while chunk = @stream.read_partial
+		chunk.clear
+	end
+end # 0.5 MB

data/lib/async/io/binary_string.rb

@@ -18,22 +18,11 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'buffer'
+
 module Async
 	module IO
-		class BinaryString < String
-			def initialize(*args)
-				super
-				
-				force_encoding(Encoding::BINARY)
-			end
-			
-			def << string
-				super
-				
-				force_encoding(Encoding::BINARY)
-			end
-			
-			alias concat <<
-		end
+		# This is deprecated.
+		BinaryString = Buffer
 	end
 end

data/lib/async/io/buffer.rb

@@ -0,0 +1,39 @@
+# Copyright, 2018, 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.
+
+module Async
+	module IO
+		class Buffer < String
+			def initialize
+				super
+				
+				force_encoding(Encoding::BINARY)
+			end
+			
+			def << string
+				super
+				
+				force_encoding(Encoding::BINARY)
+			end
+			
+			alias concat <<
+		end
+	end
+end

data/lib/async/io/stream.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'binary_string'
+require_relative 'buffer'
 require_relative 'generic'
 
 module Async
@@ -37,11 +37,11 @@ module Async
 				
 				@block_size = block_size
 				
-				@read_buffer = BinaryString.new
-				@write_buffer = BinaryString.new
+				@read_buffer = Buffer.new
+				@write_buffer = Buffer.new
 				
 				# Used as destination buffer for underlying reads.
-				@input_buffer = BinaryString.new
+				@input_buffer = Buffer.new
 			end
 			
 			attr :io
@@ -52,9 +52,17 @@ module Async
 				return '' if size == 0
 				
 				if size
-					fill_read_buffer until @eof or @read_buffer.size >= size
+					until @eof or @read_buffer.size >= size
+						# Compute the amount of data we need to read from the underlying stream:
+						read_size = size - @read_buffer.bytesize
+						
+						# Don't read less than @block_size to avoid lots of small reads:
+						fill_read_buffer(read_size > @block_size ? read_size : @block_size)
+					end
 				else
-					fill_read_buffer until @eof
+					until @eof
+						fill_read_buffer
+					end
 				end
 				
 				return consume_read_buffer(size)
@@ -81,14 +89,15 @@ module Async
 					return unless fill_read_buffer
 				end
 				
-				matched = @read_buffer.slice!(0, index)
-				@read_buffer.slice!(0, pattern.bytesize)
+				@read_buffer.freeze
+				matched = @read_buffer.byteslice(0, index)
+				@read_buffer = @read_buffer.byteslice(index+pattern.bytesize, @read_buffer.bytesize)
 				
 				return matched
 			end
 			
 			def peek
-				until yield(@read_buffer) || @eof
+				until yield(@read_buffer) or @eof
 					fill_read_buffer
 				end
 			end
@@ -182,10 +191,10 @@ module Async
 			private
 			
 			# Fills the buffer from the underlying stream.
-			def fill_read_buffer
-				if @read_buffer.empty? and @io.read(@block_size, @read_buffer)
+			def fill_read_buffer(size = @block_size)
+				if @read_buffer.empty? and @io.read(size, @read_buffer)
 					return true
-				elsif chunk = @io.read(@block_size, @input_buffer)
+				elsif chunk = @io.read(size, @input_buffer)
 					@read_buffer << chunk
 					return true
 				else
@@ -203,13 +212,20 @@ module Async
 				
 				result = nil
 				
-				if size == nil || size >= @read_buffer.size
+				if size.nil? or size >= @read_buffer.size
 					# Consume the entire read buffer:
 					result = @read_buffer
-					@read_buffer = BinaryString.new
+					@read_buffer = Buffer.new
 				else
-					# Consume only part of the read buffer:
-					result = @read_buffer.slice!(0, size)
+					# This approach uses more memory.
+					# result = @read_buffer.slice!(0, size)
+					
+					# We know that we are not going to reuse the original buffer.
+					# But byteslice will generate a hidden copy. So let's freeze it first:
+					@read_buffer.freeze
+					
+					result = @read_buffer.byteslice(0, size)
+					@read_buffer = @read_buffer.byteslice(size, @read_buffer.bytesize)
 				end
 				
 				return result

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.12.3"
+		VERSION = "1.13.0"
 	end
 end

data/spec/addrinfo.rb

@@ -0,0 +1,15 @@
+
+# This is useful for specs, but I hesitate to monkey patch a core class in the library itself.
+class Addrinfo
+	def == other
+		self.to_s == other.to_s
+	end
+	
+	def != other
+		self.to_s != other.to_s
+	end
+	
+	def <=> other
+		self.to_s <=> other.to_s
+	end
+end

data/spec/async/io/stream_spec.rb

@@ -19,12 +19,15 @@
 # THE SOFTWARE.
 
 require 'async/io/stream'
+require 'async/rspec/buffer'
 
 RSpec.describe Async::IO::Stream do
+	include_context Async::RSpec::Buffer
 	include_context Async::RSpec::Memory
+	include_context Async::RSpec::Reactor
 	
-	let(:io) {StringIO.new}
-	let(:stream) {Async::IO::Stream.new(io)}
+	let!(:stream) {Async::IO::Stream.new(buffer)}
+	let(:io) {stream.io}
 	
 	describe '#read' do
 		it "should read everything" do
@@ -51,12 +54,20 @@ RSpec.describe Async::IO::Stream do
 		end
 		
 		context "with large content" do
-			let!(:io) { StringIO.new("a" * 5*1024*1024) }
-			
 			it "allocates expected amount of bytes" do
+				io.write("." * 16*1024)
+				io.seek(0)
+				
+				buffer = nil
+				
 				expect do
-					stream.read(16*1024).clear until stream.eof?
-				end.to limit_allocations(size: 100*1024)
+					# The read buffer is already allocated, and it will be resized to fit the incoming data. It will be swapped with an empty buffer.
+					buffer = stream.read(16*1024)
+				end.to limit_allocations.of(String, count: 1, size: 0)
+				
+				expect(buffer.size).to be == 16*1024
+				
+				io.close
 			end
 		end
 	end
@@ -72,12 +83,10 @@ RSpec.describe Async::IO::Stream do
 		end
 		
 		context "with large content" do
-			let!(:io) { StringIO.new("a" * 5*1024*1024 + "b") }
-			
 			it "allocates expected amount of bytes" do
 				expect do
-					stream.read_until("b").clear
-				end.to limit_allocations(size: 100*1024)
+					stream.read_until("b")
+				end.to limit_allocations.of(String, size: 0, count: 1)
 			end
 		end
 	end
@@ -99,22 +108,38 @@ RSpec.describe Async::IO::Stream do
 	end
 	
 	describe '#read_partial' do
-		it "should avoid calling read" do
-			io.write "Hello World" * 1024
+		before(:each) do
+			io.write "Hello World!" * 1024
 			io.seek(0)
-			
+		end
+		
+		it "should avoid calling read" do
 			expect(io).to receive(:read).and_call_original.once
 			
-			expect(stream.read_partial(11)).to be == "Hello World"
+			expect(stream.read_partial(12)).to be == "Hello World!"
 		end
 		
 		context "with large content" do
-			let!(:io) { StringIO.new("a" * 5*1024*1024) }
+			it "allocates only the amount required" do
+				expect do
+					stream.read(4*1024)
+				end.to limit_allocations.of(String, count: 2, size: 4*1024+1)
+			end
+			
+			it "allocates exact number of bytes being read" do
+				expect do
+					stream.read(16*1024)
+				end.to limit_allocations.of(String, count: 1, size: 0)
+			end
 			
 			it "allocates expected amount of bytes" do
+				buffer = nil
+				
 				expect do
-					stream.read_partial(16*1024).clear until stream.eof?
-				end.to limit_allocations(size: 100*1024)
+					buffer = stream.read_partial
+				end.to limit_allocations.of(String, count: 1)
+				
+				expect(buffer.size).to be == stream.block_size
 			end
 		end
 	end
@@ -126,7 +151,9 @@ RSpec.describe Async::IO::Stream do
 			stream.write "Hello World\n"
 			stream.flush
 			
-			expect(io.string).to be == "Hello World\n"
+			io.seek(0)
+			
+			expect(stream.read).to be == "Hello World\n"
 		end
 	end
 	

data/spec/spec_helper.rb

@@ -19,24 +19,11 @@ end
 require "bundler/setup"
 require "async/io"
 
-# This is useful for specs, but I hesitate to monkey patch a core class in the library itself.
-class Addrinfo
-	def == other
-		self.to_s == other.to_s
-	end
-	
-	def != other
-		self.to_s != other.to_s
-	end
-	
-	def <=> other
-		self.to_s <=> other.to_s
-	end
-end
-
 # Shared rspec helpers:
 require "async/rspec"
 
+require_relative 'addrinfo'
+
 RSpec.configure do |config|
 	# Enable flags like --only-failures and --next-failure
 	config.example_status_persistence_file_path = ".rspec_status"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.12.3
+  version: 1.13.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-07 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +95,9 @@ files:
 - README.md
 - Rakefile
 - async-io.gemspec
-- examples/allocations.rb
+- examples/allocations/byteslice.rb
+- examples/allocations/memory.rb
+- examples/allocations/read_chunks.rb
 - examples/chat/client.rb
 - examples/chat/server.rb
 - examples/issues/broken_ssl.rb
@@ -103,6 +105,7 @@ files:
 - lib/async/io/address.rb
 - lib/async/io/address_endpoint.rb
 - lib/async/io/binary_string.rb
+- lib/async/io/buffer.rb
 - lib/async/io/endpoint.rb
 - lib/async/io/endpoint/each.rb
 - lib/async/io/generic.rb
@@ -121,6 +124,7 @@ files:
 - lib/async/io/udp_socket.rb
 - lib/async/io/unix_socket.rb
 - lib/async/io/version.rb
+- spec/addrinfo.rb
 - spec/async/io/c10k_spec.rb
 - spec/async/io/echo_spec.rb
 - spec/async/io/endpoint_spec.rb
@@ -165,6 +169,7 @@ signing_key:
 specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.
 test_files:
+- spec/addrinfo.rb
 - spec/async/io/c10k_spec.rb
 - spec/async/io/echo_spec.rb
 - spec/async/io/endpoint_spec.rb

data/examples/allocations.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative "../lib/async/io/stream"
-# require "async/io/stream"
-require "stringio"
-
-io = StringIO.new("a" * (50*1024*1024))
-stream = Async::IO::Stream.new(io)
-
-GC.disable
-
-start_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
-
-while (chunk = stream.read_partial)
-	chunk.clear
-end
-
-end_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
-puts "#{(end_memory - start_memory).to_f / 1024} MB"