/*

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

 *

 */

#ifndef SHARE_RUNTIME_GLOBALS_HPP

#define SHARE_RUNTIME_GLOBALS_HPP

#include "compiler/compiler_globals.hpp"

#include "gc/shared/gc_globals.hpp"

#include "runtime/globals_shared.hpp"

#include "utilities/align.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/macros.hpp"

#include CPU_HEADER(globals)

#include OS_HEADER(globals)

#include OS_CPU_HEADER(globals)

// develop flags are settable / visible only during development and are constant in the PRODUCT version

// product flags are always settable / visible

// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version

// A flag must be declared with one of the following types:

// bool, int, uint, intx, uintx, size_t, ccstr, ccstrlist, double, or uint64_t.

// The type "ccstr" and "ccstrlist" are an alias for "const char*" and is used

// only in this file, because the macrology requires single-token type names.

// Note: Diagnostic options not meant for VM tuning or for product modes.

// They are to be used for VM quality assurance or field diagnosis

// of VM bugs.  They are hidden so that users will not be encouraged to

// try them as if they were VM ordinary execution options.  However, they

// are available in the product version of the VM.  Under instruction

// from support engineers, VM customers can turn them on to collect

// diagnostic information about VM problems.  To use a VM diagnostic

// option, you must first specify +UnlockDiagnosticVMOptions.

// (This master switch also affects the behavior of -Xprintflags.)

//

// experimental flags are in support of features that are not

//    part of the officially supported product, but are available

//    for experimenting with. They could, for example, be performance

//    features that may not have undergone full or rigorous QA, but which may

//    help performance in some cases and released for experimentation

//    by the community of users and developers. This flag also allows one to

//    be able to build a fully supported product that nonetheless also

//    ships with some unsupported, lightly tested, experimental features.

//    Like the UnlockDiagnosticVMOptions flag above, there is a corresponding

//    UnlockExperimentalVMOptions flag, which allows the control and

//    modification of the experimental flags.

//

// Nota bene: neither diagnostic nor experimental options should be used casually,

//    and they are not supported on production loads, except under explicit

//    direction from support engineers.

//

// manageable flags are writeable external product flags.

//    They are dynamically writeable through the JDK management interface

//    (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.

//    These flags are external exported interface (see CCC).  The list of

//    manageable flags can be queried programmatically through the management

//    interface.

//

//    A flag can be made as "manageable" only if

//    - the flag is defined in a CCC as an external exported interface.

//    - the VM implementation supports dynamic setting of the flag.

//      This implies that the VM must *always* query the flag variable

//      and not reuse state related to the flag state at any given time.

//    - you want the flag to be queried programmatically by the customers.

//

// product_rw flags are writeable internal product flags.

//    They are like "manageable" flags but for internal/private use.

//    The list of product_rw flags are internal/private flags which

//    may be changed/removed in a future release.  It can be set

//    through the management interface to get/set value

//    when the name of flag is supplied.

//

//    A flag can be made as "product_rw" only if

//    - the VM implementation supports dynamic setting of the flag.

//      This implies that the VM must *always* query the flag variable

//      and not reuse state related to the flag state at any given time.

//

// Note that when there is a need to support develop flags to be writeable,

// it can be done in the same way as product_rw.

//

// range is a macro that will expand to min and max arguments for range

//    checking code if provided - see jvmFlagRangeList.hpp

//

// constraint is a macro that will expand to custom function call

//    for constraint checking if provided - see jvmFlagConstraintList.hpp

//

// writeable is a macro that controls if and how the value can change during the runtime

//

// writeable(Always) is optional and allows the flag to have its value changed

//    without any limitations at any time

//

// writeable(Once) flag value's can be only set once during the lifetime of VM

//

// writeable(CommandLineOnly) flag value's can be only set from command line

//    (multiple times allowed)

//

// Default and minimum StringTable and SymbolTable size values

// Must be powers of 2

const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536);

const size_t minimumStringTableSize = 128;

const size_t defaultSymbolTableSize = 32768; // 2^15

const size_t minimumSymbolTableSize = 1024;

