Graph

java.lang.Object
- org.graalvm.compiler.graph.Graph

Direct Known Subclasses:

CallTree, StructuredGraph
```
public class Graph
extends Object
```
This class is a graph container, it contains the set of nodes that belong to this graph.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Graph.DuplicationReplacement`
`static class`	`Graph.Mark` A snapshot of the live node count in a graph.
`static class`	`Graph.NodeEvent` The type of events sent to a `Graph.NodeEventListener`.
`static class`	`Graph.NodeEventListener` Client interested in one or more node related events.
`class`	`Graph.NodeEventScope` Registers a given `Graph.NodeEventListener` with the enclosing graph until this object is closed.
`static class`	`Graph.Options`

Field Summary

Fields
Modifier and Type	Field and Description
`String`	`name`
`protected boolean`	`trackNodeSourcePosition` Records if updating of node source information is required when performing inlining.
`boolean`	`verifyGraphEdges`
`boolean`	`verifyGraphs` Cached actual value of the `Graph.Options` to avoid expensive map lookup for every time a node / graph is verified.

Constructor Summary

Constructors
Constructor and Description
`Graph(OptionValues options, DebugContext debug)` Creates an empty Graph with no name.
`Graph(String name, OptionValues options, DebugContext debug, boolean trackNodeSourcePosition)` Creates an empty Graph with a given name.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends Node> T`	`add(T node)` Adds a new node to the graph.
`org.graalvm.collections.EconomicMap<Node,Node>`	`addDuplicates(Iterable<? extends Node> newNodes, Graph oldGraph, int estimatedNodeCount, org.graalvm.collections.EconomicMap<Node,Node> replacementsMap)` Adds duplicates of the nodes in `newNodes` to this graph.
`org.graalvm.collections.EconomicMap<Node,Node>`	`addDuplicates(Iterable<? extends Node> newNodes, Graph oldGraph, int estimatedNodeCount, Graph.DuplicationReplacement replacements)`
`<T extends Node> T`	`addOrUnique(T node)`
`<T extends Node> T`	`addOrUniqueWithInputs(T node)`
`<T extends Node> T`	`addWithoutUnique(T node)`
`<T extends Node> T`	`addWithoutUniqueWithInputs(T node)`
`void`	`afterDecodingFields(Node node)` Notifies node event listeners registered with this graph that `node` has been created as part of decoding a graph and its fields have now been initialized.
`protected void`	`afterNodeIdChange(Node node, Object value)`
`protected void`	`afterRegister(Node node)`
`void`	`beforeDecodingFields(Node node)` Notifies node event listeners registered with this graph that `node` has been created as part of decoding a graph but its fields have yet to be initialized.
`void`	`beforeNodeDuplication(Graph sourceGraph)` This is called before nodes are transferred to `sourceGraph` by `NodeClass.addGraphDuplicate(org.graalvm.compiler.graph.Graph, org.graalvm.compiler.graph.Graph, int, java.lang.Iterable<? extends org.graalvm.compiler.graph.Node>, org.graalvm.compiler.graph.Graph.DuplicationReplacement)` to allow the transfer of any other state which should also be transferred.
`protected Object`	`beforeNodeIdChange(Node node)`
`protected boolean`	`compress(boolean minimizeSize)`
`Graph`	`copy(Consumer<org.graalvm.collections.UnmodifiableEconomicMap<Node,Node>> duplicationMapCallback, DebugContext debugForCopy)` Creates a copy of this graph.
`Graph`	`copy(DebugContext debugForCopy)` Creates a copy of this graph.
`protected Graph`	`copy(String newName, Consumer<org.graalvm.collections.UnmodifiableEconomicMap<Node,Node>> duplicationMapCallback, DebugContext debugForCopy)` Creates a copy of this graph.
`Graph`	`copy(String newName, DebugContext debugForCopy)` Creates a copy of this graph.
`NodeWorkList`	`createIterativeNodeWorkList(boolean fill, int iterationLimitPerNode)`
`NodeBitMap`	`createNodeBitMap()`
`NodeFlood`	`createNodeFlood()`
`<T> NodeMap<T>`	`createNodeMap()`
`NodeWorkList`	`createNodeWorkList()`
`NodeSourcePosition`	`currentNodeSourcePosition()`
`<T extends Node> T`	`findDuplicate(T node)` Returns a possible duplicate for the given node in the graph or `null` if no such duplicate exists.
`void`	`freeze()`
`int`	`getCompressions()` Gets the number of times this graph has been compressed.
`DebugContext`	`getDebug()`
`void`	`getDebugProperties(Map<Object,Object> properties)` Add any per graph properties that might be useful for debugging (e.g., to view in the ideal graph visualizer).
`int`	`getEdgeModificationCount()`
`Graph.Mark`	`getMark()` Gets a mark that can be used with `Graph.getNewNodes(org.graalvm.compiler.graph.Graph.Mark)`.
`NodeIterable<Node>`	`getNewNodes(Graph.Mark mark)` Returns an `Iterable` providing all nodes added since the last `mark`.
`Node`	`getNode(int id)`
`int`	`getNodeCount()` Gets the number of live nodes in this graph.
`NodeIterable<Node>`	`getNodes()` Returns an `Iterable` providing all the live nodes.
`<T extends Node & IterableNodeType> NodeIterable<T>`	`getNodes(NodeClass<T> nodeClass)` Returns an `Iterable` providing all the live nodes whose type is compatible with `type`.
`int`	`getNodesDeletedSinceLastCompression()` Gets the number of nodes which have been deleted from this graph since it was last compressed.
`OptionValues`	`getOptions()`
`int`	`getTotalNodesDeleted()` Gets the total number of nodes which have been deleted from this graph.
`<T extends Node & IterableNodeType> boolean`	`hasNode(NodeClass<T> type)` Returns whether the graph contains at least one node of the given type.
`boolean`	`isFrozen()`
`boolean`	`isNew(Graph.Mark mark, Node node)`
`static boolean`	`isNodeModificationCountsEnabled()` We only want the expensive modification count tracking when assertions are enabled for the `Graph` class.
`boolean`	`maybeCompress()` If the compression threshold is met, the list of nodes is compressed such that all non-null entries precede all null entries while preserving the ordering between the nodes within the list.
`void`	`minimizeSize()` Minimize the memory occupied by the graph by trimming all node arrays to the minimum size.
`int`	`nodeIdCount()` Returns the number of node ids generated so far.
`void`	`resetDebug(DebugContext newDebug)` Resets the `DebugContext` for this graph to a new value.
`void`	`setTrackNodeSourcePosition()`
`void`	`temporaryFreeze()`
`String`	`toString()`
`Graph.NodeEventScope`	`trackNodeEvents(Graph.NodeEventListener listener)` Registers a given `Graph.NodeEventListener` with this graph.
`boolean`	`trackNodeSourcePosition()`
`static boolean`	`trackNodeSourcePositionDefault(OptionValues options, DebugContext debug)`
`void`	`unfreeze()`
`<T extends Node & Node.ValueNumberable> T`	`unique(T node)` Looks for a node similar to `node` and returns it if found.
`boolean`	`verify()`
`boolean`	`verifySourcePositions(boolean performConsistencyCheck)`
`DebugCloseable`	`withNodeSourcePosition(Node node)` Opens a scope in which the source information from `node` is copied into nodes created within the scope.
`DebugCloseable`	`withNodeSourcePosition(NodeSourcePosition sourcePosition)` Opens a scope in which `sourcePosition` is copied into nodes created within the scope.
`DebugCloseable`	`withoutNodeSourcePosition()` Opens a scope in which newly created nodes do not get any source information added.

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

