truffle: src/share/vm/gc_implementation/g1/heapRegion.hpp comparison

comparison src/share/vm/gc_implementation/g1/heapRegion.hpp @ 2152:0fa27f37d4d4

6977804: G1: remove the zero-filling thread Summary: This changeset removes the zero-filling thread from G1 and collapses the two free region lists we had before (the "free" and "unclean" lists) into one. The new free list uses the new heap region sets / lists abstractions that we'll ultimately use it to keep track of all regions in the heap. A heap region set was also introduced for the humongous regions. Finally, this change increases the concurrency between the thread that completes freeing regions (after a cleanup pause) and the rest of the system (before we'd have to wait for said thread to complete before allocating a new region). The changest also includes a lot of refactoring and code simplification. Reviewed-by: jcoomes, johnc

author	tonyp
date	Wed, 19 Jan 2011 19:30:42 -0500
parents	b158bed62ef5
children	1216415d8e35

comparison

equal deleted inserted replaced

-:cb913d743d09
+:0fa27f37d4d4
 class CompactibleSpace;
 class ContiguousSpace;
 class HeapRegionRemSet;
 class HeapRegionRemSetIterator;
 class HeapRegion;
+class HeapRegionSetBase;
+#define HR_FORMAT "%d:["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]"
+#define HR_FORMAT_PARAMS(__hr) (__hr)->hrs_index(), (__hr)->bottom(), \
+(__hr)->top(), (__hr)->end()
 // A dirty card to oop closure for heap regions. It
 // knows how to get the G1 heap and how to use the bitmap
 // in the concurrent marker used by G1 to filter remembered
 // sets.
 HeapWord* _orig_end;
 // True iff the region is in current collection_set.
 bool _in_collection_set;
-// True iff the region is on the unclean list, waiting to be zero filled.
-bool _is_on_unclean_list;
-// True iff the region is on the free list, ready for allocation.
-bool _is_on_free_list;
 // Is this or has it been an allocation region in the current collection
 // pause.
 bool _is_gc_alloc_region;
 // True iff an attempt to evacuate an object in the region failed.
 // next region in the young "generation" region set
 HeapRegion* _next_young_region;
 // Next region whose cards need cleaning
 HeapRegion* _next_dirty_cards_region;
+// Fields used by the HeapRegionSetBase class and subclasses.
+HeapRegion* _next;
+#ifdef ASSERT
+HeapRegionSetBase* _containing_set;
+#endif // ASSERT
+bool _pending_removal;
 // For parallel heapRegion traversal.
 jint _claimed;
 // We use concurrent marking to determine the amount of live data
 _prev_top_at_mark_start = bot;
 _next_top_at_mark_start = bot;
 _top_at_conc_mark_count = bot;
 }
-jint _zfs;  // A member of ZeroFillState.  Protected by ZF_lock.
-Thread* _zero_filler; // If _zfs is ZeroFilling, the thread that (last)
-// made it so.
 void set_young_type(YoungType new_type) {
 //assert(_young_type != new_type, "setting the same type" );
 // TODO: add more assertions here
 _young_type = new_type;
 }
 FinalCountClaimValue  = 1,
 NoteEndClaimValue     = 2,
 ScrubRemSetClaimValue = 3,
 ParVerifyClaimValue   = 4,
 RebuildRSClaimValue   = 5
-};
-// Concurrent refinement requires contiguous heap regions (in which TLABs
-// might be allocated) to be zero-filled.  Each region therefore has a
-// zero-fill-state.
-enum ZeroFillState {
-NotZeroFilled,
-ZeroFilling,
-ZeroFilled,
-Allocated
 };
 inline HeapWord* par_allocate_no_bot_updates(size_t word_size) {
 assert(is_young(), "we can only skip BOT updates on young regions");
 return ContiguousSpace::par_allocate(word_size);
 // Makes the current region be a "continues humongous'
 // region. first_hr is the "start humongous" region of the series
 // which this region will be part of.
 void set_continuesHumongous(HeapRegion* first_hr);
+// Unsets the humongous-related fields on the region.
+void set_notHumongous();
 // If the region has a remembered set, return a pointer to it.
 HeapRegionRemSet* rem_set() const {
 return _rem_set;
 }
 assert(is_gc_alloc_region(), "should only invoke on member of CS.");
 assert(r == NULL || r->is_gc_alloc_region(), "Malformed CS.");
 _next_in_special_set = r;
 }
