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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 1709:5f429ee79634

6966222: G1: simplify TaskQueue overflow handling Reviewed-by: tonyp, ysr

author	jcoomes
date	Mon, 09 Aug 2010 05:41:05 -0700
parents	2d160770d2e5
children	bb847e31b836

comparison

equal deleted inserted replaced

-:a03ae377b2e8
+:5f429ee79634
 class ConcurrentMark;
 class ConcurrentMarkThread;
 class ConcurrentG1Refine;
 class ConcurrentZFThread;
-// If want to accumulate detailed statistics on work queues
+typedef OverflowTaskQueue<StarTask>         RefToScanQueue;
-// turn this on.
-#define G1_DETAILED_STATS 0
-#if G1_DETAILED_STATS
-#  define IF_G1_DETAILED_STATS(code) code
-#else
-#  define IF_G1_DETAILED_STATS(code)
-#endif
-typedef GenericTaskQueue<StarTask>          RefToScanQueue;
 typedef GenericTaskQueueSet<RefToScanQueue> RefToScanQueueSet;
 typedef int RegionIdx_t;   // needs to hold [ 0..max_regions() )
 typedef int CardIdx_t;     // needs to hold [ 0..CardsPerRegion )
 // 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 shrink_helper(size_t expand_bytes);
+#if TASKQUEUE_STATS
+static void print_taskqueue_stats_hdr(outputStream* const st = gclog_or_tty);
+void print_taskqueue_stats(outputStream* const st = gclog_or_tty) const;
+void reset_taskqueue_stats();
+#endif // TASKQUEUE_STATS
 // Do an incremental collection: identify a collection set, and evacuate
 // its live objects elsewhere.
 virtual void do_collection_pause();
 // The guts of the incremental collection pause, executed by the vm
 bool _unclean_regions_coming;
 public:
 void set_refine_cte_cl_concurrency(bool concurrent);
-RefToScanQueue *task_queue(int i);
+RefToScanQueue *task_queue(int i) const;
 // A set of cards where updates happened during the GC
 DirtyCardQueueSet& dirty_card_queue_set() { return _dirty_card_queue_set; }
 // A DirtyCardQueueSet that is used to hold cards that contain
 RefToScanQueue*  _refs;
 DirtyCardQueue   _dcq;
 CardTableModRefBS* _ct_bs;
 G1RemSet* _g1_rem;
-typedef GrowableArray<StarTask> OverflowQueue;
-OverflowQueue* _overflowed_refs;
 G1ParGCAllocBuffer  _surviving_alloc_buffer;
 G1ParGCAllocBuffer  _tenured_alloc_buffer;
 G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
 ageTable            _age_table;
 int _hash_seed;
 int _queue_num;
 size_t _term_attempts;
-#if G1_DETAILED_STATS
-int _pushes, _pops, _steals, _steal_attempts;
-int _overflow_pushes;
-#endif
 double _start;
 double _start_strong_roots;
 double _strong_roots_time;
 double _start_term;
 // surviving words. base is what we get back from the malloc call
 size_t* _surviving_young_words_base;
 // this points into the array, as we use the first few entries for padding
 size_t* _surviving_young_words;
-#define PADDING_ELEM_NUM (64 / sizeof(size_t))
+#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
 void   add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
 void   add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
 ~G1ParScanThreadState() {
 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base);
 }
 RefToScanQueue*   refs()            { return _refs;             }
-OverflowQueue*    overflowed_refs() { return _overflowed_refs;  }
 ageTable*         age_table()       { return &_age_table;       }
 G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
 return _alloc_buffers[purpose];
 }
-size_t alloc_buffer_waste()                    { return _alloc_buffer_waste; }
+size_t alloc_buffer_waste() const              { return _alloc_buffer_waste; }
-size_t undo_waste()                            { return _undo_waste; }
+size_t undo_waste() const                      { return _undo_waste; }
 template <class T> void push_on_queue(T* ref) {
 assert(ref != NULL, "invariant");
 assert(has_partial_array_mask(ref) ||
 _g1h->is_in_g1_reserved(oopDesc::load_decode_heap_oop(ref)), "invariant");
 oop p = clear_partial_array_mask(ref);
 // Verify that we point into the CS
 assert(_g1h->obj_in_cs(p), "Should be in CS");
 }
 #endif
