1 /* 2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test TestPLABPromotion 26 * @bug 8141278 8141141 27 * @summary Test PLAB promotion 28 * @requires vm.gc=="G1" | vm.gc=="null" 29 * @requires vm.opt.FlightRecorder != true 30 * @library /testlibrary /test/lib / 31 * @modules java.management 32 * @build ClassFileInstaller 33 * sun.hotspot.WhiteBox 34 * gc.g1.plab.lib.MemoryConsumer 35 * gc.g1.plab.lib.LogParser 36 * gc.g1.plab.lib.AppPLABPromotion 37 * @run main ClassFileInstaller sun.hotspot.WhiteBox 38 * sun.hotspot.WhiteBox$WhiteBoxPermission 39 * @run main/timeout=240 gc.g1.plab.TestPLABPromotion 40 */ 41 package gc.g1.plab; 42 43 import java.util.List; 44 import java.util.Arrays; 45 import java.io.PrintStream; 46 47 import gc.g1.plab.lib.AppPLABPromotion; 48 import gc.g1.plab.lib.LogParser; 49 import gc.g1.plab.lib.PLABUtils; 50 import gc.g1.plab.lib.PlabInfo; 51 52 import jdk.test.lib.OutputAnalyzer; 53 import jdk.test.lib.ProcessTools; 54 55 /** 56 * Test checks PLAB promotion of different size objects. 57 */ 58 public class TestPLABPromotion { 59 60 // GC ID with survivor PLAB statistics 61 private final static long GC_ID_SURVIVOR_STATS = 1l; 62 // GC ID with old PLAB statistics 63 private final static long GC_ID_OLD_STATS = 2l; 64 65 private final static String PLAB_USED_FIELD_NAME = "used"; 66 private final static String PLAB_DIRECT_ALLOCATED_FIELD_NAME = "direct allocated"; 67 private final static List<String> FIELDS_TO_EXTRACT = Arrays.asList(PLAB_USED_FIELD_NAME, PLAB_DIRECT_ALLOCATED_FIELD_NAME); 68 69 private static String output; 70 71 // Allowable difference for memory consumption (percentage) 72 private final static long MEM_DIFFERENCE_PCT = 5; 73 74 private static final int PLAB_SIZE_SMALL = 1024; 75 private static final int PLAB_SIZE_MEDIUM = 4096; 76 private static final int PLAB_SIZE_HIGH = 65536; 77 private static final int OBJECT_SIZE_SMALL = 10; 78 private static final int OBJECT_SIZE_MEDIUM = 100; 79 private static final int OBJECT_SIZE_HIGH = 1000; 80 private static final int GC_NUM_SMALL = 1; 81 private static final int GC_NUM_MEDIUM = 3; 82 private static final int GC_NUM_HIGH = 7; 83 private static final int WASTE_PCT_SMALL = 10; 84 private static final int WASTE_PCT_MEDIUM = 20; 85 private static final int WASTE_PCT_HIGH = 30; 86 private static final int YOUNG_SIZE_LOW = 16; 87 private static final int YOUNG_SIZE_HIGH = 64; 88 private static final boolean PLAB_FIXED = true; 89 private static final boolean PLAB_DYNAMIC = false; 90 91 private final static TestCase[] TEST_CASES = { 92 // Test cases for unreachable object, PLAB size is fixed 93 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_SMALL, OBJECT_SIZE_MEDIUM, GC_NUM_SMALL, YOUNG_SIZE_LOW, PLAB_FIXED, false, false), 94 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_MEDIUM, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_FIXED, false, false), 95 // Test cases for reachable objects, PLAB size is fixed 96 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_SMALL, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_FIXED, true, true), 97 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_MEDIUM, OBJECT_SIZE_MEDIUM, GC_NUM_SMALL, YOUNG_SIZE_LOW, PLAB_FIXED, true, true), 98 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_SMALL, OBJECT_SIZE_HIGH, GC_NUM_MEDIUM, YOUNG_SIZE_LOW, PLAB_FIXED, true, false), 99 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_HIGH, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_FIXED, true, true), 100 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_SMALL, OBJECT_SIZE_MEDIUM, GC_NUM_SMALL, YOUNG_SIZE_LOW, PLAB_FIXED, true, true), 101 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_MEDIUM, OBJECT_SIZE_HIGH, GC_NUM_MEDIUM, YOUNG_SIZE_LOW, PLAB_FIXED, true, true), 102 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_SMALL, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_FIXED, true, true), 103 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_HIGH, OBJECT_SIZE_MEDIUM, GC_NUM_SMALL, YOUNG_SIZE_LOW, PLAB_FIXED, true, true), 104 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_SMALL, OBJECT_SIZE_HIGH, GC_NUM_MEDIUM, YOUNG_SIZE_HIGH, PLAB_FIXED, true, false), 105 // Test cases for unreachable object, PLAB size is not fixed 106 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_MEDIUM, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_LOW, PLAB_DYNAMIC, false, false), 107 // Test cases for reachable objects, PLAB size is not fixed 108 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_HIGH, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_DYNAMIC, true, true), 109 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_MEDIUM, OBJECT_SIZE_SMALL, GC_NUM_SMALL, YOUNG_SIZE_LOW, PLAB_DYNAMIC, true, true), 110 new TestCase(WASTE_PCT_SMALL, PLAB_SIZE_MEDIUM, OBJECT_SIZE_HIGH, GC_NUM_HIGH, YOUNG_SIZE_HIGH, PLAB_DYNAMIC, true, false), 111 new TestCase(WASTE_PCT_MEDIUM, PLAB_SIZE_SMALL, OBJECT_SIZE_MEDIUM, GC_NUM_MEDIUM, YOUNG_SIZE_LOW, PLAB_DYNAMIC, true, true), 112 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_HIGH, OBJECT_SIZE_MEDIUM, GC_NUM_SMALL, YOUNG_SIZE_HIGH, PLAB_DYNAMIC, true, true), 113 new TestCase(WASTE_PCT_HIGH, PLAB_SIZE_HIGH, OBJECT_SIZE_SMALL, GC_NUM_HIGH, YOUNG_SIZE_LOW, PLAB_DYNAMIC, true, true) 114 }; 115 116 public static void main(String[] args) throws Throwable { 117 118 for (TestCase testCase : TEST_CASES) { 119 // What we going to check. 120 testCase.print(System.out); 121 List<String> options = PLABUtils.prepareOptions(testCase.toOptions()); 122 options.add(AppPLABPromotion.class.getName()); 123 OutputAnalyzer out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()])); 124 if (out.getExitValue() != 0) { 125 System.out.println(out.getOutput()); 126 throw new RuntimeException("Expect exit code 0."); 127 } 128 output = out.getOutput(); 129 checkResults(testCase); 130 } 131 } 132 133 private static void checkResults(TestCase testCase) { 134 long plabAllocatedSurvivor; 135 long directAllocatedSurvivor; 136 long plabAllocatedOld; 137 long directAllocatedOld; 138 long memAllocated = testCase.getMemToFill(); 139 LogParser logParser = new LogParser(output); 140 141 PlabInfo survivorPlabInfo = logParser.getSpecifiedStats(GC_ID_SURVIVOR_STATS, LogParser.ReportType.SURVIVOR_STATS, FIELDS_TO_EXTRACT); 142 PlabInfo oldPlabInfo = logParser.getSpecifiedStats(GC_ID_OLD_STATS, LogParser.ReportType.OLD_STATS, FIELDS_TO_EXTRACT); 143 144 checkFields(survivorPlabInfo); 145 checkFields(oldPlabInfo); 146 147 plabAllocatedSurvivor = survivorPlabInfo.get(PLAB_USED_FIELD_NAME); 148 directAllocatedSurvivor = survivorPlabInfo.get(PLAB_DIRECT_ALLOCATED_FIELD_NAME); 149 plabAllocatedOld = oldPlabInfo.get(PLAB_USED_FIELD_NAME); 150 directAllocatedOld = oldPlabInfo.get(PLAB_DIRECT_ALLOCATED_FIELD_NAME); 151 152 System.out.printf("Survivor PLAB allocated:%17d Direct allocated: %17d Mem consumed:%17d%n", plabAllocatedSurvivor, directAllocatedSurvivor, memAllocated); 153 System.out.printf("Old PLAB allocated:%17d Direct allocated: %17d Mem consumed:%17d%n", plabAllocatedOld, directAllocatedOld, memAllocated); 154 155 // Unreachable objects case 156 if (testCase.isDeadObjectCase()) { 157 checkDeadObjectsPromotion(plabAllocatedSurvivor, directAllocatedSurvivor, memAllocated); 158 checkDeadObjectsPromotion(plabAllocatedOld, directAllocatedOld, memAllocated); 159 160 } else { 161 // Live objects case 162 if (testCase.isPromotedByPLAB()) { 163 checkLiveObjectsPromotion(plabAllocatedSurvivor, memAllocated, "Expect that Survivor PLAB allocation are similar to all mem consumed"); 164 checkLiveObjectsPromotion(plabAllocatedOld, memAllocated, "Expect that Old PLAB allocation are similar to all mem consumed"); 165 } else { 166 // All big objects should be directly allocated 167 checkLiveObjectsPromotion(directAllocatedSurvivor, memAllocated, "Expect that Survivor direct allocation are similar to all mem consumed"); 168 checkLiveObjectsPromotion(directAllocatedOld, memAllocated, "Expect that Old direct allocation are similar to all mem consumed"); 169 } 170 171 checkTotalPromotion(plabAllocatedSurvivor, directAllocatedSurvivor, memAllocated, "Expect that Survivor gen total allocation are similar to all mem consumed"); 172 checkTotalPromotion(plabAllocatedOld, directAllocatedOld, memAllocated, "Expect that Old gen total allocation are similar to all mem consumed"); 173 } 174 System.out.println("Test passed!"); 175 } 176 177 private static void checkTotalPromotion(long plabAllocatedSurvivor, long directAllocatedSurvivor, long memAllocated, String exceptionMessage) { 178 // All promoted objects size should be similar to all consumed memory 179 if (!checkDifferenceRatio(plabAllocatedSurvivor + directAllocatedSurvivor, memAllocated)) { 180 System.out.println(output); 181 throw new RuntimeException(exceptionMessage); 182 } 183 } 184 185 /** 186 * Checks that live objects were promoted as expected. 187 * @param plabAllocated 188 * @param totalMemAllocated 189 * @param exceptionMessage 190 */ 191 private static void checkLiveObjectsPromotion(long plabAllocated, long totalMemAllocated, String exceptionMessage) { 192 // All live small objects should be promoted using PLAB 193 if (!checkDifferenceRatio(plabAllocated, totalMemAllocated)) { 194 System.out.println(output); 195 throw new RuntimeException(exceptionMessage); 196 } 197 } 198 199 /** 200 * Checks that dead objects are not promoted. 201 * @param plabPromoted promoted by PLAB 202 * @param directlyPromoted 203 * @param memoryAllocated total memory allocated 204 */ 205 private static void checkDeadObjectsPromotion(long plabPromoted, long directlyPromoted, long memoryAllocated) { 206 // No dead objects should be promoted 207 if (!(checkRatio(plabPromoted, memoryAllocated) && checkRatio(directlyPromoted, memoryAllocated))) { 208 System.out.println(output); 209 throw new RuntimeException("Unreachable objects should not be allocated using PLAB or directly allocated to Survivor/Old"); 210 } 211 } 212 213 /** 214 * Checks that PLAB statistics contains expected fields. 215 * @param info 216 */ 217 private static void checkFields(PlabInfo info) { 218 if (!info.checkFields(FIELDS_TO_EXTRACT)) { 219 System.out.println(output); 220 throw new RuntimeException("PLAB log does not contain expected fields"); 221 } 222 } 223 224 /** 225 * Returns true if checkedValue is less than MEM_DIFFERENCE_PCT percent of controlValue. 226 * 227 * @param checkedValue - checked value 228 * @param controlValue - referent value 229 * @return true if checkedValue is less than MEM_DIFFERENCE_PCT percent of controlValue 230 */ 231 private static boolean checkRatio(long checkedValue, long controlValue) { 232 return (Math.abs(checkedValue) / controlValue) * 100L < MEM_DIFFERENCE_PCT; 233 } 234 235 /** 236 * Returns true if difference of checkedValue and controlValue is less than 237 * MEM_DIFFERENCE_PCT percent of controlValue. 238 * 239 * @param checkedValue - checked value 240 * @param controlValue - referent value 241 * @return true if difference of checkedValue and controlValue is less than 242 * MEM_DIFFERENCE_PCT percent of controlValue 243 */ 244 private static boolean checkDifferenceRatio(long checkedValue, long controlValue) { 245 return (Math.abs(checkedValue - controlValue) / controlValue) * 100L < MEM_DIFFERENCE_PCT; 246 } 247 248 /** 249 * Description of one test case. 250 */ 251 private static class TestCase { 252 253 private final int wastePct; 254 private final int plabSize; 255 private final int chunkSize; 256 private final int parGCThreads; 257 private final int edenSize; 258 private final boolean plabIsFixed; 259 private final boolean objectsAreReachable; 260 private final boolean promotedByPLAB; 261 262 /** 263 * @param wastePct 264 * ParallelGCBufferWastePct 265 * @param plabSize 266 * -XX:OldPLABSize and -XX:YoungPLABSize 267 * @param chunkSize 268 * requested object size for memory consumption 269 * @param parGCThreads 270 * -XX:ParallelGCThreads 271 * @param edenSize 272 * NewSize and MaxNewSize 273 * @param plabIsFixed 274 * Use dynamic PLAB or fixed size PLAB 275 * @param objectsAreReachable 276 * true - allocate live objects 277 * false - allocate unreachable objects 278 * @param promotedByPLAB 279 * true - we expect to see PLAB allocation during promotion 280 * false - objects will be directly allocated during promotion 281 */ 282 public TestCase(int wastePct, 283 int plabSize, 284 int chunkSize, 285 int parGCThreads, 286 int edenSize, 287 boolean plabIsFixed, 288 boolean objectsAreReachable, 289 boolean promotedByPLAB 290 ) { 291 if (wastePct == 0 || plabSize == 0 || chunkSize == 0 || parGCThreads == 0 || edenSize == 0) { 292 throw new IllegalArgumentException("Parameters should not be 0"); 293 } 294 this.wastePct = wastePct; 295 this.plabSize = plabSize; 296 this.chunkSize = chunkSize; 297 this.parGCThreads = parGCThreads; 298 this.edenSize = edenSize; 299 this.plabIsFixed = plabIsFixed; 300 this.objectsAreReachable = objectsAreReachable; 301 this.promotedByPLAB = promotedByPLAB; 302 } 303 304 /** 305 * Convert current TestCase to List of options. 306 * Assume test will fill half of existed eden. 307 * 308 * @return 309 * List of options 310 */ 311 public List<String> toOptions() { 312 return Arrays.asList("-XX:ParallelGCThreads=" + parGCThreads, 313 "-XX:ParallelGCBufferWastePct=" + wastePct, 314 "-XX:OldPLABSize=" + plabSize, 315 "-XX:YoungPLABSize=" + plabSize, 316 "-XX:" + (plabIsFixed ? "-" : "+") + "ResizePLAB", 317 "-Dchunk.size=" + chunkSize, 318 "-Dreachable=" + objectsAreReachable, 319 "-XX:NewSize=" + edenSize + "m", 320 "-XX:MaxNewSize=" + edenSize + "m", 321 "-Dmem.to.fill=" + getMemToFill() 322 ); 323 } 324 325 /** 326 * Print details about test case. 327 */ 328 public void print(PrintStream out) { 329 boolean expectPLABAllocation = promotedByPLAB && objectsAreReachable; 330 boolean expectDirectAllocation = (!promotedByPLAB) && objectsAreReachable; 331 332 out.println("Test case details:"); 333 out.println(" Young gen size : " + edenSize + "M"); 334 out.println(" Predefined PLAB size : " + plabSize); 335 out.println(" Parallel GC buffer waste pct : " + wastePct); 336 out.println(" Chunk size : " + chunkSize); 337 out.println(" Parallel GC threads : " + parGCThreads); 338 out.println(" Objects are created : " + (objectsAreReachable ? "reachable" : "unreachable")); 339 out.println(" PLAB size is fixed: " + (plabIsFixed ? "yes" : "no")); 340 out.println("Test expectations:"); 341 out.println(" PLAB allocation : " + (expectPLABAllocation ? "expected" : "unexpected")); 342 out.println(" Direct allocation : " + (expectDirectAllocation ? "expected" : "unexpected")); 343 } 344 345 /** 346 * @return 347 * true if we expect PLAB allocation 348 * false if no 349 */ 350 public boolean isPromotedByPLAB() { 351 return promotedByPLAB; 352 } 353 354 /** 355 * @return 356 * true if it is test case for unreachable objects 357 * false for live objects 358 */ 359 public boolean isDeadObjectCase() { 360 return !objectsAreReachable; 361 } 362 363 /** 364 * Returns amount of memory to fill 365 * 366 * @return amount of memory 367 */ 368 public long getMemToFill() { 369 return (long) (edenSize) * 1024l * 1024l / 2; 370 } 371 } 372 }