acquire gil around hash messages

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/dict/PDict.java

@@ -49,16 +49,17 @@
 import com.oracle.graal.python.nodes.attributes.LookupInheritedAttributeNode;
 import com.oracle.graal.python.nodes.object.IsBuiltinClassProfile;
 import com.oracle.graal.python.nodes.util.CastToJavaLongLossyNode;
+import com.oracle.graal.python.runtime.GilNode;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.Cached.Shared;
+import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.exception.AbstractTruffleException;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnknownKeyException;
 import com.oracle.truffle.api.interop.UnsupportedTypeException;
-import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
@@ -166,22 +167,41 @@ static boolean hasHashEntries(@SuppressWarnings("unused") PDict self) {
 
     @ExportMessage(limit = "2")
     static long getHashSize(PDict self,
+                    @Exclusive @Cached GilNode gil,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) {
-        return lib.length(self.getDictStorage());
+        boolean mustRelease = gil.acquire();
+        try {
+            return lib.length(self.getDictStorage());
+        } finally {
+            gil.release(mustRelease);
+        }
     }
 
     @ExportMessage(limit = "2")
     @ExportMessage(name = "isHashEntryModifiable", limit = "2")
     @ExportMessage(name = "isHashEntryRemovable", limit = "2")
     static boolean isHashEntryReadable(PDict self, Object key,
+                    @Exclusive @Cached GilNode gil,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) {
-        return lib.hasKey(self.getDictStorage(), key);
+        boolean mustRelease = gil.acquire();
+        try {
+            return lib.hasKey(self.getDictStorage(), key);
+        } finally {
+            gil.release(mustRelease);
+        }
     }
 
     @ExportMessage(limit = "2")
     static Object readHashValue(PDict self, Object key,
+                    @Exclusive @Cached GilNode gil,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) throws UnknownKeyException {
-        Object value = lib.getItem(self.getDictStorage(), key);
+        Object value = null;
+        boolean mustRelease = gil.acquire();
+        try {
+            value = lib.getItem(self.getDictStorage(), key);
+        } finally {
+            gil.release(mustRelease);
+        }
         if (value == null) {
             throw UnknownKeyException.create(key);
         } else {
@@ -191,60 +211,94 @@ static Object readHashValue(PDict self, Object key,
 
     @ExportMessage(limit = "3")
     static boolean isHashEntryInsertable(PDict self, Object key,
+                    @Exclusive @Cached GilNode gil,
                     @CachedLibrary("key") PythonObjectLibrary keyLib,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) {
-        if (lib.hasKey(self.getDictStorage(), key)) {
-            return false;
-        } else {
-            // we can only insert hashable types
-            try {
-                keyLib.hash(key);
-            } catch (AbstractTruffleException e) {
+        boolean mustRelease = gil.acquire();
+        try {
+            if (lib.hasKey(self.getDictStorage(), key)) {
                 return false;
+            } else {
+                // we can only insert hashable types
+                try {
+                    keyLib.hash(key);
+                } catch (AbstractTruffleException e) {
+                    return false;
+                }
+                return true;
             }
-            return true;
+        } finally {
+            gil.release(mustRelease);
         }
     }
 
     @ExportMessage(limit = "2")
     static void writeHashEntry(PDict self, Object key, Object value,
+                    @Exclusive @Cached GilNode gil,
                     @Cached IsBuiltinClassProfile errorProfile,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) throws UnsupportedTypeException {
+        boolean mustRelease = gil.acquire();
         try {
             lib.setItem(self.getDictStorage(), key, value);
         } catch (PException e) {
             e.expect(PythonBuiltinClassType.TypeError, errorProfile);
             throw UnsupportedTypeException.create(new Object[]{key}, "keys for Python arrays must be hashable");
+        } finally {
+            gil.release(mustRelease);
         }
     }
 
     @ExportMessage(limit = "2")
     static void removeHashEntry(PDict self, Object key,
+                    @Exclusive @Cached GilNode gil,
                     @CachedLibrary("self.getDictStorage()") HashingStorageLibrary lib) throws UnknownKeyException {
-        if (!isHashEntryReadable(self, key, lib)) {
-            throw UnknownKeyException.create(key);
+        boolean mustRelease = gil.acquire();
+        try {
+            if (!isHashEntryReadable(self, key, gil, lib)) {
+                throw UnknownKeyException.create(key);
+            }
+            lib.delItem(self.getDictStorage(), key);
+        } finally {
+            gil.release(mustRelease);
         }
-        lib.delItem(self.getDictStorage(), key);
     }
 
     @ExportMessage
     static Object getHashEntriesIterator(PDict self,
+                    @Exclusive @Cached GilNode gil,
                     @Shared("iterLib") @CachedLibrary(limit = "2") PythonObjectLibrary lib) {
-        Object dictItems = lib.lookupAndCallSpecialMethod(self, null, ITEMS);
-        return lib.getIterator(dictItems);
+        boolean mustRelease = gil.acquire();
+        try {
+            Object dictItems = lib.lookupAndCallSpecialMethod(self, null, ITEMS);
+            return lib.getIterator(dictItems);
+        } finally {
+            gil.release(mustRelease);
+        }
     }
 
     @ExportMessage
     static Object getHashKeysIterator(PDict self,
+                    @Exclusive @Cached GilNode gil,
                     @Shared("iterLib") @CachedLibrary(limit = "2") PythonObjectLibrary lib) {
-        Object dictKeys = lib.lookupAndCallSpecialMethod(self, null, KEYS);
-        return lib.getIterator(dictKeys);
+        boolean mustRelease = gil.acquire();
+        try {
+            Object dictKeys = lib.lookupAndCallSpecialMethod(self, null, KEYS);
+            return lib.getIterator(dictKeys);
+        } finally {
+            gil.release(mustRelease);
+        }
     }
 
     @ExportMessage
     static Object getHashValuesIterator(PDict self,
+                    @Exclusive @Cached GilNode gil,
                     @Shared("iterLib") @CachedLibrary(limit = "2") PythonObjectLibrary lib) {
-        Object dictValues = lib.lookupAndCallSpecialMethod(self, null, VALUES);
-        return lib.getIterator(dictValues);
+        boolean mustRelease = gil.acquire();
+        try {
+            Object dictValues = lib.lookupAndCallSpecialMethod(self, null, VALUES);
+            return lib.getIterator(dictValues);
+        } finally {
+            gil.release(mustRelease);
+        }
     }
 }