InliningData (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.phases.common.inlining.walker.InliningData

```
public class InliningData
extends Object
```
The space of inlining decisions is explored depth-first with the help of a stack realized by InliningData. At any point in time, the topmost element of that stack consists of:
- the callsite under consideration is tracked as a MethodInvocation.
- one or more CallsiteHolders, all of them associated to the callsite above. Why more than one? Depending on the type-profile for the receiver more than one concrete method may be feasible target.
The bottom element in the stack consists of:
- a single MethodInvocation (the root one, ie the unknown caller of the root graph)
- a single CallsiteHolder (the root one, for the method on which inlining was called)
See Also:

moveForward()

Field Summary

Fields
Modifier and Type	Field and Description
`private CanonicalizerPhase`	`canonicalizer`
`private HighTierContext`	`context`
`private ArrayDeque<CallsiteHolder>`	`graphQueue` Call hierarchy from outer most call (i.e., compilation unit) to inner most callee.
`private InliningPolicy`	`inliningPolicy`
`private ArrayDeque<MethodInvocation>`	`invocationQueue`
`private int`	`maxGraphs`
`private int`	`maxMethodPerInlining`
`private static DebugMetric`	`metricInliningConsidered`
`private static DebugMetric`	`metricInliningPerformed`
`private static DebugMetric`	`metricInliningRuns`
`private static Object[]`	`NO_CONTEXT`

Constructor Summary

Constructors
Constructor and Description
`InliningData(StructuredGraph rootGraph, HighTierContext context, int maxMethodPerInlining, CanonicalizerPhase canonicalizer, InliningPolicy inliningPolicy)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private boolean`	`checkTargetConditions(Invoke invoke, ResolvedJavaMethod method)`
`private String`	`checkTargetConditionsHelper(ResolvedJavaMethod method, int invokeBci)`
`private boolean`	`contains(StructuredGraph graph)`
`int`	`countRecursiveInlining(ResolvedJavaMethod method)`
`private CallsiteHolder`	`currentGraph()`
`private MethodInvocation`	`currentInvocation()`
`private void`	`doInline(CallsiteHolderExplorable callerCallsiteHolder, MethodInvocation calleeInvocation)`
`static BitSet`	`freshlyInstantiatedArguments(Invoke invoke, Set<ParameterNode> fixedParams)` Gets the freshly instantiated arguments.
`private InlineInfo`	`getAssumptionInlineInfo(Invoke invoke, ResolvedJavaMethod concrete, Assumptions.AssumptionResult<?> takenAssumption)`
`private InlineInfo`	`getExactInlineInfo(Invoke invoke, ResolvedJavaMethod targetMethod)`
`private InlineInfo`	`getInlineInfo(Invoke invoke)` Determines if inlining is possible at the given invoke node.
`private InlineInfo`	`getTypeCheckedInlineInfo(Invoke invoke, ResolvedJavaMethod targetMethod)`
`int`	`graphCount()`
`boolean`	`hasUnprocessedGraphs()`
`private Object[]`	`inliningContext()` Gets the call hierarchy of this inlining from outer most call to inner most callee.
`int`	`inliningDepth()`
`static boolean`	`isFreshInstantiation(ValueNode arg)`
`boolean`	`moveForward()` The stack realized by `InliningData` grows and shrinks as choices are made among the alternatives below: not worth inlining: pop stack top, which comprises: pop any remaining graphs not yet delved into pop the current invocation `delve` into one of the callsites hosted in the current graph, such callsite is explored next by `moveForward()` `try to inline`: move past the current graph (remove it from the topmost element).
`private static boolean`	`paramsAndInvokeAreInSameGraph(Invoke invoke, Set<ParameterNode> fixedParams)`
`private void`	`popGraph()`
`private void`	`popGraphs(int count)`
`private void`	`popInvocation()`
`private void`	`processNextInvoke()` This method picks one of the callsites belonging to the current `CallsiteHolderExplorable`.
`private void`	`pushInvocationAndGraphs(MethodInvocation methodInvocation)`
`boolean`	`repOK()` This method checks invariants for this class.
`private boolean`	`topGraphsForTopInvocation()` Checks an invariant that `moveForward()` must maintain: "the top invocation records how many concrete target methods (for it) remain on the `graphQueue`; those targets 'belong' to the current invocation in question.
`String`	`toString()`
`private boolean`	`tryToInline(MethodInvocation calleeInvocation, int inliningDepth)` This method attempts: to inline at the callsite given by `calleeInvocation`, where that callsite belongs to the `CallsiteHolderExplorable` at the top of the `graphQueue` maintained in this class. otherwise, to devirtualize the callsite in question.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - metricInliningPerformed
```
private static final DebugMetric metricInliningPerformed
```
  - metricInliningRuns
```
private static final DebugMetric metricInliningRuns
```
  - metricInliningConsidered
```
private static final DebugMetric metricInliningConsidered
```
  - graphQueue
```
private final ArrayDeque<CallsiteHolder> graphQueue
```
    Call hierarchy from outer most call (i.e., compilation unit) to inner most callee.
  - invocationQueue
```
private final ArrayDeque<MethodInvocation> invocationQueue
```
  - context
```
private final HighTierContext context
```
  - maxMethodPerInlining
```
private final int maxMethodPerInlining
```
  - canonicalizer
```
private final CanonicalizerPhase canonicalizer
```
  - inliningPolicy
```
private final InliningPolicy inliningPolicy
```
  - maxGraphs
```
private int maxGraphs
```
  - NO_CONTEXT
```
private static final Object[] NO_CONTEXT
```
- Constructor Detail
  - InliningData
```
public InliningData(StructuredGraph rootGraph,
                    HighTierContext context,
                    int maxMethodPerInlining,
                    CanonicalizerPhase canonicalizer,
                    InliningPolicy inliningPolicy)
```
- Method Detail
  - isFreshInstantiation
```
public static boolean isFreshInstantiation(ValueNode arg)
```
  - checkTargetConditionsHelper
```
private String checkTargetConditionsHelper(ResolvedJavaMethod method,
                                           int invokeBci)
```
  - checkTargetConditions
```
private boolean checkTargetConditions(Invoke invoke,
                                      ResolvedJavaMethod method)
```
  - getInlineInfo
```
private InlineInfo getInlineInfo(Invoke invoke)
```
    Determines if inlining is possible at the given invoke node.
    
    Parameters:
    
    invoke - the invoke that should be inlined
    
    Returns:
    
    an instance of InlineInfo, or null if no inlining is possible at the given invoke
  - getTypeCheckedInlineInfo
```
private InlineInfo getTypeCheckedInlineInfo(Invoke invoke,
                                            ResolvedJavaMethod targetMethod)
```
  - getAssumptionInlineInfo
```
private InlineInfo getAssumptionInlineInfo(Invoke invoke,
                                           ResolvedJavaMethod concrete,
                                           Assumptions.AssumptionResult<?> takenAssumption)
```
  - getExactInlineInfo
```
private InlineInfo getExactInlineInfo(Invoke invoke,
                                      ResolvedJavaMethod targetMethod)
```
  - doInline
```
private void doInline(CallsiteHolderExplorable callerCallsiteHolder,
                      MethodInvocation calleeInvocation)
```
  - tryToInline
```
private boolean tryToInline(MethodInvocation calleeInvocation,
                            int inliningDepth)
```
    This method attempts:
    1. to inline at the callsite given by calleeInvocation, where that callsite belongs to the CallsiteHolderExplorable at the top of the graphQueue maintained in this class.
    2. otherwise, to devirtualize the callsite in question.
    Returns:
    
    true iff inlining was actually performed
  - processNextInvoke
```
private void processNextInvoke()
```
    This method picks one of the callsites belonging to the current CallsiteHolderExplorable. Provided the callsite qualifies to be analyzed for inlining, this method prepares a new stack top in InliningData for such callsite, which comprises:
    - preparing a summary of feasible targets, ie preparing an InlineInfo
    - based on it, preparing the stack top proper which consists of:
    The thus prepared "stack top" is needed by moveForward() to explore the space of inlining decisions (each decision one of: backtracking, delving, inlining).
    
    The InlineInfo used to get things rolling is kept around in the MethodInvocation, it will be needed in case of inlining, see InlineInfo.inline(Providers)
  - freshlyInstantiatedArguments
```
public static BitSet freshlyInstantiatedArguments(Invoke invoke,
                                                  Set<ParameterNode> fixedParams)
```
    Gets the freshly instantiated arguments.
    A freshly instantiated argument is either:
    - an isFreshInstantiation(com.oracle.graal.nodes.ValueNode)
    - a fixed-param, ie a ParameterNode receiving a freshly instantiated argument
    Returns:
    
    the positions of freshly instantiated arguments in the argument list of the invoke, or null if no such positions exist.
  - paramsAndInvokeAreInSameGraph
```
private static boolean paramsAndInvokeAreInSameGraph(Invoke invoke,
                                                     Set<ParameterNode> fixedParams)
```
  - graphCount
```
public int graphCount()
```
  - hasUnprocessedGraphs
```
public boolean hasUnprocessedGraphs()
```
  - currentGraph
```
private CallsiteHolder currentGraph()
```
  - popGraph
```
private void popGraph()
```
  - popGraphs
```
private void popGraphs(int count)
```
  - inliningContext
```
private Object[] inliningContext()
```
    Gets the call hierarchy of this inlining from outer most call to inner most callee.
  - currentInvocation
```
private MethodInvocation currentInvocation()
```
  - pushInvocationAndGraphs
```
private void pushInvocationAndGraphs(MethodInvocation methodInvocation)
```
  - popInvocation
```
private void popInvocation()
```
  - countRecursiveInlining
```
public int countRecursiveInlining(ResolvedJavaMethod method)
```
  - inliningDepth
```
public int inliningDepth()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - contains
```
private boolean contains(StructuredGraph graph)
```
  - moveForward
```
public boolean moveForward()
```
    The stack realized by InliningData grows and shrinks as choices are made among the alternatives below:
    1. not worth inlining: pop stack top, which comprises:
      
      pop any remaining graphs not yet delved into
      
      pop the current invocation
    2. delve into one of the callsites hosted in the current graph, such callsite is explored next by moveForward()
    3. try to inline: move past the current graph (remove it from the topmost element).
      
      If that was the last one then try to inline the callsite under consideration (ie, the "current invocation").
      
      Whether inlining occurs or not, that callsite is removed from the top of InliningData .
    Some facts about the alternatives above:
    - the first step amounts to backtracking, the 2nd one to depth-search, and the 3rd one also involves backtracking (however possibly after inlining).
    - the choice of abandon-and-backtrack or delve-into depends on InliningPolicy.isWorthInlining(com.oracle.graal.nodes.spi.Replacements, com.oracle.graal.phases.common.inlining.walker.MethodInvocation, int, boolean) and InliningPolicy.continueInlining(com.oracle.graal.nodes.StructuredGraph).
    - the 3rd choice is picked whenever none of the previous choices are made
    Returns:
    
    true iff inlining was actually performed
  - topGraphsForTopInvocation
```
private boolean topGraphsForTopInvocation()
```
    Checks an invariant that moveForward() must maintain: "the top invocation records how many concrete target methods (for it) remain on the graphQueue; those targets 'belong' to the current invocation in question.
  - repOK
```
public boolean repOK()
```
    This method checks invariants for this class. Named after shorthand for "internal representation is ok".

Class InliningData

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

metricInliningPerformed

metricInliningRuns

metricInliningConsidered

graphQueue

invocationQueue

context

maxMethodPerInlining

canonicalizer

inliningPolicy

maxGraphs

NO_CONTEXT

Constructor Detail

InliningData

Method Detail

isFreshInstantiation

checkTargetConditionsHelper

checkTargetConditions

getInlineInfo

getTypeCheckedInlineInfo

getAssumptionInlineInfo

getExactInlineInfo

doInline

tryToInline

processNextInvoke

freshlyInstantiatedArguments

paramsAndInvokeAreInSameGraph

graphCount

hasUnprocessedGraphs

currentGraph

popGraph

popGraphs

inliningContext

currentInvocation

pushInvocationAndGraphs

popInvocation

countRecursiveInlining

inliningDepth

toString

contains

moveForward

topGraphsForTopInvocation

repOK