< prev index next >

src/share/vm/runtime/globals.hpp

Print this page




3068           "2 = use TLAB watermark to gate allocation prefetch, "            \
3069           "3 = use BIS instruction on Sparc for allocation prefetch")       \
3070           range(0, 3)                                                       \
3071                                                                             \
3072   product(intx,  AllocatePrefetchDistance, -1,                              \
3073           "Distance to prefetch ahead of allocation pointer. "              \
3074           "-1: use system-specific value (automatically determined")        \
3075           constraint(AllocatePrefetchDistanceConstraintFunc, AfterMemoryInit)\
3076                                                                             \
3077   product(intx,  AllocatePrefetchLines, 3,                                  \
3078           "Number of lines to prefetch ahead of array allocation pointer")  \
3079           range(1, max_jint / 2)                                            \
3080                                                                             \
3081   product(intx,  AllocateInstancePrefetchLines, 1,                          \
3082           "Number of lines to prefetch ahead of instance allocation "       \
3083           "pointer")                                                        \
3084           range(1, max_jint / 2)                                            \
3085                                                                             \
3086   product(intx,  AllocatePrefetchStepSize, 16,                              \
3087           "Step size in bytes of sequential prefetch instructions")         \

3088           constraint(AllocatePrefetchStepSizeConstraintFunc,AfterMemoryInit)\
3089                                                                             \
3090   product(intx,  AllocatePrefetchInstr, 0,                                  \
3091           "Prefetch instruction to prefetch ahead of allocation pointer")   \
3092           constraint(AllocatePrefetchInstrConstraintFunc, AfterErgo)        \
3093                                                                             \
3094   /* deoptimization */                                                      \
3095   develop(bool, TraceDeoptimization, false,                                 \
3096           "Trace deoptimization")                                           \
3097                                                                             \
3098   develop(bool, PrintDeoptimizationDetails, false,                          \
3099           "Print more information about deoptimization")                    \
3100                                                                             \
3101   develop(bool, DebugDeoptimization, false,                                 \
3102           "Tracing various information while debugging deoptimization")     \
3103                                                                             \
3104   product(intx, SelfDestructTimer, 0,                                       \
3105           "Will cause VM to terminate after a given time (in minutes) "     \
3106           "(0 means off)")                                                  \
3107           range(0, max_intx)                                                \


3551           range(0, max_intx)                                                \
3552                                                                             \
3553   develop_pd(size_t, JVMInvokeMethodSlack,                                  \
3554           "Stack space (bytes) required for JVM_InvokeMethod to complete")  \
3555                                                                             \
3556   /* code cache parameters                                    */            \
3557   /* ppc64/tiered compilation has large code-entry alignment. */            \
3558   develop(uintx, CodeCacheSegmentSize,                                      \
3559           64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),                   \
3560           "Code cache segment size (in bytes) - smallest unit of "          \
3561           "allocation")                                                     \
3562           range(1, 1024)                                                    \
3563           constraint(CodeCacheSegmentSizeConstraintFunc, AfterErgo)         \
3564                                                                             \
3565   develop_pd(intx, CodeEntryAlignment,                                      \
3566           "Code entry alignment for generated code (in bytes)")             \
3567           constraint(CodeEntryAlignmentConstraintFunc, AfterErgo)           \
3568                                                                             \
3569   product_pd(intx, OptoLoopAlignment,                                       \
3570           "Align inner loops to zero relative to this modulus")             \

3571           constraint(OptoLoopAlignmentConstraintFunc, AfterErgo)            \
3572                                                                             \
3573   product_pd(uintx, InitialCodeCacheSize,                                   \
3574           "Initial code cache size (in bytes)")                             \
3575           range(0, max_uintx)                                               \
3576                                                                             \
3577   develop_pd(uintx, CodeCacheMinimumUseSpace,                               \
3578           "Minimum code cache size (in bytes) required to start VM.")       \
3579           range(0, max_uintx)                                               \
3580                                                                             \
3581   product(bool, SegmentedCodeCache, false,                                  \
3582           "Use a segmented code cache")                                     \
3583                                                                             \
3584   product_pd(uintx, ReservedCodeCacheSize,                                  \
3585           "Reserved code cache size (in bytes) - maximum code cache size")  \
3586           range(0, max_uintx)                                               \
3587                                                                             \
3588   product_pd(uintx, NonProfiledCodeHeapSize,                                \
3589           "Size of code heap with non-profiled methods (in bytes)")         \
3590           range(0, max_uintx)                                               \


