atomic 1.0.2 → 1.1.0

data/.gitignore

@@ -1 +1,5 @@
 lib/atomic_reference.jar
+/nbproject
+ext/*.bundle
+ext/*.so
+ext/*.jar

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.8.7
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode

data/README.md

@@ -1,5 +1,4 @@
-atomic: An atomic reference implementation for JRuby and green or GIL-threaded
-Ruby implementations (MRI 1.8/1.9, Rubinius)
+atomic: An atomic reference implementation for JRuby, Rubinius, and MRI.
 
 Summary
 =======
@@ -56,4 +55,11 @@ my_atomic.value = 1
 my_atomic.swap(2) # => 1
 my_atomic.compare_and_swap(2, 3) # => true, updated to 3
 my_atomic.compare_and_swap(2, 3) # => false, current is not 2
-````
+````
+
+Building
+========
+
+As of 1.1.0, JDK8 is required to build the atomic gem, since it attempts to use
+the new atomic Unsafe.getAndSetObject method only in JDK8. The resulting code
+should still work fine as far back as Java 5.

data/Rakefile

@@ -18,6 +18,7 @@ task :default => :test
 desc "Run tests"
 Rake::TestTask.new :test do |t|
   t.libs << "lib"
+  t.libs << "ext"
   t.test_files = FileList["test/**/*.rb"]
 end
 
@@ -50,4 +51,15 @@ if defined?(JRUBY_VERSION)
   end
 
   task :package => :jar
+else
+  task :package do
+    Dir.chdir("ext") do
+      # this does essentially the same thing
+      # as what RubyGems does
+      ruby "extconf.rb"
+      sh "make"
+    end
+  end
 end
+
+task :test => :package

data/atomic.gemspec

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

data/ext/atomic_reference.c

@@ -13,62 +13,67 @@
 #include <ruby.h>
 
 static void ir_mark(void *value) {
-  rb_gc_mark_maybe((VALUE)value);
+    rb_gc_mark_maybe((VALUE) value);
 }
 
 static VALUE ir_alloc(VALUE klass) {
-  return rb_data_object_alloc(klass, (void *)Qnil, ir_mark, NULL);
+    return rb_data_object_alloc(klass, (void *) Qnil, ir_mark, NULL);
 }
 
-static VALUE ir_initialize(VALUE self, VALUE value) {
-  DATA_PTR(self) = (void *)value;
-  return Qnil;
+static VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE value = Qnil;
+    if (rb_scan_args(argc, argv, "01", &value) == 1) {
+	value = argv[0];
+    }
+    DATA_PTR(self) = (void *) value;
+    return Qnil;
 }
 
 static VALUE ir_get(VALUE self) {
-  return (VALUE)DATA_PTR(self);
+    return (VALUE) DATA_PTR(self);
 }
 
 static VALUE ir_set(VALUE self, VALUE new_value) {
-  DATA_PTR(self) = (void *)new_value;
-  return new_value;
+    DATA_PTR(self) = (void *) new_value;
+    return new_value;
 }
 
 static VALUE ir_get_and_set(VALUE self, VALUE new_value) {
-  VALUE old_value;
-  old_value = (VALUE)DATA_PTR(self);
-  DATA_PTR(self) = (void *)new_value;
-  return old_value;
+    VALUE old_value;
+    old_value = (VALUE) DATA_PTR(self);
+    DATA_PTR(self) = (void *) new_value;
+    return old_value;
 }
 
 static VALUE ir_compare_and_set(volatile VALUE self, VALUE expect_value, VALUE new_value) {
 #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
-  if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
-    return Qtrue;
-  }
+    if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
+	return Qtrue;
+    }
 #elif (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100
-  if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
-    return Qtrue;
-  }
+    if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
+	return Qtrue;
+    }
 #else
-# error No CAS operation available for this platform
+#error No CAS operation available for this platform
 #endif
