Improve uncached case and do another caching case on methods.

Author: fangerer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/function/PFunction.java

@@ -154,6 +154,10 @@ public PCode getCode() {
         return uncachedCode;
     }
 
+    public PCode getUncachedCode() {
+        return uncachedCode;
+    }
+
     public void setCode(PCode code) {
         codeStableAssumption.invalidate("code changed for function " + getName());
         this.code = this.uncachedCode = code;
@@ -173,6 +177,10 @@ public Object[] getDefaults() {
         return uncachedDefaultValues;
     }
 
+    public Object[] getUncachedDefaultValues() {
+        return uncachedDefaultValues;
+    }
+
     public void setDefaults(Object[] defaults) {
         this.defaultsStableAssumption.invalidate("defaults changed for function " + getName());
         this.defaultValues = this.uncachedDefaultValues = defaults;
@@ -188,6 +196,10 @@ public PKeyword[] getKwDefaults() {
         return uncachedKwDefaultValues;
     }
 
+    public PKeyword[] getUncachedKwDefaults() {
+        return uncachedKwDefaultValues;
+    }
+
     public void setKwDefaults(PKeyword[] defaults) {
         this.defaultsStableAssumption.invalidate("kw defaults changed for function " + getName());
         this.kwDefaultValues = this.uncachedKwDefaultValues = defaults;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/argument/CreateArgumentsNode.java

@@ -77,7 +77,6 @@ public static CreateArgumentsNode create() {
     }
 
     @Specialization(guards = {"isMethod(method)", "method == cachedMethod"}, limit = "getVariableArgumentInlineCacheLimit()")
-    @ExplodeLoop
     Object[] doMethodCached(PythonObject method, Object[] userArguments, PKeyword[] keywords,
                     @Cached("create()") CreateAndCheckArgumentsNode createAndCheckArgumentsNode,
                     @Cached("method") @SuppressWarnings("unused") PythonObject cachedMethod) {
@@ -93,8 +92,7 @@ Object[] doMethodCached(PythonObject method, Object[] userArguments, PKeyword[]
 
     @Specialization(guards = {"isMethod(method)", "getFunction(method) == cachedFunction",
                     "getSelf(method) == cachedSelf"}, limit = "getVariableArgumentInlineCacheLimit()", replaces = "doMethodCached")
-    @ExplodeLoop
-    Object[] doMethodFunctionCached(PythonObject method, Object[] userArguments, PKeyword[] keywords,
+    Object[] doMethodFunctionAndSelfCached(PythonObject method, Object[] userArguments, PKeyword[] keywords,
                     @Cached("create()") CreateAndCheckArgumentsNode createAndCheckArgumentsNode,
                     @Cached("getFunction(method)") @SuppressWarnings("unused") Object cachedFunction,
                     @Cached("getSelf(method)") Object cachedSelf) {
@@ -107,8 +105,21 @@ Object[] doMethodFunctionCached(PythonObject method, Object[] userArguments, PKe
         return createAndCheckArgumentsNode.execute(method, userArguments, keywords, arity, cachedSelf, defaults, kwdefaults, isMethodCall(cachedSelf));
     }
 
+    @Specialization(guards = {"isMethod(method)", "getFunction(method) == cachedFunction"}, limit = "getVariableArgumentInlineCacheLimit()", replaces = "doMethodFunctionAndSelfCached")
+    Object[] doMethodFunctionCached(PythonObject method, Object[] userArguments, PKeyword[] keywords,
+                    @Cached("create()") CreateAndCheckArgumentsNode createAndCheckArgumentsNode,
+                    @Cached("getFunction(method)") @SuppressWarnings("unused") Object cachedFunction) {
+
+        // We do not directly cache these objects because they are compilation final anyway and the
+        // getter check the appropriate assumptions.
+        Arity arity = getArity(cachedFunction);
+        Object[] defaults = getDefaults(cachedFunction);
+        PKeyword[] kwdefaults = getKwDefaults(cachedFunction);
+        Object self = getSelf(method);
+        return createAndCheckArgumentsNode.execute(method, userArguments, keywords, arity, self, defaults, kwdefaults, isMethodCall(self));
+    }
+
     @Specialization(guards = {"isFunction(callable)", "callable == cachedCallable"}, limit = "getVariableArgumentInlineCacheLimit()")
-    @ExplodeLoop
     Object[] doFunctionCached(PythonObject callable, Object[] userArguments, PKeyword[] keywords,
                     @Cached("create()") CreateAndCheckArgumentsNode createAndCheckArgumentsNode,
                     @Cached("callable") @SuppressWarnings("unused") PythonObject cachedCallable) {
@@ -121,17 +132,17 @@ Object[] doFunctionCached(PythonObject callable, Object[] userArguments, PKeywor
         return createAndCheckArgumentsNode.execute(callable, userArguments, keywords, arity, null, defaults, kwdefaults, false);
     }
 
-    @Specialization(replaces = {"doFunctionCached", "doMethodCached", "doMethodFunctionCached"})
+    @Specialization(replaces = {"doFunctionCached", "doMethodCached", "doMethodFunctionAndSelfCached", "doMethodFunctionCached"})
     Object[] uncached(PythonObject callable, Object[] userArguments, PKeyword[] keywords,
                     @Cached("create()") CreateAndCheckArgumentsNode createAndCheckArgumentsNode) {
 
         // mostly we will be calling proper functions directly here,
         // but sometimes also methods that have functions directly.
         // In all other cases, the arguments
 
-        Arity arity = getArity(callable);
-        Object[] defaults = getDefaults(callable);
-        PKeyword[] kwdefaults = getKwDefaults(callable);
+        Arity arity = getArityUncached(callable);
+        Object[] defaults = getDefaultsUncached(callable);
+        PKeyword[] kwdefaults = getKwDefaultsUncached(callable);
         Object self = getSelf(callable);
         boolean methodcall = !(self instanceof PythonModule);
 
@@ -560,6 +571,18 @@ public static FindKwDefaultNode create() {
         }
     }
 
+    protected static Arity getArityUncached(Object callable) {
+        return getProperty(callable, UncachedArityGetter.INSTANCE);
+    }
+
+    protected static Object[] getDefaultsUncached(Object callable) {
+        return getProperty(callable, UncachedDefaultsGetter.INSTANCE);
+    }
+
+    protected static PKeyword[] getKwDefaultsUncached(Object callable) {
+        return getProperty(callable, UncachedKwDefaultsGetter.INSTANCE);
+    }
+
     protected static Arity getArity(Object callable) {
         return getProperty(callable, ArityGetter.INSTANCE);
     }
@@ -670,6 +693,48 @@ public PKeyword[] fromPBuiltinFunction(PBuiltinFunction fun) {
         }
     }
 
+    private static final class UncachedArityGetter extends Getter<Arity> {
+        private static final UncachedArityGetter INSTANCE = new UncachedArityGetter();
+
+        @Override
+        public Arity fromPFunction(PFunction fun) {
+            return fun.getUncachedCode().getArity();
+        }
+
+        @Override
+        public Arity fromPBuiltinFunction(PBuiltinFunction fun) {
+            return fun.getArity();
+        }
+    }
+
+    private static final class UncachedDefaultsGetter extends Getter<Object[]> {
+        private static final UncachedDefaultsGetter INSTANCE = new UncachedDefaultsGetter();
+
+        @Override
+        public Object[] fromPFunction(PFunction fun) {
+            return fun.getUncachedDefaultValues();
+        }
+
+        @Override
+        public Object[] fromPBuiltinFunction(PBuiltinFunction fun) {
+            return fun.getDefaults();
+        }
+    }
+
+    private static final class UncachedKwDefaultsGetter extends Getter<PKeyword[]> {
+        private static final UncachedKwDefaultsGetter INSTANCE = new UncachedKwDefaultsGetter();
+
+        @Override
+        public PKeyword[] fromPFunction(PFunction fun) {
+            return fun.getUncachedKwDefaults();
+        }
+
+        @Override
+        public PKeyword[] fromPBuiltinFunction(PBuiltinFunction fun) {
+            return fun.getKwDefaults();
+        }
+    }
+
     private static final class NameGetter extends Getter<String> {
         private static final NameGetter INSTANCE = new NameGetter();