test/gc/survivorAlignment/SurvivorAlignmentTestMain.java - platform/external/jetbrains/jdk8u_hotspot - Git at Google

 /*
  * Copyright (c) 2014, 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.
  */

 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryPoolMXBean;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import com.oracle.java.testlibrary.Asserts;
 import com.sun.management.ThreadMXBean;
 import sun.hotspot.WhiteBox;
 import sun.misc.Unsafe;

 /**
  * Main class for tests on {@code SurvivorAlignmentInBytes} option.
  *
  * Typical usage is to obtain instance using fromArgs method, allocate objects
  * and verify that actual memory usage in tested heap space is close to
  * expected.
  */
 public class SurvivorAlignmentTestMain {
     enum HeapSpace {
         EDEN,
         SURVIVOR,
         TENURED
     }

     public static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

     public static final long MAX_TENURING_THRESHOLD = Optional.ofNullable(
             SurvivorAlignmentTestMain.WHITE_BOX.getIntxVMFlag(
                     "MaxTenuringThreshold")).orElse(15L);

     /**
      * Regexp used to parse memory size params, like 2G, 34m or 15k.
      */
     private static final Pattern SIZE_REGEX
             = Pattern.compile("(?<size>[0-9]+)(?<multiplier>[GMKgmk])?");

     // Names of different heap spaces.
     private static final String DEF_NEW_EDEN = "Eden Space";
     private static final String DEF_NEW_SURVIVOR = "Survivor Space";
     private static final String PAR_NEW_EDEN = "Par Eden Space";
     private static final String PAR_NEW_SURVIVOR = "Par Survivor Space";
     private static final String PS_EDEN = "PS Eden Space";
     private static final String PS_SURVIVOR = "PS Survivor Space";
     private static final String G1_EDEN = "G1 Eden Space";
     private static final String G1_SURVIVOR = "G1 Survivor Space";
     private static final String SERIAL_TENURED = "Tenured Gen";
     private static final String CMS_TENURED = "CMS Old Gen";
     private static final String PS_TENURED = "PS Old Gen";
     private static final String G1_TENURED = "G1 Old Gen";

     private static final long G1_HEAP_REGION_SIZE = Optional.ofNullable(
             SurvivorAlignmentTestMain.WHITE_BOX.getUintxVMFlag(
                     "G1HeapRegionSize")).orElse(-1L);

     /**
      * Min size of free chunk in CMS generation.
      * An object allocated in CMS generation will at least occupy this amount
      * of bytes.
      */
     private static final long CMS_MIN_FREE_CHUNK_SIZE
             = 3L * Unsafe.ADDRESS_SIZE;

     private static final AlignmentHelper EDEN_SPACE_HELPER;
     private static final AlignmentHelper SURVIVOR_SPACE_HELPER;
     private static final AlignmentHelper TENURED_SPACE_HELPER;
     /**
      * Amount of memory that should be filled during a test run.
      */
     private final long memoryToFill;
     /**
      * The size of an objects that will be allocated during a test run.
      */
     private final long objectSize;
     /**
      * Amount of memory that will be actually occupied by an object in eden
      * space.
      */
     private final long actualObjectSize;
     /**
      * Storage for allocated objects.
      */
     private final Object[] garbage;
     /**
      * Heap space whose memory usage is a subject of assertions during the test
      * run.
      */
     private final HeapSpace testedSpace;

     private long[] baselinedThreadMemoryUsage = null;
     private long[] threadIds = null;

     /**
      * Initialize {@code EDEN_SPACE_HELPER}, {@code SURVIVOR_SPACE_HELPER} and
      * {@code TENURED_SPACE_HELPER} to represent heap spaces in use.
      *
      * Note that regardless to GC object's alignment in survivor space is
      * expected to be equal to {@code SurvivorAlignmentInBytes} value and
      * alignment in other spaces is expected to be equal to
      * {@code ObjectAlignmentInBytes} value.
      *
      * In CMS generation we can't allocate less then {@code MinFreeChunk} value,
      * for other CGs we expect that object of size {@code MIN_OBJECT_SIZE}
      * could be allocated as it is (of course, its size could be aligned
      * according to alignment value used in a particular space).
      *
      * For G1 GC MXBeans could report memory usage only with region size
      * precision (if an object allocated in some G1 heap region, then all region
      * will claimed as used), so for G1's spaces precision is equal to
      * {@code G1HeapRegionSize} value.
      */
     static {
         AlignmentHelper edenHelper = null;
         AlignmentHelper survivorHelper = null;
         AlignmentHelper tenuredHelper = null;
         for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
             switch (pool.getName()) {
                 case SurvivorAlignmentTestMain.DEF_NEW_EDEN:
                 case SurvivorAlignmentTestMain.PAR_NEW_EDEN:
                 case SurvivorAlignmentTestMain.PS_EDEN:
                     Asserts.assertNull(edenHelper,
                             "Only one bean for eden space is expected.");
                     edenHelper = new AlignmentHelper(
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.MIN_OBJECT_SIZE, pool);
                     break;
                 case SurvivorAlignmentTestMain.G1_EDEN:
                     Asserts.assertNull(edenHelper,
                             "Only one bean for eden space is expected.");
                     edenHelper = new AlignmentHelper(
                             SurvivorAlignmentTestMain.G1_HEAP_REGION_SIZE,
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.MIN_OBJECT_SIZE, pool);
                     break;
                 case SurvivorAlignmentTestMain.DEF_NEW_SURVIVOR:
                 case SurvivorAlignmentTestMain.PAR_NEW_SURVIVOR:
                 case SurvivorAlignmentTestMain.PS_SURVIVOR:
                     Asserts.assertNull(survivorHelper,
                             "Only one bean for survivor space is expected.");
                     survivorHelper = new AlignmentHelper(
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.SURVIVOR_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.MIN_OBJECT_SIZE, pool);
                     break;
                 case SurvivorAlignmentTestMain.G1_SURVIVOR:
                     Asserts.assertNull(survivorHelper,
                             "Only one bean for survivor space is expected.");
                     survivorHelper = new AlignmentHelper(
                             SurvivorAlignmentTestMain.G1_HEAP_REGION_SIZE,
                             AlignmentHelper.SURVIVOR_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.MIN_OBJECT_SIZE, pool);
                     break;
                 case SurvivorAlignmentTestMain.SERIAL_TENURED:
                 case SurvivorAlignmentTestMain.PS_TENURED:
                 case SurvivorAlignmentTestMain.G1_TENURED:
                     Asserts.assertNull(tenuredHelper,
                             "Only one bean for tenured space is expected.");
                     tenuredHelper = new AlignmentHelper(
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.MIN_OBJECT_SIZE, pool);
                     break;
                 case SurvivorAlignmentTestMain.CMS_TENURED:
                     Asserts.assertNull(tenuredHelper,
                             "Only one bean for tenured space is expected.");
                     tenuredHelper = new AlignmentHelper(
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
                             SurvivorAlignmentTestMain.CMS_MIN_FREE_CHUNK_SIZE,
                             pool);
                     break;
             }
         }
         EDEN_SPACE_HELPER = Objects.requireNonNull(edenHelper,
                 "AlignmentHelper for eden space should be initialized.");
         SURVIVOR_SPACE_HELPER = Objects.requireNonNull(survivorHelper,
                 "AlignmentHelper for survivor space should be initialized.");
         TENURED_SPACE_HELPER = Objects.requireNonNull(tenuredHelper,
                 "AlignmentHelper for tenured space should be initialized.");
     }
     /**
      * Returns an SurvivorAlignmentTestMain instance constructed using CLI
      * options.
      *
      * Following options are expected:
      * <ul>
      *     <li>memoryToFill</li>
      *     <li>objectSize</li>
      * </ul>
      *
      * Both argument may contain multiplier suffix k, m or g.
      */
     public static SurvivorAlignmentTestMain fromArgs(String[] args) {
         Asserts.assertEQ(args.length, 3, "Expected three arguments: "
                 + "memory size, object size and tested heap space name.");

         long memoryToFill = parseSize(args[0]);
         long objectSize = Math.max(parseSize(args[1]),
                 AlignmentHelper.MIN_ARRAY_SIZE);
         HeapSpace testedSpace = HeapSpace.valueOf(args[2]);

         return new SurvivorAlignmentTestMain(memoryToFill, objectSize,
                 testedSpace);
     }

     /**
      * Returns a value parsed from a string with format
      * &lt;integer&gt;&lt;multiplier&gt;.
      */
     private static long parseSize(String sizeString) {
         Matcher matcher = SIZE_REGEX.matcher(sizeString);
         Asserts.assertTrue(matcher.matches(),
                 "sizeString should have following format \"[0-9]+([MBK])?\"");
         long size = Long.valueOf(matcher.group("size"));

         if (matcher.group("multiplier") != null) {
             long K = 1024L;
             // fall through multipliers
             switch (matcher.group("multiplier").toLowerCase()) {
                 case "g":
                     size *= K;
                 case "m":
                     size *= K;
                 case "k":
                     size *= K;
             }
         }
         return size;
     }

     private SurvivorAlignmentTestMain(long memoryToFill, long objectSize,
             HeapSpace testedSpace) {
         this.objectSize = objectSize;
         this.memoryToFill = memoryToFill;
         this.testedSpace = testedSpace;

         AlignmentHelper helper = SurvivorAlignmentTestMain.EDEN_SPACE_HELPER;

         this.actualObjectSize = helper.getObjectSizeInThisSpace(
                 this.objectSize);
         int arrayLength = helper.getObjectsCount(memoryToFill, this.objectSize);
         garbage = new Object[arrayLength];
     }

     /**
      * Allocate byte arrays to fill {@code memoryToFill} memory.
      */
     public void allocate() {
         int byteArrayLength = Math.max((int) (objectSize
                 - Unsafe.ARRAY_BYTE_BASE_OFFSET), 0);

         for (int i = 0; i < garbage.length; i++) {
             garbage[i] = new byte[byteArrayLength];
         }
     }

     /**
      * Release memory occupied after {@code allocate} call.
      */
     public void release() {
         for (int i = 0; i < garbage.length; i++) {
             garbage[i] = null;
         }
     }

     /**
      * Returns expected amount of memory occupied in a {@code heapSpace} by
      * objects referenced from {@code garbage} array.
      */
     public long getExpectedMemoryUsage() {
         AlignmentHelper alignmentHelper = getAlignmentHelper(testedSpace);
         return alignmentHelper.getExpectedMemoryUsage(objectSize,
                 garbage.length);
     }

     /**
      * Verifies that memory usage in a {@code heapSpace} deviates from
      * {@code expectedUsage} for no more than {@code MAX_RELATIVE_DEVIATION}.
      */
     public void verifyMemoryUsage(long expectedUsage) {
         AlignmentHelper alignmentHelper = getAlignmentHelper(testedSpace);

         long actualMemoryUsage = alignmentHelper.getActualMemoryUsage();
         boolean otherThreadsAllocatedMemory = areOtherThreadsAllocatedMemory();

         long memoryUsageDiff = Math.abs(actualMemoryUsage - expectedUsage);
         long maxAllowedUsageDiff
                 = alignmentHelper.getAllowedMemoryUsageDeviation(expectedUsage);

         System.out.println("Verifying memory usage in space: " + testedSpace);
         System.out.println("Allocated objects count: " + garbage.length);
         System.out.println("Desired object size: " + objectSize);
         System.out.println("Actual object size: " + actualObjectSize);
         System.out.println("Expected object size in space: "
                 + alignmentHelper.getObjectSizeInThisSpace(objectSize));
         System.out.println("Expected memory usage: " + expectedUsage);
         System.out.println("Actual memory usage: " + actualMemoryUsage);
         System.out.println("Memory usage diff: " + memoryUsageDiff);
         System.out.println("Max allowed usage diff: " + maxAllowedUsageDiff);

         if (memoryUsageDiff > maxAllowedUsageDiff
                 && otherThreadsAllocatedMemory) {
             System.out.println("Memory usage diff is incorrect, but it seems "
                     + "like someone else allocated objects");
             return;
         }

         Asserts.assertLTE(memoryUsageDiff, maxAllowedUsageDiff,
                 "Actual memory usage should not deviate from expected for " +
                         "more then " + maxAllowedUsageDiff);
     }

     /**
      * Baselines amount of memory allocated by each thread.
      */
     public void baselineMemoryAllocation() {
         ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
         threadIds = bean.getAllThreadIds();
         baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
     }

     /**
      * Checks if threads other then the current thread were allocating objects
      * after baselinedThreadMemoryUsage call.
      *
      * If baselinedThreadMemoryUsage was not called, then this method will return
      * {@code false}.
      */
     public boolean areOtherThreadsAllocatedMemory() {
         if (baselinedThreadMemoryUsage == null) {
             return false;
         }

         ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
         long currentMemoryAllocation[]
                 = bean.getThreadAllocatedBytes(threadIds);
         boolean otherThreadsAllocatedMemory = false;

         System.out.println("Verifying amount of memory allocated by threads:");
         for (int i = 0; i < threadIds.length; i++) {
             System.out.format("Thread %d%nbaseline allocation: %d"
                             + "%ncurrent allocation:%d%n", threadIds[i],
                     baselinedThreadMemoryUsage[i], currentMemoryAllocation[i]);
             System.out.println(bean.getThreadInfo(threadIds[i]));

             long bytesAllocated = Math.abs(currentMemoryAllocation[i]
                     - baselinedThreadMemoryUsage[i]);
             if (bytesAllocated > 0
                     && threadIds[i] != Thread.currentThread().getId()) {
                 otherThreadsAllocatedMemory = true;
             }
         }

         return otherThreadsAllocatedMemory;
     }

     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();

         builder.append(String.format("SurvivorAlignmentTestMain info:%n"));
         builder.append(String.format("Desired object size: %d%n", objectSize));
         builder.append(String.format("Memory to fill: %d%n", memoryToFill));
         builder.append(String.format("Objects to be allocated: %d%n",
                 garbage.length));

         builder.append(String.format("Alignment helpers to be used: %n"));
         for (HeapSpace heapSpace: HeapSpace.values()) {
             builder.append(String.format("For space %s:%n%s%n", heapSpace,
                     getAlignmentHelper(heapSpace)));
         }

         return builder.toString();
     }

     /**
      * Returns {@code AlignmentHelper} for a space {@code heapSpace}.
      */
     public static AlignmentHelper getAlignmentHelper(HeapSpace heapSpace) {
         switch (heapSpace) {
             case EDEN:
                 return SurvivorAlignmentTestMain.EDEN_SPACE_HELPER;
             case SURVIVOR:
                 return SurvivorAlignmentTestMain.SURVIVOR_SPACE_HELPER;
             case TENURED:
                 return SurvivorAlignmentTestMain.TENURED_SPACE_HELPER;
             default:
                 throw new Error("Unexpected heap space: " + heapSpace);
         }
     }
 }
	/*
	* Copyright (c) 2014, 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.
	*/

	import java.lang.management.ManagementFactory;
	import java.lang.management.MemoryPoolMXBean;
	import java.util.Objects;
	import java.util.Optional;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import com.oracle.java.testlibrary.Asserts;
	import com.sun.management.ThreadMXBean;
	import sun.hotspot.WhiteBox;
	import sun.misc.Unsafe;

	/**
	* Main class for tests on {@code SurvivorAlignmentInBytes} option.
	*
	* Typical usage is to obtain instance using fromArgs method, allocate objects
	* and verify that actual memory usage in tested heap space is close to
	* expected.
	*/
	public class SurvivorAlignmentTestMain {
	enum HeapSpace {
	EDEN,
	SURVIVOR,
	TENURED
	}

	public static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

	public static final long MAX_TENURING_THRESHOLD = Optional.ofNullable(
	SurvivorAlignmentTestMain.WHITE_BOX.getIntxVMFlag(
	"MaxTenuringThreshold")).orElse(15L);

	/**
	* Regexp used to parse memory size params, like 2G, 34m or 15k.
	*/
	private static final Pattern SIZE_REGEX
	= Pattern.compile("(?<size>[0-9]+)(?<multiplier>[GMKgmk])?");

	// Names of different heap spaces.
	private static final String DEF_NEW_EDEN = "Eden Space";
	private static final String DEF_NEW_SURVIVOR = "Survivor Space";
	private static final String PAR_NEW_EDEN = "Par Eden Space";
	private static final String PAR_NEW_SURVIVOR = "Par Survivor Space";
	private static final String PS_EDEN = "PS Eden Space";
	private static final String PS_SURVIVOR = "PS Survivor Space";
	private static final String G1_EDEN = "G1 Eden Space";
	private static final String G1_SURVIVOR = "G1 Survivor Space";
	private static final String SERIAL_TENURED = "Tenured Gen";
	private static final String CMS_TENURED = "CMS Old Gen";
	private static final String PS_TENURED = "PS Old Gen";
	private static final String G1_TENURED = "G1 Old Gen";

	private static final long G1_HEAP_REGION_SIZE = Optional.ofNullable(
	SurvivorAlignmentTestMain.WHITE_BOX.getUintxVMFlag(
	"G1HeapRegionSize")).orElse(-1L);

	/**
	* Min size of free chunk in CMS generation.
	* An object allocated in CMS generation will at least occupy this amount
	* of bytes.
	*/
	private static final long CMS_MIN_FREE_CHUNK_SIZE
	= 3L * Unsafe.ADDRESS_SIZE;

	private static final AlignmentHelper EDEN_SPACE_HELPER;
	private static final AlignmentHelper SURVIVOR_SPACE_HELPER;
	private static final AlignmentHelper TENURED_SPACE_HELPER;
	/**
	* Amount of memory that should be filled during a test run.
	*/
	private final long memoryToFill;
	/**
	* The size of an objects that will be allocated during a test run.
	*/
	private final long objectSize;
	/**
	* Amount of memory that will be actually occupied by an object in eden
	* space.
	*/
	private final long actualObjectSize;
	/**
	* Storage for allocated objects.
	*/
	private final Object[] garbage;
	/**
	* Heap space whose memory usage is a subject of assertions during the test
	* run.
	*/
	private final HeapSpace testedSpace;

	private long[] baselinedThreadMemoryUsage = null;
	private long[] threadIds = null;

	/**
	* Initialize {@code EDEN_SPACE_HELPER}, {@code SURVIVOR_SPACE_HELPER} and
	* {@code TENURED_SPACE_HELPER} to represent heap spaces in use.
	*
	* Note that regardless to GC object's alignment in survivor space is
	* expected to be equal to {@code SurvivorAlignmentInBytes} value and
	* alignment in other spaces is expected to be equal to
	* {@code ObjectAlignmentInBytes} value.
	*
	* In CMS generation we can't allocate less then {@code MinFreeChunk} value,
	* for other CGs we expect that object of size {@code MIN_OBJECT_SIZE}
	* could be allocated as it is (of course, its size could be aligned
	* according to alignment value used in a particular space).
	*
	* For G1 GC MXBeans could report memory usage only with region size
	* precision (if an object allocated in some G1 heap region, then all region
	* will claimed as used), so for G1's spaces precision is equal to
	* {@code G1HeapRegionSize} value.
	*/
	static {
	AlignmentHelper edenHelper = null;
	AlignmentHelper survivorHelper = null;
	AlignmentHelper tenuredHelper = null;
	for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
	switch (pool.getName()) {
	case SurvivorAlignmentTestMain.DEF_NEW_EDEN:
	case SurvivorAlignmentTestMain.PAR_NEW_EDEN:
	case SurvivorAlignmentTestMain.PS_EDEN:
	Asserts.assertNull(edenHelper,
	"Only one bean for eden space is expected.");
	edenHelper = new AlignmentHelper(
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.MIN_OBJECT_SIZE, pool);
	break;
	case SurvivorAlignmentTestMain.G1_EDEN:
	Asserts.assertNull(edenHelper,
	"Only one bean for eden space is expected.");
	edenHelper = new AlignmentHelper(
	SurvivorAlignmentTestMain.G1_HEAP_REGION_SIZE,
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.MIN_OBJECT_SIZE, pool);
	break;
	case SurvivorAlignmentTestMain.DEF_NEW_SURVIVOR:
	case SurvivorAlignmentTestMain.PAR_NEW_SURVIVOR:
	case SurvivorAlignmentTestMain.PS_SURVIVOR:
	Asserts.assertNull(survivorHelper,
	"Only one bean for survivor space is expected.");
	survivorHelper = new AlignmentHelper(
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.SURVIVOR_ALIGNMENT_IN_BYTES,
	AlignmentHelper.MIN_OBJECT_SIZE, pool);
	break;
	case SurvivorAlignmentTestMain.G1_SURVIVOR:
	Asserts.assertNull(survivorHelper,
	"Only one bean for survivor space is expected.");
	survivorHelper = new AlignmentHelper(
	SurvivorAlignmentTestMain.G1_HEAP_REGION_SIZE,
	AlignmentHelper.SURVIVOR_ALIGNMENT_IN_BYTES,
	AlignmentHelper.MIN_OBJECT_SIZE, pool);
	break;
	case SurvivorAlignmentTestMain.SERIAL_TENURED:
	case SurvivorAlignmentTestMain.PS_TENURED:
	case SurvivorAlignmentTestMain.G1_TENURED:
	Asserts.assertNull(tenuredHelper,
	"Only one bean for tenured space is expected.");
	tenuredHelper = new AlignmentHelper(
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.MIN_OBJECT_SIZE, pool);
	break;
	case SurvivorAlignmentTestMain.CMS_TENURED:
	Asserts.assertNull(tenuredHelper,
	"Only one bean for tenured space is expected.");
	tenuredHelper = new AlignmentHelper(
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES,
	SurvivorAlignmentTestMain.CMS_MIN_FREE_CHUNK_SIZE,
	pool);
	break;
	}
	}
	EDEN_SPACE_HELPER = Objects.requireNonNull(edenHelper,
	"AlignmentHelper for eden space should be initialized.");
	SURVIVOR_SPACE_HELPER = Objects.requireNonNull(survivorHelper,
	"AlignmentHelper for survivor space should be initialized.");
	TENURED_SPACE_HELPER = Objects.requireNonNull(tenuredHelper,
	"AlignmentHelper for tenured space should be initialized.");
	}
	/**
	* Returns an SurvivorAlignmentTestMain instance constructed using CLI
	* options.
	*
	* Following options are expected:
	* <ul>
	* <li>memoryToFill</li>
	* <li>objectSize</li>
	* </ul>
	*
	* Both argument may contain multiplier suffix k, m or g.
	*/
	public static SurvivorAlignmentTestMain fromArgs(String[] args) {
	Asserts.assertEQ(args.length, 3, "Expected three arguments: "
	+ "memory size, object size and tested heap space name.");

	long memoryToFill = parseSize(args[0]);
	long objectSize = Math.max(parseSize(args[1]),
	AlignmentHelper.MIN_ARRAY_SIZE);
	HeapSpace testedSpace = HeapSpace.valueOf(args[2]);

	return new SurvivorAlignmentTestMain(memoryToFill, objectSize,
	testedSpace);
	}

	/**
	* Returns a value parsed from a string with format
	* <integer><multiplier>.
	*/
	private static long parseSize(String sizeString) {
	Matcher matcher = SIZE_REGEX.matcher(sizeString);
	Asserts.assertTrue(matcher.matches(),
	"sizeString should have following format \"[0-9]+([MBK])?\"");
	long size = Long.valueOf(matcher.group("size"));

	if (matcher.group("multiplier") != null) {
	long K = 1024L;
	// fall through multipliers
	switch (matcher.group("multiplier").toLowerCase()) {
	case "g":
	size *= K;
	case "m":
	size *= K;
	case "k":
	size *= K;
	}
	}
	return size;
	}

	private SurvivorAlignmentTestMain(long memoryToFill, long objectSize,
	HeapSpace testedSpace) {
	this.objectSize = objectSize;
	this.memoryToFill = memoryToFill;
	this.testedSpace = testedSpace;

	AlignmentHelper helper = SurvivorAlignmentTestMain.EDEN_SPACE_HELPER;

	this.actualObjectSize = helper.getObjectSizeInThisSpace(
	this.objectSize);
	int arrayLength = helper.getObjectsCount(memoryToFill, this.objectSize);
	garbage = new Object[arrayLength];
	}

	/**
	* Allocate byte arrays to fill {@code memoryToFill} memory.
	*/
	public void allocate() {
	int byteArrayLength = Math.max((int) (objectSize
	- Unsafe.ARRAY_BYTE_BASE_OFFSET), 0);

	for (int i = 0; i < garbage.length; i++) {
	garbage[i] = new byte[byteArrayLength];
	}
	}

	/**
	* Release memory occupied after {@code allocate} call.
	*/
	public void release() {
	for (int i = 0; i < garbage.length; i++) {
	garbage[i] = null;
	}
	}

	/**
	* Returns expected amount of memory occupied in a {@code heapSpace} by
	* objects referenced from {@code garbage} array.
	*/
	public long getExpectedMemoryUsage() {
	AlignmentHelper alignmentHelper = getAlignmentHelper(testedSpace);
	return alignmentHelper.getExpectedMemoryUsage(objectSize,
	garbage.length);
	}

	/**
	* Verifies that memory usage in a {@code heapSpace} deviates from
	* {@code expectedUsage} for no more than {@code MAX_RELATIVE_DEVIATION}.
	*/
	public void verifyMemoryUsage(long expectedUsage) {
	AlignmentHelper alignmentHelper = getAlignmentHelper(testedSpace);

	long actualMemoryUsage = alignmentHelper.getActualMemoryUsage();
	boolean otherThreadsAllocatedMemory = areOtherThreadsAllocatedMemory();

	long memoryUsageDiff = Math.abs(actualMemoryUsage - expectedUsage);
	long maxAllowedUsageDiff
	= alignmentHelper.getAllowedMemoryUsageDeviation(expectedUsage);

	System.out.println("Verifying memory usage in space: " + testedSpace);
	System.out.println("Allocated objects count: " + garbage.length);
	System.out.println("Desired object size: " + objectSize);
	System.out.println("Actual object size: " + actualObjectSize);
	System.out.println("Expected object size in space: "
	+ alignmentHelper.getObjectSizeInThisSpace(objectSize));
	System.out.println("Expected memory usage: " + expectedUsage);
	System.out.println("Actual memory usage: " + actualMemoryUsage);
	System.out.println("Memory usage diff: " + memoryUsageDiff);
	System.out.println("Max allowed usage diff: " + maxAllowedUsageDiff);

	if (memoryUsageDiff > maxAllowedUsageDiff
	&& otherThreadsAllocatedMemory) {
	System.out.println("Memory usage diff is incorrect, but it seems "
	+ "like someone else allocated objects");
	return;
	}

	Asserts.assertLTE(memoryUsageDiff, maxAllowedUsageDiff,
	"Actual memory usage should not deviate from expected for " +
	"more then " + maxAllowedUsageDiff);
	}

	/**
	* Baselines amount of memory allocated by each thread.
	*/
	public void baselineMemoryAllocation() {
	ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
	threadIds = bean.getAllThreadIds();
	baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
	}

	/**
	* Checks if threads other then the current thread were allocating objects
	* after baselinedThreadMemoryUsage call.
	*
	* If baselinedThreadMemoryUsage was not called, then this method will return
	* {@code false}.
	*/
	public boolean areOtherThreadsAllocatedMemory() {
	if (baselinedThreadMemoryUsage == null) {
	return false;
	}

	ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
	long currentMemoryAllocation[]
	= bean.getThreadAllocatedBytes(threadIds);
	boolean otherThreadsAllocatedMemory = false;

	System.out.println("Verifying amount of memory allocated by threads:");
	for (int i = 0; i < threadIds.length; i++) {
	System.out.format("Thread %d%nbaseline allocation: %d"
	+ "%ncurrent allocation:%d%n", threadIds[i],
	baselinedThreadMemoryUsage[i], currentMemoryAllocation[i]);
	System.out.println(bean.getThreadInfo(threadIds[i]));

	long bytesAllocated = Math.abs(currentMemoryAllocation[i]
	- baselinedThreadMemoryUsage[i]);
	if (bytesAllocated > 0
	&& threadIds[i] != Thread.currentThread().getId()) {
	otherThreadsAllocatedMemory = true;
	}
	}

	return otherThreadsAllocatedMemory;
	}

	@Override
	public String toString() {
	StringBuilder builder = new StringBuilder();

	builder.append(String.format("SurvivorAlignmentTestMain info:%n"));
	builder.append(String.format("Desired object size: %d%n", objectSize));
	builder.append(String.format("Memory to fill: %d%n", memoryToFill));
	builder.append(String.format("Objects to be allocated: %d%n",
	garbage.length));

	builder.append(String.format("Alignment helpers to be used: %n"));
	for (HeapSpace heapSpace: HeapSpace.values()) {
	builder.append(String.format("For space %s:%n%s%n", heapSpace,
	getAlignmentHelper(heapSpace)));
	}

	return builder.toString();
	}

	/**
	* Returns {@code AlignmentHelper} for a space {@code heapSpace}.
	*/
	public static AlignmentHelper getAlignmentHelper(HeapSpace heapSpace) {
	switch (heapSpace) {
	case EDEN:
	return SurvivorAlignmentTestMain.EDEN_SPACE_HELPER;
	case SURVIVOR:
	return SurvivorAlignmentTestMain.SURVIVOR_SPACE_HELPER;
	case TENURED:
	return SurvivorAlignmentTestMain.TENURED_SPACE_HELPER;
	default:
	throw new Error("Unexpected heap space: " + heapSpace);
	}
	}
	}