/*
 * Copyright (c) 2015, 2017, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package com.sun.marlin;

import java.util.Arrays;
import static com.sun.marlin.MarlinUtils.logInfo;

public final class ArrayCacheConst implements MarlinConst {

    static final int BUCKETS = 8;
    static final int MIN_ARRAY_SIZE = 4096;
    // maximum array size
    static final int MAX_ARRAY_SIZE;
    // threshold below to grow arrays by 4
    static final int THRESHOLD_SMALL_ARRAY_SIZE = 4 * 1024 * 1024;
    // threshold to grow arrays only by (3/2) instead of 2
    static final int THRESHOLD_ARRAY_SIZE;
    // threshold to grow arrays only by (5/4) instead of (3/2)
    static final long THRESHOLD_HUGE_ARRAY_SIZE;
    static final int[] ARRAY_SIZES = new int[BUCKETS];

    static {
        // initialize buckets for int/float arrays
        int arraySize = MIN_ARRAY_SIZE;

        int inc_lg = 2; // x4

        for (int i = 0; i < BUCKETS; i++, arraySize <<= inc_lg) {
            ARRAY_SIZES[i] = arraySize;

            if (DO_TRACE) {
                logInfo("arraySize[" + i + "]: " + arraySize);
            }

            if (arraySize >= THRESHOLD_SMALL_ARRAY_SIZE) {
                inc_lg = 1; // x2
            }
        }
        MAX_ARRAY_SIZE = arraySize >> inc_lg;

        if (MAX_ARRAY_SIZE <= 0) {
            throw new IllegalStateException("Invalid max array size !");
        }

        THRESHOLD_ARRAY_SIZE       =  16  * 1024 * 1024; // >16M
        THRESHOLD_HUGE_ARRAY_SIZE  =  48L * 1024 * 1024; // >48M

        if (DO_STATS || DO_MONITORS) {
            logInfo("ArrayCache.BUCKETS        = " + BUCKETS);
            logInfo("ArrayCache.MIN_ARRAY_SIZE = " + MIN_ARRAY_SIZE);
            logInfo("ArrayCache.MAX_ARRAY_SIZE = " + MAX_ARRAY_SIZE);
            logInfo("ArrayCache.ARRAY_SIZES = "
                    + Arrays.toString(ARRAY_SIZES));
            logInfo("ArrayCache.THRESHOLD_ARRAY_SIZE = "
                    + THRESHOLD_ARRAY_SIZE);
            logInfo("ArrayCache.THRESHOLD_HUGE_ARRAY_SIZE = "
                    + THRESHOLD_HUGE_ARRAY_SIZE);
        }
    }

    private ArrayCacheConst() {
        // Utility class
    }

    // small methods used a lot (to be inlined / optimized by hotspot)

    static int getBucket(final int length) {
        for (int i = 0; i < ARRAY_SIZES.length; i++) {
            if (length <= ARRAY_SIZES[i]) {
                return i;
            }
        }
        return -1;
    }

    
Return the new array size (~ x2)
Params:
  • curSize – current used size
  • needSize – needed size
Returns:new array size
/** * Return the new array size (~ x2) * @param curSize current used size * @param needSize needed size * @return new array size */
public static int getNewSize(final int curSize, final int needSize) { // check if needSize is negative or integer overflow: if (needSize < 0) { // hard overflow failure - we can't even accommodate // new items without overflowing throw new ArrayIndexOutOfBoundsException( "array exceeds maximum capacity !"); } assert curSize >= 0; final int initial = curSize; int size; if (initial > THRESHOLD_ARRAY_SIZE) { size = initial + (initial >> 1); // x(3/2) } else { size = (initial << 1); // x2 } // ensure the new size is >= needed size: if (size < needSize) { // align to 4096 (may overflow): size = ((needSize >> 12) + 1) << 12; } // check integer overflow: if (size < 0) { // resize to maximum capacity: size = Integer.MAX_VALUE; } return size; }
Return the new array size (~ x2)
Params:
  • curSize – current used size
  • needSize – needed size
Returns:new array size
/** * Return the new array size (~ x2) * @param curSize current used size * @param needSize needed size * @return new array size */
public static long getNewLargeSize(final long curSize, final long needSize) { // check if needSize is negative or integer overflow: if ((needSize >> 31L) != 0L) { // hard overflow failure - we can't even accommodate // new items without overflowing throw new ArrayIndexOutOfBoundsException( "array exceeds maximum capacity !"); } assert curSize >= 0L; long size; if (curSize > THRESHOLD_HUGE_ARRAY_SIZE) { size = curSize + (curSize >> 2L); // x(5/4) } else if (curSize > THRESHOLD_ARRAY_SIZE) { size = curSize + (curSize >> 1L); // x(3/2) } else if (curSize > THRESHOLD_SMALL_ARRAY_SIZE) { size = (curSize << 1L); // x2 } else { size = (curSize << 2L); // x4 } // ensure the new size is >= needed size: if (size < needSize) { // align to 4096: size = ((needSize >> 12L) + 1L) << 12L; } // check integer overflow: if (size > Integer.MAX_VALUE) { // resize to maximum capacity: size = Integer.MAX_VALUE; } return size; } static final class CacheStats { final String name; final BucketStats[] bucketStats; int resize = 0; int oversize = 0; long totalInitial = 0L; CacheStats(final String name) { this.name = name; bucketStats = new BucketStats[BUCKETS]; for (int i = 0; i < BUCKETS; i++) { bucketStats[i] = new BucketStats(); } } void reset() { resize = 0; oversize = 0; for (int i = 0; i < BUCKETS; i++) { bucketStats[i].reset(); } } long dumpStats() { long totalCacheBytes = 0L; if (DO_STATS) { for (int i = 0; i < BUCKETS; i++) { final BucketStats s = bucketStats[i]; if (s.maxSize != 0) { totalCacheBytes += getByteFactor() * (s.maxSize * ARRAY_SIZES[i]); } } if (totalInitial != 0L || totalCacheBytes != 0L || resize != 0 || oversize != 0) { logInfo(name + ": resize: " + resize + " - oversize: " + oversize + " - initial: " + getTotalInitialBytes() + " bytes (" + totalInitial + " elements)" + " - cache: " + totalCacheBytes + " bytes" ); } if (totalCacheBytes != 0L) { logInfo(name + ": usage stats:"); for (int i = 0; i < BUCKETS; i++) { final BucketStats s = bucketStats[i]; if (s.getOp != 0) { logInfo(" Bucket[" + ARRAY_SIZES[i] + "]: " + "get: " + s.getOp + " - put: " + s.returnOp + " - create: " + s.createOp + " :: max size: " + s.maxSize ); } } } } return totalCacheBytes; } private int getByteFactor() { int factor = 1; if (name.contains("Int") || name.contains("Float")) { factor = 4; } else if (name.contains("Double")) { factor = 8; } return factor; } long getTotalInitialBytes() { return getByteFactor() * totalInitial; } } static final class BucketStats { int getOp = 0; int createOp = 0; int returnOp = 0; int maxSize = 0; void reset() { getOp = 0; createOp = 0; returnOp = 0; maxSize = 0; } void updateMaxSize(final int size) { if (size > maxSize) { maxSize = size; } } } }