async_enum 0.0.5 → 0.0.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDFhMWYwZjQ0ZWE1Njc1NzJiZGU3ZTEwMDAyMzIzN2M4ZmZhZDM4ZA==
+    OTY4MmYzYjc3ZjgxMDRjNjE5MWM4OGZhYTUzYWQwZmVkMTg4NDc2Mw==
   data.tar.gz: !binary |-
-    ZDAzNTI1ZjczYzU4NjQ0YTNhNTVmMTkzMzdjNzEyMzk4Y2Q4ZjUwMw==
+    YTY3NjJjYmI1ZGE4NzUxMjNmODJjN2YwMDMxOTYwYzM0NzZjOTFiOA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YmQ0MjFmMTU3NGQyMWEzZTQ4MWY5NjM2NGZhMWVhN2Q0OTU4ZGY3ZTBhNDI3
-    NWUyNmQ1YzZlMWVkNjA0YmIwNWE5OTZhNTdhNzg1ZjUxZTdkZDkxZjUzMzM4
-    MDA5NmFhZGU3NzE5MTQyMGMzOTU3N2IzNTUxYzczMzgwMzcwNTE=
+    OWQ1NzEzMDQ4OGRmYmU2NjE0N2IzZjlkYjcyYTVmNGM5YzQ5NzUzYTZiMjIy
+    OThmOGNmZDUxZjdlYjEwOTU2MDlhZWU0YWU1M2ZhNzNkODU2NGU4OTYwNWEw
+    YjA0OGFkMWYyNDYzZGM1NTkwOTNlMTc5ZDg0Zjc2YzJmNzEwZmE=
   data.tar.gz: !binary |-
-    ZjdiNzk0OWI1MGI0YzE1MzE5NjExYzI4OTNjNGYzNmM1YzQ0ZmViODk0NTA0
-    OWMyZWUyNjQwOTY5MzdlYzEzZjc2OThjNWVhZGExYWE1MzI2MmQ4NTM4M2Zj
-    YmZlMmFhMjljNTk1ODVhYWIxZTY2MTIwOWUyNDQ3MmQ1ZjRkZDc=
+    MTVmZjc3M2JhYmEwNTMxMjQzNGY1NWM0Y2UwYWExMmM4NzNjMTQ4NWI4ZDU3
+    NTRkYTI0ZjdkYjhmYjcyYzg0NTE3YTQyOTVmZGZjYTlmMDNlMWNjMzEyMjE3
+    NjM3ZDMxMjhlY2RhNmNmNjMzNTcxOWM3ZmE0OWJhNjNhODY2NGM=

data/README.md

@@ -1,4 +1,4 @@
-# async\_enum
+# async\_enum ![](https://travis-ci.org/aj0strow/async_enum.png)
 
 Inspired by Enumerable#lazy coupled with Enumerator::Lazy, and the Async.js library, I thought it would be cool to have syntax like `urls.async.map{ |url| http_get(url) }`.
 
@@ -83,12 +83,15 @@ end
 
 #### Preventing race conditions
 
-When programming concurrently, nasty bugs can come up because some operations aren't atomic. For instance, incrementing a variable `x += 1` will not necessarily work as expected. To provide easy locking, there's a DSL-style `lock` method you can use in the block passed to the async enum. 
+When programming concurrently, nasty bugs can come up because some operations aren't atomic. For instance, incrementing a variable `x += 1` will not necessarily work as expected. Use a lock when encountering these types of errors. 
 
 ```ruby
+require 'async_enum'
+
 count = 0
+mutex = Mutex.new
 ('a'..'z').async.each do
-  lock :count do
+  mutex.synchronize do
     count += 1
   end
 end
@@ -96,7 +99,7 @@ count
 # => 26
 ```
 
-The name of the lock doesn't matter, but using the variable name helps make the code understandable. You should try to use 1 lock per thread-unsafe variable.
+There used to be a lock DSL syntax, but it ruined using async_enum in scoped method calls. 
 
 ## Notes
 
