src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/MemoryScheduleTest.java
changeset 58877 aec7bf35d6f5
parent 54084 84f10bbf993f
equal deleted inserted replaced
58876:1a8d65e71a66 58877:aec7bf35d6f5
    36 import org.graalvm.compiler.api.directives.GraalDirectives;
    36 import org.graalvm.compiler.api.directives.GraalDirectives;
    37 import org.graalvm.compiler.debug.DebugContext;
    37 import org.graalvm.compiler.debug.DebugContext;
    38 import org.graalvm.compiler.graph.Node;
    38 import org.graalvm.compiler.graph.Node;
    39 import org.graalvm.compiler.graph.iterators.NodeIterable;
    39 import org.graalvm.compiler.graph.iterators.NodeIterable;
    40 import org.graalvm.compiler.nodes.ReturnNode;
    40 import org.graalvm.compiler.nodes.ReturnNode;
    41 import org.graalvm.compiler.nodes.StartNode;
       
    42 import org.graalvm.compiler.nodes.StructuredGraph;
    41 import org.graalvm.compiler.nodes.StructuredGraph;
    43 import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions;
    42 import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions;
    44 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
    43 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
    45 import org.graalvm.compiler.nodes.cfg.Block;
    44 import org.graalvm.compiler.nodes.cfg.Block;
    46 import org.graalvm.compiler.nodes.memory.FloatingReadNode;
    45 import org.graalvm.compiler.nodes.memory.FloatingReadNode;
   175     }
   174     }
   176 
   175 
   177     @Test
   176     @Test
   178     public void testLoop1() {
   177     public void testLoop1() {
   179         ScheduleResult schedule = getFinalSchedule("testLoop1Snippet", TestMode.WITHOUT_FRAMESTATES);
   178         ScheduleResult schedule = getFinalSchedule("testLoop1Snippet", TestMode.WITHOUT_FRAMESTATES);
   180         assertDeepEquals(6, schedule.getCFG().getBlocks().length);
       
   181         assertReadWithinStartBlock(schedule, true);
   179         assertReadWithinStartBlock(schedule, true);
   182         assertReadWithinAllReturnBlocks(schedule, false);
   180         assertReadWithinAllReturnBlocks(schedule, false);
   183     }
   181     }
   184 
   182 
   185     /**
   183     /**
   200     }
   198     }
   201 
   199 
   202     @Test
   200     @Test
   203     public void testLoop2() {
   201     public void testLoop2() {
   204         ScheduleResult schedule = getFinalSchedule("testLoop2Snippet", TestMode.WITHOUT_FRAMESTATES);
   202         ScheduleResult schedule = getFinalSchedule("testLoop2Snippet", TestMode.WITHOUT_FRAMESTATES);
   205         assertDeepEquals(6, schedule.getCFG().getBlocks().length);
       
   206         assertReadWithinStartBlock(schedule, false);
   203         assertReadWithinStartBlock(schedule, false);
   207         assertReadWithinAllReturnBlocks(schedule, true);
   204         assertReadWithinAllReturnBlocks(schedule, true);
   208     }
   205     }
   209 
   206 
   210     /**
   207     /**
   222     }
   219     }
   223 
   220 
   224     @Test
   221     @Test
   225     public void testLoop3() {
   222     public void testLoop3() {
   226         ScheduleResult schedule = getFinalSchedule("testLoop3Snippet", TestMode.WITHOUT_FRAMESTATES);
   223         ScheduleResult schedule = getFinalSchedule("testLoop3Snippet", TestMode.WITHOUT_FRAMESTATES);
   227         assertDeepEquals(6, schedule.getCFG().getBlocks().length);
       
   228         assertReadWithinStartBlock(schedule, true);
   224         assertReadWithinStartBlock(schedule, true);
   229         assertReadWithinAllReturnBlocks(schedule, false);
   225         assertReadWithinAllReturnBlocks(schedule, false);
   230     }
   226     }
   231 
   227 
   232     public String testStringReplaceSnippet(String input) {
   228     public String testStringReplaceSnippet(String input) {
   258     }
   254     }
   259 
   255 
   260     @Test
   256     @Test
   261     public void testLoop5() {
   257     public void testLoop5() {
   262         ScheduleResult schedule = getFinalSchedule("testLoop5Snippet", TestMode.WITHOUT_FRAMESTATES);
   258         ScheduleResult schedule = getFinalSchedule("testLoop5Snippet", TestMode.WITHOUT_FRAMESTATES);
   263         assertDeepEquals(10, schedule.getCFG().getBlocks().length);
       
   264         assertReadWithinStartBlock(schedule, false);
   259         assertReadWithinStartBlock(schedule, false);
   265         assertReadWithinAllReturnBlocks(schedule, false);
   260         assertReadWithinAllReturnBlocks(schedule, false);
   266     }
   261     }
   267 
   262 
   268     /**
   263     /**
   287     }
   282     }
   288 
   283 
   289     @Test
   284     @Test
   290     public void testLoop6() {
   285     public void testLoop6() {
   291         ScheduleResult schedule = getFinalSchedule("testLoop6Snippet", TestMode.WITHOUT_FRAMESTATES);
   286         ScheduleResult schedule = getFinalSchedule("testLoop6Snippet", TestMode.WITHOUT_FRAMESTATES);
   292         assertDeepEquals(13, schedule.getCFG().getBlocks().length);
       
   293         assertReadWithinStartBlock(schedule, false);
   287         assertReadWithinStartBlock(schedule, false);
   294         assertReadWithinAllReturnBlocks(schedule, false);
   288         assertReadWithinAllReturnBlocks(schedule, false);
   295     }
   289     }
   296 
   290 
   297     /**
   291     /**
   320     }
   314     }
   321 
   315 
   322     @Test
   316     @Test
   323     public void testLoop7() {
   317     public void testLoop7() {
   324         ScheduleResult schedule = getFinalSchedule("testLoop7Snippet", TestMode.WITHOUT_FRAMESTATES);
   318         ScheduleResult schedule = getFinalSchedule("testLoop7Snippet", TestMode.WITHOUT_FRAMESTATES);
   325         assertDeepEquals(18, schedule.getCFG().getBlocks().length);
       
   326         assertReadWithinStartBlock(schedule, false);
   319         assertReadWithinStartBlock(schedule, false);
   327         assertReadWithinAllReturnBlocks(schedule, false);
   320         assertReadWithinAllReturnBlocks(schedule, false);
   328     }
   321     }
   329 
   322 
   330     /**
   323     /**
   347     }
   340     }
   348 
   341 
   349     @Test
   342     @Test
   350     public void testLoop8() {
   343     public void testLoop8() {
   351         ScheduleResult schedule = getFinalSchedule("testLoop8Snippet", TestMode.WITHOUT_FRAMESTATES);
   344         ScheduleResult schedule = getFinalSchedule("testLoop8Snippet", TestMode.WITHOUT_FRAMESTATES);
   352         assertDeepEquals(10, schedule.getCFG().getBlocks().length);
       
   353         assertReadWithinStartBlock(schedule, true);
   345         assertReadWithinStartBlock(schedule, true);
   354         assertReadWithinAllReturnBlocks(schedule, false);
   346         assertReadWithinAllReturnBlocks(schedule, false);
   355     }
   347     }
   356 
   348 
   357     /**
   349     /**
   389     }
   381     }
   390 
   382 
   391     @Test
   383     @Test
   392     public void testIfRead1() {
   384     public void testIfRead1() {
   393         ScheduleResult schedule = getFinalSchedule("testIfRead1Snippet", TestMode.WITHOUT_FRAMESTATES);
   385         ScheduleResult schedule = getFinalSchedule("testIfRead1Snippet", TestMode.WITHOUT_FRAMESTATES);
   394         assertDeepEquals(3, schedule.getCFG().getBlocks().length);
       
   395         assertReadWithinStartBlock(schedule, true);
   386         assertReadWithinStartBlock(schedule, true);
   396         assertReadAndWriteInSameBlock(schedule, false);
   387         assertReadAndWriteInSameBlock(schedule, false);
   397     }
   388     }
   398 
   389 
   399     /**
   390     /**
   410     }
   401     }
   411 
   402 
   412     @Test
   403     @Test
   413     public void testIfRead2() {
   404     public void testIfRead2() {
   414         ScheduleResult schedule = getFinalSchedule("testIfRead2Snippet", TestMode.WITHOUT_FRAMESTATES);
   405         ScheduleResult schedule = getFinalSchedule("testIfRead2Snippet", TestMode.WITHOUT_FRAMESTATES);
   415         assertDeepEquals(3, schedule.getCFG().getBlocks().length);
       
   416         assertDeepEquals(1, schedule.getCFG().graph.getNodes().filter(FloatingReadNode.class).count());
   406         assertDeepEquals(1, schedule.getCFG().graph.getNodes().filter(FloatingReadNode.class).count());
   417         assertReadWithinStartBlock(schedule, false);
   407         assertReadWithinStartBlock(schedule, false);
   418         assertReadWithinAllReturnBlocks(schedule, false);
   408         assertReadWithinAllReturnBlocks(schedule, false);
   419         assertReadAndWriteInSameBlock(schedule, false);
   409         assertReadAndWriteInSameBlock(schedule, false);
   420     }
   410     }
   432     }
   422     }
   433 
   423 
   434     @Test
   424     @Test
   435     public void testIfRead3() {
   425     public void testIfRead3() {
   436         ScheduleResult schedule = getFinalSchedule("testIfRead3Snippet", TestMode.WITHOUT_FRAMESTATES);
   426         ScheduleResult schedule = getFinalSchedule("testIfRead3Snippet", TestMode.WITHOUT_FRAMESTATES);
   437         assertDeepEquals(4, schedule.getCFG().getBlocks().length);
       
   438         assertReadWithinStartBlock(schedule, false);
   427         assertReadWithinStartBlock(schedule, false);
   439         assertReadWithinAllReturnBlocks(schedule, true);
   428         assertReadWithinAllReturnBlocks(schedule, true);
   440     }
   429     }
   441 
   430 
   442     /**
   431     /**
   453     }
   442     }
   454 
   443 
   455     @Test
   444     @Test
   456     public void testIfRead4() {
   445     public void testIfRead4() {
   457         ScheduleResult schedule = getFinalSchedule("testIfRead4Snippet", TestMode.WITHOUT_FRAMESTATES);
   446         ScheduleResult schedule = getFinalSchedule("testIfRead4Snippet", TestMode.WITHOUT_FRAMESTATES);
   458         assertDeepEquals(3, schedule.getCFG().getBlocks().length);
       
   459         assertReadWithinStartBlock(schedule, false);
   447         assertReadWithinStartBlock(schedule, false);
   460         assertReadWithinAllReturnBlocks(schedule, false);
   448         assertReadWithinAllReturnBlocks(schedule, false);
   461         assertReadAndWriteInSameBlock(schedule, true);
   449         assertReadAndWriteInSameBlock(schedule, true);
   462     }
   450     }
   463 
   451 
   472     }
   460     }
   473 
   461 
   474     @Test
   462     @Test
   475     public void testIfRead5() {
   463     public void testIfRead5() {
   476         ScheduleResult schedule = getFinalSchedule("testIfRead5Snippet", TestMode.WITHOUT_FRAMESTATES);
   464         ScheduleResult schedule = getFinalSchedule("testIfRead5Snippet", TestMode.WITHOUT_FRAMESTATES);
   477         assertDeepEquals(4, schedule.getCFG().getBlocks().length);
       
   478         assertReadWithinStartBlock(schedule, false);
   465         assertReadWithinStartBlock(schedule, false);
   479         assertReadWithinAllReturnBlocks(schedule, true);
   466         assertReadWithinAllReturnBlocks(schedule, true);
   480         assertReadAndWriteInSameBlock(schedule, false);
   467         assertReadAndWriteInSameBlock(schedule, false);
   481     }
   468     }
   482 
   469 
   498     }
   485     }
   499 
   486 
   500     @Test
   487     @Test
   501     public void testAntiDependency() {
   488     public void testAntiDependency() {
   502         ScheduleResult schedule = getFinalSchedule("testAntiDependencySnippet", TestMode.WITHOUT_FRAMESTATES);
   489         ScheduleResult schedule = getFinalSchedule("testAntiDependencySnippet", TestMode.WITHOUT_FRAMESTATES);
   503         assertDeepEquals(4, schedule.getCFG().getBlocks().length);
       
   504         assertReadBeforeAllWritesInStartBlock(schedule);
   490         assertReadBeforeAllWritesInStartBlock(schedule);
   505     }
   491     }
   506 
   492 
   507     /**
   493     /**
   508      * testing scheduling within a block.
   494      * testing scheduling within a block.
   525     public void testBlockSchedule() {
   511     public void testBlockSchedule() {
   526         ScheduleResult schedule = getFinalSchedule("testBlockScheduleSnippet", TestMode.WITHOUT_FRAMESTATES);
   512         ScheduleResult schedule = getFinalSchedule("testBlockScheduleSnippet", TestMode.WITHOUT_FRAMESTATES);
   527         StructuredGraph graph = schedule.getCFG().graph;
   513         StructuredGraph graph = schedule.getCFG().graph;
   528         NodeIterable<WriteNode> writeNodes = graph.getNodes().filter(WriteNode.class);
   514         NodeIterable<WriteNode> writeNodes = graph.getNodes().filter(WriteNode.class);
   529 
   515 
   530         assertDeepEquals(1, schedule.getCFG().getBlocks().length);
       
   531         assertDeepEquals(8, writeNodes.count());
   516         assertDeepEquals(8, writeNodes.count());
   532         assertDeepEquals(1, graph.getNodes().filter(FloatingReadNode.class).count());
   517         assertDeepEquals(1, graph.getNodes().filter(FloatingReadNode.class).count());
   533 
   518 
   534         FloatingReadNode read = graph.getNodes().filter(FloatingReadNode.class).first();
   519         FloatingReadNode read = graph.getNodes().filter(FloatingReadNode.class).first();
   535 
   520 
   706         OptionValues options = new OptionValues(getInitialOptions(), OptScheduleOutOfLoops, schedulingStrategy == SchedulingStrategy.LATEST_OUT_OF_LOOPS, OptImplicitNullChecks, false);
   691         OptionValues options = new OptionValues(getInitialOptions(), OptScheduleOutOfLoops, schedulingStrategy == SchedulingStrategy.LATEST_OUT_OF_LOOPS, OptImplicitNullChecks, false);
   707         final StructuredGraph graph = parseEager(snippet, AllowAssumptions.NO, options);
   692         final StructuredGraph graph = parseEager(snippet, AllowAssumptions.NO, options);
   708         DebugContext debug = graph.getDebug();
   693         DebugContext debug = graph.getDebug();
   709         try (DebugContext.Scope d = debug.scope("FloatingReadTest", graph)) {
   694         try (DebugContext.Scope d = debug.scope("FloatingReadTest", graph)) {
   710             HighTierContext context = getDefaultHighTierContext();
   695             HighTierContext context = getDefaultHighTierContext();
   711             CanonicalizerPhase canonicalizer = new CanonicalizerPhase();
   696             CanonicalizerPhase canonicalizer = createCanonicalizerPhase();
   712             canonicalizer.apply(graph, context);
   697             canonicalizer.apply(graph, context);
   713             if (mode == TestMode.INLINED_WITHOUT_FRAMESTATES) {
   698             if (mode == TestMode.INLINED_WITHOUT_FRAMESTATES) {
   714                 createInliningPhase(canonicalizer).apply(graph, context);
   699                 createInliningPhase(canonicalizer).apply(graph, context);
   715             }
   700             }
   716             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.HIGH_TIER).apply(graph, context);
   701             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.HIGH_TIER).apply(graph, context);
   727             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.MID_TIER).apply(graph, midContext);
   712             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.MID_TIER).apply(graph, midContext);
   728             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.LOW_TIER).apply(graph, midContext);
   713             new LoweringPhase(canonicalizer, LoweringTool.StandardLoweringStage.LOW_TIER).apply(graph, midContext);
   729 
   714 
   730             SchedulePhase schedule = new SchedulePhase(schedulingStrategy);
   715             SchedulePhase schedule = new SchedulePhase(schedulingStrategy);
   731             schedule.apply(graph);
   716             schedule.apply(graph);
   732             assertDeepEquals(1, graph.getNodes().filter(StartNode.class).count());
       
   733             return graph.getLastSchedule();
   717             return graph.getLastSchedule();
   734         } catch (Throwable e) {
   718         } catch (Throwable e) {
   735             throw debug.handle(e);
   719             throw debug.handle(e);
   736         }
   720         }
   737     }
   721     }