src/share/vm/gc/g1/g1_globals.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File 8112746_open Sdiff src/share/vm/gc/g1

src/share/vm/gc/g1/g1_globals.hpp

Print this page




   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_G1_G1_GLOBALS_HPP
  26 #define SHARE_VM_GC_G1_G1_GLOBALS_HPP
  27 

  28 #include "runtime/globals.hpp"

  29 //
  30 // Defines all globals flags used by the garbage-first compiler.
  31 //
  32 
  33 #define G1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, range, constraint) \
  34                                                                             \
  35   product(uintx, G1ConfidencePercent, 50,                                   \
  36           "Confidence level for MMU/pause predictions")                     \
  37           range(0, 100)                                                     \
  38                                                                             \
  39   develop(intx, G1MarkingOverheadPercent, 0,                                \
  40           "Overhead of concurrent marking")                                 \
  41           range(0, 100)                                                     \
  42                                                                             \
  43   develop(intx, G1MarkingVerboseLevel, 0,                                   \
  44           "Level (0-4) of verboseness of the marking code")                 \
  45           range(0, 4)                                                       \
  46                                                                             \
  47   develop(bool, G1TraceMarkStackOverflow, false,                            \
  48           "If true, extra debugging code for CM restart for ovflw.")        \


  54           "Summarize concurrent mark info")                                 \
  55                                                                             \
  56   diagnostic(bool, G1SummarizeRSetStats, false,                             \
  57           "Summarize remembered set processing info")                       \
  58                                                                             \
  59   diagnostic(intx, G1SummarizeRSetStatsPeriod, 0,                           \
  60           "The period (in number of GCs) at which we will generate "        \
  61           "update buffer processing info "                                  \
  62           "(0 means do not periodically generate this info); "              \
  63           "it also requires -XX:+G1SummarizeRSetStats")                     \
  64                                                                             \
  65   diagnostic(bool, G1TraceConcRefinement, false,                            \
  66           "Trace G1 concurrent refinement")                                 \
  67                                                                             \
  68   experimental(bool, G1TraceStringSymbolTableScrubbing, false,              \
  69           "Trace information string and symbol table scrubbing.")           \
  70                                                                             \
  71   product(double, G1ConcMarkStepDurationMillis, 10.0,                       \
  72           "Target duration of individual concurrent marking steps "         \
  73           "in milliseconds.")                                               \
  74           range(1.0, (double)max_uintx)                                     \
  75                                                                             \
  76   product(intx, G1RefProcDrainInterval, 10,                                 \
  77           "The number of discovered reference objects to process before "   \
  78           "draining concurrent marking work queues.")                       \
  79           range(1, max_intx)                                                \
  80                                                                             \
  81   experimental(bool, G1UseConcMarkReferenceProcessing, true,                \
  82           "If true, enable reference discovery during concurrent "          \
  83           "marking and reference processing at the end of remark.")         \
  84                                                                             \
  85   product(size_t, G1SATBBufferSize, 1*K,                                    \
  86           "Number of entries in an SATB log buffer.")                       \
  87                                                                             \
  88   develop(intx, G1SATBProcessCompletedThreshold, 20,                        \
  89           "Number of completed buffers that triggers log processing.")      \
  90                                                                             \
  91   product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60,                \
  92           "Before enqueueing them, each mutator thread tries to do some "   \
  93           "filtering on the SATB buffers it generates. If post-filtering "  \
  94           "the percentage of retained entries is over this threshold "      \




   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_G1_G1_GLOBALS_HPP
  26 #define SHARE_VM_GC_G1_G1_GLOBALS_HPP
  27 
  28 #include <float.h> // for DBL_MAX
  29 #include "runtime/globals.hpp"
  30 
  31 //
  32 // Defines all globals flags used by the garbage-first compiler.
  33 //
  34 
  35 #define G1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, range, constraint) \
  36                                                                             \
  37   product(uintx, G1ConfidencePercent, 50,                                   \
  38           "Confidence level for MMU/pause predictions")                     \
  39           range(0, 100)                                                     \
  40                                                                             \
  41   develop(intx, G1MarkingOverheadPercent, 0,                                \
  42           "Overhead of concurrent marking")                                 \
  43           range(0, 100)                                                     \
  44                                                                             \
  45   develop(intx, G1MarkingVerboseLevel, 0,                                   \
  46           "Level (0-4) of verboseness of the marking code")                 \
  47           range(0, 4)                                                       \
  48                                                                             \
  49   develop(bool, G1TraceMarkStackOverflow, false,                            \
  50           "If true, extra debugging code for CM restart for ovflw.")        \


  56           "Summarize concurrent mark info")                                 \
  57                                                                             \
  58   diagnostic(bool, G1SummarizeRSetStats, false,                             \
  59           "Summarize remembered set processing info")                       \
  60                                                                             \
  61   diagnostic(intx, G1SummarizeRSetStatsPeriod, 0,                           \
  62           "The period (in number of GCs) at which we will generate "        \
  63           "update buffer processing info "                                  \
  64           "(0 means do not periodically generate this info); "              \
  65           "it also requires -XX:+G1SummarizeRSetStats")                     \
  66                                                                             \
  67   diagnostic(bool, G1TraceConcRefinement, false,                            \
  68           "Trace G1 concurrent refinement")                                 \
  69                                                                             \
  70   experimental(bool, G1TraceStringSymbolTableScrubbing, false,              \
  71           "Trace information string and symbol table scrubbing.")           \
  72                                                                             \
  73   product(double, G1ConcMarkStepDurationMillis, 10.0,                       \
  74           "Target duration of individual concurrent marking steps "         \
  75           "in milliseconds.")                                               \
  76           range(1.0, DBL_MAX)                                               \
  77                                                                             \
  78   product(intx, G1RefProcDrainInterval, 10,                                 \
  79           "The number of discovered reference objects to process before "   \
  80           "draining concurrent marking work queues.")                       \
  81           range(1, max_intx)                                                \
  82                                                                             \
  83   experimental(bool, G1UseConcMarkReferenceProcessing, true,                \
  84           "If true, enable reference discovery during concurrent "          \
  85           "marking and reference processing at the end of remark.")         \
  86                                                                             \
  87   product(size_t, G1SATBBufferSize, 1*K,                                    \
  88           "Number of entries in an SATB log buffer.")                       \
  89                                                                             \
  90   develop(intx, G1SATBProcessCompletedThreshold, 20,                        \
  91           "Number of completed buffers that triggers log processing.")      \
  92                                                                             \
  93   product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60,                \
  94           "Before enqueueing them, each mutator thread tries to do some "   \
  95           "filtering on the SATB buffers it generates. If post-filtering "  \
  96           "the percentage of retained entries is over this threshold "      \


src/share/vm/gc/g1/g1_globals.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File