package org.graalvm.compiler.java;
import static org.graalvm.compiler.nodes.cfg.ControlFlowGraph.multiplyProbabilities;
import java.util.List;
import jdk.internal.vm.compiler.collections.EconomicMap;
import org.graalvm.compiler.nodes.AbstractBeginNode;
import org.graalvm.compiler.nodes.AbstractMergeNode;
import org.graalvm.compiler.nodes.ControlSplitNode;
import org.graalvm.compiler.nodes.FixedNode;
import org.graalvm.compiler.nodes.LoopBeginNode;
import org.graalvm.compiler.nodes.LoopExitNode;
import org.graalvm.compiler.nodes.StructuredGraph;
import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
import org.graalvm.compiler.phases.Phase;
import org.graalvm.compiler.phases.graph.ReentrantNodeIterator;
public final class ComputeLoopFrequenciesClosure extends ReentrantNodeIterator.NodeIteratorClosure<Double> {
private static final ComputeLoopFrequenciesClosure INSTANCE = new ComputeLoopFrequenciesClosure();
private ComputeLoopFrequenciesClosure() {
}
@Override
protected Double processNode(FixedNode node, Double currentState) {
return currentState;
}
@Override
protected Double merge(AbstractMergeNode merge, List<Double> states) {
double result = 0.0;
for (double d : states) {
result += d;
}
return result;
}
@Override
protected Double afterSplit(AbstractBeginNode node, Double oldState) {
ControlSplitNode split = (ControlSplitNode) node.predecessor();
return oldState * split.probability(node);
}
@Override
protected EconomicMap<LoopExitNode, Double> processLoop(LoopBeginNode loop, Double initialState) {
EconomicMap<LoopExitNode, Double> exitStates = ReentrantNodeIterator.processLoop(this, loop, 1D).exitStates;
double exitProbability = 0.0;
for (double d : exitStates.getValues()) {
exitProbability += d;
}
exitProbability = Math.min(1.0, exitProbability);
exitProbability = Math.max(ControlFlowGraph.MIN_PROBABILITY, exitProbability);
double loopFrequency = 1.0 / exitProbability;
loop.setLoopFrequency(loopFrequency);
double adjustmentFactor = initialState * loopFrequency;
exitStates.replaceAll((exitNode, probability) -> multiplyProbabilities(probability, adjustmentFactor));
return exitStates;
}
public static void compute(StructuredGraph graph) {
if (graph.hasLoops()) {
ReentrantNodeIterator.apply(INSTANCE, graph.start(), 1D);
}
}
public static class ComputeLoopFrequencyPhase extends Phase {
@Override
protected void run(StructuredGraph graph) {
compute(graph);
}
}
public static final ComputeLoopFrequencyPhase PHASE_INSTANCE = new ComputeLoopFrequencyPhase();
}