-  return Qfalse;
+    return Qfalse;
 }
 
 void Init_atomic_reference() {
-  VALUE cAtomic;
-  VALUE cInternalReference;
+    VALUE cAtomic;
 
-  cAtomic = rb_const_get(rb_cObject, rb_intern("Atomic"));
-  cInternalReference = rb_define_class_under(cAtomic, "InternalReference",
-                                             rb_cObject);
+    cAtomic = rb_define_class_under(rb_cObject, "Atomic", rb_cObject);
 
-  rb_define_alloc_func(cInternalReference, ir_alloc);
+    rb_define_alloc_func(cAtomic, ir_alloc);
 
-  rb_define_method(cInternalReference, "initialize", ir_initialize, 1);
-  rb_define_method(cInternalReference, "get", ir_get, 0);
-  rb_define_method(cInternalReference, "set", ir_set, 1);
-  rb_define_method(cInternalReference, "get_and_set", ir_get_and_set, 1);
-  rb_define_method(cInternalReference, "compare_and_set", ir_compare_and_set, 2);
+    rb_define_method(cAtomic, "initialize", ir_initialize, -1);
+    rb_define_method(cAtomic, "get", ir_get, 0);
+    rb_define_method(cAtomic, "value", ir_get, 0);
+    rb_define_method(cAtomic, "set", ir_set, 1);
+    rb_define_method(cAtomic, "value=", ir_set, 1);
+    rb_define_method(cAtomic, "get_and_set", ir_get_and_set, 1);
+    rb_define_method(cAtomic, "swap", ir_get_and_set, 1);
+    rb_define_method(cAtomic, "compare_and_set", ir_compare_and_set, 2);
+    rb_define_method(cAtomic, "compare_and_swap", ir_compare_and_set, 2);
 }

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

@@ -24,6 +24,8 @@ import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.Library;
+import org.jruby.util.unsafe.UnsafeFactory;
+import org.jruby.util.unsafe.UnsafeGetter;
 
 /**
  * This library adds an atomic reference type to JRuby for use in the atomic
@@ -34,10 +36,14 @@ import org.jruby.runtime.load.Library;
  */
 public class AtomicReferenceLibrary implements Library {
     public void load(Ruby runtime, boolean wrap) throws IOException {
-        RubyModule atomicCls = runtime.getClass("Atomic");
-        RubyClass jrubyRefClass = runtime.defineClassUnder("InternalReference", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR, atomicCls);
-        jrubyRefClass.setAllocator(JRUBYREFERENCE_ALLOCATOR);
-        jrubyRefClass.defineAnnotatedMethods(JRubyReference.class);
+        RubyClass atomicCls = runtime.defineClass("Atomic", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        try {
+            sun.misc.Unsafe.class.getMethod("getAndSetObject", Object.class);
+            atomicCls.setAllocator(JRUBYREFERENCE8_ALLOCATOR);
+        } catch (Exception e) {
+            // leave it as Java 6/7 version
+        }
+        atomicCls.defineAnnotatedMethods(JRubyReference.class);
     }
     
     private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
@@ -45,51 +51,83 @@ public class AtomicReferenceLibrary implements Library {
             return new JRubyReference(runtime, klazz);
         }
     };
+    
+    private static final ObjectAllocator JRUBYREFERENCE8_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference(runtime, klazz);
+        }
+    };
 
     @JRubyClass(name="JRubyReference", parent="Object")
     public static class JRubyReference extends RubyObject {
-        private volatile IRubyObject reference;
-        private final static AtomicReferenceFieldUpdater<JRubyReference, IRubyObject> UPDATER =
-            AtomicReferenceFieldUpdater.newUpdater(JRubyReference.class, IRubyObject.class, "reference");
+        volatile IRubyObject reference;
+        
+        static final sun.misc.Unsafe UNSAFE;
+        static final long referenceOffset;
+
+        static {
+            try {
+                UNSAFE = UnsafeGetter.getUnsafe();
+                Class k = JRubyReference.class;
+                referenceOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("reference"));
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
 
         public JRubyReference(Ruby runtime, RubyClass klass) {
             super(runtime, klass);
-            reference = runtime.getNil();
         }
 
         @JRubyMethod
         public IRubyObject initialize(ThreadContext context) {
-            Ruby runtime = context.getRuntime();
-            UPDATER.set(this, runtime.getNil());
-            return runtime.getNil();
+            UNSAFE.putObject(this, referenceOffset, context.nil);
+            return context.nil;
         }
 
         @JRubyMethod
         public IRubyObject initialize(ThreadContext context, IRubyObject value) {
-            Ruby runtime = context.getRuntime();
-            UPDATER.set(this, value);
-            return runtime.getNil();
+            UNSAFE.putObject(this, referenceOffset, value);
+            return context.nil;
         }
 
         @JRubyMethod(name = {"get", "value"})
         public IRubyObject get() {
-            return UPDATER.get(this);
+            return reference;
         }
 
         @JRubyMethod(name = {"set", "value="})
         public IRubyObject set(IRubyObject newValue) {
-            UPDATER.set(this, newValue);
+            UNSAFE.putObjectVolatile(this, referenceOffset, newValue);
             return newValue;
         }
 
-        @JRubyMethod
+        @JRubyMethod(name = {"compare_and_set", "compare_and_swap"})
         public IRubyObject compare_and_set(ThreadContext context, IRubyObject oldValue, IRubyObject newValue) {
-            return context.getRuntime().newBoolean(UPDATER.compareAndSet(this, oldValue, newValue));
+            return context.runtime.newBoolean(UNSAFE.compareAndSwapObject(this, referenceOffset, oldValue, newValue));
         }
 
-        @JRubyMethod
+        @JRubyMethod(name = {"get_and_set", "swap"})
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            // less-efficient version for Java 6 and 7
+            while (true) {
+                IRubyObject oldValue = get();
+                if (UNSAFE.compareAndSwapObject(this, referenceOffset, oldValue, newValue)) {
+                    return oldValue;
+                }
+            }
+        }
+    }
+    
+    public static class JRubyReference8 extends JRubyReference {
+        public JRubyReference8(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @Override
         public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
-            return UPDATER.getAndSet(this, newValue);
+            // efficient version for Java 8
+            return (IRubyObject)UNSAFE.getAndSetObject(this, referenceOffset, newValue);
         }
     }
 }

