src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraphScheduleTest.java
changeset 48861 47f19ff9903c
parent 47216 71c04702a3d5
child 50858 2d3e99a72541
equal deleted inserted replaced
48860:5bce1b7e7800 48861:47f19ff9903c
    22  */
    22  */
    23 package org.graalvm.compiler.core.test;
    23 package org.graalvm.compiler.core.test;
    24 
    24 
    25 import java.util.List;
    25 import java.util.List;
    26 
    26 
    27 import org.junit.Assert;
       
    28 
       
    29 import org.graalvm.compiler.graph.Node;
    27 import org.graalvm.compiler.graph.Node;
    30 import org.graalvm.compiler.graph.NodeMap;
    28 import org.graalvm.compiler.graph.NodeMap;
    31 import org.graalvm.compiler.nodes.StructuredGraph;
    29 import org.graalvm.compiler.nodes.StructuredGraph;
    32 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
    30 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
    33 import org.graalvm.compiler.nodes.cfg.Block;
    31 import org.graalvm.compiler.nodes.cfg.Block;
    34 import org.graalvm.compiler.phases.schedule.SchedulePhase;
    32 import org.graalvm.compiler.phases.schedule.SchedulePhase;
       
    33 import org.junit.Assert;
       
    34 
       
    35 import jdk.vm.ci.meta.SpeculationLog;
    35 
    36 
    36 public class GraphScheduleTest extends GraalCompilerTest {
    37 public class GraphScheduleTest extends GraalCompilerTest {
    37 
    38 
    38     protected void assertOrderedAfterSchedule(StructuredGraph graph, Node a, Node b) {
    39     protected void assertOrderedAfterSchedule(StructuredGraph graph, Node a, Node b) {
    39         SchedulePhase ibp = new SchedulePhase(SchedulePhase.SchedulingStrategy.LATEST);
    40         assertOrderedAfterSchedule(graph, SchedulePhase.SchedulingStrategy.LATEST, a, b);
       
    41     }
       
    42 
       
    43     protected void assertOrderedAfterSchedule(StructuredGraph graph, SchedulePhase.SchedulingStrategy strategy, Node a, Node b) {
       
    44         SchedulePhase ibp = new SchedulePhase(strategy);
    40         ibp.apply(graph);
    45         ibp.apply(graph);
       
    46         assertOrderedAfterLastSchedule(graph, a, b);
       
    47     }
       
    48 
       
    49     protected void assertOrderedAfterLastSchedule(StructuredGraph graph, Node a, Node b) {
    41         assertOrderedAfterSchedule(graph.getLastSchedule(), a, b);
    50         assertOrderedAfterSchedule(graph.getLastSchedule(), a, b);
    42     }
    51     }
    43 
    52 
    44     protected void assertOrderedAfterSchedule(ScheduleResult ibp, Node a, Node b) {
    53     protected void assertOrderedAfterSchedule(ScheduleResult ibp, Node a, Node b) {
    45         NodeMap<Block> nodeToBlock = ibp.getCFG().getNodeToBlock();
    54         NodeMap<Block> nodeToBlock = ibp.getCFG().getNodeToBlock();
    46         Block bBlock = nodeToBlock.get(b);
    55         Block bBlock = nodeToBlock.get(b);
    47         Block aBlock = nodeToBlock.get(a);
    56         Block aBlock = nodeToBlock.get(a);
    48 
    57 
    49         if (bBlock == aBlock) {
    58         if (bBlock == aBlock) {
    50             List<Node> instructions = ibp.nodesFor(bBlock);
    59             List<Node> instructions = ibp.nodesFor(bBlock);
    51             Assert.assertTrue(instructions.indexOf(b) > instructions.indexOf(a));
    60             Assert.assertTrue(a + " should be before " + b, instructions.indexOf(b) > instructions.indexOf(a));
    52         } else {
    61         } else {
    53             Block block = bBlock;
    62             Block block = bBlock;
    54             while (block != null) {
    63             while (block != null) {
    55                 if (block == aBlock) {
    64                 if (block == aBlock) {
    56                     return;
    65                     return;
    58                 block = block.getDominator();
    67                 block = block.getDominator();
    59             }
    68             }
    60             Assert.fail("block of A doesn't dominate the block of B");
    69             Assert.fail("block of A doesn't dominate the block of B");
    61         }
    70         }
    62     }
    71     }
       
    72 
       
    73     @Override
       
    74     protected SpeculationLog getSpeculationLog() {
       
    75         return getCodeCache().createSpeculationLog();
       
    76     }
    63 }
    77 }