store the class again also on the python object, and in multi-context case, not on the shape

Author: timfel

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

@@ -1497,7 +1497,7 @@ Object doObjectCachedInstanceShape(@SuppressWarnings("unused") PythonManagedClas
             if (varargs.length > 0 || kwargs.length > 0) {
                 // TODO: tfel: this should throw an error only if init isn't overridden
             }
-            return factory().createPythonObject(cachedInstanceShape);
+            return factory().createPythonObject(self, cachedInstanceShape);
         }
 
         @Specialization(guards = "!self.needsNativeAllocation()", replaces = "doObjectCachedInstanceShape")

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/object/ObjectBuiltins.java

@@ -93,6 +93,7 @@
 import com.oracle.graal.python.nodes.object.GetClassNode;
 import com.oracle.graal.python.nodes.object.GetLazyClassNode;
 import com.oracle.graal.python.nodes.object.IsBuiltinClassProfile;
+import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
@@ -142,6 +143,7 @@ LazyPythonClass setClass(@SuppressWarnings("unused") Object self, @SuppressWarni
 
         @Specialization
         PNone setClass(VirtualFrame frame, PythonObject self, PythonAbstractClass value,
+                        @Cached("singleContextAssumption()") Assumption singleContextAssumption,
                         @Cached("create()") BranchProfile errorValueBranch,
                         @Cached("create()") BranchProfile errorSelfBranch,
                         @Cached("create()") BranchProfile errorSlotsBranch,
@@ -163,7 +165,7 @@ PNone setClass(VirtualFrame frame, PythonObject self, PythonAbstractClass value,
                     throw raise(TypeError, "__class__ assignment: '%s' object layout differs from '%s'", getTypeName(value), getTypeName(lazyClass));
                 }
             }
-            self.setLazyPythonClass(value);
+            self.setLazyPythonClass(value, singleContextAssumption);
             return PNone.NONE;
         }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/object/PythonObject.java

@@ -37,6 +37,7 @@
 import com.oracle.graal.python.builtins.objects.type.PythonAbstractClass;
 import com.oracle.graal.python.builtins.objects.type.PythonManagedClass;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes;
+import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.object.DynamicObject;
@@ -47,16 +48,20 @@
 import com.oracle.truffle.api.object.dsl.Nullable;
 
 public class PythonObject extends PythonAbstractObject {
+    private LazyPythonClass storedPythonClass;
     private final DynamicObject storage;
 
     public PythonObject(LazyPythonClass pythonClass) {
         assert pythonClass != null : getClass().getSimpleName();
-        storage = TypeNodes.GetInstanceShape.doSlowPath(pythonClass).newInstance();
+        this.storedPythonClass = pythonClass;
+        this.storage = TypeNodes.GetInstanceShape.doSlowPath(pythonClass).newInstance();
         assert getLazyPythonClass() == pythonClass;
     }
 
-    public PythonObject(Shape instanceShape) {
-        storage = instanceShape.newInstance();
+    public PythonObject(LazyPythonClass pythonClass, Shape instanceShape) {
+        assert pythonClass != null;
+        this.storedPythonClass = pythonClass;
+        this.storage = instanceShape.newInstance();
     }
 
     public final PythonAbstractClass getPythonClass() {
@@ -69,15 +74,25 @@ public final PythonAbstractClass getPythonClass() {
         }
     }
 
-    public final void setLazyPythonClass(PythonAbstractClass cls) {
-        PythonObjectLayoutImpl.INSTANCE.setLazyPythonClass(storage, cls);
+    public final void setLazyPythonClass(PythonAbstractClass cls, Assumption storingClassesInShapes) {
+        storedPythonClass = cls;
+        if (storingClassesInShapes.isValid()) {
+            PythonObjectLayoutImpl.INSTANCE.setLazyPythonClass(storage, cls);
+        } else {
+            if (PythonObjectLayoutImpl.INSTANCE.getLazyPythonClass(storage) != null) {
+                // for the builtin class enums, we now should change the shape
+                // to the generic one that just doesn't store the class
+                Shape shape = storage.getShape();
+                storage.setShapeAndGrow(shape, shape.changeType(emptyShape.getObjectType()));
+            }
+        }
     }
 
     /**
      * This is usually final, a fact may be optimized further if the storage turns into a constant.
      */
     public final LazyPythonClass getLazyPythonClass() {
-        return PythonObjectLayoutImpl.INSTANCE.getLazyPythonClass(storage);
+        return storedPythonClass;
     }
 
     public final DynamicObject getStorage() {
@@ -132,7 +147,7 @@ public String toString() {
     }
 
     /**
-     * Returns the dictionary backed by {@link #storage} (only available for user objects).
+     * Returns the dictionary (only available for user objects).
      */
     public final PHashingCollection getDict() {
         return PythonObjectLayoutImpl.INSTANCE.getDict(storage);
@@ -161,10 +176,17 @@ protected static interface PythonObjectLayout {
         void setLazyPythonClass(DynamicObject object, LazyPythonClass value);
     }
 
+    private static final Shape emptyShape = PythonObjectLayoutImpl.INSTANCE.createPythonObjectShape(null).getShape();
+
     public static Shape freshShape(LazyPythonClass klass) {
+        assert (PythonLanguage.getCurrent().singleContextAssumption.isValid() && klass != null) || klass instanceof PythonBuiltinClassType;
         return PythonObjectLayoutImpl.INSTANCE.createPythonObjectShape(klass).getShape();
     }
 
+    public static Shape freshShape() {
+        return emptyShape;
+    }
+
     public static LazyPythonClass getLazyPythonClass(ObjectType type) {
         return PythonObjectLayoutImpl.INSTANCE.getLazyPythonClass(type);
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/PythonManagedClass.java

@@ -33,6 +33,7 @@
 import java.util.Set;
 import java.util.WeakHashMap;
 
+import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.cext.PythonClassNativeWrapper;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
@@ -64,7 +65,7 @@ public abstract class PythonManagedClass extends PythonObject implements PythonA
 
     @TruffleBoundary
     public PythonManagedClass(LazyPythonClass typeClass, String name, PythonAbstractClass... baseClasses) {
-        super(PythonObject.freshShape(typeClass) /* do not inherit layout from the */);
+        super(typeClass);
         this.className = name;
 
         this.methodResolutionOrder = new MroSequenceStorage(name, 0);
@@ -85,7 +86,11 @@ public PythonManagedClass(LazyPythonClass typeClass, String name, PythonAbstract
         setAttribute(__QUALNAME__, className);
         setAttribute(__DOC__, PNone.NONE);
         // provide our instances with a fresh shape tree
-        this.instanceShape = PythonObject.freshShape(this);
+        if (PythonLanguage.getCurrent().singleContextAssumption.isValid()) {
+            this.instanceShape = PythonObject.freshShape(this);
+        } else {
+            this.instanceShape = PythonObject.freshShape();
+        }
     }
 
     private static String getBaseName(String qname) {

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

@@ -191,8 +191,8 @@ public PythonObject createPythonObject(LazyPythonClass cls) {
      * Creates a Python object with the given shape. Python object shapes store the class in the
      * ObjectType.
      */
-    public PythonObject createPythonObject(Shape instanceShape) {
-        return trace(new PythonObject(instanceShape));
+    public PythonObject createPythonObject(LazyPythonClass klass, Shape instanceShape) {
+        return trace(new PythonObject(klass, instanceShape));
     }
 
     public PythonNativeObject createNativeObjectWrapper(TruffleObject obj) {