split ReadAttributeFromObjectNode into ReadAttributeFromObjectNode and ReadAttributeFromDynamicObjectNode

Author: cosminbasca

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java

@@ -680,7 +680,7 @@ Object doTpSubclasses(PythonClass object, @SuppressWarnings("unused") String key
         Object doMdDef(PythonObject object, @SuppressWarnings("unused") String key, Object value) {
             DynamicObjectNativeWrapper nativeWrapper = ((PythonAbstractObject) object).getNativeWrapper();
             assert nativeWrapper != null;
-            getSetItemNode().execute(nativeWrapper.createNativeMemberStore(object.getDictStableAssumption()), NativeMemberNames.MD_DEF, value);
+            getSetItemNode().execute(nativeWrapper.createNativeMemberStore(object.getDictUnsetOrSameAsStorageAssumption()), NativeMemberNames.MD_DEF, value);
             return value;
         }
 
@@ -701,7 +701,7 @@ Object doTpDict(PythonClass object, @SuppressWarnings("unused") String key, Obje
                 if (existing != null) {
                     d.setDictStorage(existing.getDictStorage());
                 } else {
-                    d.setDictStorage(new DynamicObjectStorage.PythonObjectDictStorage(object.getStorage(), object.getDictStableAssumption()));
+                    d.setDictStorage(new DynamicObjectStorage.PythonObjectDictStorage(object.getStorage(), object.getDictUnsetOrSameAsStorageAssumption()));
                 }
                 object.setDict(d);
             } else {

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

@@ -503,7 +503,7 @@ Object dict(PythonObject self, @SuppressWarnings("unused") PNone none) {
 
         @Specialization(guards = {"!isBuiltinObjectExact(self)", "!isClass(self)", "!isExactObjectInstance(self)"})
         Object dict(PythonObject self, PDict dict) {
-            self.getDictStableAssumption().invalidate();
+            self.getDictUnsetOrSameAsStorageAssumption().invalidate();
             self.setDict(dict);
             return PNone.NONE;
         }

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

@@ -50,7 +50,7 @@
 public class PythonObject extends PythonAbstractObject {
     @CompilationFinal private LazyPythonClass pythonClass;
     private final Assumption classStable = Truffle.getRuntime().createAssumption("class unchanged");
-    private final Assumption dictStable = Truffle.getRuntime().createAssumption("dict unchanged from instance attributes");
+    private final Assumption dictUnsetOrSameAsStorage = Truffle.getRuntime().createAssumption("dict unset or same as instance attributes");
     private final DynamicObject storage;
     private PHashingCollection dict;
 
@@ -104,8 +104,8 @@ public final Assumption getClassStableAssumption() {
         return classStable;
     }
 
-    public final Assumption getDictStableAssumption() {
-        return dictStable;
+    public final Assumption getDictUnsetOrSameAsStorageAssumption() {
+        return dictUnsetOrSameAsStorage;
     }
 
     public final DynamicObject getStorage() {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/attributes/ReadAttributeFromDynamicObjectNode.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2017, 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.nodes.attributes;
+
+import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.str.PString;
+import com.oracle.graal.python.nodes.PGuards;
+import com.oracle.graal.python.nodes.PNodeWithContext;
+import com.oracle.graal.python.runtime.PythonOptions;
+import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.ImportStatic;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.Location;
+import com.oracle.truffle.api.object.Property;
+import com.oracle.truffle.api.object.Shape;
+
+@ImportStatic({PGuards.class, PythonOptions.class})
+public abstract class ReadAttributeFromDynamicObjectNode extends PNodeWithContext {
+    public static ReadAttributeFromDynamicObjectNode create() {
+        return ReadAttributeFromDynamicObjectNodeGen.create();
+    }
+
+    public abstract Object execute(Object object, Object key);
+
+    protected static Location getLocationOrNull(Property prop) {
+        return prop == null ? null : prop.getLocation();
+    }
+
+    protected static boolean isNull(Object value) {
+        return value == null;
+    }
+
+    protected static Object readFinalValue(DynamicObject object, Location location) {
+        Object value = location.get(object);
+        return value == null ? PNone.NO_VALUE : value;
+    }
+
+    /*
+     * Includes "dynamicObject" as a parameter so that Truffle DSL sees this as a dynamic check.
+     */
+    protected static boolean checkShape(@SuppressWarnings("unused") DynamicObject dynamicObject, DynamicObject cachedObject, Shape cachedShape) {
+        return cachedObject.getShape() == cachedShape;
+    }
+
+    protected Object attrKey(Object key) {
+        if (key instanceof PString) {
+            return ((PString) key).getValue();
+        } else {
+            return key;
+        }
+    }
+
+    private static boolean assertFinal(DynamicObject dynamicObject, Object key, Object cachedValue) {
+        Object other = dynamicObject.get(key) == null ? PNone.NO_VALUE : dynamicObject.get(key);
+        return cachedValue == other || cachedValue instanceof Number && other instanceof Number && ((Number) cachedValue).doubleValue() == ((Number) other).doubleValue();
+    }
+
+    @SuppressWarnings("unused")
+    @Specialization(limit = "1", //
+                    guards = {
+                                    "dynamicObject == cachedDynamicObject",
+                                    "checkShape(dynamicObject, cachedDynamicObject, cachedShape)",
+                                    "key == cachedKey",
+                                    "!isNull(loc)",
+                                    "loc.isAssumedFinal()",
+                    }, //
+                    assumptions = {
+                                    "layoutAssumption",
+                                    "finalAssumption"
+                    })
+    protected Object readDirectFinal(DynamicObject dynamicObject, Object key,
+                    @Cached("dynamicObject") DynamicObject cachedDynamicObject,
+                    @Cached("key") Object cachedKey,
+                    @Cached("attrKey(key)") Object attrKey,
+                    @Cached("dynamicObject.getShape()") Shape cachedShape,
+                    @Cached("cachedShape.getValidAssumption()") Assumption layoutAssumption,
+                    @Cached("getLocationOrNull(cachedShape.getProperty(attrKey))") Location loc,
+                    @Cached("loc.getFinalAssumption()") Assumption finalAssumption,
+                    @Cached("readFinalValue(dynamicObject, loc)") Object cachedValue) {
+        assert assertFinal(dynamicObject, attrKey, cachedValue);
+        return cachedValue;
+    }
+
+    @SuppressWarnings("unused")
+    @Specialization(limit = "getIntOption(getContext(), AttributeAccessInlineCacheMaxDepth)", //
+                    guards = {
+                                    "dynamicObject.getShape() == cachedShape",
+                                    "key == cachedKey",
+                                    "isNull(loc) || !loc.isAssumedFinal()",
+                    }, //
+                    assumptions = {
+                                    "layoutAssumption"
+                    })
+    protected Object readDirect(DynamicObject dynamicObject, Object key,
+                    @Cached("key") Object cachedKey,
+                    @Cached("attrKey(cachedKey)") Object attrKey,
+                    @Cached("dynamicObject.getShape()") Shape cachedShape,
+                    @Cached("cachedShape.getValidAssumption()") Assumption layoutAssumption,
+                    @Cached("getLocationOrNull(cachedShape.getProperty(attrKey))") Location loc) {
+        if (loc == null) {
+            return PNone.NO_VALUE;
+        } else {
+            return loc.get(dynamicObject);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    @Specialization(guards = {
+                    "dynamicObject.getShape() == cachedShape",
+                    "!layoutAssumption.isValid()"
+    })
+    protected Object updateShapeAndRead(DynamicObject dynamicObject, Object key,
+                    @Cached("dynamicObject.getShape()") Shape cachedShape,
+                    @Cached("cachedShape.getValidAssumption()") Assumption layoutAssumption,
+                    @Cached("create()") ReadAttributeFromDynamicObjectNode nextNode) {
+        CompilerDirectives.transferToInterpreter();
+        dynamicObject.updateShape();
+        return nextNode.execute(dynamicObject, key);
+    }
+
+    @Specialization(replaces = "readDirect")
+    protected Object readIndirect(DynamicObject dynamicObject, Object key) {
+        Object value = dynamicObject.get(attrKey(key));
+        if (value == null) {
+            return PNone.NO_VALUE;
+        } else {
+            return value;
+        }
+    }
+}