atomic 0.0.2 → 0.0.3

data/Rakefile

@@ -8,3 +8,29 @@ Rake::TestTask.new :test do |t|
   t.libs << "lib"
   t.test_files = FileList["test/**/*.rb"]
 end
+
+if defined?(JRUBY_VERSION)
+  require 'ant'
+
+  directory "pkg/classes"
+
+  desc "Clean up build artifacts"
+  task :clean do
+    rm_rf "pkg/classes"
+    rm_rf "lib/refqueue.jar"
+  end
+
+  desc "Compile the extension"
+  task :compile => "pkg/classes" do |t|
+    ant.javac :srcdir => "ext", :destdir => t.prerequisites.first,
+      :source => "1.5", :target => "1.5", :debug => true,
+      :classpath => "${java.class.path}:${sun.boot.class.path}"
+  end
+
+  desc "Build the jar"
+  task :jar => :compile do
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/atomic_reference.jar", :includes => "**/*.class"
+  end
+
+  task :package => :jar
+end

data/atomic.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{atomic}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
   s.authors = ["Charles Oliver Nutter", "MenTaLguY"]
   s.date = Time.now.strftime('YYYY-MM-DD')
   s.description = "An atomic reference implementation for JRuby and green or GIL-threaded impls"
   s.email = ["headius@headius.com", "mental@rydia.net"]
-  s.files = Dir['{lib,examples,test}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
+  s.files = Dir['{lib,examples,test,ext}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
   s.homepage = "http://github.com/headius/ruby-atomic"
   s.require_paths = ["lib"]
   s.summary = "An atomic reference implementation for JRuby and green or GIL-threaded impls"

data/ext/AtomicReferenceService.java

@@ -0,0 +1,12 @@
+import java.io.IOException;
+        
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class AtomicReferenceService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new org.jruby.ext.atomic.AtomicReferenceLibrary().load(runtime, false);
+        return true;
+    }
+}
+

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

@@ -0,0 +1,81 @@
+package org.jruby.ext.atomic;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicReference;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+/**
+ * This library adds an atomic reference type to JRuby for use in the atomic
+ * library. We do a native version to avoid the implicit value coercion that
+ * normally happens through JI.
+ * 
+ * @author headius
+ */
+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);
+    }
+    
+    private static final ObjectAllocator JRUBYREFERENCE_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 final AtomicReference<IRubyObject> reference;
+
+        public JRubyReference(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+            reference = new AtomicReference<IRubyObject>(runtime.getNil());
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            Ruby runtime = context.getRuntime();
+            reference.set(runtime.getNil());
+            return runtime.getNil();
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            Ruby runtime = context.getRuntime();
+            reference.set(value);
+            return runtime.getNil();
+        }
+
+        @JRubyMethod(name = {"get", "value"})
+        public IRubyObject get() {
+            return reference.get();
+        }
+
+        @JRubyMethod(name = {"set", "value="})
+        public IRubyObject set(IRubyObject newValue) {
+            reference.set(newValue);
+            return newValue;
+        }
+
+        @JRubyMethod
+        public IRubyObject compare_and_set(ThreadContext context, IRubyObject oldValue, IRubyObject newValue) {
+            return context.getRuntime().newBoolean(reference.compareAndSet(oldValue, newValue));
+        }
+
+        @JRubyMethod
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            return reference.getAndSet(newValue);
+        }
+    }
+}

data/lib/atomic.rb

@@ -17,6 +17,10 @@ class Atomic
     new_value
   end
 
+  def swap(new_value)
+    @ref.get_and_set(new_value)
+  end
+
   # 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.
@@ -34,13 +38,12 @@ class Atomic
     unless @ref.compare_and_set(old_value, new_value)
       raise ConcurrentUpdateError, "Update failed"
     end
-    old_value
+    new_value
   end
 end
 
 if defined? RUBY_ENGINE && RUBY_ENGINE == "jruby"
-  require 'java'
-  Atomic::InternalReference = java.util.concurrent.atomic.AtomicReference
+  require 'atomic_reference'
 else
   class Atomic::InternalReference
     attr_accessor :value
@@ -51,6 +54,14 @@ else
       @value = value
     end
 
+    def get_and_set(new_value)
+      Thread.exclusive do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+
     def compare_and_set(old_value, new_value)
       Thread.exclusive do 
         return false unless @value.equal? old_value

data/test/test_atomic.rb

@@ -18,34 +18,46 @@ class TestAtomic < Test::Unit::TestCase
   end
   
   def test_update
-    atomic = Atomic.new(0)
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = Atomic.new(1000)
     res = atomic.update {|v| v + 1}
     
-    assert_equal 1, atomic.value
-    assert_equal 0, res
+    assert_equal 1001, atomic.value
+    assert_equal 1001, res
   end
   
   def test_try_update
-    atomic = Atomic.new(0)
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = Atomic.new(1000)
     res = atomic.try_update {|v| v + 1}
     
-    assert_equal 1, atomic.value
-    assert_equal 0, res
+    assert_equal 1001, atomic.value
+    assert_equal 1001, res
+  end
+
+  def test_swap
+    atomic = Atomic.new(1000)
+    res = atomic.swap(1001)
+
+    assert_equal 1001, atomic.value
+    assert_equal 1000, res
   end
   
   def test_try_update_fails
-    atomic = Atomic.new(0)
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = Atomic.new(1000)
     assert_raise Atomic::ConcurrentUpdateError do
       # assigning within block exploits implementation detail for test
-      atomic.try_update{|v| atomic.value = 1 ; v + 1}
+      atomic.try_update{|v| atomic.value = 1001 ; v + 1}
     end
   end
 
   def test_update_retries
     tries = 0
-    atomic = Atomic.new(0)
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = Atomic.new(1000)
     # assigning within block exploits implementation detail for test
-    atomic.update{|v| tries += 1 ; atomic.value = 1 ; v + 1}
+    atomic.update{|v| tries += 1 ; atomic.value = 1001 ; v + 1}
     assert_equal 2, tries
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 2
-  version: 0.0.2
+    - 3
+  version: 0.0.3
 platform: ruby
 authors: 
   - Charles Oliver Nutter
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-08 00:29:12.585000 -04:00
+date: 2010-06-08 08:04:17.179000 -04:00
 default_executable: 
 dependencies: []
 
@@ -31,8 +31,12 @@ extra_rdoc_files: []
 
 files: 
   - lib/atomic.rb
+  - lib/atomic_reference.jar
+  - lib/atomicreference.jar
   - examples/atomic_example.rb
   - test/test_atomic.rb
+  - ext/AtomicReferenceService.java
+  - ext/org/jruby/ext/atomic/AtomicReferenceLibrary.java
   - README.txt
   - atomic.gemspec
   - Rakefile