Graph (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.graph.Graph

Direct Known Subclasses:

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
`private static class`	`Graph.CacheEntry` Entry in `cachedLeafNodes`.
`private static class`	`Graph.ChainedNodeEventListener`
`static interface`	`Graph.DuplicationReplacement`
`private static class`	`Graph.MapReplacement`
`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 interface`	`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`
`(package private) static class`	`Graph.PlaceHolderNode`

Field Summary

Fields
Modifier and Type	Field and Description
`private HashMap<Graph.CacheEntry,Node>`	`cachedLeafNodes` Used to global value number `Node.ValueNumberable` leaf nodes.
`static int`	`COMPRESSION_THRESHOLD` When the percent of live nodes in `nodes` fall below this number, a call to `maybeCompress()` will actually do compression.
`(package private) int`	`compressions` The number of times this graph has been compressed.
`private static DebugTimer`	`DuplicateGraph`
`private static DebugMetric`	`GraphCompressions`
`private static int`	`INITIAL_NODES_SIZE`
`private boolean`	`isFrozen`
`private ArrayList<Node>`	`iterableNodesFirst`
`private ArrayList<Node>`	`iterableNodesLast`
`static boolean`	`MODIFICATION_COUNTS_ENABLED`
`String`	`name`
`(package private) Graph.NodeEventListener`	`nodeEventListener`
`private int[]`	`nodeModCounts` Records the modification count for nodes.
`(package private) Node[]`	`nodes` The set of nodes in the graph, ordered by registration time.
`private int`	`nodesDeletedBeforeLastCompression`
`private int`	`nodesDeletedSinceLastCompression`
`(package private) int`	`nodesSize` The number of valid entries in `nodes`.
`private int[]`	`nodeUsageModCounts` Records the modification count for nodes' usage lists.
`(package private) static Node`	`PLACE_HOLDER`

Constructor Summary

Constructors
Constructor and Description

Graph()
Creates an empty Graph with no name.

Graph(String name)
Creates an empty Graph with a given name.

Constructors
Constructor and Description
`Graph()` Creates an empty Graph with no name.
`Graph(String name)` 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.
`Map<Node,Node>`	`addDuplicates(Iterable<? extends Node> newNodes, Graph oldGraph, int estimatedNodeCount, Graph.DuplicationReplacement replacements)`
`Map<Node,Node>`	`addDuplicates(Iterable<? extends Node> newNodes, Graph oldGraph, int estimatedNodeCount, Map<Node,Node> replacementsMap)` Adds duplicates of the nodes in `nodes` to this graph.
`private <T extends Node> T`	`addHelper(T node)`
`private <T extends Node> void`	`addInputs(T node)`
`<T extends Node> T`	`addOrUnique(T node)`
`<T extends Node> T`	`addOrUniqueWithInputs(T node)`
`<T extends Node> T`	`addWithoutUnique(T node)`
`<T extends Node> void`	`addWithoutUniqueWithInputs(T node)`
`private static boolean`	`assertionsEnabled()` Determines if assertions are enabled for the `Graph` class.
`Graph`	`copy()` Creates a copy of this graph.
`Graph`	`copy(Consumer<Map<Node,Node>> duplicationMapCallback)` Creates a copy of this graph.
`Graph`	`copy(String newName)` Creates a copy of this graph.
`protected Graph`	`copy(String newName, Consumer<Map<Node,Node>> duplicationMapCallback)` Creates a copy of this graph.
`NodeWorkList`	`createIterativeNodeWorkList(boolean fill, int iterationLimitPerNode)`
`NodeBitMap`	`createNodeBitMap()`
`NodeFlood`	`createNodeFlood()`
`<T> NodeMap<T>`	`createNodeMap()`
`NodeWorkList`	`createNodeWorkList()`
`(package private) int`	`extractOriginalNodeId(Node node)`
`<T extends Node> T`	`findDuplicate(T node)`
`private Node`	`findFirstLiveIterable(int iterableId, Node node)`
`private Node`	`findNextLiveiterable(Node start)`
`(package private) Node`	`findNodeInCache(Node node)`
`void`	`freeze()`
`int`	`getCompressions()` Gets the number of times this graph has been compressed.
`(package private) Node`	`getIterableNodeNext(Node node)`
`(package private) Node`	`getIterableNodeStart(int iterableId)`
`Graph.Mark`	`getMark()` Gets a mark that can be used with `getNewNodes(com.oracle.graal.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.
`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.
`(package private) void`	`incModCount(Node node)`
`(package private) void`	`incUsageModCount(Node node)`
`boolean`	`isFrozen()`
`boolean`	`isNew(Graph.Mark mark, Node node)`
`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.
`(package private) int`	`modCount(Node node)`
`(package private) int`	`nodeIdCount()` Returns the number of node ids generated so far.
`private void`	`postDeserialization()`
`(package private) void`	`putNodeIntoCache(Node node)`
`private void`	`recomputeIterableNodeLists()` Rebuilds the lists used to support `getNodes(NodeClass)`.
`(package private) void`	`register(Node node)`
`void`	`reverseUsageOrder()` Reverses the usage orders of all nodes.
`String`	`toString()`
`Graph.NodeEventScope`	`trackNodeEvents(Graph.NodeEventListener listener)` Registers a given `Graph.NodeEventListener` with this graph.
`<T extends Node & Node.ValueNumberable> T`	`unique(T node)` Looks for a node similar to `node` and returns it if found.
`(package private) <T extends Node> T`	`uniqueHelper(T node, boolean addIfMissing)`
`(package private) void`	`unregister(Node node)`
`private void`	`updateNodeCaches(Node node)`
`(package private) int`	`usageModCount(Node node)`
`boolean`	`verify()`

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

- Field Detail
  - name
```
public final String name
```
  - nodes
```
Node[] nodes
```
    The set of nodes in the graph, ordered by registration time.
  - nodesSize
```
int nodesSize
```
    The number of valid entries in nodes.
  - nodeModCounts
```
private int[] nodeModCounts
```
    Records the modification count for nodes. This is only used in assertions.
  - nodeUsageModCounts
```
private int[] nodeUsageModCounts
```
    Records the modification count for nodes' usage lists. This is only used in assertions.
  - iterableNodesFirst
```
private final ArrayList<Node> iterableNodesFirst
```
  - iterableNodesLast
```
private final ArrayList<Node> iterableNodesLast
```
  - nodesDeletedSinceLastCompression
```
private int nodesDeletedSinceLastCompression
```
  - nodesDeletedBeforeLastCompression
```
private int nodesDeletedBeforeLastCompression
```
  - compressions
```
int compressions
```
    The number of times this graph has been compressed.
  - nodeEventListener
```
Graph.NodeEventListener nodeEventListener
```
  - cachedLeafNodes
```
private final HashMap<Graph.CacheEntry,Node> cachedLeafNodes
```
    Used to global value number Node.ValueNumberable leaf nodes.
  - isFrozen
```
private boolean isFrozen
```
  - MODIFICATION_COUNTS_ENABLED
```
public static final boolean MODIFICATION_COUNTS_ENABLED
```
  - INITIAL_NODES_SIZE
```
private static final int INITIAL_NODES_SIZE
```
    See Also:
    
    Constant Field Values
  - PLACE_HOLDER
```
static final Node PLACE_HOLDER
```
  - COMPRESSION_THRESHOLD
```
public static final int COMPRESSION_THRESHOLD
```
    When the percent of live nodes in nodes fall below this number, a call to maybeCompress() will actually do compression.
  - GraphCompressions
```
private static final DebugMetric GraphCompressions
```
  - DuplicateGraph
```
private static final DebugTimer DuplicateGraph
```
- Constructor Detail
  - Graph
```
public Graph()
```
    Creates an empty Graph with no name.
  - Graph
```
public Graph(String name)
```
    Creates an empty Graph with a given name.
    
    Parameters:
    
    name - the name of the graph, used for debugging purposes
- Method Detail
  - assertionsEnabled
```
private static boolean assertionsEnabled()
```
    Determines if assertions are enabled for the Graph class.
  - extractOriginalNodeId
```
int extractOriginalNodeId(Node node)
```
  - modCount
```
int modCount(Node node)
```
  - incModCount
```
void incModCount(Node node)
```
  - usageModCount
```
int usageModCount(Node node)
```
  - incUsageModCount
```
void incUsageModCount(Node node)
```
  - copy
```
public final Graph copy()
```
    Creates a copy of this graph.
  - copy
```
public final Graph copy(Consumer<Map<Node,Node>> duplicationMapCallback)
```
    Creates a copy of this graph.
    
    Parameters:
    
    duplicationMapCallback - consumer of the duplication map created during the copying
  - copy
```
public final Graph copy(String newName)
```
    Creates a copy of this graph.
    
    Parameters:
    
    newName - the name of the copy, used for debugging purposes (can be null)
  - copy
```
protected Graph copy(String newName,
                     Consumer<Map<Node,Node>> duplicationMapCallback)
```
    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
  - 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)
```
  - addWithoutUniqueWithInputs
```
public <T extends Node> void addWithoutUniqueWithInputs(T node)
```
  - addOrUniqueWithInputs
```
public <T extends Node> T addOrUniqueWithInputs(T node)
```
  - addInputs
```
private <T extends Node> void addInputs(T node)
```
  - addHelper
```
private <T extends Node> T addHelper(T node)
```
  - 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
  - uniqueHelper
```
<T extends Node> T uniqueHelper(T node,
                                boolean addIfMissing)
```
  - putNodeIntoCache
```
void putNodeIntoCache(Node node)
```
  - findNodeInCache
```
Node findNodeInCache(Node node)
```
  - findDuplicate
```
public <T extends Node> T findDuplicate(T node)
```
  - isNew
```
public boolean isNew(Graph.Mark mark,
                     Node node)
```
  - getMark
```
public Graph.Mark getMark()
```
    Gets a mark that can be used with getNewNodes(com.oracle.graal.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.
  - maybeCompress
```
public 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.
  - 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
  - getIterableNodeStart
```
Node getIterableNodeStart(int iterableId)
```
    Parameters:
    
    iterableId -
    
    Returns:
    
    the first live Node with a matching iterableId
  - findFirstLiveIterable
```
private Node findFirstLiveIterable(int iterableId,
                                   Node node)
```
  - getIterableNodeNext
```
Node getIterableNodeNext(Node node)
```
    Parameters:
    
    node -
    
    Returns:
    
    return the first live Node with a matching iterableId starting from node
  - findNextLiveiterable
```
private Node findNextLiveiterable(Node start)
```
  - 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)
```
  - register
```
void register(Node node)
```
  - postDeserialization
```
private void postDeserialization()
```
  - recomputeIterableNodeLists
```
private void recomputeIterableNodeLists()
```
    Rebuilds the lists used to support getNodes(NodeClass). This is useful for serialization where the underlying iterable ids may have changed.
  - updateNodeCaches
```
private void updateNodeCaches(Node node)
```
  - unregister
```
void unregister(Node node)
```
  - verify
```
public boolean verify()
```
  - getNode
```
public Node getNode(int id)
```
  - nodeIdCount
```
int nodeIdCount()
```
    Returns the number of node ids generated so far.
    
    Returns:
    
    the number of node ids generated so far
  - addDuplicates
```
public Map<Node,Node> addDuplicates(Iterable<? extends Node> newNodes,
                                    Graph oldGraph,
                                    int estimatedNodeCount,
                                    Map<Node,Node> replacementsMap)
```
    Adds duplicates of the nodes in nodes 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 Map<Node,Node> addDuplicates(Iterable<? extends Node> newNodes,
                                    Graph oldGraph,
                                    int estimatedNodeCount,
                                    Graph.DuplicationReplacement replacements)
```
  - reverseUsageOrder
```
public void reverseUsageOrder()
```
    Reverses the usage orders of all nodes. This is used for debugging to make sure an unorthodox usage order does not trigger bugs in the compiler.
  - isFrozen
```
public boolean isFrozen()
```
  - freeze
```
public void freeze()
```

Class Graph

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

name

nodes

nodesSize

nodeModCounts

nodeUsageModCounts

iterableNodesFirst

iterableNodesLast

nodesDeletedSinceLastCompression

nodesDeletedBeforeLastCompression

compressions

nodeEventListener

cachedLeafNodes

isFrozen

MODIFICATION_COUNTS_ENABLED

INITIAL_NODES_SIZE

PLACE_HOLDER

COMPRESSION_THRESHOLD

GraphCompressions

DuplicateGraph

Constructor Detail

Graph

Graph

Method Detail

assertionsEnabled

extractOriginalNodeId

modCount

incModCount

usageModCount

incUsageModCount

copy

copy

copy

copy

toString

getNodeCount

getCompressions

getNodesDeletedSinceLastCompression

getTotalNodesDeleted

add

addWithoutUnique

addOrUnique

addWithoutUniqueWithInputs

addOrUniqueWithInputs

addInputs

addHelper

trackNodeEvents

unique

uniqueHelper

putNodeIntoCache

findNodeInCache

findDuplicate

isNew

getMark

getNewNodes

getNodes

maybeCompress

getNodes

hasNode

getIterableNodeStart

findFirstLiveIterable

getIterableNodeNext

findNextLiveiterable

createNodeBitMap

createNodeMap

createNodeFlood

createNodeWorkList

createIterativeNodeWorkList

register

postDeserialization

recomputeIterableNodeLists

updateNodeCaches

unregister

verify