Limit inlining of builtins to avoid compilation bailouts for large

functions.

Author: fangerer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -160,10 +160,12 @@ protected void finalizeContext(PythonContext context) {
     protected boolean areOptionsCompatible(OptionValues firstOptions, OptionValues newOptions) {
         // internal sources were marked during context initialization
         return (firstOptions.get(PythonOptions.ExposeInternalSources).equals(newOptions.get(PythonOptions.ExposeInternalSources)) &&
-                        // we cache WithThread on the lanugage
+                        // we cache WithThread on the language
                         firstOptions.get(PythonOptions.WithThread).equals(newOptions.get(PythonOptions.WithThread)) &&
                         // we cache CatchAllExceptions hard on TryExceptNode
-                        firstOptions.get(PythonOptions.CatchAllExceptions).equals(newOptions.get(PythonOptions.CatchAllExceptions)));
+                        firstOptions.get(PythonOptions.CatchAllExceptions).equals(newOptions.get(PythonOptions.CatchAllExceptions)) &&
+                        // we cache BuiltinsInliningMaxCallerSize on the language
+                        firstOptions.get(PythonOptions.BuiltinsInliningMaxCallerSize).equals(newOptions.get(PythonOptions.BuiltinsInliningMaxCallerSize)));
     }
 
     private boolean areOptionsCompatibleWithPreinitializedContext(OptionValues firstOptions, OptionValues newOptions) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/CallSpecialMethodNode.java

@@ -55,64 +55,77 @@
 import com.oracle.graal.python.nodes.truffle.PythonTypes;
 import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.ReportPolymorphism;
 import com.oracle.truffle.api.dsl.TypeSystemReference;
 import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.nodes.NodeUtil;
 import com.oracle.truffle.api.nodes.RootNode;
 
 @TypeSystemReference(PythonTypes.class)
 @ImportStatic(PythonOptions.class)
 @ReportPolymorphism
 abstract class CallSpecialMethodNode extends Node {
+
     /**
      * Returns a new instanceof the builtin if it's a subclass of the given class, and null
      * otherwise.
      */
-    private static <T extends PythonBuiltinBaseNode> T getBuiltin(PBuiltinFunction func, Class<T> clazz) {
+    private <T extends PythonBuiltinBaseNode> T getBuiltin(PBuiltinFunction func, Class<T> clazz) {
+        CompilerAsserts.neverPartOfCompilation();
         NodeFactory<? extends PythonBuiltinBaseNode> builtinNodeFactory = func.getBuiltinNodeFactory();
-        if (builtinNodeFactory != null) {
+        if (builtinNodeFactory != null && !callerExceedsMaxSize()) {
             return clazz.isAssignableFrom(builtinNodeFactory.getNodeClass()) ? clazz.cast(func.getBuiltinNodeFactory().createNode()) : null;
         } else {
             return null;
         }
     }
 
+    private boolean callerExceedsMaxSize() {
+        CompilerAsserts.neverPartOfCompilation();
+        int n = NodeUtil.countNodes(getRootNode());
+        // nb: option 'BuiltinsInliningMaxCallerSize' is defined as a compatible option, i.e., ASTs
+        // will only we shared between contexts that have the same value for this option.
+        int maxSize = PythonOptions.getOption(lookupContextReference(PythonLanguage.class).get(), PythonOptions.BuiltinsInliningMaxCallerSize);
+        return n >= maxSize;
+    }
+
     protected Assumption singleContextAssumption() {
         return PythonLanguage.getCurrent().singleContextAssumption;
     }
 
-    protected static PythonUnaryBuiltinNode getUnary(Object func) {
+    PythonUnaryBuiltinNode getUnary(Object func) {
         if (func instanceof PBuiltinFunction) {
             return getBuiltin((PBuiltinFunction) func, PythonUnaryBuiltinNode.class);
         }
         return null;
     }
 
-    protected static PythonBinaryBuiltinNode getBinary(Object func) {
+    PythonBinaryBuiltinNode getBinary(Object func) {
         if (func instanceof PBuiltinFunction) {
             return getBuiltin((PBuiltinFunction) func, PythonBinaryBuiltinNode.class);
         }
         return null;
     }
 
-    protected static PythonTernaryBuiltinNode getTernary(Object func) {
+    PythonTernaryBuiltinNode getTernary(Object func) {
         if (func instanceof PBuiltinFunction) {
             return getBuiltin((PBuiltinFunction) func, PythonTernaryBuiltinNode.class);
         }
         return null;
     }
 
-    protected static PythonQuaternaryBuiltinNode getQuaternary(Object func) {
+    PythonQuaternaryBuiltinNode getQuaternary(Object func) {
         if (func instanceof PBuiltinFunction) {
             return getBuiltin((PBuiltinFunction) func, PythonQuaternaryBuiltinNode.class);
         }
         return null;
     }
 
-    protected static PythonVarargsBuiltinNode getVarargs(Object func) {
+    PythonVarargsBuiltinNode getVarargs(Object func) {
         if (func instanceof PBuiltinFunction) {
             return getBuiltin((PBuiltinFunction) func, PythonVarargsBuiltinNode.class);
         }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java

@@ -154,6 +154,9 @@ private PythonOptions() {
     @Option(category = OptionCategory.EXPERT, help = "Embedder option: what to print in response to PythonLanguage#toString.") //
     public static final OptionKey<Boolean> UseReprForPrintString = new OptionKey<>(true);
 
+    @Option(category = OptionCategory.EXPERT, help = "Stop inlining of builtins if caller's cumulative tree size would exceed this limit") //
+    public static final OptionKey<Integer> BuiltinsInliningMaxCallerSize = new OptionKey<>(2250);
+
     public static OptionDescriptors createDescriptors() {
         return new PythonOptionsOptionDescriptors();
     }