20 * questions.
21 *
22 */
23
24 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHHEAP_HPP
25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHHEAP_HPP
26
27 #include "gc/shared/cmBitMap.hpp"
28
29 class ConcurrentGCTimer;
30
31 class ShenandoahCollectorPolicy;
32 class ShenandoahHeapRegion;
33 class ShenandoahHeapRegionClosure;
34 class ShenandoahHeapRegionSet;
35 class ShenandoahCollectionSet;
36 class ShenandoahFreeSet;
37 class ShenandoahConcurrentMark;
38 class ShenandoahConcurrentThread;
39 class ShenandoahMonitoringSupport;
40 class ShenandoahJNICritical;
41
42 class ShenandoahAlwaysTrueClosure : public BoolObjectClosure {
43 public:
44 bool do_object_b(oop p) { return true; }
45 };
46
47
48 class ShenandoahIsAliveClosure: public BoolObjectClosure {
49 private:
50 ShenandoahHeap* _heap;
51 public:
52 ShenandoahIsAliveClosure();
53 void init(ShenandoahHeap* heap);
54 bool do_object_b(oop obj);
55 };
56
57 class ShenandoahForwardedIsAliveClosure: public BoolObjectClosure {
58 private:
59 ShenandoahHeap* _heap;
60 public:
110 WorkGang* _conc_workers;
111 WorkGang* _workers;
112
113
114 volatile size_t _used;
115
116 CMBitMap _mark_bit_map0;
117 CMBitMap _mark_bit_map1;
118 CMBitMap* _prev_mark_bit_map;
119 CMBitMap* _next_mark_bit_map;
120
121 bool* _in_cset_fast_test;
122 bool* _in_cset_fast_test_base;
123 uint _in_cset_fast_test_length;
124
125 HeapWord** _top_at_mark_starts;
126 HeapWord** _top_at_mark_starts_base;
127
128 bool _cancelled_concgc;
129
130 ShenandoahJNICritical* _jni_critical;
131
132 jbyte _growing_heap;
133
134 size_t _bytes_allocated_since_cm;
135 size_t _bytes_allocated_during_cm;
136 size_t _bytes_allocated_during_cm_start;
137 size_t _max_allocated_gc;
138 size_t _allocated_last_gc;
139 size_t _used_start_gc;
140
141 unsigned int _concurrent_mark_in_progress;
142
143 bool _full_gc_in_progress;
144
145 unsigned int _evacuation_in_progress;
146 bool _need_update_refs;
147 bool _need_reset_bitmaps;
148
149 ReferenceProcessor* _ref_processor;
150
151 ShenandoahForwardedIsAliveClosure isAlive;
198 void object_iterate(ObjectClosure* cl) /* override */;
199 void safe_object_iterate(ObjectClosure* cl) /* override */;
200 size_t unsafe_max_tlab_alloc(Thread *thread) const /* override */;
201 size_t max_tlab_size() const /* override */;
202 void resize_all_tlabs() /* override */;
203 void accumulate_statistics_all_gclabs() /* override */;
204 HeapWord* tlab_post_allocation_setup(HeapWord* obj) /* override */;
205 uint oop_extra_words() /* override */;
206 size_t tlab_used(Thread* ignored) const /* override */;
207 void stop() /* override */;
208
209 bool needs_reference_pending_list_locker_thread() const /* override */;
210
211 #ifndef CC_INTERP
212 void compile_prepare_oop(MacroAssembler* masm, Register obj) /* override */;
213 #endif
214
215 void register_nmethod(nmethod* nm);
216 void unregister_nmethod(nmethod* nm);
217
218
219 static ShenandoahHeap* heap();
220 static ShenandoahHeap* heap_no_check();
221 static size_t conservative_max_heap_alignment();
222 static address in_cset_fast_test_addr();
223
224 ShenandoahCollectorPolicy *shenandoahPolicy() { return _shenandoah_policy;}
225
226 inline ShenandoahHeapRegion* heap_region_containing(const void* addr) const;
227 inline uint heap_region_index_containing(const void* addr) const;
228 inline bool requires_marking(const void* entry) const;
229 template <class T>
230 inline oop maybe_update_oop_ref(T* p);
231
232 void recycle_dirty_regions();
233
234 void start_concurrent_marking();
235 void stop_concurrent_marking();
236 inline bool concurrent_mark_in_progress();
237 static address concurrent_mark_in_progress_addr();
282
283 void parallel_evacuate_region(ShenandoahHeapRegion* from_region);
284
285 template <class T>
286 inline oop update_oop_ref_not_null(T* p, oop obj);
287
288 void print_heap_regions(outputStream* st = tty) const;
289 void print_all_refs(const char* prefix);
290 void print_heap_locations(HeapWord* start, HeapWord* end);
291
292 size_t bytes_allocated_since_cm();
293 void set_bytes_allocated_since_cm(size_t bytes);
294
295 size_t max_allocated_gc();
296
297 void reclaim_humongous_region_at(ShenandoahHeapRegion* r);
298
299 VirtualSpace* storage() const;
300
301 ShenandoahMonitoringSupport* monitoring_support();
302 ShenandoahJNICritical* jni_critical();
303 ShenandoahConcurrentMark* concurrentMark() { return _scm;}
304
305 ReferenceProcessor* ref_processor() { return _ref_processor;}
306
307 WorkGang* conc_workers() const { return _conc_workers;}
308 WorkGang* workers() const { return _workers;}
309 int max_conc_workers();
310
311 int max_workers();
312 int max_parallel_workers();
313
314 void do_evacuation();
315 inline void initialize_brooks_ptr(oop p);
316 ShenandoahHeapRegion* next_compaction_region(const ShenandoahHeapRegion* r);
317
318 void heap_region_iterate(ShenandoahHeapRegionClosure* blk, bool skip_dirty_regions = false, bool skip_humongous_continuation = false) const;
319
320 void verify_heap_after_evacuation();
321
322 // Delete entries for dead interned string and clean up unreferenced symbols
|
20 * questions.
21 *
22 */
23
24 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHHEAP_HPP
25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHHEAP_HPP
26
27 #include "gc/shared/cmBitMap.hpp"
28
29 class ConcurrentGCTimer;
30
31 class ShenandoahCollectorPolicy;
32 class ShenandoahHeapRegion;
33 class ShenandoahHeapRegionClosure;
34 class ShenandoahHeapRegionSet;
35 class ShenandoahCollectionSet;
36 class ShenandoahFreeSet;
37 class ShenandoahConcurrentMark;
38 class ShenandoahConcurrentThread;
39 class ShenandoahMonitoringSupport;
40
41 class ShenandoahAlwaysTrueClosure : public BoolObjectClosure {
42 public:
43 bool do_object_b(oop p) { return true; }
44 };
45
46
47 class ShenandoahIsAliveClosure: public BoolObjectClosure {
48 private:
49 ShenandoahHeap* _heap;
50 public:
51 ShenandoahIsAliveClosure();
52 void init(ShenandoahHeap* heap);
53 bool do_object_b(oop obj);
54 };
55
56 class ShenandoahForwardedIsAliveClosure: public BoolObjectClosure {
57 private:
58 ShenandoahHeap* _heap;
59 public:
109 WorkGang* _conc_workers;
110 WorkGang* _workers;
111
112
113 volatile size_t _used;
114
115 CMBitMap _mark_bit_map0;
116 CMBitMap _mark_bit_map1;
117 CMBitMap* _prev_mark_bit_map;
118 CMBitMap* _next_mark_bit_map;
119
120 bool* _in_cset_fast_test;
121 bool* _in_cset_fast_test_base;
122 uint _in_cset_fast_test_length;
123
124 HeapWord** _top_at_mark_starts;
125 HeapWord** _top_at_mark_starts_base;
126
127 bool _cancelled_concgc;
128
129 jbyte _growing_heap;
130
131 size_t _bytes_allocated_since_cm;
132 size_t _bytes_allocated_during_cm;
133 size_t _bytes_allocated_during_cm_start;
134 size_t _max_allocated_gc;
135 size_t _allocated_last_gc;
136 size_t _used_start_gc;
137
138 unsigned int _concurrent_mark_in_progress;
139
140 bool _full_gc_in_progress;
141
142 unsigned int _evacuation_in_progress;
143 bool _need_update_refs;
144 bool _need_reset_bitmaps;
145
146 ReferenceProcessor* _ref_processor;
147
148 ShenandoahForwardedIsAliveClosure isAlive;
195 void object_iterate(ObjectClosure* cl) /* override */;
196 void safe_object_iterate(ObjectClosure* cl) /* override */;
197 size_t unsafe_max_tlab_alloc(Thread *thread) const /* override */;
198 size_t max_tlab_size() const /* override */;
199 void resize_all_tlabs() /* override */;
200 void accumulate_statistics_all_gclabs() /* override */;
201 HeapWord* tlab_post_allocation_setup(HeapWord* obj) /* override */;
202 uint oop_extra_words() /* override */;
203 size_t tlab_used(Thread* ignored) const /* override */;
204 void stop() /* override */;
205
206 bool needs_reference_pending_list_locker_thread() const /* override */;
207
208 #ifndef CC_INTERP
209 void compile_prepare_oop(MacroAssembler* masm, Register obj) /* override */;
210 #endif
211
212 void register_nmethod(nmethod* nm);
213 void unregister_nmethod(nmethod* nm);
214
215 void enter_critical(oop o);
216 void exit_critical(oop o);
217
218 static ShenandoahHeap* heap();
219 static ShenandoahHeap* heap_no_check();
220 static size_t conservative_max_heap_alignment();
221 static address in_cset_fast_test_addr();
222
223 ShenandoahCollectorPolicy *shenandoahPolicy() { return _shenandoah_policy;}
224
225 inline ShenandoahHeapRegion* heap_region_containing(const void* addr) const;
226 inline uint heap_region_index_containing(const void* addr) const;
227 inline bool requires_marking(const void* entry) const;
228 template <class T>
229 inline oop maybe_update_oop_ref(T* p);
230
231 void recycle_dirty_regions();
232
233 void start_concurrent_marking();
234 void stop_concurrent_marking();
235 inline bool concurrent_mark_in_progress();
236 static address concurrent_mark_in_progress_addr();
281
282 void parallel_evacuate_region(ShenandoahHeapRegion* from_region);
283
284 template <class T>
285 inline oop update_oop_ref_not_null(T* p, oop obj);
286
287 void print_heap_regions(outputStream* st = tty) const;
288 void print_all_refs(const char* prefix);
289 void print_heap_locations(HeapWord* start, HeapWord* end);
290
291 size_t bytes_allocated_since_cm();
292 void set_bytes_allocated_since_cm(size_t bytes);
293
294 size_t max_allocated_gc();
295
296 void reclaim_humongous_region_at(ShenandoahHeapRegion* r);
297
298 VirtualSpace* storage() const;
299
300 ShenandoahMonitoringSupport* monitoring_support();
301 ShenandoahConcurrentMark* concurrentMark() { return _scm;}
302
303 ReferenceProcessor* ref_processor() { return _ref_processor;}
304
305 WorkGang* conc_workers() const { return _conc_workers;}
306 WorkGang* workers() const { return _workers;}
307 int max_conc_workers();
308
309 int max_workers();
310 int max_parallel_workers();
311
312 void do_evacuation();
313 inline void initialize_brooks_ptr(oop p);
314 ShenandoahHeapRegion* next_compaction_region(const ShenandoahHeapRegion* r);
315
316 void heap_region_iterate(ShenandoahHeapRegionClosure* blk, bool skip_dirty_regions = false, bool skip_humongous_continuation = false) const;
317
318 void verify_heap_after_evacuation();
319
320 // Delete entries for dead interned string and clean up unreferenced symbols
|