com.oracle.graal.lir.constopt

Class ConstantTreeAnalyzer

java.lang.Object

com.oracle.graal.lir.constopt.ConstantTreeAnalyzer

public final class ConstantTreeAnalyzer
extends Object

Analyzes a ConstantTree and marks potential materialization positions.

Field Summary

Fields

Modifier and Type	Field and Description
private ConstantTree	tree
private BitSet	visited

Constructor Summary

Constructors

Modifier	Constructor and Description
private	ConstantTreeAnalyzer(ConstantTree tree)

Method Summary

Modifier and Type	Method and Description
static ConstantTree.NodeCost	analyze(ConstantTree tree, AbstractBlockBase<?> startBlock)
private void	analyzeBlocks(AbstractBlockBase<?> startBlock) Queues all relevant blocks for processing.
private void	filteredPush(Deque<AbstractBlockBase<?>> worklist, AbstractBlockBase<?> block)
private boolean	isLeafBlock(AbstractBlockBase<?> block)
private boolean	isMarked(AbstractBlockBase<?> block)
private void	leafCost(AbstractBlockBase<?> block)
private void	process(AbstractBlockBase<?> block) Calculates the cost of a block.
private static boolean	shouldMaterializerInCurrentBlock(double probabilityBlock, double probabilityChildren, int numMat) This is the cost function that decides whether a materialization should be inserted in the current block.

Methods inherited from class java.lang.Object

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

Field Detail

tree

private final ConstantTree tree

visited

private final BitSet visited

Constructor Detail

ConstantTreeAnalyzer

private ConstantTreeAnalyzer(ConstantTree tree)

Method Detail

analyze

public static ConstantTree.NodeCost analyze(ConstantTree tree,
                                            AbstractBlockBase<?> startBlock)

analyzeBlocks

private void analyzeBlocks(AbstractBlockBase<?> startBlock)

Queues all relevant blocks for processing. This is a worklist-style algorithm because a (more elegant) recursive implementation may cause stack overflows on larger graphs.

Parameters:

startBlock - The start block of the dominator subtree.

process

private void process(AbstractBlockBase<?> block)

Calculates the cost of a block. It is assumed that all children have already been processed

Parameters:

block - The block to be processed.

shouldMaterializerInCurrentBlock

private static boolean shouldMaterializerInCurrentBlock(double probabilityBlock,
                                                        double probabilityChildren,
                                                        int numMat)

This is the cost function that decides whether a materialization should be inserted in the current block.

Note that this function does not take into account if a materialization is required despite the probabilities (e.g. there are usages in the current block).

Parameters:

probabilityBlock - Probability of the current block.

probabilityChildren - Accumulated probability of the children.

numMat - Number of materializations along the subtrees. We use numMat - 1 to insert materializations as late as possible if the probabilities are the same.

filteredPush

private void filteredPush(Deque<AbstractBlockBase<?>> worklist,
                          AbstractBlockBase<?> block)

leafCost

private void leafCost(AbstractBlockBase<?> block)

isMarked

private boolean isMarked(AbstractBlockBase<?> block)

isLeafBlock

private boolean isLeafBlock(AbstractBlockBase<?> block)