CompLevel.java

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

packagecompiler.lib.ir_framework;

importcompiler.lib.ir_framework.shared.TestFrameworkException;
importcompiler.lib.ir_framework.shared.TestRun;
importcompiler.lib.ir_framework.shared.TestRunException;
importcompiler.lib.ir_framework.test.TestVM;
importjdk.test.lib.Utils;

importjava.lang.reflect.Executable;
importjava.util.HashMap;
importjava.util.Map;

/**
 * Compilation levels used by the framework to initiate a compilation of a method. The compilation levels map to the used
 * levels in HotSpot (apart from the framework specific values {@link #SKIP} and {@link #WAIT_FOR_COMPILATION} that cannot
 * be found in HotSpot). The HotSpot specific levels must be in sync with hotspot/share/compiler/compilerDefinitions.hpp.
 *
 * <p>
 * The compilation levels can be specified in the {@link Test}, {@link ForceCompile}, and
 * {@link ForceCompileClassInitializer} annotation.
 *
 * @see Test
 * @see ForceCompile
 * @see ForceCompileClassInitializer
 */
publicenumCompLevel {
/**
 * Can only be used at {@link Test#compLevel()}. After the warm-up, the framework keeps invoking the test over a span
 * of 10s (configurable by setting the property flag {@code -DWaitForCompilationTimeout}) until HotSpot compiles the
 * {@link Test} method. If the method was not compiled after 10s, an exception is thrown. The framework does not wait
 * for the compilation if the test VM is run with {@code -Xcomp}, {@code -XX:-UseCompiler}, or
 * {@code -DExcludeRandom=true}.
 */
WAIT_FOR_COMPILATION(-4),
/**
 * Can only be used at {@link Test#compLevel()}. Skip a compilation of the {@link Test @Test} method completely.
 */
SKIP(-3),
/**
 * Use any compilation level depending on the usage:
 * <ul>
 * <li><p>{@link Test @Test}, {@link ForceCompile @ForceCompile}: Use the highest available compilation level
 * which is usually C2.</li>
 * <li><p>{@link DontCompile @DontCompile}: Prevents any compilation of the associated helper method.</li>
 * </ul>
 */
ANY(-1),
/**
 * Compilation level 1: C1 compilation without any profile information.
 */
C1_SIMPLE(1),
/**
 * Compilation level 2: C1 compilation with limited profile information: Includes Invocation and backedge counters.
 */
C1_LIMITED_PROFILE(2),
/**
 * Compilation level 3: C1 compilation with full profile information: Includes Invocation and backedge counters with MDO.
 */
C1_FULL_PROFILE(3),
/**
 * Compilation level 4: C2 compilation with full optimizations.
 */
C2(4),

 ;

privatestaticfinalMap<Integer, CompLevel> TYPES_BY_VALUE = newHashMap<>();
privatefinalintvalue;

static {
for (CompLevellevel : CompLevel.values()) {
TYPES_BY_VALUE.put(level.value, level);
 }
 }

CompLevel(intlevel) {
this.value = level;
 }

/**
 * Get the compilation level as integer value. These will match the levels specified in HotSpot (if available).
 *
 * @return the compilation level as integer.
 */
publicintgetValue() {
returnvalue;
 }

/**
 * Get the compilation level enum from the specified integer.
 *
 * @param value the compilation level as integer.
 * @throws TestRunException if {@code value} does not specify a valid compilation level.
 * @return the compilation level enum for {@code value}.
 */
publicstaticCompLevelforValue(intvalue) {
CompLevellevel = TYPES_BY_VALUE.get(value);
TestRun.check(level != null, "Invalid compilation level " + value);
returnlevel;
 }

/**
 * Called by {@link TestFramework} to check if this compilation level is not part of the compiler.
 */
publicbooleanisNotCompilationLevelOfCompiler(Compilerc) {
returnswitch (c) {
caseC1 -> !isC1();
caseC2 -> this != C2;
default -> thrownewTestFrameworkException("Should not be called with compiler " + c);
 };
 }

/**
 * Called by {@link TestFramework} to flip compilation levels.
 */
publicCompLevelflipCompLevel() {
switch (this) {
caseC1_SIMPLE, C1_LIMITED_PROFILE, C1_FULL_PROFILE -> {
returnCompLevel.C2;
 }
caseC2 -> {
returnCompLevel.C1_SIMPLE;
 }
 }
returnthis;
 }

/**
 * Called by {@link TestFramework}. Return the compilation level when only allowing a compilation with the specified
 * compiler.
 */
publicCompLevelexcludeCompilationRandomly(Executableex) {
if (Utils.getRandomInstance().nextBoolean()) {
// No exclusion
returnthis;
 }
Compilercompiler = TestVM.excludeRandomly(ex);
returnswitch (compiler) {
caseANY -> SKIP;
caseC1 -> isC1() ? SKIP : this;
caseC2 -> this == C2 ? SKIP : this;
 };
 }

privatebooleanisC1() {
returnthis == C1_SIMPLE || this == C1_LIMITED_PROFILE || this == C1_FULL_PROFILE;
 }
}