test/hotspot/jtreg/gc/arguments/AllocationHelper.java

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

import java.util.LinkedList;
import java.util.concurrent.Callable;

/**
 * Helper class which allocates memory.
 *
 * Typical usage:
 * <pre>
 * {@code
 *           AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE,
 *                   () -> (verifier()));
 *           // Allocate byte[CHUNK_SIZE] ARRAY_LENGTH times. Total allocated bytes will be CHUNK_SIZE * ARRAY_LENGTH + refs length.
 *           // Then invoke verifier and iterate MAX_ITERATIONS times.
 *           allocator.allocateMemoryAndVerify();
 * }
 * </pre>
 */
public final class AllocationHelper {

    private final int arrayLength;
    private final int maxIterations;
    private final int chunkSize;

    // garbageStorage is used to store link to garbage to prevent optimization.
    private static Object garbageStorage;
    private byte garbage[][];
    private final Callable<?> verifierInstance;

    /**
     * Create an AllocationHelper with specified iteration count, array length, chunk size and verifier.
     *
     * @param maxIterations
     * @param arrayLength
     * @param chunkSize
     * @param verifier - Callable instance which will be invoked after all allocation cycle. Can be null;
     */
    public AllocationHelper(int maxIterations, int arrayLength, int chunkSize, Callable<?> verifier) {
        if ((arrayLength <= 0) || (maxIterations <= 0) || (chunkSize <= 0)) {
            throw new IllegalArgumentException("maxIterations, arrayLength and chunkSize should be greater then 0.");
        }
        this.arrayLength = arrayLength;
        this.maxIterations = maxIterations;
        this.chunkSize = chunkSize;
        verifierInstance = verifier;
        garbage = new byte[this.arrayLength][];
        garbageStorage = garbage;
    }

    private void allocateMemoryOneIteration() {
        for (int j = 0; j < arrayLength; j++) {
            garbage[j] = new byte[chunkSize];
        }
    }

    /**
     * Allocate memory and invoke Verifier during all iteration.
     *
     * @throws java.lang.Exception
     */
    public void allocateMemoryAndVerify() throws Exception {
        for (int i = 0; i < maxIterations; i++) {
            allocateMemoryOneIteration();
            if (verifierInstance != null) {
                verifierInstance.call();
            }
        }
    }

    /**
     * The same as allocateMemoryAndVerify() but hides OOME
     *
     * @throws Exception
     */
    public void allocateMemoryAndVerifyNoOOME() throws Exception {
        try {
            allocateMemoryAndVerify();
        } catch (OutOfMemoryError e) {
            // exit on OOME
        }
    }

    /**
     * Release link to allocated garbage to make it available for further GC
     */
    public void release() {
        if (garbage != null) {
            garbage = null;
            garbageStorage = null;
        }
    }
}