< prev index next >

src/hotspot/share/gc/z/zArguments.cpp

Concurrent class unloading

65     vm_exit_during_initialization("The flag -XX:+UseZGC can not be combined with -XX:ConcGCThreads=0");                              
66   }                                                                                                                                  
67 
68 #ifdef COMPILER2                                                                                                                     
69   // Enable loop strip mining by default                                                                                             
70   if (FLAG_IS_DEFAULT(UseCountedLoopSafepoints)) {                                                                                   
71     FLAG_SET_DEFAULT(UseCountedLoopSafepoints, true);                                                                                
72     if (FLAG_IS_DEFAULT(LoopStripMiningIter)) {                                                                                      
73       FLAG_SET_DEFAULT(LoopStripMiningIter, 1000);                                                                                   
74     }                                                                                                                                
75   }                                                                                                                                  
76 #endif                                                                                                                               
77 
78   // To avoid asserts in set_active_workers()                                                                                        
79   FLAG_SET_DEFAULT(UseDynamicNumberOfGCThreads, true);                                                                               
80 
81   // CompressedOops/UseCompressedClassPointers not supported                                                                         
82   FLAG_SET_DEFAULT(UseCompressedOops, false);                                                                                        
83   FLAG_SET_DEFAULT(UseCompressedClassPointers, false);                                                                               
84 
85   // ClassUnloading not (yet) supported                                                                                              
86   FLAG_SET_DEFAULT(ClassUnloading, false);                                                                                           
87   FLAG_SET_DEFAULT(ClassUnloadingWithConcurrentMark, false);                                                                         
88                                                                                                                                      
89   // Verification before startup and after exit not (yet) supported                                                                  
90   FLAG_SET_DEFAULT(VerifyDuringStartup, false);                                                                                      
91   FLAG_SET_DEFAULT(VerifyBeforeExit, false);                                                                                         
92 
93   // Verification before heap iteration not (yet) supported, for the                                                                 
94   // same reason we need fixup_partial_loads                                                                                         
95   FLAG_SET_DEFAULT(VerifyBeforeIteration, false);                                                                                    
96 
97   // Verification of stacks not (yet) supported, for the same reason                                                                 
98   // we need fixup_partial_loads                                                                                                     
99   DEBUG_ONLY(FLAG_SET_DEFAULT(VerifyStack, false));                                                                                  
100 }                                                                                                                                    
101 
102 CollectedHeap* ZArguments::create_heap() {                                                                                           
103   return create_heap_with_policy<ZCollectedHeap, ZCollectorPolicy>();                                                                
104 }                                                                                                                                    

65     vm_exit_during_initialization("The flag -XX:+UseZGC can not be combined with -XX:ConcGCThreads=0");
66   }
67 
68 #ifdef COMPILER2
69   // Enable loop strip mining by default
70   if (FLAG_IS_DEFAULT(UseCountedLoopSafepoints)) {
71     FLAG_SET_DEFAULT(UseCountedLoopSafepoints, true);
72     if (FLAG_IS_DEFAULT(LoopStripMiningIter)) {
73       FLAG_SET_DEFAULT(LoopStripMiningIter, 1000);
74     }
75   }
76 #endif
77 
78   // To avoid asserts in set_active_workers()
79   FLAG_SET_DEFAULT(UseDynamicNumberOfGCThreads, true);
80 
81   // CompressedOops/UseCompressedClassPointers not supported
82   FLAG_SET_DEFAULT(UseCompressedOops, false);
83   FLAG_SET_DEFAULT(UseCompressedClassPointers, false);
84 




85   // Verification before startup and after exit not (yet) supported
86   FLAG_SET_DEFAULT(VerifyDuringStartup, false);
87   FLAG_SET_DEFAULT(VerifyBeforeExit, false);
88 
89   // Verification before heap iteration not (yet) supported, for the
90   // same reason we need fixup_partial_loads
91   FLAG_SET_DEFAULT(VerifyBeforeIteration, false);
92 
93   // Verification of stacks not (yet) supported, for the same reason
94   // we need fixup_partial_loads
95   DEBUG_ONLY(FLAG_SET_DEFAULT(VerifyStack, false));
96 }
97 
98 CollectedHeap* ZArguments::create_heap() {
99   return create_heap_with_policy<ZCollectedHeap, ZCollectorPolicy>();
100 }
< prev index next >