| /* |
| * Copyright (c) 2016, 2019, 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. |
| * |
| */ |
| |
| #include "precompiled.hpp" |
| #include "code/codeCache.hpp" |
| #include "runtime/globals.hpp" |
| #include "runtime/globals_extension.hpp" |
| #include "compiler/compilerDefinitions.hpp" |
| #include "gc/shared/gcConfig.hpp" |
| #include "utilities/defaultStream.hpp" |
| |
| const char* compilertype2name_tab[compiler_number_of_types] = { |
| "", |
| "c1", |
| "c2", |
| "jvmci" |
| }; |
| |
| #if defined(COMPILER2) |
| CompLevel CompLevel_highest_tier = CompLevel_full_optimization; // pure C2 and tiered or JVMCI and tiered |
| #elif defined(COMPILER1) |
| CompLevel CompLevel_highest_tier = CompLevel_simple; // pure C1 or JVMCI |
| #else |
| CompLevel CompLevel_highest_tier = CompLevel_none; |
| #endif |
| |
| #if defined(TIERED) |
| CompLevel CompLevel_initial_compile = CompLevel_full_profile; // tiered |
| #elif defined(COMPILER1) || INCLUDE_JVMCI |
| CompLevel CompLevel_initial_compile = CompLevel_simple; // pure C1 or JVMCI |
| #elif defined(COMPILER2) |
| CompLevel CompLevel_initial_compile = CompLevel_full_optimization; // pure C2 |
| #else |
| CompLevel CompLevel_initial_compile = CompLevel_none; |
| #endif |
| |
| #if defined(COMPILER2) |
| CompMode Compilation_mode = CompMode_server; |
| #elif defined(COMPILER1) |
| CompMode Compilation_mode = CompMode_client; |
| #else |
| CompMode Compilation_mode = CompMode_none; |
| #endif |
| |
| // Returns threshold scaled with CompileThresholdScaling |
| intx CompilerConfig::scaled_compile_threshold(intx threshold) { |
| return scaled_compile_threshold(threshold, CompileThresholdScaling); |
| } |
| |
| // Returns freq_log scaled with CompileThresholdScaling |
| intx CompilerConfig::scaled_freq_log(intx freq_log) { |
| return scaled_freq_log(freq_log, CompileThresholdScaling); |
| } |
| |
| // Returns threshold scaled with the value of scale. |
| // If scale < 0.0, threshold is returned without scaling. |
| intx CompilerConfig::scaled_compile_threshold(intx threshold, double scale) { |
| assert(threshold >= 0, "must be"); |
| if (scale == 1.0 || scale < 0.0) { |
| return threshold; |
| } else { |
| double v = threshold * scale; |
| assert(v >= 0, "must be"); |
| if (v > max_intx) { |
| return max_intx; |
| } else { |
| return (intx)(v); |
| } |
| } |
| } |
| |
| // Returns freq_log scaled with the value of scale. |
| // Returned values are in the range of [0, InvocationCounter::number_of_count_bits + 1]. |
| // If scale < 0.0, freq_log is returned without scaling. |
| intx CompilerConfig::scaled_freq_log(intx freq_log, double scale) { |
| // Check if scaling is necessary or if negative value was specified. |
| if (scale == 1.0 || scale < 0.0) { |
| return freq_log; |
| } |
| // Check values to avoid calculating log2 of 0. |
| if (scale == 0.0 || freq_log == 0) { |
| return 0; |
| } |
| // Determine the maximum notification frequency value currently supported. |
| // The largest mask value that the interpreter/C1 can handle is |
| // of length InvocationCounter::number_of_count_bits. Mask values are always |
| // one bit shorter then the value of the notification frequency. Set |
| // max_freq_bits accordingly. |
| intx max_freq_bits = InvocationCounter::number_of_count_bits + 1; |
| intx scaled_freq = scaled_compile_threshold((intx)1 << freq_log, scale); |
| if (scaled_freq == 0) { |
| // Return 0 right away to avoid calculating log2 of 0. |
| return 0; |
| } else if (scaled_freq > nth_bit(max_freq_bits)) { |
| return max_freq_bits; |
| } else { |
| return log2_intptr(scaled_freq); |
| } |
| } |
| |
| #ifdef TIERED |
| void set_client_compilation_mode() { |
| Compilation_mode = CompMode_client; |
| CompLevel_highest_tier = CompLevel_simple; |
| CompLevel_initial_compile = CompLevel_simple; |
| FLAG_SET_ERGO(bool, TieredCompilation, false); |
| FLAG_SET_ERGO(bool, ProfileInterpreter, false); |
| #if INCLUDE_JVMCI |
| FLAG_SET_ERGO(bool, EnableJVMCI, false); |
| FLAG_SET_ERGO(bool, UseJVMCICompiler, false); |
| #endif |
| #if INCLUDE_AOT |
| FLAG_SET_ERGO(bool, UseAOT, false); |
| #endif |
| if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) { |
| FLAG_SET_ERGO(bool, NeverActAsServerClassMachine, true); |
| } |
| if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) { |
| FLAG_SET_ERGO(uintx, InitialCodeCacheSize, 160*K); |
| } |
| if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) { |
| FLAG_SET_ERGO(uintx, ReservedCodeCacheSize, 32*M); |
| } |
| if (FLAG_IS_DEFAULT(NonProfiledCodeHeapSize)) { |
| FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, 27*M); |
| } |
| if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize)) { |
| FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, 0); |
| } |
| if (FLAG_IS_DEFAULT(NonNMethodCodeHeapSize)) { |
| FLAG_SET_ERGO(uintx, NonNMethodCodeHeapSize, 5*M); |
| } |
| if (FLAG_IS_DEFAULT(CodeCacheExpansionSize)) { |
| FLAG_SET_ERGO(uintx, CodeCacheExpansionSize, 32*K); |
| } |
| if (FLAG_IS_DEFAULT(MetaspaceSize)) { |
| FLAG_SET_ERGO(size_t, MetaspaceSize, MIN2(12*M, MaxMetaspaceSize)); |
| } |
| if (FLAG_IS_DEFAULT(MaxRAM)) { |
| // Do not use FLAG_SET_ERGO to update MaxRAM, as this will impact |
| // heap setting done based on available phys_mem (see Arguments::set_heap_size). |
| FLAG_SET_DEFAULT(MaxRAM, 1ULL*G); |
| } |
| if (FLAG_IS_DEFAULT(CompileThreshold)) { |
| FLAG_SET_ERGO(intx, CompileThreshold, 1500); |
| } |
| if (FLAG_IS_DEFAULT(OnStackReplacePercentage)) { |
| FLAG_SET_ERGO(intx, OnStackReplacePercentage, 933); |
| } |
| if (FLAG_IS_DEFAULT(CICompilerCount)) { |
| FLAG_SET_ERGO(intx, CICompilerCount, 1); |
| } |
| } |
| |
| bool compilation_mode_selected() { |
| return !FLAG_IS_DEFAULT(TieredCompilation) || |
| !FLAG_IS_DEFAULT(TieredStopAtLevel) || |
| !FLAG_IS_DEFAULT(UseAOT) |
| JVMCI_ONLY(|| !FLAG_IS_DEFAULT(EnableJVMCI) |
| || !FLAG_IS_DEFAULT(UseJVMCICompiler)); |
| } |
| |
| void select_compilation_mode_ergonomically() { |
| #if defined(_WINDOWS) && !defined(_LP64) |
| if (FLAG_IS_DEFAULT(NeverActAsServerClassMachine)) { |
| FLAG_SET_ERGO(bool, NeverActAsServerClassMachine, true); |
| } |
| #endif |
| if (NeverActAsServerClassMachine) { |
| set_client_compilation_mode(); |
| } |
| } |
| |
| #endif // TIERED |
| |
| void CompilerConfig::set_tiered_flags() { |
| // With tiered, set default policy to SimpleThresholdPolicy, which is 2. |
| if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) { |
| FLAG_SET_DEFAULT(CompilationPolicyChoice, 2); |
| } |
| if (CompilationPolicyChoice < 2) { |
| vm_exit_during_initialization( |
| "Incompatible compilation policy selected", NULL); |
| } |
| // Increase the code cache size - tiered compiles a lot more. |
| if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) { |
| FLAG_SET_ERGO(uintx, ReservedCodeCacheSize, |
| MIN2(CODE_CACHE_DEFAULT_LIMIT, (size_t)ReservedCodeCacheSize * 5)); |
| } |
| // Enable SegmentedCodeCache if TieredCompilation is enabled, ReservedCodeCacheSize >= 240M |
| // and the code cache contains at least 8 pages (segmentation disables advantage of huge pages). |
| if (FLAG_IS_DEFAULT(SegmentedCodeCache) && ReservedCodeCacheSize >= 240*M && |
| 8 * CodeCache::page_size() <= ReservedCodeCacheSize) { |
| FLAG_SET_ERGO(bool, SegmentedCodeCache, true); |
| } |
| if (!UseInterpreter) { // -Xcomp |
| Tier3InvokeNotifyFreqLog = 0; |
| Tier4InvocationThreshold = 0; |
| } |
| |
| if (CompileThresholdScaling < 0) { |
| vm_exit_during_initialization("Negative value specified for CompileThresholdScaling", NULL); |
| } |
| |
| // Scale tiered compilation thresholds. |
| // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves compilation thresholds unchanged. |
| if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) { |
| FLAG_SET_ERGO(intx, Tier0InvokeNotifyFreqLog, scaled_freq_log(Tier0InvokeNotifyFreqLog)); |
| FLAG_SET_ERGO(intx, Tier0BackedgeNotifyFreqLog, scaled_freq_log(Tier0BackedgeNotifyFreqLog)); |
| |
| FLAG_SET_ERGO(intx, Tier3InvocationThreshold, scaled_compile_threshold(Tier3InvocationThreshold)); |
| FLAG_SET_ERGO(intx, Tier3MinInvocationThreshold, scaled_compile_threshold(Tier3MinInvocationThreshold)); |
| FLAG_SET_ERGO(intx, Tier3CompileThreshold, scaled_compile_threshold(Tier3CompileThreshold)); |
| FLAG_SET_ERGO(intx, Tier3BackEdgeThreshold, scaled_compile_threshold(Tier3BackEdgeThreshold)); |
| |
| // Tier2{Invocation,MinInvocation,Compile,Backedge}Threshold should be scaled here |
| // once these thresholds become supported. |
| |
| FLAG_SET_ERGO(intx, Tier2InvokeNotifyFreqLog, scaled_freq_log(Tier2InvokeNotifyFreqLog)); |
| FLAG_SET_ERGO(intx, Tier2BackedgeNotifyFreqLog, scaled_freq_log(Tier2BackedgeNotifyFreqLog)); |
| |
| FLAG_SET_ERGO(intx, Tier3InvokeNotifyFreqLog, scaled_freq_log(Tier3InvokeNotifyFreqLog)); |
| FLAG_SET_ERGO(intx, Tier3BackedgeNotifyFreqLog, scaled_freq_log(Tier3BackedgeNotifyFreqLog)); |
| |
| FLAG_SET_ERGO(intx, Tier23InlineeNotifyFreqLog, scaled_freq_log(Tier23InlineeNotifyFreqLog)); |
| |
| FLAG_SET_ERGO(intx, Tier4InvocationThreshold, scaled_compile_threshold(Tier4InvocationThreshold)); |
| FLAG_SET_ERGO(intx, Tier4MinInvocationThreshold, scaled_compile_threshold(Tier4MinInvocationThreshold)); |
| FLAG_SET_ERGO(intx, Tier4CompileThreshold, scaled_compile_threshold(Tier4CompileThreshold)); |
| FLAG_SET_ERGO(intx, Tier4BackEdgeThreshold, scaled_compile_threshold(Tier4BackEdgeThreshold)); |
| } |
| } |
| |
| #if INCLUDE_JVMCI |
| void set_jvmci_specific_flags() { |
| if (UseJVMCICompiler) { |
| Compilation_mode = CompMode_server; |
| |
| if (FLAG_IS_DEFAULT(TypeProfileWidth)) { |
| FLAG_SET_DEFAULT(TypeProfileWidth, 8); |
| } |
| if (FLAG_IS_DEFAULT(OnStackReplacePercentage)) { |
| FLAG_SET_DEFAULT(OnStackReplacePercentage, 933); |
| } |
| // JVMCI needs values not less than defaults |
| if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) { |
| FLAG_SET_DEFAULT(ReservedCodeCacheSize, MAX2(64*M, ReservedCodeCacheSize)); |
| } |
| if (FLAG_IS_DEFAULT(InitialCodeCacheSize)) { |
| FLAG_SET_DEFAULT(InitialCodeCacheSize, MAX2(16*M, InitialCodeCacheSize)); |
| } |
| if (FLAG_IS_DEFAULT(MetaspaceSize)) { |
| FLAG_SET_DEFAULT(MetaspaceSize, MIN2(MAX2(12*M, MetaspaceSize), MaxMetaspaceSize)); |
| } |
| if (FLAG_IS_DEFAULT(NewSizeThreadIncrease)) { |
| FLAG_SET_DEFAULT(NewSizeThreadIncrease, MAX2(4*K, NewSizeThreadIncrease)); |
| } |
| if (TieredStopAtLevel != CompLevel_full_optimization) { |
| // Currently JVMCI compiler can only work at the full optimization level |
| warning("forcing TieredStopAtLevel to full optimization because JVMCI is enabled"); |
| FLAG_SET_ERGO(intx, TieredStopAtLevel, CompLevel_full_optimization); |
| } |
| if (FLAG_IS_DEFAULT(TypeProfileLevel)) { |
| FLAG_SET_DEFAULT(TypeProfileLevel, 0); |
| } |
| } |
| } |
| #endif // INCLUDE_JVMCI |
| |
| bool CompilerConfig::check_args_consistency(bool status) { |
| // Check lower bounds of the code cache |
| // Template Interpreter code is approximately 3X larger in debug builds. |
| uint min_code_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3); |
| if (ReservedCodeCacheSize < InitialCodeCacheSize) { |
| jio_fprintf(defaultStream::error_stream(), |
| "Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n", |
| ReservedCodeCacheSize/K, InitialCodeCacheSize/K); |
| status = false; |
| } else if (ReservedCodeCacheSize < min_code_cache_size) { |
| jio_fprintf(defaultStream::error_stream(), |
| "Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\n", ReservedCodeCacheSize/K, |
| min_code_cache_size/K); |
| status = false; |
| } else if (ReservedCodeCacheSize > CODE_CACHE_SIZE_LIMIT) { |
| // Code cache size larger than CODE_CACHE_SIZE_LIMIT is not supported. |
| jio_fprintf(defaultStream::error_stream(), |
| "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M, |
| CODE_CACHE_SIZE_LIMIT/M); |
| status = false; |
| } else if (NonNMethodCodeHeapSize < min_code_cache_size) { |
| jio_fprintf(defaultStream::error_stream(), |
| "Invalid NonNMethodCodeHeapSize=%dK. Must be at least %uK.\n", NonNMethodCodeHeapSize/K, |
| min_code_cache_size/K); |
| status = false; |
| } |
| |
| #ifdef _LP64 |
| if (!FLAG_IS_DEFAULT(CICompilerCount) && !FLAG_IS_DEFAULT(CICompilerCountPerCPU) && CICompilerCountPerCPU) { |
| warning("The VM option CICompilerCountPerCPU overrides CICompilerCount."); |
| } |
| #endif |
| |
| if (BackgroundCompilation && (CompileTheWorld || ReplayCompiles)) { |
| if (!FLAG_IS_DEFAULT(BackgroundCompilation)) { |
| warning("BackgroundCompilation disabled due to CompileTheWorld or ReplayCompiles options."); |
| } |
| FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); |
| } |
| |
| #ifdef COMPILER2 |
| if (PostLoopMultiversioning && !RangeCheckElimination) { |
| if (!FLAG_IS_DEFAULT(PostLoopMultiversioning)) { |
| warning("PostLoopMultiversioning disabled because RangeCheckElimination is disabled."); |
| } |
| FLAG_SET_CMDLINE(bool, PostLoopMultiversioning, false); |
| } |
| if (UseCountedLoopSafepoints && LoopStripMiningIter == 0) { |
| if (!FLAG_IS_DEFAULT(UseCountedLoopSafepoints) || !FLAG_IS_DEFAULT(LoopStripMiningIter)) { |
| warning("When counted loop safepoints are enabled, LoopStripMiningIter must be at least 1 (a safepoint every 1 iteration): setting it to 1"); |
| } |
| LoopStripMiningIter = 1; |
| } else if (!UseCountedLoopSafepoints && LoopStripMiningIter > 0) { |
| if (!FLAG_IS_DEFAULT(UseCountedLoopSafepoints) || !FLAG_IS_DEFAULT(LoopStripMiningIter)) { |
| warning("Disabling counted safepoints implies no loop strip mining: setting LoopStripMiningIter to 0"); |
| } |
| LoopStripMiningIter = 0; |
| } |
| #endif // COMPILER2 |
| |
| if (Arguments::is_interpreter_only()) { |
| if (UseCompiler) { |
| if (!FLAG_IS_DEFAULT(UseCompiler)) { |
| warning("UseCompiler disabled due to -Xint."); |
| } |
| FLAG_SET_CMDLINE(bool, UseCompiler, false); |
| } |
| if (ProfileInterpreter) { |
| if (!FLAG_IS_DEFAULT(ProfileInterpreter)) { |
| warning("ProfileInterpreter disabled due to -Xint."); |
| } |
| FLAG_SET_CMDLINE(bool, ProfileInterpreter, false); |
| } |
| if (TieredCompilation) { |
| if (!FLAG_IS_DEFAULT(TieredCompilation)) { |
| warning("TieredCompilation disabled due to -Xint."); |
| } |
| FLAG_SET_CMDLINE(bool, TieredCompilation, false); |
| } |
| #if INCLUDE_JVMCI |
| if (EnableJVMCI) { |
| if (!FLAG_IS_DEFAULT(EnableJVMCI) || !FLAG_IS_DEFAULT(UseJVMCICompiler)) { |
| warning("JVMCI Compiler disabled due to -Xint."); |
| } |
| FLAG_SET_CMDLINE(bool, EnableJVMCI, false); |
| FLAG_SET_CMDLINE(bool, UseJVMCICompiler, false); |
| } |
| #endif |
| } else { |
| #if INCLUDE_JVMCI |
| status = status && JVMCIGlobals::check_jvmci_flags_are_consistent(); |
| #endif |
| } |
| return status; |
| } |
| |
| void CompilerConfig::ergo_initialize() { |
| if (Arguments::is_interpreter_only()) { |
| return; // Nothing to do. |
| } |
| |
| #ifdef TIERED |
| if (!compilation_mode_selected()) { |
| select_compilation_mode_ergonomically(); |
| } |
| #endif |
| |
| #if INCLUDE_JVMCI |
| // Check that JVMCI compiler supports selested GC. |
| // Should be done after GCConfig::initialize() was called. |
| JVMCIGlobals::check_jvmci_supported_gc(); |
| set_jvmci_specific_flags(); |
| #endif |
| |
| if (TieredCompilation) { |
| set_tiered_flags(); |
| } else { |
| int max_compilation_policy_choice = 1; |
| #ifdef COMPILER2 |
| if (is_server_compilation_mode_vm()) { |
| max_compilation_policy_choice = 2; |
| } |
| #endif |
| // Check if the policy is valid. |
| if (CompilationPolicyChoice >= max_compilation_policy_choice) { |
| vm_exit_during_initialization( |
| "Incompatible compilation policy selected", NULL); |
| } |
| // Scale CompileThreshold |
| // CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged. |
| if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) { |
| FLAG_SET_ERGO(intx, CompileThreshold, scaled_compile_threshold(CompileThreshold)); |
| } |
| } |
| |
| if (UseOnStackReplacement && !UseLoopCounter) { |
| warning("On-stack-replacement requires loop counters; enabling loop counters"); |
| FLAG_SET_DEFAULT(UseLoopCounter, true); |
| } |
| |
| #ifdef COMPILER2 |
| if (!EliminateLocks) { |
| EliminateNestedLocks = false; |
| } |
| if (!Inline) { |
| IncrementalInline = false; |
| } |
| #ifndef PRODUCT |
| if (!IncrementalInline) { |
| AlwaysIncrementalInline = false; |
| } |
| if (FLAG_IS_CMDLINE(PrintIdealGraph) && !PrintIdealGraph) { |
| FLAG_SET_ERGO(intx, PrintIdealGraphLevel, -1); |
| } |
| #endif |
| if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) { |
| // nothing to use the profiling, turn if off |
| FLAG_SET_DEFAULT(TypeProfileLevel, 0); |
| } |
| if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) { |
| FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1); |
| } |
| if (FLAG_IS_DEFAULT(LoopStripMiningIterShortLoop)) { |
| // blind guess |
| LoopStripMiningIterShortLoop = LoopStripMiningIter / 10; |
| } |
| #endif // COMPILER2 |
| } |