atomic 0.0.6-java → 0.0.7-java

data/atomic.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{atomic}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
   s.authors = ["Charles Oliver Nutter", "MenTaLguY"]
   s.date = Time.now.strftime('%Y-%m-%d')
   s.description = "An atomic reference implementation for JRuby and green or GIL-threaded impls"

data/examples/bench_atomic_1.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'optparse'
+require 'thread'
+require 'benchmark'
+
+require 'atomic'
+
+Thread.abort_on_exception = true
+
+$conf = {
+  :lock => "atomic",
+  :num_threads => 100,
+  :count => 100_000,
+  :count_per_thread => nil,
+  :slow => nil,
+}
+
+OptionParser.new do |opts|
+  opts.on("-c", "--count NUM") do |n|
+    $conf[:count] = n.to_i
+  end
+  opts.on("-p", "--count-per-thread") do |n|
+    $conf[:count_per_thread] = n.to_i
+  end
+  opts.on("-t", "--num-threads NUM") do |n|
+    $conf[:num_threads] = n.to_i
+  end
+  opts.on("-s", "--slow NUM") do |n|
+    $conf[:slow] = n.to_i
+  end
+  opts.on("-l", "--lock atomic|mutex") do |x|
+    $conf[:lock] = x
+  end
+  opts.on("-h", "--help"){ puts opts; exit }
+end.parse!(ARGV)
+
+unless $conf[:count_per_thread]
+  $conf[:count_per_thread] = $conf[:count] / $conf[:num_threads]
+end
+$conf.delete(:count)
+
+if $conf[:slow].to_i > 0
+  require 'digest/md5'
+  def slow_down
+    $conf[:slow].times do |i|
+      Digest::MD5.hexdigest(i.to_s)
+    end
+  end
+
+  ret = []
+  10.times do
+    m = Benchmark.measure{ slow_down }
+    ret << m.real
+  end
+
+  $conf[:slow_time] = [ret.min, ret.max]
+else
+  def slow_down; end
+end
+
+$stderr.puts $conf.inspect
+
+def para_prepare(&block)
+  num_threads = $conf[:num_threads]
+  count = $conf[:count_per_thread]
+
+  if num_threads % 2 > 0
+    raise ArgumentError, "num_threads must be a multiple of two"
+  end
+
+  # Keep those threads together
+  tg = ThreadGroup.new
+
+  num_threads.times do |i|
+    diff = (i % 2 == 0) ? 1 : -1
+
+    t = Thread.new do
+      nil until $go
+      count.times do
+        yield diff
+      end
+    end
+
+    tg.add(t)
+  end
+
+  # Make sure all threads are started
+  while tg.list.find{|t| t.status != "run"}
+    Thread.pass
+  end
+
+  # For good measure
+  GC.start
+
+  $go = false
+
+  tg
+end
+
+
+
+$tg = nil
+if $conf[:lock] == "atomic"
+  $atom = Atomic.new(0)
+  $tg = para_prepare do |diff|
+    $atom.update do |x|
+      slow_down
+      x + diff
+    end
+  end
+else
+  $lock = Mutex.new
+  $value = 0
+  $tg = para_prepare do |diff|
+    $lock.synchronize do
+      slow_down
+      $value += diff
+    end
+  end
+end
+
+
+# Run !
+#
+# NOTE: It seems to me that this measurement method
+#       is sensible to how the system dispatches his resources.
+#
+#       More precise caluclation could be done using
+#       getrusage's times
+ret = Benchmark.measure do
+  $go = true
+  $tg.list.each{|t| t.join}
+  $go = false
+end
+puts ret.real

data/examples/graph_atomic_bench.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+conf = {
+  :vary => "threads",
+  :lock => "atomic"
+}
+
+OptionParser.new do |opts|
+  opts.on("-l", "--lock atomic|mutex") do |l|
+    conf[:lock] = l
+  end
+  opts.on("-v", "--vary threads|speed") do |v|
+    conf[:vary] = v
+  end
+  opts.on("-h", "--help"){ puts opts; exit }
+end.parse!(ARGV)
+
+result = File.open("results_#{conf[:lock]}_#{conf[:vary]}.csv", "w")
+
+
+if conf[:vary] == "threads"
+  # Vary the number of concurrent threads that update the value.
+  #
+  # There is a total count of 1mio updates that is distributed
+  # between the number of threads.
+  #
+  # A pair number of threads is used so that even add and odd substract 1.
+  # This avoid creating instances for Bignum since the number should
+  # stay in the Fixnum range.
+  #
+  (1..100).each do |i|
+    i = i * 2
+
+    ret = []
+    10.times do
+      ret << `ruby ./bench_atomic_1.rb -l #{conf[:lock]} -t #{i}`.to_f
+    end
+
+    line = ([i] + ret).join(', ')
+
+    puts line
+    result.puts line
+  end
+elsif conf[:vary] == "speed"
+  # Varies the execution time of the update block
+  # by using long calulation (MD5)
+  #
+  # NOTE: Thread.pass and sleep() are not usable by the atomic
+  #       lock. It needs to run the whole block without hitting
+  #       another atomic update otherwise it has to retry
+  #
+  # The expected result is that the atomic lock's performance
+  # will hit a certain threshold where it will be worse than mutexes.
+  #
+  (1..30).each do |i|
+
+    ret = []
+    10.times do
+      ret << `ruby ./bench_atomic_1.rb -l #{conf[:lock]} -s #{i}`.to_f
+    end
+
+    line = ([i] + ret).join(', ')
+
+    puts line
+    result.puts line
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: atomic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.6
+  version: 0.0.7
 platform: java
 authors: 
   - Charles Oliver Nutter
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-06 00:00:00 Z
+date: 2011-11-28 00:00:00 Z
 dependencies: []
 
 description: An atomic reference implementation for JRuby and green or GIL-threaded impls
@@ -29,8 +29,9 @@ files:
   - lib/atomic_reference.jar
   - examples/atomic_example.rb
   - examples/bench_atomic.rb
+  - examples/bench_atomic_1.rb
+  - examples/graph_atomic_bench.rb
   - test/test_atomic.rb
-  - README.txt
   - atomic.gemspec
   - Rakefile
 homepage: http://github.com/headius/ruby-atomic

data/README.txt

@@ -1,33 +0,0 @@
-atomic: An atomic reference implementation for JRuby and green or GIL-threaded
-Ruby implementations (MRI 1.8/1.9, Rubinius)
-
-== Summary ==
-
-This library provides:
-
-* an Atomic class that guarantees atomic updates to its contained value
-
-The Atomic class provides accessors for the contained "value" plus two update
-methods:
-
-* update will run the provided block, passing the current value and replacing
-  it with the block result iff the value has not been changed in the mean time.
-  It may run the block repeatedly if there are other concurrent updates in
-  progress.
-* try_update will run the provided block, passing the current value and
-  replacing it with the block result. If the value changes before the update
-  can happen, it will throw Atomic::ConcurrentUpdateError.
-
-The atomic repository is at http://github.com/headius/ruby-atomic.
-
-== Usage ==
-
-require 'atomic'
-
-my_atomic = Atomic.new(0)
-my_atomic.update {|v| v + 1}
-begin
-  my_atomic.try_update {|v| v + 1}
-rescue Atomic::ConcurrentUpdateError => cue
-  # deal with it (retry, propagate, etc)
-end