Added simple benchmarks for Atomic, AtomicBoolean, and AtomicFixnum.

Author: jdantonio

examples/benchmark_atomic_boolean.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$:.push File.join(File.dirname(__FILE__), '../lib')
+
+require 'concurrent'
+require 'benchmark'
+require 'rbconfig'
+
+def atomic_test(clazz, opts = {})
+  threads = opts.fetch(:threads, 5)
+  tests = opts.fetch(:tests, 100)
+
+  atomic = clazz.new
+  latch = Concurrent::CountDownLatch.new(threads)
+
+  print "Testing with #{clazz}...\n"
+  stats = Benchmark.measure do
+    threads.times do |i|
+      Thread.new do
+        tests.times{ atomic.value = true }
+        latch.count_down
+      end
+    end
+    latch.wait
+  end
+  print stats
+end
+
+puts "Testing with #{RbConfig::CONFIG['ruby_install_name']} #{RUBY_VERSION}"
+
+atomic_test(Concurrent::MutexAtomicBoolean, threads: 10, tests: 1_000_000)
+
+if defined? Concurrent::CAtomicBoolean
+  atomic_test(Concurrent::CAtomicBoolean, threads: 10, tests: 1_000_000)
+elsif RUBY_PLATFORM == 'java'
+  atomic_test(Concurrent::JavaAtomicBoolean, threads: 10, tests: 1_000_000)
+end

examples/benchmark_atomic_fixnum.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$:.push File.join(File.dirname(__FILE__), '../lib')
+
+require 'concurrent'
+require 'benchmark'
+require 'rbconfig'
+
+def atomic_test(clazz, opts = {})
+  threads = opts.fetch(:threads, 5)
+  tests = opts.fetch(:tests, 100)
+
+  num = clazz.new
+  latch = Concurrent::CountDownLatch.new(threads)
+
+  print "Testing with #{clazz}...\n"
+  stats = Benchmark.measure do
+    threads.times do |i|
+      Thread.new do
+        tests.times{ num.up }
+        latch.count_down
+      end
+    end
+    latch.wait
+  end
+  print stats
+end
+
+puts "Testing with #{RbConfig::CONFIG['ruby_install_name']} #{RUBY_VERSION}"
+
+atomic_test(Concurrent::MutexAtomicFixnum, threads: 10, tests: 1_000_000)
+
+if defined? Concurrent::CAtomicFixnum
+  atomic_test(Concurrent::CAtomicFixnum, threads: 10, tests: 1_000_000)
+elsif RUBY_PLATFORM == 'java'
+  atomic_test(Concurrent::JavaAtomicFixnum, threads: 10, tests: 1_000_000)
+end

lib/concurrent/atomic.rb

@@ -20,6 +20,38 @@
   #
   #   An object reference that may be updated atomically.
   #
+  #       Testing with ruby 2.1.2
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.000000   0.000000   0.000000 (  0.005502)
+  #       mutex        0.030000   0.000000   0.030000 (  0.025158)
+  #       MutexAtomic  0.100000   0.000000   0.100000 (  0.103096)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.034012)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.010000   0.000000   0.010000 (  0.009387)
+  #       mutex        0.030000   0.010000   0.040000 (  0.032545)
+  #       MutexAtomic  0.830000   2.280000   3.110000 (  2.146622)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.038332)
+  #
+  #       Testing with jruby 1.9.3
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.170000   0.000000   0.170000 (  0.051000)
+  #       mutex        0.370000   0.010000   0.380000 (  0.121000)
+  #       MutexAtomic  1.530000   0.020000   1.550000 (  0.471000)
+  #       JavaAtomic   0.370000   0.010000   0.380000 (  0.112000)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.390000   0.000000   0.390000 (  0.105000)
+  #       mutex        0.480000   0.040000   0.520000 (  0.145000)
+  #       MutexAtomic  1.600000   0.180000   1.780000 (  0.511000)
+  #       JavaAtomic   0.460000   0.010000   0.470000 (  0.131000)
+  #
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
   class Concurrent::Atomic < Concurrent::JavaAtomic

lib/concurrent/atomic/atomic_boolean.rb

@@ -6,6 +6,18 @@ module Concurrent
   #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
   #   briefly but no explicit locking is required.
   #
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         2.790000   0.000000   2.790000 (  2.791454)
+  #       Testing with Concurrent::CAtomicBoolean...
+  #         0.740000   0.000000   0.740000 (  0.740206)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         5.240000   2.520000   7.760000 (  3.683000)
+  #       Testing with Concurrent::JavaAtomicBoolean...
+  #         3.340000   0.010000   3.350000 (  0.855000)
+  #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
   class MutexAtomicBoolean
 

lib/concurrent/atomic/atomic_fixnum.rb

@@ -6,6 +6,18 @@ module Concurrent
   #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
   #   briefly but no explicit locking is required.
   #
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         3.130000   0.000000   3.130000 (  3.136505)
+  #       Testing with Concurrent::CAtomicFixnum...
+  #         0.790000   0.000000   0.790000 (  0.785550)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         5.460000   2.460000   7.920000 (  3.715000)
+  #       Testing with Concurrent::JavaAtomicFixnum...
+  #         4.520000   0.030000   4.550000 (  1.187000)
+  #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
   class MutexAtomicFixnum