/*

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

#define SHARE_VM_RUNTIME_GLOBALS_HPP

#include "gc/shared/gc_globals.hpp"

#include "utilities/align.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/macros.hpp"

#include <float.h> // for DBL_MAX

// The larger HeapWordSize for 64bit requires larger heaps

// for the same application running in 64bit.  See bug 4967770.

// The minimum alignment to a heap word size is done.  Other

// parts of the memory system may require additional alignment

// and are responsible for those alignments.

#ifdef _LP64

#define ScaleForWordSize(x) align_down_((x) * 13 / 10, HeapWordSize)

#else

#define ScaleForWordSize(x) (x)

#endif

// use this for flags that are true per default in the tiered build

// but false in non-tiered builds, and vice versa

#ifdef TIERED

#define  trueInTiered true

#define falseInTiered false

#else

#define  trueInTiered false

#define falseInTiered true

#endif

#include CPU_HEADER(globals)

#include OS_HEADER(globals)

#include OS_CPU_HEADER(globals)

#ifdef COMPILER1

#include CPU_HEADER(c1_globals)

#include OS_HEADER(c1_globals)

#endif

#ifdef COMPILER2

#include CPU_HEADER(c2_globals)

#include OS_HEADER(c2_globals)

#endif

#if !defined(COMPILER1) && !defined(COMPILER2) && !INCLUDE_JVMCI

define_pd_global(bool, BackgroundCompilation,        false);

define_pd_global(bool, UseTLAB,                      false);

define_pd_global(bool, CICompileOSR,                 false);

define_pd_global(bool, UseTypeProfile,               false);

define_pd_global(bool, UseOnStackReplacement,        false);

define_pd_global(bool, InlineIntrinsics,             false);

define_pd_global(bool, PreferInterpreterNativeStubs, true);

define_pd_global(bool, ProfileInterpreter,           false);

define_pd_global(bool, ProfileTraps,                 false);

define_pd_global(bool, TieredCompilation,            false);

define_pd_global(intx, CompileThreshold,             0);

define_pd_global(intx,   OnStackReplacePercentage,   0);

define_pd_global(bool,   ResizeTLAB,                 false);

define_pd_global(intx,   FreqInlineSize,             0);

define_pd_global(size_t, NewSizeThreadIncrease,      4*K);

define_pd_global(bool,   InlineClassNatives,         true);

define_pd_global(bool,   InlineUnsafeOps,            true);

define_pd_global(uintx,  InitialCodeCacheSize,       160*K);

define_pd_global(uintx,  ReservedCodeCacheSize,      32*M);

define_pd_global(uintx,  NonProfiledCodeHeapSize,    0);

define_pd_global(uintx,  ProfiledCodeHeapSize,       0);

define_pd_global(uintx,  NonNMethodCodeHeapSize,     32*M);

define_pd_global(uintx,  CodeCacheExpansionSize,     32*K);

define_pd_global(uintx,  CodeCacheMinBlockLength,    1);

define_pd_global(uintx,  CodeCacheMinimumUseSpace,   200*K);

define_pd_global(size_t, MetaspaceSize,              ScaleForWordSize(4*M));

define_pd_global(bool, NeverActAsServerClassMachine, true);

define_pd_global(uint64_t,MaxRAM,                    1ULL*G);

#define CI_COMPILER_COUNT 0

#else

#if COMPILER2_OR_JVMCI

#define CI_COMPILER_COUNT 2

#else

#define CI_COMPILER_COUNT 1

#endif // COMPILER2_OR_JVMCI

#endif // no compilers

// use this for flags that are true by default in the debug version but

// false in the optimized version, and vice versa

#ifdef ASSERT

#define trueInDebug  true

#define falseInDebug false

#else

#define trueInDebug  false

#define falseInDebug true

#endif

// use this for flags that are true per default in the product build

// but false in development builds, and vice versa

#ifdef PRODUCT

#define trueInProduct  true

#define falseInProduct false

#else

#define trueInProduct  false

#define falseInProduct true

#endif

// 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, double, or uint64_t.

// The type "ccstr" is 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)

//

#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)          \

                                                                            \

  product(bool, AssumeMP, true,                                             \

          "(Deprecated) Instruct the VM to assume multiple processors are available")\

                                                                            \

  /* UseMembar is theoretically a temp flag used for memory barrier      */ \

  /* removal testing.  It was supposed to be removed before FCS but has  */ \

  /* been re-added (see 6401008)                                         */ \

  product_pd(bool, UseMembar,                                               \

          "(Unstable) Issues membars on thread state transitions")          \

                                                                            \

  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_pd(bool, NeedsDeoptSuspend,                                       \

          "True for register window machines (sparc/ia64)")                 \

                                                                            \

  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(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")                                              \

                                                                            \

  develop(bool, SafepointALot, false,                                       \

          "Generate a lot of safepoints. 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")                                  \

                                                                            \

  product(bool, PrintJNIResolving, false,                                   \

          "Used to implement -v:jni")                                       \

                                                                            \

  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")                \

                                                                            \

  product(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")   \

                                                                            \

  product(bool, UnlinkSymbolsALot, false,                                   \

          "Unlink unreferenced symbols from the symbol table at safepoints")\

                                                                            \

  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)")                             \

                                                                            \