13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
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 #include "gc/shenandoah/shenandoahWorkGroup.hpp"
29
30 class ConcurrentGCTimer;
31
32 class ShenandoahCollectorPolicy;
33 class ShenandoahHeapRegion;
34 class ShenandoahHeapRegionClosure;
35 class ShenandoahHeapRegionSet;
36 class ShenandoahCollectionSet;
37 class ShenandoahFreeSet;
38 class ShenandoahConcurrentMark;
39 class ShenandoahConcurrentThread;
40 class ShenandoahMonitoringSupport;
41
42 class SCMUpdateRefsClosure: public OopClosure {
43 private:
44 ShenandoahHeap* _heap;
45
46 template <class T>
47 inline void do_oop_work(T* p);
48
49 public:
50 SCMUpdateRefsClosure();
51
52 public:
123 };
124
125 public:
126 enum ShenandoahCancelCause {
127 _oom_evacuation,
128 _vm_stop,
129 };
130 private:
131
132 static ShenandoahHeap* _pgc;
133 ShenandoahCollectorPolicy* _shenandoah_policy;
134 VirtualSpace _storage;
135 ShenandoahHeapRegion* _first_region;
136 HeapWord* _first_region_bottom;
137
138 // Sortable array of regions
139 ShenandoahHeapRegionSet* _ordered_regions;
140 ShenandoahHeapRegionSet* _sorted_regions;
141 ShenandoahFreeSet* _free_regions;
142 ShenandoahCollectionSet* _collection_set;
143 ShenandoahHeapRegion* _currentAllocationRegion;
144 ShenandoahConcurrentMark* _scm;
145
146
147
148 ShenandoahConcurrentThread* _concurrent_gc_thread;
149
150 ShenandoahMonitoringSupport* _monitoring_support;
151
152 size_t _num_regions;
153 size_t _max_regions;
154 size_t _initialSize;
155 #ifndef NDEBUG
156 uint _numAllocs;
157 #endif
158 uint _max_workers;
159
160 ShenandoahWorkGang* _workers;
161
162
186 size_t _allocated_last_gc;
187 size_t _used_start_gc;
188
189 unsigned int _concurrent_mark_in_progress;
190
191 bool _full_gc_in_progress;
192
193 unsigned int _evacuation_in_progress;
194 bool _need_update_refs;
195 bool _need_reset_bitmaps;
196
197 ReferenceProcessor* _ref_processor;
198
199 ShenandoahForwardedIsAliveClosure isAlive;
200
201 ConcurrentGCTimer* _gc_timer;
202
203 // See allocate_memory()
204 volatile jbyte _heap_lock;
205
206 #ifdef ASSERT
207 volatile Thread* _heap_lock_owner;
208 #endif
209
210 public:
211 ShenandoahHeap(ShenandoahCollectorPolicy* policy);
212
213 HeapWord *first_region_bottom() { return _first_region_bottom; }
214
215 const char* name() const /* override */;
216 HeapWord* allocate_new_tlab(size_t word_size) /* override */;
217 void print_on(outputStream* st) const /* override */;
218
219 ShenandoahHeap::Name kind() const /* override */{
220 return CollectedHeap::ShenandoahHeap;
221 }
222
223 jint initialize() /* override */;
224 void post_initialize() /* override */;
225 size_t capacity() const /* override */;
278 static address cancelled_concgc_addr();
279
280 ShenandoahCollectorPolicy *shenandoahPolicy() { return _shenandoah_policy;}
281
282 inline ShenandoahHeapRegion* heap_region_containing(const void* addr) const;
283 inline uint heap_region_index_containing(const void* addr) const;
284 inline bool requires_marking(const void* entry) const;
285 template <class T>
286 inline oop maybe_update_oop_ref(T* p);
287
288 void recycle_dirty_regions();
289
290 void start_concurrent_marking();
291 void stop_concurrent_marking();
292 inline bool concurrent_mark_in_progress();
293 static address concurrent_mark_in_progress_addr();
294
295 void prepare_for_concurrent_evacuation();
296 void evacuate_and_update_roots();
297
298 private:
299 void set_evacuation_in_progress(bool in_progress);
300 public:
301 inline bool is_evacuation_in_progress();
302 void set_evacuation_in_progress_concurrently(bool in_progress);
303 void set_evacuation_in_progress_at_safepoint(bool in_progress);
304
305 void set_full_gc_in_progress(bool in_progress);
306 bool is_full_gc_in_progress() const;
307
308 inline bool need_update_refs() const;
309 void set_need_update_refs(bool update_refs);
310
311 inline bool region_in_collection_set(size_t region_index) const;
312
313 void set_region_in_collection_set(size_t region_index, bool b);
314
315 // Mainly there to avoid accidentally calling the templated
316 // method below with ShenandoahHeapRegion* which would be *wrong*.
317 inline bool in_collection_set(ShenandoahHeapRegion* r) const;
322 void clear_cset_fast_test();
323
324 inline bool allocated_after_next_mark_start(HeapWord* addr) const;
325 void set_next_top_at_mark_start(HeapWord* region_base, HeapWord* addr);
326 HeapWord* next_top_at_mark_start(HeapWord* region_base);
327
328 inline bool allocated_after_complete_mark_start(HeapWord* addr) const;
329 void set_complete_top_at_mark_start(HeapWord* region_base, HeapWord* addr);
330 HeapWord* complete_top_at_mark_start(HeapWord* region_base);
331
332 inline oop evacuate_object(oop src, Thread* thread);
333 inline bool cancelled_concgc() const;
334 inline void set_cancelled_concgc(bool v);
335 inline bool try_cancel_concgc() const;
336 void clear_cancelled_concgc();
337
338 ShenandoahHeapRegionSet* regions() { return _ordered_regions;}
339 ShenandoahFreeSet* free_regions();
340 void clear_free_regions();
341 void add_free_region(ShenandoahHeapRegion* r);
342
343 void increase_used(size_t bytes);
344 void decrease_used(size_t bytes);
345
346 void set_used(size_t bytes);
347 size_t calculateUsed();
348
349 size_t garbage();
350
351 void reset_next_mark_bitmap(WorkGang* gang);
352 void reset_complete_mark_bitmap(WorkGang* gang);
353
354 CMBitMap* complete_mark_bit_map();
355 CMBitMap* next_mark_bit_map();
356 inline bool is_marked_complete(oop obj) const;
357 inline bool mark_next(oop obj) const;
358 inline bool is_marked_next(oop obj) const;
359 bool is_next_bitmap_clear();
360 bool is_complete_bitmap_clear_range(HeapWord* start, HeapWord* end);
361
|
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
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 #include "gc/shenandoah/shenandoahWorkGroup.hpp"
29
30 class ConcurrentGCTimer;
31
32 class ShenandoahCollectorPolicy;
33 class ShenandoahConnectionMatrix;
34 class ShenandoahHeapRegion;
35 class ShenandoahHeapRegionClosure;
36 class ShenandoahHeapRegionSet;
37 class ShenandoahCollectionSet;
38 class ShenandoahFreeSet;
39 class ShenandoahConcurrentMark;
40 class ShenandoahConcurrentThread;
41 class ShenandoahMonitoringSupport;
42
43 class SCMUpdateRefsClosure: public OopClosure {
44 private:
45 ShenandoahHeap* _heap;
46
47 template <class T>
48 inline void do_oop_work(T* p);
49
50 public:
51 SCMUpdateRefsClosure();
52
53 public:
124 };
125
126 public:
127 enum ShenandoahCancelCause {
128 _oom_evacuation,
129 _vm_stop,
130 };
131 private:
132
133 static ShenandoahHeap* _pgc;
134 ShenandoahCollectorPolicy* _shenandoah_policy;
135 VirtualSpace _storage;
136 ShenandoahHeapRegion* _first_region;
137 HeapWord* _first_region_bottom;
138
139 // Sortable array of regions
140 ShenandoahHeapRegionSet* _ordered_regions;
141 ShenandoahHeapRegionSet* _sorted_regions;
142 ShenandoahFreeSet* _free_regions;
143 ShenandoahCollectionSet* _collection_set;
144
145 ShenandoahHeapRegion* _currentAllocationRegion;
146 ShenandoahConcurrentMark* _scm;
147
148
149
150 ShenandoahConcurrentThread* _concurrent_gc_thread;
151
152 ShenandoahMonitoringSupport* _monitoring_support;
153
154 size_t _num_regions;
155 size_t _max_regions;
156 size_t _initialSize;
157 #ifndef NDEBUG
158 uint _numAllocs;
159 #endif
160 uint _max_workers;
161
162 ShenandoahWorkGang* _workers;
163
164
188 size_t _allocated_last_gc;
189 size_t _used_start_gc;
190
191 unsigned int _concurrent_mark_in_progress;
192
193 bool _full_gc_in_progress;
194
195 unsigned int _evacuation_in_progress;
196 bool _need_update_refs;
197 bool _need_reset_bitmaps;
198
199 ReferenceProcessor* _ref_processor;
200
201 ShenandoahForwardedIsAliveClosure isAlive;
202
203 ConcurrentGCTimer* _gc_timer;
204
205 // See allocate_memory()
206 volatile jbyte _heap_lock;
207
208 ShenandoahConnectionMatrix* _connection_matrix;
209
210 #ifdef ASSERT
211 volatile Thread* _heap_lock_owner;
212 #endif
213
214 public:
215 ShenandoahHeap(ShenandoahCollectorPolicy* policy);
216
217 HeapWord *first_region_bottom() { return _first_region_bottom; }
218
219 const char* name() const /* override */;
220 HeapWord* allocate_new_tlab(size_t word_size) /* override */;
221 void print_on(outputStream* st) const /* override */;
222
223 ShenandoahHeap::Name kind() const /* override */{
224 return CollectedHeap::ShenandoahHeap;
225 }
226
227 jint initialize() /* override */;
228 void post_initialize() /* override */;
229 size_t capacity() const /* override */;
282 static address cancelled_concgc_addr();
283
284 ShenandoahCollectorPolicy *shenandoahPolicy() { return _shenandoah_policy;}
285
286 inline ShenandoahHeapRegion* heap_region_containing(const void* addr) const;
287 inline uint heap_region_index_containing(const void* addr) const;
288 inline bool requires_marking(const void* entry) const;
289 template <class T>
290 inline oop maybe_update_oop_ref(T* p);
291
292 void recycle_dirty_regions();
293
294 void start_concurrent_marking();
295 void stop_concurrent_marking();
296 inline bool concurrent_mark_in_progress();
297 static address concurrent_mark_in_progress_addr();
298
299 void prepare_for_concurrent_evacuation();
300 void evacuate_and_update_roots();
301
302 void verify_matrix();
303 private:
304 void set_evacuation_in_progress(bool in_progress);
305 public:
306 inline bool is_evacuation_in_progress();
307 void set_evacuation_in_progress_concurrently(bool in_progress);
308 void set_evacuation_in_progress_at_safepoint(bool in_progress);
309
310 void set_full_gc_in_progress(bool in_progress);
311 bool is_full_gc_in_progress() const;
312
313 inline bool need_update_refs() const;
314 void set_need_update_refs(bool update_refs);
315
316 inline bool region_in_collection_set(size_t region_index) const;
317
318 void set_region_in_collection_set(size_t region_index, bool b);
319
320 // Mainly there to avoid accidentally calling the templated
321 // method below with ShenandoahHeapRegion* which would be *wrong*.
322 inline bool in_collection_set(ShenandoahHeapRegion* r) const;
327 void clear_cset_fast_test();
328
329 inline bool allocated_after_next_mark_start(HeapWord* addr) const;
330 void set_next_top_at_mark_start(HeapWord* region_base, HeapWord* addr);
331 HeapWord* next_top_at_mark_start(HeapWord* region_base);
332
333 inline bool allocated_after_complete_mark_start(HeapWord* addr) const;
334 void set_complete_top_at_mark_start(HeapWord* region_base, HeapWord* addr);
335 HeapWord* complete_top_at_mark_start(HeapWord* region_base);
336
337 inline oop evacuate_object(oop src, Thread* thread);
338 inline bool cancelled_concgc() const;
339 inline void set_cancelled_concgc(bool v);
340 inline bool try_cancel_concgc() const;
341 void clear_cancelled_concgc();
342
343 ShenandoahHeapRegionSet* regions() { return _ordered_regions;}
344 ShenandoahFreeSet* free_regions();
345 void clear_free_regions();
346 void add_free_region(ShenandoahHeapRegion* r);
347
348 ShenandoahConnectionMatrix* connection_matrix();
349
350 void increase_used(size_t bytes);
351 void decrease_used(size_t bytes);
352
353 void set_used(size_t bytes);
354 size_t calculateUsed();
355
356 size_t garbage();
357
358 void reset_next_mark_bitmap(WorkGang* gang);
359 void reset_complete_mark_bitmap(WorkGang* gang);
360
361 CMBitMap* complete_mark_bit_map();
362 CMBitMap* next_mark_bit_map();
363 inline bool is_marked_complete(oop obj) const;
364 inline bool mark_next(oop obj) const;
365 inline bool is_marked_next(oop obj) const;
366 bool is_next_bitmap_clear();
367 bool is_complete_bitmap_clear_range(HeapWord* start, HeapWord* end);
368
|