test/hotspot/jtreg/gc/stress/TestStressG1Humongous.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /*
  * @test TestStressG1Humongous
  * @key gc stress
  * @summary Stress G1 by humongous allocations in situation near OOM
  * @requires vm.gc.G1
  * @requires !vm.flightRecorder
  * @library /test/lib
  * @modules java.base/jdk.internal.misc
  * @run driver/timeout=1300 TestStressG1Humongous
  */

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Collections;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;

 import jdk.test.lib.Platform;
 import jdk.test.lib.Utils;
 import jdk.test.lib.process.ProcessTools;
 import jdk.test.lib.process.OutputAnalyzer;

 public class TestStressG1Humongous{

     public static void main(String[] args) throws Exception {
         // Limit heap size on 32-bit platforms
         int heapSize = Platform.is32bit() ? 512 : 1024;
         // Heap size, region size, threads, humongous size, timeout
         run(heapSize, 4, 3, 1.1, 120);
         run(heapSize, 16, 5, 2.1, 120);
         run(heapSize, 32, 4, 0.6, 120);
         run(heapSize, 1, 7, 0.6, 600);
     }

     private static void run(int heapSize, int regionSize, int threads, double humongousSize, int timeout)
             throws Exception {
         ArrayList<String> options = new ArrayList<>();
         Collections.addAll(options, Utils.getTestJavaOpts());
         Collections.addAll(options,
                 "-Xlog:gc=debug",
                 "-Xmx" + heapSize + "m",
                 "-XX:+UseG1GC",
                 "-XX:G1HeapRegionSize=" + regionSize + "m",
                 "-Dtimeout=" + timeout,
                 "-Dthreads=" + threads,
                 "-Dhumongoussize=" + humongousSize,
                 "-Dregionsize=" + regionSize,
                 TestStressG1HumongousImpl.class.getName()
         );
         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(options.toArray(new String[options.size()]));
         OutputAnalyzer output = new OutputAnalyzer(pb.start());
         output.shouldHaveExitValue(0);
     }
 }

 class TestStressG1HumongousImpl {
     // Timeout in seconds
     private static final int TIMEOUT = Integer.getInteger("timeout", 60);
     private static final int THREAD_COUNT = Integer.getInteger("threads", 2);
     private static final int REGION_SIZE = Integer.getInteger("regionsize", 1) * 1024 * 1024;
     private static final int HUMONGOUS_SIZE = (int) (REGION_SIZE * Double.parseDouble(System.getProperty("humongoussize", "1.5")));
     private static final int NUMBER_OF_FREE_REGIONS = 2;

     private volatile boolean isRunning;
     private final Thread[] threads;
     private final AtomicInteger alocatedObjectsCount;
     private CountDownLatch countDownLatch;
     public static final List<Object> GARBAGE = Collections.synchronizedList(new ArrayList<>());

     public static void main(String[] args) throws InterruptedException {
         new TestStressG1HumongousImpl().run();
     }

     public TestStressG1HumongousImpl() {
         isRunning = true;
         threads = new Thread[THREAD_COUNT];
         alocatedObjectsCount = new AtomicInteger(0);
     }

     private void run() throws InterruptedException {
         new Thread(new Timer()).start();
         int checkedAmountOfHObjects = getExpectedAmountOfObjects();
         while (isRunning()) {
             countDownLatch = new CountDownLatch(THREAD_COUNT);
             startAllocationThreads(checkedAmountOfHObjects);
             countDownLatch.await();
             GARBAGE.clear();
             System.out.println("Allocated " + alocatedObjectsCount.get() + " objects.");
             alocatedObjectsCount.set(0);
         }
         System.out.println("Done!");
     }

     /**
      * Tries to fill available memory with humongous objects to get expected amount.
      * @return expected amount of humongous objects
      */
     private int getExpectedAmountOfObjects() {
         long maxMem = Runtime.getRuntime().maxMemory();
         int expectedHObjects = (int) (maxMem / HUMONGOUS_SIZE);
         // Will allocate NUMBER_OF_FREE_REGIONS region less to give some free space for VM.
         int checkedAmountOfHObjects = checkHeapCapacity(expectedHObjects) - NUMBER_OF_FREE_REGIONS;
         if (checkedAmountOfHObjects <= 0) {
             throw new RuntimeException("Cannot start testing because selected maximum heap "
                     + "is not large enough to contain more than " + NUMBER_OF_FREE_REGIONS + " regions");
         }
         return checkedAmountOfHObjects;
     }

     /**
      * Starts several threads to allocate the requested amount of humongous objects.
      * @param totalObjects total amount of object that will be created
      */
     private void startAllocationThreads(int totalObjects) {
         int objectsPerThread = totalObjects / THREAD_COUNT;
         int objectsForLastThread = objectsPerThread + totalObjects % THREAD_COUNT;
         for (int i = 0; i < THREAD_COUNT - 1; ++i) {
             threads[i] = new Thread(new AllocationThread(countDownLatch, objectsPerThread, alocatedObjectsCount));
         }
         threads[THREAD_COUNT - 1] = new Thread(new AllocationThread(countDownLatch, objectsForLastThread, alocatedObjectsCount));
         for (int i = 0; i < THREAD_COUNT; ++i) {
             threads[i].start();
         }
     }

     /**
      * Creates a humongous object of the predefined size.
      */
     private void createObject() {
         GARBAGE.add(new byte[HUMONGOUS_SIZE]);
     }

     /**
      * Tries to create the requested amount of humongous objects.
      * In case of OOME, stops creating and cleans the created garbage.
      * @param expectedObjects amount of objects based on heap size
      * @return amount of created objects
      */
     private int checkHeapCapacity(int expectedObjects) {
         int allocated = 0;
         try {
             while (isRunning() && allocated < expectedObjects) {
                 createObject();
                 ++allocated;
             }
         } catch (OutOfMemoryError oome) {
             GARBAGE.clear();
         }
         return allocated;
     }

     private void setDone() {
         isRunning = false;
     }

     private boolean isRunning() {
         return isRunning;
     }

     /**
      * Thread which allocates requested amount of humongous objects.
      */
     private class AllocationThread implements Runnable {

         private final int totalObjects;
         private final CountDownLatch cdl;
         private final AtomicInteger allocationCounter;

         /**
          * Creates allocation thread
          * @param cdl CountDownLatch
          * @param objects amount of objects to allocate
          * @param counter
          */
         public AllocationThread(CountDownLatch cdl, int objects, AtomicInteger counter) {
             totalObjects = objects;
             this.cdl = cdl;
             allocationCounter = counter;
         }

         @Override
         public void run() {
             int allocatedObjects = 0;
             try {
                 while (isRunning && allocatedObjects < totalObjects) {
                     createObject();
                     allocatedObjects++;
                     allocationCounter.incrementAndGet();
                 }

             } catch (OutOfMemoryError oome) {
                 GARBAGE.clear();
                 System.out.print("OOME was caught.");
                 System.out.println(" Allocated in thread: " + allocatedObjects + " . Totally allocated: " + allocationCounter.get() + ".");
             } finally {
                 cdl.countDown();
             }
         }
     }

     /**
      * Simple Runnable which waits TIMEOUT and sets isRunning to false.
      */
     class Timer implements Runnable {

         @Override
         public void run() {
             try {
                 Thread.sleep(TIMEOUT * 1000);
             } catch (InterruptedException ex) {
             }
             setDone();
         }
     }
 }
	/*
	* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* @test TestStressG1Humongous
	* @key gc stress
	* @summary Stress G1 by humongous allocations in situation near OOM
	* @requires vm.gc.G1
	* @requires !vm.flightRecorder
	* @library /test/lib
	* @modules java.base/jdk.internal.misc
	* @run driver/timeout=1300 TestStressG1Humongous
	*/

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Collections;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.atomic.AtomicInteger;

	import jdk.test.lib.Platform;
	import jdk.test.lib.Utils;
	import jdk.test.lib.process.ProcessTools;
	import jdk.test.lib.process.OutputAnalyzer;

	public class TestStressG1Humongous{

	public static void main(String[] args) throws Exception {
	// Limit heap size on 32-bit platforms
	int heapSize = Platform.is32bit() ? 512 : 1024;
	// Heap size, region size, threads, humongous size, timeout
	run(heapSize, 4, 3, 1.1, 120);
	run(heapSize, 16, 5, 2.1, 120);
	run(heapSize, 32, 4, 0.6, 120);
	run(heapSize, 1, 7, 0.6, 600);
	}

	private static void run(int heapSize, int regionSize, int threads, double humongousSize, int timeout)
	throws Exception {
	ArrayList<String> options = new ArrayList<>();
	Collections.addAll(options, Utils.getTestJavaOpts());
	Collections.addAll(options,
	"-Xlog:gc=debug",
	"-Xmx" + heapSize + "m",
	"-XX:+UseG1GC",
	"-XX:G1HeapRegionSize=" + regionSize + "m",
	"-Dtimeout=" + timeout,
	"-Dthreads=" + threads,
	"-Dhumongoussize=" + humongousSize,
	"-Dregionsize=" + regionSize,
	TestStressG1HumongousImpl.class.getName()
	);
	ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(options.toArray(new String[options.size()]));
	OutputAnalyzer output = new OutputAnalyzer(pb.start());
	output.shouldHaveExitValue(0);
	}
	}

	class TestStressG1HumongousImpl {
	// Timeout in seconds
	private static final int TIMEOUT = Integer.getInteger("timeout", 60);
	private static final int THREAD_COUNT = Integer.getInteger("threads", 2);
	private static final int REGION_SIZE = Integer.getInteger("regionsize", 1) * 1024 * 1024;
	private static final int HUMONGOUS_SIZE = (int) (REGION_SIZE * Double.parseDouble(System.getProperty("humongoussize", "1.5")));
	private static final int NUMBER_OF_FREE_REGIONS = 2;

	private volatile boolean isRunning;
	private final Thread[] threads;
	private final AtomicInteger alocatedObjectsCount;
	private CountDownLatch countDownLatch;
	public static final List<Object> GARBAGE = Collections.synchronizedList(new ArrayList<>());

	public static void main(String[] args) throws InterruptedException {
	new TestStressG1HumongousImpl().run();
	}

	public TestStressG1HumongousImpl() {
	isRunning = true;
	threads = new Thread[THREAD_COUNT];
	alocatedObjectsCount = new AtomicInteger(0);
	}

	private void run() throws InterruptedException {
	new Thread(new Timer()).start();
	int checkedAmountOfHObjects = getExpectedAmountOfObjects();
	while (isRunning()) {
	countDownLatch = new CountDownLatch(THREAD_COUNT);
	startAllocationThreads(checkedAmountOfHObjects);
	countDownLatch.await();
	GARBAGE.clear();
	System.out.println("Allocated " + alocatedObjectsCount.get() + " objects.");
	alocatedObjectsCount.set(0);
	}
	System.out.println("Done!");
	}

	/**
	* Tries to fill available memory with humongous objects to get expected amount.
	* @return expected amount of humongous objects
	*/
	private int getExpectedAmountOfObjects() {
	long maxMem = Runtime.getRuntime().maxMemory();
	int expectedHObjects = (int) (maxMem / HUMONGOUS_SIZE);
	// Will allocate NUMBER_OF_FREE_REGIONS region less to give some free space for VM.
	int checkedAmountOfHObjects = checkHeapCapacity(expectedHObjects) - NUMBER_OF_FREE_REGIONS;
	if (checkedAmountOfHObjects <= 0) {
	throw new RuntimeException("Cannot start testing because selected maximum heap "
	+ "is not large enough to contain more than " + NUMBER_OF_FREE_REGIONS + " regions");
	}
	return checkedAmountOfHObjects;
	}

	/**
	* Starts several threads to allocate the requested amount of humongous objects.
	* @param totalObjects total amount of object that will be created
	*/
	private void startAllocationThreads(int totalObjects) {
	int objectsPerThread = totalObjects / THREAD_COUNT;
	int objectsForLastThread = objectsPerThread + totalObjects % THREAD_COUNT;
	for (int i = 0; i < THREAD_COUNT - 1; ++i) {
	threads[i] = new Thread(new AllocationThread(countDownLatch, objectsPerThread, alocatedObjectsCount));
	}
	threads[THREAD_COUNT - 1] = new Thread(new AllocationThread(countDownLatch, objectsForLastThread, alocatedObjectsCount));
	for (int i = 0; i < THREAD_COUNT; ++i) {
	threads[i].start();
	}
	}

	/**
	* Creates a humongous object of the predefined size.
	*/
	private void createObject() {
	GARBAGE.add(new byte[HUMONGOUS_SIZE]);
	}

	/**
	* Tries to create the requested amount of humongous objects.
	* In case of OOME, stops creating and cleans the created garbage.
	* @param expectedObjects amount of objects based on heap size
	* @return amount of created objects
	*/
	private int checkHeapCapacity(int expectedObjects) {
	int allocated = 0;
	try {
	while (isRunning() && allocated < expectedObjects) {
	createObject();
	++allocated;
	}
	} catch (OutOfMemoryError oome) {
	GARBAGE.clear();
	}
	return allocated;
	}

	private void setDone() {
	isRunning = false;
	}

	private boolean isRunning() {
	return isRunning;
	}

	/**
	* Thread which allocates requested amount of humongous objects.
	*/
	private class AllocationThread implements Runnable {

	private final int totalObjects;
	private final CountDownLatch cdl;
	private final AtomicInteger allocationCounter;

	/**
	* Creates allocation thread
	* @param cdl CountDownLatch
	* @param objects amount of objects to allocate
	* @param counter
	*/
	public AllocationThread(CountDownLatch cdl, int objects, AtomicInteger counter) {
	totalObjects = objects;
	this.cdl = cdl;
	allocationCounter = counter;
	}

	@Override
	public void run() {
	int allocatedObjects = 0;
	try {
	while (isRunning && allocatedObjects < totalObjects) {
	createObject();
	allocatedObjects++;
	allocationCounter.incrementAndGet();
	}

	} catch (OutOfMemoryError oome) {
	GARBAGE.clear();
	System.out.print("OOME was caught.");
	System.out.println(" Allocated in thread: " + allocatedObjects + " . Totally allocated: " + allocationCounter.get() + ".");
	} finally {
	cdl.countDown();
	}
	}
	}

	/**
	* Simple Runnable which waits TIMEOUT and sets isRunning to false.
	*/
	class Timer implements Runnable {

	@Override
	public void run() {
	try {
	Thread.sleep(TIMEOUT * 1000);
	} catch (InterruptedException ex) {
	}
	setDone();
	}
	}
	}