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/markBitMap.hpp"
28 #include "gc/shared/collectedHeap.hpp"
29 #include "gc/shenandoah/shenandoahHeapLock.hpp"
30 #include "gc/shenandoah/shenandoahEvacOOMHandler.hpp"
31 #include "gc/shenandoah/shenandoahSharedVariables.hpp"
32 #include "gc/shenandoah/shenandoahWorkGroup.hpp"
33 #include "services/memoryManager.hpp"
34
35 class ConcurrentGCTimer;
36 class ShenandoahAsserts;
37 class ShenandoahAllocTracker;
38 class ShenandoahCollectorPolicy;
39 class ShenandoahConnectionMatrix;
40 class ShenandoahFastRegionSet;
41 class ShenandoahPhaseTimings;
42 class ShenandoahHeap;
43 class ShenandoahHeapRegion;
44 class ShenandoahHeapRegionClosure;
45 class ShenandoahHeapRegionSet;
46 class ShenandoahCollectionSet;
47 class ShenandoahFreeSet;
48 class ShenandoahConcurrentMark;
49 class ShenandoahMarkCompact;
50 class ShenandoahPacer;
51 class ShenandoahTraversalGC;
52 class ShenandoahVerifier;
53 class ShenandoahControlThread;
54 class ShenandoahMonitoringSupport;
55
302 ShenandoahSharedEnumFlag<CancelState> _cancelled_concgc;
303
304 ReferenceProcessor* _ref_processor;
305
306 ShenandoahForwardedIsAliveClosure _forwarded_is_alive;
307 ShenandoahIsAliveClosure _is_alive;
308
309 ConcurrentGCTimer* _gc_timer;
310
311 ShenandoahConnectionMatrix* _connection_matrix;
312
313 GCMemoryManager _stw_memory_manager;
314 GCMemoryManager _cycle_memory_manager;
315
316 MemoryPool* _memory_pool;
317
318 ShenandoahEvacOOMHandler _oom_evac_handler;
319
320 ShenandoahSharedEnumFlag<GCCycleMode> _gc_cycle_mode;
321
322 #ifdef ASSERT
323 int _heap_expansion_count;
324 #endif
325
326 public:
327 ShenandoahHeap(ShenandoahCollectorPolicy* policy);
328
329 const char* name() const /* override */;
330 HeapWord* allocate_new_tlab(size_t word_size) /* override */;
331 void print_on(outputStream* st) const /* override */;
332 void print_extended_on(outputStream *st) const /* override */;
333
334 ShenandoahHeap::Name kind() const /* override */{
335 return CollectedHeap::ShenandoahHeap;
336 }
337
338 jint initialize() /* override */;
339 void post_initialize() /* override */;
340 size_t capacity() const /* override */;
341 size_t used() const /* override */;
353 void collect(GCCause::Cause cause) /* override */;
354 void do_full_collection(bool clear_all_soft_refs) /* override */;
355 AdaptiveSizePolicy* size_policy() /* override */;
356 CollectorPolicy* collector_policy() const /* override */;
357 void ensure_parsability(bool retire_tlabs) /* override */;
358 HeapWord* block_start(const void* addr) const /* override */;
359 size_t block_size(const HeapWord* addr) const /* override */;
360 bool block_is_obj(const HeapWord* addr) const /* override */;
361 jlong millis_since_last_gc() /* override */;
362 void prepare_for_verify() /* override */;
363 void print_gc_threads_on(outputStream* st) const /* override */;
364 void gc_threads_do(ThreadClosure* tcl) const /* override */;
365 void print_tracing_info() const /* override */;
366 void verify(VerifyOption vo) /* override */;
367 bool supports_tlab_allocation() const /* override */;
368 size_t tlab_capacity(Thread *thr) const /* override */;
369 void object_iterate(ObjectClosure* cl) /* override */;
370 void safe_object_iterate(ObjectClosure* cl) /* override */;
371 size_t unsafe_max_tlab_alloc(Thread *thread) const /* override */;
372 size_t max_tlab_size() const /* override */;
373 void resize_all_tlabs() /* override */;
374 void accumulate_statistics_all_gclabs() /* override */;
375 HeapWord* tlab_post_allocation_setup(HeapWord* obj) /* override */;
376 uint oop_extra_words() /* override */;
377 size_t tlab_used(Thread* ignored) const /* override */;
378 void stop() /* override */;
379 virtual void safepoint_synchronize_begin();
380 virtual void safepoint_synchronize_end();
381
382 WorkGang* get_safepoint_workers() { return _safepoint_workers; }
383
384 #ifndef CC_INTERP
385 void compile_prepare_oop(MacroAssembler* masm, Register obj) /* override */;
386 #endif
387
388 void register_nmethod(nmethod* nm);
389 void unregister_nmethod(nmethod* nm);
390
391 /* override: object pinning support */
392 bool supports_object_pinning() const { return true; }
393 oop pin_object(JavaThread* thread, oop obj);
394 void unpin_object(JavaThread* thread, oop obj);
395
396 static ShenandoahHeap* heap();
397 static ShenandoahHeap* heap_no_check();
398 static address in_cset_fast_test_addr();
399 static address cancelled_concgc_addr();
400 static address gc_state_addr();
401
402 ShenandoahCollectorPolicy *shenandoahPolicy() const { return _shenandoah_policy; }
403 ShenandoahPhaseTimings* phase_timings() const { return _phase_timings; }
404 ShenandoahAllocTracker* alloc_tracker() const { return _alloc_tracker; }
405
406 inline ShenandoahHeapRegion* const heap_region_containing(const void* addr) const;
407 inline size_t heap_region_index_containing(const void* addr) const;
408 inline bool requires_marking(const void* entry) const;
409
410 template <class T>
411 inline oop evac_update_with_forwarded(T* p);
412
413 template <class T>
414 inline oop maybe_update_with_forwarded(T* p);
415
416 template <class T>
417 inline oop maybe_update_with_forwarded_not_null(T* p, oop obj);
418
419 template <class T>
420 inline oop update_with_forwarded_not_null(T* p, oop obj);
421
422 void trash_cset_regions();
423
424 void stop_concurrent_marking();
425
563
564 void assert_gc_workers(uint nworker) PRODUCT_RETURN;
565
566 void do_evacuation();
567 ShenandoahHeapRegion* next_compaction_region(const ShenandoahHeapRegion* r);
568
569 void heap_region_iterate(ShenandoahHeapRegionClosure* blk, bool skip_cset_regions = false, bool skip_humongous_continuation = false) const;
570
571 // Delete entries for dead interned string and clean up unreferenced symbols
572 // in symbol table, possibly in parallel.
573 void unload_classes_and_cleanup_tables(bool full_gc);
574
575 inline size_t num_regions() const { return _num_regions; }
576
577 BoolObjectClosure* is_alive_closure();
578
579 // Call before starting evacuation.
580 void enter_evacuation();
581 // Call after finished with evacuation.
582 void leave_evacuation();
583
584 private:
585 template<class T>
586 inline void marked_object_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit);
587
588 template<class T>
589 inline void marked_object_oop_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit);
590
591 public:
592 template<class T>
593 inline void marked_object_iterate(ShenandoahHeapRegion* region, T* cl);
594
595 template<class T>
596 inline void marked_object_safe_iterate(ShenandoahHeapRegion* region, T* cl);
597
598 template<class T>
599 inline void marked_object_oop_iterate(ShenandoahHeapRegion* region, T* cl);
600
601 template<class T>
602 inline void marked_object_oop_safe_iterate(ShenandoahHeapRegion* region, T* cl);
|
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/markBitMap.hpp"
28 #include "gc/shared/collectedHeap.hpp"
29 #include "gc/shenandoah/shenandoahHeapLock.hpp"
30 #include "gc/shenandoah/shenandoahEvacOOMHandler.hpp"
31 #include "gc/shenandoah/shenandoahSharedVariables.hpp"
32 #include "gc/shenandoah/shenandoahWorkGroup.hpp"
33 #include "services/memoryManager.hpp"
34
35 class ConcurrentGCTimer;
36 class PLABStats;
37 class ShenandoahAsserts;
38 class ShenandoahAllocTracker;
39 class ShenandoahCollectorPolicy;
40 class ShenandoahConnectionMatrix;
41 class ShenandoahFastRegionSet;
42 class ShenandoahPhaseTimings;
43 class ShenandoahHeap;
44 class ShenandoahHeapRegion;
45 class ShenandoahHeapRegionClosure;
46 class ShenandoahHeapRegionSet;
47 class ShenandoahCollectionSet;
48 class ShenandoahFreeSet;
49 class ShenandoahConcurrentMark;
50 class ShenandoahMarkCompact;
51 class ShenandoahPacer;
52 class ShenandoahTraversalGC;
53 class ShenandoahVerifier;
54 class ShenandoahControlThread;
55 class ShenandoahMonitoringSupport;
56
303 ShenandoahSharedEnumFlag<CancelState> _cancelled_concgc;
304
305 ReferenceProcessor* _ref_processor;
306
307 ShenandoahForwardedIsAliveClosure _forwarded_is_alive;
308 ShenandoahIsAliveClosure _is_alive;
309
310 ConcurrentGCTimer* _gc_timer;
311
312 ShenandoahConnectionMatrix* _connection_matrix;
313
314 GCMemoryManager _stw_memory_manager;
315 GCMemoryManager _cycle_memory_manager;
316
317 MemoryPool* _memory_pool;
318
319 ShenandoahEvacOOMHandler _oom_evac_handler;
320
321 ShenandoahSharedEnumFlag<GCCycleMode> _gc_cycle_mode;
322
323 PLABStats* _mutator_gclab_stats;
324 PLABStats* _collector_gclab_stats;
325
326 #ifdef ASSERT
327 int _heap_expansion_count;
328 #endif
329
330 public:
331 ShenandoahHeap(ShenandoahCollectorPolicy* policy);
332
333 const char* name() const /* override */;
334 HeapWord* allocate_new_tlab(size_t word_size) /* override */;
335 void print_on(outputStream* st) const /* override */;
336 void print_extended_on(outputStream *st) const /* override */;
337
338 ShenandoahHeap::Name kind() const /* override */{
339 return CollectedHeap::ShenandoahHeap;
340 }
341
342 jint initialize() /* override */;
343 void post_initialize() /* override */;
344 size_t capacity() const /* override */;
345 size_t used() const /* override */;
357 void collect(GCCause::Cause cause) /* override */;
358 void do_full_collection(bool clear_all_soft_refs) /* override */;
359 AdaptiveSizePolicy* size_policy() /* override */;
360 CollectorPolicy* collector_policy() const /* override */;
361 void ensure_parsability(bool retire_tlabs) /* override */;
362 HeapWord* block_start(const void* addr) const /* override */;
363 size_t block_size(const HeapWord* addr) const /* override */;
364 bool block_is_obj(const HeapWord* addr) const /* override */;
365 jlong millis_since_last_gc() /* override */;
366 void prepare_for_verify() /* override */;
367 void print_gc_threads_on(outputStream* st) const /* override */;
368 void gc_threads_do(ThreadClosure* tcl) const /* override */;
369 void print_tracing_info() const /* override */;
370 void verify(VerifyOption vo) /* override */;
371 bool supports_tlab_allocation() const /* override */;
372 size_t tlab_capacity(Thread *thr) const /* override */;
373 void object_iterate(ObjectClosure* cl) /* override */;
374 void safe_object_iterate(ObjectClosure* cl) /* override */;
375 size_t unsafe_max_tlab_alloc(Thread *thread) const /* override */;
376 size_t max_tlab_size() const /* override */;
377 HeapWord* tlab_post_allocation_setup(HeapWord* obj) /* override */;
378 uint oop_extra_words() /* override */;
379 size_t tlab_used(Thread* ignored) const /* override */;
380 void stop() /* override */;
381 virtual void safepoint_synchronize_begin();
382 virtual void safepoint_synchronize_end();
383
384 WorkGang* get_safepoint_workers() { return _safepoint_workers; }
385
386 #ifndef CC_INTERP
387 void compile_prepare_oop(MacroAssembler* masm, Register obj) /* override */;
388 #endif
389
390 void register_nmethod(nmethod* nm);
391 void unregister_nmethod(nmethod* nm);
392
393 /* override: object pinning support */
394 bool supports_object_pinning() const { return true; }
395 oop pin_object(JavaThread* thread, oop obj);
396 void unpin_object(JavaThread* thread, oop obj);
397
398 static ShenandoahHeap* heap();
399 static ShenandoahHeap* heap_no_check();
400 static address in_cset_fast_test_addr();
401 static address cancelled_concgc_addr();
402 static address gc_state_addr();
403
404 ShenandoahCollectorPolicy *shenandoahPolicy() const { return _shenandoah_policy; }
405 ShenandoahPhaseTimings* phase_timings() const { return _phase_timings; }
406 ShenandoahAllocTracker* alloc_tracker() const { return _alloc_tracker; }
407
408 void accumulate_statistics_all_gclabs();
409 PLABStats* mutator_gclab_stats() const { return _mutator_gclab_stats; }
410 PLABStats* collector_gclab_stats() const { return _collector_gclab_stats; }
411
412 inline ShenandoahHeapRegion* const heap_region_containing(const void* addr) const;
413 inline size_t heap_region_index_containing(const void* addr) const;
414 inline bool requires_marking(const void* entry) const;
415
416 template <class T>
417 inline oop evac_update_with_forwarded(T* p);
418
419 template <class T>
420 inline oop maybe_update_with_forwarded(T* p);
421
422 template <class T>
423 inline oop maybe_update_with_forwarded_not_null(T* p, oop obj);
424
425 template <class T>
426 inline oop update_with_forwarded_not_null(T* p, oop obj);
427
428 void trash_cset_regions();
429
430 void stop_concurrent_marking();
431
569
570 void assert_gc_workers(uint nworker) PRODUCT_RETURN;
571
572 void do_evacuation();
573 ShenandoahHeapRegion* next_compaction_region(const ShenandoahHeapRegion* r);
574
575 void heap_region_iterate(ShenandoahHeapRegionClosure* blk, bool skip_cset_regions = false, bool skip_humongous_continuation = false) const;
576
577 // Delete entries for dead interned string and clean up unreferenced symbols
578 // in symbol table, possibly in parallel.
579 void unload_classes_and_cleanup_tables(bool full_gc);
580
581 inline size_t num_regions() const { return _num_regions; }
582
583 BoolObjectClosure* is_alive_closure();
584
585 // Call before starting evacuation.
586 void enter_evacuation();
587 // Call after finished with evacuation.
588 void leave_evacuation();
589
590 void initialize_gclab(Thread* thread);
591 void finalize_mutator_gclab(Thread* thread);
592
593 private:
594 template<class T>
595 inline void marked_object_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit);
596
597 template<class T>
598 inline void marked_object_oop_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit);
599
600 public:
601 template<class T>
602 inline void marked_object_iterate(ShenandoahHeapRegion* region, T* cl);
603
604 template<class T>
605 inline void marked_object_safe_iterate(ShenandoahHeapRegion* region, T* cl);
606
607 template<class T>
608 inline void marked_object_oop_iterate(ShenandoahHeapRegion* region, T* cl);
609
610 template<class T>
611 inline void marked_object_oop_safe_iterate(ShenandoahHeapRegion* region, T* cl);
|