src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
Print this page
rev 2518 : [mq]: g1-reference-processing
@@ -152,11 +152,25 @@
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;
@@ -565,10 +579,18 @@
// 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!).
@@ -836,18 +858,77 @@
#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.
+ //
+ // 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;
- // ("Weak") Reference processing support
- ReferenceProcessor* _ref_processor;
+ // 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.
@@ -884,10 +965,11 @@
// 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);
@@ -935,12 +1017,17 @@
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; }
+ // 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.