src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8015774 Sdiff src/share/vm/runtime

src/share/vm/runtime/globals.hpp

Print this page




 170 define_pd_global(bool, CICompileOSR,                 false);
 171 define_pd_global(bool, UseTypeProfile,               false);
 172 define_pd_global(bool, UseOnStackReplacement,        false);
 173 define_pd_global(bool, InlineIntrinsics,             false);
 174 define_pd_global(bool, PreferInterpreterNativeStubs, true);
 175 define_pd_global(bool, ProfileInterpreter,           false);
 176 define_pd_global(bool, ProfileTraps,                 false);
 177 define_pd_global(bool, TieredCompilation,            false);
 178 
 179 define_pd_global(intx, CompileThreshold,             0);
 180 define_pd_global(intx, BackEdgeThreshold,            0);
 181 
 182 define_pd_global(intx, OnStackReplacePercentage,     0);
 183 define_pd_global(bool, ResizeTLAB,                   false);
 184 define_pd_global(intx, FreqInlineSize,               0);
 185 define_pd_global(intx, NewSizeThreadIncrease,        4*K);
 186 define_pd_global(intx, InlineClassNatives,           true);
 187 define_pd_global(intx, InlineUnsafeOps,              true);
 188 define_pd_global(intx, InitialCodeCacheSize,         160*K);
 189 define_pd_global(intx, ReservedCodeCacheSize,        32*M);




 190 define_pd_global(intx, CodeCacheExpansionSize,       32*K);
 191 define_pd_global(intx, CodeCacheMinBlockLength,      1);
 192 define_pd_global(intx, CodeCacheMinimumUseSpace,     200*K);
 193 define_pd_global(uintx,MetaspaceSize,    ScaleForWordSize(4*M));
 194 define_pd_global(bool, NeverActAsServerClassMachine, true);
 195 define_pd_global(uint64_t,MaxRAM,                    1ULL*G);
 196 #define CI_COMPILER_COUNT 0
 197 #else
 198 
 199 #ifdef COMPILER2
 200 #define CI_COMPILER_COUNT 2
 201 #else
 202 #define CI_COMPILER_COUNT 1
 203 #endif // COMPILER2
 204 
 205 #endif // no compilers
 206 
 207 // string type aliases used only in this file
 208 typedef const char* ccstr;
 209 typedef const char* ccstrlist;   // represents string arguments which accumulate


3298   /* code cache parameters */                                               \
3299   /* ppc64/tiered compilation has large code-entry alignment. */            \
3300   develop(uintx, CodeCacheSegmentSize, 64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),\
3301           "Code cache segment size (in bytes) - smallest unit of "          \
3302           "allocation")                                                     \
3303                                                                             \
3304   develop_pd(intx, CodeEntryAlignment,                                      \
3305           "Code entry alignment for generated code (in bytes)")             \
3306                                                                             \
3307   product_pd(intx, OptoLoopAlignment,                                       \
3308           "Align inner loops to zero relative to this modulus")             \
3309                                                                             \
3310   product_pd(uintx, InitialCodeCacheSize,                                   \
3311           "Initial code cache size (in bytes)")                             \
3312                                                                             \
3313   develop_pd(uintx, CodeCacheMinimumUseSpace,                               \
3314           "Minimum code cache size (in bytes) required to start VM.")       \
3315                                                                             \
3316   product_pd(uintx, ReservedCodeCacheSize,                                  \
3317           "Reserved code cache size (in bytes) - maximum code cache size")  \









