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_MEMORY_GENCOLLECTEDHEAP_HPP
26 #define SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP
27
28 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
29 #include "memory/collectorPolicy.hpp"
30 #include "memory/generation.hpp"
31 #include "memory/sharedHeap.hpp"
32
33 class SubTasksDone;
34
35 // A "GenCollectedHeap" is a SharedHeap that uses generational
36 // collection. It is represented with a sequence of Generation's.
37 class GenCollectedHeap : public SharedHeap {
38 friend class GenCollectorPolicy;
39 friend class Generation;
40 friend class DefNewGeneration;
41 friend class TenuredGeneration;
42 friend class ConcurrentMarkSweepGeneration;
43 friend class CMSCollector;
44 friend class GenMarkSweep;
45 friend class VM_GenCollectForAllocation;
46 friend class VM_GenCollectFull;
47 friend class VM_GenCollectFullConcurrent;
48 friend class VM_GC_HeapInspection;
49 friend class VM_HeapDumper;
50 friend class HeapInspection;
51 friend class GCCauseSetter;
52 friend class VMStructs;
53 public:
54 enum SomeConstants {
55 max_gens = 10
56 };
57
58 friend class VM_PopulateDumpSharedSpace;
59
60 protected:
61 // Fields:
62 static GenCollectedHeap* _gch;
63
64 private:
65 int _n_gens;
66 Generation* _gens[max_gens];
67 GenerationSpec** _gen_specs;
68
69 // The generational collector policy.
70 GenCollectorPolicy* _gen_policy;
71
72 // Indicates that the most recent previous incremental collection failed.
73 // The flag is cleared when an action is taken that might clear the
74 // condition that caused that incremental collection to fail.
75 bool _incremental_collection_failed;
76
77 // In support of ExplicitGCInvokesConcurrent functionality
78 unsigned int _full_collections_completed;
79
80 // Data structure for claiming the (potentially) parallel tasks in
81 // (gen-specific) roots processing.
82 SubTasksDone* _gen_process_roots_tasks;
83 SubTasksDone* gen_process_roots_tasks() { return _gen_process_roots_tasks; }
84
85 // In block contents verification, the number of header words to skip
86 NOT_PRODUCT(static size_t _skip_header_HeapWords;)
87
88 protected:
89 // Helper functions for allocation
90 HeapWord* attempt_allocation(size_t size,
91 bool is_tlab,
92 bool first_only);
93
94 // Helper function for two callbacks below.
95 // Considers collection of the first max_level+1 generations.
96 void do_collection(bool full,
97 bool clear_all_soft_refs,
98 size_t size,
99 bool is_tlab,
100 int max_level);
101
102 // Callback from VM_GenCollectForAllocation operation.
103 // This function does everything necessary/possible to satisfy an
104 // allocation request that failed in the youngest generation that should
105 // have handled it (including collection, expansion, etc.)
106 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab);
107
108 // Callback from VM_GenCollectFull operation.
109 // Perform a full collection of the first max_level+1 generations.
110 virtual void do_full_collection(bool clear_all_soft_refs);
111 void do_full_collection(bool clear_all_soft_refs, int max_level);
112
113 // Does the "cause" of GC indicate that
114 // we absolutely __must__ clear soft refs?
115 bool must_clear_all_soft_refs();
116
117 public:
118 GenCollectedHeap(GenCollectorPolicy *policy);
119
120 GCStats* gc_stats(int level) const;
121
122 // Returns JNI_OK on success
123 virtual jint initialize();
124 char* allocate(size_t alignment,
125 size_t* _total_reserved, int* _n_covered_regions,
126 ReservedSpace* heap_rs);
127
128 // Does operations required after initialization has been done.
129 void post_initialize();
130
131 // Initialize ("weak") refs processing support
132 virtual void ref_processing_init();
133
134 virtual CollectedHeap::Name kind() const {
135 return CollectedHeap::GenCollectedHeap;
136 }
137
138 // The generational collector policy.
139 GenCollectorPolicy* gen_policy() const { return _gen_policy; }
140 virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) gen_policy(); }
141
142 // Adaptive size policy
143 virtual AdaptiveSizePolicy* size_policy() {
144 return gen_policy()->size_policy();
145 }
146
147 // Return the (conservative) maximum heap alignment
148 static size_t conservative_max_heap_alignment() {
149 return Generation::GenGrain;
150 }
151
152 size_t capacity() const;
153 size_t used() const;
154
155 // Save the "used_region" for generations level and lower.
156 void save_used_regions(int level);
157
158 size_t max_capacity() const;
159
289
290 // Ensure parsability: override
291 virtual void ensure_parsability(bool retire_tlabs);
292
293 // Time in ms since the longest time a collector ran in
294 // in any generation.
295 virtual jlong millis_since_last_gc();
296
297 // Total number of full collections completed.
298 unsigned int total_full_collections_completed() {
299 assert(_full_collections_completed <= _total_full_collections,
300 "Can't complete more collections than were started");
301 return _full_collections_completed;
302 }
303
304 // Update above counter, as appropriate, at the end of a stop-world GC cycle
305 unsigned int update_full_collections_completed();
306 // Update above counter, as appropriate, at the end of a concurrent GC cycle
307 unsigned int update_full_collections_completed(unsigned int count);
308
309 // Update "time of last gc" for all constituent generations
310 // to "now".
311 void update_time_of_last_gc(jlong now) {
312 for (int i = 0; i < _n_gens; i++) {
313 _gens[i]->update_time_of_last_gc(now);
314 }
315 }
316
317 // Update the gc statistics for each generation.
318 // "level" is the level of the latest collection.
319 void update_gc_stats(int current_level, bool full) {
320 for (int i = 0; i < _n_gens; i++) {
321 _gens[i]->update_gc_stats(current_level, full);
322 }
323 }
324
325 // Override.
326 bool no_gc_in_progress() { return !is_gc_active(); }
327
328 // Override.
329 void prepare_for_verify();
330
331 // Override.
332 void verify(bool silent, VerifyOption option);
333
334 // Override.
335 virtual void print_on(outputStream* st) const;
336 virtual void print_gc_threads_on(outputStream* st) const;
337 virtual void gc_threads_do(ThreadClosure* tc) const;
338 virtual void print_tracing_info() const;
339 virtual void print_on_error(outputStream* st) const;
340
341 // PrintGC, PrintGCDetails support
342 void print_heap_change(size_t prev_used) const;
347
348 class GenClosure : public StackObj {
349 public:
350 virtual void do_generation(Generation* gen) = 0;
351 };
352
353 // Apply "cl.do_generation" to all generations in the heap
354 // If "old_to_young" determines the order.
355 void generation_iterate(GenClosure* cl, bool old_to_young);
356
357 void space_iterate(SpaceClosure* cl);
358
359 // Return "true" if all generations have reached the
360 // maximal committed limit that they can reach, without a garbage
361 // collection.
362 virtual bool is_maximal_no_gc() const;
363
364 // Return the generation before "gen".
365 Generation* prev_gen(Generation* gen) const {
366 int l = gen->level();
367 guarantee(l > 0, "Out of bounds");
368 return _gens[l-1];
369 }
370
371 // Return the generation after "gen".
372 Generation* next_gen(Generation* gen) const {
373 int l = gen->level() + 1;
374 guarantee(l < _n_gens, "Out of bounds");
375 return _gens[l];
376 }
377
378 Generation* get_gen(int i) const {
379 guarantee(i >= 0 && i < _n_gens, "Out of bounds");
380 return _gens[i];
381 }
382
383 int n_gens() const {
384 assert(_n_gens == gen_policy()->number_of_generations(), "Sanity");
385 return _n_gens;
386 }
387
388 // Convenience function to be used in situations where the heap type can be
389 // asserted to be this type.
390 static GenCollectedHeap* heap();
391
392 void set_par_threads(uint t);
393
394 // Invoke the "do_oop" method of one of the closures "not_older_gens"
395 // or "older_gens" on root locations for the generation at
396 // "level". (The "older_gens" closure is used for scanning references
397 // from older generations; "not_older_gens" is used everywhere else.)
398 // If "younger_gens_as_roots" is false, younger generations are
399 // not scanned as roots; in this case, the caller must be arranging to
400 // scan the younger generations itself. (For example, a generation might
|
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_MEMORY_GENCOLLECTEDHEAP_HPP
26 #define SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP
27
28 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
29 #include "memory/collectorPolicy.hpp"
30 #include "memory/generation.hpp"
31 #include "memory/sharedHeap.hpp"
32
33 class SubTasksDone;
34
35 // A "GenCollectedHeap" is a SharedHeap that uses generational
36 // collection. It has two generations, young and old.
37 class GenCollectedHeap : public SharedHeap {
38 friend class GenCollectorPolicy;
39 friend class Generation;
40 friend class DefNewGeneration;
41 friend class TenuredGeneration;
42 friend class ConcurrentMarkSweepGeneration;
43 friend class CMSCollector;
44 friend class GenMarkSweep;
45 friend class VM_GenCollectForAllocation;
46 friend class VM_GenCollectFull;
47 friend class VM_GenCollectFullConcurrent;
48 friend class VM_GC_HeapInspection;
49 friend class VM_HeapDumper;
50 friend class HeapInspection;
51 friend class GCCauseSetter;
52 friend class VMStructs;
53 public:
54 enum SomeConstants {
55 max_gens = 10
56 };
57
58 friend class VM_PopulateDumpSharedSpace;
59
60 protected:
61 // Fields:
62 static GenCollectedHeap* _gch;
63
64 private:
65 int _n_gens;
66
67 Generation* _young_gen;
68 Generation* _old_gen;
69
70 GenerationSpec** _gen_specs;
71
72 // The generational collector policy.
73 GenCollectorPolicy* _gen_policy;
74
75 // Indicates that the most recent previous incremental collection failed.
76 // The flag is cleared when an action is taken that might clear the
77 // condition that caused that incremental collection to fail.
78 bool _incremental_collection_failed;
79
80 // In support of ExplicitGCInvokesConcurrent functionality
81 unsigned int _full_collections_completed;
82
83 // Data structure for claiming the (potentially) parallel tasks in
84 // (gen-specific) roots processing.
85 SubTasksDone* _gen_process_roots_tasks;
86 SubTasksDone* gen_process_roots_tasks() { return _gen_process_roots_tasks; }
87
88 void collect_generation(Generation* gen, bool full, size_t size, bool is_tlab,
89 bool run_verification, bool clear_soft_refs);
90
91 // In block contents verification, the number of header words to skip
92 NOT_PRODUCT(static size_t _skip_header_HeapWords;)
93
94 protected:
95 // Helper functions for allocation
96 HeapWord* attempt_allocation(size_t size,
97 bool is_tlab,
98 bool first_only);
99
100 // Helper function for two callbacks below.
101 // Considers collection of the first max_level+1 generations.
102 void do_collection(bool full,
103 bool clear_all_soft_refs,
104 size_t size,
105 bool is_tlab,
106 int max_level);
107
108 // Callback from VM_GenCollectForAllocation operation.
109 // This function does everything necessary/possible to satisfy an
110 // allocation request that failed in the youngest generation that should
111 // have handled it (including collection, expansion, etc.)
112 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab);
113
114 // Callback from VM_GenCollectFull operation.
115 // Perform a full collection of the first max_level+1 generations.
116 virtual void do_full_collection(bool clear_all_soft_refs);
117 void do_full_collection(bool clear_all_soft_refs, int max_level);
118
119 // Does the "cause" of GC indicate that
120 // we absolutely __must__ clear soft refs?
121 bool must_clear_all_soft_refs();
122
123 public:
124 GenCollectedHeap(GenCollectorPolicy *policy);
125
126 GCStats* gc_stats(int level) const;
127
128 // Returns JNI_OK on success
129 virtual jint initialize();
130
131 char* allocate(size_t alignment,
132 size_t* _total_reserved, int* _n_covered_regions,
133 ReservedSpace* heap_rs);
134
135 // Does operations required after initialization has been done.
136 void post_initialize();
137
138 // Initialize ("weak") refs processing support
139 virtual void ref_processing_init();
140
141 virtual CollectedHeap::Name kind() const {
142 return CollectedHeap::GenCollectedHeap;
143 }
144
145 Generation* young_gen() { return _young_gen; }
146 Generation* old_gen() { return _old_gen; }
147
148 // The generational collector policy.
149 GenCollectorPolicy* gen_policy() const { return _gen_policy; }
150
151 virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) gen_policy(); }
152
153 // Adaptive size policy
154 virtual AdaptiveSizePolicy* size_policy() {
155 return gen_policy()->size_policy();
156 }
157
158 // Return the (conservative) maximum heap alignment
159 static size_t conservative_max_heap_alignment() {
160 return Generation::GenGrain;
161 }
162
163 size_t capacity() const;
164 size_t used() const;
165
166 // Save the "used_region" for generations level and lower.
167 void save_used_regions(int level);
168
169 size_t max_capacity() const;
170
300
301 // Ensure parsability: override
302 virtual void ensure_parsability(bool retire_tlabs);
303
304 // Time in ms since the longest time a collector ran in
305 // in any generation.
306 virtual jlong millis_since_last_gc();
307
308 // Total number of full collections completed.
309 unsigned int total_full_collections_completed() {
310 assert(_full_collections_completed <= _total_full_collections,
311 "Can't complete more collections than were started");
312 return _full_collections_completed;
313 }
314
315 // Update above counter, as appropriate, at the end of a stop-world GC cycle
316 unsigned int update_full_collections_completed();
317 // Update above counter, as appropriate, at the end of a concurrent GC cycle
318 unsigned int update_full_collections_completed(unsigned int count);
319
320 // Update "time of last gc" for all generations to "now".
321 void update_time_of_last_gc(jlong now) {
322 _young_gen->update_time_of_last_gc(now);
323 _old_gen->update_time_of_last_gc(now);
324 }
325
326 // Update the gc statistics for each generation.
327 // "level" is the level of the latest collection.
328 void update_gc_stats(int current_level, bool full) {
329 _young_gen->update_gc_stats(current_level, full);
330 _old_gen->update_gc_stats(current_level, full);
331 }
332
333 // Override.
334 bool no_gc_in_progress() { return !is_gc_active(); }
335
336 // Override.
337 void prepare_for_verify();
338
339 // Override.
340 void verify(bool silent, VerifyOption option);
341
342 // Override.
343 virtual void print_on(outputStream* st) const;
344 virtual void print_gc_threads_on(outputStream* st) const;
345 virtual void gc_threads_do(ThreadClosure* tc) const;
346 virtual void print_tracing_info() const;
347 virtual void print_on_error(outputStream* st) const;
348
349 // PrintGC, PrintGCDetails support
350 void print_heap_change(size_t prev_used) const;
355
356 class GenClosure : public StackObj {
357 public:
358 virtual void do_generation(Generation* gen) = 0;
359 };
360
361 // Apply "cl.do_generation" to all generations in the heap
362 // If "old_to_young" determines the order.
363 void generation_iterate(GenClosure* cl, bool old_to_young);
364
365 void space_iterate(SpaceClosure* cl);
366
367 // Return "true" if all generations have reached the
368 // maximal committed limit that they can reach, without a garbage
369 // collection.
370 virtual bool is_maximal_no_gc() const;
371
372 // Return the generation before "gen".
373 Generation* prev_gen(Generation* gen) const {
374 int l = gen->level();
375 guarantee(l == 1, "Out of bounds");
376 return _young_gen;
377 }
378
379 // Return the generation after "gen".
380 Generation* next_gen(Generation* gen) const {
381 int l = gen->level() + 1;
382 guarantee(l == 1, "Out of bounds");
383 return _old_gen;
384 }
385
386 Generation* get_gen(int i) const {
387 guarantee(i >= 0 && i < _n_gens, "Out of bounds");
388 if (i == 0) return _young_gen;
389 else return _old_gen;
390 }
391
392 int n_gens() const {
393 assert(_n_gens == gen_policy()->number_of_generations(), "Sanity");
394 return _n_gens;
395 }
396
397 // Convenience function to be used in situations where the heap type can be
398 // asserted to be this type.
399 static GenCollectedHeap* heap();
400
401 void set_par_threads(uint t);
402
403 // Invoke the "do_oop" method of one of the closures "not_older_gens"
404 // or "older_gens" on root locations for the generation at
405 // "level". (The "older_gens" closure is used for scanning references
406 // from older generations; "not_older_gens" is used everywhere else.)
407 // If "younger_gens_as_roots" is false, younger generations are
408 // not scanned as roots; in this case, the caller must be arranging to
409 // scan the younger generations itself. (For example, a generation might
|