graal-jvmci-8: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp comparison

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 20190:0982ec23da03

8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps Reviewed-by: jwilhelm, ehelin, tschatzl

author	brutisso
date	Thu, 19 Jun 2014 13:31:14 +0200
parents	8e20ef014b08
children	ce8f6bb717c9

comparison

equal deleted inserted replaced

-:5d855d021755
+:0982ec23da03
 gc_timer->register_gc_start();
 SerialOldTracer* gc_tracer = GenMarkSweep::gc_tracer();
 gc_tracer->report_gc_start(gch->gc_cause(), gc_timer->gc_start());
-GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL);
+GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL, gc_tracer->gc_id());
 if (PrintGC && Verbose && !(GCCause::is_user_requested_gc(gch->gc_cause()))) {
 gclog_or_tty->print_cr("Compact ConcurrentMarkSweepGeneration after %d "
 "collections passed to foreground collector", _full_gcs_since_conc_gc);
 }
 assert(Thread::current()->is_VM_thread(), "A foreground collection"
 "may only be done by the VM Thread with the world stopped");
 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(),
 "VM thread should have CMS token");
+// The gc id is created in register_foreground_gc_start if this collection is synchronous
+const GCId gc_id = _collectorState == InitialMarking ? GCId::peek() : _gc_tracer_cm->gc_id();
 NOT_PRODUCT(GCTraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose,
-true, NULL);)
+true, NULL, gc_id);)
 if (UseAdaptiveSizePolicy) {
 size_policy()->ms_collection_begin();
 }
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact);
 // phases.
 class CMSPhaseAccounting: public StackObj {
 public:
 CMSPhaseAccounting(CMSCollector *collector,
 const char *phase,
+const GCId gc_id,
 bool print_cr = true);
 ~CMSPhaseAccounting();
 private:
 CMSCollector *_collector;
 const char *_phase;
 elapsedTimer _wallclock;
 bool _print_cr;
+const GCId _gc_id;
 public:
 // Not MT-safe; so do not pass around these StackObj's
 // where they may be accessed by other threads.
 jlong wallclock_millis() {
 }
 };
 CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector,
 const char *phase,
+const GCId gc_id,
 bool print_cr) :
