org.graalvm.compiler.virtual.phases.ea

Class PartialEscapeClosure<BlockT extends PartialEscapeBlockState<BlockT>>

java.lang.Object

org.graalvm.compiler.phases.graph.ReentrantBlockIterator.BlockIteratorClosure<T>

org.graalvm.compiler.virtual.phases.ea.EffectsPhase.Closure<BlockT>

org.graalvm.compiler.virtual.phases.ea.EffectsClosure<BlockT>

org.graalvm.compiler.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
static class	PartialEscapeClosure.Final Final subclass of PartialEscapeClosure, for performance and to make everything behave nicely with generics.
protected class	PartialEscapeClosure.MergeProcessor

Nested classes/interfaces inherited from class org.graalvm.compiler.virtual.phases.ea.EffectsClosure

EffectsClosure.LoopKillCache

Field Summary

Fields

Modifier and Type	Field and Description
static CounterKey	COUNTER_ALLOCATION_REMOVED
static CounterKey	COUNTER_MATERIALIZATIONS
static CounterKey	COUNTER_MATERIALIZATIONS_LOOP_END
static CounterKey	COUNTER_MATERIALIZATIONS_LOOP_EXIT
static CounterKey	COUNTER_MATERIALIZATIONS_LOOP_REITERATION
static CounterKey	COUNTER_MATERIALIZATIONS_MERGE
static CounterKey	COUNTER_MATERIALIZATIONS_PHI
static CounterKey	COUNTER_MATERIALIZATIONS_UNHANDLED
static CounterKey	COUNTER_MEMORYCHECKPOINT
protected org.graalvm.compiler.virtual.phases.ea.VirtualizerToolImpl	tool This is handed out to implementers of Virtualizable.
ArrayList<VirtualObjectNode>	virtualObjects The indexes into this array correspond to VirtualObjectNode.getObjectId().

Fields inherited from class org.graalvm.compiler.virtual.phases.ea.EffectsClosure

aliases, blockEffects, cfg, changed, currentMode, debug, loopLocationKillCache, loopMergeEffects, schedule

Constructor Summary

Constructors

Constructor and Description
PartialEscapeClosure(StructuredGraph.ScheduleResult schedule, CoreProviders providers)

Method Summary

Modifier and Type	Method and Description
protected PartialEscapeClosure.MergeProcessor	createMergeProcessor(Block merge)
protected boolean	ensureMaterialized(PartialEscapeBlockState<?> state, int object, FixedNode materializeBefore, GraphEffectList effects, CounterKey counter)
ValueNode	getAlias(ValueNode value)
ValueNode	getAliasAndResolve(PartialEscapeBlockState<?> state, ValueNode value)
ObjectState	getObjectState(PartialEscapeBlockState<?> state, ValueNode value)
boolean	needsApplyEffects()
protected void	processInitialLoopState(Loop<Block> loop, BlockT initialState)
protected void	processLoopExit(LoopExitNode exitNode, BlockT initialState, BlockT exitState, GraphEffectList effects)
protected boolean	processNode(Node node, BlockT state, GraphEffectList effects, FixedWithNextNode lastFixedNode) Collects the effects of virtualizing the given node.
protected void	processNodeInputs(ValueNode node, FixedNode insertBefore, BlockT state, GraphEffectList effects) This replaces all inputs that point to virtual or materialized values with the actual value, materializing if necessary.
protected void	processNodeWithState(NodeWithState nodeWithState, BlockT state, GraphEffectList effects)
protected void	processStateBeforeLoopOnOverflow(BlockT initialState, FixedNode materializeBefore, GraphEffectList effects)
protected boolean	requiresProcessing(Node node)
protected boolean	shouldMaterializeNonVirtualizable(BlockT state, int id, FixedNode insertBefore)
protected BlockT	stripKilledLoopLocations(Loop<Block> loop, BlockT originalInitialState)
static boolean	updateStatesForMaterialized(PartialEscapeBlockState<?> state, VirtualObjectNode virtual, ValueNode materializedValue)
protected boolean	virtualize(ValueNode node, VirtualizerTool vt)

Methods inherited from class org.graalvm.compiler.virtual.phases.ea.EffectsClosure

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

Methods inherited from class org.graalvm.compiler.phases.graph.ReentrantBlockIterator.BlockIteratorClosure

cloneState, getInitialState

Methods inherited from class java.lang.Object

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

Field Detail

COUNTER_MATERIALIZATIONS

public static final CounterKey COUNTER_MATERIALIZATIONS

COUNTER_MATERIALIZATIONS_PHI

public static final CounterKey COUNTER_MATERIALIZATIONS_PHI

COUNTER_MATERIALIZATIONS_MERGE

public static final CounterKey COUNTER_MATERIALIZATIONS_MERGE

COUNTER_MATERIALIZATIONS_UNHANDLED

public static final CounterKey COUNTER_MATERIALIZATIONS_UNHANDLED

COUNTER_MATERIALIZATIONS_LOOP_REITERATION

public static final CounterKey COUNTER_MATERIALIZATIONS_LOOP_REITERATION

COUNTER_MATERIALIZATIONS_LOOP_END

public static final CounterKey COUNTER_MATERIALIZATIONS_LOOP_END

COUNTER_MATERIALIZATIONS_LOOP_EXIT

public static final CounterKey COUNTER_MATERIALIZATIONS_LOOP_EXIT

COUNTER_ALLOCATION_REMOVED

public static final CounterKey COUNTER_ALLOCATION_REMOVED

COUNTER_MEMORYCHECKPOINT

public static final CounterKey COUNTER_MEMORYCHECKPOINT

tool

protected final org.graalvm.compiler.virtual.phases.ea.VirtualizerToolImpl tool

This is handed out to implementers of Virtualizable.

virtualObjects

public final ArrayList<VirtualObjectNode> virtualObjects

The indexes into this array correspond to VirtualObjectNode.getObjectId().

Constructor Detail

PartialEscapeClosure

public PartialEscapeClosure(StructuredGraph.ScheduleResult schedule,
                            CoreProviders providers)

Method Detail

needsApplyEffects

public boolean needsApplyEffects()

Overrides:

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

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

processStateBeforeLoopOnOverflow

protected void processStateBeforeLoopOnOverflow(BlockT initialState,
                                                FixedNode materializeBefore,
                                                GraphEffectList effects)

Overrides:

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

requiresProcessing

protected boolean requiresProcessing(Node node)

virtualize

protected boolean virtualize(ValueNode node,
                             VirtualizerTool vt)

processNodeInputs

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

This replaces all inputs that point to virtual or materialized values with the actual value, materializing if necessary. Also takes care of frame states, adding the necessary VirtualObjectState.

shouldMaterializeNonVirtualizable

protected boolean shouldMaterializeNonVirtualizable(BlockT state,
                                                    int id,
                                                    FixedNode insertBefore)

processNodeWithState

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

ensureMaterialized

protected boolean ensureMaterialized(PartialEscapeBlockState<?> state,
                                     int object,
                                     FixedNode materializeBefore,
                                     GraphEffectList effects,
                                     CounterKey counter)

Returns:

true if materialization happened, false if not.

updateStatesForMaterialized

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

stripKilledLoopLocations

protected BlockT stripKilledLoopLocations(Loop<Block> loop,
                                          BlockT originalInitialState)

Overrides:

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

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>>

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)