jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp

equal deleted inserted replaced

-:90e562b9f1cc
+:dce68ee3d184
 &_to_space_root_closure, gen_, &_old_gen_root_closure,
 work_queue_set_, &term_),
 _is_alive_closure(gen_), _scan_weak_ref_closure(gen_, this),
 _keep_alive_closure(&_scan_weak_ref_closure),
 _promotion_failure_size(0),
-_pushes(0), _pops(0), _steals(0), _steal_attempts(0), _term_attempts(0),
 _strong_roots_time(0.0), _term_time(0.0)
 {
+#if TASKQUEUE_STATS
+_term_attempts = 0;
+_overflow_refills = 0;
+_overflow_refill_objs = 0;
+#endif // TASKQUEUE_STATS
 _survivor_chunk_array =
 (ChunkArray*) old_gen()->get_data_recorder(thread_num());
 _hash_seed = 17;  // Might want to take time-based random value.
 _start = os::elapsedTime();
 _old_gen_closure.set_generation(old_gen_);
 end = start + ParGCArrayScanChunk;
 arrayOop(old)->set_length(end);
 // Push remainder.
 bool ok = work_queue()->push(old);
 assert(ok, "just popped, push must be okay");
-note_push();
 } else {
 // Restore length so that it can be used if there
 // is a promotion failure and forwarding pointers
 // must be removed.
 arrayOop(old)->set_length(end);
 ObjToScanQueue* queue = work_queue();
 do {
 while (queue->size() > (juint)max_size) {
 oop obj_to_scan;
 if (queue->pop_local(obj_to_scan)) {
-note_pop();
 if ((HeapWord *)obj_to_scan < young_old_boundary()) {
 if (obj_to_scan->is_objArray() &&
 obj_to_scan->is_forwarded() &&
 obj_to_scan->forwardee() != obj_to_scan) {
 scan_partial_array_and_push_remainder(obj_to_scan);
 Generation&             old_gen,
 ObjToScanQueueSet&      queue_set,
 GrowableArray<oop>**    overflow_stacks_,
 size_t                  desired_plab_sz,
 ParallelTaskTerminator& term);
+~ParScanThreadStateSet() { TASKQUEUE_STATS_ONLY(reset_stats()); }
 inline ParScanThreadState& thread_state(int i);
-int pushes() { return _pushes; }
-int pops()   { return _pops; }
-int steals() { return _steals; }
 void reset(bool promotion_failed);
 void flush();
+#if TASKQUEUE_STATS
+static void
+print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
+void print_termination_stats(outputStream* const st = gclog_or_tty);
+static void
+print_taskqueue_stats_hdr(outputStream* const st = gclog_or_tty);
+void print_taskqueue_stats(outputStream* const st = gclog_or_tty);
+void reset_stats();
+#endif // TASKQUEUE_STATS
 private:
 ParallelTaskTerminator& _term;
 ParNewGeneration&       _gen;
 Generation&             _next_gen;
-// staticstics
-int _pushes;
-int _pops;
-int _steals;
 };
 ParScanThreadStateSet::ParScanThreadStateSet(
 int num_threads, Space& to_space, ParNewGeneration& gen,
 Generation& old_gen, ObjToScanQueueSet& queue_set,
 GrowableArray<oop>** overflow_stack_set_,
 size_t desired_plab_sz, ParallelTaskTerminator& term)
 : ResourceArray(sizeof(ParScanThreadState), num_threads),
-_gen(gen), _next_gen(old_gen), _term(term),
+_gen(gen), _next_gen(old_gen), _term(term)
-_pushes(0), _pops(0), _steals(0)
 {
 assert(num_threads > 0, "sanity check!");
 // Initialize states.
 for (int i = 0; i < num_threads; ++i) {
 new ((ParScanThreadState*)_data + i)
 thread_state(i).print_and_clear_promotion_failure_size();
 }
 }
 }
+#if TASKQUEUE_STATS
+void
+ParScanThreadState::reset_stats()
+{
+taskqueue_stats().reset();
+_term_attempts = 0;
+_overflow_refills = 0;
+_overflow_refill_objs = 0;
+}
+void ParScanThreadStateSet::reset_stats()
+{
+for (int i = 0; i < length(); ++i) {
+thread_state(i).reset_stats();
+}
+}
+void
+ParScanThreadStateSet::print_termination_stats_hdr(outputStream* const st)
+{
+st->print_raw_cr("GC Termination Stats");
+st->print_raw_cr("     elapsed  --strong roots-- "
+"-------termination-------");
+st->print_raw_cr("thr     ms        ms       %   "
+"    ms       %   attempts");
+st->print_raw_cr("--- --------- --------- ------ "
+"--------- ------ --------");
+}
+void ParScanThreadStateSet::print_termination_stats(outputStream* const st)
+{
+print_termination_stats_hdr(st);
+for (int i = 0; i < length(); ++i) {
+const ParScanThreadState & pss = thread_state(i);
+const double elapsed_ms = pss.elapsed_time() * 1000.0;
+const double s_roots_ms = pss.strong_roots_time() * 1000.0;
+const double term_ms = pss.term_time() * 1000.0;
+st->print_cr("%3d %9.2f %9.2f %6.2f "
+"%9.2f %6.2f " SIZE_FORMAT_W(8),
+i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms,
+term_ms, term_ms * 100 / elapsed_ms, pss.term_attempts());
+}
+}
+// Print stats related to work queue activity.
+void ParScanThreadStateSet::print_taskqueue_stats_hdr(outputStream* const st)
+{
+st->print_raw_cr("GC Task Stats");
+st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr();
+st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr();
+}
+void ParScanThreadStateSet::print_taskqueue_stats(outputStream* const st)
+{
+print_taskqueue_stats_hdr(st);
+TaskQueueStats totals;
+for (int i = 0; i < length(); ++i) {
+const ParScanThreadState & pss = thread_state(i);
+const TaskQueueStats & stats = pss.taskqueue_stats();
+st->print("%3d ", i); stats.print(st); st->cr();
+totals += stats;
+if (pss.overflow_refills() > 0) {
+st->print_cr("    " SIZE_FORMAT_W(10) " overflow refills    "
+SIZE_FORMAT_W(10) " overflow objects",
+pss.overflow_refills(), pss.overflow_refill_objs());
+}
+}
+st->print("tot "); totals.print(st); st->cr();
+DEBUG_ONLY(totals.verify());
+}
+#endif // TASKQUEUE_STATS
 void ParScanThreadStateSet::flush()
 {
 // Work in this loop should be kept as lightweight as
 // possible since this might otherwise become a bottleneck
 // to scaling. Should we add heavy-weight work into this
 _gen.age_table()->merge(local_table);
 // Inform old gen that we're done.
 _next_gen.par_promote_alloc_done(i);
 _next_gen.par_oop_since_save_marks_iterate_done(i);
+}
-// Flush stats related to work queue activity (push/pop/steal)
-// This could conceivably become a bottleneck; if so, we'll put the
-// stat's gathering under the flag.
-if (PAR_STATS_ENABLED) {
-_pushes += par_scan_state.pushes();
-_pops   += par_scan_state.pops();
-_steals += par_scan_state.steals();
-if (ParallelGCVerbose) {
-gclog_or_tty->print("Thread %d complete:\n"
-"  Pushes: %7d    Pops: %7d    Steals %7d (in %d attempts)\n",
-i, par_scan_state.pushes(), par_scan_state.pops(),
-par_scan_state.steals(), par_scan_state.steal_attempts());
-if (par_scan_state.overflow_pushes() > 0 ||
-par_scan_state.overflow_refills() > 0) {
-gclog_or_tty->print("  Overflow pushes: %7d    "
-"Overflow refills: %7d for %d objs.\n",
-par_scan_state.overflow_pushes(),
-par_scan_state.overflow_refills(),
-par_scan_state.overflow_refill_objs());
-}
-double elapsed = par_scan_state.elapsed();
-double strong_roots = par_scan_state.strong_roots_time();
-double term = par_scan_state.term_time();
-gclog_or_tty->print(
-"  Elapsed: %7.2f ms.\n"
-"    Strong roots: %7.2f ms (%6.2f%%)\n"
-"    Termination:  %7.2f ms (%6.2f%%) (in %d entries)\n",
-elapsed * 1000.0,
-strong_roots * 1000.0, (strong_roots*100.0/elapsed),
-term * 1000.0, (term*100.0/elapsed),
-par_scan_state.term_attempts());
-}
-}
-}
 if (UseConcMarkSweepGC && ParallelGCThreads > 0) {
 // We need to call this even when ResizeOldPLAB is disabled
 // so as to avoid breaking some asserts. While we may be able
 // to avoid this by reorganizing the code a bit, I am loathe
 // to do that unless we find cases where ergo leads to bad
 par_scan_state()->trim_queues(0);
 // We have no local work, attempt to steal from other threads.
 // attempt to steal work from promoted.
-par_scan_state()->note_steal_attempt();
 if (task_queues()->steal(par_scan_state()->thread_num(),
 par_scan_state()->hash_seed(),
 obj_to_scan)) {
-par_scan_state()->note_steal();
 bool res = work_q->push(obj_to_scan);
 assert(res, "Empty queue should have room for a push.");
-par_scan_state()->note_push();
 //   if successful, goto Start.
 continue;
 // try global overflow list.
 } else if (par_gen()->take_from_overflow_list(par_scan_state())) {
 } else {
 GenCollectedHeap::StrongRootsScope srs(gch);
 tsk.work(0);
 }
 thread_state_set.reset(promotion_failed());
-if (PAR_STATS_ENABLED && ParallelGCVerbose) {
-gclog_or_tty->print("Thread totals:\n"
-"  Pushes: %7d    Pops: %7d    Steals %7d (sum = %7d).\n",
-thread_state_set.pushes(), thread_state_set.pops(),
-thread_state_set.steals(),
-thread_state_set.pops()+thread_state_set.steals());
-}
-assert(thread_state_set.pushes() == thread_state_set.pops()
-+ thread_state_set.steals(),
-"Or else the queues are leaky.");
 // Process (weak) reference objects found during scavenge.
 ReferenceProcessor* rp = ref_processor();
 IsAliveClosure is_alive(this);
 ScanWeakRefClosure scan_weak_ref(this);
 if (PrintGC && !PrintGCDetails) {
 gch->print_heap_change(gch_prev_used);
 }
+TASKQUEUE_STATS_ONLY(thread_state_set.print_termination_stats());
+TASKQUEUE_STATS_ONLY(thread_state_set.print_taskqueue_stats());
 if (UseAdaptiveSizePolicy) {
 size_policy->minor_collection_end(gch->gc_cause());
 size_policy->avg_survived()->sample(from()->used());
 }
 // Add stats for overflow pushes.
 if (Verbose && PrintGCDetails) {
 gclog_or_tty->print("queue overflow!\n");
 }
 push_on_overflow_list(old, par_scan_state);
-par_scan_state->note_overflow_push();
+TASKQUEUE_STATS_ONLY(par_scan_state->taskqueue_stats().record_overflow(0));
 }
-par_scan_state->note_push();
 return new_obj;
 }
 // Oops.  Someone beat us to it.  Undo the allocation.  Where did we
 }
 )
 if (simulate_overflow || !par_scan_state->work_queue()->push(obj_to_push)) {
 // Add stats for overflow pushes.
 push_on_overflow_list(old, par_scan_state);
-par_scan_state->note_overflow_push();
+TASKQUEUE_STATS_ONLY(par_scan_state->taskqueue_stats().record_overflow(0));
 }
-par_scan_state->note_push();
 return new_obj;
 }
 // Oops.  Someone beat us to it.  Undo the allocation.  Where did we
 bool ok = work_q->push(obj_to_push);
 assert(ok, "Should have succeeded");
 cur = next;
 n++;
 }
-par_scan_state->note_overflow_refill(n);
+TASKQUEUE_STATS_ONLY(par_scan_state->note_overflow_refill(n));
 #ifndef PRODUCT
 assert(_num_par_pushes >= n, "Too many pops?");
 Atomic::add_ptr(-(intptr_t)n, &_num_par_pushes);
 #endif
 return true;

changeset 6252	dce68ee3d184
parent 6067	8bfddf73fc04
child 6254	71523cbc990c