@@ -116,6 +119,12 @@ $ cd async_enum
 $ ruby -I lib demos/sleep.rb 
 ```
 
-**Disclaimer**: I am not an expert at multithreading. Quite the opposite in fact.
+#### Contributions
+
+* Yoshida Tetsuya ([@yoshida-eth0](https://github.com/yoshida-eth0)) fixed the fiber error issue, and made the gem work with hashes.
 
 Please report errors and feel free to contribute and improve things!
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/aj0strow/async_enum/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/async_enum.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name        = 'async_enum'
-  s.version     = '0.0.5'
+  s.version     = '0.0.6'
   s.authors     = %w(aj0strow)
   s.email       = 'alexander.ostrow@gmail.com'
   s.description = 'iterate over enumerable objects concurrently'

data/demos/lock.rb

@@ -1,8 +1,9 @@
 require 'async_enum'
 
 count = 0
+mutex = Mutex.new
 ('a'..'z').async.each do
-  lock :count do
+  mutex.synchronize do
     count += 1
   end
 end

data/demos/pool_size.rb

@@ -2,7 +2,7 @@ require 'benchmark'
 require 'async_enum'
 
 default = Benchmark.measure do
-	500.times.async.each{ true }
+  500.times.async.each{ true }
 end
 
 limited = Benchmark.measure do

data/demos/sleep.rb

@@ -2,7 +2,7 @@ require 'benchmark'
 require 'async_enum'
 
 sync = Benchmark.measure do
-	5.times{ sleep 0.1 }
+  5.times{ sleep 0.1 }
 end
 
 async = Benchmark.measure do

data/lib/enumerator/async.rb

@@ -3,35 +3,17 @@ require 'thread'
 class Enumerator
   class Async < Enumerator
     
-    class Lockset
-      def initialize
-        @semaphores = Hash.new do |locks, key| 
-          locks[key] = Mutex.new 
-        end
-      end
-      
-      def lock(key = :__default__, &thread_unsafe_block)
-        @semaphores[key].synchronize(&thread_unsafe_block)
-      end
-      
-      alias_method :evaluate, :instance_exec
-    end
-    
     EOQ = Object.new
     private_constant :EOQ
     
     def initialize(enum, pool_size = nil)
-      if pool_size
-        unless pool_size >= 1
-          message = "Thread pool size is invalid! Expected a positive integer but got: #{pool_size}"
-          raise ArgumentError, message
-        end
-        pool_size = pool_size.to_i
+      pool_size = (pool_size || enum.count).to_i
+      unless pool_size >= 1
+        message = "Thread pool size is invalid! Expected a positive integer but got: #{pool_size}"
+        raise ArgumentError, message
       end
 
-      @enum = enum
-      @pool_size = pool_size
-      @lockset = Lockset.new
+      @enum, @pool_size = enum, pool_size
     end
     
     def to_a
@@ -41,86 +23,59 @@ class Enumerator
     def sync
       @enum
     end
-    
     alias_method :to_enum, :sync
     
     def size
       @enum.size
     end
         
-    def each(&work)
-      raise_error('each') unless block_given?
+    def each
+      raise_error(:each) unless block_given?
       
-      if @pool_size
-        queue = SizedQueue.new @pool_size
-        
-        threads = @pool_size.times.map do
-          Thread.new do
-            loop do
-              item = queue.pop
-              item != EOQ ? evaluate(item, &work) : break
-            end
+      queue = SizedQueue.new @pool_size
+              
+      threads = @pool_size.times.map do
+        Thread.new do
+          loop do
+            item = queue.pop
+            item != EOQ ? yield(item) : break
           end
         end
-        
-        begin
-          loop { queue.push @enum.next }
-        rescue StopIteration
-        ensure
-          @pool_size.times { queue.push EOQ }
-        end
-
-        threads.each(&:join)
-        @enum.rewind
-      else
-        unlimited_threads(&work).each(&:join)
       end
+      
+      begin
+        loop { queue.push @enum.next }
+      rescue StopIteration
+      ensure
+        @pool_size.times { queue.push EOQ }
+      end
+
+      threads.each(&:join)
+      @enum.rewind
       self
     end
     
     def with_index(start = 0, &work)
       @enum = @enum.with_index(start)
-      if block_given?
-        each(&work)
-      else
-        self
-      end
+      block_given? ? each(&work) : self
     end
     
-    def with_object(obj, &work)
-      @enum = @enum.with_object(obj)
-      if block_given?
-        each(&work); obj
-      else
-        self
-      end
+    def with_object(object, &work)
+      @enum = @enum.with_object(object)
+      block_given? ? (each(&work) and object) : self
     end
     
-    def map(&work)
-      raise_error('map') unless block_given?
+    def map
+      raise_error(:map) unless block_given?
       
-      if @pool_size
-        outs = []
+      [].tap do |outs|
         with_index do |item, index|
-          outs[index] = evaluate(item, &work)
+          outs[index] = yield(item)
         end
-        outs
-      else
-        unlimited_threads(&work).map(&:value)
       end
     end
 
     private
-    
-    def evaluate(*args, &work)
-      @lockset.instance_exec(*args, &work)
-    end
-    
-    def unlimited_threads(&work)
-      @enum.map do |*args|
-        Thread.new{ evaluate(*args, &work) }
-      end
-    end
 
     def raise_error(method)
       raise ArgumentError, "Tried to call async #{method} without a block"

data/test/async_enum_test/enumerator_async_test.rb

@@ -87,15 +87,5 @@ class EnumeratorAsyncTest < Test
     strs = @enum.map{ |i| sleep rand; i.to_s }
     assert_equal '1 2 3 4 5', strs.join(' ')
   end
-  
-  test 'lock in block' do
-    count = 0
-    1000.times.async(5).each do
-      lock :count do
-        count += 1
-      end
-    end
-    assert_equal 1000, count
-  end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async_enum
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - aj0strow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2014-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler