com.oracle.graal.virtual.phases.ea

Class PartialEscapeClosure<BlockT extends PartialEscapeBlockState<BlockT>>

java.lang.Object

com.oracle.graal.phases.graph.ReentrantBlockIterator.BlockIteratorClosure<T>

com.oracle.graal.virtual.phases.ea.EffectsPhase.Closure<BlockT>

com.oracle.graal.virtual.phases.ea.EffectsClosure<BlockT>

com.oracle.graal.virtual.phases.ea.PartialEscapeClosure<BlockT>

Direct Known Subclasses:

PartialEscapeClosure.Final, PEReadEliminationClosure

public abstract class PartialEscapeClosure<BlockT extends PartialEscapeBlockState<BlockT>>
extends EffectsClosure<BlockT>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	PartialEscapeClosure.CollectVirtualObjectsClosure
static class	PartialEscapeClosure.Final Final subclass of PartialEscapeClosure, for performance and to make everything behave nicely with generics.
protected class	PartialEscapeClosure.MergeProcessor

Field Summary

Fields

Modifier and Type	Field and Description
private NodeBitMap	hasVirtualInputs
static DebugMetric	METRIC_ALLOCATION_REMOVED
static DebugMetric	METRIC_MATERIALIZATIONS
static DebugMetric	METRIC_MATERIALIZATIONS_LOOP_END
static DebugMetric	METRIC_MATERIALIZATIONS_LOOP_REITERATION
static DebugMetric	METRIC_MATERIALIZATIONS_MERGE
static DebugMetric	METRIC_MATERIALIZATIONS_PHI
static DebugMetric	METRIC_MATERIALIZATIONS_UNHANDLED
static DebugMetric	METRIC_MEMORYCHECKPOINT
private VirtualizerToolImpl	tool
ArrayList<VirtualObjectNode>	virtualObjects

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

aliases, blockEffects, cfg, changed, schedule

Constructor Summary

Constructors

Constructor and Description
PartialEscapeClosure(SchedulePhase schedule, MetaAccessProvider metaAccess, ConstantReflectionProvider constantReflection)

Method Summary

Modifier and Type	Method and Description
(package private) void	addAndMarkAlias(VirtualObjectNode virtual, ValueNode node)
private void	addVirtualMappings(FrameState frameState, Set<VirtualObjectNode> virtual, BlockT state, GraphEffectList effects)
private void	collectLockedVirtualObjects(BlockT state, Set<VirtualObjectNode> virtual)
private void	collectReferencedVirtualObjects(BlockT state, Set<VirtualObjectNode> virtual)
protected PartialEscapeClosure.MergeProcessor	createMergeProcessor(Block merge)
private boolean	ensureMaterialized(PartialEscapeBlockState<?> state, int object, FixedNode materializeBefore, GraphEffectList effects, DebugMetric metric)
ValueNode	getAlias(ValueNode value)
ValueNode	getAliasAndResolve(PartialEscapeBlockState<?> state, ValueNode value)
ObjectState	getObjectState(PartialEscapeBlockState<?> state, ValueNode value)
private static FrameState	getUniqueFramestate(NodeWithState nodeWithState, FrameState frameState)
private void	markVirtualUsages(Node node)
private boolean	prepareCanonicalNode(ValueNode node, BlockT state, GraphEffectList effects)
protected void	processInitialLoopState(Loop<Block> loop, BlockT initialState)
protected void	processLoopExit(LoopExitNode exitNode, BlockT initialState, BlockT exitState, GraphEffectList effects)
private static void	processMaterializedAtLoopExit(LoopExitNode exitNode, GraphEffectList effects, Map<Integer,ProxyNode> proxies, int object, ObjectState exitObjState, ObjectState initialObjState, PartialEscapeBlockState<?> exitState)
protected boolean	processNode(Node node, BlockT state, GraphEffectList effects, FixedWithNextNode lastFixedNode) Collects the effects of virtualizing the given node.
private void	processNodeInputs(ValueNode node, FixedNode insertBefore, BlockT state, GraphEffectList effects)
private boolean	processNodeInternal(Node node, BlockT state, GraphEffectList effects, FixedWithNextNode lastFixedNode)
private boolean	processNodeWithScalarReplacedInputs(ValueNode node, FixedNode insertBefore, BlockT state, GraphEffectList effects)
private void	processNodeWithState(NodeWithState nodeWithState, BlockT state, GraphEffectList effects)
private static void	processVirtualAtLoopExit(LoopExitNode exitNode, GraphEffectList effects, int object, ObjectState exitObjState, ObjectState initialObjState, PartialEscapeBlockState<?> exitState)
private boolean	processVirtualizable(ValueNode node, FixedNode insertBefore, BlockT state, GraphEffectList effects)
protected boolean	requiresProcessing(Node node)
static void	updateStatesForMaterialized(PartialEscapeBlockState<?> state, VirtualObjectNode virtual, ValueNode materializedValue)
protected boolean	virtualize(ValueNode node, VirtualizerTool vt)

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

addScalarAlias, applyEffects, getScalarAlias, hasChanged, hasScalarReplacedInputs, merge, processBlock, processLoop

Methods inherited from class com.oracle.graal.phases.graph.ReentrantBlockIterator.BlockIteratorClosure

cloneState, getInitialState

Methods inherited from class java.lang.Object

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

Field Detail

METRIC_MATERIALIZATIONS

public static final DebugMetric METRIC_MATERIALIZATIONS

METRIC_MATERIALIZATIONS_PHI

public static final DebugMetric METRIC_MATERIALIZATIONS_PHI

METRIC_MATERIALIZATIONS_MERGE

