[GR-16580] Use lock for interop calls if multi-threaded.

PullRequest: graalpython/552

Author: cosminbasca

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -618,7 +618,8 @@ protected boolean isThreadAccessAllowed(Thread thread, boolean singleThreaded) {
 
     @Override
     protected void initializeMultiThreading(PythonContext context) {
-        PythonContext.getSingleThreadedAssumption().invalidate();
+        context.createInteropLock();
+        context.getSingleThreadedAssumption().invalidate();
     }
 
     @Override

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/ExecutionContext.java

@@ -288,6 +288,9 @@ public abstract static class IndirectCallContext {
          * </p>
          */
         public static PException enter(VirtualFrame frame, PythonContext context, Node callNode) {
+            if (!context.getSingleThreadedAssumption().isValid()) {
+                context.acquireInteropLock();
+            }
             PFrame.Reference prev = context.popTopFrameInfo();
             assert prev == null : "trying to call from Python to a foreign function, but we didn't clear the topframeref. " +
                             "This indicates that a call into Python code happened without a proper enter through ForeignToPythonCallContext";
@@ -303,6 +306,9 @@ public static void exit(PythonContext context, PException savedExceptionState) {
             if (context != null) {
                 context.popTopFrameInfo();
                 ExceptionContext.exit(context, savedExceptionState);
+                if (!context.getSingleThreadedAssumption().isValid()) {
+                    context.releaseInteropLock();
+                }
             }
         }
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonContext.java

@@ -34,6 +34,7 @@
 import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Supplier;
 
@@ -102,8 +103,12 @@ public final class PythonContext {
     private OutputStream err;
     private InputStream in;
     @CompilationFinal private Object capiLibrary = null;
+    private final Assumption singleThreaded = Truffle.getRuntime().createAssumption("single Threaded");
+
     private static final Assumption singleNativeContext = Truffle.getRuntime().createAssumption("single native context assumption");
-    private static final Assumption singleThreaded = Truffle.getRuntime().createAssumption("single Threaded");
+
+    /* A lock for interop calls when this context is used by multiple threads. */
+    private Lock interopLock;
 
     @CompilationFinal private HashingStorage.Equivalence slowPathEquivalence;
 
@@ -402,7 +407,7 @@ public static Assumption getSingleNativeContextAssumption() {
         return singleNativeContext;
     }
 
-    public static Assumption getSingleThreadedAssumption() {
+    public Assumption getSingleThreadedAssumption() {
         return singleThreaded;
     }
 
@@ -452,4 +457,19 @@ public Object getSingletonNativePtr(PythonAbstractObject obj) {
         }
         return null;
     }
+
+    @TruffleBoundary
+    public void acquireInteropLock() {
+        interopLock.lock();
+    }
+
+    @TruffleBoundary
+    public void releaseInteropLock() {
+        interopLock.unlock();
+    }
+
+    @TruffleBoundary
+    public void createInteropLock() {
+        interopLock = new ReentrantLock();
+    }
 }