- Field Detail
  - name
```
public final String name
```
  - verifyGraphs
```
public final boolean verifyGraphs
```
    Cached actual value of the Graph.Options to avoid expensive map lookup for every time a node / graph is verified.
  - verifyGraphEdges
```
public final boolean verifyGraphEdges
```
  - trackNodeSourcePosition
```
protected boolean trackNodeSourcePosition
```
    Records if updating of node source information is required when performing inlining.
- Constructor Detail
  - Graph
```
public Graph(OptionValues options,
             DebugContext debug)
```
    Creates an empty Graph with no name.
  - Graph
```
public Graph(String name,
             OptionValues options,
             DebugContext debug,
             boolean trackNodeSourcePosition)
```
    Creates an empty Graph with a given name.
    
    Parameters:
    
    name - the name of the graph, used for debugging purposes
- Method Detail
  - currentNodeSourcePosition
```
public NodeSourcePosition currentNodeSourcePosition()
```
  - withNodeSourcePosition
```
public DebugCloseable withNodeSourcePosition(Node node)
```
    Opens a scope in which the source information from node is copied into nodes created within the scope. If node has no source information information, no scope is opened and null is returned.
    
    Returns:
    
    a DebugCloseable for managing the opened scope or null if no scope was opened
  - withNodeSourcePosition
