jdk-sandbox: comparison src/hotspot/share/gc/g1/g1CollectedHeap.hpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "gc/g1/g1BiasedArray.hpp"
 #include "gc/g1/g1CardTable.hpp"
 #include "gc/g1/g1CollectionSet.hpp"
 #include "gc/g1/g1CollectorState.hpp"
 #include "gc/g1/g1ConcurrentMark.hpp"
-#include "gc/g1/g1DirtyCardQueue.hpp"
 #include "gc/g1/g1EdenRegions.hpp"
 #include "gc/g1/g1EvacFailure.hpp"
 #include "gc/g1/g1EvacStats.hpp"
 #include "gc/g1/g1EvacuationInfo.hpp"
 #include "gc/g1/g1GCPhaseTimes.hpp"
 #include "gc/g1/g1HeapTransition.hpp"
 #include "gc/g1/g1HeapVerifier.hpp"
 #include "gc/g1/g1HRPrinter.hpp"
 #include "gc/g1/g1HeapRegionAttr.hpp"
 #include "gc/g1/g1MonitoringSupport.hpp"
+#include "gc/g1/g1RedirtyCardsQueue.hpp"
 #include "gc/g1/g1SurvivorRegions.hpp"
 #include "gc/g1/g1YCTypes.hpp"
 #include "gc/g1/heapRegionManager.hpp"
 #include "gc/g1/heapRegionSet.hpp"
 #include "gc/g1/heterogeneousHeapRegionManager.hpp"
 class MemoryManager;
 class ObjectClosure;
 class SpaceClosure;
 class CompactibleSpaceClosure;
 class Space;
+class G1CardTableEntryClosure;
 class G1CollectionSet;
 class G1Policy;
 class G1HotCardCache;
 class G1RemSet;
 class G1YoungRemSetSamplingThread;
-class HeapRegionRemSetIterator;
 class G1ConcurrentMark;
 class G1ConcurrentMarkThread;
 class G1ConcurrentRefine;
 class GenerationCounters;
 class STWGCTimer;
 public:
 virtual void on_commit(uint start_idx, size_t num_regions, bool zero_filled);
 };
 class G1CollectedHeap : public CollectedHeap {
-friend class G1FreeCollectionSetTask;
 friend class VM_CollectForMetadataAllocation;
 friend class VM_G1CollectForAllocation;
 friend class VM_G1CollectFull;
 friend class VMStructs;
 friend class MutatorAllocRegion;
 assert_at_safepoint();                                                    \
 assert(Thread::current_or_null() != NULL, "no current thread");           \
 assert(Thread::current()->is_VM_thread(), "current thread is not VM thread"); \
 } while (0)
+#ifdef ASSERT
 #define assert_used_and_recalculate_used_equal(g1h)                           \
 do {                                                                        \
 size_t cur_used_bytes = g1h->used();                                      \
 size_t recal_used_bytes = g1h->recalculate_used();                        \
 assert(cur_used_bytes == recal_used_bytes, "Used(" SIZE_FORMAT ") is not" \
 " same as recalculated used(" SIZE_FORMAT ").",                    \
 cur_used_bytes, recal_used_bytes);                                 \
 } while (0)
+#else
+#define assert_used_and_recalculate_used_equal(g1h) do {} while(0)
+#endif
 const char* young_gc_name() const;
 // The young region list.
 G1EdenRegions _eden;
 }
 void clear_region_attr() {
 _region_attr.clear();
 }
+// Verify that the G1RegionAttr remset tracking corresponds to actual remset tracking
+// for all regions.
+void verify_region_attr_remset_update() PRODUCT_RETURN;
 bool is_user_requested_concurrent_full_gc(GCCause::Cause cause);
 // This is called at the start of either a concurrent cycle or a Full
 // GC to update the number of old marking cycles started.
 private:
 // Evacuate the next set of optional regions.
 void evacuate_next_optional_regions(G1ParScanThreadStateSet* per_thread_states);
 public:
-void pre_evacuate_collection_set(G1EvacuationInfo& evacuation_info);
+void pre_evacuate_collection_set(G1EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* pss);
-void post_evacuate_collection_set(G1EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* pss);
+void post_evacuate_collection_set(G1EvacuationInfo& evacuation_info,
+G1RedirtyCardsQueueSet* rdcqs,
+G1ParScanThreadStateSet* pss);
 void expand_heap_after_young_collection();
 // Update object copying statistics.
 void record_obj_copy_mem_stats();
 G1HotCardCache* _hot_card_cache;
 // The g1 remembered set of the heap.
 G1RemSet* _rem_set;
-// A set of cards that cover the objects for which the Rsets should be updated
-// concurrently after the collection.
-G1DirtyCardQueueSet _dirty_card_queue_set;
 // After a collection pause, convert the regions in the collection set into free
 // regions.
 void free_collection_set(G1CollectionSet* collection_set, G1EvacuationInfo& evacuation_info, const size_t* surviving_young_words);
 // Abandon the current collection set without recording policy
 EvacuationFailedInfo* _evacuation_failed_info_array;
 // Failed evacuations cause some logical from-space objects to have
 // forwarding pointers to themselves.  Reset them.
