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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	89e4d67fdd2a f2110083203d
children	6b0fd0964b87

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 /*
-* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2013, 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.
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #include "gc_implementation/g1/concurrentMark.hpp"
+#include "gc_implementation/g1/evacuationInfo.hpp"
 #include "gc_implementation/g1/g1AllocRegion.hpp"
 #include "gc_implementation/g1/g1HRPrinter.hpp"
+#include "gc_implementation/g1/g1MonitoringSupport.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
-#include "gc_implementation/g1/g1MonitoringSupport.hpp"
+#include "gc_implementation/g1/g1YCTypes.hpp"
 #include "gc_implementation/g1/heapRegionSeq.hpp"
 #include "gc_implementation/g1/heapRegionSets.hpp"
 #include "gc_implementation/shared/hSpaceCounters.hpp"
 #include "gc_implementation/shared/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 class G1RemSet;
 class HeapRegionRemSetIterator;
 class ConcurrentMark;
 class ConcurrentMarkThread;
 class ConcurrentG1Refine;
+class ConcurrentGCTimer;
 class GenerationCounters;
+class STWGCTimer;
+class G1NewTracer;
+class G1OldTracer;
+class EvacuationFailedInfo;
 typedef OverflowTaskQueue<StarTask, mtGC>         RefToScanQueue;
 typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
 typedef int RegionIdx_t;   // needs to hold [ 0..max_regions() )
 // The G1 STW is alive closure.
 // An instance is embedded into the G1CH and used as the
 // (optional) _is_alive_non_header closure in the STW
 // reference processor. It is also extensively used during
-// refence processing during STW evacuation pauses.
+// reference 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 SurvivorGCAllocRegion : public G1AllocRegion {
 protected:
 // It releases the mutator alloc region.
 void release_mutator_alloc_region();
 // It initializes the GC alloc regions at the start of a GC.
-void init_gc_alloc_regions();
+void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
 // It releases the GC alloc regions at the end of a GC.
-void release_gc_alloc_regions(uint no_of_gc_workers);
+void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
 // It does any cleanup that needs to be done on the GC alloc regions
 // before a Full GC.
 void abandon_gc_alloc_regions();
 volatile unsigned int _old_marking_cycles_started;
 // Keeps track of how many "old marking cycles" (i.e., Full GCs or
 // concurrent cycles) we have completed.
 volatile unsigned int _old_marking_cycles_completed;
+bool _concurrent_cycle_started;
 // This is a non-product method that is helpful for testing. It is
 // called at the end of a GC and artificially expands the heap by
 // allocating a number of dead regions. This way we can induce very
 // frequent marking cycles and stress the cleanup / concurrent
 // 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.
 unsigned int old_marking_cycles_completed() {
 return _old_marking_cycles_completed;
 }
+void register_concurrent_cycle_start(jlong start_time);
+void register_concurrent_cycle_end();
+void trace_heap_after_concurrent_cycle();
+G1YCType yc_type();
 G1HRPrinter* hr_printer() { return &_hr_printer; }
 protected:
 // Shrink the garbage-first heap by at most the given size (in bytes!).
 // thread. It returns false if it is unable to do the collection due
 // to the GC locker being active, true otherwise
 bool do_collection_pause_at_safepoint(double target_pause_time_ms);
 // Actually do the work of evacuating the collection set.
-void evacuate_collection_set();
+void evacuate_collection_set(EvacuationInfo& evacuation_info);
 // The g1 remembered set of the heap.
 G1RemSet* _g1_rem_set;
 // And it's mod ref barrier set, used to track updates for the above.
 ModRefBarrierSet* _mr_bs;
 // A set of cards that cover the objects for which the Rsets should be updated
 // concurrently after the collection.
 DirtyCardQueueSet _dirty_card_queue_set;
-// The Heap Region Rem Set Iterator.
-HeapRegionRemSetIterator** _rem_set_iterator;
 // The closure used to refine a single card.
 RefineCardTableEntryClosure* _refine_cte_cl;
 // A function to check the consistency of dirty card logs.
 // set in the event of an evacuation failure.
 DirtyCardQueueSet _into_cset_dirty_card_queue_set;
 // After a collection pause, make the regions in the CS into free
 // regions.
-void free_collection_set(HeapRegion* cs_head);
+void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info);
 // Abandon the current collection set without recording policy
 // statistics or updating free lists.
 void abandon_collection_set(HeapRegion* cs_head);
 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,
+void g1_process_weak_roots(OopClosure* root_closure);
-OopClosure* non_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
 RefToScanQueueSet *_task_queues;
 // True iff a evacuation has failed in the current collection.
 bool _evacuation_failed;
-// Set the attribute indicating whether evacuation has failed in the
+EvacuationFailedInfo* _evacuation_failed_info_array;
-// current collection.
-void set_evacuation_failed(bool b) { _evacuation_failed = b; }
 // Failed evacuations cause some logical from-space objects to have
 // forwarding pointers to themselves.  Reset them.
 void remove_self_forwarding_pointers();
 // Do any necessary cleanup for evacuation-failure handling data
 // structures.
 void finalize_for_evac_failure();
 // An attempt to evacuate "obj" has failed; take necessary steps.
-oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj);
+oop handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state, oop obj);
 void handle_evacuation_failure_common(oop obj, markOop m);
 #ifndef PRODUCT
 // Support for forcing evacuation failures. Analogous to
 // PromotionFailureALot for the other collectors.
 // Return true if it's time to cause an evacuation failure.
 inline bool evacuation_should_fail();
 // Reset the G1EvacuationFailureALot counters.  Should be called at
-// the end of an evacuation pause in which an evacuation failure ocurred.
+// the end of an evacuation pause in which an evacuation failure occurred.
 inline void reset_evacuation_should_fail();
 #endif // !PRODUCT
 // ("Weak") Reference processing support.
 //
-// G1 has 2 instances of the referece processor class. One
+// G1 has 2 instances of the reference 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
 //    lists (also checked as a precondition during initial marking).
 // The (stw) reference processor...
 ReferenceProcessor* _ref_processor_stw;
+STWGCTimer* _gc_timer_stw;
+ConcurrentGCTimer* _gc_timer_cm;
+G1OldTracer* _gc_tracer_cm;
+G1NewTracer* _gc_tracer_stw;
 // During reference object discovery, the _is_alive_non_header
 // closure (if non-null) is applied to the referent object to
 // determine whether the referent is live. If so then the
 // reference object does not need to be 'discovered' and can
 // be treated as a regular oop. This has the benefit of reducing
 // The rem set and barrier set.
 G1RemSet* g1_rem_set() const { return _g1_rem_set; }
 ModRefBarrierSet* mr_bs() const { return _mr_bs; }
-// The rem set iterator.
-HeapRegionRemSetIterator* rem_set_iterator(int i) {
-return _rem_set_iterator[i];
-}
-HeapRegionRemSetIterator* rem_set_iterator() {
-return _rem_set_iterator[0];
-}
 unsigned get_gc_time_stamp() {
 return _gc_time_stamp;
 }
 void reset_gc_time_stamp() {
 // Reference Processing accessors
 // The STW reference processor....
 ReferenceProcessor* ref_processor_stw() const { return _ref_processor_stw; }
-// The Concurent Marking reference processor...
+// The Concurrent Marking reference processor...
 ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
+ConcurrentGCTimer* gc_timer_cm() const { return _gc_timer_cm; }
+G1OldTracer* gc_tracer_cm() const { return _gc_tracer_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.
 // necessary (i.e., during heap verification).
 void verify_region_sets();
 // verify_region_sets_optional() is planted in the code for
 // list verification in non-product builds (and it can be enabled in
-// product builds by definning HEAP_REGION_SET_FORCE_VERIFY to be 1).
+// product builds by defining HEAP_REGION_SET_FORCE_VERIFY to be 1).
 #if HEAP_REGION_SET_FORCE_VERIFY
 void verify_region_sets_optional() {
 verify_region_sets();
 }
 #else // HEAP_REGION_SET_FORCE_VERIFY
 virtual void collect(GCCause::Cause cause);
 // The same as above but assume that the caller holds the Heap_lock.
 void collect_locked(GCCause::Cause cause);
-// True iff a evacuation has failed in the most-recent collection.
+// 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
 // all dead. It calls either free_region() or
 // free_humongous_region() depending on the type of the region that
 // full GC.
 void verify(bool silent, VerifyOption vo);
 // Override; it uses the "prev" marking information
 virtual void verify(bool silent);
 virtual void print_on(outputStream* st) const;
 virtual void print_extended_on(outputStream* st) const;
 virtual void print_on_error(outputStream* st) const;
 virtual void print_gc_threads_on(outputStream* st) const;
 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;
 CardTableModRefBS* _ct_bs;
 G1RemSet* _g1_rem;
-G1ParGCAllocBuffer  _surviving_alloc_buffer;
+G1ParGCAllocBufferContainer  _surviving_alloc_buffer;
-G1ParGCAllocBuffer  _tenured_alloc_buffer;
+G1ParGCAllocBufferContainer  _tenured_alloc_buffer;
-G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
+G1ParGCAllocBufferContainer* _alloc_buffers[GCAllocPurposeCount];
 ageTable            _age_table;
 size_t           _alloc_buffer_waste;
 size_t           _undo_waste;
 OopsInHeapRegionClosure*      _evac_failure_cl;
 G1ParScanHeapEvacClosure*     _evac_cl;
 G1ParScanPartialArrayClosure* _partial_scan_cl;
-int _hash_seed;
+int  _hash_seed;
 uint _queue_num;
 size_t _term_attempts;
 double _start;
 }
 RefToScanQueue*   refs()            { return _refs;             }
 ageTable*         age_table()       { return &_age_table;       }
-G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
+G1ParGCAllocBufferContainer* 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) {
-G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
+G1ParGCAllocBufferContainer* 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.
-alloc_buf->set_word_size(gclab_word_size);
+add_to_alloc_buffer_waste(alloc_buf->words_remaining_in_retired_buffer());
-alloc_buf->set_buf(buf);
+alloc_buf->update(false /* end_of_gc */, false /* retain */, buf, gclab_word_size);
 obj = alloc_buf->allocate(word_sz);
 assert(obj != NULL, "buffer was definitely big enough...");
 } else {
 obj = _g1h->par_allocate_during_gc(purpose, word_sz);
 } else {
 deal_with_reference((oop*)ref);
 }
 }
-public:
 void trim_queue();
 };
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 10408:836a62f43af9