test_thread add append lock (to be removed when the append method (and simmilar) are thread safe)

- merge _thread module builtins with the new builtin LazyPythonClass mechanism

Author: cosminbasca

graalpython/com.oracle.graal.python.test/src/tests/test_thread.py

@@ -121,16 +121,19 @@ def test_stack_size(self):
     def test__count(self):
         # Test the _count() function.
         orig = thread._count()
+        _append_lock = thread.allocate_lock()
         mut = thread.allocate_lock()
         mut.acquire()
         started = []
         done = []
 
         def task():
-            started.append(None)
+            with _append_lock:
+                started.append(None)
             mut.acquire()
             mut.release()
-            done.append(None)
+            with _append_lock:
+                done.append(None)
 
         thread.start_new_thread(task, ())
         while not started:
@@ -249,14 +252,19 @@ def __init__(self, f, n, wait_before_exit=False):
         self.started = []
         self.finished = []
         self._can_exit = not wait_before_exit
+        self._append_lock = thread.allocate_lock()
 
         def task():
             tid = threading.get_ident()
-            self.started.append(tid)
+            # TODO: remove the append lock once append like ops are thread safe
+            with self._append_lock:
+                self.started.append(tid)
             try:
                 f()
             finally:
-                self.finished.append(tid)
+                # TODO: remove the append lock once append like ops are thread safe
+                with self._append_lock:
+                    self.finished.append(tid)
                 while not self._can_exit:
                     _wait()
         try:

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

@@ -86,9 +86,9 @@ public enum PythonBuiltinClassType implements LazyPythonClass {
     PCode("code"),
     PZip("zip", "builtins"),
     PBuffer("buffer", "builtins"),
-    PThread("thread", "_thread"),
-    PLock("lock", "_thread"),
-    PRLock("rlock", "_thread"),
+    PThread("start_new_thread", "_thread"),
+    PLock("LockType", "_thread"),
+    PRLock("RLock", "_thread"),
     PSocket("socket", "_socket"),
 
     // Errors and exceptions:

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

@@ -41,15 +41,15 @@
 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;
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 
 public abstract class AbstractPythonLock extends PythonBuiltinObject {
 
     public static double TIMEOUT_MAX = 2 ^ 31;
     public static boolean DEFAULT_BLOCKING = true;
     public static double DEFAULT_TIMEOUT = -1.0;
 
-    AbstractPythonLock(PythonClass cls) {
+    AbstractPythonLock(LazyPythonClass cls) {
         super(cls);
     }
 

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

@@ -43,13 +43,14 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 
 public final class PLock extends AbstractPythonLock {
     private final Semaphore semaphore;
 
-    public PLock(PythonClass cls) {
+    public PLock(LazyPythonClass cls) {
         super(cls);
         semaphore = new Semaphore(1);
     }

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

@@ -43,7 +43,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 
-import com.oracle.graal.python.builtins.objects.type.PythonClass;
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 
 public final class PRLock extends AbstractPythonLock {
@@ -61,7 +61,7 @@ long getOwnerId() {
 
     private final InternalReentrantLock lock;
 
-    public PRLock(PythonClass cls) {
+    public PRLock(LazyPythonClass cls) {
         super(cls);
         this.lock = new InternalReentrantLock();
     }

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

@@ -41,18 +41,18 @@
 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;
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 
 public class PThread extends PythonBuiltinObject {
     public final static String GRAALPYTHON_THREADS = "GRAALPYTHON_THREADS";
     private final Thread thread;
 
-    public PThread(PythonClass cls, ThreadGroup group, Runnable runnable) {
+    public PThread(LazyPythonClass cls, ThreadGroup group, Runnable runnable) {
         this(cls, group, 0, runnable);
     }
 
-    public PThread(PythonClass cls, ThreadGroup group, long stackSize, Runnable runnable) {
+    public PThread(LazyPythonClass cls, ThreadGroup group, long stackSize, Runnable runnable) {
         super(cls);
         this.thread = new Thread(group, runnable, "graalpython-thread-" + group.activeCount(), stackSize);
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/object/PythonObjectFactory.java

@@ -753,15 +753,15 @@ public PSocket createSocket(PythonClass cls, int family, int type, int proto) {
      */
 
     public PLock createLock() {
-        return createLock(PythonBuiltinClassType.PLock);
+        return trace(new PLock(PythonBuiltinClassType.PLock));
     }
 
     public PLock createLock(PythonClass cls) {
         return trace(new PLock(cls));
     }
 
     public PRLock createRLock() {
-        return trace(new PRLock(lookupClass(PythonBuiltinClassType.PRLock)));
+        return trace(new PRLock(PythonBuiltinClassType.PRLock));
     }
 
     public PRLock createRLock(PythonClass cls) {