data/lib/atomic.rb

@@ -10,106 +10,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'thread'
-
-class Atomic
-  class ConcurrentUpdateError < ThreadError
-  end
-  
-  def initialize(value=nil)
-    @ref = InternalReference.new(value)
-  end
-
-  def value
-    @ref.get
-  end
-  alias get value
-  
-  def value=(new_value)
-    @ref.set(new_value)
-    new_value
-  end
-  alias set value=
-
-  def swap(new_value)
-    @ref.get_and_set(new_value)
-  end
-  alias get_and_set swap
-  
-  def compare_and_swap(old_value, new_value)
-    @ref.compare_and_set(old_value, new_value)
-  end
-  alias compare_and_set compare_and_swap
-
-  # Pass the current value to the given block, replacing it
-  # with the block's result. May retry if the value changes
-  # during the block's execution.
-  def update
-    true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))
-    new_value
-  end
-  
-  # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-  CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-
-  def try_update
-    old_value = @ref.get
-    new_value = yield old_value
-    unless @ref.compare_and_set(old_value, new_value)
-      if $VERBOSE
-        raise ConcurrentUpdateError, "Update failed"
-      else
-        raise ConcurrentUpdateError, "Update failed", CONC_UP_ERR_BACKTRACE
-      end
-    end
-    new_value
-  end
-end
-
 begin
   ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
-  case ruby_engine
-  when 'jruby', 'ruby'
-    require 'atomic_reference'
-  when 'rbx'
-    Atomic::InternalReference = Rubinius::AtomicReference
-  else
-    raise LoadError
-  end
+  require "atomic/#{ruby_engine}"
 rescue LoadError
-  warn 'unsupported Ruby engine, using less-efficient Atomic impl' if $VERBOSE
-  # Portable/generic (but not very memory or scheduling-efficient) fallback
-  class Atomic::InternalReference #:nodoc: all
-    def initialize(value)
-      @mutex = Mutex.new
-      @value = value
-    end
-
-    def get
-      @mutex.synchronize { @value }
-    end
-
-    def set(new_value)
-      @mutex.synchronize { @value = new_value }
-    end
-
-    def get_and_set(new_value)
-      @mutex.synchronize do
-        old_value = @value
-        @value = new_value
-        old_value
-      end
-    end
-
-    def compare_and_set(old_value, new_value)
-      return false unless @mutex.try_lock
-      begin
-        return false unless @value.equal? old_value
-        @value = new_value
-      ensure
-        @mutex.unlock
-      end
-      true
-    end
-  end
-end
+  require 'atomic/fallback'
+end

