src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/inlining/walker/InliningData.java

*** 33,46 ****
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.graalvm.compiler.core.common.type.ObjectStamp;
! import org.graalvm.compiler.debug.Debug;
! import org.graalvm.compiler.debug.DebugCounter;
  import org.graalvm.compiler.debug.GraalError;
- import org.graalvm.compiler.debug.internal.method.MethodMetricsInlineeScopeInfo;
  import org.graalvm.compiler.graph.Graph;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.nodes.CallTargetNode;
  import org.graalvm.compiler.nodes.Invoke;
  import org.graalvm.compiler.nodes.ParameterNode;
--- 33,45 ----
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.graalvm.compiler.core.common.type.ObjectStamp;
! import org.graalvm.compiler.debug.CounterKey;
! import org.graalvm.compiler.debug.DebugContext;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Graph;
  import org.graalvm.compiler.graph.Node;
  import org.graalvm.compiler.nodes.CallTargetNode;
  import org.graalvm.compiler.nodes.Invoke;
  import org.graalvm.compiler.nodes.ParameterNode;
*** 99,111 ****
   * @see #moveForward()
   */
  public class InliningData {
  
      // Counters
!     private static final DebugCounter counterInliningPerformed = Debug.counter("InliningPerformed");
!     private static final DebugCounter counterInliningRuns = Debug.counter("InliningRuns");
!     private static final DebugCounter counterInliningConsidered = Debug.counter("InliningConsidered");
  
      /**
       * Call hierarchy from outer most call (i.e., compilation unit) to inner most callee.
       */
      private final ArrayDeque<CallsiteHolder> graphQueue = new ArrayDeque<>();
--- 98,110 ----
   * @see #moveForward()
   */
  public class InliningData {
  
      // Counters
!     private static final CounterKey counterInliningPerformed = DebugContext.counter("InliningPerformed");
!     private static final CounterKey counterInliningRuns = DebugContext.counter("InliningRuns");
!     private static final CounterKey counterInliningConsidered = DebugContext.counter("InliningConsidered");
  
      /**
       * Call hierarchy from outer most call (i.e., compilation unit) to inner most callee.
       */
      private final ArrayDeque<CallsiteHolder> graphQueue = new ArrayDeque<>();
*** 114,123 ****
--- 113,123 ----
      private final HighTierContext context;
      private final int maxMethodPerInlining;
      private final CanonicalizerPhase canonicalizer;
      private final InliningPolicy inliningPolicy;
      private final StructuredGraph rootGraph;
+     private final DebugContext debug;
  
      private int maxGraphs;
  
      public InliningData(StructuredGraph rootGraph, HighTierContext context, int maxMethodPerInlining, CanonicalizerPhase canonicalizer, InliningPolicy inliningPolicy, LinkedList<Invoke> rootInvokes) {
          assert rootGraph != null;
*** 125,134 ****
--- 125,135 ----
          this.maxMethodPerInlining = maxMethodPerInlining;
          this.canonicalizer = canonicalizer;
          this.inliningPolicy = inliningPolicy;
          this.maxGraphs = 1;
          this.rootGraph = rootGraph;
+         this.debug = rootGraph.getDebug();
  
          invocationQueue.push(new MethodInvocation(null, 1.0, 1.0, null));
          graphQueue.push(new CallsiteHolderExplorable(rootGraph, 1.0, 1.0, null, rootInvokes));
      }
  
*** 393,410 ****
      @SuppressWarnings("try")
      private void doInline(CallsiteHolderExplorable callerCallsiteHolder, MethodInvocation calleeInvocation) {
          StructuredGraph callerGraph = callerCallsiteHolder.graph();
          InlineInfo calleeInfo = calleeInvocation.callee();
          try {
!             OptionValues options = rootGraph.getOptions();
!             try (Debug.Scope scope = Debug.scope("doInline", callerGraph); Debug.Scope s = Debug.methodMetricsScope("InlineEnhancement", MethodMetricsInlineeScopeInfo.create(options), false)) {
                  EconomicSet<Node> canonicalizedNodes = EconomicSet.create(Equivalence.IDENTITY);
                  canonicalizedNodes.addAll(calleeInfo.invoke().asNode().usages());
                  EconomicSet<Node> parameterUsages = calleeInfo.inline(new Providers(context));
                  canonicalizedNodes.addAll(parameterUsages);
!                 counterInliningRuns.increment();
!                 Debug.dump(Debug.DETAILED_LEVEL, callerGraph, "after %s", calleeInfo);
  
                  Graph.Mark markBeforeCanonicalization = callerGraph.getMark();
  
                  canonicalizer.applyIncremental(callerGraph, context, canonicalizedNodes);
  
--- 394,410 ----
      @SuppressWarnings("try")
      private void doInline(CallsiteHolderExplorable callerCallsiteHolder, MethodInvocation calleeInvocation) {
          StructuredGraph callerGraph = callerCallsiteHolder.graph();
          InlineInfo calleeInfo = calleeInvocation.callee();
          try {
!             try (DebugContext.Scope scope = debug.scope("doInline", callerGraph)) {
                  EconomicSet<Node> canonicalizedNodes = EconomicSet.create(Equivalence.IDENTITY);
                  canonicalizedNodes.addAll(calleeInfo.invoke().asNode().usages());
                  EconomicSet<Node> parameterUsages = calleeInfo.inline(new Providers(context));
                  canonicalizedNodes.addAll(parameterUsages);
!                 counterInliningRuns.increment(debug);
!                 debug.dump(DebugContext.DETAILED_LEVEL, callerGraph, "after %s", calleeInfo);
  
                  Graph.Mark markBeforeCanonicalization = callerGraph.getMark();
  
                  canonicalizer.applyIncremental(callerGraph, context, canonicalizedNodes);
  
*** 415,434 ****
                      }
                  }
  
                  callerCallsiteHolder.computeProbabilities();
  
!                 counterInliningPerformed.increment();
              }
          } catch (BailoutException bailout) {
              throw bailout;
          } catch (AssertionError | RuntimeException e) {
              throw new GraalError(e).addContext(calleeInfo.toString());
          } catch (GraalError e) {
              throw e.addContext(calleeInfo.toString());
          } catch (Throwable e) {
!             throw Debug.handle(e);
          }
      }
  
      /**
       *
--- 415,434 ----
                      }
                  }
  
                  callerCallsiteHolder.computeProbabilities();
  
!                 counterInliningPerformed.increment(debug);
              }
          } catch (BailoutException bailout) {
              throw bailout;
          } catch (AssertionError | RuntimeException e) {
              throw new GraalError(e).addContext(calleeInfo.toString());
          } catch (GraalError e) {
              throw e.addContext(calleeInfo.toString());
          } catch (Throwable e) {
!             throw debug.handle(e);
          }
      }
  
      /**
       *
*** 444,454 ****
       */
      private boolean tryToInline(MethodInvocation calleeInvocation, int inliningDepth) {
          CallsiteHolderExplorable callerCallsiteHolder = (CallsiteHolderExplorable) currentGraph();
          InlineInfo calleeInfo = calleeInvocation.callee();
          assert callerCallsiteHolder.containsInvoke(calleeInfo.invoke());
!         counterInliningConsidered.increment();
  
          if (inliningPolicy.isWorthInlining(context.getReplacements(), calleeInvocation, inliningDepth, true)) {
              doInline(callerCallsiteHolder, calleeInvocation);
              return true;
          }
--- 444,454 ----
       */
      private boolean tryToInline(MethodInvocation calleeInvocation, int inliningDepth) {
          CallsiteHolderExplorable callerCallsiteHolder = (CallsiteHolderExplorable) currentGraph();
          InlineInfo calleeInfo = calleeInvocation.callee();
          assert callerCallsiteHolder.containsInvoke(calleeInfo.invoke());
!         counterInliningConsidered.increment(debug);
  
          if (inliningPolicy.isWorthInlining(context.getReplacements(), calleeInvocation, inliningDepth, true)) {
              doInline(callerCallsiteHolder, calleeInvocation);
              return true;
          }
*** 570,580 ****
  
      /**
       * Gets the call hierarchy of this inlining from outer most call to inner most callee.
       */
      private Object[] inliningContext() {
!         if (!Debug.isDumpEnabled(Debug.INFO_LEVEL)) {
              return NO_CONTEXT;
          }
          Object[] result = new Object[graphQueue.size()];
          int i = 0;
          for (CallsiteHolder g : graphQueue) {
--- 570,580 ----
  
      /**
       * Gets the call hierarchy of this inlining from outer most call to inner most callee.
       */
      private Object[] inliningContext() {
!         if (!debug.isDumpEnabled(DebugContext.INFO_LEVEL)) {
              return NO_CONTEXT;
          }
          Object[] result = new Object[graphQueue.size()];
          int i = 0;
          for (CallsiteHolder g : graphQueue) {
*** 735,752 ****
              /*
               * "all of currentInvocation's graphs processed" amounts to
               * "all concrete methods that come into question already had the callees they contain analyzed for inlining"
               */
              popInvocation();
!             try (Debug.Scope s = Debug.scope("Inlining", inliningContext())) {
                  if (tryToInline(currentInvocation, inliningDepth() + 1)) {
                      // Report real progress only if we inline into the root graph
                      return currentGraph().graph() == rootGraph;
                  }
                  return false;
              } catch (Throwable e) {
!                 throw Debug.handle(e);
              }
          }
  
          return false;
      }
--- 735,752 ----
              /*
               * "all of currentInvocation's graphs processed" amounts to
               * "all concrete methods that come into question already had the callees they contain analyzed for inlining"
               */
              popInvocation();
!             try (DebugContext.Scope s = debug.scope("Inlining", inliningContext())) {
                  if (tryToInline(currentInvocation, inliningDepth() + 1)) {
                      // Report real progress only if we inline into the root graph
                      return currentGraph().graph() == rootGraph;
                  }
                  return false;
              } catch (Throwable e) {
!                 throw debug.handle(e);
              }
          }
  
          return false;
      }