atomic 0.0.6 → 0.0.7

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

data/ext/org/jruby/ext/atomic/AtomicReferenceLibrary.java

@@ -1,7 +1,7 @@
 package org.jruby.ext.atomic;
 
 import java.io.IOException;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyModule;
@@ -36,46 +36,48 @@ public class AtomicReferenceLibrary implements Library {
 
     @JRubyClass(name="JRubyReference", parent="Object")
     public static class JRubyReference extends RubyObject {
-        private final AtomicReference<IRubyObject> reference;
+        private volatile IRubyObject reference;
+        private final static AtomicReferenceFieldUpdater<JRubyReference, IRubyObject> UPDATER =
+            AtomicReferenceFieldUpdater.newUpdater(JRubyReference.class, IRubyObject.class, "reference");
 
         public JRubyReference(Ruby runtime, RubyClass klass) {
             super(runtime, klass);
-            reference = new AtomicReference<IRubyObject>(runtime.getNil());
+            reference = runtime.getNil();
         }
 
         @JRubyMethod
         public IRubyObject initialize(ThreadContext context) {
             Ruby runtime = context.getRuntime();
-            reference.set(runtime.getNil());
+            UPDATER.set(this, runtime.getNil());
             return runtime.getNil();
         }
 
         @JRubyMethod
         public IRubyObject initialize(ThreadContext context, IRubyObject value) {
             Ruby runtime = context.getRuntime();
-            reference.set(value);
+            UPDATER.set(this, value);
             return runtime.getNil();
         }
 
         @JRubyMethod(name = {"get", "value"})
         public IRubyObject get() {
-            return reference.get();
+            return UPDATER.get(this);
         }
 
         @JRubyMethod(name = {"set", "value="})
         public IRubyObject set(IRubyObject newValue) {
-            reference.set(newValue);
+            UPDATER.set(this, newValue);
             return newValue;
         }
 
         @JRubyMethod
         public IRubyObject compare_and_set(ThreadContext context, IRubyObject oldValue, IRubyObject newValue) {
-            return context.getRuntime().newBoolean(reference.compareAndSet(oldValue, newValue));
+            return context.getRuntime().newBoolean(UPDATER.compareAndSet(this, oldValue, newValue));
         }
 
         @JRubyMethod
         public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
-            return reference.getAndSet(newValue);
+            return UPDATER.getAndSet(this, newValue);
         }
     }
 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: atomic
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Charles Oliver Nutter
@@ -16,7 +16,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
@@ -34,12 +34,13 @@ 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
 - ext/atomic_reference.c
 - ext/AtomicReferenceService.java
 - ext/extconf.rb
 - ext/org/jruby/ext/atomic/AtomicReferenceLibrary.java
-- 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