public static final DebugMetric METRIC_MATERIALIZATIONS_MERGE

METRIC_MATERIALIZATIONS_UNHANDLED

public static final DebugMetric METRIC_MATERIALIZATIONS_UNHANDLED

METRIC_MATERIALIZATIONS_LOOP_REITERATION

public static final DebugMetric METRIC_MATERIALIZATIONS_LOOP_REITERATION

METRIC_MATERIALIZATIONS_LOOP_END

public static final DebugMetric METRIC_MATERIALIZATIONS_LOOP_END

METRIC_ALLOCATION_REMOVED

public static final DebugMetric METRIC_ALLOCATION_REMOVED

METRIC_MEMORYCHECKPOINT

public static final DebugMetric METRIC_MEMORYCHECKPOINT

hasVirtualInputs

private final NodeBitMap hasVirtualInputs

tool

private final VirtualizerToolImpl tool

virtualObjects

public final ArrayList<VirtualObjectNode> virtualObjects

Constructor Detail

PartialEscapeClosure

public PartialEscapeClosure(SchedulePhase schedule,
                            MetaAccessProvider metaAccess,
                            ConstantReflectionProvider constantReflection)

Method Detail

processNode

protected boolean processNode(Node node,
                              BlockT state,
                              GraphEffectList effects,
                              FixedWithNextNode lastFixedNode)

Description copied from class: EffectsClosure

Collects the effects of virtualizing the given node.

Specified by:

processNode in class EffectsClosure<BlockT extends PartialEscapeBlockState<BlockT>>

Returns:

true if the node was deleted, false otherwise

processNodeInternal

private boolean processNodeInternal(Node node,
                                    BlockT state,
                                    GraphEffectList effects,
                                    FixedWithNextNode lastFixedNode)

requiresProcessing

protected boolean requiresProcessing(Node node)

processNodeWithScalarReplacedInputs

private boolean processNodeWithScalarReplacedInputs(ValueNode node,
                                                    FixedNode insertBefore,
                                                    BlockT state,
                                                    GraphEffectList effects)

prepareCanonicalNode

private boolean prepareCanonicalNode(ValueNode node,
                                     BlockT state,
                                     GraphEffectList effects)

processNodeInputs

private void processNodeInputs(ValueNode node,
                               FixedNode insertBefore,
                               BlockT state,
                               GraphEffectList effects)

processVirtualizable

private boolean processVirtualizable(ValueNode node,
                                     FixedNode insertBefore,
                                     BlockT state,
                                     GraphEffectList effects)

virtualize

protected boolean virtualize(ValueNode node,
                             VirtualizerTool vt)

processNodeWithState

private void processNodeWithState(NodeWithState nodeWithState,
                                  BlockT state,
                                  GraphEffectList effects)

getUniqueFramestate

private static FrameState getUniqueFramestate(NodeWithState nodeWithState,
                                              FrameState frameState)

addVirtualMappings

private void addVirtualMappings(FrameState frameState,
                                Set<VirtualObjectNode> virtual,
                                BlockT state,
                                GraphEffectList effects)

collectReferencedVirtualObjects

private void collectReferencedVirtualObjects(BlockT state,
                                             Set<VirtualObjectNode> virtual)

collectLockedVirtualObjects

private void collectLockedVirtualObjects(BlockT state,
                                         Set<VirtualObjectNode> virtual)

ensureMaterialized

private boolean ensureMaterialized(PartialEscapeBlockState<?> state,
                                   int object,
                                   FixedNode materializeBefore,
                                   GraphEffectList effects,
                                   DebugMetric metric)

Returns:

true if materialization happened, false if not.

updateStatesForMaterialized

public static void updateStatesForMaterialized(PartialEscapeBlockState<?> state,
                                               VirtualObjectNode virtual,
                                               ValueNode materializedValue)

processInitialLoopState

protected void processInitialLoopState(Loop<Block> loop,
                                       BlockT initialState)

Overrides:

processInitialLoopState in class EffectsClosure<BlockT extends PartialEscapeBlockState<BlockT>>

processLoopExit

protected void processLoopExit(LoopExitNode exitNode,
                               BlockT initialState,
                               BlockT exitState,
                               GraphEffectList effects)

Specified by:

processLoopExit in class EffectsClosure<BlockT extends PartialEscapeBlockState<BlockT>>

processMaterializedAtLoopExit

private static void processMaterializedAtLoopExit(LoopExitNode exitNode,
                                                  GraphEffectList effects,
                                                  Map<Integer,ProxyNode> proxies,
                                                  int object,
                                                  ObjectState exitObjState,
                                                  ObjectState initialObjState,
                                                  PartialEscapeBlockState<?> exitState)

processVirtualAtLoopExit

private static void processVirtualAtLoopExit(LoopExitNode exitNode,
                                             GraphEffectList effects,
                                             int object,
                                             ObjectState exitObjState,
                                             ObjectState initialObjState,
                                             PartialEscapeBlockState<?> exitState)

createMergeProcessor

protected PartialEscapeClosure.MergeProcessor createMergeProcessor(Block merge)

Specified by:

createMergeProcessor in class EffectsClosure<BlockT extends PartialEscapeBlockState<BlockT>>

getObjectState

public ObjectState getObjectState(PartialEscapeBlockState<?> state,
                                  ValueNode value)

getAlias

public ValueNode getAlias(ValueNode value)

getAliasAndResolve

public ValueNode getAliasAndResolve(PartialEscapeBlockState<?> state,
                                    ValueNode value)

addAndMarkAlias

void addAndMarkAlias(VirtualObjectNode virtual,
                     ValueNode node)

markVirtualUsages

private void markVirtualUsages(Node node)