23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/gcConfig.hpp"
27 #include "runtime/globals_extension.hpp"
28 #include "runtime/java.hpp"
29 #include "runtime/os.hpp"
30 #include "utilities/macros.hpp"
31 #if INCLUDE_CMSGC
32 #include "gc/cms/cmsArguments.hpp"
33 #endif
34 #if INCLUDE_G1GC
35 #include "gc/g1/g1Arguments.hpp"
36 #endif
37 #if INCLUDE_PARALLELGC
38 #include "gc/parallel/parallelArguments.hpp"
39 #endif
40 #if INCLUDE_SERIALGC
41 #include "gc/serial/serialArguments.hpp"
42 #endif
43
44 struct SupportedGC {
45 bool& _flag;
46 CollectedHeap::Name _name;
47 GCArguments& _arguments;
48 const char* _hs_err_name;
49
50 SupportedGC(bool& flag, CollectedHeap::Name name, GCArguments& arguments, const char* hs_err_name) :
51 _flag(flag), _name(name), _arguments(arguments), _hs_err_name(hs_err_name) {}
52 };
53
54 CMSGC_ONLY(static CMSArguments cmsArguments;)
55 G1GC_ONLY(static G1Arguments g1Arguments;)
56 PARALLELGC_ONLY(static ParallelArguments parallelArguments;)
57 SERIALGC_ONLY(static SerialArguments serialArguments;)
58
59 // Table of supported GCs, for translating between command
60 // line flag, CollectedHeap::Name and GCArguments instance.
61 static const SupportedGC SupportedGCs[] = {
62 CMSGC_ONLY_ARG(SupportedGC(UseConcMarkSweepGC, CollectedHeap::CMS, cmsArguments, "concurrent mark sweep gc"))
63 G1GC_ONLY_ARG(SupportedGC(UseG1GC, CollectedHeap::G1, g1Arguments, "g1 gc"))
64 PARALLELGC_ONLY_ARG(SupportedGC(UseParallelGC, CollectedHeap::Parallel, parallelArguments, "parallel gc"))
65 PARALLELGC_ONLY_ARG(SupportedGC(UseParallelOldGC, CollectedHeap::Parallel, parallelArguments, "parallel gc"))
66 SERIALGC_ONLY_ARG(SupportedGC(UseSerialGC, CollectedHeap::Serial, serialArguments, "serial gc"))
67 };
68
69 #define FOR_EACH_SUPPORTED_GC(var) \
70 for (const SupportedGC* var = &SupportedGCs[0]; var < &SupportedGCs[ARRAY_SIZE(SupportedGCs)]; var++)
71
72 GCArguments* GCConfig::_arguments = NULL;
73 bool GCConfig::_gc_selected_ergonomically = false;
74
75 void GCConfig::select_gc_ergonomically() {
76 if (os::is_server_class_machine()) {
77 #if INCLUDE_G1GC
78 FLAG_SET_ERGO_IF_DEFAULT(bool, UseG1GC, true);
79 #elif INCLUDE_PARALLELGC
80 FLAG_SET_ERGO_IF_DEFAULT(bool, UseParallelGC, true);
81 #elif INCLUDE_SERIALGC
82 FLAG_SET_ERGO_IF_DEFAULT(bool, UseSerialGC, true);
83 #endif
84 } else {
85 #if INCLUDE_SERIALGC
86 FLAG_SET_ERGO_IF_DEFAULT(bool, UseSerialGC, true);
87 #endif
88 }
89
90 NOT_CMSGC( UNSUPPORTED_OPTION(UseConcMarkSweepGC));
91 NOT_G1GC( UNSUPPORTED_OPTION(UseG1GC);)
92 NOT_PARALLELGC(UNSUPPORTED_OPTION(UseParallelGC);)
93 NOT_PARALLELGC(UNSUPPORTED_OPTION(UseParallelOldGC));
94 NOT_SERIALGC( UNSUPPORTED_OPTION(UseSerialGC);)
95 }
96
97 bool GCConfig::is_no_gc_selected() {
98 FOR_EACH_SUPPORTED_GC(gc) {
99 if (gc->_flag) {
100 return false;
101 }
102 }
103
104 return true;
105 }
106
107 bool GCConfig::is_exactly_one_gc_selected() {
108 CollectedHeap::Name selected = CollectedHeap::None;
109
110 FOR_EACH_SUPPORTED_GC(gc) {
111 if (gc->_flag) {
112 if (gc->_name == selected || selected == CollectedHeap::None) {
113 // Selected
114 selected = gc->_name;
|
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/gcConfig.hpp"
27 #include "runtime/globals_extension.hpp"
28 #include "runtime/java.hpp"
29 #include "runtime/os.hpp"
30 #include "utilities/macros.hpp"
31 #if INCLUDE_CMSGC
32 #include "gc/cms/cmsArguments.hpp"
33 #endif
34 #if INCLUDE_G1GC
35 #include "gc/g1/g1Arguments.hpp"
36 #endif
37 #if INCLUDE_PARALLELGC
38 #include "gc/parallel/parallelArguments.hpp"
39 #endif
40 #if INCLUDE_SERIALGC
41 #include "gc/serial/serialArguments.hpp"
42 #endif
43 #if INCLUDE_EPSILONGC
44 #include "gc/epsilon/epsilonArguments.hpp"
45 #endif
46
47 struct SupportedGC {
48 bool& _flag;
49 CollectedHeap::Name _name;
50 GCArguments& _arguments;
51 const char* _hs_err_name;
52
53 SupportedGC(bool& flag, CollectedHeap::Name name, GCArguments& arguments, const char* hs_err_name) :
54 _flag(flag), _name(name), _arguments(arguments), _hs_err_name(hs_err_name) {}
55 };
56
57 CMSGC_ONLY(static CMSArguments cmsArguments;)
58 G1GC_ONLY(static G1Arguments g1Arguments;)
59 PARALLELGC_ONLY(static ParallelArguments parallelArguments;)
60 SERIALGC_ONLY(static SerialArguments serialArguments;)
61 EPSILONGC_ONLY(static EpsilonArguments epsilonArguments;)
62
63 // Table of supported GCs, for translating between command
64 // line flag, CollectedHeap::Name and GCArguments instance.
65 static const SupportedGC SupportedGCs[] = {
66 CMSGC_ONLY_ARG(SupportedGC(UseConcMarkSweepGC, CollectedHeap::CMS, cmsArguments, "concurrent mark sweep gc"))
67 G1GC_ONLY_ARG(SupportedGC(UseG1GC, CollectedHeap::G1, g1Arguments, "g1 gc"))
68 PARALLELGC_ONLY_ARG(SupportedGC(UseParallelGC, CollectedHeap::Parallel, parallelArguments, "parallel gc"))
69 PARALLELGC_ONLY_ARG(SupportedGC(UseParallelOldGC, CollectedHeap::Parallel, parallelArguments, "parallel gc"))
70 SERIALGC_ONLY_ARG(SupportedGC(UseSerialGC, CollectedHeap::Serial, serialArguments, "serial gc"))
71 EPSILONGC_ONLY_ARG(SupportedGC(UseEpsilonGC, CollectedHeap::Epsilon, epsilonArguments, "epsilon gc"))
72 };
73
74 #define FOR_EACH_SUPPORTED_GC(var) \
75 for (const SupportedGC* var = &SupportedGCs[0]; var < &SupportedGCs[ARRAY_SIZE(SupportedGCs)]; var++)
76
77 GCArguments* GCConfig::_arguments = NULL;
78 bool GCConfig::_gc_selected_ergonomically = false;
79
80 void GCConfig::select_gc_ergonomically() {
81 if (os::is_server_class_machine()) {
82 #if INCLUDE_G1GC
83 FLAG_SET_ERGO_IF_DEFAULT(bool, UseG1GC, true);
84 #elif INCLUDE_PARALLELGC
85 FLAG_SET_ERGO_IF_DEFAULT(bool, UseParallelGC, true);
86 #elif INCLUDE_SERIALGC
87 FLAG_SET_ERGO_IF_DEFAULT(bool, UseSerialGC, true);
88 #endif
89 } else {
90 #if INCLUDE_SERIALGC
91 FLAG_SET_ERGO_IF_DEFAULT(bool, UseSerialGC, true);
92 #endif
93 }
94
95 NOT_CMSGC( UNSUPPORTED_OPTION(UseConcMarkSweepGC));
96 NOT_G1GC( UNSUPPORTED_OPTION(UseG1GC);)
97 NOT_PARALLELGC(UNSUPPORTED_OPTION(UseParallelGC);)
98 NOT_PARALLELGC(UNSUPPORTED_OPTION(UseParallelOldGC));
99 NOT_SERIALGC( UNSUPPORTED_OPTION(UseSerialGC);)
100 NOT_EPSILONGC( UNSUPPORTED_OPTION(UseEpsilonGC);)
101 }
102
103 bool GCConfig::is_no_gc_selected() {
104 FOR_EACH_SUPPORTED_GC(gc) {
105 if (gc->_flag) {
106 return false;
107 }
108 }
109
110 return true;
111 }
112
113 bool GCConfig::is_exactly_one_gc_selected() {
114 CollectedHeap::Name selected = CollectedHeap::None;
115
116 FOR_EACH_SUPPORTED_GC(gc) {
117 if (gc->_flag) {
118 if (gc->_name == selected || selected == CollectedHeap::None) {
119 // Selected
120 selected = gc->_name;
|