data/lib/atomic/concurrent_update_error.rb

@@ -0,0 +1,6 @@
+class Atomic
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
+end

data/lib/atomic/delegated_update.rb

@@ -0,0 +1,25 @@
+require 'atomic/concurrent_update_error'
+
+# Define update methods that delegate to @ref field
+class Atomic
+  # Pass the current value to the given block, replacing it
+  # with the block's result. May retry if the value changes
+  # during the block's execution.
+  def update
+    true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))
+    new_value
+  end
+
+  def try_update
+    old_value = @ref.get
+    new_value = yield old_value
+    unless @ref.compare_and_set(old_value, new_value)
+      if $VERBOSE
+        raise ConcurrentUpdateError, "Update failed"
+      else
+        raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+      end
+    end
+    new_value
+  end
+end

data/lib/atomic/direct_update.rb

@@ -0,0 +1,25 @@
+require 'atomic/concurrent_update_error'
+
+# Define update methods that use direct paths
+class Atomic
+  # Pass the current value to the given block, replacing it
+  # with the block's result. May retry if the value changes
+  # during the block's execution.
+  def update
+    true until compare_and_set(old_value = get, new_value = yield(old_value))
+    new_value
+  end
+
+  def try_update
+    old_value = get
+    new_value = yield old_value
+    unless compare_and_set(old_value, new_value)
+      if $VERBOSE
+        raise ConcurrentUpdateError, "Update failed"
+      else
+        raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+      end
+    end
+    new_value
+  end
+end

data/lib/atomic/fallback.rb

@@ -0,0 +1,43 @@
+warn "#{__FILE__}:#{__LINE__}: unsupported Ruby engine `#{RUBY_ENGINE}', using less-efficient Atomic impl"
+
+require 'thread'
+require 'atomic/direct_update'
+
+# Portable/generic (but not very memory or scheduling-efficient) fallback
+class Atomic #:nodoc: all
+  def initialize(value = nil)
+    @mutex = Mutex.new
+    @value = value
+  end
+
+  def get
+    @mutex.synchronize { @value }
+  end
+  alias value get
+
+  def set(new_value)
+    @mutex.synchronize { @value = new_value }
+  end
+  alias value= set
+
+  def get_and_set(new_value)
+    @mutex.synchronize do
+      old_value = @value
+      @value = new_value
+      old_value
+    end
+  end
+  alias swap get_and_set
+
+  def compare_and_set(old_value, new_value)
+    return false unless @mutex.try_lock
+    begin
+      return false unless @value.equal? old_value
+      @value = new_value
+    ensure
+      @mutex.unlock
+    end
+    true
+  end
+  alias compare_and_swap compare_and_set
+end

data/lib/atomic/jruby.rb

@@ -0,0 +1,2 @@
+require 'atomic_reference'
+require 'atomic/direct_update'

data/lib/atomic/rbx.rb

@@ -0,0 +1,11 @@
+Atomic = Rubinius::AtomicReference
+
+require 'atomic/direct_update'
+
+# define additional aliases
+class Atomic
+  alias value get
+  alias value= set
+  alias compare_and_swap compare_and_set
+  alias swap get_and_set
+end

data/lib/atomic/ruby.rb

@@ -0,0 +1,2 @@
+require 'atomic_reference'
+require 'atomic/direct_update'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-29 00:00:00.000000000 Z
+date: 2013-04-04 00:00:00.000000000 Z
 dependencies: []
 description: An atomic reference implementation for JRuby, Rubinius, and MRI
 email:
@@ -24,6 +24,7 @@ files:
 - test/test_atomic.rb
 - ext/extconf.rb
 - .gitignore
+- .travis.yml
 - LICENSE
 - README.md
 - Rakefile
@@ -36,6 +37,13 @@ files:
 - ext/atomic_reference.c
 - ext/org/jruby/ext/atomic/AtomicReferenceLibrary.java
 - lib/atomic.rb
+- lib/atomic/concurrent_update_error.rb
+- lib/atomic/delegated_update.rb
+- lib/atomic/direct_update.rb
+- lib/atomic/fallback.rb
+- lib/atomic/jruby.rb
+- lib/atomic/rbx.rb
+- lib/atomic/ruby.rb
 homepage: http://github.com/headius/ruby-atomic
 licenses: []
 post_install_message: