win32-nio 0.0.1

data/CHANGES

@@ -0,0 +1,2 @@
+== 0.0.1 - 28-Nov-2008
+* Initial release

data/MANIFEST

@@ -0,0 +1,9 @@
+* CHANGES
+* MANIFEST
+* Rakefile
+* README
+* win32-nio.gemspec
+* benchmarks/win32_nio_benchmarks.rb
+* lib/win32/nio.rb
+* test/test_win32_nio_read.rb
+* test/test_win32_nio_readlines.rb

data/README

@@ -0,0 +1,70 @@
+= Description
+   Native IO for Windows. This class matches and extends the current Ruby
+   IO class API, using native Windows functions underneath the hood.
+
+= Synopsis
+   require 'win32/nio'
+   include Win32
+   
+   p NIO.read('some_file.text')
+   
+   p NIO.readlines('some_file.txt')
+   
+= Proof of Concept
+   This code is ALPHA!
+   
+   This code is mostly a proof of concept to see how to implement Ruby's
+   IO functions in pure Windows functions. While it does offer a couple of
+   features over and above Ruby's IO interface, such as the ability to supply
+   an event or a block to the NIO.read method, it offers little practical
+   advantage at the moment.
+   
+   In addition, it is currently using pure Ruby (via win32-api), which means
+   it isn't optimized for speed.
+
+= Benchmarks
+
+   Using my HP Windows XP Pro laptop, with a 1.66 core duo Pentium T5500 and
+   2gb of RAM, I saw these results, which were typical in repeated runs:
+                         
+                          user     system      total        real
+   IO.read(small)         0.016000   0.047000   0.063000 (  0.063000)
+   NIO.read(small)        0.109000   0.000000   0.109000 (  0.109000)
+   IO.read(medium)        0.422000   0.094000   0.516000 (  0.532000)
+   NIO.read(medium)       0.937000   0.062000   0.999000 (  1.047000)
+   IO.read(large)         3.282000   1.063000   4.345000 (  4.468000)
+   NIO.read(large)        8.187000   1.062000   9.249000 (  9.454000)
+   IO.readlines(small)    0.156000   0.063000   0.219000 (  0.234000)
+   NIO.readlines(small)   0.141000   0.000000   0.141000 (  0.797000)
+   IO.readlines(medium)   2.984000   0.250000   3.234000 (  3.625000)
+   NIO.readlines(medium)  1.172000   0.062000   1.234000 (  3.406000)
+   IO.readlines(large)    18.625000   2.281000  20.906000 ( 21.532000)
+   NIO.readlines(large)   12.406000   0.563000  12.969000 (122.643000)
+   
+   Note that, in most cases, the user and system time has decreased, but
+   the real time has increased.
+   
+= Known Bugs
+   None that I know of. Please log any other bug reports on the RubyForge
+   project page at http://www.rubyforge.net/projects/win32utils
+
+= Future Plans
+   The pure Ruby code is really only meant for prototyping. The eventual
+   plan is to convert the Ruby code to equivalent C code in order to improve
+   performance.
+
+= License
+   Ruby's
+    
+= Copyright
+   (C) 2008 Daniel J. Berger, All Rights Reserved
+    
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= Author(s)
+   Daniel Berger
+   Park Heesob
+   

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+desc 'Install the win32-nio library (non-gem)'
+task :install do
+   sitelibdir = CONFIG['sitelibdir']
+   installdir = File.join(sitelibdir, 'win32')
+   file = 'lib\win32\nio.rb'
+
+   Dir.mkdir(installdir) unless File.exists?(installdir)
+   FileUtils.cp(file, installdir, :verbose => true)
+end
+
+desc 'Run the benchmark suite'
+task :bench do
+   sh "ruby -Ilib benchmarks/win32_nio_benchmarks.rb"
+
+Rake::TestTask.new do |t|
+   t.verbose = true
+   t.warning = true
+end

data/benchmarks/win32_nio_benchmarks.rb

@@ -0,0 +1,113 @@
+########################################################################
+# win32_nio_benchmarks.rb
+#
+# Run this via the 'rake bench' task to compare win32-nio with Ruby's
+# own IO methods. This benchmark will take a bit of time, since it
+# generates some test files on the fly.
+########################################################################
+require 'benchmark'
+require 'win32/nio'
+include Win32
+
+MAX = (ARGV[0] || '10').chomp.to_i # Default to 10 iterations
+PHRASE = "The quick brown fox jumped over the lazy dog's back"
+
+SMALL_FILE  = "small_nio_test.txt"  # 588k
+MEDIUM_FILE = "medium_nio_test.txt" # 6mb
+LARGE_FILE  = "large_nio_test.txt"  # 60mb
+HUGE_FILE   = "huge_nio_test.txt"   # 618mb
+
+unless File.exists?(SMALL_FILE)
+   File.open(SMALL_FILE, 'w'){ |fh|
+      10000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Small file created"
+end
+
+unless File.exists?(MEDIUM_FILE)
+   File.open(MEDIUM_FILE, 'w'){ |fh|
+      110000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Medium file created"
+end
+
+unless File.exists?(LARGE_FILE)
+   File.open(LARGE_FILE, 'w'){ |fh|
+      1000000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Large file created"
+end
+
+unless File.exists?(HUGE_FILE)
+   #File.open(HUGE_FILE, 'w'){ |fh|
+   #   10000000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   #}
+
+   #puts "Huge file created"
+end
+
+Benchmark.bm(20) do |x|
+   x.report('IO.read(small)'){
+      MAX.times{ IO.read(SMALL_FILE) }
+   }
+
+   x.report('NIO.read(small)'){
+      MAX.times{ NIO.read(SMALL_FILE) }
+   }
+
+   x.report('IO.read(medium)'){
+      MAX.times{ IO.read(MEDIUM_FILE) }
+   }
+
+   x.report('NIO.read(medium)'){
+      MAX.times{ NIO.read(MEDIUM_FILE) }
+   }
+
+   x.report('IO.read(large)'){
+      MAX.times{ IO.read(LARGE_FILE) }
+   }
+
+   x.report('NIO.read(large)'){
+      MAX.times{ NIO.read(LARGE_FILE) }
+   }
+
+   #x.report('IO.read(huge)'){
+   #   MAX.times{ IO.read(HUGE_FILE) }
+   #}
+
+   #x.report('NIO.read(huge)'){
+   #   MAX.times{ NIO.read(HUGE_FILE) }
+   #}
+
+   x.report('IO.readlines(small)'){
+      MAX.times{ IO.readlines(SMALL_FILE) }
+   }
+
+   x.report('NIO.readlines(small)'){
+      MAX.times{ NIO.readlines(SMALL_FILE) }
+   }
+   
+   x.report('IO.readlines(medium)'){
+      MAX.times{ IO.readlines(MEDIUM_FILE) }
+   }
+
+   x.report('NIO.readlines(medium)'){
+      MAX.times{ NIO.readlines(MEDIUM_FILE) }
+   }
+   
+   x.report('IO.readlines(large)'){
+      MAX.times{ IO.readlines(LARGE_FILE) }
+   }
+
+   x.report('NIO.readlines(large)'){
+      MAX.times{ NIO.readlines(LARGE_FILE) }
+   }
+end
+
+File.delete(SMALL_FILE) if File.exists?(SMALL_FILE)
+File.delete(MEDIUM_FILE) if File.exists?(MEDIUM_FILE)
+File.delete(LARGE_FILE) if File.exists?(LARGE_FILE)
+File.delete(HUGE_FILE) if File.exists?(HUGE_FILE)

data/lib/win32/nio.rb

@@ -0,0 +1,215 @@
+require 'windows/file'
+require 'windows/handle'
+require 'windows/error'
+require 'windows/memory'
+require 'windows/nio'
+require 'windows/synchronize'
+require 'windows/system_info'
+require 'windows/thread'
+require 'windows/msvcrt/io'
+require 'windows/msvcrt/buffer'
+require 'win32/event'
+
+module Win32
+   class NIO
+      include Windows::File
+      include Windows::Handle
+      include Windows::Error
+      include Windows::Synchronize
+      include Windows::MSVCRT::IO
+      include Windows::MSVCRT::Buffer
+      include Windows::SystemInfo
+      include Windows::Memory      
+      include Windows::NIO
+      include Windows::Thread
+
+      extend Windows::File
+      extend Windows::Handle
+      extend Windows::Error
+      extend Windows::Synchronize
+      extend Windows::MSVCRT::IO
+      extend Windows::MSVCRT::Buffer
+      extend Windows::SystemInfo
+      extend Windows::Memory      
+      extend Windows::NIO
+      extend Windows::Thread
+      
+      # The version of this library
+      VERSION = '0.0.1'
+
+      # Error typically raised if any of the native functions fail.
+      class Error < StandardError; end
+
+      # This method is similar to Ruby's IO.read method except that, in
+      # addition to using native function calls, accepts an optional +event+
+      # argument for the fourth argument, which must be an instance of
+      # Win32::Event (if provided). The event is automatically set to a
+      # signaled state when the read operation completes.
+      #   
+      # If a block is provided, then it is treated as a callback that fires
+      # when the read operation is complete.
+      #
+      def self.read(port_name, length=nil, offset=0, event=nil, &block)
+         if length
+            raise TypeError unless length.is_a?(Fixnum)
+            raise ArgumentError if length < 0
+         end
+
+         if offset
+            raise TypeError unless offset.is_a?(Fixnum)
+            raise ArgumentError if offset < 0
+         end
+
+         if event
+            raise TypeError unless event.is_a?(Win32::Event)
+         end
+
+         flags = FILE_FLAG_SEQUENTIAL_SCAN 
+
+         overlapped = 0.chr * 20  # sizeof(OVERLAPPED)
+         overlapped[8,4] = [offset].pack('L') # OVERLAPPED.Offset
+
+         if offset > 0 || event
+            flags |= FILE_FLAG_OVERLAPPED
+            overlapped[16,4] = [event.handle].pack('L') if event
+         end
+
+         handle = CreateFile(
+            port_name,
+            FILE_READ_DATA,
+            FILE_SHARE_READ,
+            0,
+            OPEN_EXISTING,
+            flags,
+            0
+         )
+
+         if handle == INVALID_HANDLE_VALUE
+            raise Error, get_last_error
+         end
+         
+         # Ruby's File.size is broken, so we implement it here. Also, if an
+         # offset is provided, we can reduce the size to only what we need.
+         if length.nil?
+            size = [0].pack('Q')
+            GetFileSizeEx(handle, size)
+            length = size.unpack('Q').first
+            length -= offset if offset
+         end
+
+         buf = 0.chr * length
+
+         begin
+            if block_given?
+               callback = Win32::API::Callback.new('LLP', 'V'){ block.call }
+               bool = ReadFileEx(handle, buf, length, overlapped, callback)
+            else
+               bytes = [0].pack('L')
+               bool = ReadFile(handle, buf, length, bytes, overlapped)
+            end
+            
+            errno = GetLastError()
+
+            SleepEx(1, true) # Must be in alertable wait state
+         
+            unless bool
+               if errno = ERROR_IO_PENDING
+                  unless GetOverlappedResult(handle, overlapped, bytes, true)
+                     raise Error, get_last_error
+                  end
+               else
+                  raise Error, errno
+               end
+            end
+            
+            event.wait if event
+         ensure
+            CloseHandle(handle)
+         end
+         
+         buf[0, length]
+      end
+
+      # Reads the entire file specified by portname as individual lines, and
+      # returns those lines in an array. Lines are separated by +sep+.
+      #--
+      # The semantics are the same as the MRI version but the implementation
+      # is drastically different. We use a scattered IO read.
+      #
+      def self.readlines(file, sep = "\r\n")
+         handle = CreateFile(
+            file,
+            GENERIC_READ,
+            FILE_SHARE_READ,
+            nil,
+            OPEN_EXISTING,
+            FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
+            nil
+         )
+         
+         if handle == INVALID_HANDLE_VALUE
+            raise Error, get_last_error
+         end
+         
+         sysbuf = 0.chr * 40
+         GetSystemInfo(sysbuf)
+
+         file_size = [0].pack('Q')
+         GetFileSizeEx(handle, file_size)
+         file_size = file_size.unpack('Q')[0]
+
+         page_size = sysbuf[4,4].unpack('L')[0] # dwPageSize
+         page_num  = (file_size.to_f / page_size).ceil
+         
+         begin
+            base_address = VirtualAlloc(
+               nil,
+               page_size * page_num,
+               MEM_COMMIT,
+               PAGE_READWRITE
+            )
+               
+            buf_list = []
+            
+            for i in 0...page_num
+               buf_list.push(base_address + page_size * i)
+            end
+                  
+            seg_array  = buf_list.pack('Q*') + 0.chr * 8
+            overlapped = 0.chr * 20
+                  
+            bool = ReadFileScatter(
+               handle,
+               seg_array,
+               page_size * page_num, 
+               nil,
+               overlapped
+            )
+
+            unless bool
+               error = GetLastError()
+               if error != ERROR_IO_PENDING
+                  raise Error, get_last_error(error)
+               end
+            end
+
+            SleepEx(1, true) unless HasOverlappedIoCompleted(overlapped)
+
+            buffer = 0.chr * file_size
+            memcpy(buffer, buf_list[0], file_size)
+         ensure
+            CloseHandle(handle)
+            VirtualFree(base_address, 0, MEM_RELEASE)
+         end
+
+         if sep == ""
+            buffer = buffer.split(/(\r\n){2,}/)
+            buffer.delete("\r\n")
+         else
+            buffer = buffer.split(sep)
+         end
+
+         buffer
+      end
+   end
+end

data/test/test_win32_nio_read.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+gem 'test-unit'
+
+require 'win32/nio'
+require 'test/unit'
+include Win32
+
+class TC_Win32_NIO_Read < Test::Unit::TestCase
+   def self.startup
+      @@file = 'read_test.txt'
+      @@text = "The quick brown fox jumped over the lazy dog's back"
+      
+      File.open(@@file, 'w'){ |fh|
+         100.times{ |n|
+            fh.puts @@text + ": #{n}"
+         }
+      }
+   end
+
+   def setup
+      @size  = File.size(@@file)
+      @event = Win32::Event.new('test')
+   end
+   
+   def test_nio_version
+      assert_equal('0.0.1', Win32::NIO::VERSION)      
+   end
+
+   def test_nio_read_basic
+      assert_respond_to(NIO, :read)
+   end
+
+   def test_nio_read_with_file_name
+      assert_nothing_raised{ NIO.read(@@file) }
+      assert_kind_of(String, NIO.read(@@file))
+      assert_true(NIO.read(@@file).size == @size)
+   end
+
+   def test_nio_read_with_file_name_and_length
+      assert_nothing_raised{ NIO.read(@@file, 19) }
+      assert_equal('The quick brown fox', NIO.read(@@file, 19))
+      assert_equal('', NIO.read(@@file, 0))
+   end
+
+   def test_nio_read_with_file_name_and_length_and_offset
+      assert_nothing_raised{ NIO.read(@@file, 19, 4) }
+      assert_equal('quick brown fox', NIO.read(@@file, 15, 4))
+      assert_equal("lazy dog's back: 99\r\n", NIO.read(@@file, nil, @size-21))
+   end
+   
+   def test_nio_read_with_event
+      assert_false(@event.signaled?)
+      assert_nothing_raised{ NIO.read(@@file, 9, 0, @event) }
+      assert_true(@event.signaled?)
+   end
+
+   def test_nio_read_expected_errors
+      assert_raise(ArgumentError){ NIO.read }
+      assert_raise(ArgumentError){ NIO.read(@@file, -1) }
+      assert_raise(TypeError){ NIO.read(@@file, 'foo') }
+      assert_raise(ArgumentError){ NIO.read(@@file, 1, -1) }
+      assert_raise(TypeError){ NIO.read(@@file, 1, 'foo') }
+      assert_raise(TypeError){ NIO.read(@@file, 1, 1, 'foo') }
+   end
+   
+   def test_readlines_basic
+      assert_respond_to(NIO, :readlines)
+      assert_nothing_raised{ NIO.readlines(@@file) }
+      assert_kind_of(Array, NIO.readlines(@@file))   
+   end
+   
+   def test_readlines
+      assert_equal("#{@@text}: 0", NIO.readlines(@@file).first)
+      assert_equal("#{@@text}: 99", NIO.readlines(@@file).last)    
+   end
+
+   def teardown
+      @size = nil
+      @event.close if @event
+      @event = nil
+   end
+
+   def self.teardown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file = nil
+      @@text = nil
+   end
+end

data/test/test_win32_nio_readlines.rb

@@ -0,0 +1,61 @@
+#######################################################################
+# test_win32_nio_readlines.rb
+#
+# Test case for the Win32::NIO.readlines method.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+require 'win32/nio'
+include Win32
+
+class TC_Win32_NIO_Readlines < Test::Unit::TestCase
+   def self.startup
+      @@line = "The quick brown fox jumped over the lazy dog's back"
+      @@file = "readlines_test.txt"
+      @@size = 10
+      File.open(@@file, 'w'){ |fh|
+         1.upto(@@size){ |n|
+            fh.puts @@line + ": #{n}"
+            fh.puts if n % 3 == 0
+         }
+      }
+   end
+
+   def setup
+      @array = nil
+   end
+
+   def test_nio_readlines_basic
+      assert_respond_to(NIO, :readlines)
+   end
+
+   def test_nio_readlines
+      assert_nothing_raised{ NIO.readlines(@@file) }
+      assert_kind_of(Array, NIO.readlines(@@file))
+      assert_equal(@@size + 3, NIO.readlines(@@file).size)
+      assert_equal(@@line + ': 1', NIO.readlines(@@file).first)
+   end
+
+   def test_nio_readlines_with_empty_line_ending
+      assert_nothing_raised{ NIO.readlines(@@file, '') }
+      assert_kind_of(Array, NIO.readlines(@@file, ''))
+      assert_equal(4, NIO.readlines(@@file, '').size)
+   end
+
+   def test_nio_readlines_expected_errors
+      assert_raise(ArgumentError){ NIO.readlines }
+      assert_raise(ArgumentError){ NIO.readlines(@@file, '', true) }
+   end
+
+   def teardown
+      @array = nil
+   end
+
+   def self.shutdown
+      File.delete(@@file) if File.exists?(@@file)
+      @@file = nil
+      @@size = nil
+      @@line = nil
+   end
+end

data/win32-nio.gemspec

@@ -0,0 +1,23 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "win32-nio"
+   gem.version     = "0.0.1"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "Native IO for MS Windows"
+   gem.description = "Native IO for MS Windows"
+   gem.has_rdoc    = true
+   gem.files       = Dir["lib/win32/*.rb"] + Dir["test/*"] + Dir["[A-Z]*"] + Dir["benchmarks/*.rb"]
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["README", "CHANGES", "MANIFEST"]
+   gem.rubyforge_project = "Win32Utils"
+   gem.add_dependency("windows-pr", ">= 0.9.5")
+end
+
+if $0 == __FILE__
+   Gem::Builder.new(spec).build
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: win32-nio
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.5
+    version: 
+description: Native IO for MS Windows
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+files: 
+- lib/win32/nio.rb
+- test/test_win32_nio_read.rb
+- test/test_win32_nio_readlines.rb
+- benchmarks
+- CHANGES
+- lib
+- MANIFEST
+- Rakefile
+- README
+- test
+- win32-nio.gemspec
+- benchmarks/win32_nio_benchmarks.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/win32utils
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: Win32Utils
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Native IO for MS Windows
+test_files: []
+