LockType and RLock builtins are in

- using a Semaphore for regular locks and ReentrantLock for RLocks
- threading module can be imported

Author: cosminbasca

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java

@@ -137,6 +137,7 @@
 import com.oracle.graal.python.builtins.objects.str.StringBuiltins;
 import com.oracle.graal.python.builtins.objects.superobject.SuperBuiltins;
 import com.oracle.graal.python.builtins.objects.thread.LockBuiltins;
+import com.oracle.graal.python.builtins.objects.thread.RLockBuiltins;
 import com.oracle.graal.python.builtins.objects.thread.ThreadBuiltins;
 import com.oracle.graal.python.builtins.objects.traceback.TracebackBuiltins;
 import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
@@ -291,6 +292,7 @@ private static final PythonBuiltins[] initializeBuiltins() {
                         new ThreadModuleBuiltins(),
                         new ThreadBuiltins(),
                         new LockBuiltins(),
+                        new RLockBuiltins(),
                         new SuperBuiltins(),
                         new BinasciiModuleBuiltins(),
                         new PosixSubprocessModuleBuiltins(),

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java

@@ -88,6 +88,7 @@ public enum PythonBuiltinClassType implements LazyPythonClass {
     PBuffer("buffer", "builtins"),
     PThread("thread", "_thread"),
     PLock("lock", "_thread"),
+    PRLock("rlock", "_thread"),
     PSocket("socket", "_socket"),
 
     // Errors and exceptions:

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ThreadModuleBuiltins.java

@@ -50,6 +50,7 @@
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.thread.PLock;
+import com.oracle.graal.python.builtins.objects.thread.PRLock;
 import com.oracle.graal.python.builtins.objects.thread.PThread;
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
@@ -71,15 +72,24 @@ protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFa
         return ThreadModuleBuiltinsFactory.getFactories();
     }
 
-    @Builtin(name = "allocate_lock", fixedNumOfPositionalArgs = 1, constructsClass = PythonBuiltinClassType.PLock)
+    @Builtin(name = "LockType", fixedNumOfPositionalArgs = 1, constructsClass = PythonBuiltinClassType.PLock)
     @GenerateNodeFactory
-    abstract static class AllocateLockNode extends PythonUnaryBuiltinNode {
+    abstract static class ConstructLockNode extends PythonUnaryBuiltinNode {
         @Specialization
-        PLock allocate(PythonClass cls) {
+        PLock construct(PythonClass cls) {
             return factory().createLock(cls);
         }
     }
 
+    @Builtin(name = "RLock", fixedNumOfPositionalArgs = 1, constructsClass = PythonBuiltinClassType.PRLock)
+    @GenerateNodeFactory
+    abstract static class ConstructRLockNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        PRLock construct(PythonClass cls) {
+            return factory().createRLock(cls);
+        }
+    }
+
     @Builtin(name = "get_ident", fixedNumOfPositionalArgs = 0)
     @GenerateNodeFactory
     abstract static class GetCurrentThreadIdNode extends PythonBuiltinNode {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/thread/AbstractPythonLock.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.builtins.objects.thread;
+
+import com.oracle.graal.python.builtins.objects.object.PythonBuiltinObject;
+import com.oracle.graal.python.builtins.objects.type.PythonClass;
+
+public abstract class AbstractPythonLock extends PythonBuiltinObject {
+
+    AbstractPythonLock(PythonClass cls) {
+        super(cls);
+    }
+
+    private long getTimeoutInMillis(double timeout) {
+        // TODO: look at
+        // https://github.com/python/cpython/blob/e42b705188271da108de42b55d9344642170aa2b/Python/pytime.c
+        // _PyTime_AsMicroseconds
+        long seconds = (long) timeout;
+        long milli = (long) ((timeout - seconds) * 1000);
+        return seconds * 1000 + milli;
+    }
+
+    abstract boolean tryToAcquire();
+
+    abstract boolean blockUntilAcquire() throws InterruptedException;
+
+    abstract boolean acquireTimeout(long timeout) throws InterruptedException;
+
+    boolean acquire() {
+        try {
+            return blockUntilAcquire();
+        } catch (InterruptedException e) {
+            return false;
+        }
+    }
+
+    boolean acquire(int waitFlag, double timeout) {
+        if (waitFlag == 0) {
+            return tryToAcquire();
+        } else {
+            try {
+                if (timeout < 0) {
+                    return blockUntilAcquire();
+                } else {
+                    return acquireTimeout(getTimeoutInMillis(timeout));
+                }
+            } catch (InterruptedException e) {
+                return false;
+            }
+        }
+    }
+
+    public abstract void release();
+
+    public abstract boolean locked();
+}

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/thread/LockBuiltins.java

@@ -42,6 +42,7 @@
 
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__ENTER__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__EXIT__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__REPR__;
 
 import java.util.List;
 
@@ -150,4 +151,17 @@ boolean isLocked(PLock self) {
             return self.locked();
         }
     }
+
+    @Builtin(name = __REPR__, fixedNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class ReprLockNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        @TruffleBoundary
+        String repr(PLock self) {
+            return String.format("<%s %s object at %s>",
+                            (self.locked()) ? "locked" : "unlocked",
+                            self.getPythonClass(),
+                            self.hashCode());
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/thread/PLock.java

@@ -40,47 +40,42 @@
  */
 package com.oracle.graal.python.builtins.objects.thread;
 
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.ReentrantLock;
 
-import com.oracle.graal.python.builtins.objects.object.PythonBuiltinObject;
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 
-public class PLock extends PythonBuiltinObject {
-    private final ReentrantLock lock;
+public class PLock extends AbstractPythonLock {
+    private final Semaphore semaphore;
 
     public PLock(PythonClass cls) {
         super(cls);
-        lock = new ReentrantLock();
+        semaphore = new Semaphore(1);
     }
 
-    public boolean acquire(int waitFlag, double timeout) {
-        if (waitFlag == 0) {
-            return lock.tryLock();
-        } else {
-            if (timeout < 0) {
-                lock.lock();
-                return true;
-            } else {
-                // TODO: look at
-                // https://github.com/python/cpython/blob/e42b705188271da108de42b55d9344642170aa2b/Python/pytime.c
-                // _PyTime_AsMicroseconds
-                long seconds = (long) timeout;
-                long milli = (long) ((timeout - seconds) * 1000);
-                try {
-                    return lock.tryLock(seconds * 1000 + milli, TimeUnit.MILLISECONDS);
-                } catch (InterruptedException e) {
-                    return false;
-                }
-            }
-        }
+    @Override
+    boolean tryToAcquire() {
+        return semaphore.tryAcquire();
     }
 
+    @Override
+    boolean blockUntilAcquire() throws InterruptedException {
+        semaphore.acquire();
+        return true;
+    }
+
+    @Override
+    boolean acquireTimeout(long timeout) throws InterruptedException {
+        return semaphore.tryAcquire(timeout, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
     public void release() {
-        lock.unlock();
+        semaphore.release();
     }
 
+    @Override
     public boolean locked() {
-        return lock.isLocked();
+        return semaphore.availablePermits() == 0;
     }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/thread/PRLock.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.builtins.objects.thread;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+import com.oracle.graal.python.builtins.objects.type.PythonClass;
+
+public class PRLock extends AbstractPythonLock {
+    private class InternalReentrantLock extends ReentrantLock {
+        private static final long serialVersionUID = 2531000884985514112L;
+
+        long getOwnerId() {
+            Thread owner = getOwner();
+            if (owner != null) {
+                return owner.getId();
+            }
+            return 0;
+        }
+    }
+
+    private final InternalReentrantLock lock;
+
+    public PRLock(PythonClass cls) {
+        super(cls);
+        this.lock = new InternalReentrantLock();
+    }
+
+    public boolean isOwned() {
+        return lock.isHeldByCurrentThread();
+    }
+
+    public int getCount() {
+        return lock.getHoldCount();
+    }
+
+    public long getOwnerId() {
+        return lock.getOwnerId();
+    }
+
+    public void releaseAll() {
+        while (lock.getHoldCount() > 0) {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    boolean tryToAcquire() {
+        return lock.tryLock();
+    }
+
+    @Override
+    boolean blockUntilAcquire() throws InterruptedException {
+        lock.lock();
+        return true;
+    }
+
+    @Override
+    boolean acquireTimeout(long timeout) throws InterruptedException {
+        return lock.tryLock(timeout, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void release() {
+        lock.unlock();
+    }
+
+    @Override
+    public boolean locked() {
+        return lock.isLocked();
+    }
+}