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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	02f27ecb4f3a 60fd6d24f49f
children	4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 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;
 // 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) {
 assert(_in_cset_fast_test != NULL, "sanity");
-if (_g1_committed.contains((HeapWord*) obj)) {
+assert(_g1_committed.contains((HeapWord*) obj), err_msg("Given reference outside of heap, is "PTR_FORMAT, (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,
 ScanningOption so,
 OopClosure* scan_non_heap_roots,
 OopsInHeapRegionClosure* scan_rs,
 G1KlassScanClosure* scan_klasses,
 int 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
 // Some heaps may offer a contiguous region for shared non-blocking
 // allocation, via inlined code (by exporting the address of the top and
 // end fields defining the extent of the contiguous allocation region.)
 // But G1CollectedHeap doesn't yet support this.
-// Return an estimate of the maximum allocation that could be performed
-// without triggering any collection or expansion activity.  In a
-// generational collector, for example, this is probably the largest
-// allocation that could be supported (without expansion) in the youngest
-// generation.  It is "unsafe" because no locks are taken; the result
-// should be treated as an approximation, not a guarantee, for use in
-// heuristic resizing decisions.
-virtual size_t unsafe_max_alloc();
 virtual bool is_maximal_no_gc() const {
 return _g1_storage.uncommitted_size() == 0;
 }
 // The total number of regions in the heap.
 HeapRegion* region_at(uint index) const { return _hrs.at(index); }
 // 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
+// in parallel by ParallelGCThreads worker threads with distinct worker
 // ids in the range [0..max(ParallelGCThreads-1, 1)], that all parallel
 // calls will use the same "claim_value", and that that claim value is
 // different from the claim_value of any heap region before the start of
 // the iteration.  Applies "blk->doHeapRegion" to each of the regions, by
 // attempting to claim the first region in each chunk, and, if
 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
 }
 // 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
+// are capped at the humongous threshold and we want to
 // ensure that we don't try to allocate a TLAB as
 // humongous and that we don't allocate a humongous
 // object in a TLAB.
 return word_size > _humongous_object_threshold_in_words;
 }
 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();
 }
 void push_dirty_cards_region(HeapRegion* hr);
 HeapRegion* pop_dirty_cards_region();
 // Optimized nmethod scanning support routines
-// Register the given nmethod with the G1 heap
+// Register the given nmethod with the G1 heap.
 virtual void register_nmethod(nmethod* nm);
-// Unregister the given nmethod from the G1 heap
+// Unregister the given nmethod from the G1 heap.
 virtual void unregister_nmethod(nmethod* nm);
 // Migrate the nmethods in the code root lists of the regions
 // 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.
+// that were not successfully evacuated are not migrated.
 void migrate_strong_code_roots();
 // 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
+// Rebuild the strong code root lists for each region
-// after a full GC
+// 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);
 // Verification
 // The following is just to alert the verification code
 // that a full collection has occurred and that the
 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:
 G1CollectedHeap* _g1h;
 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;
 }
 }
 }
 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; }
 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);
 _alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
 true /* end_of_gc */,
 false /* retain */);
 }
 }
+oop copy_to_survivor_space(oop const obj);
 template <class T> void deal_with_reference(T* ref_to_scan) {
 if (has_partial_array_mask(ref_to_scan)) {
 _partial_scan_cl->do_oop_nv(ref_to_scan);
 } else {
 } else {
 deal_with_reference((oop*)ref);
 }
 }
+public:
 void trim_queue();
 };
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 14518:d8041d695d19