concurrent-ruby 1.1.5

data/ext/concurrent-ruby/ConcurrentRubyService.java

@@ -0,0 +1,17 @@
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class ConcurrentRubyService implements BasicLibraryService {
+
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new com.concurrent_ruby.ext.AtomicReferenceLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JRubyMapBackendLibrary().load(runtime, false);
+        return true;
+    }
+}

data/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -0,0 +1,175 @@
+package com.concurrent_ruby.ext;
+
+import java.lang.reflect.Field;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+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 concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicReference", 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() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference(runtime, klazz);
+        }
+    };
+    
+    private static final ObjectAllocator JRUBYREFERENCE8_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference8(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name="JRubyReference", parent="Object")
+    public static class JRubyReference extends RubyObject {
+        volatile IRubyObject reference;
+        
+        static final sun.misc.Unsafe UNSAFE;
+        static final long referenceOffset;
+
+        static {
+            try {
+                UNSAFE = UnsafeHolder.U;
+                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);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            UNSAFE.putObject(this, referenceOffset, context.nil);
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            UNSAFE.putObject(this, referenceOffset, value);
+            return context.nil;
+        }
+
+        @JRubyMethod(name = {"get", "value"})
+        public IRubyObject get() {
+            return reference;
+        }
+
+        @JRubyMethod(name = {"set", "value="})
+        public IRubyObject set(IRubyObject newValue) {
+            UNSAFE.putObjectVolatile(this, referenceOffset, newValue);
+            return newValue;
+        }
+
+        @JRubyMethod(name = {"compare_and_set", "compare_and_swap"})
+        public IRubyObject compare_and_set(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            if (expectedValue instanceof RubyNumeric) {
+                // numerics are not always idempotent in Ruby, so we need to do slower logic
+                return compareAndSetNumeric(context, expectedValue, newValue);
+            }
+            
+            return runtime.newBoolean(UNSAFE.compareAndSwapObject(this, referenceOffset, expectedValue, newValue));
+        }
+
+        @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;
+                }
+            }
+        }
+        
+        private IRubyObject compareAndSetNumeric(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            // loop until:
+            // * reference CAS would succeed for same-valued objects
+            // * current and expected have different values as determined by #equals
+            while (true) {
+                IRubyObject current = reference;
+
+                if (!(current instanceof RubyNumeric)) {
+                    // old value is not numeric, CAS fails
+                    return runtime.getFalse();
+                }
+
+                RubyNumeric currentNumber = (RubyNumeric)current;
+                if (!currentNumber.equals(expectedValue)) {
+                    // current number does not equal expected, fail CAS
+                    return runtime.getFalse();
+                }
+
+                // check that current has not changed, or else allow loop to repeat
+                boolean success = UNSAFE.compareAndSwapObject(this, referenceOffset, current, newValue);
+                if (success) {
+                    // value is same and did not change in interim...success
+                    return runtime.getTrue();
+                }
+            }
+        }
+    }
+
+    private static final class UnsafeHolder {
+	private UnsafeHolder(){}
+	    
+	public static final sun.misc.Unsafe U = loadUnsafe();
+	
+	private static sun.misc.Unsafe loadUnsafe() {
+	    try {
+		Class unsafeClass = Class.forName("sun.misc.Unsafe");
+		Field f = unsafeClass.getDeclaredField("theUnsafe");
+		f.setAccessible(true);
+		return (sun.misc.Unsafe) f.get(null);
+	    } catch (Exception e) {
+		return null;
+	    }
+	}
+    }
+    
+    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) {
+            // efficient version for Java 8
+            return (IRubyObject)UNSAFE.getAndSetObject(this, referenceOffset, newValue);
+        }
+    }
+}

data/ext/concurrent-ruby/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java

