graal-compiler: src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 a45a4f5a9609
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "gc_implementation/g1/g1MonitoringSupport.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
 #include "gc_implementation/g1/g1YCTypes.hpp"
 #include "gc_implementation/g1/heapRegionSeq.hpp"
-#include "gc_implementation/g1/heapRegionSets.hpp"
+#include "gc_implementation/g1/heapRegionSet.hpp"
 #include "gc_implementation/shared/hSpaceCounters.hpp"
 #include "gc_implementation/shared/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/memRegion.hpp"
 #include "memory/sharedHeap.hpp"
 friend class MutatorAllocRegion;
 friend class SurvivorGCAllocRegion;
 friend class OldGCAllocRegion;
 // Closures used in implementation.
-template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
+template <G1Barrier barrier, bool do_mark_object>
 friend class G1ParCopyClosure;
 friend class G1IsAliveClosure;
 friend class G1EvacuateFollowersClosure;
 friend class G1ParScanThreadState;
 friend class G1ParScanClosureSuper;
 // The part of _g1_storage that is currently committed.
 MemRegion _g1_committed;
 // The master free list. It will satisfy all new region allocations.
-MasterFreeRegionList      _free_list;
+FreeRegionList _free_list;
 // The secondary free list which contains regions that have been
 // freed up during the cleanup process. This will be appended to the
 // master free list when appropriate.
-SecondaryFreeRegionList   _secondary_free_list;
+FreeRegionList _secondary_free_list;
 // It keeps track of the old regions.
-MasterOldRegionSet        _old_set;
+HeapRegionSet _old_set;
 // It keeps track of the humongous regions.
-MasterHumongousRegionSet  _humongous_set;
+HeapRegionSet _humongous_set;
 // The number of regions we could create by expansion.
 uint _expansion_regions;
 // The block offset table for the G1 heap.
 // This is the second level of trying to allocate a new region. If
 // new_region() didn't find a region on the free_list, this call will
 // check whether there's anything available on the
 // secondary_free_list and/or wait for more regions to appear on
 // that list, if _free_regions_coming is set.
-HeapRegion* new_region_try_secondary_free_list();
+HeapRegion* new_region_try_secondary_free_list(bool is_old);
 // Try to allocate a single non-humongous HeapRegion sufficient for
 // an allocation of the given word_size. If do_expand is true,
 // attempt to expand the heap if necessary to satisfy the allocation
-// request.
+// request. If the region is to be used as an old region or for a
-HeapRegion* new_region(size_t word_size, bool do_expand);
+// humongous object, set is_old to true. If not, to false.
+HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand);
 // Attempt to satisfy a humongous allocation request of the given
 // size by finding a contiguous set of free regions of num_regions
 // length and remove them from the master free list. Return the
 // index of the first region or G1_NULL_HRS_INDEX if the search
 // allocation region, either by picking one or expanding the
 // heap, and then allocate a block of the given size. The block
 // may not be a humongous - it must fit into a single heap region.
 HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size);
+HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose,
+HeapRegion*    alloc_region,
+bool           par,
+size_t         word_size);
 // Ensure that no further allocations can happen in "r", bearing in mind
 // that parallel threads might be attempting allocations.
 void par_allocate_remaining_space(HeapRegion* r);
 // Allocation attempt during GC for a survivor object / PLAB.
 assert(!_in_cset_fast_test_base[index], "invariant");
 _in_cset_fast_test_base[index] = true;
 }
 // This is a fast test on whether a reference points into the
