< prev index next >

src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp

8221260: Initialize more class members on construction, remove some unused ones
Reviewed-by:

75   GCMemoryManager* _old_manager;                                                                                           
76 
77   MemoryPool* _eden_pool;                                                                                                  
78   MemoryPool* _survivor_pool;                                                                                              
79   MemoryPool* _old_pool;                                                                                                   
80 
81   virtual void initialize_serviceability();                                                                                
82 
83   void trace_heap(GCWhen::Type when, const GCTracer* tracer);                                                              
84 
85  protected:                                                                                                                
86   static inline size_t total_invocations();                                                                                
87   HeapWord* allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size);                                
88 
89   inline bool should_alloc_in_eden(size_t size) const;                                                                     
90   inline void death_march_check(HeapWord* const result, size_t size);                                                      
91   HeapWord* mem_allocate_old_gen(size_t size);                                                                             
92 
93  public:                                                                                                                   
94   ParallelScavengeHeap(GenerationSizer* policy) :                                                                          
95     CollectedHeap(), _collector_policy(policy), _death_march_count(0) { }                                                  
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
96 
97   // For use by VM operations                                                                                              
98   enum CollectionType {                                                                                                    
99     Scavenge,                                                                                                              
100     MarkSweep                                                                                                              
101   };                                                                                                                       
102 
103   virtual Name kind() const {                                                                                              
104     return CollectedHeap::Parallel;                                                                                        
105   }                                                                                                                        
106 
107   virtual const char* name() const {                                                                                       
108     return "Parallel";                                                                                                     
109   }                                                                                                                        
110 
111   virtual CollectorPolicy* collector_policy() const { return _collector_policy; }                                          
112 
113   virtual GenerationSizer* ps_collector_policy() const { return _collector_policy; }                                       
114 

75   GCMemoryManager* _old_manager;
76 
77   MemoryPool* _eden_pool;
78   MemoryPool* _survivor_pool;
79   MemoryPool* _old_pool;
80 
81   virtual void initialize_serviceability();
82 
83   void trace_heap(GCWhen::Type when, const GCTracer* tracer);
84 
85  protected:
86   static inline size_t total_invocations();
87   HeapWord* allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size);
88 
89   inline bool should_alloc_in_eden(size_t size) const;
90   inline void death_march_check(HeapWord* const result, size_t size);
91   HeapWord* mem_allocate_old_gen(size_t size);
92 
93  public:
94   ParallelScavengeHeap(GenerationSizer* policy) :
95     CollectedHeap(),
96     _collector_policy(policy),
97     _gens(NULL),
98     _death_march_count(0),
99     _young_manager(NULL),
100     _old_manager(NULL),
101     _eden_pool(NULL),
102     _survivor_pool(NULL),
103     _old_pool(NULL) { }
104 
105   // For use by VM operations
106   enum CollectionType {
107     Scavenge,
108     MarkSweep
109   };
110 
111   virtual Name kind() const {
112     return CollectedHeap::Parallel;
113   }
114 
115   virtual const char* name() const {
116     return "Parallel";
117   }
118 
119   virtual CollectorPolicy* collector_policy() const { return _collector_policy; }
120 
121   virtual GenerationSizer* ps_collector_policy() const { return _collector_policy; }
122 
< prev index next >