3712           "    THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with     "\
3713           "    system threads. On Linux thread priorities are ignored      "\
3714           "    because the OS does not support static priority in          "\
3715           "    SCHED_OTHER scheduling class which is the only choice for   "\
3716           "    non-root, non-realtime applications.                        "\
3717           "1 : Aggressive.                                                 "\
3718           "    Java thread priorities map over to the entire range of      "\
3719           "    native thread priorities. Higher Java thread priorities map "\
3720           "    to higher native thread priorities. This policy should be   "\
3721           "    used with care, as sometimes it can cause performance       "\
3722           "    degradation in the application and/or the entire system. On "\
3723           "    Linux this policy requires root privilege.")                 \
3724           range(0, 1)                                                       \
3725                                                                             \
3726   product(bool, ThreadPriorityVerbose, false,                               \
3727           "Print priority changes")                                         \
3728                                                                             \
3729   product(intx, CompilerThreadPriority, -1,                                 \
3730           "The native priority at which compiler threads should run "       \
3731           "(-1 means no change)")                                           \

3732           constraint(CompilerThreadPriorityConstraintFunc, AfterErgo)       \
3733                                                                             \
3734   product(intx, VMThreadPriority, -1,                                       \
3735           "The native priority at which the VM thread should run "          \
3736           "(-1 means no change)")                                           \
3737           range(-1, 127)                                                    \
3738                                                                             \
3739   product(bool, CompilerThreadHintNoPreempt, true,                          \
3740           "(Solaris only) Give compiler threads an extra quanta")           \
3741                                                                             \
3742   product(bool, VMThreadHintNoPreempt, false,                               \
3743           "(Solaris only) Give VM thread an extra quanta")                  \
3744                                                                             \
3745   product(intx, JavaPriority1_To_OSPriority, -1,                            \
3746           "Map Java priorities to OS priorities")                           \
3747           range(-1, 127)                                                    \
3748                                                                             \
3749   product(intx, JavaPriority2_To_OSPriority, -1,                            \
3750           "Map Java priorities to OS priorities")                           \
3751           range(-1, 127)                                                    \




3068           "2 = use TLAB watermark to gate allocation prefetch, "            \
3069           "3 = use BIS instruction on Sparc for allocation prefetch")       \
3070           range(0, 3)                                                       \
3071                                                                             \
3072   product(intx,  AllocatePrefetchDistance, -1,                              \
3073           "Distance to prefetch ahead of allocation pointer. "              \
3074           "-1: use system-specific value (automatically determined")        \
3075           constraint(AllocatePrefetchDistanceConstraintFunc, AfterMemoryInit)\
3076                                                                             \
3077   product(intx,  AllocatePrefetchLines, 3,                                  \
3078           "Number of lines to prefetch ahead of array allocation pointer")  \
3079           range(1, max_jint / 2)                                            \
3080                                                                             \
3081   product(intx,  AllocateInstancePrefetchLines, 1,                          \
3082           "Number of lines to prefetch ahead of instance allocation "       \
3083           "pointer")                                                        \
3084           range(1, max_jint / 2)                                            \
3085                                                                             \
3086   product(intx,  AllocatePrefetchStepSize, 16,                              \
3087           "Step size in bytes of sequential prefetch instructions")         \
3088           range(1, max_jint)                                                \
3089           constraint(AllocatePrefetchStepSizeConstraintFunc,AfterMemoryInit)\
3090                                                                             \
3091   product(intx,  AllocatePrefetchInstr, 0,                                  \
3092           "Prefetch instruction to prefetch ahead of allocation pointer")   \
3093           constraint(AllocatePrefetchInstrConstraintFunc, AfterErgo)        \
3094                                                                             \
3095   /* deoptimization */                                                      \
3096   develop(bool, TraceDeoptimization, false,                                 \
3097           "Trace deoptimization")                                           \
3098                                                                             \
3099   develop(bool, PrintDeoptimizationDetails, false,                          \
3100           "Print more information about deoptimization")                    \
3101                                                                             \
3102   develop(bool, DebugDeoptimization, false,                                 \
3103           "Tracing various information while debugging deoptimization")     \
3104                                                                             \
3105   product(intx, SelfDestructTimer, 0,                                       \
3106           "Will cause VM to terminate after a given time (in minutes) "     \
3107           "(0 means off)")                                                  \
3108           range(0, max_intx)                                                \