#define RUNTIME_FLAGS(develop, \

                      develop_pd, \

                      product, \

                      product_pd, \

                      diagnostic, \

                      diagnostic_pd, \

                      experimental, \

                      notproduct, \

                      manageable, \

                      product_rw, \

                      lp64_product, \

                      range, \

                      constraint, \

                      writeable) \

                                                                            \

  lp64_product(bool, UseCompressedOops, false,                              \

          "Use 32-bit object references in 64-bit VM. "                     \

          "lp64_product means flag is always constant in 32 bit VM")        \

                                                                            \

  lp64_product(bool, UseCompressedClassPointers, false,                     \

          "Use 32-bit class pointers in 64-bit VM. "                        \

          "lp64_product means flag is always constant in 32 bit VM")        \

                                                                            \

  notproduct(bool, CheckCompressedOops, true,                               \

          "Generate checks in encoding/decoding code in debug VM")          \

                                                                            \

  product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17),                        \

          "Heap allocation steps through preferred address regions to find" \

          " where it can allocate the heap. Number of steps to take per "   \

          "region.")                                                        \

          range(1, max_uintx)                                               \

                                                                            \

  lp64_product(intx, ObjectAlignmentInBytes, 8,                             \

          "Default object alignment in bytes, 8 is minimum")                \

          range(8, 256)                                                     \

          constraint(ObjectAlignmentInBytesConstraintFunc,AtParse)          \

                                                                            \

  develop(bool, CleanChunkPoolAsync, true,                                  \

          "Clean the chunk pool asynchronously")                            \

                                                                            \

  product_pd(bool, ThreadLocalHandshakes,                                   \

          "Use thread-local polls instead of global poll for safepoints.")  \

          constraint(ThreadLocalHandshakesConstraintFunc,AfterErgo)         \

                                                                            \

  diagnostic(uint, HandshakeTimeout, 0,                                     \

          "If nonzero set a timeout in milliseconds for handshakes")        \

                                                                            \

  experimental(bool, AlwaysSafeConstructors, false,                         \

          "Force safe construction, as if all fields are final.")           \

                                                                            \

  diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \

          "Enable normal processing of flags relating to field diagnostics")\

                                                                            \

  experimental(bool, UnlockExperimentalVMOptions, false,                    \

          "Enable normal processing of flags relating to experimental "     \

          "features")                                                       \

                                                                            \

  product(bool, JavaMonitorsInStackTrace, true,                             \

          "Print information about Java monitor locks when the stacks are"  \

          "dumped")                                                         \

                                                                            \

  product_pd(bool, UseLargePages,                                           \

          "Use large page memory")                                          \

                                                                            \

  product_pd(bool, UseLargePagesIndividualAllocation,                       \

          "Allocate large pages individually for better affinity")          \

                                                                            \

  develop(bool, LargePagesIndividualAllocationInjectError, false,           \

          "Fail large pages individual allocation")                         \

                                                                            \

  product(bool, UseLargePagesInMetaspace, false,                            \

          "Use large page memory in metaspace. "                            \

          "Only used if UseLargePages is enabled.")                         \

                                                                            \

  product(bool, UseNUMA, false,                                             \

          "Use NUMA if available")                                          \

                                                                            \

  product(bool, UseNUMAInterleaving, false,                                 \

          "Interleave memory across NUMA nodes if available")               \

                                                                            \

  product(size_t, NUMAInterleaveGranularity, 2*M,                           \

          "Granularity to use for NUMA interleaving on Windows OS")         \

          range(os::vm_allocation_granularity(), NOT_LP64(2*G) LP64_ONLY(8192*G)) \

                                                                            \

  product(bool, ForceNUMA, false,                                           \

          "Force NUMA optimizations on single-node/UMA systems")            \

                                                                            \

  product(uintx, NUMAChunkResizeWeight, 20,                                 \

          "Percentage (0-100) used to weight the current sample when "      \

          "computing exponentially decaying average for "                   \

          "AdaptiveNUMAChunkSizing")                                        \

          range(0, 100)                                                     \

                                                                            \

  product(size_t, NUMASpaceResizeRate, 1*G,                                 \

          "Do not reallocate more than this amount per collection")         \

          range(0, max_uintx)                                               \

                                                                            \

  product(bool, UseAdaptiveNUMAChunkSizing, true,                           \

          "Enable adaptive chunk sizing for NUMA")                          \

                                                                            \

  product(bool, NUMAStats, false,                                           \

          "Print NUMA stats in detailed heap information")                  \

                                                                            \

  product(uintx, NUMAPageScanRate, 256,                                     \

          "Maximum number of pages to include in the page scan procedure")  \

          range(0, max_uintx)                                               \

                                                                            \

  product(intx, UseSSE, 99,                                                 \

          "Highest supported SSE instructions set on x86/x64")              \

          range(0, 99)                                                      \

                                                                            \

  product(bool, UseAES, false,                                              \

          "Control whether AES instructions are used when available")       \

                                                                            \

  product(bool, UseFMA, false,                                              \

          "Control whether FMA instructions are used when available")       \

                                                                            \

  product(bool, UseSHA, false,                                              \

          "Control whether SHA instructions are used when available")       \

                                                                            \

  diagnostic(bool, UseGHASHIntrinsics, false,                               \

          "Use intrinsics for GHASH versions of crypto")                    \

                                                                            \

  product(bool, UseBASE64Intrinsics, false,                                 \

          "Use intrinsics for java.util.Base64")                            \

                                                                            \

  product(size_t, LargePageSizeInBytes, 0,                                  \

          "Large page size (0 to let VM choose the page size)")             \

          range(0, max_uintx)                                               \

                                                                            \

  product(size_t, LargePageHeapSizeThreshold, 128*M,                        \

          "Use large pages if maximum heap is at least this big")           \

          range(0, max_uintx)                                               \

                                                                            \

  product(bool, ForceTimeHighResolution, false,                             \

          "Using high time resolution (for Win32 only)")                    \

                                                                            \

  develop(bool, TracePcPatching, false,                                     \

          "Trace usage of frame::patch_pc")                                 \

                                                                            \

  develop(bool, TraceRelocator, false,                                      \

          "Trace the bytecode relocator")                                   \

                                                                            \

  develop(bool, TraceLongCompiles, false,                                   \

          "Print out every time compilation is longer than "                \

          "a given threshold")                                              \

                                                                            \

  diagnostic(bool, SafepointALot, false,                                    \

          "Generate a lot of safepoints. This works with "                  \

          "GuaranteedSafepointInterval")                                    \

                                                                            \

  diagnostic(bool, HandshakeALot, false,                                    \

          "Generate a lot of handshakes. This works with "                  \

          "GuaranteedSafepointInterval")                                    \

                                                                            \

  product_pd(bool, BackgroundCompilation,                                   \

          "A thread requesting compilation is not blocked during "          \

          "compilation")                                                    \

                                                                            \

  product(bool, PrintVMQWaitTime, false,                                    \

          "Print out the waiting time in VM operation queue")               \

                                                                            \

  product(bool, MethodFlushing, true,                                       \

          "Reclamation of zombie and not-entrant methods")                  \

                                                                            \

  develop(bool, VerifyStack, false,                                         \

          "Verify stack of each thread when it is entering a runtime call") \

                                                                            \

  diagnostic(bool, ForceUnreachable, false,                                 \

          "Make all non code cache addresses to be unreachable by "         \

          "forcing use of 64bit literal fixups")                            \

                                                                            \

  notproduct(bool, StressDerivedPointers, false,                            \

          "Force scavenge when a derived pointer is detected on stack "     \

          "after rtm call")                                                 \

                                                                            \

  develop(bool, TraceDerivedPointers, false,                                \

          "Trace traversal of derived pointers on stack")                   \

                                                                            \

  notproduct(bool, TraceCodeBlobStacks, false,                              \

          "Trace stack-walk of codeblobs")                                  \

                                                                            \

  notproduct(bool, PrintRewrites, false,                                    \

          "Print methods that are being rewritten")                         \

                                                                            \

  product(bool, UseInlineCaches, true,                                      \

          "Use Inline Caches for virtual calls ")                           \

                                                                            \

  diagnostic(bool, InlineArrayCopy, true,                                   \

          "Inline arraycopy native that is known to be part of "            \

          "base library DLL")                                               \

                                                                            \

  diagnostic(bool, InlineObjectHash, true,                                  \

          "Inline Object::hashCode() native that is known to be part "      \

          "of base library DLL")                                            \

                                                                            \

  diagnostic(bool, InlineNatives, true,                                     \

          "Inline natives that are known to be part of base library DLL")   \

                                                                            \

  diagnostic(bool, InlineMathNatives, true,                                 \

          "Inline SinD, CosD, etc.")                                        \

                                                                            \

  diagnostic(bool, InlineClassNatives, true,                                \

          "Inline Class.isInstance, etc")                                   \

                                                                            \

  diagnostic(bool, InlineThreadNatives, true,                               \

          "Inline Thread.currentThread, etc")                               \

                                                                            \

  diagnostic(bool, InlineUnsafeOps, true,                                   \

          "Inline memory ops (native methods) from Unsafe")                 \

                                                                            \

  product(bool, CriticalJNINatives, true,                                   \

          "Check for critical JNI entry points")                            \

                                                                            \

  notproduct(bool, StressCriticalJNINatives, false,                         \

          "Exercise register saving code in critical natives")              \

                                                                            \

  diagnostic(bool, UseAESIntrinsics, false,                                 \

          "Use intrinsics for AES versions of crypto")                      \

                                                                            \

  diagnostic(bool, UseAESCTRIntrinsics, false,                              \

          "Use intrinsics for the paralleled version of AES/CTR crypto")    \

                                                                            \

  diagnostic(bool, UseSHA1Intrinsics, false,                                \

          "Use intrinsics for SHA-1 crypto hash function. "                 \

          "Requires that UseSHA is enabled.")                               \

                                                                            \

  diagnostic(bool, UseSHA256Intrinsics, false,                              \

          "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. "  \

          "Requires that UseSHA is enabled.")                               \

                                                                            \

  diagnostic(bool, UseSHA512Intrinsics, false,                              \

          "Use intrinsics for SHA-384 and SHA-512 crypto hash functions. "  \

          "Requires that UseSHA is enabled.")                               \

                                                                            \

  diagnostic(bool, UseCRC32Intrinsics, false,                               \

          "use intrinsics for java.util.zip.CRC32")                         \

                                                                            \

  diagnostic(bool, UseCRC32CIntrinsics, false,                              \

          "use intrinsics for java.util.zip.CRC32C")                        \

                                                                            \

  diagnostic(bool, UseAdler32Intrinsics, false,                             \

          "use intrinsics for java.util.zip.Adler32")                       \

                                                                            \

  diagnostic(bool, UseVectorizedMismatchIntrinsic, false,                   \

          "Enables intrinsification of ArraysSupport.vectorizedMismatch()") \

                                                                            \

  diagnostic(ccstrlist, DisableIntrinsic, "",                               \

         "do not expand intrinsics whose (internal) names appear here")     \

                                                                            \

  develop(bool, TraceCallFixup, false,                                      \

          "Trace all call fixups")                                          \

                                                                            \

  develop(bool, DeoptimizeALot, false,                                      \

          "Deoptimize at every exit from the runtime system")               \

                                                                            \

  notproduct(ccstrlist, DeoptimizeOnlyAt, "",                               \

          "A comma separated list of bcis to deoptimize at")                \

                                                                            \

  develop(bool, DeoptimizeRandom, false,                                    \

          "Deoptimize random frames on random exit from the runtime system")\

                                                                            \

  notproduct(bool, ZombieALot, false,                                       \

          "Create zombies (non-entrant) at exit from the runtime system")   \

                                                                            \

  notproduct(bool, WalkStackALot, false,                                    \

          "Trace stack (no print) at every exit from the runtime system")   \

                                                                            \

  product(bool, Debugging, false,                                           \

          "Set when executing debug methods in debug.cpp "                  \

          "(to prevent triggering assertions)")                             \

                                                                            \

  notproduct(bool, VerifyLastFrame, false,                                  \

          "Verify oops on last frame on entry to VM")                       \

                                                                            \

  product(bool, SafepointTimeout, false,                                    \

          "Time out and warn or fail after SafepointTimeoutDelay "          \

          "milliseconds if failed to reach safepoint")                      \

                                                                            \

  diagnostic(bool, AbortVMOnSafepointTimeout, false,                        \

          "Abort upon failure to reach safepoint (see SafepointTimeout)")   \

                                                                            \

  diagnostic(bool, AbortVMOnVMOperationTimeout, false,                      \

          "Abort upon failure to complete VM operation promptly")           \

                                                                            \

  diagnostic(intx, AbortVMOnVMOperationTimeoutDelay, 1000,                  \

          "Delay in milliseconds for option AbortVMOnVMOperationTimeout")   \

          range(0, max_intx)                                                \

                                                                            \

  /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */      \

  /* typically, at most a few retries are needed                    */      \

  product(intx, SuspendRetryCount, 50,                                      \

          "Maximum retry count for an external suspend request")            \

          range(0, max_intx)                                                \

                                                                            \

  product(intx, SuspendRetryDelay, 5,                                       \

          "Milliseconds to delay per retry (* current_retry_count)")        \

          range(0, max_intx)                                                \

                                                                            \

  product(bool, AssertOnSuspendWaitFailure, false,                          \

          "Assert/Guarantee on external suspend wait failure")              \

                                                                            \

  product(bool, TraceSuspendWaitFailures, false,                            \

          "Trace external suspend wait failures")                           \

                                                                            \

  product(bool, MaxFDLimit, true,                                           \

          "Bump the number of file descriptors to maximum in Solaris")      \

                                                                            \

  diagnostic(bool, LogEvents, true,                                         \

          "Enable the various ring buffer event logs")                      \

                                                                            \

  diagnostic(uintx, LogEventsBufferEntries, 20,                             \

          "Number of ring buffer event logs")                               \

          range(1, NOT_LP64(1*K) LP64_ONLY(1*M))                            \

                                                                            \

  diagnostic(bool, BytecodeVerificationRemote, true,                        \

          "Enable the Java bytecode verifier for remote classes")           \

                                                                            \

  diagnostic(bool, BytecodeVerificationLocal, false,                        \

          "Enable the Java bytecode verifier for local classes")            \

                                                                            \

  develop(bool, ForceFloatExceptions, trueInDebug,                          \

          "Force exceptions on FP stack under/overflow")                    \

                                                                            \

  develop(bool, VerifyStackAtCalls, false,                                  \

          "Verify that the stack pointer is unchanged after calls")         \

                                                                            \

  develop(bool, TraceJavaAssertions, false,                                 \

          "Trace java language assertions")                                 \

                                                                            \

  notproduct(bool, VerifyCodeCache, false,                                  \

          "Verify code cache on memory allocation/deallocation")            \

                                                                            \

  develop(bool, UseMallocOnly, false,                                       \

          "Use only malloc/free for allocation (no resource area/arena)")   \

                                                                            \

  develop(bool, ZapResourceArea, trueInDebug,                               \

          "Zap freed resource/arena space with 0xABABABAB")                 \

                                                                            \

  notproduct(bool, ZapVMHandleArea, trueInDebug,                            \

          "Zap freed VM handle space with 0xBCBCBCBC")                      \

                                                                            \

  notproduct(bool, ZapStackSegments, trueInDebug,                           \

          "Zap allocated/freed stack segments with 0xFADFADED")             \

                                                                            \

  develop(bool, ZapUnusedHeapArea, trueInDebug,                             \

          "Zap unused heap space with 0xBAADBABE")                          \

                                                                            \

  develop(bool, CheckZapUnusedHeapArea, false,                              \

          "Check zapping of unused heap space")                             \

                                                                            \

  develop(bool, ZapFillerObjects, trueInDebug,                              \

          "Zap filler objects with 0xDEAFBABE")                             \

                                                                            \

  develop(bool, PrintVMMessages, true,                                      \

          "Print VM messages on console")                                   \

                                                                            \

  notproduct(uintx, ErrorHandlerTest, 0,                                    \

          "If > 0, provokes an error after VM initialization; the value "   \

          "determines which error to provoke. See test_error_handler() "    \

          "in vmError.cpp.")                                                \

                                                                            \

  notproduct(uintx, TestCrashInErrorHandler, 0,                             \

          "If > 0, provokes an error inside VM error handler (a secondary " \

          "crash). see test_error_handler() in vmError.cpp")                \

                                                                            \

  notproduct(bool, TestSafeFetchInErrorHandler, false,                      \

          "If true, tests SafeFetch inside error handler.")                 \

                                                                            \