/*

 * 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.MemoryPoolMXBean;

import java.util.Optional;

import sun.hotspot.WhiteBox;

/**

 * Helper class aimed to provide information about alignment of objects in

 * particular heap space, expected memory usage after objects' allocation so on.

 */

public class AlignmentHelper {

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

    private static final long OBJECT_ALIGNMENT_IN_BYTES_FOR_32_VM = 8L;

    /**

     * Max relative allowed actual memory usage deviation from expected memory

     * usage.

     */

    private static final float MAX_RELATIVE_DEVIATION = 0.05f; // 5%

    public static final long OBJECT_ALIGNMENT_IN_BYTES = Optional.ofNullable(

            AlignmentHelper.WHITE_BOX.getIntxVMFlag("ObjectAlignmentInBytes"))

            .orElse(AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES_FOR_32_VM);

    public static final long SURVIVOR_ALIGNMENT_IN_BYTES = Optional.ofNullable(

            AlignmentHelper.WHITE_BOX.getIntxVMFlag("SurvivorAlignmentInBytes"))

            .orElseThrow(() ->new AssertionError(

                    "Unable to get SurvivorAlignmentInBytes value"));

    /**

     * Min amount of memory that will be occupied by an object.

     */

    public static final long MIN_OBJECT_SIZE

            = AlignmentHelper.WHITE_BOX.getObjectSize(new Object());

    /**

     * Min amount of memory that will be occupied by an empty byte array.

     */

    public static final long MIN_ARRAY_SIZE

            = AlignmentHelper.WHITE_BOX.getObjectSize(new byte[0]);

    /**

     * Precision at which actual memory usage in a heap space represented by

     * this sizing helper could be measured.

     */

    private final long memoryUsageMeasurementPrecision;

    /**

     * Min amount of memory that will be occupied by an object allocated in a

     * heap space represented by this sizing helper.

     */

    private final long minObjectSizeInThisSpace;

    /**

     * Object's alignment in a heap space represented by this sizing helper.

     */

    private final long objectAlignmentInThisRegion;

    /**

     * MemoryPoolMXBean associated with a heap space represented by this sizing

     * helper.

     */

    private final MemoryPoolMXBean poolMXBean;

    private static long alignUp(long value, long alignment) {

        return ((value - 1) / alignment + 1) * alignment;

    }

    protected AlignmentHelper(long memoryUsageMeasurementPrecision,

            long objectAlignmentInThisRegion, long minObjectSizeInThisSpace,

            MemoryPoolMXBean poolMXBean) {

        this.memoryUsageMeasurementPrecision = memoryUsageMeasurementPrecision;

        this.minObjectSizeInThisSpace = minObjectSizeInThisSpace;

        this.objectAlignmentInThisRegion = objectAlignmentInThisRegion;

        this.poolMXBean = poolMXBean;

    }

    /**

     * Returns how many objects have to be allocated to fill

     * {@code memoryToFill} bytes in this heap space using objects of size

     * {@code objectSize}.

     */

    public int getObjectsCount(long memoryToFill, long objectSize) {

        return (int) (memoryToFill / getObjectSizeInThisSpace(objectSize));

    }

    /**

     * Returns amount of memory that {@code objectsCount} of objects with size

     * {@code objectSize} will occupy this this space after allocation.

     */

    public long getExpectedMemoryUsage(long objectSize, int objectsCount) {

        long correctedObjectSize = getObjectSizeInThisSpace(objectSize);

        return AlignmentHelper.alignUp(correctedObjectSize * objectsCount,

                memoryUsageMeasurementPrecision);

    }

    /**

     * Returns current memory usage in this heap space.

     */

    public long getActualMemoryUsage() {

        return poolMXBean.getUsage().getUsed();

    }

    /**

     * Returns maximum memory usage deviation from {@code expectedMemoryUsage}

     * given the max allowed relative deviation equal to

     * {@code relativeDeviation}.

     *

     * Note that value returned by this method is aligned according to

     * memory measurement precision for this heap space.

     */

    public long getAllowedMemoryUsageDeviation(long expectedMemoryUsage) {

        long unalignedDeviation = (long) (expectedMemoryUsage *

                AlignmentHelper.MAX_RELATIVE_DEVIATION);

        return AlignmentHelper.alignUp(unalignedDeviation,

                memoryUsageMeasurementPrecision);

    }

    /**

     * Returns amount of memory that will be occupied by an object with size

     * {@code objectSize} in this heap space.

     */

    public long getObjectSizeInThisSpace(long objectSize) {

        objectSize = Math.max(objectSize, minObjectSizeInThisSpace);

        long alignedObjectSize = AlignmentHelper.alignUp(objectSize,

                objectAlignmentInThisRegion);

        long sizeDiff = alignedObjectSize - objectSize;

        // If there is not enough space to fit padding object, then object will

        // be aligned to {@code 2 * objectAlignmentInThisRegion}.

        if (sizeDiff >= AlignmentHelper.OBJECT_ALIGNMENT_IN_BYTES

                && sizeDiff < AlignmentHelper.MIN_OBJECT_SIZE) {

            alignedObjectSize += AlignmentHelper.MIN_OBJECT_SIZE;

            alignedObjectSize = AlignmentHelper.alignUp(alignedObjectSize,

                    objectAlignmentInThisRegion);

        }

        return alignedObjectSize;

    }

    @Override

    public String toString() {

        StringBuilder builder = new StringBuilder();

        builder.append(String.format("AlignmentHelper for memory pool '%s':%n",

                poolMXBean.getName()));

        builder.append(String.format("Memory usage measurement precision: %d%n",

                memoryUsageMeasurementPrecision));

        builder.append(String.format("Min object size in this space: %d%n",

                minObjectSizeInThisSpace));

        builder.append(String.format("Object alignment in this space: %d%n",

                objectAlignmentInThisRegion));

        return builder.toString();

    }

}