-// collection set or not. It does not assume that the reference
+// collection set or not. Assume that the reference
-// points into the heap; if it doesn't, it will return false.
+// points into the heap.
-bool in_cset_fast_test(oop obj) {
+inline bool in_cset_fast_test(oop obj);
-assert(_in_cset_fast_test != NULL, "sanity");
-if (_g1_committed.contains((HeapWord*) obj)) {
-// no need to subtract the bottom of the heap from obj,
-// _in_cset_fast_test is biased
-uintx index = cast_from_oop<uintx>(obj) >> HeapRegion::LogOfHRGrainBytes;
-bool ret = _in_cset_fast_test[index];
-// let's make sure the result is consistent with what the slower
-// test returns
-assert( ret || !obj_in_cs(obj), "sanity");
-assert(!ret ||  obj_in_cs(obj), "sanity");
-return ret;
-} else {
-return false;
-}
-}
 void clear_cset_fast_test() {
 assert(_in_cset_fast_test_base != NULL, "sanity");
 memset(_in_cset_fast_test_base, false,
 (size_t) _in_cset_fast_test_length * sizeof(bool));
 G1YCType yc_type();
 G1HRPrinter* hr_printer() { return &_hr_printer; }
+// Frees a non-humongous region by initializing its contents and
+// adding it to the free list that's passed as a parameter (this is
+// usually a local list which will be appended to the master free
+// list later). The used bytes of freed regions are accumulated in
+// pre_used. If par is true, the region's RSet will not be freed
+// up. The assumption is that this will be done later.
+// The locked parameter indicates if the caller has already taken
+// care of proper synchronization. This may allow some optimizations.
+void free_region(HeapRegion* hr,
+FreeRegionList* free_list,
+bool par,
+bool locked = false);
+// Frees a humongous region by collapsing it into individual regions
+// and calling free_region() for each of them. The freed regions
+// will be added to the free list that's passed as a parameter (this
+// is usually a local list which will be appended to the master free
+// list later). The used bytes of freed regions are accumulated in
+// pre_used. If par is true, the region's RSet will not be freed
+// up. The assumption is that this will be done later.
+void free_humongous_region(HeapRegion* hr,
+FreeRegionList* free_list,
+bool par);
 protected:
 // Shrink the garbage-first heap by at most the given size (in bytes!).
 // (Rounds down to a HeapRegion boundary.)
 virtual void shrink(size_t expand_bytes);
 void g1_process_strong_roots(bool is_scavenging,
 ScanningOption so,
 OopClosure* scan_non_heap_roots,
 OopsInHeapRegionClosure* scan_rs,
 G1KlassScanClosure* scan_klasses,
-int worker_i);
+uint worker_i);
 // Apply "blk" to all the weak roots of the system.  These include
 // JNI weak roots, the code cache, system dictionary, symbol table,
 // string table, and referents of reachable weak refs.
 void g1_process_weak_roots(OopClosure* root_closure);
-// Frees a non-humongous region by initializing its contents and
-// adding it to the free list that's passed as a parameter (this is
-// usually a local list which will be appended to the master free
-// list later). The used bytes of freed regions are accumulated in
-// pre_used. If par is true, the region's RSet will not be freed
-// up. The assumption is that this will be done later.
-void free_region(HeapRegion* hr,
-size_t* pre_used,
-FreeRegionList* free_list,
-bool par);
-// Frees a humongous region by collapsing it into individual regions
-// and calling free_region() for each of them. The freed regions
-// will be added to the free list that's passed as a parameter (this
-// is usually a local list which will be appended to the master free
-// list later). The used bytes of freed regions are accumulated in
-// pre_used. If par is true, the region's RSet will not be freed
-// up. The assumption is that this will be done later.
-void free_humongous_region(HeapRegion* hr,
-size_t* pre_used,
-FreeRegionList* free_list,
-HumongousRegionSet* humongous_proxy_set,
-bool par);
 // Notifies all the necessary spaces that the committed space has
 // been updated (either expanded or shrunk). It should be called
 // after _g1_storage is updated.
 void update_committed_space(HeapWord* old_end, HeapWord* new_end);
 // Initialize the G1CollectedHeap to have the initial and
 // maximum sizes and remembered and barrier sets
 // specified by the policy object.
 jint initialize();
