src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
Print this page
rev 2585 : [mq]: g1-reference-processing
*** 153,163 ****
--- 153,177 ----
public:
MutatorAllocRegion()
: G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
};
+ // The G1 STW is alive closure.
+ // An instance is embedded into the G1CH and used as the
+ // _is_alive_non_header closure in the STW reference
+ // processor. It is also extensively used during refence
+ // processing during STW evacuation pauses.
+ class G1STWIsAliveClosure: public BoolObjectClosure {
+ G1CollectedHeap* _g1;
+ public:
+ G1STWIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
+ void do_object(oop p) { assert(false, "Do not call."); }
+ bool do_object_b(oop p);
+ };
+
class RefineCardTableEntryClosure;
+
class G1CollectedHeap : public SharedHeap {
friend class VM_G1CollectForAllocation;
friend class VM_GenCollectForPermanentAllocation;
friend class VM_G1CollectFull;
friend class VM_G1IncCollectionPause;
*** 564,573 ****
--- 578,595 ----
// to support an allocation of the given "word_size". If
// successful, perform the allocation and return the address of the
// allocated block, or else "NULL".
HeapWord* expand_and_allocate(size_t word_size);
+ // Process any reference objects discovered during
+ // an incremental evacuation pause.
+ void process_discovered_references();
+
+ // Enqueue any remaining discovered references
+ // after processing.
+ void enqueue_discovered_references();
+
public:
G1MonitoringSupport* g1mm() { return _g1mm; }
// Expand the garbage-first heap by at least the given size (in bytes!).
*** 837,854 ****
#ifndef PRODUCT
// Useful for debugging.
void print_gc_alloc_regions();
#endif // !PRODUCT
! // Instance of the concurrent mark is_alive closure for embedding
! // into the reference processor as the is_alive_non_header. This
! // prevents unnecessary additions to the discovered lists during
! // concurrent discovery.
! G1CMIsAliveClosure _is_alive_closure;
! // ("Weak") Reference processing support
! ReferenceProcessor* _ref_processor;
enum G1H_process_strong_roots_tasks {
G1H_PS_mark_stack_oops_do,
G1H_PS_refProcessor_oops_do,
// Leave this one last.
--- 859,935 ----
#ifndef PRODUCT
// Useful for debugging.
void print_gc_alloc_regions();
#endif // !PRODUCT
! // ("Weak") Reference processing support.
! //
! // G1 has 2 instances of the referece processor class. One
! // (_ref_processor_cm) handles reference object discovery
! // and subsequent processing during concurrent marking cycles.
! //
! // The other (_ref_processor_stw) handles reference object
! // discovery and processing during full GCs and incremental
! // evacuation pauses.
! //
! // During an incremental pause, reference discovery will be
! // temporarily disabled for _ref_processor_cm and will be
! // enabled for _ref_processor_stw. At the end of the evacuation
! // pause references discovered by _ref_processor_stw will be
! // processed and discovery will be disabled. The previous
! // setting for reference object discovery for _ref_processor_cm
! // will be re-instated.
! //
! // At the start of marking:
! // * Discovery by the CM ref processor is verified to be inactive
! // and it's discovered lists are empty.
! // * Discovery by the CM ref processor is then enabled.
! //
! // At the end of marking:
! // * Any references on the CM ref processor's discovered
! // lists are processed (possibly MT).
! //
! // At the start of full GC we:
! // * Disable discovery by the CM ref processor and
! // empty CM ref processor's discovered lists
! // (without processing any entries).
! // * Verify that the STW ref processor is inactive and it's
! // discovered lists are empty.
! // * Temporarily set STW ref processor discovery as single threaded.
! // * Temporarily clear the STW ref processor's _is_alive_non_header
! // field.
! // * Finally enable discovery by the STW ref processor.
! //
! // The STW ref processor is used to record any discovered
! // references during the full GC.
! //
! // At the end of a full GC we:
! // * Will enqueue any non-live discovered references on the
! // STW ref processor's discovered lists. This makes the
! // STW ref processor inactive by disabling discovery.
! // * Verify that the CM ref processor is still inactive
! // and no references have been placed on it's discovered
! // lists (also checked as a precondition during initial marking).
!
! // The (stw) reference processor...
! ReferenceProcessor* _ref_processor_stw;
!
! // Instance of the is_alive closure for embedding into the
! // STW reference processor as the _is_alive_non_header field.
! // The _is_alive_non_header prevents unnecessary additions to
! // the discovered lists during reference discovery.
! G1STWIsAliveClosure _is_alive_closure_stw;
! // The (concurrent marking) reference processor...
! ReferenceProcessor* _ref_processor_cm;
!
! // Instance of the concurrent mark is_alive closure for embedding
! // into the Concurrent Marking reference processor as the
! // _is_alive_non_header field. The _is_alive_non_header
! // prevents unnecessary additions to the discovered lists
! // during concurrent discovery.
! G1CMIsAliveClosure _is_alive_closure_cm;
enum G1H_process_strong_roots_tasks {
G1H_PS_mark_stack_oops_do,
G1H_PS_refProcessor_oops_do,
// Leave this one last.
*** 885,894 ****
--- 966,976 ----
// Initialize the G1CollectedHeap to have the initial and
// maximum sizes, permanent generation, and remembered and barrier sets
// specified by the policy object.
jint initialize();
+ // Initialize weak reference processing.
virtual void ref_processing_init();
void set_par_threads(int t) {
SharedHeap::set_par_threads(t);
_process_strong_tasks->set_n_threads(t);
*** 936,947 ****
bool concurrent, int worker_i);
// The shared block offset table array.
G1BlockOffsetSharedArray* bot_shared() const { return _bot_shared; }
! // Reference Processing accessor
! ReferenceProcessor* ref_processor() { return _ref_processor; }
virtual size_t capacity() const;
virtual size_t used() const;
// This should be called when we're not holding the heap lock. The
// result might be a bit inaccurate.
--- 1018,1034 ----
bool concurrent, int worker_i);
// The shared block offset table array.
G1BlockOffsetSharedArray* bot_shared() const { return _bot_shared; }
! // Reference Processing accessors
!
! // The STW reference processor....
! ReferenceProcessor* ref_processor_stw() const { return _ref_processor_stw; }
!
! // The Concurent Marking reference processor...
! ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
virtual size_t capacity() const;
virtual size_t used() const;
// This should be called when we're not holding the heap lock. The
// result might be a bit inaccurate.