31  * @run main SpaceUtilizationCheck

    31  * @build sun.hotspot.WhiteBox

    32  * @run main ClassFileInstaller sun.hotspot.WhiteBox

    33  *                              sun.hotspot.WhiteBox$WhiteBoxPermission

    34  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI SpaceUtilizationCheck

    43     // Minimum allowed utilization value (percent)

    48     // [1] Each region must have strictly less than

    44     // The goal is to have this number to be 50% for RO and RW regions

    49     //     WhiteBox.metaspaceReserveAlignment() bytes of unused space.

    45     // Once that feature is implemented, increase the MIN_UTILIZATION to 50

    50     // [2] There must be no gap between two consecutive regions.

    46     private static final int MIN_UTILIZATION = 30;

    47 

    48     // Only RO and RW regions are considered for this check, since they

    49     // currently account for the bulk of the shared space

    50     private static final int NUMBER_OF_CHECKED_SHARED_REGIONS = 2;

    53         OutputAnalyzer output = CDSTestUtils.createArchive();

    53         // (1) Default VM arguments

    54         test();

    55 

    56         // (2) Use the now deprecated VM arguments. They should have no effect.

    57         test("-XX:SharedReadWriteSize=128M",

    58              "-XX:SharedReadOnlySize=128M",

    59              "-XX:SharedMiscDataSize=128M",

    60              "-XX:SharedMiscCodeSize=128M");

    61     }

    62 

    63     static void test(String... extra_options) throws Exception {

    64         OutputAnalyzer output = CDSTestUtils.createArchive(extra_options);

    56         String stdout = output.getStdout();

    71         long last_region = -1;

    57         ArrayList<String> utilization = findUtilization(stdout);

    72         Hashtable<String,String> checked = new Hashtable<>();

    58 

    73         for (String line : output.getStdout().split("\n")) {

    59         if (utilization.size() != NUMBER_OF_CHECKED_SHARED_REGIONS )

    74             if (line.contains(" space:") && !line.contains("st space:")) {

    60             throw new RuntimeException("The output format of sharing summary has changed");

    75                 Matcher matcher = pattern.matcher(line);

    61 

    76                 if (matcher.find()) {

    62         for(String str : utilization) {

    77                     String name = matcher.group(1);

    63             int value = Integer.parseInt(str);

    78                     if (name.equals("s0") || name.equals("s1")) {

    64             if (value < MIN_UTILIZATION) {

    79                       // String regions are listed at the end and they may not be fully occupied.

    65                 System.out.println(stdout);

    80                       break;

    66                 throw new RuntimeException("Utilization for one of the regions" +

    81                     } else {

    67                     "is below a threshold of " + MIN_UTILIZATION + "%");

    82                       System.out.println("Checking " + name + " in : " + line);

    83                       checked.put(name, name);

    84                     }

    85                     long used = Long.parseLong(matcher.group(2));

    86                     long capacity = Long.parseLong(matcher.group(3));

    87                     long address = Long.parseLong(matcher.group(4), 16);

    88                     long unused = capacity - used;

    89                     if (unused < 0) {

    90                         throw new RuntimeException("Unused space (" + unused + ") less than 0");

    91                     }

    92                     if (unused > reserve_alignment) {

    93                         // [1] Check for unused space

    94                         throw new RuntimeException("Unused space (" + unused + ") must be smaller than Metaspace::reserve_alignment() (" +

    95                                                    reserve_alignment + ")");

    96                     }

    97                     if (last_region >= 0 && address != last_region) {

    98                         // [2] Check for no-gap

    99                         throw new RuntimeException("Region 0x" + address + " should have started at 0x" + Long.toString(last_region, 16));

   100                     }

   101                     last_region = address + capacity;

   102                 }

    70     }

   105         if (checked.size() != 5) {

    71 

   106           throw new RuntimeException("Must have 5 consecutive, fully utilized regions");

    72     public static ArrayList<String> findUtilization(String input) {

    73         ArrayList<String> regions = filterRegionsOfInterest(input.split("\n"));

    74         return filterByPattern(filterByPattern(regions, "bytes \\[.*% used\\]"), "\\d+");

    75     }

    76 

    77     private static ArrayList<String> filterByPattern(Iterable<String> input, String pattern) {

    78         ArrayList<String> result = new ArrayList<String>();

    79         for (String str : input) {

    80             Matcher matcher = Pattern.compile(pattern).matcher(str);

    81             if (matcher.find()) {

    82                 result.add(matcher.group());

    83             }