3318                                                                             \
3319   product(uintx, CodeCacheMinimumFreeSpace, 500*K,                          \
3320           "When less than X space left, we stop compiling")                 \
3321                                                                             \
3322   product_pd(uintx, CodeCacheExpansionSize,                                 \
3323           "Code cache expansion size (in bytes)")                           \
3324                                                                             \
3325   develop_pd(uintx, CodeCacheMinBlockLength,                                \
3326           "Minimum number of segments in a code cache block")               \
3327                                                                             \
3328   notproduct(bool, ExitOnFullCodeCache, false,                              \
3329           "Exit the VM if we fill the code cache")                          \
3330                                                                             \
3331   product(bool, UseCodeCacheFlushing, true,                                 \
3332           "Remove cold/old nmethods from the code cache")                   \
3333                                                                             \
3334   /* interpreter debugging */                                               \
3335   develop(intx, BinarySwitchThreshold, 5,                                   \
3336           "Minimal number of lookupswitch entries for rewriting to binary " \
3337           "switch")                                                         \




 170 define_pd_global(bool, CICompileOSR,                 false);
 171 define_pd_global(bool, UseTypeProfile,               false);
 172 define_pd_global(bool, UseOnStackReplacement,        false);
 173 define_pd_global(bool, InlineIntrinsics,             false);
 174 define_pd_global(bool, PreferInterpreterNativeStubs, true);
 175 define_pd_global(bool, ProfileInterpreter,           false);
 176 define_pd_global(bool, ProfileTraps,                 false);
 177 define_pd_global(bool, TieredCompilation,            false);
 178 
 179 define_pd_global(intx, CompileThreshold,             0);
 180 define_pd_global(intx, BackEdgeThreshold,            0);
 181 
 182 define_pd_global(intx, OnStackReplacePercentage,     0);
 183 define_pd_global(bool, ResizeTLAB,                   false);
 184 define_pd_global(intx, FreqInlineSize,               0);
 185 define_pd_global(intx, NewSizeThreadIncrease,        4*K);
 186 define_pd_global(intx, InlineClassNatives,           true);
 187 define_pd_global(intx, InlineUnsafeOps,              true);
 188 define_pd_global(intx, InitialCodeCacheSize,         160*K);
 189 define_pd_global(intx, ReservedCodeCacheSize,        32*M);
 190 define_pd_global(intx, NonProfiledCodeHeapSize,      14*M);
 191 define_pd_global(intx, ProfiledCodeHeapSize,         15*M );
 192 define_pd_global(intx, NonMethodCodeHeapSize,        3*M );
 193 
 194 define_pd_global(intx, CodeCacheExpansionSize,       32*K);
 195 define_pd_global(intx, CodeCacheMinBlockLength,      1);
 196 define_pd_global(intx, CodeCacheMinimumUseSpace,     200*K);
 197 define_pd_global(uintx,MetaspaceSize,    ScaleForWordSize(4*M));
 198 define_pd_global(bool, NeverActAsServerClassMachine, true);
 199 define_pd_global(uint64_t,MaxRAM,                    1ULL*G);
 200 #define CI_COMPILER_COUNT 0
 201 #else
 202 
 203 #ifdef COMPILER2
 204 #define CI_COMPILER_COUNT 2
 205 #else
 206 #define CI_COMPILER_COUNT 1
 207 #endif // COMPILER2
 208 
 209 #endif // no compilers
 210 
 211 // string type aliases used only in this file
 212 typedef const char* ccstr;
 213 typedef const char* ccstrlist;   // represents string arguments which accumulate


3302   /* code cache parameters */                                               \
3303   /* ppc64/tiered compilation has large code-entry alignment. */            \
3304   develop(uintx, CodeCacheSegmentSize, 64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),\
3305           "Code cache segment size (in bytes) - smallest unit of "          \
3306           "allocation")                                                     \
3307                                                                             \
3308   develop_pd(intx, CodeEntryAlignment,                                      \
3309           "Code entry alignment for generated code (in bytes)")             \
3310                                                                             \
3311   product_pd(intx, OptoLoopAlignment,                                       \
3312           "Align inner loops to zero relative to this modulus")             \
3313                                                                             \
3314   product_pd(uintx, InitialCodeCacheSize,                                   \
3315           "Initial code cache size (in bytes)")                             \
3316                                                                             \
3317   develop_pd(uintx, CodeCacheMinimumUseSpace,                               \
3318           "Minimum code cache size (in bytes) required to start VM.")       \
3319                                                                             \
3320   product_pd(uintx, ReservedCodeCacheSize,                                  \
3321           "Reserved code cache size (in bytes) - maximum code cache size")  \
3322                                                                             \
3323   product_pd(uintx, NonProfiledCodeHeapSize,                                \
3324           "Size of code heap with non-profiled methods (in bytes)")         \
3325                                                                             \
3326   product_pd(uintx, ProfiledCodeHeapSize,                                   \
3327           "Size of code heap with profiled methods (in bytes)")             \
3328                                                                             \
3329   product_pd(uintx, NonMethodCodeHeapSize,                                  \
3330           "Size of code heap with non-methods (in bytes)")                  \
3331                                                                             \
3332   product(uintx, CodeCacheMinimumFreeSpace, 500*K,                          \
3333           "When less than X space left, we stop compiling")                 \
3334                                                                             \
3335   product_pd(uintx, CodeCacheExpansionSize,                                 \
3336           "Code cache expansion size (in bytes)")                           \
3337                                                                             \
3338   develop_pd(uintx, CodeCacheMinBlockLength,                                \
3339           "Minimum number of segments in a code cache block")               \
3340                                                                             \
3341   notproduct(bool, ExitOnFullCodeCache, false,                              \
3342           "Exit the VM if we fill the code cache")                          \
3343                                                                             \
3344   product(bool, UseCodeCacheFlushing, true,                                 \
3345           "Remove cold/old nmethods from the code cache")                   \
3346                                                                             \
3347   /* interpreter debugging */                                               \
3348   develop(intx, BinarySwitchThreshold, 5,                                   \
3349           "Minimal number of lookupswitch entries for rewriting to binary " \
3350           "switch")                                                         \


src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File