/*

 * Copyright (c) 1997, 2011, 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 "utilities/debug.hpp"

#ifdef TARGET_ARCH_x86

# include "globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "globals_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "globals_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "globals_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "globals_windows.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_x86

# include "globals_linux_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_sparc

# include "globals_linux_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_zero

# include "globals_linux_zero.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_x86

# include "globals_solaris_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_sparc

# include "globals_solaris_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_windows_x86

# include "globals_windows_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_arm

# include "globals_linux_arm.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_ppc

# include "globals_linux_ppc.hpp"

#endif

#ifdef COMPILER1

#ifdef TARGET_ARCH_x86

# include "c1_globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "c1_globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "c1_globals_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "c1_globals_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "c1_globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "c1_globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "c1_globals_windows.hpp"

#endif

#endif

#ifdef COMPILER2

#ifdef TARGET_ARCH_x86

# include "c2_globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "c2_globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "c2_globals_arm.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "c2_globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "c2_globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "c2_globals_windows.hpp"

#endif

#endif

#ifdef SHARK

#ifdef TARGET_ARCH_zero

# include "shark_globals_zero.hpp"

#endif

#endif

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

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, BackEdgeThreshold,            0);

define_pd_global(intx, OnStackReplacePercentage,     0);

define_pd_global(bool, ResizeTLAB,                   false);

define_pd_global(intx, FreqInlineSize,               0);

define_pd_global(intx, InlineSmallCode,              0);

define_pd_global(intx, NewSizeThreadIncrease,        4*K);

define_pd_global(intx, InlineClassNatives,           true);

define_pd_global(intx, InlineUnsafeOps,              true);

define_pd_global(intx, InitialCodeCacheSize,         160*K);

define_pd_global(intx, ReservedCodeCacheSize,        32*M);

define_pd_global(intx, CodeCacheExpansionSize,       32*K);

define_pd_global(intx, CodeCacheMinBlockLength,      1);

define_pd_global(uintx,PermSize,    ScaleForWordSize(4*M));

define_pd_global(uintx,MaxPermSize, ScaleForWordSize(64*M));

define_pd_global(bool, NeverActAsServerClassMachine, true);

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

#define CI_COMPILER_COUNT 0

#else

#ifdef COMPILER2

#define CI_COMPILER_COUNT 2

#else

#define CI_COMPILER_COUNT 1

#endif // COMPILER2

#endif // no compilers

// string type aliases used only in this file

typedef const char* ccstr;

typedef const char* ccstrlist;   // represents string arguments which accumulate

enum FlagValueOrigin {

  DEFAULT          = 0,

  COMMAND_LINE     = 1,

  ENVIRON_VAR      = 2,

  CONFIG_FILE      = 3,

  MANAGEMENT       = 4,

  ERGONOMIC        = 5,

  ATTACH_ON_DEMAND = 6,

  INTERNAL         = 99

};

struct Flag {

  const char *type;

  const char *name;

  void*       addr;

  NOT_PRODUCT(const char *doc;)

  const char *kind;

  FlagValueOrigin origin;

  // points to all Flags static array

  static Flag *flags;

  // number of flags

  static size_t numFlags;

  static Flag* find_flag(char* name, size_t length);

  bool is_bool() const        { return strcmp(type, "bool") == 0; }

  bool get_bool() const       { return *((bool*) addr); }

  void set_bool(bool value)   { *((bool*) addr) = value; }

  bool is_intx()  const       { return strcmp(type, "intx")  == 0; }

  intx get_intx() const       { return *((intx*) addr); }

  void set_intx(intx value)   { *((intx*) addr) = value; }

  bool is_uintx() const       { return strcmp(type, "uintx") == 0; }

  uintx get_uintx() const     { return *((uintx*) addr); }

  void set_uintx(uintx value) { *((uintx*) addr) = value; }

  bool is_uint64_t() const          { return strcmp(type, "uint64_t") == 0; }

  uint64_t get_uint64_t() const     { return *((uint64_t*) addr); }

  void set_uint64_t(uint64_t value) { *((uint64_t*) addr) = value; }

  bool is_double() const        { return strcmp(type, "double") == 0; }

  double get_double() const     { return *((double*) addr); }

  void set_double(double value) { *((double*) addr) = value; }

  bool is_ccstr() const          { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; }

  bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; }

  ccstr get_ccstr() const     { return *((ccstr*) addr); }

  void set_ccstr(ccstr value) { *((ccstr*) addr) = value; }

  bool is_unlocker() const;

  bool is_unlocked() const;

  bool is_writeable() const;

  bool is_external() const;

  void print_on(outputStream* st, bool withComments = false );

  void print_as_flag(outputStream* st);

};

// debug flags control various aspects of the VM and are global accessible

// use FlagSetting to temporarily change some debug flag

// e.g. FlagSetting fs(DebugThisAndThat, true);

// restored to previous value upon leaving scope

class FlagSetting {

  bool val;

  bool* flag;

 public:

  FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }

  ~FlagSetting()                       { *flag = val; }

};

class CounterSetting {

  intx* counter;

 public:

  CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }

  ~CounterSetting()         { (*counter)--; }

};

class IntFlagSetting {

  intx val;

  intx* flag;

 public:

  IntFlagSetting(intx& fl, intx newValue) { flag = &fl; val = fl; fl = newValue; }

  ~IntFlagSetting()                       { *flag = val; }

};

class DoubleFlagSetting {

  double val;

  double* flag;

 public:

  DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }

  ~DoubleFlagSetting()                           { *flag = val; }

};

class CommandLineFlags {

 public:

  static bool boolAt(char* name, size_t len, bool* value);

  static bool boolAt(char* name, bool* value)      { return boolAt(name, strlen(name), value); }

  static bool boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin);

  static bool boolAtPut(char* name, bool* value, FlagValueOrigin origin)   { return boolAtPut(name, strlen(name), value, origin); }

  static bool intxAt(char* name, size_t len, intx* value);

  static bool intxAt(char* name, intx* value)      { return intxAt(name, strlen(name), value); }

  static bool intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin);

  static bool intxAtPut(char* name, intx* value, FlagValueOrigin origin)   { return intxAtPut(name, strlen(name), value, origin); }

  static bool uintxAt(char* name, size_t len, uintx* value);

  static bool uintxAt(char* name, uintx* value)    { return uintxAt(name, strlen(name), value); }

  static bool uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin);

  static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin origin) { return uintxAtPut(name, strlen(name), value, origin); }

  static bool uint64_tAt(char* name, size_t len, uint64_t* value);

  static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }

  static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin);

  static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); }

  static bool doubleAt(char* name, size_t len, double* value);

  static bool doubleAt(char* name, double* value)    { return doubleAt(name, strlen(name), value); }

  static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);

  static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }

  static bool ccstrAt(char* name, size_t len, ccstr* value);

  static bool ccstrAt(char* name, ccstr* value)    { return ccstrAt(name, strlen(name), value); }

  static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);

  static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }

  // Returns false if name is not a command line flag.

  static bool wasSetOnCmdline(const char* name, bool* value);

  static void printSetFlags();

  static void printFlags(bool withComments = false );

  static void verify() PRODUCT_RETURN;

};

// 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

// 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

// 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, intx, uintx, ccstr.

// 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.

#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \

                                                                            \

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

                                                                            \

  notproduct(bool, CheckCompressedOops, true,                               \

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

                                                                            \

  product_pd(uintx, HeapBaseMinAddress,                                     \

            "OS specific low limit for heap base address")                  \

                                                                            \

  diagnostic(bool, PrintCompressedOopsMode, false,                          \

            "Print compressed oops base address and encoding mode")         \

                                                                            \

  lp64_product(intx, ObjectAlignmentInBytes, 8,                             \

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

                                                                            \

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

                                                                            \

  /* Temp PPC Flag to allow disabling the use of lwsync on ppc platforms    \

   * that don't support it.  This will be replaced by processor detection   \

   * logic.                                                                 \

   */                                                                       \

  product(bool, UsePPCLWSYNC, true,                                         \

          "Use lwsync instruction if true, else use slower sync")           \

                                                                            \

  /* Temporary: See 6948537 */                                             \

  experimental(bool, UseMemSetInBOT, true,                                  \

          "(Unstable) uses memset in BOT updates in GC code")               \

                                                                            \

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

                                                                            \

  develop(bool, TracePageSizes, false,                                      \

          "Trace page size selection and usage.")                           \

                                                                            \

  product(bool, UseNUMA, false,                                             \

          "Use NUMA if available")                                          \

                                                                            \

  product(bool, ForceNUMA, false,                                           \

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

                                                                            \

  product(intx, NUMAChunkResizeWeight, 20,                                  \

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

          "computing exponentially decaying average for "                   \

          "AdaptiveNUMAChunkSizing")                                        \

                                                                            \

  product(intx, NUMASpaceResizeRate, 1*G,                                   \

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

                                                                            \

  product(bool, UseAdaptiveNUMAChunkSizing, true,                           \

          "Enable adaptive chunk sizing for NUMA")                          \

                                                                            \

  product(bool, NUMAStats, false,                                           \

          "Print NUMA stats in detailed heap information")                  \

                                                                            \

  product(intx, NUMAPageScanRate, 256,                                      \

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

                                                                            \

  product_pd(bool, NeedsDeoptSuspend,                                       \

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

                                                                            \

  product(intx, UseSSE, 99,                                                 \

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

                                                                            \

  product(uintx, LargePageSizeInBytes, 0,                                   \

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

                                                                            \

  product(uintx, LargePageHeapSizeThreshold, 128*M,                         \

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

                                                                            \

  product(bool, ForceTimeHighResolution, false,                             \

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

                                                                            \

  develop(bool, TraceItables, false,                                        \

          "Trace initialization and use of itables")                        \

                                                                            \

  develop(bool, TracePcPatching, false,                                     \

          "Trace usage of frame::patch_pc")                                 \

                                                                            \

  develop(bool, TraceJumps, false,                                          \

          "Trace assembly jumps in thread ring buffer")                     \

                                                                            \

  develop(bool, TraceRelocator, false,                                      \