```
public DebugCloseable withNodeSourcePosition(NodeSourcePosition sourcePosition)
```
    Opens a scope in which sourcePosition is copied into nodes created within the scope. If sourcePosition == null, no scope is opened and null is returned.
    
    Returns:
    
    a DebugCloseable for managing the opened scope or null if no scope was opened
  - withoutNodeSourcePosition
```
public DebugCloseable withoutNodeSourcePosition()
```
    Opens a scope in which newly created nodes do not get any source information added.
    
    Returns:
    
    a DebugCloseable for managing the opened scope
  - trackNodeSourcePosition
```
public boolean trackNodeSourcePosition()
```
  - setTrackNodeSourcePosition
```
public void setTrackNodeSourcePosition()
```
  - trackNodeSourcePositionDefault
```
public static boolean trackNodeSourcePositionDefault(OptionValues options,
                                                     DebugContext debug)
```
  - getDebugProperties
```
public void getDebugProperties(Map<Object,Object> properties)
```
    Add any per graph properties that might be useful for debugging (e.g., to view in the ideal graph visualizer).
  - beforeNodeDuplication
```
public void beforeNodeDuplication(Graph sourceGraph)
```
    This is called before nodes are transferred to sourceGraph by NodeClass.addGraphDuplicate(org.graalvm.compiler.graph.Graph, org.graalvm.compiler.graph.Graph, int, java.lang.Iterable<? extends org.graalvm.compiler.graph.Node>, org.graalvm.compiler.graph.Graph.DuplicationReplacement) to allow the transfer of any other state which should also be transferred.
    
    Parameters:
    
    sourceGraph - the source of the nodes that were duplicated
  - isNodeModificationCountsEnabled
```
public static boolean isNodeModificationCountsEnabled()
```
    We only want the expensive modification count tracking when assertions are enabled for the Graph class.
  - getEdgeModificationCount
```
public int getEdgeModificationCount()
```
  - copy