+virtual void stop();
 // Return the (conservative) maximum heap alignment for any G1 heap
 static size_t conservative_max_heap_alignment();
 // Initialize weak reference processing.
 virtual void ref_processing_init();
 // continues humongous regions too.
 void reset_gc_time_stamps(HeapRegion* hr);
 void iterate_dirty_card_closure(CardTableEntryClosure* cl,
 DirtyCardQueue* into_cset_dcq,
-bool concurrent, int worker_i);
+bool concurrent, uint worker_i);
 // The shared block offset table array.
 G1BlockOffsetSharedArray* bot_shared() const { return _bot_shared; }
 // Reference Processing accessors
 #ifdef ASSERT
 bool is_on_master_free_list(HeapRegion* hr) {
 return hr->containing_set() == &_free_list;
 }
-bool is_in_humongous_set(HeapRegion* hr) {
-return hr->containing_set() == &_humongous_set;
-}
 #endif // ASSERT
 // Wrapper for the region list operations that can be called from
 // methods outside this class.
-void secondary_free_list_add_as_tail(FreeRegionList* list) {
+void secondary_free_list_add(FreeRegionList* list) {
-_secondary_free_list.add_as_tail(list);
+_secondary_free_list.add_ordered(list);
 }
 void append_secondary_free_list() {
-_free_list.add_as_head(&_secondary_free_list);
+_free_list.add_ordered(&_secondary_free_list);
 }
 void append_secondary_free_list_if_not_empty_with_lock() {
 // If the secondary free list looks empty there's no reason to
 // take the lock and then try to append it.
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 append_secondary_free_list();
 }
 }
-void old_set_remove(HeapRegion* hr) {
+inline void old_set_remove(HeapRegion* hr);
-_old_set.remove(hr);
-}
 size_t non_young_capacity_bytes() {
 return _old_set.total_capacity_bytes() + _humongous_set.total_capacity_bytes();
 }
 void collect_locked(GCCause::Cause cause);
 // True iff an evacuation has failed in the most-recent collection.
 bool evacuation_failed() { return _evacuation_failed; }
-// It will free a region if it has allocated objects in it that are
+void remove_from_old_sets(const HeapRegionSetCount& old_regions_removed, const HeapRegionSetCount& humongous_regions_removed);
-// all dead. It calls either free_region() or
+void prepend_to_freelist(FreeRegionList* list);
-// free_humongous_region() depending on the type of the region that
+void decrement_summary_bytes(size_t bytes);
-// is passed to it.
-void free_region_if_empty(HeapRegion* hr,
-size_t* pre_used,
-FreeRegionList* free_list,
-OldRegionSet* old_proxy_set,
-HumongousRegionSet* humongous_proxy_set,
-HRRSCleanupTask* hrrs_cleanup_task,
-bool par);
-// It appends the free list to the master free list and updates the
-// master humongous list according to the contents of the proxy
-// list. It also adjusts the total used bytes according to pre_used
-// (if par is true, it will do so by taking the ParGCRareEvent_lock).
-void update_sets_after_freeing_regions(size_t pre_used,
-FreeRegionList* free_list,
-OldRegionSet* old_proxy_set,
-HumongousRegionSet* humongous_proxy_set,
-bool par);
 // Returns "TRUE" iff "p" points into the committed areas of the heap.
 virtual bool is_in(const void* p) const;
 // Return "TRUE" iff the given object address is within the collection
 // Iterate over heap regions, in address order, terminating the
 // iteration early if the "doHeapRegion" method returns "true".
 void heap_region_iterate(HeapRegionClosure* blk) const;
 // Return the region with the given index. It assumes the index is valid.
-HeapRegion* region_at(uint index) const { return _hrs.at(index); }
+inline HeapRegion* region_at(uint index) const;
 // Divide the heap region sequence into "chunks" of some size (the number
 // of regions divided by the number of parallel threads times some
 // overpartition factor, currently 4).  Assumes that this will be called
 // in parallel by ParallelGCThreads worker threads with discinct worker
 // the time stamps. Called when we reset the GC time stamp.
 void clear_cset_start_regions();
 // Given the id of a worker, obtain or calculate a suitable
 // starting region for iterating over the current collection set.
-HeapRegion* start_cset_region_for_worker(int worker_i);
+HeapRegion* start_cset_region_for_worker(uint worker_i);
 // This is a convenience method that is used by the
 // HeapRegionIterator classes to calculate the starting region for
 // each worker so that they do not all start from the same region.
 HeapRegion* start_region_for_worker(uint worker_i, uint no_of_par_workers);
 virtual bool supports_heap_inspection() const { return true; }
 // Section on thread-local allocation buffers (TLABs)
 // See CollectedHeap for semantics.