-void remove_self_forwarding_pointers();
+void remove_self_forwarding_pointers(G1RedirtyCardsQueueSet* rdcqs);
 // Restore the objects in the regions in the collection set after an
 // evacuation failure.
-void restore_after_evac_failure();
+void restore_after_evac_failure(G1RedirtyCardsQueueSet* rdcqs);
 PreservedMarksSet _preserved_marks_set;
 // Preserve the mark of "obj", if necessary, in preparation for its mark
 // word being overwritten with a self-forwarding-pointer.
-void preserve_mark_during_evac_failure(uint worker_id, oop obj, markOop m);
+void preserve_mark_during_evac_failure(uint worker_id, oop obj, markWord m);
 #ifndef PRODUCT
 // Support for forcing evacuation failures. Analogous to
 // PromotionFailureALot for the other collectors.
 RefToScanQueue *task_queue(uint i) const;
 uint num_task_queues() const;
-// A set of cards where updates happened during the GC
-G1DirtyCardQueueSet& dirty_card_queue_set() { return _dirty_card_queue_set; }
 // Create a G1CollectedHeap.
 // Must call the initialize method afterwards.
 // May not return if something goes wrong.
 G1CollectedHeap();
 // Try to minimize the remembered set.
 void scrub_rem_set();
 // Apply the given closure on all cards in the Hot Card Cache, emptying it.
-void iterate_hcc_closure(G1CardTableEntryClosure* cl, uint worker_i);
+void iterate_hcc_closure(G1CardTableEntryClosure* cl, uint worker_id);
-// Apply the given closure on all cards in the Dirty Card Queue Set, emptying it.
-void iterate_dirty_card_closure(G1CardTableEntryClosure* cl, uint worker_i);
 // The shared block offset table array.
 G1BlockOffsetTable* bot() const { return _bot; }
 // Reference Processing accessors
 // corresponding region is in the collection set or not.
 G1HeapRegionAttrBiasedMappedArray _region_attr;
 public:
-inline G1HeapRegionAttr region_attr(const void* obj);
+inline G1HeapRegionAttr region_attr(const void* obj) const;
+inline G1HeapRegionAttr region_attr(uint idx) const;
 // Return "TRUE" iff the given object address is in the reserved
 // region of g1.
 bool is_in_g1_reserved(const void* p) const {
 return _hrm->reserved().contains(p);
 // reserved for the heap
 MemRegion g1_reserved() const {
 return _hrm->reserved();
 }
-G1HotCardCache* g1_hot_card_cache() const { return _hot_card_cache; }
+MemRegion reserved_region() const {
+return _reserved;
+}
+HeapWord* base() const {
+return _reserved.start();
+}
+bool is_in_reserved(const void* addr) const {
+return _reserved.contains(addr);
+}
+G1HotCardCache* hot_card_cache() const { return _hot_card_cache; }
 G1CardTable* card_table() const {
 return _card_table;
 }
 // Iterate over the regions in the current increment of the collection set.
 // Starts the iteration so that the start regions of a given worker id over the
 // set active_workers are evenly spread across the set of collection set regions
 // to be iterated.
-void collection_set_iterate_increment_from(HeapRegionClosure *blk, uint worker_id);
+// The variant with the HeapRegionClaimer guarantees that the closure will be
+// applied to a particular region exactly once.
+void collection_set_iterate_increment_from(HeapRegionClosure *blk, uint worker_id) {
+collection_set_iterate_increment_from(blk, NULL, worker_id);
+}
+void collection_set_iterate_increment_from(HeapRegionClosure *blk, HeapRegionClaimer* hr_claimer, uint worker_id);
 // Returns the HeapRegion that contains addr. addr must not be NULL.
 template <class T>
 inline HeapRegion* heap_region_containing(const T addr) const;
 // Returns the address of the start of the "block" that contains the
 // address "addr".  We say "blocks" instead of "object" since some heaps
 // may not pack objects densely; a chunk may either be an object or a
 // non-object.
-virtual HeapWord* block_start(const void* addr) const;
+HeapWord* block_start(const void* addr) const;
 // Requires "addr" to be the start of a block, and returns "TRUE" iff
 // the block is an object.
-virtual bool block_is_obj(const HeapWord* addr) const;
+bool block_is_obj(const HeapWord* addr) const;
 // Section on thread-local allocation buffers (TLABs)
 // See CollectedHeap for semantics.
 bool supports_tlab_allocation() const;
 // Performs cleaning of data structures after class unloading.
 void complete_cleaning(BoolObjectClosure* is_alive, bool class_unloading_occurred);
 // Redirty logged cards in the refinement queue.
-void redirty_logged_cards();
+void redirty_logged_cards(G1RedirtyCardsQueueSet* rdcqs);
 // Verification
 // Deduplicate the string
 virtual void deduplicate_string(oop str);
 // The following two methods are helpful for debugging RSet issues.
 void print_cset_rsets() PRODUCT_RETURN;
 void print_all_rsets() PRODUCT_RETURN;
+// Used to print information about locations in the hs_err file.
+virtual bool print_location(outputStream* st, void* addr) const;
 size_t pending_card_num();
 };
 class G1ParEvacuateFollowersClosure : public VoidClosure {
 private:

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54934	39814e0a8964
child 58679	9c3209ff7550