3552           range(0, max_intx)                                                \
3553                                                                             \
3554   develop_pd(size_t, JVMInvokeMethodSlack,                                  \
3555           "Stack space (bytes) required for JVM_InvokeMethod to complete")  \
3556                                                                             \
3557   /* code cache parameters                                    */            \
3558   /* ppc64/tiered compilation has large code-entry alignment. */            \
3559   develop(uintx, CodeCacheSegmentSize,                                      \
3560           64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),                   \
3561           "Code cache segment size (in bytes) - smallest unit of "          \
3562           "allocation")                                                     \
3563           range(1, 1024)                                                    \
3564           constraint(CodeCacheSegmentSizeConstraintFunc, AfterErgo)         \
3565                                                                             \
3566   develop_pd(intx, CodeEntryAlignment,                                      \
3567           "Code entry alignment for generated code (in bytes)")             \
3568           constraint(CodeEntryAlignmentConstraintFunc, AfterErgo)           \
3569                                                                             \
3570   product_pd(intx, OptoLoopAlignment,                                       \
3571           "Align inner loops to zero relative to this modulus")             \
3572           range(1, 16)                                                      \
3573           constraint(OptoLoopAlignmentConstraintFunc, AfterErgo)            \
3574                                                                             \
3575   product_pd(uintx, InitialCodeCacheSize,                                   \
3576           "Initial code cache size (in bytes)")                             \
3577           range(0, max_uintx)                                               \
3578                                                                             \
3579   develop_pd(uintx, CodeCacheMinimumUseSpace,                               \
3580           "Minimum code cache size (in bytes) required to start VM.")       \
3581           range(0, max_uintx)                                               \
3582                                                                             \
3583   product(bool, SegmentedCodeCache, false,                                  \
3584           "Use a segmented code cache")                                     \
3585                                                                             \
3586   product_pd(uintx, ReservedCodeCacheSize,                                  \
3587           "Reserved code cache size (in bytes) - maximum code cache size")  \
3588           range(0, max_uintx)                                               \
3589                                                                             \
3590   product_pd(uintx, NonProfiledCodeHeapSize,                                \
3591           "Size of code heap with non-profiled methods (in bytes)")         \
3592           range(0, max_uintx)                                               \


3714           "    THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with     "\
3715           "    system threads. On Linux thread priorities are ignored      "\
3716           "    because the OS does not support static priority in          "\
3717           "    SCHED_OTHER scheduling class which is the only choice for   "\
3718           "    non-root, non-realtime applications.                        "\
3719           "1 : Aggressive.                                                 "\
3720           "    Java thread priorities map over to the entire range of      "\
3721           "    native thread priorities. Higher Java thread priorities map "\
3722           "    to higher native thread priorities. This policy should be   "\
3723           "    used with care, as sometimes it can cause performance       "\
3724           "    degradation in the application and/or the entire system. On "\
3725           "    Linux this policy requires root privilege.")                 \
3726           range(0, 1)                                                       \
3727                                                                             \
3728   product(bool, ThreadPriorityVerbose, false,                               \
3729           "Print priority changes")                                         \
3730                                                                             \
3731   product(intx, CompilerThreadPriority, -1,                                 \
3732           "The native priority at which compiler threads should run "       \
3733           "(-1 means no change)")                                           \
3734           range(min_jint, max_jint)                                         \
3735           constraint(CompilerThreadPriorityConstraintFunc, AfterErgo)       \
3736                                                                             \
3737   product(intx, VMThreadPriority, -1,                                       \
3738           "The native priority at which the VM thread should run "          \
3739           "(-1 means no change)")                                           \
3740           range(-1, 127)                                                    \
3741                                                                             \
3742   product(bool, CompilerThreadHintNoPreempt, true,                          \
3743           "(Solaris only) Give compiler threads an extra quanta")           \
3744                                                                             \
3745   product(bool, VMThreadHintNoPreempt, false,                               \
3746           "(Solaris only) Give VM thread an extra quanta")                  \
3747                                                                             \
3748   product(intx, JavaPriority1_To_OSPriority, -1,                            \
3749           "Map Java priorities to OS priorities")                           \
3750           range(-1, 127)                                                    \
3751                                                                             \
3752   product(intx, JavaPriority2_To_OSPriority, -1,                            \
3753           "Map Java priorities to OS priorities")                           \
3754           range(-1, 127)                                                    \


< prev index next >