concurrent-ruby 1.0.5 → 1.1.1

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;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,113 @@
+package com.concurrent_ruby.ext;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicLong;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+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;
+import org.jruby.runtime.Block;
+
+public class JavaAtomicFixnumLibrary implements Library {
+
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicFixnum", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+
+        atomicCls.defineAnnotatedMethods(JavaAtomicFixnum.class);
+    }
+
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JavaAtomicFixnum(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name = "JavaAtomicFixnum", parent = "Object")
+    public static class JavaAtomicFixnum extends RubyObject {
+
+        private AtomicLong atomicLong;
+
+        public JavaAtomicFixnum(Ruby runtime, RubyClass metaClass) {
+            super(runtime, metaClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            this.atomicLong = new AtomicLong(0);
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            this.atomicLong = new AtomicLong(rubyFixnumToLong(value));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "value")
+        public IRubyObject getValue() {
+            return getRuntime().newFixnum(atomicLong.get());
+        }
+
+        @JRubyMethod(name = "value=")
+        public IRubyObject setValue(ThreadContext context, IRubyObject newValue) {
+            atomicLong.set(rubyFixnumToLong(newValue));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = {"increment", "up"})
+        public IRubyObject increment() {
+            return getRuntime().newFixnum(atomicLong.incrementAndGet());
+        }
+
+        @JRubyMethod(name = {"increment", "up"})
+        public IRubyObject increment(IRubyObject value) {
+            long delta = rubyFixnumToLong(value);
+            return getRuntime().newFixnum(atomicLong.addAndGet(delta));
+        }
+
+        @JRubyMethod(name = {"decrement", "down"})
+        public IRubyObject decrement() {
+            return getRuntime().newFixnum(atomicLong.decrementAndGet());
+        }
+
+        @JRubyMethod(name = {"decrement", "down"})
+        public IRubyObject decrement(IRubyObject value) {
+            long delta = rubyFixnumToLong(value);
+            return getRuntime().newFixnum(atomicLong.addAndGet(-delta));
+        }
+
+        @JRubyMethod(name = "compare_and_set")
+        public IRubyObject compareAndSet(ThreadContext context, IRubyObject expect, IRubyObject update) {
+            return getRuntime().newBoolean(atomicLong.compareAndSet(rubyFixnumToLong(expect), rubyFixnumToLong(update)));
+        }
+
+        @JRubyMethod
+        public IRubyObject update(ThreadContext context, Block block) {
+            for (;;) {
+                long _oldValue       = atomicLong.get();
+                IRubyObject oldValue = getRuntime().newFixnum(_oldValue);
+                IRubyObject newValue = block.yield(context, oldValue);
+                if (atomicLong.compareAndSet(_oldValue, rubyFixnumToLong(newValue))) {
+                    return newValue;
+                }
+            }
+        }
+
+        private long rubyFixnumToLong(IRubyObject value) {
+            if (value instanceof RubyFixnum) {
+                RubyFixnum fixNum = (RubyFixnum) value;
+                return fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError("value must be a Fixnum");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,159 @@
+package com.concurrent_ruby.ext;
+
+import java.io.IOException;
+import java.util.concurrent.Semaphore;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+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;
+
+public class JavaSemaphoreLibrary {
+
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaSemaphore", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+
+        atomicCls.defineAnnotatedMethods(JavaSemaphore.class);
+    }
+
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JavaSemaphore(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name = "JavaSemaphore", parent = "Object")
+    public static class JavaSemaphore extends RubyObject {
+
+        private JRubySemaphore semaphore;
+
+        public JavaSemaphore(Ruby runtime, RubyClass metaClass) {
+            super(runtime, metaClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            this.semaphore = new JRubySemaphore(rubyFixnumInt(value, "count"));
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject acquire(ThreadContext context, IRubyObject value) throws InterruptedException {
+            this.semaphore.acquire(rubyFixnumToPositiveInt(value, "permits"));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "available_permits")
+        public IRubyObject availablePermits(ThreadContext context) {
+            return getRuntime().newFixnum(this.semaphore.availablePermits());
+        }
+
+        @JRubyMethod(name = "drain_permits")
+        public IRubyObject drainPermits(ThreadContext context) {
+            return getRuntime().newFixnum(this.semaphore.drainPermits());
+        }
+
+        @JRubyMethod
+        public IRubyObject acquire(ThreadContext context) throws InterruptedException {
+            this.semaphore.acquire(1);
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "try_acquire")
+        public IRubyObject tryAcquire(ThreadContext context) throws InterruptedException {
+           return getRuntime().newBoolean(semaphore.tryAcquire(1));
+        }
+
+        @JRubyMethod(name = "try_acquire")
+        public IRubyObject tryAcquire(ThreadContext context, IRubyObject permits) throws InterruptedException {
+           return getRuntime().newBoolean(semaphore.tryAcquire(rubyFixnumToPositiveInt(permits, "permits")));
+        }
+
+        @JRubyMethod(name = "try_acquire")
+        public IRubyObject tryAcquire(ThreadContext context, IRubyObject permits, IRubyObject timeout) throws InterruptedException {
+             return getRuntime().newBoolean(
+                        semaphore.tryAcquire(
+                                rubyFixnumToPositiveInt(permits, "permits"),
+                                rubyNumericToLong(timeout, "timeout"),
+                                java.util.concurrent.TimeUnit.SECONDS)
+                );
+        }
+
+        @JRubyMethod
+        public IRubyObject release(ThreadContext context) {
+            this.semaphore.release(1);
+            return getRuntime().newBoolean(true);
+        }
+
+        @JRubyMethod
+        public IRubyObject release(ThreadContext context, IRubyObject value) {
+            this.semaphore.release(rubyFixnumToPositiveInt(value, "permits"));
+            return getRuntime().newBoolean(true);
+        }
+
+        @JRubyMethod(name = "reduce_permits")
+        public IRubyObject reducePermits(ThreadContext context, IRubyObject reduction) throws InterruptedException {
+            this.semaphore.publicReducePermits(rubyFixnumToNonNegativeInt(reduction, "reduction"));
+            return context.nil;
+        }
+
+        private int rubyFixnumInt(IRubyObject value, String paramName) {
+            if (value instanceof RubyFixnum) {
+                RubyFixnum fixNum = (RubyFixnum) value;
+                return (int) fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError(paramName + " must be integer");
+            }
+        }
+
+        private int rubyFixnumToNonNegativeInt(IRubyObject value, String paramName) {
+            if (value instanceof RubyFixnum && ((RubyFixnum) value).getLongValue() >= 0) {
+                RubyFixnum fixNum = (RubyFixnum) value;
+                return (int) fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError(paramName + " must be a non-negative integer");
+            }
+        }
+
+        private int rubyFixnumToPositiveInt(IRubyObject value, String paramName) {
+            if (value instanceof RubyFixnum && ((RubyFixnum) value).getLongValue() > 0) {
+                RubyFixnum fixNum = (RubyFixnum) value;
+                return (int) fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError(paramName + " must be an integer greater than zero");
+            }
+        }
+
+        private long rubyNumericToLong(IRubyObject value, String paramName) {
+            if (value instanceof RubyNumeric && ((RubyNumeric) value).getDoubleValue() > 0) {
+                RubyNumeric fixNum = (RubyNumeric) value;
+                return fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError(paramName + " must be a float greater than zero");
+            }
+        }
+
+        class JRubySemaphore extends Semaphore {
+
+            public JRubySemaphore(int permits) {
+                super(permits);
+            }
+
+            public JRubySemaphore(int permits, boolean value) {
+                super(permits, value);
+            }
+
+            public void publicReducePermits(int i) {
+                reducePermits(i);
+            }
+
+        }
+    }
+}