Adding benchmark

.yardopts

@@ -3,3 +3,6 @@
 --embed-mixins
 --output-dir ./doc
 --markup markdown
+--use-cache
+-
+examples/actress/quick.out.rb

README.md

@@ -76,7 +76,7 @@ into several general groups:
 * Thread synchronization classes and algorithms including [dataflow](https://github.com/jdantonio/concurrent-ruby/wiki/Dataflow), 
   timeout, condition, countdown latch, dependency counter, and event
 * Java-inspired [thread pools](https://github.com/jdantonio/concurrent-ruby/wiki/Thread%20Pools)
-* New light-weighted [Actor model](http://rubydoc.info/gems/concurrent-ruby/Concurrent/Actress) implementation. 
+* New fast light-weighted [Actor model](http://rubydoc.info/gems/concurrent-ruby/Concurrent/Actress) implementation. 
 * And many more...
 
 ### Semantic Versioning

examples/actress/celluloid_benchmark.rb

@@ -0,0 +1,96 @@
+require 'benchmark'
+require 'concurrent/actress'
+Concurrent::Actress.i_know_it_is_experimental!
+require 'celluloid'
+require 'celluloid/autostart'
+
+logger                          = Logger.new($stderr)
+logger.level                    = Logger::INFO
+Concurrent.configuration.logger = lambda do |level, progname, message = nil, &block|
+  logger.add level, message, progname, &block
+end
+
+scale       = 1
+ADD_TO      = (100 * scale).to_i
+counts_size = (500 * scale).to_i
+adders_size = (500 * scale).to_i
+
+class Counter
+  include Celluloid
+
+  def initialize(adders, i)
+    @adders = adders
+    @i      = i
+  end
+
+  def counting(count, ivar)
+    if count < ADD_TO
+      @adders[(@i+1) % @adders.size].counting count+1, ivar
+    else
+      ivar.set count
+    end
+  end
+end
+
+threads = []
+
+Benchmark.bmbm(10) do |b|
+  [2, adders_size, adders_size*2, adders_size*3].each do |adders_size|
+
+    b.report(format('%5d %4d %s', ADD_TO*counts_size, adders_size, 'actress')) do
+      counts = Array.new(counts_size) { [0, Concurrent::IVar.new] }
+      adders = Array.new(adders_size) do |i|
+        Concurrent::Actress::AdHoc.spawn("adder#{i}") do
+          lambda do |(count, ivar)|
+            if count.nil?
+              terminate!
+            else
+              if count < ADD_TO
+                adders[(i+1) % adders_size].tell [count+1, ivar]
+              else
+                ivar.set count
+              end
+            end
+          end
+        end
+      end
+
+      counts.each_with_index do |count, i|
+        adders[i % adders_size].tell count
+      end
+
+      counts.each do |count, ivar|
+        raise unless ivar.value >= ADD_TO
+      end
+
+      threads << Thread.list.size
+
+      adders.each { |a| a << [nil, nil] }
+    end
+
+    b.report(format('%5d %4d %s', ADD_TO*counts_size, adders_size, 'celluloid')) do
+      counts = []
+      counts_size.times { counts << [0, Concurrent::IVar.new] }
+
+      adders = []
+      adders_size.times do |i|
+        adders << Counter.new(adders, i)
+      end
+
+      counts.each_with_index do |count, i|
+        adders[i % adders_size].counting *count
+      end
+
+      counts.each do |count, ivar|
+        raise unless ivar.value >= ADD_TO
+      end
+
+      threads << Thread.list.size
+
+      adders.each(&:terminate)
+    end
+  end
+end
+
+p threads
+

lib/concurrent/actress.rb

@@ -41,6 +41,68 @@ module Concurrent
   #
   # ### {Context}
   # {include:Actress::Context}
+  #
+  # ## Speed
+  #
+  # Simple benchmark Actress vs Celluloid, the numbers are looking good
+  # but you know how it is with benchmarks. Source code is in
+  # `examples/actress/celluloid_benchmark.rb`. It sends numbers between x actors
+  # and adding 1 until certain limit is reached.
+  #
+  # Benchmark legend:
+  #
+  # - mes.  - number of messages send between the actors
+  # - act.  - number of actors exchanging the messages
+  # - impl. - which gem is used
+  #
+  # ### JRUBY
+  #
+  #     Rehearsal --------------------------------------------------------
+  #     50000    2 actress    24.110000   0.800000  24.910000 (  7.728000)
+  #     50000    2 celluloid  28.510000   4.780000  33.290000 ( 14.782000)
+  #     50000  500 actress    13.700000   0.280000  13.980000 (  4.307000)
+  #     50000  500 celluloid  14.520000  11.740000  26.260000 ( 12.258000)
+  #     50000 1000 actress    10.890000   0.220000  11.110000 (  3.760000)
+  #     50000 1000 celluloid  15.600000  21.690000  37.290000 ( 18.512000)
+  #     50000 1500 actress    10.580000   0.270000  10.850000 (  3.646000)
+  #     50000 1500 celluloid  14.490000  29.790000  44.280000 ( 26.043000)
+  #     --------------------------------------------- total: 201.970000sec
+  #     
+  #      mes. act.      impl.      user     system      total        real
+  #     50000    2 actress     9.820000   0.510000  10.330000 (  5.735000)
+  #     50000    2 celluloid  10.390000   4.030000  14.420000 (  7.494000)
+  #     50000  500 actress     9.880000   0.200000  10.080000 (  3.310000)
+  #     50000  500 celluloid  12.430000  11.310000  23.740000 ( 11.727000)
+  #     50000 1000 actress    10.590000   0.190000  10.780000 (  4.029000)
+  #     50000 1000 celluloid  14.950000  23.260000  38.210000 ( 20.841000)
+  #     50000 1500 actress    10.710000   0.250000  10.960000 (  3.892000)
+  #     50000 1500 celluloid  13.280000  30.030000  43.310000 ( 24.620000) (1)
+  #
+  # ### MRI 2.1.0
+  #
+  #     Rehearsal --------------------------------------------------------
+  #     50000    2 actress     4.640000   0.080000   4.720000 (  4.852390)
+  #     50000    2 celluloid   6.110000   2.300000   8.410000 (  7.898069)
+  #     50000  500 actress     6.260000   2.210000   8.470000 (  7.400573)
+  #     50000  500 celluloid  10.250000   4.930000  15.180000 ( 14.174329)
+  #     50000 1000 actress     6.300000   1.860000   8.160000 (  7.303162)
+  #     50000 1000 celluloid  12.300000   7.090000  19.390000 ( 17.962621)
+  #     50000 1500 actress     7.410000   2.610000  10.020000 (  8.887396)
+  #     50000 1500 celluloid  14.850000  10.690000  25.540000 ( 24.489796)
+  #     ---------------------------------------------- total: 99.890000sec
+  #     
+  #      mes. act.      impl.      user     system      total        real
+  #     50000    2 actress     4.190000   0.070000   4.260000 (  4.306386)
+  #     50000    2 celluloid   6.490000   2.210000   8.700000 (  8.280051)
+  #     50000  500 actress     7.060000   2.520000   9.580000 (  8.518707)
+  #     50000  500 celluloid  10.550000   4.980000  15.530000 ( 14.699962)
+  #     50000 1000 actress     6.440000   1.870000   8.310000 (  7.571059)
+  #     50000 1000 celluloid  12.340000   7.510000  19.850000 ( 18.793591)
+  #     50000 1500 actress     6.720000   2.160000   8.880000 (  7.929630)
+  #     50000 1500 celluloid  14.140000  10.130000  24.270000 ( 22.775288) (1)
+  #
+  # *Note (1):* Celluloid is using thread per actor so this bench is creating about 1500
+  # native threads.
   module Actress
 
     require 'concurrent/actress/type_check'