-virtual bool supports_tlab_allocation() const;
+bool supports_tlab_allocation() const;
-virtual size_t tlab_capacity(Thread* thr) const;
+size_t tlab_capacity(Thread* ignored) const;
-virtual size_t unsafe_max_tlab_alloc(Thread* thr) const;
+size_t tlab_used(Thread* ignored) const;
+size_t max_tlab_size() const;
+size_t unsafe_max_tlab_alloc(Thread* ignored) const;
 // Can a compiler initialize a new object without store barriers?
 // This permission only extends from the creation of a new object
 // via a TLAB up to the first subsequent safepoint. If such permission
 // is granted for this heap type, the compiler promises to call
 virtual bool card_mark_must_follow_store() const {
 return true;
 }
-bool is_in_young(const oop obj) {
+inline bool is_in_young(const oop obj);
-HeapRegion* hr = heap_region_containing(obj);
-return hr != NULL && hr->is_young();
-}
 #ifdef ASSERT
 virtual bool is_in_partial_collection(const void* p);
 #endif
 // We don't need barriers for initializing stores to objects
 // in the young gen: for the SATB pre-barrier, there is no
 // pre-value that needs to be remembered; for the remembered-set
 // update logging post-barrier, we don't maintain remembered set
 // information for young gen objects.
-virtual bool can_elide_initializing_store_barrier(oop new_obj) {
+virtual inline bool can_elide_initializing_store_barrier(oop new_obj);
-return is_in_young(new_obj);
-}
 // Returns "true" iff the given word_size is "very large".
 static bool isHumongous(size_t word_size) {
 // Note this has to be strictly greater-than as the TLABs
 // are capped at the humongous thresold and we want to
 static G1CollectedHeap* heap();
 void set_region_short_lived_locked(HeapRegion* hr);
 // add appropriate methods for any other surv rate groups
-YoungList* young_list() { return _young_list; }
+YoungList* young_list() const { return _young_list; }
 // debugging
 bool check_young_list_well_formed() {
 return _young_list->check_list_well_formed();
 }
 // This will find the region to which the object belongs and
 // then call the region version of the same function.
 // Added if it is NULL it isn't dead.
-bool is_obj_dead(const oop obj) const {
+inline bool is_obj_dead(const oop obj) const;
-const HeapRegion* hr = heap_region_containing(obj);
-if (hr == NULL) {
+inline bool is_obj_ill(const oop obj) const;
-if (obj == NULL) return false;
-else return true;
-}
-else return is_obj_dead(obj, hr);
-}
-bool is_obj_ill(const oop obj) const {
-const HeapRegion* hr = heap_region_containing(obj);
-if (hr == NULL) {
-if (obj == NULL) return false;
-else return true;
-}
-else return is_obj_ill(obj, hr);
-}
 bool allocated_since_marking(oop obj, HeapRegion* hr, VerifyOption vo);
 HeapWord* top_at_mark_start(HeapRegion* hr, VerifyOption vo);
 bool is_marked(oop obj, VerifyOption vo);
 const char* top_at_mark_start_str(VerifyOption vo);
 // in the collection set to regions in to-space. In the event
 // of an evacuation failure, nmethods that reference objects
 // that were not successfullly evacuated are not migrated.
 void migrate_strong_code_roots();
+// Free up superfluous code root memory.
+void purge_code_root_memory();
 // During an initial mark pause, mark all the code roots that
 // point into regions *not* in the collection set.
 void mark_strong_code_roots(uint worker_id);
 // Rebuild the stong code root lists for each region
 // after a full GC
 void rebuild_strong_code_roots();
+// Delete entries for dead interned string and clean up unreferenced symbols
+// in symbol table, possibly in parallel.
+void unlink_string_and_symbol_table(BoolObjectClosure* is_alive, bool unlink_strings = true, bool unlink_symbols = true);
+// Redirty logged cards in the refinement queue.
+void redirty_logged_cards();
 // Verification
 // The following is just to alert the verification code
 // that a full collection has occurred and that the
 // remembered sets are no longer up to date.
 // parameter. The values for that parameter, and their meanings,
 // are the same as those above.
 bool is_obj_dead_cond(const oop obj,
 const HeapRegion* hr,
-const VerifyOption vo) const {
+const VerifyOption vo) const;
-switch (vo) {
-case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj, hr);
-case VerifyOption_G1UseNextMarking: return is_obj_ill(obj, hr);
-case VerifyOption_G1UseMarkWord:    return !obj->is_gc_marked();
-default:                            ShouldNotReachHere();
-}
-return false; // keep some compilers happy
-}
 bool is_obj_dead_cond(const oop obj,
-const VerifyOption vo) const {
+const VerifyOption vo) const;
-switch (vo) {
-case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj);
-case VerifyOption_G1UseNextMarking: return is_obj_ill(obj);
-case VerifyOption_G1UseMarkWord:    return !obj->is_gc_marked();
-default:                            ShouldNotReachHere();
-}
-return false; // keep some compilers happy
-}
 // Printing
 virtual void print_on(outputStream* st) const;
 virtual void print_extended_on(outputStream* st) const;
 // The following two methods are helpful for debugging RSet issues.
 void print_cset_rsets() PRODUCT_RETURN;
 void print_all_rsets() PRODUCT_RETURN;
 public:
-void stop_conc_gc_threads();
 size_t pending_card_num();
 size_t cards_scanned();
 protected:
 size_t _max_heap_capacity;
 void retire(bool end_of_gc, bool retain) {
 if (_retired)
 return;
 ParGCAllocBuffer::retire(end_of_gc, retain);
 _retired = true;
-}
-bool is_retired() {
-return _retired;
-}
-};
-class G1ParGCAllocBufferContainer {
-protected:
-static int const _priority_max = 2;
-G1ParGCAllocBuffer* _priority_buffer[_priority_max];
-public:
-G1ParGCAllocBufferContainer(size_t gclab_word_size) {
-for (int pr = 0; pr < _priority_max; ++pr) {
-_priority_buffer[pr] = new G1ParGCAllocBuffer(gclab_word_size);
-}
-}
-~G1ParGCAllocBufferContainer() {
-for (int pr = 0; pr < _priority_max; ++pr) {
-assert(_priority_buffer[pr]->is_retired(), "alloc buffers should all retire at this point.");
-delete _priority_buffer[pr];
-}
-}
-HeapWord* allocate(size_t word_sz) {
-HeapWord* obj;
-for (int pr = 0; pr < _priority_max; ++pr) {
-obj = _priority_buffer[pr]->allocate(word_sz);
-if (obj != NULL) return obj;
-}
-return obj;
-}
-bool contains(void* addr) {
-for (int pr = 0; pr < _priority_max; ++pr) {
-if (_priority_buffer[pr]->contains(addr)) return true;
-}
-return false;
-}
-void undo_allocation(HeapWord* obj, size_t word_sz) {
-bool finish_undo;
-for (int pr = 0; pr < _priority_max; ++pr) {
-if (_priority_buffer[pr]->contains(obj)) {
-_priority_buffer[pr]->undo_allocation(obj, word_sz);
-finish_undo = true;
-}
-}
-if (!finish_undo) ShouldNotReachHere();
-}
-size_t words_remaining() {
-size_t result = 0;
-for (int pr = 0; pr < _priority_max; ++pr) {
-result += _priority_buffer[pr]->words_remaining();
-}
-return result;
-}
-size_t words_remaining_in_retired_buffer() {
-G1ParGCAllocBuffer* retired = _priority_buffer[0];
-return retired->words_remaining();
-}
-void flush_stats_and_retire(PLABStats* stats, bool end_of_gc, bool retain) {
-for (int pr = 0; pr < _priority_max; ++pr) {
-_priority_buffer[pr]->flush_stats_and_retire(stats, end_of_gc, retain);
-}
-}
-void update(bool end_of_gc, bool retain, HeapWord* buf, size_t word_sz) {
-G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0];
-retired_and_set->retire(end_of_gc, retain);
-retired_and_set->set_buf(buf);
-retired_and_set->set_word_size(word_sz);
-adjust_priority_order();
-}
-private:
-void adjust_priority_order() {
-G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0];
-int last = _priority_max - 1;
-for (int pr = 0; pr < last; ++pr) {
-_priority_buffer[pr] = _priority_buffer[pr + 1];
-}
-_priority_buffer[last] = retired_and_set;
 }
 };
 class G1ParScanThreadState : public StackObj {
 protected:
 RefToScanQueue*  _refs;
 DirtyCardQueue   _dcq;
 G1SATBCardTableModRefBS* _ct_bs;
 G1RemSet* _g1_rem;
-G1ParGCAllocBufferContainer  _surviving_alloc_buffer;
+G1ParGCAllocBuffer  _surviving_alloc_buffer;
-G1ParGCAllocBufferContainer  _tenured_alloc_buffer;
+G1ParGCAllocBuffer  _tenured_alloc_buffer;
-G1ParGCAllocBufferContainer* _alloc_buffers[GCAllocPurposeCount];
+G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
 ageTable            _age_table;
+G1ParScanClosure    _scanner;
 size_t           _alloc_buffer_waste;
 size_t           _undo_waste;
 OopsInHeapRegionClosure*      _evac_failure_cl;
-G1ParScanHeapEvacClosure*     _evac_cl;
-G1ParScanPartialArrayClosure* _partial_scan_cl;
 int  _hash_seed;
 uint _queue_num;
 size_t _term_attempts;
 void   add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
 DirtyCardQueue& dirty_card_queue()             { return _dcq;  }
 G1SATBCardTableModRefBS* ctbs()                { return _ct_bs; }
-template <class T> void immediate_rs_update(HeapRegion* from, T* p, int tid) {
+template <class T> inline void immediate_rs_update(HeapRegion* from, T* p, int tid);
-if (!from->is_survivor()) {
-_g1_rem->par_write_ref(from, p, tid);
-}
-}
 template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) {
 // If the new value of the field points to the same region or
 // is the to-space, we don't need to include it in the Rset updates.
 if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
 }
 }
 }
 public:
-G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num);
+G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp);
 ~G1ParScanThreadState() {
 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
 }
 RefToScanQueue*   refs()            { return _refs;             }
 ageTable*         age_table()       { return &_age_table;       }
-G1ParGCAllocBufferContainer* alloc_buffer(GCAllocPurpose purpose) {
+G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
 return _alloc_buffers[purpose];
 }
 size_t alloc_buffer_waste() const              { return _alloc_buffer_waste; }
 size_t undo_waste() const                      { return _undo_waste; }
 template <class T> void push_on_queue(T* ref) {
 assert(verify_ref(ref), "sanity");
 refs()->push(ref);
 }
-template <class T> void update_rs(HeapRegion* from, T* p, int tid) {
+template <class T> inline void update_rs(HeapRegion* from, T* p, int tid);
-if (G1DeferredRSUpdate) {
-deferred_rs_update(from, p, tid);
-} else {
-immediate_rs_update(from, p, tid);
-}
-}
 HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
 HeapWord* obj = NULL;
 size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
 if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
-G1ParGCAllocBufferContainer* alloc_buf = alloc_buffer(purpose);
+G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
+add_to_alloc_buffer_waste(alloc_buf->words_remaining());
+alloc_buf->retire(false /* end_of_gc */, false /* retain */);
 HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
 if (buf == NULL) return NULL; // Let caller handle allocation failure.
+// Otherwise.
-add_to_alloc_buffer_waste(alloc_buf->words_remaining_in_retired_buffer());
+alloc_buf->set_word_size(gclab_word_size);
-alloc_buf->update(false /* end_of_gc */, false /* retain */, buf, gclab_word_size);
+alloc_buf->set_buf(buf);
 obj = alloc_buf->allocate(word_sz);
 assert(obj != NULL, "buffer was definitely big enough...");
 } else {
 obj = _g1h->par_allocate_during_gc(purpose, word_sz);
 }
 OopsInHeapRegionClosure* evac_failure_closure() {
 return _evac_failure_cl;
 }