@@ -0,0 +1,248 @@
+package com.concurrent_ruby.ext;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import com.concurrent_ruby.ext.jsr166e.ConcurrentHashMap;
+import com.concurrent_ruby.ext.jsr166e.ConcurrentHashMapV8;
+import com.concurrent_ruby.ext.jsr166e.nounsafe.*;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.jruby.runtime.Visibility.PRIVATE;
+
+/**
+ * Native Java implementation to avoid the JI overhead.
+ *
+ * @author thedarkone
+ */
+public class JRubyMapBackendLibrary implements Library {
+  public void load(Ruby runtime, boolean wrap) throws IOException {
+
+    RubyModule concurrentMod = runtime.defineModule("Concurrent");
+    RubyModule thread_safeMod = concurrentMod.defineModuleUnder("Collection");
+    RubyClass jrubyRefClass = thread_safeMod.defineClassUnder("JRubyMapBackend", runtime.getObject(), BACKEND_ALLOCATOR);
+    jrubyRefClass.setAllocator(BACKEND_ALLOCATOR);
+    jrubyRefClass.defineAnnotatedMethods(JRubyMapBackend.class);
+  }
+
+  private static final ObjectAllocator BACKEND_ALLOCATOR = new ObjectAllocator() {
+    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+      return new JRubyMapBackend(runtime, klazz);
+    }
+  };
+
+  @JRubyClass(name="JRubyMapBackend", parent="Object")
+    public static class JRubyMapBackend extends RubyObject {
+      // Defaults used by the CHM
+      static final int DEFAULT_INITIAL_CAPACITY = 16;
+      static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+      public static final boolean CAN_USE_UNSAFE_CHM = canUseUnsafeCHM();
+
+      private ConcurrentHashMap<IRubyObject, IRubyObject> map;
+
+      private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM(int initialCapacity, float loadFactor) {
+        if (CAN_USE_UNSAFE_CHM) {
+          return new ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
+        } else {
+          return new com.concurrent_ruby.ext.jsr166e.nounsafe.ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
+        }
+      }
+
+      private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM() {
+        return newCHM(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
+      }
+
+      private static boolean canUseUnsafeCHM() {
+        try {
+          new com.concurrent_ruby.ext.jsr166e.ConcurrentHashMapV8(); // force class load and initialization
+          return true;
+        } catch (Throwable t) { // ensuring we really do catch everything
+          // Doug's Unsafe setup errors always have this "Could not ini.." message
+          if (isCausedBySecurityException(t)) {
+            return false;
+          }
+          throw (t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
+        }
+      }
+
+      private static boolean isCausedBySecurityException(Throwable t) {
+        while (t != null) {
+          if ((t.getMessage() != null && t.getMessage().contains("Could not initialize intrinsics")) || t instanceof SecurityException) {
+            return true;
+          }
+          t = t.getCause();
+        }
+        return false;
+      }
+
+      public JRubyMapBackend(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+      }
+
+      @JRubyMethod
+      public IRubyObject initialize(ThreadContext context) {
+        map = newCHM();
+        return context.getRuntime().getNil();
+      }
+
+      @JRubyMethod
+      public IRubyObject initialize(ThreadContext context, IRubyObject options) {
+        map = toCHM(context, options);
+        return context.getRuntime().getNil();
+      }
+
+      private ConcurrentHashMap<IRubyObject, IRubyObject> toCHM(ThreadContext context, IRubyObject options) {
+        Ruby runtime = context.getRuntime();
+        if (!options.isNil() && options.respondsTo("[]")) {
+          IRubyObject rInitialCapacity = options.callMethod(context, "[]", runtime.newSymbol("initial_capacity"));
+          IRubyObject rLoadFactor      = options.callMethod(context, "[]", runtime.newSymbol("load_factor"));
+          int initialCapacity = !rInitialCapacity.isNil() ? RubyNumeric.num2int(rInitialCapacity.convertToInteger()) : DEFAULT_INITIAL_CAPACITY;
+          float loadFactor    = !rLoadFactor.isNil() ?      (float)RubyNumeric.num2dbl(rLoadFactor.convertToFloat()) : DEFAULT_LOAD_FACTOR;
+          return newCHM(initialCapacity, loadFactor);
+        } else {
+          return newCHM();
+        }
+      }
+
+      @JRubyMethod(name = "[]", required = 1)
+        public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
+          IRubyObject value;
+          return ((value = map.get(key)) == null) ? context.getRuntime().getNil() : value;
+        }
+
+      @JRubyMethod(name = {"[]="}, required = 2)
+        public IRubyObject op_aset(IRubyObject key, IRubyObject value) {
+          map.put(key, value);
+          return value;
+        }
+
+      @JRubyMethod
+      public IRubyObject put_if_absent(IRubyObject key, IRubyObject value) {
+        IRubyObject result = map.putIfAbsent(key, value);
+        return result == null ? getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public IRubyObject compute_if_absent(final ThreadContext context, final IRubyObject key, final Block block) {
+        return map.computeIfAbsent(key, new ConcurrentHashMap.Fun<IRubyObject, IRubyObject>() {
+          @Override
+          public IRubyObject apply(IRubyObject key) {
+            return block.yieldSpecific(context);
+          }
+        });
+      }
+
+      @JRubyMethod
+      public IRubyObject compute_if_present(final ThreadContext context, final IRubyObject key, final Block block) {
+        IRubyObject result = map.computeIfPresent(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+          @Override
+          public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
+            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+            return result.isNil() ? null : result;
+          }
+        });
+        return result == null ? context.getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public IRubyObject compute(final ThreadContext context, final IRubyObject key, final Block block) {
+        IRubyObject result = map.compute(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+          @Override
+          public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
+            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+            return result.isNil() ? null : result;
+          }
+        });
+        return result == null ? context.getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public IRubyObject merge_pair(final ThreadContext context, final IRubyObject key, final IRubyObject value, final Block block) {
+        IRubyObject result = map.merge(key, value, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
+          @Override
+          public IRubyObject apply(IRubyObject oldValue, IRubyObject newValue) {
+            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
+            return result.isNil() ? null : result;
+          }
+        });
+        return result == null ? context.getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public RubyBoolean replace_pair(IRubyObject key, IRubyObject oldValue, IRubyObject newValue) {
+        return getRuntime().newBoolean(map.replace(key, oldValue, newValue));
+      }
+
+      @JRubyMethod(name = "key?", required = 1)
+        public RubyBoolean has_key_p(IRubyObject key) {
+          return map.containsKey(key) ? getRuntime().getTrue() : getRuntime().getFalse();
+        }
+
+      @JRubyMethod
+      public IRubyObject key(IRubyObject value) {
+        final IRubyObject key = map.findKey(value);
+        return key == null ? getRuntime().getNil() : key;
+      }
+
+      @JRubyMethod
+      public IRubyObject replace_if_exists(IRubyObject key, IRubyObject value) {
+        IRubyObject result = map.replace(key, value);
+        return result == null ? getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public IRubyObject get_and_set(IRubyObject key, IRubyObject value) {
+        IRubyObject result = map.put(key, value);
+        return result == null ? getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public IRubyObject delete(IRubyObject key) {
+        IRubyObject result = map.remove(key);
+        return result == null ? getRuntime().getNil() : result;
+      }
+
+      @JRubyMethod
+      public RubyBoolean delete_pair(IRubyObject key, IRubyObject value) {
+        return getRuntime().newBoolean(map.remove(key, value));
+      }
+
+      @JRubyMethod
+      public IRubyObject clear() {
+        map.clear();
+        return this;
+      }
+
+      @JRubyMethod
+      public IRubyObject each_pair(ThreadContext context, Block block) {
+        for (Map.Entry<IRubyObject,IRubyObject> entry : map.entrySet()) {
+          block.yieldSpecific(context, entry.getKey(), entry.getValue());
+        }
+        return this;
+      }
+
+      @JRubyMethod
+      public RubyFixnum size(ThreadContext context) {
+        return context.getRuntime().newFixnum(map.size());
+      }
+
+      @JRubyMethod
+      public IRubyObject get_or_default(IRubyObject key, IRubyObject defaultValue) {
+        return map.getValueOrDefault(key, defaultValue);
+      }
+
+      @JRubyMethod(visibility = PRIVATE)
+        public JRubyMapBackend initialize_copy(ThreadContext context, IRubyObject other) {
+          map = newCHM();
+          return this;
+        }
+    }
+}

data/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicBooleanLibrary.java

@@ -0,0 +1,93 @@
+package com.concurrent_ruby.ext;
+
+import org.jruby.Ruby;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNil;
+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;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class JavaAtomicBooleanLibrary implements Library {
+
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicBoolean", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        atomicCls.defineAnnotatedMethods(JavaAtomicBoolean.class);
+    }
+
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JavaAtomicBoolean(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name = "JavaAtomicBoolean", parent = "Object")
+    public static class JavaAtomicBoolean extends RubyObject {
+
+        private AtomicBoolean atomicBoolean;
+
+        public JavaAtomicBoolean(Ruby runtime, RubyClass metaClass) {
+            super(runtime, metaClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            atomicBoolean = new AtomicBoolean(convertRubyBooleanToJavaBoolean(value));
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            atomicBoolean = new AtomicBoolean();
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "value")
+        public IRubyObject value() {
+            return getRuntime().newBoolean(atomicBoolean.get());
+        }
+
+        @JRubyMethod(name = "true?")
+        public IRubyObject isAtomicTrue() {
+            return getRuntime().newBoolean(atomicBoolean.get());
+        }
+
+        @JRubyMethod(name = "false?")
+        public IRubyObject isAtomicFalse() {
+            return getRuntime().newBoolean((atomicBoolean.get() == false));
+        }
+
+        @JRubyMethod(name = "value=")
+        public IRubyObject setAtomic(ThreadContext context, IRubyObject newValue) {
+            atomicBoolean.set(convertRubyBooleanToJavaBoolean(newValue));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "make_true")
+        public IRubyObject makeTrue() {
+            return getRuntime().newBoolean(atomicBoolean.compareAndSet(false, true));
+        }
+
+        @JRubyMethod(name = "make_false")
+        public IRubyObject makeFalse() {
+            return getRuntime().newBoolean(atomicBoolean.compareAndSet(true, false));
+        }
+
+        private boolean convertRubyBooleanToJavaBoolean(IRubyObject newValue) {
+            if (newValue instanceof RubyBoolean.False || newValue instanceof RubyNil) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+    }
+}