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.