-void set_evac_closure(G1ParScanHeapEvacClosure* evac_cl) {
-_evac_cl = evac_cl;
-}
-void set_partial_scan_closure(G1ParScanPartialArrayClosure* partial_scan_cl) {
-_partial_scan_cl = partial_scan_cl;
-}
 int* hash_seed() { return &_hash_seed; }
 uint queue_num() { return _queue_num; }
 size_t term_attempts() const  { return _term_attempts; }
 void note_term_attempt() { _term_attempts++; }
 _alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
 true /* end_of_gc */,
 false /* retain */);
 }
 }
+private:
-template <class T> void deal_with_reference(T* ref_to_scan) {
+#define G1_PARTIAL_ARRAY_MASK 0x2
-if (has_partial_array_mask(ref_to_scan)) {
-_partial_scan_cl->do_oop_nv(ref_to_scan);
+inline bool has_partial_array_mask(oop* ref) const {
-} else {
+return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
-// Note: we can use "raw" versions of "region_containing" because
+}
-// "obj_to_scan" is definitely in the heap, and is not in a
-// humongous region.
+// We never encode partial array oops as narrowOop*, so return false immediately.
-HeapRegion* r = _g1h->heap_region_containing_raw(ref_to_scan);
+// This allows the compiler to create optimized code when popping references from
-_evac_cl->set_region(r);
+// the work queue.
-_evac_cl->do_oop_nv(ref_to_scan);
+inline bool has_partial_array_mask(narrowOop* ref) const {
+assert(((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) != G1_PARTIAL_ARRAY_MASK, "Partial array oop reference encoded as narrowOop*");
+return false;
+}
+// Only implement set_partial_array_mask() for regular oops, not for narrowOops.
+// We always encode partial arrays as regular oop, to allow the
+// specialization for has_partial_array_mask() for narrowOops above.
+// This means that unintentional use of this method with narrowOops are caught
+// by the compiler.
+inline oop* set_partial_array_mask(oop obj) const {
+assert(((uintptr_t)(void *)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
+return (oop*) ((uintptr_t)(void *)obj | G1_PARTIAL_ARRAY_MASK);
+}
+inline oop clear_partial_array_mask(oop* ref) const {
+return cast_to_oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
+}
+inline void do_oop_partial_array(oop* p);
+// This method is applied to the fields of the objects that have just been copied.
+template <class T> void do_oop_evac(T* p, HeapRegion* from) {
+assert(!oopDesc::is_null(oopDesc::load_decode_heap_oop(p)),
+"Reference should not be NULL here as such are never pushed to the task queue.");
+oop obj = oopDesc::load_decode_heap_oop_not_null(p);
+// Although we never intentionally push references outside of the collection
+// set, due to (benign) races in the claim mechanism during RSet scanning more
+// than one thread might claim the same card. So the same card may be
+// processed multiple times. So redo this check.
+if (_g1h->in_cset_fast_test(obj)) {
+oop forwardee;
+if (obj->is_forwarded()) {
+forwardee = obj->forwardee();
+} else {
+forwardee = copy_to_survivor_space(obj);
+}
+assert(forwardee != NULL, "forwardee should not be NULL");
+oopDesc::encode_store_heap_oop(p, forwardee);
 }
-}
+assert(obj != NULL, "Must be");
-void deal_with_reference(StarTask ref) {
+update_rs(from, p, queue_num());
-assert(verify_task(ref), "sanity");
+}
-if (ref.is_narrow()) {
+public:
-deal_with_reference((narrowOop*)ref);
-} else {
+oop copy_to_survivor_space(oop const obj);
-deal_with_reference((oop*)ref);
-}
+template <class T> inline void deal_with_reference(T* ref_to_scan);
-}
+inline void deal_with_reference(StarTask ref);
+public:
 void trim_queue();
 };
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 18041:52b4284cb496