-_collector(collector), _phase(phase), _print_cr(print_cr) {
+_collector(collector), _phase(phase), _print_cr(print_cr), _gc_id(gc_id) {
 if (PrintCMSStatistics != 0) {
 _collector->resetYields();
 }
 if (PrintGCDetails) {
-gclog_or_tty->date_stamp(PrintGCDateStamps);
+gclog_or_tty->gclog_stamp(_gc_id);
-gclog_or_tty->stamp(PrintGCTimeStamps);
 gclog_or_tty->print_cr("[%s-concurrent-%s-start]",
 _collector->cmsGen()->short_name(), _phase);
 }
 _collector->resetTimer();
 _wallclock.start();
 CMSPhaseAccounting::~CMSPhaseAccounting() {
 assert(_wallclock.is_active(), "Wall clock should not have stopped");
 _collector->stopTimer();
 _wallclock.stop();
 if (PrintGCDetails) {
-gclog_or_tty->date_stamp(PrintGCDateStamps);
+gclog_or_tty->gclog_stamp(_gc_id);
-gclog_or_tty->stamp(PrintGCTimeStamps);
 gclog_or_tty->print("[%s-concurrent-%s: %3.3f/%3.3f secs]",
 _collector->cmsGen()->short_name(),
 _phase, _collector->timerValue(), _wallclock.seconds());
 if (_print_cr) {
 gclog_or_tty->cr();
 // Setup the verification and class unloading state for this
 // CMS collection cycle.
 setup_cms_unloading_and_verification_state();
 NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork",
-PrintGCDetails && Verbose, true, _gc_timer_cm);)
+PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 if (UseAdaptiveSizePolicy) {
 size_policy()->checkpoint_roots_initial_begin();
 }
 // Reset all the PLAB chunk arrays if necessary.
 // refs in this generation concurrent (but interleaved) with
 // weak ref discovery by a younger generation collector.
 CMSTokenSyncWithLocks ts(true, bitMapLock());
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "mark", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "mark", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 res = markFromRootsWork(asynch);
 if (res) {
 _collectorState = Precleaning;
 } else { // We failed and a foreground collection wants to take over
 assert(_foregroundGCIsActive, "internal state inconsistency");
 _start_sampling = true;
 } else {
 _start_sampling = false;
 }
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1);
 }
 CMSTokenSync x(true); // is cms thread
 if (CMSPrecleaningEnabled) {
 sample_eden();
 // schedule the pause as described avove. By choosing
 // CMSScheduleRemarkEdenSizeThreshold >= max eden size
 // we will never do an actual abortable preclean cycle.
 if (get_eden_used() > CMSScheduleRemarkEdenSizeThreshold) {
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "abortable-preclean", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "abortable-preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 // We need more smarts in the abortable preclean
 // loop below to deal with cases where allocation
 // in young gen is very very slow, and our precleaning
 // is running a losing race against a horde of
 // mutators intent on flooding us with CMS updates
 // tweaking for better performance and some restructuring
 // for cleaner interfaces.
 GCTimer *gc_timer = NULL; // Currently not tracing concurrent phases
 rp->preclean_discovered_references(
 rp->is_alive_non_header(), &keep_alive, &complete_trace, &yield_cl,
-gc_timer);
+gc_timer, _gc_tracer_cm->gc_id());
 }
 if (clean_survivor) {  // preclean the active survivor space(s)
 assert(_young_gen->kind() == Generation::DefNew ||
 _young_gen->kind() == Generation::ParNew ||
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 // Temporarily set flag to false, GCH->do_collection will
 // expect it to be false and set to true
 FlagSetting fl(gch->_is_gc_active, false);
 NOT_PRODUCT(GCTraceTime t("Scavenge-Before-Remark",
-PrintGCDetails && Verbose, true, _gc_timer_cm);)
+PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 int level = _cmsGen->level() - 1;
 if (level >= 0) {
 gch->do_collection(true,        // full (i.e. force, see below)
 false,       // !clear_all_soft_refs
 0,           // size
 }
 void CMSCollector::checkpointRootsFinalWork(bool asynch,
 bool clear_all_soft_refs, bool init_mark_was_synchronous) {
-NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm);)
+NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 assert(haveFreelistLocks(), "must have free list locks");
 assert_lock_strong(bitMapLock());
 if (UseAdaptiveSizePolicy) {
 // are detected via the mod union table which is the set of all cards
 // dirtied since the first checkpoint in this GC cycle and prior to
 // the most recent young generation GC, minus those cleaned up by the
 // concurrent precleaning.
 if (CMSParallelRemarkEnabled && CollectedHeap::use_parallel_gc_threads()) {
-GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 do_remark_parallel();
 } else {
 GCTraceTime t("Rescan (non-parallel) ", PrintGCDetails, false,
-_gc_timer_cm);
+_gc_timer_cm, _gc_tracer_cm->gc_id());
 do_remark_non_parallel();
 }
 }
 } else {
 assert(!asynch, "Can't have init_mark_was_synchronous in asynch mode");
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 {
-NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm);)
+NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 refProcessingWork(asynch, clear_all_soft_refs);
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 MarkFromDirtyCardsClosure
 markFromDirtyCardsClosure(this, _span,
 NULL,  // space is set further below
 &_markBitMap, &_markStack, &mrias_cl);
 {
-GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Iterate over the dirty cards, setting the corresponding bits in the
 // mod union table.
 {
 ModUnionClosure modUnionClosure(&_modUnionTable);
 _ct->ct_bs()->dirty_card_iterate(
 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 Universe::verify();
 }
 {
-GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 GenCollectedHeap::StrongRootsScope srs(gch);
 || (roots_scanning_options() & SharedHeap::SO_CodeCache),
 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
 }
 {
-GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 // Scan all class loader data objects that might have been introduced
 // during concurrent marking.
 verify_work_stacks_empty();
 }
 {
-GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 RemarkKlassClosure remark_klass_closure(&mrias_cl);
 ClassLoaderDataGraph::classes_do(&remark_klass_closure);
 &_markStack, false /* !preclean */);
 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
 _span, &_markBitMap, &_markStack,
 &cmsKeepAliveClosure, false /* !preclean */);
 {
-GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 ReferenceProcessorStats stats;
 if (rp->processing_is_mt()) {
 // Set the degree of MT here.  If the discovery is done MT, there
 // may have been a different number of threads doing the discovery
 CMSRefProcTaskExecutor task_executor(*this);
 stats = rp->process_discovered_references(&_is_alive_closure,
 &cmsKeepAliveClosure,
 &cmsDrainMarkingStackClosure,
 &task_executor,
-_gc_timer_cm);
+_gc_timer_cm,
+_gc_tracer_cm->gc_id());
 } else {
 stats = rp->process_discovered_references(&_is_alive_closure,
 &cmsKeepAliveClosure,
 &cmsDrainMarkingStackClosure,
 NULL,
-_gc_timer_cm);
+_gc_timer_cm,
+_gc_tracer_cm->gc_id());
 }
 _gc_tracer_cm->report_gc_reference_stats(stats);
 }
 // This is the point where the entire marking should have completed.
 verify_work_stacks_empty();
 if (should_unload_classes()) {
 {
-GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Unload classes and purge the SystemDictionary.
 bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure);
 // Unload nmethods.
 // Prune dead klasses from subklass/sibling/implementor lists.
 Klass::clean_weak_klass_links(&_is_alive_closure);
 }
 {
-GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Clean up unreferenced symbols in symbol table.
 SymbolTable::unlink();
 }
 }
 // CMS doesn't use the StringTable as hard roots when class unloading is turned off.
 // Need to check if we really scanned the StringTable.
 if ((roots_scanning_options() & SharedHeap::SO_Strings) == 0) {
-GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Delete entries for dead interned strings.
 StringTable::unlink(&_is_alive_closure);
 }
 // Restore any preserved marks as a result of mark stack or
 assert(!_intra_sweep_timer.is_active(), "Should not be active");
 _intra_sweep_timer.reset();
 _intra_sweep_timer.start();
 if (asynch) {
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "sweep", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 // First sweep the old gen
 {
 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(),
 bitMapLock());
 sweepWork(_cmsGen, asynch);
 }
 // Clear the mark bitmap (no grey objects to start with)
 // for the next cycle.
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting cmspa(this, "reset", !PrintGCDetails);
+CMSPhaseAccounting cmspa(this, "reset", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 HeapWord* curAddr = _markBitMap.startWord();
 while (curAddr < _markBitMap.endWord()) {
 size_t remaining  = pointer_delta(_markBitMap.endWord(), curAddr);
 MemRegion chunk(curAddr, MIN2(CMSBitMapYieldQuantum, remaining));
 }
 void CMSCollector::do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause) {
 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL);
+GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL, _gc_tracer_cm->gc_id());
 TraceCollectorStats tcs(counters());
 switch (op) {
 case CMS_op_checkpointRootsInitial: {
 SvcGCMarker sgcm(SvcGCMarker::OTHER);

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 20190:0982ec23da03