Provide condition variable abstraction on JVM.

Author: jnthn

src/vm/jvm/QAST/Compiler.nqp

@@ -2459,6 +2459,10 @@ QAST::OperationsJAST.map_classlib_core_op('threadyield', $TYPE_OPS, 'threadyield
 QAST::OperationsJAST.map_classlib_core_op('currentthread', $TYPE_OPS, 'currentthread', [], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('lock', $TYPE_OPS, 'lock', [$RT_OBJ], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('unlock', $TYPE_OPS, 'unlock', [$RT_OBJ], $RT_OBJ, :tc);
+QAST::OperationsJAST.map_classlib_core_op('getlockcondvar', $TYPE_OPS, 'getlockcondvar', [$RT_OBJ, $RT_OBJ], $RT_OBJ, :tc);
+QAST::OperationsJAST.map_classlib_core_op('condwait', $TYPE_OPS, 'condwait', [$RT_OBJ], $RT_OBJ, :tc);
+QAST::OperationsJAST.map_classlib_core_op('condsignalone', $TYPE_OPS, 'condsignalone', [$RT_OBJ], $RT_OBJ, :tc);
+QAST::OperationsJAST.map_classlib_core_op('condsignalall', $TYPE_OPS, 'condsignalall', [$RT_OBJ], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('semacquire', $TYPE_OPS, 'semacquire', [$RT_OBJ], $RT_OBJ, :tc);
 QAST::OperationsJAST.map_classlib_core_op('semtryacquire', $TYPE_OPS, 'semtryacquire', [$RT_OBJ], $RT_INT, :tc);
 QAST::OperationsJAST.map_classlib_core_op('semrelease', $TYPE_OPS, 'semrelease', [$RT_OBJ], $RT_OBJ, :tc);

src/vm/jvm/runtime/org/perl6/nqp/runtime/Ops.java

@@ -91,6 +91,8 @@
 import org.perl6.nqp.sixmodel.reprs.ReentrantMutexInstance;
 import org.perl6.nqp.sixmodel.reprs.SemaphoreInstance;
 import org.perl6.nqp.sixmodel.reprs.ConcBlockingQueueInstance;
+import org.perl6.nqp.sixmodel.reprs.ConditionVariable;
+import org.perl6.nqp.sixmodel.reprs.ConditionVariableInstance;
 
 /**
  * Contains complex operations that are more involved that the simple ops that the
@@ -4266,6 +4268,41 @@ public static SixModelObject unlock(SixModelObject lock, ThreadContext tc) {
         return lock;
     }
 
+    public static SixModelObject getlockcondvar(SixModelObject lock, SixModelObject type, ThreadContext tc) {
+        if (!(lock instanceof ReentrantMutexInstance))
+            throw ExceptionHandling.dieInternal(tc, "getlockcondvar requires an operand with REPR ReentrantMutex");
+        if (!(type.st.REPR instanceof ConditionVariable))
+            throw ExceptionHandling.dieInternal(tc, "getlockcondvar requires a result type with REPR ConditionVariable");
+        ConditionVariableInstance result = new ConditionVariableInstance();
+        result.st = type.st;
+        result.condvar = ((ReentrantMutexInstance)lock).lock.newCondition();
+        return result;
+    }
+
+    public static SixModelObject condwait(SixModelObject cv, ThreadContext tc) throws InterruptedException {
+        if (cv instanceof ConditionVariableInstance)
+            ((ConditionVariableInstance)cv).condvar.await();
+        else
+            throw ExceptionHandling.dieInternal(tc, "condwait requires an operand with REPR ConditionVariable");
+        return cv;
+    }
+
+    public static SixModelObject condsignalone(SixModelObject cv, ThreadContext tc) {
+        if (cv instanceof ConditionVariableInstance)
+            ((ConditionVariableInstance)cv).condvar.signal();
+        else
+            throw ExceptionHandling.dieInternal(tc, "condsignalone requires an operand with REPR ConditionVariable");
+        return cv;
+    }
+
+    public static SixModelObject condsignalall(SixModelObject cv, ThreadContext tc) {
+        if (cv instanceof ConditionVariableInstance)
+            ((ConditionVariableInstance)cv).condvar.signalAll();
+        else
+            throw ExceptionHandling.dieInternal(tc, "condsignalall requires an operand with REPR ConditionVariable");
+        return cv;
+    }
+
     public static SixModelObject semacquire(SixModelObject sem, ThreadContext tc) {
         try {
             if (sem instanceof SemaphoreInstance)

src/vm/jvm/runtime/org/perl6/nqp/sixmodel/REPRRegistry.java

@@ -34,6 +34,7 @@
 import org.perl6.nqp.sixmodel.reprs.ReentrantMutex;
 import org.perl6.nqp.sixmodel.reprs.Semaphore;
 import org.perl6.nqp.sixmodel.reprs.ConcBlockingQueue;
+import org.perl6.nqp.sixmodel.reprs.ConditionVariable;
 
 public class REPRRegistry {
     private static HashMap<String, Integer> reprIdMap = new HashMap<String, Integer>();
@@ -92,5 +93,6 @@ private static void addREPR(String name, REPR REPR) {
         addREPR("ReentrantMutex", new ReentrantMutex());
         addREPR("Semaphore", new Semaphore());
         addREPR("ConcBlockingQueue", new ConcBlockingQueue());
+        addREPR("ConditionVariable", new ConditionVariable());
     }
 }

src/vm/jvm/runtime/org/perl6/nqp/sixmodel/reprs/ConditionVariable.java

@@ -0,0 +1,35 @@
+package org.perl6.nqp.sixmodel.reprs;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.perl6.nqp.runtime.ExceptionHandling;
+import org.perl6.nqp.runtime.ThreadContext;
+import org.perl6.nqp.sixmodel.REPR;
+import org.perl6.nqp.sixmodel.STable;
+import org.perl6.nqp.sixmodel.SerializationReader;
+import org.perl6.nqp.sixmodel.SixModelObject;
+import org.perl6.nqp.sixmodel.TypeObject;
+
+public class ConditionVariable extends REPR {
+    public SixModelObject type_object_for(ThreadContext tc, SixModelObject HOW) {
+        STable st = new STable(this, HOW);
+        SixModelObject obj = new TypeObject();
+        obj.st = st;
+        st.WHAT = obj;
+        return st.WHAT;
+    }
+
+    public SixModelObject allocate(ThreadContext tc, STable st) {
+        throw ExceptionHandling.dieInternal(tc,
+            "Cannot create a condition variable directly");
+    }
+
+    public SixModelObject deserialize_stub(ThreadContext tc, STable st) {
+        throw ExceptionHandling.dieInternal(tc, "Cannot deserialize a lock");
+    }
+
+    public void deserialize_finish(ThreadContext tc, STable st,
+            SerializationReader reader, SixModelObject obj) {
+        throw ExceptionHandling.dieInternal(tc, "Cannot deserialize a lock");
+    }
+}

src/vm/jvm/runtime/org/perl6/nqp/sixmodel/reprs/ConditionVariableInstance.java

@@ -0,0 +1,9 @@
+package org.perl6.nqp.sixmodel.reprs;
+
+import java.util.concurrent.locks.Condition;
+
+import org.perl6.nqp.sixmodel.SixModelObject;
+
+public class ConditionVariableInstance extends SixModelObject {
+	public Condition condvar;
+}