< prev index next >

test/hotspot/jtreg/compiler/c2/aarch64/TestVolatiles.java

Print this page




  22  */
  23 
  24 /*
  25  * common code to run and validate tests of code generation for
  26  * volatile ops on AArch64
  27  *
  28  * incoming args are <testclass> <testtype>
  29  *
  30  * where <testclass> in {TestVolatileLoad,
  31  *                       TestVolatileStore,
  32  *                       TestUnsafeVolatileLoad,
  33  *                       TestUnsafeVolatileStore,
  34  *                       TestUnsafeVolatileCAS,
  35  *                       TestUnsafeVolatileWeakCAS,
  36  *                       TestUnsafeVolatileCAE,
  37  *                       TestUnsafeVolatileGAS}
  38  * and <testtype> in {G1,
  39  *                    CMS,
  40  *                    CMSCondMark,
  41  *                    Serial,
  42  *                    Parallel}


  43  */
  44 
  45 
  46 package compiler.c2.aarch64;
  47 
  48 import java.util.List;
  49 import java.util.ListIterator;
  50 import java.util.Iterator;
  51 import java.util.regex.Pattern;
  52 import java.io.*;
  53 
  54 import jdk.test.lib.Asserts;
  55 import jdk.test.lib.compiler.InMemoryJavaCompiler;
  56 import jdk.test.lib.process.OutputAnalyzer;
  57 import jdk.test.lib.process.ProcessTools;
  58 import sun.hotspot.WhiteBox;
  59 
  60 // runner class that spawns a new JVM to exercises a combination of
  61 // volatile MemOp and GC. The ops are compiled with the dmb -->
  62 // ldar/stlr transforms either enabled or disabled. this runner parses


  83             procArgs = new String[argcount];
  84             procArgs[argcount - 2] = "-XX:+UseParallelGC";
  85             break;
  86         case "Serial":
  87             argcount = 9;
  88             procArgs = new String[argcount];
  89             procArgs[argcount - 2] = "-XX:+UseSerialGC";
  90             break;
  91         case "CMS":
  92             argcount = 10;
  93             procArgs = new String[argcount];
  94             procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";
  95             procArgs[argcount - 2] = "-XX:-UseCondCardMark";
  96             break;
  97         case "CMSCondMark":
  98             argcount = 10;
  99             procArgs = new String[argcount];
 100             procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";
 101             procArgs[argcount - 2] = "-XX:+UseCondCardMark";
 102             break;












 103         default:
 104             throw new RuntimeException("unexpected test type " + testType);
 105         }
 106 
 107         // fill in arguments common to all cases
 108 
 109         // the first round of test enables transform of barriers to
 110         // use acquiring loads and releasing stores by setting arg
 111         // zero appropriately. this arg is reset in the second run to
 112         // disable the transform.
 113 
 114         procArgs[0] = "-XX:-UseBarriersForVolatile";
 115         procArgs[1] = "-XX:+UseCompressedOops";
 116 
 117         procArgs[2] = "-XX:-TieredCompilation";
 118         procArgs[3] = "-XX:+PrintOptoAssembly";
 119         procArgs[4] = "-XX:CompileCommand=compileonly," + fullclassname + "::" + "test*";
 120         procArgs[5] = "--add-exports";
 121         procArgs[6] = "java.base/jdk.internal.misc=ALL-UNNAMED";
 122         procArgs[argcount - 1] = fullclassname;


 338                     "strb",
 339                     "membar_volatile \\(elided\\)",
 340                     "ret"
 341                 };
 342                 break;
 343             case "CMS":
 344                 // a volatile card mark membar should not be generated
 345                 // before the card mark strb from the StoreCM and the
 346                 // storestore barrier from the StoreCM should be
 347                 // generated as "dmb ishst"
 348                 matches = new String[] {
 349                     "membar_release \\(elided\\)",
 350                     useCompressedOops ? "stlrw?" : "stlr",
 351                     "storestore",
 352                     "dmb ishst",
 353                     "strb",
 354                     "membar_volatile \\(elided\\)",
 355                     "ret"
 356                 };
 357                 break;











 358             }
 359         } else {
 360             switch (testType) {
 361             default:
 362                 // this is the basic sequence of instructions
 363                 matches = new String[] {
 364                     "membar_release",
 365                     "dmb ish",
 366                     useCompressedOops ? "strw?" : "str",
 367                     "membar_volatile",
 368                     "dmb ish",
 369                     "ret"
 370                 };
 371                 break;
 372             case "G1":
 373                 // a card mark volatile barrier should be generated
 374                 // before the card mark strb
 375                 matches = new String[] {
 376                     "membar_release",
 377                     "dmb ish",


 401                     "ret"
 402                 };
 403                 break;
 404             case "CMS":
 405                 // a volatile card mark membar should not be generated
 406                 // before the card mark strb from the StoreCM and the
 407                 // storestore barrier from the StoreCM should be generated
 408                 // as "dmb ishst"
 409                 matches = new String[] {
 410                     "membar_release",
 411                     "dmb ish",
 412                     useCompressedOops ? "strw?" : "str",
 413                     "storestore",
 414                     "dmb ishst",
 415                     "strb",
 416                     "membar_volatile",
 417                     "dmb ish",
 418                     "ret"
 419                 };
 420                 break;














 421             }
 422         }
 423 
 424         checkCompile(iter, "testObj", matches, output, true);
 425     }
 426 
 427     // check for expected asm output from a volatile cas
 428 
 429     private void checkcas(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable
 430     {
 431         Iterator<String> iter = output.asLines().listIterator();
 432 
 433         String[] matches;
 434         String[][] tests = {
 435             { "testInt", "cmpxchgw" },
 436             { "testLong", "cmpxchg" },
 437             { "testByte", "cmpxchgb" },
 438             { "testShort", "cmpxchgs" },
 439         };
 440 


 503                     "storestore \\(elided\\)",
 504                     "strb",
 505                     "membar_acquire \\(elided\\)",
 506                     "ret"
 507                 };
 508                 break;
 509             case "CMS":
 510                 // a volatile card mark membar should not be generated
 511                 // before the card mark strb from the StoreCM and the
 512                 // storestore barrier from the StoreCM should be elided
 513                 matches = new String[] {
 514                     "membar_release \\(elided\\)",
 515                     useCompressedOops ? "cmpxchgw?_acq" : "cmpxchg_acq",
 516                     "storestore",
 517                     "dmb ishst",
 518                     "strb",
 519                     "membar_acquire \\(elided\\)",
 520                     "ret"
 521                 };
 522                 break;











 523             }
 524         } else {
 525             switch (testType) {
 526             default:
 527                 // this is the basic sequence of instructions
 528                 matches = new String[] {
 529                     "membar_release",
 530                     "dmb ish",
 531                     useCompressedOops ? "cmpxchgw? " : "cmpxchg ",
 532                     "membar_acquire",
 533                     "dmb ish",
 534                     "ret"
 535                 };
 536                 break;
 537             case "G1":
 538                 // a card mark volatile barrier should be generated
 539                 // before the card mark strb
 540                 matches = new String[] {
 541                     "membar_release",
 542                     "dmb ish",


 742                     "dmb ish",
 743                     "storestore \\(elided\\)",
 744                     "strb",
 745                     "membar_acquire",
 746                     "dmb ish",
 747                     "ret"
 748                 };
 749                 break;
 750             case "CMS":
 751                 // a volatile card mark membar should not be generated
 752                 // before the card mark strb from the StoreCM and the
 753                 // storestore barrier from the StoreCM should be generated
 754                 // as "dmb ishst"
 755                 matches = new String[] {
 756                     "membar_release",
 757                     "dmb ish",
 758                     useCompressedOops ? "cmpxchgw? " : "cmpxchg ",
 759                     "storestore",
 760                     "dmb ishst",
 761                     "strb",













 762                     "membar_acquire",
 763                     "dmb ish",
 764                     "ret"
 765                 };
 766                 break;
 767             }
 768         }
 769 
 770         checkCompile(iter, "testObj", matches, output, true);
 771     }
 772 
 773     private void checkgas(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable
 774     {
 775         Iterator<String> iter = output.asLines().listIterator();
 776 
 777         String[] matches;
 778         String[][] tests = {
 779             { "testInt", "atomic_xchgw" },
 780             { "testLong", "atomic_xchg" },
 781         };




  22  */
  23 
  24 /*
  25  * common code to run and validate tests of code generation for
  26  * volatile ops on AArch64
  27  *
  28  * incoming args are <testclass> <testtype>
  29  *
  30  * where <testclass> in {TestVolatileLoad,
  31  *                       TestVolatileStore,
  32  *                       TestUnsafeVolatileLoad,
  33  *                       TestUnsafeVolatileStore,
  34  *                       TestUnsafeVolatileCAS,
  35  *                       TestUnsafeVolatileWeakCAS,
  36  *                       TestUnsafeVolatileCAE,
  37  *                       TestUnsafeVolatileGAS}
  38  * and <testtype> in {G1,
  39  *                    CMS,
  40  *                    CMSCondMark,
  41  *                    Serial,
  42  *                    Parallel,
  43  *                    Shenandoah,
  44  *                    ShenandoahIU}
  45  */
  46 
  47 
  48 package compiler.c2.aarch64;
  49 
  50 import java.util.List;
  51 import java.util.ListIterator;
  52 import java.util.Iterator;
  53 import java.util.regex.Pattern;
  54 import java.io.*;
  55 
  56 import jdk.test.lib.Asserts;
  57 import jdk.test.lib.compiler.InMemoryJavaCompiler;
  58 import jdk.test.lib.process.OutputAnalyzer;
  59 import jdk.test.lib.process.ProcessTools;
  60 import sun.hotspot.WhiteBox;
  61 
  62 // runner class that spawns a new JVM to exercises a combination of
  63 // volatile MemOp and GC. The ops are compiled with the dmb -->
  64 // ldar/stlr transforms either enabled or disabled. this runner parses


  85             procArgs = new String[argcount];
  86             procArgs[argcount - 2] = "-XX:+UseParallelGC";
  87             break;
  88         case "Serial":
  89             argcount = 9;
  90             procArgs = new String[argcount];
  91             procArgs[argcount - 2] = "-XX:+UseSerialGC";
  92             break;
  93         case "CMS":
  94             argcount = 10;
  95             procArgs = new String[argcount];
  96             procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";
  97             procArgs[argcount - 2] = "-XX:-UseCondCardMark";
  98             break;
  99         case "CMSCondMark":
 100             argcount = 10;
 101             procArgs = new String[argcount];
 102             procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";
 103             procArgs[argcount - 2] = "-XX:+UseCondCardMark";
 104             break;
 105         case "Shenandoah":
 106             argcount = 8;
 107             procArgs = new String[argcount];
 108             procArgs[argcount - 2] = "-XX:+UseShenandoahGC";
 109             break;        
 110         case "ShenandoahIU":
 111             argcount = 11;
 112             procArgs = new String[argcount];
 113             procArgs[argcount - 4] = "-XX:+UnlockExperimentalVMOptions";
 114             procArgs[argcount - 3] = "-XX:+UseShenandoahGC";
 115             procArgs[argcount - 2] = "-XX:ShenandoahGCMode=iu";
 116             break;
 117         default:
 118             throw new RuntimeException("unexpected test type " + testType);
 119         }
 120 
 121         // fill in arguments common to all cases
 122 
 123         // the first round of test enables transform of barriers to
 124         // use acquiring loads and releasing stores by setting arg
 125         // zero appropriately. this arg is reset in the second run to
 126         // disable the transform.
 127 
 128         procArgs[0] = "-XX:-UseBarriersForVolatile";
 129         procArgs[1] = "-XX:+UseCompressedOops";
 130 
 131         procArgs[2] = "-XX:-TieredCompilation";
 132         procArgs[3] = "-XX:+PrintOptoAssembly";
 133         procArgs[4] = "-XX:CompileCommand=compileonly," + fullclassname + "::" + "test*";
 134         procArgs[5] = "--add-exports";
 135         procArgs[6] = "java.base/jdk.internal.misc=ALL-UNNAMED";
 136         procArgs[argcount - 1] = fullclassname;


 352                     "strb",
 353                     "membar_volatile \\(elided\\)",
 354                     "ret"
 355                 };
 356                 break;
 357             case "CMS":
 358                 // a volatile card mark membar should not be generated
 359                 // before the card mark strb from the StoreCM and the
 360                 // storestore barrier from the StoreCM should be
 361                 // generated as "dmb ishst"
 362                 matches = new String[] {
 363                     "membar_release \\(elided\\)",
 364                     useCompressedOops ? "stlrw?" : "stlr",
 365                     "storestore",
 366                     "dmb ishst",
 367                     "strb",
 368                     "membar_volatile \\(elided\\)",
 369                     "ret"
 370                 };
 371                 break;
 372             case "Shenandoah":
 373             case "ShenandoahIU":
 374                  // Shenandoah generates normal object graphs for
 375                  // volatile stores
 376                 matches = new String[] {
 377                     "membar_release (elided)",
 378                     "stlrw",
 379                     "membar_volatile (elided)",
 380                     "ret"
 381                 };
 382                 break;
 383             }
 384         } else {
 385             switch (testType) {
 386             default:
 387                 // this is the basic sequence of instructions
 388                 matches = new String[] {
 389                     "membar_release",
 390                     "dmb ish",
 391                     useCompressedOops ? "strw?" : "str",
 392                     "membar_volatile",
 393                     "dmb ish",
 394                     "ret"
 395                 };
 396                 break;
 397             case "G1":
 398                 // a card mark volatile barrier should be generated
 399                 // before the card mark strb
 400                 matches = new String[] {
 401                     "membar_release",
 402                     "dmb ish",


 426                     "ret"
 427                 };
 428                 break;
 429             case "CMS":
 430                 // a volatile card mark membar should not be generated
 431                 // before the card mark strb from the StoreCM and the
 432                 // storestore barrier from the StoreCM should be generated
 433                 // as "dmb ishst"
 434                 matches = new String[] {
 435                     "membar_release",
 436                     "dmb ish",
 437                     useCompressedOops ? "strw?" : "str",
 438                     "storestore",
 439                     "dmb ishst",
 440                     "strb",
 441                     "membar_volatile",
 442                     "dmb ish",
 443                     "ret"
 444                 };
 445                 break;
 446 
 447             case "Shenandoah":
 448             case "ShenandoahIU":
 449                  // Shenandoah generates normal object graphs for
 450                  // volatile stores
 451                 matches = new String[] {
 452                     "membar_release",
 453                     "dmb ish",
 454                     "strw",
 455                     "membar_volatile",
 456                     "dmb ish",
 457                     "ret"
 458                 };
 459                 break;
 460             }
 461         }
 462 
 463         checkCompile(iter, "testObj", matches, output, true);
 464     }
 465 
 466     // check for expected asm output from a volatile cas
 467 
 468     private void checkcas(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable
 469     {
 470         Iterator<String> iter = output.asLines().listIterator();
 471 
 472         String[] matches;
 473         String[][] tests = {
 474             { "testInt", "cmpxchgw" },
 475             { "testLong", "cmpxchg" },
 476             { "testByte", "cmpxchgb" },
 477             { "testShort", "cmpxchgs" },
 478         };
 479 


 542                     "storestore \\(elided\\)",
 543                     "strb",
 544                     "membar_acquire \\(elided\\)",
 545                     "ret"
 546                 };
 547                 break;
 548             case "CMS":
 549                 // a volatile card mark membar should not be generated
 550                 // before the card mark strb from the StoreCM and the
 551                 // storestore barrier from the StoreCM should be elided
 552                 matches = new String[] {
 553                     "membar_release \\(elided\\)",
 554                     useCompressedOops ? "cmpxchgw?_acq" : "cmpxchg_acq",
 555                     "storestore",
 556                     "dmb ishst",
 557                     "strb",
 558                     "membar_acquire \\(elided\\)",
 559                     "ret"
 560                 };
 561                 break;
 562             case "Shenandoah":
 563             case "ShenandoahIU":
 564                 // For volatile CAS, Shenanodoah generates normal
 565                 // graphs with a shenandoah-specific cmpxchg
 566                 matches = new String[] {
 567                     "membar_release (elided)",
 568                     "cmpxchgw_acq_shenandoah",
 569                     "membar_acquire (elided)",
 570                     "ret"
 571                 };
 572                 break;
 573             }
 574         } else {
 575             switch (testType) {
 576             default:
 577                 // this is the basic sequence of instructions
 578                 matches = new String[] {
 579                     "membar_release",
 580                     "dmb ish",
 581                     useCompressedOops ? "cmpxchgw? " : "cmpxchg ",
 582                     "membar_acquire",
 583                     "dmb ish",
 584                     "ret"
 585                 };
 586                 break;
 587             case "G1":
 588                 // a card mark volatile barrier should be generated
 589                 // before the card mark strb
 590                 matches = new String[] {
 591                     "membar_release",
 592                     "dmb ish",


 792                     "dmb ish",
 793                     "storestore \\(elided\\)",
 794                     "strb",
 795                     "membar_acquire",
 796                     "dmb ish",
 797                     "ret"
 798                 };
 799                 break;
 800             case "CMS":
 801                 // a volatile card mark membar should not be generated
 802                 // before the card mark strb from the StoreCM and the
 803                 // storestore barrier from the StoreCM should be generated
 804                 // as "dmb ishst"
 805                 matches = new String[] {
 806                     "membar_release",
 807                     "dmb ish",
 808                     useCompressedOops ? "cmpxchgw? " : "cmpxchg ",
 809                     "storestore",
 810                     "dmb ishst",
 811                     "strb",
 812                     "membar_acquire",
 813                     "dmb ish",
 814                     "ret"
 815                 };
 816                 break;
 817             case "Shenandoah":
 818             case "ShenandoahIU":
 819                 // For volatile CAS, Shenanodoah generates normal
 820                 // graphs with a shenandoah-specific cmpxchg
 821                 matches = new String[] {
 822                     "membar_release",
 823                     "dmb ish",
 824                     "cmpxchgw_shenandoah",
 825                     "membar_acquire",
 826                     "dmb ish",
 827                     "ret"
 828                 };
 829                 break;
 830             }
 831         }
 832 
 833         checkCompile(iter, "testObj", matches, output, true);
 834     }
 835 
 836     private void checkgas(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable
 837     {
 838         Iterator<String> iter = output.asLines().listIterator();
 839 
 840         String[] matches;
 841         String[][] tests = {
 842             { "testInt", "atomic_xchgw" },
 843             { "testLong", "atomic_xchg" },
 844         };


< prev index next >