update the IsBuiltinClassProfile to cache shapes so we can avoid the indirection to access the class in low-degree polymorphic cases

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/object/IsBuiltinClassProfile.java

@@ -40,14 +40,19 @@
  */
 package com.oracle.graal.python.nodes.object;
 
+import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
-import com.oracle.graal.python.builtins.objects.type.PythonAbstractClass;
 import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
+import com.oracle.graal.python.builtins.objects.type.PythonAbstractClass;
 import com.oracle.graal.python.builtins.objects.type.PythonBuiltinClass;
 import com.oracle.graal.python.runtime.exception.PException;
+import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.ExplodeLoop.LoopExplosionKind;
+import com.oracle.truffle.api.object.Shape;
 
 public final class IsBuiltinClassProfile {
     @CompilationFinal private boolean isBuiltinType;
@@ -57,6 +62,33 @@ public final class IsBuiltinClassProfile {
     @CompilationFinal private boolean match;
     @CompilationFinal private boolean noMatch;
 
+    // n.b.: (tfel) We store the python class as a Shape property on the
+    // DynamicObject representing the Python-level object. Thus, accessing the
+    // python class incurs an indirection that we'd like to avoid if
+    // possible. We use this cache to avoid the indirection. In the single
+    // context case, we just cache all classes, in the multi-context case, we
+    // only cache classes if they are builtin types that are shared across
+    // contexts.
+    private final Assumption singleContextAssumption = PythonLanguage.getCurrent().singleContextAssumption;
+    private static final int CLASS_CACHE_SIZE = 3;
+    @CompilationFinal(dimensions = 1) private ClassCache[] classCache = new ClassCache[CLASS_CACHE_SIZE];
+    @CompilationFinal private boolean cacheUsedInSingleContext = false;
+
+    private static final class ClassCache {
+        private final LazyPythonClass klass;
+        private final Shape shape;
+
+        ClassCache(Shape shape, LazyPythonClass klass) {
+            this.shape = shape;
+            this.klass = klass;
+        }
+    }
+
+    private static final IsBuiltinClassProfile UNCACHED = new IsBuiltinClassProfile();
+    static {
+        UNCACHED.classCache = null;
+    }
+
     private IsBuiltinClassProfile() {
         // private constructor
     }
@@ -66,27 +98,64 @@ public static IsBuiltinClassProfile create() {
     }
 
     public static IsBuiltinClassProfile getUncached() {
-        return new IsBuiltinClassProfile();
+        return UNCACHED;
     }
 
-    public boolean profileIsAnyBuiltinException(PException object) {
-        return profileIsAnyBuiltinClass(object.getExceptionObject().getLazyPythonClass());
+    @ExplodeLoop(kind = LoopExplosionKind.FULL_EXPLODE_UNTIL_RETURN)
+    private LazyPythonClass getLazyPythonClass(PythonObject object) {
+        if (classCache != null) {
+            // we're still caching
+            if (!singleContextAssumption.isValid() && cacheUsedInSingleContext) {
+                // we previously used this cache in a single context, now we're
+                // in a multi-context mode. Reset the cache.
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                cacheUsedInSingleContext = false;
+                classCache = new ClassCache[CLASS_CACHE_SIZE];
+            }
+            for (int i = 0; i < classCache.length; i++) {
+                ClassCache cache = classCache[i];
+                if (cache == null) {
+                    CompilerDirectives.transferToInterpreterAndInvalidate();
+                    Shape shape = object.getStorage().getShape();
+                    LazyPythonClass klass = PythonObject.getLazyPythonClass(shape.getObjectType());
+                    if (klass instanceof PythonBuiltinClassType) {
+                        classCache[i] = new ClassCache(shape, klass);
+                    } else if (singleContextAssumption.isValid()) {
+                        // we're caching a non-builtin type, so if we switch to
+                        // a multi-context, the cache needs to be flushed.
+                        cacheUsedInSingleContext = true;
+                        classCache[i] = new ClassCache(shape, klass);
+                    } else {
+                        classCache = null;
+                    }
+                    return klass;
+                } else if (cache.shape == object.getStorage().getShape()) {
+                    return cache.klass;
+                }
+            }
+        }
+        if (classCache != null) {
+            // cache overflow, revert to generic access
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            classCache = null;
+        }
+        return object.getLazyPythonClass();
     }
 
     public boolean profileIsAnyBuiltinObject(PythonObject object) {
-        return profileIsAnyBuiltinClass(object.getLazyPythonClass());
+        return profileIsAnyBuiltinClass(getLazyPythonClass(object));
     }
 
     public boolean profileIsOtherBuiltinObject(PythonObject object, PythonBuiltinClassType type) {
-        return profileIsOtherBuiltinClass(object.getLazyPythonClass(), type);
+        return profileIsOtherBuiltinClass(getLazyPythonClass(object), type);
     }
 
     public boolean profileException(PException object, PythonBuiltinClassType type) {
-        return profileClass(object.getExceptionObject().getLazyPythonClass(), type);
+        return profileClass(getLazyPythonClass(object.getExceptionObject()), type);
     }
 
     public boolean profileObject(PythonObject object, PythonBuiltinClassType type) {
-        return profileClass(object.getLazyPythonClass(), type);
+        return profileClass(getLazyPythonClass(object), type);
 
     }