Place limit on size of functions inlined during reduction. (#95)

* Removed unused file.

* Added a limit to the size of functions that will be inlined during reduction, to limit size explosion.

Author: afd

ast/src/main/java/com/graphicsfuzz/common/ast/inliner/Inliner.java

@@ -39,6 +39,7 @@
 import com.graphicsfuzz.common.glslversion.ShadingLanguageVersion;
 import com.graphicsfuzz.common.typing.Typer;
 import com.graphicsfuzz.common.util.IdGenerator;
+import com.graphicsfuzz.common.util.StatsVisitor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -58,9 +59,11 @@ public static void inline(FunctionCallExpr functionCallExpr, TranslationUnit tu,
     new Inliner(functionCallExpr, tu, shadingLanguageVersion).doInline(idGenerator);
   }
 
-  public static boolean canInline(FunctionCallExpr functionCallExpr, TranslationUnit tu,
-        ShadingLanguageVersion shadingLanguageVersion) {
-    return new Inliner(functionCallExpr, tu, shadingLanguageVersion).canInline();
+  public static boolean canInline(FunctionCallExpr functionCallExpr,
+                                  TranslationUnit tu,
+                                  ShadingLanguageVersion shadingLanguageVersion,
+                                  int nodeLimit) {
+    return new Inliner(functionCallExpr, tu, shadingLanguageVersion).canInline(nodeLimit);
   }
 
   private Inliner(FunctionCallExpr call, TranslationUnit tu,
@@ -72,10 +75,11 @@ private Inliner(FunctionCallExpr call, TranslationUnit tu,
     this.parentMap = IParentMap.createParentMap(tu);
   }
 
-  private boolean canInline() {
+  private boolean canInline(int nodeLimit) {
     try {
-      getCloneWithReturnsRemoved(findMatchingFunctionForCall());
-      return true;
+      final FunctionDefinition inlinable =
+          getCloneWithReturnsRemoved(findMatchingFunctionForCall());
+      return nodeLimit == 0 || new StatsVisitor(inlinable).getNumNodes() <= nodeLimit;
     } catch (CannotInlineCallException exception) {
       return false;
     }

generator/src/main/java/com/graphicsfuzz/generator/transformation/mutator/BreakIntLiterals.java

@@ -29,6 +29,8 @@
 
 public class InlineFunctionReductionOpportunities extends StandardVisitor {
 
+  private static final int INLINE_NODE_LIMIT = 100; // Only inline relatively small functions
+
   private final List<InlineFunctionReductionOpportunity> opportunities;
   private final TranslationUnit tu;
   private final ReducerContext context;
@@ -62,7 +64,8 @@ private InlineFunctionReductionOpportunities(TranslationUnit tu,
   public void visitFunctionCallExpr(FunctionCallExpr functionCallExpr) {
     super.visitFunctionCallExpr(functionCallExpr);
     if (allowedToInline(functionCallExpr)
-          && Inliner.canInline(functionCallExpr, tu, context.getShadingLanguageVersion())) {
+          && Inliner.canInline(
+              functionCallExpr, tu, context.getShadingLanguageVersion(), INLINE_NODE_LIMIT)) {
       opportunities.add(new InlineFunctionReductionOpportunity(
             functionCallExpr,
             tu,

reducer/src/main/java/com/graphicsfuzz/reducer/reductionopportunities/InlineFunctionReductionOpportunities.java

@@ -53,7 +53,10 @@ void applyReductionImpl() {
 
   @Override
   public boolean preconditionHolds() {
-    return Inliner.canInline(functionCallExpr, tu, shadingLanguageVersion);
+    // We use a node limit of 0 (to say "no limit") because we already checked the limit on
+    // creation of this opportunity, and we're OK with the possibility that the limit might now
+    // be exceeded due to other transformations.
+    return Inliner.canInline(functionCallExpr, tu, shadingLanguageVersion, 0);
   }
 
 }

reducer/src/main/java/com/graphicsfuzz/reducer/reductionopportunities/InlineFunctionReductionOpportunity.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2018 The GraphicsFuzz Project Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.graphicsfuzz.reducer.reductionopportunities;
+
+import com.graphicsfuzz.common.ast.TranslationUnit;
+import com.graphicsfuzz.common.glslversion.ShadingLanguageVersion;
+import com.graphicsfuzz.common.transformreduce.ShaderJob;
+import com.graphicsfuzz.common.util.CompareAsts;
+import com.graphicsfuzz.common.util.IdGenerator;
+import com.graphicsfuzz.common.util.ParseHelper;
+import com.graphicsfuzz.common.util.RandomWrapper;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class InlineFunctionReductionOpportunitiesTest {
+
+  @Test
+  public void testBasicInline() throws Exception {
+
+    final String program = "int inlineme(int x) { int y = 2; return y + x; }" +
+        "void main() { int z = inlineme(5); }";
+
+    final String expected = "int inlineme(int x) { int y = 2; return y + x; }" +
+        "void main() { " +
+        " int inlineme_inline_return_value_0;" +
+        " {" +
+        "  int x = 5;" +
+        "  int y = 2;" +
+        "  inlineme_inline_return_value_0 = y + x;" +
+        " }" +
+        " int z = inlineme_inline_return_value_0;" +
+        "}";
+
+    final TranslationUnit tu = ParseHelper.parse(program);
+    final ShaderJob shaderJob = MakeShaderJobFromFragmentShader.make(tu);
+
+    final List<InlineFunctionReductionOpportunity> ops =
+        InlineFunctionReductionOpportunities.findOpportunities(shaderJob,
+        new ReducerContext(true,
+            ShadingLanguageVersion.ESSL_100, new RandomWrapper(0), new IdGenerator(), false));
+
+    assertEquals(1, ops.size());
+    ops.get(0).applyReduction();
+    CompareAsts.assertEqualAsts(expected, tu);
+  }
+
+  @Test
+  public void testTooLargeToInline() throws Exception {
+
+    final StringBuilder program = new StringBuilder();
+    program.append("int donotinlineme(int x) { int y = 2;");
+    for (int i = 0; i < 100; i++) {
+      program.append(" y = y + x;");
+    }
+    program.append("}");
+    program.append("void main() { int z = donotinlineme(5); }");
+
+    final TranslationUnit tu = ParseHelper.parse(program.toString());
+    final ShaderJob shaderJob = MakeShaderJobFromFragmentShader.make(tu);
+
+    final List<InlineFunctionReductionOpportunity> ops =
+        InlineFunctionReductionOpportunities.findOpportunities(shaderJob,
+            new ReducerContext(true,
+                ShadingLanguageVersion.ESSL_100, new RandomWrapper(0), new IdGenerator(), false));
+
+    assertEquals(0, ops.size());
+  }
+
+
+}