hotspot/test/gc/g1/ihop/TestIHOPErgo.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 TestIHOPErgo
  * @bug 8148397
  * @summary Test checks that behavior of Adaptive and Static IHOP at concurrent cycle initiation
  * @requires vm.gc=="G1" | vm.gc=="null"
  * @requires vm.opt.FlightRecorder != true
  * @requires vm.opt.ExplicitGCInvokesConcurrent != true
  * @library /testlibrary /test/lib /
  * @modules java.base/jdk.internal.misc
  * @modules java.management
  * @build gc.g1.ihop.TestIHOPErgo
  *        gc.g1.ihop.lib.IhopUtils
  * @run driver/timeout=480 gc.g1.ihop.TestIHOPErgo
  */
 package gc.g1.ihop;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;

 import jdk.test.lib.OutputAnalyzer;
 import jdk.test.lib.ProcessTools;

 import gc.g1.ihop.lib.IhopUtils;

 /**
  * The test starts the AppIHOP multiple times varying settings of MaxHeapSize.
  * The test parses GC log from AppIHOP to check:
  * - occupancy is not less than threshold for Adaptive and Static IHOP at
  * concurrent cycle initiation
  * - Adaptive IHOP prediction was started during AppIHOP executing
  * - log contains ergonomic messages in log
  */
 public class TestIHOPErgo {

     // Common GC tune and logging options for test.
     private final static String[] COMMON_OPTIONS = {
         "-XX:+UnlockExperimentalVMOptions",
         "-XX:G1MixedGCLiveThresholdPercent=100",
         "-XX:G1HeapWastePercent=0",
         "-XX:MaxGCPauseMillis=30000",
         "-XX:G1MixedGCCountTarget=1",
         "-XX:+UseG1GC",
         "-XX:G1HeapRegionSize=1m",
         "-XX:+G1UseAdaptiveIHOP",
         "-Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug",
         "-XX:+AlwaysTenure",
         "-XX:G1AdaptiveIHOPNumInitialSamples=1",
         "-XX:InitiatingHeapOccupancyPercent=30"
     };

     public static void main(String[] args) throws Throwable {

         // heap size MB, sleep time for allocator, true/false for adaptive/static
         runTest(64, 0, false);
         runTest(64, 100, false);
         runTest(128, 100, false);
         runTest(256, 50, false);
         runTest(512, 30, false);
         runTest(64, 50, true);
         runTest(128, 200, true);
         runTest(256, 100, true);
         runTest(512, 50, true);
     }

     /**
      * Runs AppIHOP in separate VM and checks GC log.
      *
      * @param heapSize       heap size
      * @param sleepTime      sleep time between memory allocations.
      * @param isIhopAdaptive true forAdaptive IHOP, false for Static
      *
      * @throws Throwable
      */
     private static void runTest(int heapSize, int sleepTime, boolean isIhopAdaptive) throws Throwable {
         System.out.println("IHOP test:");
         System.out.println("  MaxHeapSize : " + heapSize);

         List<String> options = new ArrayList<>();
         Collections.addAll(options,
                 "-Dheap.size=" + heapSize,
                 "-Dsleep.time=" + sleepTime,
                 "-XX:MaxHeapSize=" + heapSize + "M",
                 "-XX:NewSize=" + heapSize / 8 + "M",
                 "-XX:MaxNewSize=" + heapSize / 8 + "M",
                 "-XX:InitialHeapSize=" + heapSize + "M",
                 "-XX:" + (isIhopAdaptive ? "+" : "-") + "G1UseAdaptiveIHOP"
         );

         Collections.addAll(options, COMMON_OPTIONS);
         options.add(AppIHOP.class.getName());
         OutputAnalyzer out = executeTest(options);

         // Checks that log contains message which indicates that IHOP prediction is active
         if (isIhopAdaptive) {
             IhopUtils.checkAdaptiveIHOPWasActivated(out);
         }
         // Checks that log contains messages which indicates that VM initiates/checks heap occupancy
         // and tries to start concurrent cycle.
         IhopUtils.checkErgoMessagesExist(out);

         // Checks threshold and occupancy values
         IhopUtils.checkIhopLogValues(out);
     }

     private static OutputAnalyzer executeTest(List<String> options) throws Throwable, RuntimeException {
         OutputAnalyzer out;
         out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
         if (out.getExitValue() != 0) {
             System.out.println(out.getOutput());
             throw new RuntimeException("AppIHOP failed with exit code" + out.getExitValue());
         }
         return out;
     }

     /**
      * The AppIHOP fills 60% of heap and allocates and frees 30% of existing
      * heap 'iterations' times to achieve IHOP activation. To be executed in
      * separate VM. Expected properties:
      * heap.size - heap size which is used to calculate amount of memory
      *             to be allocated and freed
      * sleep.time - short pause between filling each MB
      */
     public static class AppIHOP {

         public final static LinkedList<Object> GARBAGE = new LinkedList<>();

         private final int ITERATIONS = 10;
         private final int OBJECT_SIZE = 100000;
         // 60% of the heap will be filled before test cycles.
         // 30% of the heap will be filled and freed during test cycle.
         private final long HEAP_PREALLOC_PCT = 60;
         private final long HEAP_ALLOC_PCT = 30;
         private final long HEAP_SIZE;
         // Amount of memory to be allocated before iterations start
         private final long HEAP_PREALLOC_SIZE;
         // Amount of memory to be allocated and freed during iterations
         private final long HEAP_ALLOC_SIZE;
         private final int SLEEP_TIME;

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

         AppIHOP() {
             HEAP_SIZE = Integer.getInteger("heap.size") * 1024 * 1024;
             SLEEP_TIME = Integer.getInteger("sleep.time");

             HEAP_PREALLOC_SIZE = HEAP_SIZE * HEAP_PREALLOC_PCT / 100;
             HEAP_ALLOC_SIZE = HEAP_SIZE * HEAP_ALLOC_PCT / 100;
         }

         public void start() throws InterruptedException {
             fill(HEAP_PREALLOC_SIZE);
             fillAndFree(HEAP_ALLOC_SIZE, ITERATIONS);
         }

         /**
          * Fills allocationSize bytes of garbage.
          *
          * @param allocationSize amount of garbage
          */
         private void fill(long allocationSize) {
             long allocated = 0;
             while (allocated < allocationSize) {
                 GARBAGE.addFirst(new byte[OBJECT_SIZE]);
                 allocated += OBJECT_SIZE;
             }
         }

         /**
          * Allocates allocationSize bytes of garbage. Performs a short pauses
          * during allocation. Frees allocated garbage.
          *
          * @param allocationSize amount of garbage per iteration
          * @param iterations     iteration count
          *
          * @throws InterruptedException
          */
         private void fillAndFree(long allocationSize, int iterations) throws InterruptedException {

             for (int i = 0; i < iterations; ++i) {
                 System.out.println("Iteration:" + i);
                 long allocated = 0;
                 long counter = 0;
                 while (allocated < allocationSize) {
                     GARBAGE.addFirst(new byte[OBJECT_SIZE]);
                     allocated += OBJECT_SIZE;
                     counter += OBJECT_SIZE;
                     if (counter > 1024 * 1024) {
                         counter = 0;
                         if (SLEEP_TIME != 0) {
                             Thread.sleep(SLEEP_TIME);
                         }
                     }
                 }
                 long removed = 0;
                 while (removed < allocationSize) {
                     GARBAGE.removeLast();
                     removed += OBJECT_SIZE;
                 }
             }
         }
     }
 }
	/*
	* 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 TestIHOPErgo
	* @bug 8148397
	* @summary Test checks that behavior of Adaptive and Static IHOP at concurrent cycle initiation
	* @requires vm.gc=="G1" \| vm.gc=="null"
	* @requires vm.opt.FlightRecorder != true
	* @requires vm.opt.ExplicitGCInvokesConcurrent != true
	* @library /testlibrary /test/lib /
	* @modules java.base/jdk.internal.misc
	* @modules java.management
	* @build gc.g1.ihop.TestIHOPErgo
	* gc.g1.ihop.lib.IhopUtils
	* @run driver/timeout=480 gc.g1.ihop.TestIHOPErgo
	*/
	package gc.g1.ihop;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.LinkedList;
	import java.util.List;

	import jdk.test.lib.OutputAnalyzer;
	import jdk.test.lib.ProcessTools;

	import gc.g1.ihop.lib.IhopUtils;

	/**
	* The test starts the AppIHOP multiple times varying settings of MaxHeapSize.
	* The test parses GC log from AppIHOP to check:
	* - occupancy is not less than threshold for Adaptive and Static IHOP at
	* concurrent cycle initiation
	* - Adaptive IHOP prediction was started during AppIHOP executing
	* - log contains ergonomic messages in log
	*/
	public class TestIHOPErgo {

	// Common GC tune and logging options for test.
	private final static String[] COMMON_OPTIONS = {
	"-XX:+UnlockExperimentalVMOptions",
	"-XX:G1MixedGCLiveThresholdPercent=100",
	"-XX:G1HeapWastePercent=0",
	"-XX:MaxGCPauseMillis=30000",
	"-XX:G1MixedGCCountTarget=1",
	"-XX:+UseG1GC",
	"-XX:G1HeapRegionSize=1m",
	"-XX:+G1UseAdaptiveIHOP",
	"-Xlog:gc+ihop=debug,gc+ihop+ergo=debug,gc+ergo=debug",
	"-XX:+AlwaysTenure",
	"-XX:G1AdaptiveIHOPNumInitialSamples=1",
	"-XX:InitiatingHeapOccupancyPercent=30"
	};

	public static void main(String[] args) throws Throwable {

	// heap size MB, sleep time for allocator, true/false for adaptive/static
	runTest(64, 0, false);
	runTest(64, 100, false);
	runTest(128, 100, false);
	runTest(256, 50, false);
	runTest(512, 30, false);
	runTest(64, 50, true);
	runTest(128, 200, true);
	runTest(256, 100, true);
	runTest(512, 50, true);
	}

	/**
	* Runs AppIHOP in separate VM and checks GC log.
	*
	* @param heapSize heap size
	* @param sleepTime sleep time between memory allocations.
	* @param isIhopAdaptive true forAdaptive IHOP, false for Static
	*
	* @throws Throwable
	*/
	private static void runTest(int heapSize, int sleepTime, boolean isIhopAdaptive) throws Throwable {
	System.out.println("IHOP test:");
	System.out.println(" MaxHeapSize : " + heapSize);

	List<String> options = new ArrayList<>();
	Collections.addAll(options,
	"-Dheap.size=" + heapSize,
	"-Dsleep.time=" + sleepTime,
	"-XX:MaxHeapSize=" + heapSize + "M",
	"-XX:NewSize=" + heapSize / 8 + "M",
	"-XX:MaxNewSize=" + heapSize / 8 + "M",
	"-XX:InitialHeapSize=" + heapSize + "M",
	"-XX:" + (isIhopAdaptive ? "+" : "-") + "G1UseAdaptiveIHOP"
	);

	Collections.addAll(options, COMMON_OPTIONS);
	options.add(AppIHOP.class.getName());
	OutputAnalyzer out = executeTest(options);

	// Checks that log contains message which indicates that IHOP prediction is active
	if (isIhopAdaptive) {
	IhopUtils.checkAdaptiveIHOPWasActivated(out);
	}
	// Checks that log contains messages which indicates that VM initiates/checks heap occupancy
	// and tries to start concurrent cycle.
	IhopUtils.checkErgoMessagesExist(out);

	// Checks threshold and occupancy values
	IhopUtils.checkIhopLogValues(out);
	}

	private static OutputAnalyzer executeTest(List<String> options) throws Throwable, RuntimeException {
	OutputAnalyzer out;
	out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
	if (out.getExitValue() != 0) {
	System.out.println(out.getOutput());
	throw new RuntimeException("AppIHOP failed with exit code" + out.getExitValue());
	}
	return out;
	}

	/**
	* The AppIHOP fills 60% of heap and allocates and frees 30% of existing
	* heap 'iterations' times to achieve IHOP activation. To be executed in
	* separate VM. Expected properties:
	* heap.size - heap size which is used to calculate amount of memory
	* to be allocated and freed
	* sleep.time - short pause between filling each MB
	*/
	public static class AppIHOP {

	public final static LinkedList<Object> GARBAGE = new LinkedList<>();

	private final int ITERATIONS = 10;
	private final int OBJECT_SIZE = 100000;
	// 60% of the heap will be filled before test cycles.
	// 30% of the heap will be filled and freed during test cycle.
	private final long HEAP_PREALLOC_PCT = 60;
	private final long HEAP_ALLOC_PCT = 30;
	private final long HEAP_SIZE;
	// Amount of memory to be allocated before iterations start
	private final long HEAP_PREALLOC_SIZE;
	// Amount of memory to be allocated and freed during iterations
	private final long HEAP_ALLOC_SIZE;
	private final int SLEEP_TIME;

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

	AppIHOP() {
	HEAP_SIZE = Integer.getInteger("heap.size") * 1024 * 1024;
	SLEEP_TIME = Integer.getInteger("sleep.time");

	HEAP_PREALLOC_SIZE = HEAP_SIZE * HEAP_PREALLOC_PCT / 100;
	HEAP_ALLOC_SIZE = HEAP_SIZE * HEAP_ALLOC_PCT / 100;
	}

	public void start() throws InterruptedException {
	fill(HEAP_PREALLOC_SIZE);
	fillAndFree(HEAP_ALLOC_SIZE, ITERATIONS);
	}

	/**
	* Fills allocationSize bytes of garbage.
	*
	* @param allocationSize amount of garbage
	*/
	private void fill(long allocationSize) {
	long allocated = 0;
	while (allocated < allocationSize) {
	GARBAGE.addFirst(new byte[OBJECT_SIZE]);
	allocated += OBJECT_SIZE;
	}
	}

	/**
	* Allocates allocationSize bytes of garbage. Performs a short pauses
	* during allocation. Frees allocated garbage.
	*
	* @param allocationSize amount of garbage per iteration
	* @param iterations iteration count
	*
	* @throws InterruptedException
	*/
	private void fillAndFree(long allocationSize, int iterations) throws InterruptedException {

	for (int i = 0; i < iterations; ++i) {
	System.out.println("Iteration:" + i);
	long allocated = 0;
	long counter = 0;
	while (allocated < allocationSize) {
	GARBAGE.addFirst(new byte[OBJECT_SIZE]);
	allocated += OBJECT_SIZE;
	counter += OBJECT_SIZE;
	if (counter > 1024 * 1024) {
	counter = 0;
	if (SLEEP_TIME != 0) {
	Thread.sleep(SLEEP_TIME);
	}
	}
	}
	long removed = 0;
	while (removed < allocationSize) {
	GARBAGE.removeLast();
	removed += OBJECT_SIZE;
	}
	}
	}
	}
	}