-bool is_on_free_list() {
+// Methods used by the HeapRegionSetBase class and subclasses.
-return _is_on_free_list;
-}
+// Getter and setter for the next field used to link regions into
+// linked lists.
-void set_on_free_list(bool b) {
+HeapRegion* next()              { return _next; }
-_is_on_free_list = b;
-}
+void set_next(HeapRegion* next) { _next = next; }
-HeapRegion* next_from_free_list() {
+// Every region added to a set is tagged with a reference to that
-assert(is_on_free_list(),
+// set. This is used for doing consistency checking to make sure that
-"Should only invoke on free space.");
+// the contents of a set are as they should be and it's only
-assert(_next_in_special_set == NULL ||
+// available in non-product builds.
-_next_in_special_set->is_on_free_list(),
+#ifdef ASSERT
-"Malformed Free List.");
+void set_containing_set(HeapRegionSetBase* containing_set) {
-return _next_in_special_set;
+assert((containing_set == NULL && _containing_set != NULL) ||
-}
+(containing_set != NULL && _containing_set == NULL),
+err_msg("containing_set: "PTR_FORMAT" "
-void set_next_on_free_list(HeapRegion* r) {
+"_containing_set: "PTR_FORMAT,
-assert(r == NULL || r->is_on_free_list(), "Malformed free list.");
+containing_set, _containing_set));
-_next_in_special_set = r;
-}
+_containing_set = containing_set;
+}
-bool is_on_unclean_list() {
-return _is_on_unclean_list;
+HeapRegionSetBase* containing_set() { return _containing_set; }
-}
+#else // ASSERT
+void set_containing_set(HeapRegionSetBase* containing_set) { }
-void set_on_unclean_list(bool b);
+// containing_set() is only used in asserts so there's not reason
-HeapRegion* next_from_unclean_list() {
+// to provide a dummy version of it.
-assert(is_on_unclean_list(),
+#endif // ASSERT
-"Should only invoke on unclean space.");
-assert(_next_in_special_set == NULL ||
+// If we want to remove regions from a list in bulk we can simply tag
-_next_in_special_set->is_on_unclean_list(),
+// them with the pending_removal tag and call the
-"Malformed unclean List.");
+// remove_all_pending() method on the list.
-return _next_in_special_set;
-}
+bool pending_removal() { return _pending_removal; }
-void set_next_on_unclean_list(HeapRegion* r);
+void set_pending_removal(bool pending_removal) {
+// We can only set pending_removal to true, if it's false and the
+// region belongs to a set.
+assert(!pending_removal ||
+(!_pending_removal && containing_set() != NULL), "pre-condition");
+// We can only set pending_removal to false, if it's true and the
+// region does not belong to a set.
+assert( pending_removal ||
+( _pending_removal && containing_set() == NULL), "pre-condition");
+_pending_removal = pending_removal;
+}
 HeapRegion* get_next_young_region() { return _next_young_region; }
 void set_next_young_region(HeapRegion* hr) {
 _next_young_region = hr;
 }
 // Reset HR stuff to default values.
 void hr_clear(bool par, bool clear_space);
 void initialize(MemRegion mr, bool clear_space, bool mangle_space);
-// Ensure that "this" is zero-filled.
-void ensure_zero_filled();
-// This one requires that the calling thread holds ZF_mon.
-void ensure_zero_filled_locked();
 // Get the start of the unmarked area in this region.
 HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; }
 HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; }
 // Requires that "addr" is within the region.  Returns the start of the
 // first ("careful") block that starts at or after "addr", or else the
 // "end" of the region if there is no such block.
 HeapWord* next_block_start_careful(HeapWord* addr);
-// Returns the zero-fill-state of the current region.
-ZeroFillState zero_fill_state() { return (ZeroFillState)_zfs; }
-bool zero_fill_is_allocated() { return _zfs == Allocated; }
-Thread* zero_filler() { return _zero_filler; }
-// Indicate that the contents of the region are unknown, and therefore
-// might require zero-filling.
-void set_zero_fill_needed() {
-set_zero_fill_state_work(NotZeroFilled);
-}
-void set_zero_fill_in_progress(Thread* t) {
-set_zero_fill_state_work(ZeroFilling);
-_zero_filler = t;
-}
-void set_zero_fill_complete();
-void set_zero_fill_allocated() {
-set_zero_fill_state_work(Allocated);
-}
-void set_zero_fill_state_work(ZeroFillState zfs);
-// This is called when a full collection shrinks the heap.
-// We want to set the heap region to a value which says
-// it is no longer part of the heap.  For now, we'll let "NotZF" fill
-// that role.
-void reset_zero_fill() {
-set_zero_fill_state_work(NotZeroFilled);
-_zero_filler = NULL;
-}
 size_t recorded_rs_length() const        { return _recorded_rs_length; }
 double predicted_elapsed_time_ms() const { return _predicted_elapsed_time_ms; }
 size_t predicted_bytes_to_copy() const   { return _predicted_bytes_to_copy; }
 void set_recorded_rs_length(size_t rs_length) {
 // the "next" marking information at the end of remark.
 void verify(bool allow_dirty, bool use_prev_marking, bool *failures) const;
 // Override; it uses the "prev" marking information
 virtual void verify(bool allow_dirty) const;
-#ifdef DEBUG
-HeapWord* allocate(size_t size);
-#endif
 };
 // HeapRegionClosure is used for iterating over regions.
 // Terminates the iteration when the "doHeapRegion" method returns "true".
 class HeapRegionClosure : public StackObj {
 // True after iteration if the closure was applied to all heap regions
 // and returned "false" in all cases.
 bool complete() { return _complete; }
 };