```
public final Graph copy(DebugContext debugForCopy)
```
    Creates a copy of this graph.
    
    Parameters:
    
    debugForCopy - the debug context for the graph copy. This must not be the debug for this graph if this graph can be accessed from multiple threads (e.g., it's in a cache accessed by multiple threads).
  - copy
```
public final Graph copy(Consumer<org.graalvm.collections.UnmodifiableEconomicMap<Node,Node>> duplicationMapCallback,
                        DebugContext debugForCopy)
```
    Creates a copy of this graph.
    
    Parameters:
    
    duplicationMapCallback - consumer of the duplication map created during the copying
    
    debugForCopy - the debug context for the graph copy. This must not be the debug for this graph if this graph can be accessed from multiple threads (e.g., it's in a cache accessed by multiple threads).
  - copy
```
public final Graph copy(String newName,
                        DebugContext debugForCopy)
```
    Creates a copy of this graph.
    
    Parameters:
    
    newName - the name of the copy, used for debugging purposes (can be null)
    
    debugForCopy - the debug context for the graph copy. This must not be the debug for this graph if this graph can be accessed from multiple threads (e.g., it's in a cache accessed by multiple threads).
  - copy
```
protected Graph copy(String newName,
                     Consumer<org.graalvm.collections.UnmodifiableEconomicMap<Node,Node>> duplicationMapCallback,
                     DebugContext debugForCopy)
```
    Creates a copy of this graph.
    
    Parameters:
    
    newName - the name of the copy, used for debugging purposes (can be null)
    
    duplicationMapCallback - consumer of the duplication map created during the copying
    
    debugForCopy - the debug context for the graph copy. This must not be the debug for this graph if this graph can be accessed from multiple threads (e.g., it's in a cache accessed by multiple threads).
  - getOptions
```
public final OptionValues getOptions()
```
  - getDebug
```
public DebugContext getDebug()
```
  - resetDebug
```
public void resetDebug(DebugContext newDebug)
```
    Resets the DebugContext for this graph to a new value. This is useful when a graph is "handed over" from its creating thread to another thread. This must only be done when the current thread is no longer using the graph. This is in general impossible to test due to races and since metrics can be updated at any time. As such, this method only performs a weak sanity check that at least the current debug context does not have a nested scope open (the top level scope will always be open if scopes are enabled).
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getNodeCount
```
public int getNodeCount()
```
    Gets the number of live nodes in this graph. That is the number of nodes which have been added to the graph minus the number of deleted nodes.
    
    Returns:
    
    the number of live nodes in this graph
  - getCompressions
```
public int getCompressions()
```
    Gets the number of times this graph has been compressed. Node identifiers are only stable between compressions. To ensure this constraint is observed, any entity relying upon stable node identifiers should use NodeIdAccessor.
  - getNodesDeletedSinceLastCompression
```
public int getNodesDeletedSinceLastCompression()
```
    Gets the number of nodes which have been deleted from this graph since it was last compressed.
  - getTotalNodesDeleted
```
public int getTotalNodesDeleted()
```
    Gets the total number of nodes which have been deleted from this graph.
  - add
```
public <T extends Node> T add(T node)
```
    Adds a new node to the graph.
    
    Parameters:
    
    node - the node to be added
    
    Returns:
    
    the node which was added to the graph
  - addWithoutUnique
```
public <T extends Node> T addWithoutUnique(T node)
```
  - addOrUnique
```
public <T extends Node> T addOrUnique(T node)
```
  - addOrUniqueWithInputs
```
public <T extends Node> T addOrUniqueWithInputs(T node)
```
  - addWithoutUniqueWithInputs
```
public <T extends Node> T addWithoutUniqueWithInputs(T node)
```
  - beforeDecodingFields
```
public void beforeDecodingFields(Node node)
```
    Notifies node event listeners registered with this graph that node has been created as part of decoding a graph but its fields have yet to be initialized.
  - afterDecodingFields
```
public void afterDecodingFields(Node node)
```
    Notifies node event listeners registered with this graph that node has been created as part of decoding a graph and its fields have now been initialized.
  - trackNodeEvents
```
public Graph.NodeEventScope trackNodeEvents(Graph.NodeEventListener listener)
```
    Registers a given Graph.NodeEventListener with this graph. This should be used in conjunction with try-with-resources statement as follows:
```
 try (NodeEventScope nes = graph.trackNodeEvents(listener)) {
     // make changes to the graph
 }
 
```
  - unique
```
public <T extends Node & Node.ValueNumberable> T unique(T node)
```
    Looks for a node similar to node and returns it if found. Otherwise node is added to this graph and returned.
    
    Returns:
    
    a node similar to node if one exists, otherwise node
  - findDuplicate
```
public <T extends Node> T findDuplicate(T node)
```
    Returns a possible duplicate for the given node in the graph or null if no such duplicate exists.
  - isNew
```
public boolean isNew(Graph.Mark mark,
                     Node node)
```
  - getMark
```
public Graph.Mark getMark()
```
    Gets a mark that can be used with Graph.getNewNodes(org.graalvm.compiler.graph.Graph.Mark).
  - getNewNodes
```
public NodeIterable<Node> getNewNodes(Graph.Mark mark)
```
    Returns an Iterable providing all nodes added since the last mark.
  - getNodes
```
public NodeIterable<Node> getNodes()
```
    Returns an Iterable providing all the live nodes.
    
    Returns:
    
    an Iterable providing all the live nodes.
  - beforeNodeIdChange
```
protected Object beforeNodeIdChange(Node node)
```
  - afterNodeIdChange
```
protected void afterNodeIdChange(Node node,
                                 Object value)
```
  - maybeCompress
```
public final boolean maybeCompress()
```
    If the compression threshold is met, the list of nodes is compressed such that all non-null entries precede all null entries while preserving the ordering between the nodes within the list.
  - minimizeSize
```
public final void minimizeSize()
```
    Minimize the memory occupied by the graph by trimming all node arrays to the minimum size. Note that this can make subsequent optimization phases run slower, because additions to the graph must re-allocate larger arrays again. So invoking this method is only beneficial if a graph is alive for a long time.
  - compress
```
protected boolean compress(boolean minimizeSize)
```
  - getNodes
```
public <T extends Node & IterableNodeType> NodeIterable<T> getNodes(NodeClass<T> nodeClass)
```
    Returns an Iterable providing all the live nodes whose type is compatible with type.
    
    Parameters:
    
    nodeClass - the type of node to return
    
    Returns:
    
    an Iterable providing all the matching nodes
  - hasNode
```
public <T extends Node & IterableNodeType> boolean hasNode(NodeClass<T> type)
```
    Returns whether the graph contains at least one node of the given type.
    
    Parameters:
    
    type - the type of node that is checked for occurrence
    
    Returns:
    
    whether there is at least one such node
  - createNodeBitMap
```
public NodeBitMap createNodeBitMap()
```
  - createNodeMap
```
public <T> NodeMap<T> createNodeMap()
```
  - createNodeFlood
```
public NodeFlood createNodeFlood()
```
  - createNodeWorkList
```
public NodeWorkList createNodeWorkList()
```
  - createIterativeNodeWorkList
```
public NodeWorkList createIterativeNodeWorkList(boolean fill,
                                                int iterationLimitPerNode)
```
  - afterRegister
```
protected void afterRegister(Node node)
```
  - verify
```
public boolean verify()
```
  - verifySourcePositions
```
public boolean verifySourcePositions(boolean performConsistencyCheck)
```
  - getNode
```
public Node getNode(int id)
```
  - nodeIdCount
```
public int nodeIdCount()
```
    Returns the number of node ids generated so far.
    
    Returns:
    
    the number of node ids generated so far
  - addDuplicates
```
public org.graalvm.collections.EconomicMap<Node,Node> addDuplicates(Iterable<? extends Node> newNodes,
                                                                    Graph oldGraph,
                                                                    int estimatedNodeCount,
                                                                    org.graalvm.collections.EconomicMap<Node,Node> replacementsMap)
```
    Adds duplicates of the nodes in newNodes to this graph. This will recreate any edges between the duplicate nodes. The replacement map can be used to replace a node from the source graph by a given node (which must already be in this graph). Edges between duplicate and replacement nodes will also be recreated so care should be taken regarding the matching of node types in the replacement map.
    
    Parameters:
    
    newNodes - the nodes to be duplicated
    
    replacementsMap - the replacement map (can be null if no replacement is to be performed)
    
    Returns:
    
    a map which associates the original nodes from nodes to their duplicates
  - addDuplicates
```
public org.graalvm.collections.EconomicMap<Node,Node> addDuplicates(Iterable<? extends Node> newNodes,
                                                                    Graph oldGraph,
                                                                    int estimatedNodeCount,
                                                                    Graph.DuplicationReplacement replacements)
```
  - isFrozen
```
public boolean isFrozen()
```
  - freeze
```
public void freeze()
```
  - temporaryFreeze
```
public void temporaryFreeze()
```
  - unfreeze
```
public void unfreeze()
```

Class Graph

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

name

verifyGraphs

verifyGraphEdges

trackNodeSourcePosition

Constructor Detail

Graph

Graph

Method Detail

currentNodeSourcePosition

withNodeSourcePosition

withNodeSourcePosition

withoutNodeSourcePosition

trackNodeSourcePosition

setTrackNodeSourcePosition

trackNodeSourcePositionDefault

getDebugProperties

beforeNodeDuplication

isNodeModificationCountsEnabled

getEdgeModificationCount

copy

copy

copy

copy

getOptions

getDebug

resetDebug

toString

getNodeCount

getCompressions

getNodesDeletedSinceLastCompression

getTotalNodesDeleted

add

addWithoutUnique

addOrUnique

addOrUniqueWithInputs

addWithoutUniqueWithInputs

beforeDecodingFields

afterDecodingFields

trackNodeEvents

unique

findDuplicate

isNew

getMark

getNewNodes

getNodes

beforeNodeIdChange

afterNodeIdChange

maybeCompress

minimizeSize

compress

getNodes

hasNode

createNodeBitMap

createNodeMap

createNodeFlood

createNodeWorkList

createIterativeNodeWorkList

afterRegister

verify

verifySourcePositions

getNode

nodeIdCount

addDuplicates

addDuplicates

isFrozen

freeze

temporaryFreeze

unfreeze