com.oracle.graal.virtual.phases.ea

Class PartialEscapeClosure.MergeProcessor

java.lang.Object

com.oracle.graal.virtual.phases.ea.EffectsClosure.MergeProcessor

com.oracle.graal.virtual.phases.ea.PartialEscapeClosure.MergeProcessor

Direct Known Subclasses:

PEReadEliminationClosure.ReadEliminationMergeProcessor

Enclosing class:

PartialEscapeClosure<BlockT extends PartialEscapeBlockState<BlockT>>

protected class PartialEscapeClosure.MergeProcessor
extends EffectsClosure.MergeProcessor

Field Summary

Fields

Modifier and Type	Field and Description
private HashMap<Object,ValuePhiNode>	materializedPhis
private boolean	needsCaching
private Map<ValuePhiNode,VirtualObjectNode>	valueObjectVirtuals
private Map<ValueNode,ValuePhiNode[]>	valuePhis

Fields inherited from class com.oracle.graal.virtual.phases.ea.EffectsClosure.MergeProcessor

afterMergeEffects, mergeEffects, newState

Constructor Summary

Constructors

Constructor and Description
MergeProcessor(Block mergeBlock)

Method Summary

Modifier and Type	Method and Description
protected <T> PhiNode	getPhi(T virtual, Stamp stamp)
private <T> PhiNode	getPhiCached(T virtual, Stamp stamp)
private VirtualObjectNode	getValueObjectVirtual(ValuePhiNode phi, VirtualObjectNode virtual)
private VirtualObjectNode	getValueObjectVirtualCached(ValuePhiNode phi, VirtualObjectNode virtual)
private PhiNode[]	getValuePhis(ValueNode key, int entryCount)
private PhiNode[]	getValuePhisCached(ValueNode key, int entryCount)
private int[]	intersectVirtualObjects(PartialEscapeBlockState<?>[] states)
protected void	merge(List<BlockT> statesList) Merge all predecessor block states into one block state.
private boolean	mergeObjectEntry(IntFunction<Integer> objectIdFunc, PartialEscapeBlockState<?>[] states, PhiNode phi, int entryIndex) Fill the inputs of the PhiNode corresponding to one Kind.Object entry in the virtual object.
private boolean	mergeObjectStates(int resultObject, int[] sourceObjects, PartialEscapeBlockState<?>[] states) Try to merge multiple virtual object states into a single object state.
private boolean	processPhi(ValuePhiNode phi, PartialEscapeBlockState<?>[] states, int[] mergedVirtualObjects) Examine a PhiNode and try to replace it with merging of virtual objects if all its inputs refer to virtual object states.

Methods inherited from class com.oracle.graal.virtual.phases.ea.EffectsClosure.MergeProcessor

commitEnds, createValuePhi, getPhis, getPhiValueAt, getPredecessor, getStateIndex, graph, setPhiInput, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

materializedPhis

private HashMap<Object,ValuePhiNode> materializedPhis

valuePhis

private Map<ValueNode,ValuePhiNode[]> valuePhis

valueObjectVirtuals

private Map<ValuePhiNode,VirtualObjectNode> valueObjectVirtuals

needsCaching

private final boolean needsCaching

Constructor Detail

MergeProcessor

public MergeProcessor(Block mergeBlock)

Method Detail

getPhi

protected <T> PhiNode getPhi(T virtual,
                             Stamp stamp)

getPhiCached

private <T> PhiNode getPhiCached(T virtual,
                                 Stamp stamp)

getValuePhis

private PhiNode[] getValuePhis(ValueNode key,
                               int entryCount)

getValuePhisCached

private PhiNode[] getValuePhisCached(ValueNode key,
                                     int entryCount)

getValueObjectVirtual

private VirtualObjectNode getValueObjectVirtual(ValuePhiNode phi,
                                                VirtualObjectNode virtual)

getValueObjectVirtualCached

private VirtualObjectNode getValueObjectVirtualCached(ValuePhiNode phi,
                                                      VirtualObjectNode virtual)

merge

protected void merge(List<BlockT> statesList)

Merge all predecessor block states into one block state. This is an iterative process, because merging states can lead to materializations which make previous parts of the merging operation invalid. The merging process is executed until a stable state has been reached. This method needs to be careful to place the effects of the merging operation into the correct blocks.

Overrides:

merge in class EffectsClosure.MergeProcessor

Parameters:

statesList - the predecessor block states of the merge

intersectVirtualObjects

private int[] intersectVirtualObjects(PartialEscapeBlockState<?>[] states)

mergeObjectStates

private boolean mergeObjectStates(int resultObject,
                                  int[] sourceObjects,
                                  PartialEscapeBlockState<?>[] states)

Try to merge multiple virtual object states into a single object state. If the incoming object states are compatible, then this method will create PhiNodes for the object's entries where needed. If they are incompatible, then all incoming virtual objects will be materialized, and a PhiNode for the materialized values will be created. Object states can be incompatible if they contain long or double values occupying two int slots in such a way that that their values cannot be merged using PhiNodes.

Parameters:

states - the predecessor block states of the merge

Returns:

true if materialization happened during the merge, false otherwise

mergeObjectEntry

private boolean mergeObjectEntry(IntFunction<Integer> objectIdFunc,
                                 PartialEscapeBlockState<?>[] states,
                                 PhiNode phi,
                                 int entryIndex)

Fill the inputs of the PhiNode corresponding to one Kind.Object entry in the virtual object.

Returns:

true if materialization happened during the merge, false otherwise

processPhi

private boolean processPhi(ValuePhiNode phi,
                           PartialEscapeBlockState<?>[] states,
                           int[] mergedVirtualObjects)

Examine a PhiNode and try to replace it with merging of virtual objects if all its inputs refer to virtual object states. In order for the merging to happen, all incoming object states need to be compatible and without object identity (meaning that their object identity if not used later on).

Parameters:

phi - the PhiNode that should be processed

states - the predecessor block states of the merge

mergedVirtualObjects - the set of virtual objects that exist in all incoming states, and therefore also exist in the merged state

Returns:

true if materialization happened during the merge, false otherwise