rev 10932 : New G1 humongous allocation stress test
rev 10933 : @Bug removed

   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 TestStressG1Humongous

  26  * @key gc
  27  * @key stress
  28  * @summary Stress G1 by humongous allocations in situation near OOM
  29  * @requires vm.gc=="G1" | vm.gc=="null"
  30  * @run main/othervm/timeout=200 -Xlog:gc=debug -Xmx1g -XX:+UseG1GC -XX:G1HeapRegionSize=4m
  31  *              -Dtimeout=120 -Dthreads=3 -Dhumongoussize=1.1 -Dregionsize=4 TestStressG1Humongous
  32  * @run main/othervm/timeout=200 -Xlog:gc=debug -Xmx1g -XX:+UseG1GC -XX:G1HeapRegionSize=16m
  33  *              -Dtimeout=120 -Dthreads=5 -Dhumongoussize=2.1 -Dregionsize=16 TestStressG1Humongous
  34  * @run main/othervm/timeout=200 -Xlog:gc=debug -Xmx1g -XX:+UseG1GC -XX:G1HeapRegionSize=32m
  35  *              -Dtimeout=120 -Dthreads=4 -Dhumongoussize=0.6 -Dregionsize=32 TestStressG1Humongous
  36  * @run main/othervm/timeout=700 -Xlog:gc=debug -Xmx1g -XX:+UseG1GC -XX:G1HeapRegionSize=1m
  37  *              -Dtimeout=600 -Dthreads=7 -Dhumongoussize=0.6 -Dregionsize=1 TestStressG1Humongous
  38  */
  39 
  40 import java.util.ArrayList;
  41 import java.util.List;
  42 import java.util.Collections;
  43 import java.util.concurrent.CountDownLatch;
  44 import java.util.concurrent.ExecutorService;
  45 import java.util.concurrent.Executors;
  46 import java.util.concurrent.atomic.AtomicInteger;
  47 
  48 public class TestStressG1Humongous {
  49 
  50     // Timeout in seconds
  51     private static final int TIMEOUT = Integer.getInteger("timeout", 60);
  52     private static final int THREAD_COUNT = Integer.getInteger("threads", 2);
  53     private static final int REGION_SIZE = Integer.getInteger("regionsize", 1) * 1024 * 1024;
  54     private static final int HUMONGOUS_SIZE = (int) (REGION_SIZE * Double.parseDouble(System.getProperty("humongoussize", "1.5")));
  55 
  56     private volatile boolean isRunning;
  57     private final ExecutorService threadExecutor;
  58     private final AtomicInteger alocatedObjectsCount;
  59     private CountDownLatch countDownLatch;
  60     public static final List<Object> GARBAGE = Collections.synchronizedList(new ArrayList<>());
  61 
  62     public static void main(String[] args) throws InterruptedException {
  63         new TestStressG1Humongous().run();
  64     }
  65 
  66     public TestStressG1Humongous() {
  67         isRunning = true;
  68         threadExecutor = Executors.newFixedThreadPool(THREAD_COUNT + 1);
  69         alocatedObjectsCount = new AtomicInteger(0);
  70     }
  71 
  72     private void run() throws InterruptedException {
  73         threadExecutor.submit(new Timer());
  74         int checkedAmountOfHObjects = getExpectedAmountOfObjects();
  75         while (isRunning()) {
  76             countDownLatch = new CountDownLatch(THREAD_COUNT);
  77             startAllocationThreads(checkedAmountOfHObjects);
  78             countDownLatch.await();
  79             GARBAGE.clear();
  80             System.out.println("Allocated " + alocatedObjectsCount.get() + " objects.");
  81             alocatedObjectsCount.set(0);
  82         }
  83         threadExecutor.shutdown();
  84         System.out.println("Done!");
  85     }
  86 
  87     /**
  88      * Tries to fill available memory with humongous objects to get expected amount.
  89      * @return expected amount of humongous objects
  90      */
  91     private int getExpectedAmountOfObjects() {
  92         long maxMem = Runtime.getRuntime().maxMemory();
  93         int expectedHObjects = (int) (maxMem / HUMONGOUS_SIZE);
  94         // Will allocate 1 region less to give some free space for VM.
  95         int checkedAmountOfHObjects = checkHeapCapacity(expectedHObjects) - 1;
  96         return checkedAmountOfHObjects;
  97     }
  98 
  99     /**
 100      * Starts several threads to allocate the requested amount of humongous objects.
 101      * @param totalObjects total amount of object that will be created
 102      */
 103     private void startAllocationThreads(int totalObjects) {
 104         int objectsPerThread = totalObjects / THREAD_COUNT;
 105         int objectsForLastThread = objectsPerThread + totalObjects % THREAD_COUNT;
 106         for (int i = 0; i < THREAD_COUNT - 1; ++i) {
 107             threadExecutor.submit(new AllocationThread(countDownLatch, objectsPerThread, alocatedObjectsCount));
 108         }
 109         threadExecutor.submit(new AllocationThread(countDownLatch, objectsForLastThread, alocatedObjectsCount));
 110     }
 111 
 112     /**
 113      * Creates a humongous object of the predefined size.
 114      */
 115     private void createObject() {
 116         GARBAGE.add(new byte[HUMONGOUS_SIZE]);
 117     }
 118 
 119     /**
 120      * Tries to create the requested amount of humongous objects.
 121      * In case of OOME, stops creating and cleans the created garbage.
 122      * @param expectedObjects amount of objects based on heap size
 123      * @return amount of created objects
 124      */
 125     private int checkHeapCapacity(int expectedObjects) {
 126         int allocated = 0;
 127         try {
 128             while (isRunning() && allocated < expectedObjects) {
 129                 createObject();
 130                 ++allocated;
 131             }
 132         } catch (OutOfMemoryError oome) {
 133             GARBAGE.clear();
 134         }
 135         return allocated;
 136     }
 137 
 138     private void setDone() {
 139         isRunning = false;
 140     }
 141 
 142     private boolean isRunning() {
 143         return isRunning;
 144     }
 145 
 146     /**
 147      * Thread which allocates requested amount of humongous objects.
 148      */
 149     private class AllocationThread implements Runnable {
 150 
 151         private final int totalObjects;
 152         private final CountDownLatch cdl;
 153         private final AtomicInteger allocationCounter;
 154 
 155         /**
 156          * Creates allocation thread
 157          * @param cdl CountDownLatch
 158          * @param objects amount of objects to allocate
 159          * @param counter
 160          */
 161         public AllocationThread(CountDownLatch cdl, int objects, AtomicInteger counter) {
 162             totalObjects = objects;
 163             this.cdl = cdl;
 164             allocationCounter = counter;
 165         }
 166 
 167         @Override
 168         public void run() {
 169             int allocatedObjects = 0;
 170             try {
 171                 while (isRunning && allocatedObjects < totalObjects) {
 172                     createObject();
 173                     allocatedObjects++;
 174                     allocationCounter.incrementAndGet();
 175                 }
 176 
 177             } catch (OutOfMemoryError oome) {
 178                 GARBAGE.clear();
 179                 System.out.print("OOME was caught.");
 180                 System.out.println(" Allocated in thread: " + allocatedObjects + " . Totally allocated: " + allocationCounter.get() + ".");
 181             } finally {
 182                 cdl.countDown();
 183             }
 184         }
 185     }
 186 
 187     /**
 188      * Simple Runnable which waits TIMEOUT and sets isRunning to false.
 189      */
 190     class Timer implements Runnable {
 191 
 192         @Override
 193         public void run() {
 194             try {
 195                 Thread.sleep(TIMEOUT * 1000);
 196             } catch (InterruptedException ex) {
 197             }
 198             setDone();
 199         }
 200     }
 201 }
--- EOF ---