-if (!refs()->push(ref)) {
+refs()->push(ref);
-overflowed_refs()->push(ref);
-IF_G1_DETAILED_STATS(note_overflow_push());
-} else {
-IF_G1_DETAILED_STATS(note_push());
-}
 }
 void pop_from_queue(StarTask& ref) {
 if (refs()->pop_local(ref)) {
 assert((oop*)ref != NULL, "pop_local() returned true");
 assert(UseCompressedOops || !ref.is_narrow(), "Error");
 assert(has_partial_array_mask((oop*)ref) ||
 _g1h->is_in_g1_reserved(ref.is_narrow() ? oopDesc::load_decode_heap_oop((narrowOop*)ref)
 : oopDesc::load_decode_heap_oop((oop*)ref)),
 "invariant");
-IF_G1_DETAILED_STATS(note_pop());
 } else {
 StarTask null_task;
 ref = null_task;
 }
 }
 void pop_from_overflow_queue(StarTask& ref) {
-StarTask new_ref = overflowed_refs()->pop();
+StarTask new_ref;
+refs()->pop_overflow(new_ref);
 assert((oop*)new_ref != NULL, "pop() from a local non-empty stack");
 assert(UseCompressedOops || !new_ref.is_narrow(), "Error");
 assert(has_partial_array_mask((oop*)new_ref) ||
 _g1h->is_in_g1_reserved(new_ref.is_narrow() ? oopDesc::load_decode_heap_oop((narrowOop*)new_ref)
 : oopDesc::load_decode_heap_oop((oop*)new_ref)),
 "invariant");
 ref = new_ref;
 }
-int refs_to_scan()                             { return refs()->size();                 }
+int refs_to_scan()            { return refs()->size(); }
-int overflowed_refs_to_scan()                  { return overflowed_refs()->length();    }
+int overflowed_refs_to_scan() { return refs()->overflow_stack()->length(); }
 template <class T> void update_rs(HeapRegion* from, T* p, int tid) {
 if (G1DeferredRSUpdate) {
 deferred_rs_update(from, p, tid);
 } else {
 }
 int* hash_seed() { return &_hash_seed; }
 int  queue_num() { return _queue_num; }
-size_t term_attempts()   { return _term_attempts; }
+size_t term_attempts() const  { return _term_attempts; }
 void note_term_attempt() { _term_attempts++; }
-#if G1_DETAILED_STATS
-int pushes()          { return _pushes; }
-int pops()            { return _pops; }
-int steals()          { return _steals; }
-int steal_attempts()  { return _steal_attempts; }
-int overflow_pushes() { return _overflow_pushes; }
-void note_push()          { _pushes++; }
-void note_pop()           { _pops++; }
-void note_steal()         { _steals++; }
-void note_steal_attempt() { _steal_attempts++; }
-void note_overflow_push() { _overflow_pushes++; }
-#endif
 void start_strong_roots() {
 _start_strong_roots = os::elapsedTime();
 }
 void end_strong_roots() {
 _strong_roots_time += (os::elapsedTime() - _start_strong_roots);
 }
-double strong_roots_time() { return _strong_roots_time; }
+double strong_roots_time() const { return _strong_roots_time; }
 void start_term_time() {
 note_term_attempt();
 _start_term = os::elapsedTime();
 }
 void end_term_time() {
 _term_time += (os::elapsedTime() - _start_term);
 }
-double term_time() { return _term_time; }
+double term_time() const { return _term_time; }
-double elapsed() {
+double elapsed_time() const {
 return os::elapsedTime() - _start;
 }
+static void
+print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
+void
+print_termination_stats(int i, outputStream* const st = gclog_or_tty) const;
 size_t* surviving_young_words() {
 // We add on to hide entry 0 which accumulates surviving words for
 // age -1 regions (i.e. non-young ones)
 return _surviving_young_words;

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 1709:5f429ee79634