1 /*
2 * Copyright (c) 2013, 2015, Red Hat, Inc. and/or its affiliates.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This code is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
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
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:
60 ShenandoahForwardedIsAliveClosure();
61 void init(ShenandoahHeap* heap);
62 bool do_object_b(oop obj);
63 };
64
65
66 // // A "ShenandoahHeap" is an implementation of a java heap for HotSpot.
67 // // It uses a new pauseless GC algorithm based on Brooks pointers.
68 // // Derived from G1
69
70 // //
71 // // CollectedHeap
72 // // SharedHeap
73 // // ShenandoahHeap
74
75 class ShenandoahHeap : public CollectedHeap {
76
77 private:
78
79 static ShenandoahHeap* _pgc;
80 ShenandoahCollectorPolicy* _shenandoah_policy;
81 VirtualSpace _storage;
82 ShenandoahHeapRegion* _first_region;
83 HeapWord* _first_region_bottom;
84
85 // Sortable array of regions
86 ShenandoahHeapRegionSet* _ordered_regions;
87 ShenandoahHeapRegionSet* _sorted_regions;
88 ShenandoahFreeSet* _free_regions;
89 ShenandoahCollectionSet* _collection_set;
90 ShenandoahHeapRegion* _currentAllocationRegion;
91 ShenandoahConcurrentMark* _scm;
92
93
94
95 ShenandoahConcurrentThread* _concurrent_gc_thread;
96
97 ShenandoahMonitoringSupport* _monitoring_support;
98
99 size_t _num_regions;
100 size_t _max_regions;
101 size_t _initialSize;
102 #ifndef NDEBUG
103 uint _numAllocs;
104 #endif
105 uint _max_parallel_workers;
106 uint _max_conc_workers;
107 uint _max_workers;
108
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 size_t _in_cset_fast_test_length;
123
124 HeapWord** _top_at_mark_starts;
125 HeapWord** _top_at_mark_starts_base;
126
127 volatile jbyte _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;
149
150 ConcurrentGCTimer* _gc_timer;
151
152 public:
153 ShenandoahHeap(ShenandoahCollectorPolicy* policy);
154
155 HeapWord *first_region_bottom() { return _first_region_bottom; }
156
157 const char* name() const /* override */;
158 HeapWord* allocate_new_tlab(size_t word_size) /* override */;
159 void print_on(outputStream* st) const /* override */;
160
161 ShenandoahHeap::Name kind() const /* override */{
162 return CollectedHeap::ShenandoahHeap;
163 }
164
165 jint initialize() /* override */;
166 void post_initialize() /* override */;
167 size_t capacity() const /* override */;
168 size_t used() const /* override */;
169 bool is_maximal_no_gc() const /* override */;
170 size_t max_capacity() const /* override */;
171 size_t min_capacity() const /* override */;
172 bool is_in(const void* p) const /* override */;
173 bool is_scavengable(const void* addr) /* override */;
174 HeapWord* mem_allocate(size_t size, bool* what) /* override */;
175 bool can_elide_tlab_store_barriers() const /* override */;
176 oop new_store_pre_barrier(JavaThread* thread, oop new_obj) /* override */;
177 bool can_elide_initializing_store_barrier(oop new_obj) /* override */;
178 bool card_mark_must_follow_store() const /* override */;
179 void collect(GCCause::Cause) /* override */;
180 void do_full_collection(bool clear_all_soft_refs) /* override */;
181 AdaptiveSizePolicy* size_policy() /* override */;
182 CollectorPolicy* collector_policy() const /* override */;
183 void ensure_parsability(bool retire_tlabs) /* override */;
184 HeapWord* block_start(const void* addr) const /* override */;
185 size_t block_size(const HeapWord* addr) const /* override */;
186 bool block_is_obj(const HeapWord* addr) const /* override */;
187 jlong millis_since_last_gc() /* override */;
188 void prepare_for_verify() /* override */;
189 void print_gc_threads_on(outputStream* st) const /* override */;
190 void gc_threads_do(ThreadClosure* tcl) const /* override */;
191 void print_tracing_info() const /* override */;
192 void verify(VerifyOption vo) /* override */;
193 bool supports_tlab_allocation() const /* override */;
194 size_t tlab_capacity(Thread *thr) const /* override */;
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 #ifndef CC_INTERP
207 void compile_prepare_oop(MacroAssembler* masm, Register obj) /* override */;
208 #endif
209
210 void register_nmethod(nmethod* nm);
211 void unregister_nmethod(nmethod* nm);
212
213 void pin_object(oop o) /* override */;
214 void unpin_object(oop o) /* override */;
215
216 static ShenandoahHeap* heap();
217 static ShenandoahHeap* heap_no_check();
218 static size_t conservative_max_heap_alignment();
219 static address in_cset_fast_test_addr();
220 static address cancelled_concgc_addr();
221
222 static void pretouch_storage(char* start, char* end, WorkGang* workers);
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();
238
239 void prepare_for_concurrent_evacuation();
240 void evacuate_and_update_roots();
241 inline bool is_evacuation_in_progress();
242 void set_evacuation_in_progress(bool in_progress);
243
244 void set_full_gc_in_progress(bool in_progress);
245 bool is_full_gc_in_progress() const;
246
247 inline bool need_update_refs() const;
248 void set_need_update_refs(bool update_refs);
249
250 inline bool in_cset_fast_test(HeapWord* obj);
251 void clear_cset_fast_test();
252 void register_region_with_in_cset_fast_test(ShenandoahHeapRegion* r);
253
254 inline bool allocated_after_mark_start(HeapWord* addr) const;
255 void set_top_at_mark_start(HeapWord* region_base, HeapWord* addr);
256
257 inline oop evacuate_object(oop src, Thread* thread);
258 inline bool cancelled_concgc() const;
259 void clear_cancelled_concgc();
260
261 ShenandoahHeapRegionSet* regions() { return _ordered_regions;}
262 ShenandoahHeapRegionSet* sorted_regions() { return _sorted_regions;}
263 ShenandoahFreeSet* free_regions();
264 void clear_free_regions();
265 void add_free_region(ShenandoahHeapRegion* r);
266
267 void increase_used(size_t bytes);
268 void decrease_used(size_t bytes);
269
270 void set_used(size_t bytes);
271 size_t calculateUsed();
272
273 void reset_mark_bitmap(WorkGang* gang);
274 void reset_prev_mark_bitmap(WorkGang* gang);
275 void reset_mark_bitmap_range(HeapWord* from, HeapWord* to);
276 void reset_prev_mark_bitmap_range(HeapWord* from, HeapWord* to);
277 CMBitMap* prev_mark_bit_map();
278 CMBitMap* next_mark_bit_map();
279 inline bool is_marked_prev(oop obj) const;
280 inline bool mark_current(oop obj) const;
281 inline bool is_marked_current(oop obj) const;
282 bool is_obj_dead(const oop obj, const ShenandoahHeapRegion* r) const;
283 bool is_bitmap_clear();
284
285 void parallel_evacuate_region(ShenandoahHeapRegion* from_region);
286
287 template <class T>
288 inline oop update_oop_ref_not_null(T* p, oop obj);
289
290 void print_heap_regions(outputStream* st = tty) const;
291 void print_all_refs(const char* prefix);
292 void print_heap_locations(HeapWord* start, HeapWord* end);
293
294 size_t bytes_allocated_since_cm();
295 void set_bytes_allocated_since_cm(size_t bytes);
296
297 size_t max_allocated_gc();
298
299 void reclaim_humongous_region_at(ShenandoahHeapRegion* r);
300
301 VirtualSpace* storage() const;
302
303 ShenandoahMonitoringSupport* monitoring_support();
304 ShenandoahConcurrentMark* concurrentMark() { return _scm;}
305
306 ReferenceProcessor* ref_processor() { return _ref_processor;}
307
308 WorkGang* conc_workers() const { return _conc_workers;}
309 WorkGang* workers() const { return _workers;}
310
311 uint max_conc_workers();
312 uint max_workers();
313 uint max_parallel_workers();
314
315 void do_evacuation();
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
323 // in symbol table, possibly in parallel.
324 void unlink_string_and_symbol_table(BoolObjectClosure* is_alive, bool unlink_strings = true, bool unlink_symbols = true);
325
326 size_t num_regions();
327 size_t max_regions();
328
329 // TODO: consider moving this into ShenandoahHeapRegion.
330
331 template<class T>
332 inline void marked_prev_object_iterate(ShenandoahHeapRegion* region, T* cl);
333
334 template<class T>
335 inline void marked_next_object_iterate(ShenandoahHeapRegion* region, T* cl);
336
337 GCTimer* gc_timer() const;
338
339 private:
340 HeapWord* allocate_new_tlab(size_t word_size, bool mark);
341 HeapWord* allocate_memory(size_t word_size, bool evacuating);
342 // Shenandoah functionality.
343 inline HeapWord* allocate_from_gclab(Thread* thread, size_t size);
344 HeapWord* allocate_from_gclab_slow(Thread* thread, size_t size);
345 HeapWord* allocate_new_gclab(size_t word_size);
346
347 void roots_iterate(OopClosure* cl);
348
349 template<class T>
350 inline void marked_object_iterate(ShenandoahHeapRegion* region, T* cl, CMBitMap* mark_bit_map, HeapWord* top_at_mark_start);
351
352 template<class T>
353 inline void do_marked_object(CMBitMap* bitmap, T* cl, oop obj);
354
355 ShenandoahConcurrentThread* concurrent_thread() { return _concurrent_gc_thread; }
356
357 void swap_mark_bitmaps();
358
359 inline bool mark_current_no_checks(oop obj) const;
360 inline bool is_marked_current(oop obj, ShenandoahHeapRegion* r) const;
361
362 inline bool is_marked_prev(oop obj, const ShenandoahHeapRegion* r) const;
363
364 void parallel_evacuate();
365
366 template <class T>
367 inline oop maybe_update_oop_ref_not_null(T* p, oop obj);
368
369 inline oop atomic_compare_exchange_oop(oop n, narrowOop* addr, oop c);
370 inline oop atomic_compare_exchange_oop(oop n, oop* addr, oop c);
371
372 void evacuate_region(ShenandoahHeapRegion* from_region, ShenandoahHeapRegion* to_region);
373
374 #ifdef ASSERT
375 void verify_evacuated_region(ShenandoahHeapRegion* from_region);
376 #endif
377
378 bool is_in_collection_set(const void* p);
379
380 inline void copy_object(oop p, HeapWord* s, size_t words);
381 void verify_copy(oop p, oop c);
382 void verify_heap_size_consistency();
383 void verify_heap_after_marking();
384 void verify_heap_after_update_refs();
385 void verify_regions_after_update_refs();
386
387 void ref_processing_init();
388
389 GCTracer* tracer();
390 ShenandoahCollectionSet* collection_set() { return _collection_set; }
391
392 bool call_from_write_barrier(bool evacuating);
393 bool check_grow_heap();
394 void grow_heap_by(size_t num_regions);
395 void ensure_new_regions(size_t num_new_regions);
396
397 void verify_evacuation(ShenandoahHeapRegion* from_region);
398 void set_concurrent_mark_in_progress(bool in_progress);
399
400 void oom_during_evacuation();
401 void cancel_concgc();
402 inline void set_cancelled_concgc(bool v);
403
404 void verify_live();
405 void verify_liveness_after_concurrent_mark();
406
407 HeapWord* allocate_memory_work(size_t word_size);
408 HeapWord* allocate_large_memory(size_t word_size);
409
410 void set_from_region_protection(bool protect);
411
412 };
413
414 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHHEAP_HPP