-// A linked lists of heap regions.  It leaves the "next" field
-// unspecified; that's up to subtypes.
-class RegionList VALUE_OBJ_CLASS_SPEC {
-protected:
-virtual HeapRegion* get_next(HeapRegion* chr) = 0;
-virtual void set_next(HeapRegion* chr,
-HeapRegion* new_next) = 0;
-HeapRegion* _hd;
-HeapRegion* _tl;
-size_t _sz;
-// Protected constructor because this type is only meaningful
-// when the _get/_set next functions are defined.
-RegionList() : _hd(NULL), _tl(NULL), _sz(0) {}
-public:
-void reset() {
-_hd = NULL;
-_tl = NULL;
-_sz = 0;
-}
-HeapRegion* hd() { return _hd; }
-HeapRegion* tl() { return _tl; }
-size_t sz() { return _sz; }
-size_t length();
-bool well_formed() {
-return
-((hd() == NULL && tl() == NULL && sz() == 0)
-|| (hd() != NULL && tl() != NULL && sz() > 0))
-&& (sz() == length());
-}
-virtual void insert_before_head(HeapRegion* r);
-void prepend_list(RegionList* new_list);
-virtual HeapRegion* pop();
-void dec_sz() { _sz--; }
-// Requires that "r" is an element of the list, and is not the tail.
-void delete_after(HeapRegion* r);
-};
-class EmptyNonHRegionList: public RegionList {
-protected:
-// Protected constructor because this type is only meaningful
-// when the _get/_set next functions are defined.
-EmptyNonHRegionList() : RegionList() {}
-public:
-void insert_before_head(HeapRegion* r) {
-//    assert(r->is_empty(), "Better be empty");
-assert(!r->isHumongous(), "Better not be humongous.");
-RegionList::insert_before_head(r);
-}
-void prepend_list(EmptyNonHRegionList* new_list) {
-//    assert(new_list->hd() == NULL || new_list->hd()->is_empty(),
-//     "Better be empty");
-assert(new_list->hd() == NULL || !new_list->hd()->isHumongous(),
-"Better not be humongous.");
-//    assert(new_list->tl() == NULL || new_list->tl()->is_empty(),
-//     "Better be empty");
-assert(new_list->tl() == NULL || !new_list->tl()->isHumongous(),
-"Better not be humongous.");
-RegionList::prepend_list(new_list);
-}
-};
-class UncleanRegionList: public EmptyNonHRegionList {
-public:
-HeapRegion* get_next(HeapRegion* hr) {
-return hr->next_from_unclean_list();
-}
-void set_next(HeapRegion* hr, HeapRegion* new_next) {
-hr->set_next_on_unclean_list(new_next);
-}
-UncleanRegionList() : EmptyNonHRegionList() {}
-void insert_before_head(HeapRegion* r) {
-assert(!r->is_on_free_list(),
-"Better not already be on free list");
-assert(!r->is_on_unclean_list(),
-"Better not already be on unclean list");
-r->set_zero_fill_needed();
-r->set_on_unclean_list(true);
-EmptyNonHRegionList::insert_before_head(r);
-}
-void prepend_list(UncleanRegionList* new_list) {
-assert(new_list->tl() == NULL || !new_list->tl()->is_on_free_list(),
-"Better not already be on free list");
-assert(new_list->tl() == NULL || new_list->tl()->is_on_unclean_list(),
-"Better already be marked as on unclean list");
-assert(new_list->hd() == NULL || !new_list->hd()->is_on_free_list(),
-"Better not already be on free list");
-assert(new_list->hd() == NULL || new_list->hd()->is_on_unclean_list(),
-"Better already be marked as on unclean list");
-EmptyNonHRegionList::prepend_list(new_list);
-}
-HeapRegion* pop() {
-HeapRegion* res = RegionList::pop();
-if (res != NULL) res->set_on_unclean_list(false);
-return res;
-}
-};
-// Local Variables: ***
-// c-indentation-style: gnu ***
-// End: ***
 #endif // SERIALGC
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegion.hpp @ 2152:0fa27f37d4d4