--- old/src/os/windows/vm/os_windows.cpp 2015-12-01 12:06:03.590930982 +0100 +++ new/src/os/windows/vm/os_windows.cpp 2015-12-01 12:06:03.474930986 +0100 @@ -5986,7 +5986,7 @@ void TestReserveMemorySpecial_test() { if (!UseLargePages) { if (VerboseInternalVMTests) { - gclog_or_tty->print("Skipping test because large pages are disabled"); + tty->print("Skipping test because large pages are disabled"); } return; } @@ -6002,7 +6002,7 @@ char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false); if (result == NULL) { if (VerboseInternalVMTests) { - gclog_or_tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.", + tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.", large_allocation_size); } } else { @@ -6015,7 +6015,7 @@ char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false); if (actual_location == NULL) { if (VerboseInternalVMTests) { - gclog_or_tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.", + tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.", expected_location, large_allocation_size); } } else { --- old/src/share/vm/Xusage.txt 2015-12-01 12:06:03.838930973 +0100 +++ new/src/share/vm/Xusage.txt 2015-12-01 12:06:03.726930977 +0100 @@ -8,7 +8,6 @@ prepend in front of bootstrap class path -Xnoclassgc disable class garbage collection -Xlog: control JVM logging, use -Xlog:help for details - -Xloggc: log GC status to a file with time stamps -Xbatch disable background compilation -Xms set initial Java heap size -Xmx set maximum Java heap size --- old/src/share/vm/gc/cms/allocationStats.hpp 2015-12-01 12:06:04.010930967 +0100 +++ new/src/share/vm/gc/cms/allocationStats.hpp 2015-12-01 12:06:03.910930971 +0100 @@ -26,6 +26,7 @@ #define SHARE_VM_GC_CMS_ALLOCATIONSTATS_HPP #include "gc/shared/gcUtil.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/macros.hpp" @@ -119,11 +120,9 @@ ssize_t old_desired = _desired; float delta_ise = (CMSExtrapolateSweep ? intra_sweep_estimate : 0.0); _desired = (ssize_t)(new_rate * (inter_sweep_estimate + delta_ise)); - if (PrintFLSStatistics > 1) { - gclog_or_tty->print_cr("demand: " SSIZE_FORMAT ", old_rate: %f, current_rate: %f, " - "new_rate: %f, old_desired: " SSIZE_FORMAT ", new_desired: " SSIZE_FORMAT, - demand, old_rate, rate, new_rate, old_desired, _desired); - } + log_trace(gc, freelist)("demand: " SSIZE_FORMAT ", old_rate: %f, current_rate: %f, " + "new_rate: %f, old_desired: " SSIZE_FORMAT ", new_desired: " SSIZE_FORMAT, + demand, old_rate, rate, new_rate, old_desired, _desired); } } --- old/src/share/vm/gc/cms/compactibleFreeListSpace.cpp 2015-12-01 12:06:04.178930961 +0100 +++ new/src/share/vm/gc/cms/compactibleFreeListSpace.cpp 2015-12-01 12:06:04.078930965 +0100 @@ -400,17 +400,16 @@ void CompactibleFreeListSpace::print_indexed_free_lists(outputStream* st) const { - reportIndexedFreeListStatistics(); - gclog_or_tty->print_cr("Layout of Indexed Freelists"); - gclog_or_tty->print_cr("---------------------------"); + reportIndexedFreeListStatistics(st); + st->print_cr("Layout of Indexed Freelists"); + st->print_cr("---------------------------"); AdaptiveFreeList::print_labels_on(st, "size"); for (size_t i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) { - _indexedFreeList[i].print_on(gclog_or_tty); - for (FreeChunk* fc = _indexedFreeList[i].head(); fc != NULL; - fc = fc->next()) { - gclog_or_tty->print_cr("\t[" PTR_FORMAT "," PTR_FORMAT ") %s", - p2i(fc), p2i((HeapWord*)fc + i), - fc->cantCoalesce() ? "\t CC" : ""); + _indexedFreeList[i].print_on(st); + for (FreeChunk* fc = _indexedFreeList[i].head(); fc != NULL; fc = fc->next()) { + st->print_cr("\t[" PTR_FORMAT "," PTR_FORMAT ") %s", + p2i(fc), p2i((HeapWord*)fc + i), + fc->cantCoalesce() ? "\t CC" : ""); } } } @@ -422,7 +421,7 @@ void CompactibleFreeListSpace::print_dictionary_free_lists(outputStream* st) const { - _dictionary->report_statistics(); + _dictionary->report_statistics(st); st->print_cr("Layout of Freelists in Tree"); st->print_cr("---------------------------"); _dictionary->print_free_lists(st); @@ -472,54 +471,58 @@ return sz; } -void CompactibleFreeListSpace::dump_at_safepoint_with_locks(CMSCollector* c, - outputStream* st) { - st->print_cr("\n========================="); +void CompactibleFreeListSpace::dump_at_safepoint_with_locks(CMSCollector* c, outputStream* st) { + st->print_cr("========================="); st->print_cr("Block layout in CMS Heap:"); st->print_cr("========================="); BlkPrintingClosure bpcl(c, this, c->markBitMap(), st); blk_iterate(&bpcl); - st->print_cr("\n======================================="); + st->print_cr("======================================="); st->print_cr("Order & Layout of Promotion Info Blocks"); st->print_cr("======================================="); print_promo_info_blocks(st); - st->print_cr("\n==========================="); + st->print_cr("==========================="); st->print_cr("Order of Indexed Free Lists"); st->print_cr("========================="); print_indexed_free_lists(st); - st->print_cr("\n================================="); + st->print_cr("================================="); st->print_cr("Order of Free Lists in Dictionary"); st->print_cr("================================="); print_dictionary_free_lists(st); } -void CompactibleFreeListSpace::reportFreeListStatistics() const { +void CompactibleFreeListSpace::reportFreeListStatistics(const char* title) const { assert_lock_strong(&_freelistLock); - assert(PrintFLSStatistics != 0, "Reporting error"); - _dictionary->report_statistics(); - if (PrintFLSStatistics > 1) { - reportIndexedFreeListStatistics(); + LogHandle(gc, freelist, stats) log; + if (!log.is_debug()) { + return; + } + log.debug("%s", title); + _dictionary->report_statistics(log.debug_stream()); + if (log.is_trace()) { + ResourceMark rm; + reportIndexedFreeListStatistics(log.trace_stream()); size_t total_size = totalSizeInIndexedFreeLists() + _dictionary->total_chunk_size(DEBUG_ONLY(freelistLock())); - gclog_or_tty->print(" free=" SIZE_FORMAT " frag=%1.4f\n", total_size, flsFrag()); + log.trace(" free=" SIZE_FORMAT " frag=%1.4f", total_size, flsFrag()); } } -void CompactibleFreeListSpace::reportIndexedFreeListStatistics() const { +void CompactibleFreeListSpace::reportIndexedFreeListStatistics(outputStream* st) const { assert_lock_strong(&_freelistLock); - gclog_or_tty->print("Statistics for IndexedFreeLists:\n" - "--------------------------------\n"); + st->print_cr("Statistics for IndexedFreeLists:"); + st->print_cr("--------------------------------"); size_t total_size = totalSizeInIndexedFreeLists(); - size_t free_blocks = numFreeBlocksInIndexedFreeLists(); - gclog_or_tty->print("Total Free Space: " SIZE_FORMAT "\n", total_size); - gclog_or_tty->print("Max Chunk Size: " SIZE_FORMAT "\n", maxChunkSizeInIndexedFreeLists()); - gclog_or_tty->print("Number of Blocks: " SIZE_FORMAT "\n", free_blocks); + size_t free_blocks = numFreeBlocksInIndexedFreeLists(); + st->print_cr("Total Free Space: " SIZE_FORMAT, total_size); + st->print_cr("Max Chunk Size: " SIZE_FORMAT, maxChunkSizeInIndexedFreeLists()); + st->print_cr("Number of Blocks: " SIZE_FORMAT, free_blocks); if (free_blocks != 0) { - gclog_or_tty->print("Av. Block Size: " SIZE_FORMAT "\n", total_size/free_blocks); + st->print_cr("Av. Block Size: " SIZE_FORMAT, total_size/free_blocks); } } @@ -1824,10 +1827,7 @@ void CompactibleFreeListSpace::gc_prologue() { assert_locked(); - if (PrintFLSStatistics != 0) { - gclog_or_tty->print("Before GC:\n"); - reportFreeListStatistics(); - } + reportFreeListStatistics("Before GC:"); refillLinearAllocBlocksIfNeeded(); } @@ -1837,11 +1837,7 @@ assert(_promoInfo.noPromotions(), "_promoInfo inconsistency"); _promoInfo.stopTrackingPromotions(); repairLinearAllocationBlocks(); - // Print Space's stats - if (PrintFLSStatistics != 0) { - gclog_or_tty->print("After GC:\n"); - reportFreeListStatistics(); - } + reportFreeListStatistics("After GC:"); } // Iteration support, mostly delegated from a CMS generation @@ -2014,9 +2010,7 @@ size_t i; for (i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) { AdaptiveFreeList* fl = &_indexedFreeList[i]; - if (PrintFLSStatistics > 1) { - gclog_or_tty->print("size[" SIZE_FORMAT "] : ", i); - } + log_trace(gc, freelist)("size[" SIZE_FORMAT "] : ", i); fl->compute_desired(inter_sweep_current, inter_sweep_estimate, intra_sweep_estimate); fl->set_coal_desired((ssize_t)((double)fl->desired() * CMSSmallCoalSurplusPercent)); fl->set_before_sweep(fl->count()); @@ -2065,16 +2059,10 @@ } void CompactibleFreeListSpace::endSweepFLCensus(size_t sweep_count) { - if (PrintFLSStatistics > 0) { - HeapWord* largestAddr = (HeapWord*) dictionary()->find_largest_dict(); - gclog_or_tty->print_cr("CMS: Large block " PTR_FORMAT, - p2i(largestAddr)); - } + log_debug(gc, freelist)("CMS: Large block " PTR_FORMAT, p2i(dictionary()->find_largest_dict())); setFLSurplus(); setFLHints(); - if (PrintGC && PrintFLSCensus > 0) { - printFLCensus(sweep_count); - } + printFLCensus(sweep_count); clearFLCensus(); assert_locked(); _dictionary->end_sweep_dict_census(CMSLargeSplitSurplusPercent); @@ -2213,14 +2201,15 @@ } } if (res == 0) { - gclog_or_tty->print_cr("Livelock: no rank reduction!"); - gclog_or_tty->print_cr( - " Current: addr = " PTR_FORMAT ", size = " SIZE_FORMAT ", obj = %s, live = %s \n" - " Previous: addr = " PTR_FORMAT ", size = " SIZE_FORMAT ", obj = %s, live = %s \n", + LogHandle(gc, verify) log; + log.info("Livelock: no rank reduction!"); + log.info(" Current: addr = " PTR_FORMAT ", size = " SIZE_FORMAT ", obj = %s, live = %s \n" + " Previous: addr = " PTR_FORMAT ", size = " SIZE_FORMAT ", obj = %s, live = %s \n", p2i(addr), res, was_obj ?"true":"false", was_live ?"true":"false", p2i(_last_addr), _last_size, _last_was_obj?"true":"false", _last_was_live?"true":"false"); - _sp->print_on(gclog_or_tty); - guarantee(false, "Seppuku!"); + ResourceMark rm; + _sp->print_on(log.info_stream()); + guarantee(false, "Verification failed."); } _last_addr = addr; _last_size = res; @@ -2386,17 +2375,23 @@ void CompactibleFreeListSpace::printFLCensus(size_t sweep_count) const { assert_lock_strong(&_freelistLock); + LogHandle(gc, freelist, census) log; + if (!log.is_debug()) { + return; + } AdaptiveFreeList total; - gclog_or_tty->print("end sweep# " SIZE_FORMAT "\n", sweep_count); - AdaptiveFreeList::print_labels_on(gclog_or_tty, "size"); + log.debug("end sweep# " SIZE_FORMAT, sweep_count); + ResourceMark rm; + outputStream* out = log.debug_stream(); + AdaptiveFreeList::print_labels_on(out, "size"); size_t total_free = 0; for (size_t i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) { const AdaptiveFreeList *fl = &_indexedFreeList[i]; total_free += fl->count() * fl->size(); if (i % (40*IndexSetStride) == 0) { - AdaptiveFreeList::print_labels_on(gclog_or_tty, "size"); + AdaptiveFreeList::print_labels_on(out, "size"); } - fl->print_on(gclog_or_tty); + fl->print_on(out); total.set_bfr_surp( total.bfr_surp() + fl->bfr_surp() ); total.set_surplus( total.surplus() + fl->surplus() ); total.set_desired( total.desired() + fl->desired() ); @@ -2408,14 +2403,13 @@ total.set_split_births(total.split_births() + fl->split_births()); total.set_split_deaths(total.split_deaths() + fl->split_deaths()); } - total.print_on(gclog_or_tty, "TOTAL"); - gclog_or_tty->print_cr("Total free in indexed lists " - SIZE_FORMAT " words", total_free); - gclog_or_tty->print("growth: %8.5f deficit: %8.5f\n", - (double)(total.split_births()+total.coal_births()-total.split_deaths()-total.coal_deaths())/ - (total.prev_sweep() != 0 ? (double)total.prev_sweep() : 1.0), - (double)(total.desired() - total.count())/(total.desired() != 0 ? (double)total.desired() : 1.0)); - _dictionary->print_dict_census(); + total.print_on(out, "TOTAL"); + log.debug("Total free in indexed lists " SIZE_FORMAT " words", total_free); + log.debug("growth: %8.5f deficit: %8.5f", + (double)(total.split_births()+total.coal_births()-total.split_deaths()-total.coal_deaths())/ + (total.prev_sweep() != 0 ? (double)total.prev_sweep() : 1.0), + (double)(total.desired() - total.count())/(total.desired() != 0 ? (double)total.desired() : 1.0)); + _dictionary->print_dict_census(out); } /////////////////////////////////////////////////////////////////////////// @@ -2544,10 +2538,7 @@ // Reset counters for next round _global_num_workers[i] = 0; _global_num_blocks[i] = 0; - if (PrintOldPLAB) { - gclog_or_tty->print_cr("[" SIZE_FORMAT "]: " SIZE_FORMAT, - i, (size_t)_blocks_to_claim[i].average()); - } + log_trace(gc, plab)("[" SIZE_FORMAT "]: " SIZE_FORMAT, i, (size_t)_blocks_to_claim[i].average()); } } } @@ -2584,10 +2575,8 @@ _indexedFreeList[i].set_size(i); } } - if (PrintOldPLAB) { - gclog_or_tty->print_cr("%d[" SIZE_FORMAT "]: " SIZE_FORMAT "/" SIZE_FORMAT "/" SIZE_FORMAT, - tid, i, num_retire, _num_blocks[i], (size_t)_blocks_to_claim[i].average()); - } + log_trace(gc, plab)("%d[" SIZE_FORMAT "]: " SIZE_FORMAT "/" SIZE_FORMAT "/" SIZE_FORMAT, + tid, i, num_retire, _num_blocks[i], (size_t)_blocks_to_claim[i].average()); // Reset stats for next round _num_blocks[i] = 0; } --- old/src/share/vm/gc/cms/compactibleFreeListSpace.hpp 2015-12-01 12:06:04.406930953 +0100 +++ new/src/share/vm/gc/cms/compactibleFreeListSpace.hpp 2015-12-01 12:06:04.306930957 +0100 @@ -29,6 +29,7 @@ #include "gc/cms/promotionInfo.hpp" #include "gc/shared/blockOffsetTable.hpp" #include "gc/shared/space.hpp" +#include "logging/log.hpp" #include "memory/binaryTreeDictionary.hpp" #include "memory/freeList.hpp" @@ -275,8 +276,8 @@ void verify_objects_initialized() const; // Statistics reporting helper functions - void reportFreeListStatistics() const; - void reportIndexedFreeListStatistics() const; + void reportFreeListStatistics(const char* title) const; + void reportIndexedFreeListStatistics(outputStream* st) const; size_t maxChunkSizeInIndexedFreeLists() const; size_t numFreeBlocksInIndexedFreeLists() const; // Accessor @@ -450,11 +451,9 @@ void save_sweep_limit() { _sweep_limit = BlockOffsetArrayUseUnallocatedBlock ? unallocated_block() : end(); - if (CMSTraceSweeper) { - gclog_or_tty->print_cr(">>>>> Saving sweep limit " PTR_FORMAT - " for space [" PTR_FORMAT "," PTR_FORMAT ") <<<<<<", - p2i(_sweep_limit), p2i(bottom()), p2i(end())); - } + log_develop_trace(gc, sweep)(">>>>> Saving sweep limit " PTR_FORMAT + " for space [" PTR_FORMAT "," PTR_FORMAT ") <<<<<<", + p2i(_sweep_limit), p2i(bottom()), p2i(end())); } NOT_PRODUCT( void clear_sweep_limit() { _sweep_limit = NULL; } --- old/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp 2015-12-01 12:06:04.602930947 +0100 +++ new/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp 2015-12-01 12:06:04.494930950 +0100 @@ -46,13 +46,14 @@ #include "gc/shared/gcPolicyCounters.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/strongRootsScope.hpp" #include "gc/shared/taskqueue.inline.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/iterator.inline.hpp" #include "memory/padded.hpp" @@ -64,6 +65,7 @@ #include "runtime/handles.inline.hpp" #include "runtime/java.hpp" #include "runtime/orderAccess.inline.hpp" +#include "runtime/timer.hpp" #include "runtime/vmThread.hpp" #include "services/memoryService.hpp" #include "services/runtimeService.hpp" @@ -366,13 +368,9 @@ cms_adjustment = cms_adjustment * cms_free_adjustment_factor(cms_free); cms_free_dbl = cms_free_dbl * cms_adjustment; - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("CMSStats::time_until_cms_gen_full: cms_free " - SIZE_FORMAT " expected_promotion " SIZE_FORMAT, - cms_free, expected_promotion); - gclog_or_tty->print_cr(" cms_free_dbl %f cms_consumption_rate %f", - cms_free_dbl, cms_consumption_rate() + 1.0); - } + log_trace(gc)("CMSStats::time_until_cms_gen_full: cms_free " SIZE_FORMAT " expected_promotion " SIZE_FORMAT, + cms_free, expected_promotion); + log_trace(gc)(" cms_free_dbl %f cms_consumption_rate %f", cms_free_dbl, cms_consumption_rate() + 1.0); // Add 1 in case the consumption rate goes to zero. return cms_free_dbl / (cms_consumption_rate() + 1.0); } @@ -401,12 +399,8 @@ // If a concurrent mode failure occurred recently, we want to be // more conservative and halve our expected time_until_cms_gen_full() if (work > deadline) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print( - " CMSCollector: collect because of anticipated promotion " - "before full %3.7f + %3.7f > %3.7f ", cms_duration(), - gc0_period(), time_until_cms_gen_full()); - } + log_develop_trace(gc)("CMSCollector: collect because of anticipated promotion before full %3.7f + %3.7f > %3.7f ", + cms_duration(), gc0_period(), time_until_cms_gen_full()); return 0.0; } return work - deadline; @@ -668,31 +662,6 @@ } #endif -void ConcurrentMarkSweepGeneration::printOccupancy(const char *s) { - GenCollectedHeap* gch = GenCollectedHeap::heap(); - if (PrintGCDetails) { - // I didn't want to change the logging when removing the level concept, - // but I guess this logging could say "old" or something instead of "1". - assert(gch->is_old_gen(this), - "The CMS generation should be the old generation"); - uint level = 1; - if (Verbose) { - gclog_or_tty->print("[%u %s-%s: " SIZE_FORMAT "(" SIZE_FORMAT ")]", - level, short_name(), s, used(), capacity()); - } else { - gclog_or_tty->print("[%u %s-%s: " SIZE_FORMAT "K(" SIZE_FORMAT "K)]", - level, short_name(), s, used() / K, capacity() / K); - } - } - if (Verbose) { - gclog_or_tty->print(" " SIZE_FORMAT "(" SIZE_FORMAT ")", - gch->used(), gch->capacity()); - } else { - gclog_or_tty->print(" " SIZE_FORMAT "K(" SIZE_FORMAT "K)", - gch->used() / K, gch->capacity() / K); - } -} - size_t ConcurrentMarkSweepGeneration::contiguous_available() const { // dld proposes an improvement in precision here. If the committed @@ -716,21 +685,18 @@ size_t available = max_available(); size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average(); bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); - if (Verbose && PrintGCDetails) { - gclog_or_tty->print_cr( - "CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT ")," - "max_promo(" SIZE_FORMAT ")", - res? "":" not", available, res? ">=":"<", - av_promo, max_promotion_in_bytes); - } + log_trace(gc, promotion)("CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "), max_promo(" SIZE_FORMAT ")", + res? "":" not", available, res? ">=":"<", av_promo, max_promotion_in_bytes); return res; } // At a promotion failure dump information on block layout in heap // (cms old generation). void ConcurrentMarkSweepGeneration::promotion_failure_occurred() { - if (CMSDumpAtPromotionFailure) { - cmsSpace()->dump_at_safepoint_with_locks(collector(), gclog_or_tty); + LogHandle(gc, promotion) log; + if (log.is_trace()) { + ResourceMark rm; + cmsSpace()->dump_at_safepoint_with_locks(collector(), log.trace_stream()); } } @@ -786,27 +752,26 @@ size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); assert(desired_capacity >= capacity(), "invalid expansion size"); size_t expand_bytes = MAX2(desired_capacity - capacity(), MinHeapDeltaBytes); - if (PrintGCDetails && Verbose) { + LogHandle(gc) log; + if (log.is_trace()) { size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); - gclog_or_tty->print_cr("\nFrom compute_new_size: "); - gclog_or_tty->print_cr(" Free fraction %f", free_percentage); - gclog_or_tty->print_cr(" Desired free fraction %f", desired_free_percentage); - gclog_or_tty->print_cr(" Maximum free fraction %f", maximum_free_percentage); - gclog_or_tty->print_cr(" Capacity " SIZE_FORMAT, capacity() / 1000); - gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT, desired_capacity / 1000); + log.trace("From compute_new_size: "); + log.trace(" Free fraction %f", free_percentage); + log.trace(" Desired free fraction %f", desired_free_percentage); + log.trace(" Maximum free fraction %f", maximum_free_percentage); + log.trace(" Capacity " SIZE_FORMAT, capacity() / 1000); + log.trace(" Desired capacity " SIZE_FORMAT, desired_capacity / 1000); GenCollectedHeap* gch = GenCollectedHeap::heap(); assert(gch->is_old_gen(this), "The CMS generation should always be the old generation"); size_t young_size = gch->young_gen()->capacity(); - gclog_or_tty->print_cr(" Young gen size " SIZE_FORMAT, young_size / 1000); - gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT, unsafe_max_alloc_nogc() / 1000); - gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT, contiguous_available() / 1000); - gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)", expand_bytes); + log.trace(" Young gen size " SIZE_FORMAT, young_size / 1000); + log.trace(" unsafe_max_alloc_nogc " SIZE_FORMAT, unsafe_max_alloc_nogc() / 1000); + log.trace(" contiguous available " SIZE_FORMAT, contiguous_available() / 1000); + log.trace(" Expand by " SIZE_FORMAT " (bytes)", expand_bytes); } // safe if expansion fails expand_for_gc_cause(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" Expanded free fraction %f", ((double) free()) / capacity()); - } + log.trace(" Expanded free fraction %f", ((double) free()) / capacity()); } else { size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); assert(desired_capacity <= capacity(), "invalid expansion size"); @@ -1144,10 +1109,7 @@ bool CMSCollector::shouldConcurrentCollect() { if (_full_gc_requested) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print_cr("CMSCollector: collect because of explicit " - " gc request (or gc_locker)"); - } + log_trace(gc)("CMSCollector: collect because of explicit gc request (or gc_locker)"); return true; } @@ -1155,24 +1117,21 @@ // ------------------------------------------------------------------ // Print out lots of information which affects the initiation of // a collection. - if (PrintCMSInitiationStatistics && stats().valid()) { - gclog_or_tty->print("CMSCollector shouldConcurrentCollect: "); - gclog_or_tty->stamp(); - gclog_or_tty->cr(); - stats().print_on(gclog_or_tty); - gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f", - stats().time_until_cms_gen_full()); - gclog_or_tty->print_cr("free=" SIZE_FORMAT, _cmsGen->free()); - gclog_or_tty->print_cr("contiguous_available=" SIZE_FORMAT, - _cmsGen->contiguous_available()); - gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate()); - gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate()); - gclog_or_tty->print_cr("occupancy=%3.7f", _cmsGen->occupancy()); - gclog_or_tty->print_cr("initiatingOccupancy=%3.7f", _cmsGen->initiating_occupancy()); - gclog_or_tty->print_cr("cms_time_since_begin=%3.7f", stats().cms_time_since_begin()); - gclog_or_tty->print_cr("cms_time_since_end=%3.7f", stats().cms_time_since_end()); - gclog_or_tty->print_cr("metadata initialized %d", - MetaspaceGC::should_concurrent_collect()); + LogHandle(gc) log; + if (log.is_trace() && stats().valid()) { + log.trace("CMSCollector shouldConcurrentCollect: "); + ResourceMark rm; + stats().print_on(log.debug_stream()); + log.trace("time_until_cms_gen_full %3.7f", stats().time_until_cms_gen_full()); + log.trace("free=" SIZE_FORMAT, _cmsGen->free()); + log.trace("contiguous_available=" SIZE_FORMAT, _cmsGen->contiguous_available()); + log.trace("promotion_rate=%g", stats().promotion_rate()); + log.trace("cms_allocation_rate=%g", stats().cms_allocation_rate()); + log.trace("occupancy=%3.7f", _cmsGen->occupancy()); + log.trace("initiatingOccupancy=%3.7f", _cmsGen->initiating_occupancy()); + log.trace("cms_time_since_begin=%3.7f", stats().cms_time_since_begin()); + log.trace("cms_time_since_end=%3.7f", stats().cms_time_since_end()); + log.trace("metadata initialized %d", MetaspaceGC::should_concurrent_collect()); } // ------------------------------------------------------------------ @@ -1190,12 +1149,8 @@ // this branch will not fire after the first successful CMS // collection because the stats should then be valid. if (_cmsGen->occupancy() >= _bootstrap_occupancy) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print_cr( - " CMSCollector: collect for bootstrapping statistics:" - " occupancy = %f, boot occupancy = %f", _cmsGen->occupancy(), - _bootstrap_occupancy); - } + log_trace(gc)(" CMSCollector: collect for bootstrapping statistics: occupancy = %f, boot occupancy = %f", + _cmsGen->occupancy(), _bootstrap_occupancy); return true; } } @@ -1207,9 +1162,7 @@ // XXX We need to make sure that the gen expansion // criterion dovetails well with this. XXX NEED TO FIX THIS if (_cmsGen->should_concurrent_collect()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print_cr("CMS old gen initiated"); - } + log_trace(gc)("CMS old gen initiated"); return true; } @@ -1220,16 +1173,12 @@ assert(gch->collector_policy()->is_generation_policy(), "You may want to check the correctness of the following"); if (gch->incremental_collection_will_fail(true /* consult_young */)) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("CMSCollector: collect because incremental collection will fail "); - } + log_trace(gc)("CMSCollector: collect because incremental collection will fail "); return true; } if (MetaspaceGC::should_concurrent_collect()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("CMSCollector: collect for metadata allocation "); - } + log_trace(gc)("CMSCollector: collect for metadata allocation "); return true; } @@ -1243,13 +1192,11 @@ // Check the CMS time since begin (we do not check the stats validity // as we want to be able to trigger the first CMS cycle as well) if (stats().cms_time_since_begin() >= (CMSTriggerInterval / ((double) MILLIUNITS))) { - if (Verbose && PrintGCDetails) { - if (stats().valid()) { - gclog_or_tty->print_cr("CMSCollector: collect because of trigger interval (time since last begin %3.7f secs)", - stats().cms_time_since_begin()); - } else { - gclog_or_tty->print_cr("CMSCollector: collect because of trigger interval (first collection)"); - } + if (stats().valid()) { + log_trace(gc)("CMSCollector: collect because of trigger interval (time since last begin %3.7f secs)", + stats().cms_time_since_begin()); + } else { + log_trace(gc)("CMSCollector: collect because of trigger interval (first collection)"); } return true; } @@ -1292,20 +1239,15 @@ assert_lock_strong(freelistLock()); if (occupancy() > initiating_occupancy()) { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" %s: collect because of occupancy %f / %f ", - short_name(), occupancy(), initiating_occupancy()); - } + log_trace(gc)(" %s: collect because of occupancy %f / %f ", + short_name(), occupancy(), initiating_occupancy()); return true; } if (UseCMSInitiatingOccupancyOnly) { return false; } if (expansion_cause() == CMSExpansionCause::_satisfy_allocation) { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" %s: collect because expanded for allocation ", - short_name()); - } + log_trace(gc)(" %s: collect because expanded for allocation ", short_name()); return true; } return false; @@ -1362,13 +1304,9 @@ void CMSCollector::report_concurrent_mode_interruption() { if (is_external_interruption()) { - if (PrintGCDetails) { - gclog_or_tty->print(" (concurrent mode interrupted)"); - } + log_debug(gc)("Concurrent mode interrupted"); } else { - if (PrintGCDetails) { - gclog_or_tty->print(" (concurrent mode failure)"); - } + log_debug(gc)("Concurrent mode failure"); _gc_tracer_cm->report_concurrent_mode_failure(); } } @@ -1502,11 +1440,9 @@ "VM thread should have CMS token"); getFreelistLocks(); bitMapLock()->lock_without_safepoint_check(); - if (TraceCMSState) { - gclog_or_tty->print_cr("CMS foreground collector has asked for control " - INTPTR_FORMAT " with first state %d", p2i(Thread::current()), first_state); - gclog_or_tty->print_cr(" gets control with state %d", _collectorState); - } + log_debug(gc, state)("CMS foreground collector has asked for control " INTPTR_FORMAT " with first state %d", + p2i(Thread::current()), first_state); + log_debug(gc, state)(" gets control with state %d", _collectorState); // Inform cms gen if this was due to partial collection failing. // The CMS gen may use this fact to determine its expansion policy. @@ -1580,7 +1516,7 @@ 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(Trace, gc) t("CMS:MSC"); // Temporarily widen the span of the weak reference processing to // the entire heap. @@ -1665,33 +1601,34 @@ } void CMSCollector::print_eden_and_survivor_chunk_arrays() { + LogHandle(gc, heap) log; + if (!log.is_trace()) { + return; + } + ContiguousSpace* eden_space = _young_gen->eden(); ContiguousSpace* from_space = _young_gen->from(); ContiguousSpace* to_space = _young_gen->to(); // Eden if (_eden_chunk_array != NULL) { - gclog_or_tty->print_cr("eden " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")", - p2i(eden_space->bottom()), p2i(eden_space->top()), - p2i(eden_space->end()), eden_space->capacity()); - gclog_or_tty->print_cr("_eden_chunk_index=" SIZE_FORMAT ", " - "_eden_chunk_capacity=" SIZE_FORMAT, - _eden_chunk_index, _eden_chunk_capacity); + log.trace("eden " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")", + p2i(eden_space->bottom()), p2i(eden_space->top()), + p2i(eden_space->end()), eden_space->capacity()); + log.trace("_eden_chunk_index=" SIZE_FORMAT ", _eden_chunk_capacity=" SIZE_FORMAT, + _eden_chunk_index, _eden_chunk_capacity); for (size_t i = 0; i < _eden_chunk_index; i++) { - gclog_or_tty->print_cr("_eden_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT, - i, p2i(_eden_chunk_array[i])); + log.trace("_eden_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT, i, p2i(_eden_chunk_array[i])); } } // Survivor if (_survivor_chunk_array != NULL) { - gclog_or_tty->print_cr("survivor " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")", - p2i(from_space->bottom()), p2i(from_space->top()), - p2i(from_space->end()), from_space->capacity()); - gclog_or_tty->print_cr("_survivor_chunk_index=" SIZE_FORMAT ", " - "_survivor_chunk_capacity=" SIZE_FORMAT, - _survivor_chunk_index, _survivor_chunk_capacity); + log.trace("survivor " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")", + p2i(from_space->bottom()), p2i(from_space->top()), + p2i(from_space->end()), from_space->capacity()); + log.trace("_survivor_chunk_index=" SIZE_FORMAT ", _survivor_chunk_capacity=" SIZE_FORMAT, + _survivor_chunk_index, _survivor_chunk_capacity); for (size_t i = 0; i < _survivor_chunk_index; i++) { - gclog_or_tty->print_cr("_survivor_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT, - i, p2i(_survivor_chunk_array[i])); + log.trace("_survivor_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT, i, p2i(_survivor_chunk_array[i])); } } } @@ -1780,11 +1717,7 @@ _collection_count_start = gch->total_full_collections(); } - // Used for PrintGC - size_t prev_used = 0; - if (PrintGC && Verbose) { - prev_used = _cmsGen->used(); - } + size_t prev_used = _cmsGen->used(); // The change of the collection state is normally done at this level; // the exceptions are phases that are executed while the world is @@ -1795,10 +1728,8 @@ // while the world is stopped because the foreground collector already // has the world stopped and would deadlock. while (_collectorState != Idling) { - if (TraceCMSState) { - gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d", - p2i(Thread::current()), _collectorState); - } + log_debug(gc, state)("Thread " INTPTR_FORMAT " in CMS state %d", + p2i(Thread::current()), _collectorState); // The foreground collector // holds the Heap_lock throughout its collection. // holds the CMS token (but not the lock) @@ -1828,11 +1759,8 @@ // done this round. assert(_foregroundGCShouldWait == false, "We set it to false in " "waitForForegroundGC()"); - if (TraceCMSState) { - gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT - " exiting collection CMS state %d", - p2i(Thread::current()), _collectorState); - } + log_debug(gc, state)("CMS Thread " INTPTR_FORMAT " exiting collection CMS state %d", + p2i(Thread::current()), _collectorState); return; } else { // The background collector can run but check to see if the @@ -1936,10 +1864,8 @@ ShouldNotReachHere(); break; } - if (TraceCMSState) { - gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d", - p2i(Thread::current()), _collectorState); - } + log_debug(gc, state)(" Thread " INTPTR_FORMAT " done - next CMS state %d", + p2i(Thread::current()), _collectorState); assert(_foregroundGCShouldWait, "block post-condition"); } @@ -1958,14 +1884,10 @@ assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "Possible deadlock"); } - if (TraceCMSState) { - gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT - " exiting collection CMS state %d", - p2i(Thread::current()), _collectorState); - } - if (PrintGC && Verbose) { - _cmsGen->print_heap_change(prev_used); - } + log_debug(gc, state)("CMS Thread " INTPTR_FORMAT " exiting collection CMS state %d", + p2i(Thread::current()), _collectorState); + log_info(gc, heap)("Old: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + prev_used / K, _cmsGen->used()/K, _cmsGen->capacity() /K); } void CMSCollector::register_gc_start(GCCause::Cause cause) { @@ -2017,10 +1939,8 @@ ConcurrentMarkSweepThread::CMS_cms_wants_token); // Get a possibly blocked foreground thread going CGC_lock->notify(); - if (TraceCMSState) { - gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d", - p2i(Thread::current()), _collectorState); - } + log_debug(gc, state)("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d", + p2i(Thread::current()), _collectorState); while (_foregroundGCIsActive) { CGC_lock->wait(Mutex::_no_safepoint_check_flag); } @@ -2029,10 +1949,8 @@ ConcurrentMarkSweepThread::clear_CMS_flag( ConcurrentMarkSweepThread::CMS_cms_wants_token); } - if (TraceCMSState) { - gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d", - p2i(Thread::current()), _collectorState); - } + log_debug(gc, state)("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d", + p2i(Thread::current()), _collectorState); return res; } @@ -2129,11 +2047,8 @@ NOT_PRODUCT( assert(_numObjectsPromoted == 0, "check"); assert(_numWordsPromoted == 0, "check"); - if (Verbose && PrintGC) { - gclog_or_tty->print("Allocated " SIZE_FORMAT " objects, " - SIZE_FORMAT " bytes concurrently", - _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); - } + log_develop_trace(gc, alloc)("Allocated " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes concurrently", + _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); _numObjectsAllocated = 0; _numWordsAllocated = 0; ) @@ -2210,21 +2125,15 @@ NOT_PRODUCT( assert(_numObjectsAllocated == 0, "check"); assert(_numWordsAllocated == 0, "check"); - if (Verbose && PrintGC) { - gclog_or_tty->print("Promoted " SIZE_FORMAT " objects, " - SIZE_FORMAT " bytes", - _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); - } + log_develop_trace(gc, promotion)("Promoted " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", + _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); _numObjectsPromoted = 0; _numWordsPromoted = 0; ) - if (PrintGC && Verbose) { - // Call down the chain in contiguous_available needs the freelistLock - // so print this out before releasing the freeListLock. - gclog_or_tty->print(" Contiguous available " SIZE_FORMAT " bytes ", - contiguous_available()); - } + // Call down the chain in contiguous_available needs the freelistLock + // so print this out before releasing the freeListLock. + log_develop_trace(gc)(" Contiguous available " SIZE_FORMAT " bytes ", contiguous_available()); } #ifndef PRODUCT @@ -2308,8 +2217,10 @@ bool do_bit(size_t offset) { HeapWord* addr = _marks->offsetToHeapWord(offset); if (!_marks->isMarked(addr)) { - oop(addr)->print_on(gclog_or_tty); - gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", p2i(addr)); + LogHandle(gc, verify) log; + ResourceMark rm; + oop(addr)->print_on(log.info_stream()); + log.info(" (" INTPTR_FORMAT " should have been marked)", p2i(addr)); _failed = true; } return true; @@ -2318,8 +2229,8 @@ bool failed() { return _failed; } }; -bool CMSCollector::verify_after_remark(bool silent) { - if (!silent) gclog_or_tty->print(" [Verifying CMS Marking... "); +bool CMSCollector::verify_after_remark() { + GCTraceTime(Info, gc, verify) tm("Verifying CMS Marking."); MutexLockerEx ml(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag); static bool init = false; @@ -2382,7 +2293,6 @@ warning("Unrecognized value " UINTX_FORMAT " for CMSRemarkVerifyVariant", CMSRemarkVerifyVariant); } - if (!silent) gclog_or_tty->print(" done] "); return true; } @@ -2434,8 +2344,10 @@ VerifyMarkedClosure vcl(markBitMap()); verification_mark_bm()->iterate(&vcl); if (vcl.failed()) { - gclog_or_tty->print("Verification failed"); - gch->print_on(gclog_or_tty); + LogHandle(gc, verify) log; + log.info("Verification failed"); + ResourceMark rm; + gch->print_on(log.info_stream()); fatal("CMS: failed marking verification after remark"); } } @@ -2728,10 +2640,7 @@ // a new CMS cycle. if (success) { set_expansion_cause(cause); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("Expanded CMS gen for %s", - CMSExpansionCause::to_string(cause)); - } + log_trace(gc)("Expanded CMS gen for %s", CMSExpansionCause::to_string(cause)); } } @@ -2799,9 +2708,7 @@ void ConcurrentMarkSweepGeneration::shrink_free_list_by(size_t bytes) { assert_locked_or_safepoint(Heap_lock); assert_lock_strong(freelistLock()); - if (PrintGCDetails && Verbose) { - warning("Shrinking of CMS not yet implemented"); - } + log_trace(gc)("Shrinking of CMS not yet implemented"); return; } @@ -2811,63 +2718,35 @@ class CMSPhaseAccounting: public StackObj { public: CMSPhaseAccounting(CMSCollector *collector, - const char *phase, - bool print_cr = true); + const char *title); ~CMSPhaseAccounting(); private: CMSCollector *_collector; - const char *_phase; - elapsedTimer _wallclock; - bool _print_cr; + const char *_title; + GCTraceConcTime(Info, gc) _trace_time; public: // Not MT-safe; so do not pass around these StackObj's // where they may be accessed by other threads. jlong wallclock_millis() { - assert(_wallclock.is_active(), "Wall clock should not stop"); - _wallclock.stop(); // to record time - jlong ret = _wallclock.milliseconds(); - _wallclock.start(); // restart - return ret; + return TimeHelper::counter_to_millis(os::elapsed_counter() - _trace_time.start_time()); } }; CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector, - const char *phase, - bool print_cr) : - _collector(collector), _phase(phase), _print_cr(print_cr) { - - if (PrintCMSStatistics != 0) { - _collector->resetYields(); - } - if (PrintGCDetails) { - gclog_or_tty->gclog_stamp(); - gclog_or_tty->print_cr("[%s-concurrent-%s-start]", - _collector->cmsGen()->short_name(), _phase); - } + const char *title) : + _collector(collector), _title(title), _trace_time(title) { + + _collector->resetYields(); _collector->resetTimer(); - _wallclock.start(); _collector->startTimer(); } CMSPhaseAccounting::~CMSPhaseAccounting() { - assert(_wallclock.is_active(), "Wall clock should not have stopped"); _collector->stopTimer(); - _wallclock.stop(); - if (PrintGCDetails) { - gclog_or_tty->gclog_stamp(); - 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(); - } - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr(" (CMS-concurrent-%s yielded %d times)", _phase, - _collector->yields()); - } - } + log_debug(gc)("Concurrent active time: %.3fms", TimeHelper::counter_to_seconds(_collector->timerTicks())); + log_trace(gc)(" (CMS %s yielded %d times)", _title, _collector->yields()); } // CMS work @@ -2934,8 +2813,7 @@ // CMS collection cycle. setup_cms_unloading_and_verification_state(); - NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork", - PrintGCDetails && Verbose, true, _gc_timer_cm);) + GCTraceTime(Trace, gc) ts("checkpointRootsInitialWork", _gc_timer_cm); // Reset all the PLAB chunk arrays if necessary. if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) { @@ -2966,9 +2844,7 @@ // the klasses. The claimed marks need to be cleared before marking starts. ClassLoaderDataGraph::clear_claimed_marks(); - if (CMSPrintEdenSurvivorChunks) { - print_eden_and_survivor_chunk_arrays(); - } + print_eden_and_survivor_chunk_arrays(); { #if defined(COMPILER2) || INCLUDE_JVMCI @@ -3039,17 +2915,15 @@ // weak ref discovery by the young generation collector. CMSTokenSyncWithLocks ts(true, bitMapLock()); - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - CMSPhaseAccounting pa(this, "mark", !PrintGCDetails); + GCTraceCPUTime tcpu; + CMSPhaseAccounting pa(this, "Concrurrent Mark"); bool res = markFromRootsWork(); if (res) { _collectorState = Precleaning; } else { // We failed and a foreground collection wants to take over assert(_foregroundGCIsActive, "internal state inconsistency"); assert(_restart_addr == NULL, "foreground will restart from scratch"); - if (PrintGCDetails) { - gclog_or_tty->print_cr("bailing out to foreground collection"); - } + log_debug(gc)("bailing out to foreground collection"); } verify_overflow_empty(); return res; @@ -3254,22 +3128,14 @@ _timer.start(); do_scan_and_mark(worker_id, _cms_space); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("Finished cms space scanning in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - // XXX: need xxx/xxx type of notation, two timers - } + log_trace(gc, task)("Finished cms space scanning in %dth thread: %3.3f sec", worker_id, _timer.seconds()); // ... do work stealing _timer.reset(); _timer.start(); do_work_steal(worker_id); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("Finished work stealing in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - // XXX: need xxx/xxx type of notation, two timers - } + log_trace(gc, task)("Finished work stealing in %dth thread: %3.3f sec", worker_id, _timer.seconds()); assert(_collector->_markStack.isEmpty(), "Should have been emptied"); assert(work_queue(worker_id)->size() == 0, "Should have been emptied"); // Note that under the current task protocol, the @@ -3484,10 +3350,7 @@ if (simulate_overflow || !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { // stack overflow - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " - SIZE_FORMAT, _overflow_stack->capacity()); - } + log_trace(gc)("CMS marking stack overflow (benign) at " SIZE_FORMAT, _overflow_stack->capacity()); // We cannot assert that the overflow stack is full because // it may have been emptied since. assert(simulate_overflow || @@ -3572,9 +3435,7 @@ _bit_map_lock->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // It is possible for whichever thread initiated the yield request // not to get a chance to wake up and take the bitmap lock between @@ -3736,8 +3597,8 @@ } else { _start_sampling = false; } - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails); + GCTraceCPUTime tcpu; + CMSPhaseAccounting pa(this, "Concurrent Preclean"); preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1); } CMSTokenSync x(true); // is cms thread @@ -3765,8 +3626,8 @@ // 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); + GCTraceCPUTime tcpu; + CMSPhaseAccounting pa(this, "Concurrent Abortable Preclean"); // 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 @@ -3788,15 +3649,11 @@ // been at it for too long. if ((CMSMaxAbortablePrecleanLoops != 0) && loops >= CMSMaxAbortablePrecleanLoops) { - if (PrintGCDetails) { - gclog_or_tty->print(" CMS: abort preclean due to loops "); - } + log_debug(gc)(" CMS: abort preclean due to loops "); break; } if (pa.wallclock_millis() > CMSMaxAbortablePrecleanTime) { - if (PrintGCDetails) { - gclog_or_tty->print(" CMS: abort preclean due to time "); - } + log_debug(gc)(" CMS: abort preclean due to time "); break; } // If we are doing little work each iteration, we should @@ -3809,10 +3666,8 @@ waited++; } } - if (PrintCMSStatistics > 0) { - gclog_or_tty->print(" [" SIZE_FORMAT " iterations, " SIZE_FORMAT " waits, " SIZE_FORMAT " cards)] ", - loops, waited, cumworkdone); - } + log_trace(gc)(" [" SIZE_FORMAT " iterations, " SIZE_FORMAT " waits, " SIZE_FORMAT " cards)] ", + loops, waited, cumworkdone); } CMSTokenSync x(true); // is cms thread if (_collectorState != Idling) { @@ -3956,9 +3811,7 @@ numIter < CMSPrecleanIter; numIter++, lastNumCards = curNumCards, cumNumCards += curNumCards) { curNumCards = preclean_mod_union_table(_cmsGen, &smoac_cl); - if (Verbose && PrintGCDetails) { - gclog_or_tty->print(" (modUnionTable: " SIZE_FORMAT " cards)", curNumCards); - } + log_trace(gc)(" (modUnionTable: " SIZE_FORMAT " cards)", curNumCards); // Either there are very few dirty cards, so re-mark // pause will be small anyway, or our pre-cleaning isn't // that much faster than the rate at which cards are being @@ -3978,10 +3831,8 @@ curNumCards = preclean_card_table(_cmsGen, &smoac_cl); cumNumCards += curNumCards; - if (PrintGCDetails && PrintCMSStatistics != 0) { - gclog_or_tty->print_cr(" (cardTable: " SIZE_FORMAT " cards, re-scanned " SIZE_FORMAT " cards, " SIZE_FORMAT " iterations)", - curNumCards, cumNumCards, numIter); - } + log_trace(gc)(" (cardTable: " SIZE_FORMAT " cards, re-scanned " SIZE_FORMAT " cards, " SIZE_FORMAT " iterations)", + curNumCards, cumNumCards, numIter); return cumNumCards; // as a measure of useful work done } @@ -4235,19 +4086,17 @@ verify_work_stacks_empty(); verify_overflow_empty(); - if (PrintGCDetails) { - gclog_or_tty->print("[YG occupancy: " SIZE_FORMAT " K (" SIZE_FORMAT " K)]", - _young_gen->used() / K, - _young_gen->capacity() / K); - } + log_debug(gc)("YG occupancy: " SIZE_FORMAT " K (" SIZE_FORMAT " K)", + _young_gen->used() / K, _young_gen->capacity() / K); { if (CMSScavengeBeforeRemark) { 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);) + + GCTraceTime(Trace, gc) tm("Pause Scavenge Before Remark", _gc_timer_cm); + gch->do_collection(true, // full (i.e. force, see below) false, // !clear_all_soft_refs 0, // size @@ -4265,7 +4114,7 @@ } void CMSCollector::checkpointRootsFinalWork() { - NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm);) + GCTraceTime(Trace, gc) tm("checkpointRootsFinalWork", _gc_timer_cm); assert(haveFreelistLocks(), "must have free list locks"); assert_lock_strong(bitMapLock()); @@ -4297,9 +4146,7 @@ // Update the saved marks which may affect the root scans. gch->save_marks(); - if (CMSPrintEdenSurvivorChunks) { - print_eden_and_survivor_chunk_arrays(); - } + print_eden_and_survivor_chunk_arrays(); { #if defined(COMPILER2) || INCLUDE_JVMCI @@ -4317,10 +4164,10 @@ // the most recent young generation GC, minus those cleaned up by the // concurrent precleaning. if (CMSParallelRemarkEnabled) { - GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Rescan (parallel)", _gc_timer_cm); do_remark_parallel(); } else { - GCTraceTime t("Rescan (non-parallel) ", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Rescan (non-parallel)", _gc_timer_cm); do_remark_non_parallel(); } } @@ -4328,7 +4175,7 @@ verify_overflow_empty(); { - NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm);) + GCTraceTime(Trace, gc) ts("refProcessingWork", _gc_timer_cm); refProcessingWork(); } verify_work_stacks_empty(); @@ -4347,13 +4194,8 @@ size_t ser_ovflw = _ser_pmc_remark_ovflw + _ser_pmc_preclean_ovflw + _ser_kac_ovflw + _ser_kac_preclean_ovflw; if (ser_ovflw > 0) { - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("Marking stack overflow (benign) " - "(pmc_pc=" SIZE_FORMAT ", pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT - ", kac_preclean=" SIZE_FORMAT ")", - _ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw, - _ser_kac_ovflw, _ser_kac_preclean_ovflw); - } + log_trace(gc)("Marking stack overflow (benign) (pmc_pc=" SIZE_FORMAT ", pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT ", kac_preclean=" SIZE_FORMAT ")", + _ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw, _ser_kac_ovflw, _ser_kac_preclean_ovflw); _markStack.expand(); _ser_pmc_remark_ovflw = 0; _ser_pmc_preclean_ovflw = 0; @@ -4361,26 +4203,19 @@ _ser_kac_ovflw = 0; } if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) { - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("Work queue overflow (benign) " - "(pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT ")", - _par_pmc_remark_ovflw, _par_kac_ovflw); - } - _par_pmc_remark_ovflw = 0; + log_trace(gc)("Work queue overflow (benign) (pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT ")", + _par_pmc_remark_ovflw, _par_kac_ovflw); + _par_pmc_remark_ovflw = 0; _par_kac_ovflw = 0; } - if (PrintCMSStatistics != 0) { - if (_markStack._hit_limit > 0) { - gclog_or_tty->print_cr(" (benign) Hit max stack size limit (" SIZE_FORMAT ")", - _markStack._hit_limit); - } - if (_markStack._failed_double > 0) { - gclog_or_tty->print_cr(" (benign) Failed stack doubling (" SIZE_FORMAT ")," - " current capacity " SIZE_FORMAT, - _markStack._failed_double, - _markStack.capacity()); - } - } + if (_markStack._hit_limit > 0) { + log_trace(gc)(" (benign) Hit max stack size limit (" SIZE_FORMAT ")", + _markStack._hit_limit); + } + if (_markStack._failed_double > 0) { + log_trace(gc)(" (benign) Failed stack doubling (" SIZE_FORMAT "), current capacity " SIZE_FORMAT, + _markStack._failed_double, _markStack.capacity()); + } _markStack._hit_limit = 0; _markStack._failed_double = 0; @@ -4414,11 +4249,7 @@ { work_on_young_gen_roots(worker_id, &par_mri_cl); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished young gen initial mark scan work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished young gen initial mark scan work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // ---------- remaining roots -------------- @@ -4439,11 +4270,7 @@ || (_collector->CMSCollector::roots_scanning_options() & GenCollectedHeap::SO_AllCodeCache), "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops"); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished remaining root initial mark scan work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished remaining root initial mark scan work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // Parallel remark task @@ -4556,11 +4383,7 @@ { work_on_young_gen_roots(worker_id, &par_mrias_cl); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished young gen rescan work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished young gen rescan work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // ---------- remaining roots -------------- @@ -4579,11 +4402,7 @@ || (_collector->CMSCollector::roots_scanning_options() & GenCollectedHeap::SO_AllCodeCache), "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops"); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished remaining root rescan work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished remaining root rescan work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); // ---------- unhandled CLD scanning ---------- if (worker_id == 0) { // Single threaded at the moment. @@ -4602,11 +4421,7 @@ ClassLoaderDataGraph::remember_new_clds(false); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished unhandled CLD scanning work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished unhandled CLD scanning work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // ---------- dirty klass scanning ---------- @@ -4619,11 +4434,7 @@ ClassLoaderDataGraph::classes_do(&remark_klass_closure); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished dirty klass scanning work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished dirty klass scanning work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // We might have added oops to ClassLoaderData::_handles during the @@ -4641,11 +4452,7 @@ // "worker_id" is passed to select the task_queue for "worker_id" do_dirty_card_rescan_tasks(_cms_space, worker_id, &par_mrias_cl); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished dirty card rescan work in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished dirty card rescan work in %dth thread: %3.3f sec", worker_id, _timer.seconds()); // ---------- steal work from other threads ... // ---------- ... and drain overflow list. @@ -4653,11 +4460,7 @@ _timer.start(); do_work_steal(worker_id, &par_mrias_cl, _collector->hash_seed(worker_id)); _timer.stop(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr( - "Finished work stealing in %dth thread: %3.3f sec", - worker_id, _timer.seconds()); - } + log_trace(gc, task)("Finished work stealing in %dth thread: %3.3f sec", worker_id, _timer.seconds()); } // Note that parameter "i" is not used. @@ -4851,11 +4654,7 @@ break; // nirvana from the infinite cycle } } - NOT_PRODUCT( - if (PrintCMSStatistics != 0) { - gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); - } - ) + log_develop_trace(gc, task)("\t(%d: stole %d oops)", i, num_steals); assert(work_q->size() == 0 && _collector->overflow_list_is_empty(), "Else our work is not yet done"); } @@ -4952,9 +4751,7 @@ } // We are all done; record the size of the _survivor_chunk_array _survivor_chunk_index = i; // exclusive: [0, i) - if (PrintCMSStatistics > 0) { - gclog_or_tty->print(" (Survivor:" SIZE_FORMAT "chunks) ", i); - } + log_trace(gc, survivor)(" (Survivor:" SIZE_FORMAT "chunks) ", i); // Verify that we used up all the recorded entries #ifdef ASSERT size_t total = 0; @@ -4966,10 +4763,8 @@ // Check that the merged array is in sorted order if (total > 0) { for (size_t i = 0; i < total - 1; i++) { - if (PrintCMSStatistics > 0) { - gclog_or_tty->print(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ", - i, p2i(_survivor_chunk_array[i])); - } + log_develop_trace(gc, survivor)(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ", + i, p2i(_survivor_chunk_array[i])); assert(_survivor_chunk_array[i] < _survivor_chunk_array[i+1], "Not sorted"); } @@ -5103,7 +4898,7 @@ NULL, // space is set further below &_markBitMap, &_markStack, &mrias_cl); { - GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Trace, gc) t("Grey Object Rescan", _gc_timer_cm); // Iterate over the dirty cards, setting the corresponding bits in the // mod union table. { @@ -5128,10 +4923,7 @@ _modUnionTable.dirty_range_iterate_clear(cms_span, &markFromDirtyCardsClosure); verify_work_stacks_empty(); - if (PrintCMSStatistics != 0) { - gclog_or_tty->print(" (re-scanned " SIZE_FORMAT " dirty cards in cms gen) ", - markFromDirtyCardsClosure.num_dirty_cards()); - } + log_trace(gc)(" (re-scanned " SIZE_FORMAT " dirty cards in cms gen) ", markFromDirtyCardsClosure.num_dirty_cards()); } } if (VerifyDuringGC && @@ -5140,7 +4932,7 @@ Universe::verify(); } { - GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Trace, gc) t("Root Rescan", _gc_timer_cm); verify_work_stacks_empty(); @@ -5162,7 +4954,7 @@ } { - GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Trace, gc) t("Visit Unhandled CLDs", _gc_timer_cm); verify_work_stacks_empty(); @@ -5181,7 +4973,7 @@ } { - GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Trace, gc) t("Dirty Klass Scan", _gc_timer_cm); verify_work_stacks_empty(); @@ -5343,11 +5135,7 @@ break; // nirvana from the infinite cycle } } - NOT_PRODUCT( - if (PrintCMSStatistics != 0) { - gclog_or_tty->print("\n\t(%d: stole %d oops)", i, num_steals); - } - ) + log_develop_trace(gc, task)("\t(%d: stole %d oops)", i, num_steals); } void CMSRefProcTaskExecutor::execute(ProcessTask& task) @@ -5389,7 +5177,7 @@ _span, &_markBitMap, &_markStack, &cmsKeepAliveClosure, false /* !preclean */); { - GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Weak Refs Processing", _gc_timer_cm); ReferenceProcessorStats stats; if (rp->processing_is_mt()) { @@ -5431,7 +5219,7 @@ if (should_unload_classes()) { { - GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Class Unloading", _gc_timer_cm); // Unload classes and purge the SystemDictionary. bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure); @@ -5444,13 +5232,13 @@ } { - GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Scrub Symbol Table", _gc_timer_cm); // Clean up unreferenced symbols in symbol table. SymbolTable::unlink(); } { - GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm); + GCTraceTime(Debug, gc) t("Scrub String Table", _gc_timer_cm); // Delete entries for dead interned strings. StringTable::unlink(&_is_alive_closure); } @@ -5517,8 +5305,8 @@ _intra_sweep_timer.reset(); _intra_sweep_timer.start(); { - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails); + GCTraceCPUTime tcpu; + CMSPhaseAccounting pa(this, "Concurrent Sweep"); // First sweep the old gen { CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(), @@ -5601,13 +5389,8 @@ size_t largestOffset = pointer_delta(largestAddr, minAddr); size_t nearLargestOffset = (size_t)((double)largestOffset * nearLargestPercent) - MinChunkSize; - if (PrintFLSStatistics != 0) { - gclog_or_tty->print_cr( - "CMS: Large Block: " PTR_FORMAT ";" - " Proximity: " PTR_FORMAT " -> " PTR_FORMAT, - p2i(largestAddr), - p2i(_cmsSpace->nearLargestChunk()), p2i(minAddr + nearLargestOffset)); - } + log_debug(gc, freelist)("CMS: Large Block: " PTR_FORMAT "; Proximity: " PTR_FORMAT " -> " PTR_FORMAT, + p2i(largestAddr), p2i(_cmsSpace->nearLargestChunk()), p2i(minAddr + nearLargestOffset)); _cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset); } @@ -5701,8 +5484,8 @@ // 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); + GCTraceCPUTime tcpu; + CMSPhaseAccounting cmspa(this, "Concurrent Reset"); HeapWord* curAddr = _markBitMap.startWord(); while (curAddr < _markBitMap.endWord()) { @@ -5718,9 +5501,7 @@ bitMapLock()->unlock(); ConcurrentMarkSweepThread::desynchronize(true); stopTimer(); - if (PrintCMSStatistics != 0) { - incrementYields(); - } + incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -5757,25 +5538,20 @@ } void CMSCollector::do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause) { - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL); + GCTraceCPUTime tcpu; TraceCollectorStats tcs(counters()); switch (op) { case CMS_op_checkpointRootsInitial: { + GCTraceTime(Info, gc) t("Pause Initial Mark", NULL, GCCause::_no_gc, true); SvcGCMarker sgcm(SvcGCMarker::OTHER); checkpointRootsInitial(); - if (PrintGC) { - _cmsGen->printOccupancy("initial-mark"); - } break; } case CMS_op_checkpointRootsFinal: { + GCTraceTime(Info, gc) t("Pause Remark", NULL, GCCause::_no_gc, true); SvcGCMarker sgcm(SvcGCMarker::OTHER); checkpointRootsFinal(); - if (PrintGC) { - _cmsGen->printOccupancy("remark"); - } break; } default: @@ -5988,9 +5764,9 @@ void CMSMarkStack::expand() { assert(_capacity <= MarkStackSizeMax, "stack bigger than permitted"); if (_capacity == MarkStackSizeMax) { - if (_hit_limit++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { + if (_hit_limit++ == 0 && !CMSConcurrentMTEnabled) { // We print a warning message only once per CMS cycle. - gclog_or_tty->print_cr(" (benign) Hit CMSMarkStack max size limit"); + log_debug(gc)(" (benign) Hit CMSMarkStack max size limit"); } return; } @@ -6010,12 +5786,11 @@ _base = (oop*)(_virtual_space.low()); _index = 0; _capacity = new_capacity; - } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { + } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled) { // Failed to double capacity, continue; // we print a detail message only once per CMS cycle. - gclog_or_tty->print(" (benign) Failed to expand marking stack from " SIZE_FORMAT "K to " - SIZE_FORMAT "K", - _capacity / K, new_capacity / K); + log_debug(gc)(" (benign) Failed to expand marking stack from " SIZE_FORMAT "K to " SIZE_FORMAT "K", + _capacity / K, new_capacity / K); } } @@ -6092,8 +5867,10 @@ if (_span.contains(addr)) { _verification_bm->mark(addr); if (!_cms_bm->isMarked(addr)) { - oop(addr)->print(); - gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", p2i(addr)); + LogHandle(gc, verify) log; + ResourceMark rm; + oop(addr)->print_on(log.info_stream()); + log.info(" (" INTPTR_FORMAT " should have been marked)", p2i(addr)); fatal("... aborting"); } } @@ -6189,9 +5966,7 @@ _freelistLock->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; @@ -6347,9 +6122,7 @@ _freelistLock->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -6416,9 +6189,7 @@ _bit_map->lock()->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -6571,9 +6342,7 @@ _bitMap->lock()->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -6879,17 +6648,15 @@ // Oop lies in _span and isn't yet grey or black _verification_bm->mark(addr); // now grey if (!_cms_bm->isMarked(addr)) { - oop(addr)->print(); - gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", - p2i(addr)); + LogHandle(gc, verify) log; + ResourceMark rm; + oop(addr)->print_on(log.info_stream()); + log.info(" (" INTPTR_FORMAT " should have been marked)", p2i(addr)); fatal("... aborting"); } if (!_mark_stack->push(obj)) { // stack overflow - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " - SIZE_FORMAT, _mark_stack->capacity()); - } + log_trace(gc)("CMS marking stack overflow (benign) at " SIZE_FORMAT, _mark_stack->capacity()); assert(_mark_stack->isFull(), "Else push should have succeeded"); handle_stack_overflow(addr); } @@ -6989,10 +6756,7 @@ } ) if (simulate_overflow || !_markStack->push(obj)) { // stack overflow - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " - SIZE_FORMAT, _markStack->capacity()); - } + log_trace(gc)("CMS marking stack overflow (benign) at " SIZE_FORMAT, _markStack->capacity()); assert(simulate_overflow || _markStack->isFull(), "Else push should have succeeded"); handle_stack_overflow(addr); } @@ -7041,10 +6805,7 @@ if (simulate_overflow || !(_work_queue->push(obj) || _overflow_stack->par_push(obj))) { // stack overflow - if (PrintCMSStatistics != 0) { - gclog_or_tty->print_cr("CMS marking stack overflow (benign) at " - SIZE_FORMAT, _overflow_stack->capacity()); - } + log_trace(gc)("CMS marking stack overflow (benign) at " SIZE_FORMAT, _overflow_stack->capacity()); // We cannot assert that the overflow stack is full because // it may have been emptied since. assert(simulate_overflow || @@ -7206,9 +6967,7 @@ ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -7239,10 +6998,7 @@ // However, that would be too strong in one case -- the last // partition ends at _unallocated_block which, in general, can be // an arbitrary boundary, not necessarily card aligned. - if (PrintCMSStatistics != 0) { - _num_dirty_cards += - mr.word_size()/CardTableModRefBS::card_size_in_words; - } + _num_dirty_cards += mr.word_size()/CardTableModRefBS::card_size_in_words; _space->object_iterate_mem(mr, &_scan_cl); } @@ -7275,10 +7031,8 @@ ) assert(_limit >= _sp->bottom() && _limit <= _sp->end(), "sweep _limit out of bounds"); - if (CMSTraceSweeper) { - gclog_or_tty->print_cr("\n====================\nStarting new sweep with limit " PTR_FORMAT, - p2i(_limit)); - } + log_develop_trace(gc, sweep)("===================="); + log_develop_trace(gc, sweep)("Starting new sweep with limit " PTR_FORMAT, p2i(_limit)); } void SweepClosure::print_on(outputStream* st) const { @@ -7305,42 +7059,32 @@ print(); ShouldNotReachHere(); } - if (Verbose && PrintGC) { - gclog_or_tty->print("Collected " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", - _numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); - gclog_or_tty->print_cr("\nLive " SIZE_FORMAT " objects, " - SIZE_FORMAT " bytes " - "Already free " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", - _numObjectsLive, _numWordsLive*sizeof(HeapWord), - _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); - size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) - * sizeof(HeapWord); - gclog_or_tty->print_cr("Total sweep: " SIZE_FORMAT " bytes", totalBytes); - - if (PrintCMSStatistics && CMSVerifyReturnedBytes) { - size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); - size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes(); - size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes; - gclog_or_tty->print("Returned " SIZE_FORMAT " bytes", returned_bytes); - gclog_or_tty->print(" Indexed List Returned " SIZE_FORMAT " bytes", - indexListReturnedBytes); - gclog_or_tty->print_cr(" Dictionary Returned " SIZE_FORMAT " bytes", - dict_returned_bytes); - } - } - if (CMSTraceSweeper) { - gclog_or_tty->print_cr("end of sweep with _limit = " PTR_FORMAT "\n================", - p2i(_limit)); + + if (log_is_enabled(Debug, gc, sweep)) { + log_debug(gc, sweep)("Collected " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", + _numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); + log_debug(gc, sweep)("Live " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes Already free " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", + _numObjectsLive, _numWordsLive*sizeof(HeapWord), _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); + size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) * sizeof(HeapWord); + log_debug(gc, sweep)("Total sweep: " SIZE_FORMAT " bytes", totalBytes); + } + + if (log_is_enabled(Trace, gc, sweep) && CMSVerifyReturnedBytes) { + size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); + size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes(); + size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes; + log_trace(gc, sweep)("Returned " SIZE_FORMAT " bytes Indexed List Returned " SIZE_FORMAT " bytes Dictionary Returned " SIZE_FORMAT " bytes", + returned_bytes, indexListReturnedBytes, dict_returned_bytes); } + log_develop_trace(gc, sweep)("end of sweep with _limit = " PTR_FORMAT, p2i(_limit)); + log_develop_trace(gc, sweep)("================"); } #endif // PRODUCT void SweepClosure::initialize_free_range(HeapWord* freeFinger, bool freeRangeInFreeLists) { - if (CMSTraceSweeper) { - gclog_or_tty->print("---- Start free range at " PTR_FORMAT " with free block (%d)\n", - p2i(freeFinger), freeRangeInFreeLists); - } + log_develop_trace(gc, sweep)("---- Start free range at " PTR_FORMAT " with free block (%d)", + p2i(freeFinger), freeRangeInFreeLists); assert(!inFreeRange(), "Trampling existing free range"); set_inFreeRange(true); set_lastFreeRangeCoalesced(false); @@ -7406,13 +7150,9 @@ "freeFinger() " PTR_FORMAT " is out-of-bounds", p2i(freeFinger())); flush_cur_free_chunk(freeFinger(), pointer_delta(addr, freeFinger())); - if (CMSTraceSweeper) { - gclog_or_tty->print("Sweep: last chunk: "); - gclog_or_tty->print("put_free_blk " PTR_FORMAT " (" SIZE_FORMAT ") " - "[coalesced:%d]\n", - p2i(freeFinger()), pointer_delta(addr, freeFinger()), - lastFreeRangeCoalesced() ? 1 : 0); - } + log_develop_trace(gc, sweep)("Sweep: last chunk: put_free_blk " PTR_FORMAT " (" SIZE_FORMAT ") [coalesced:%d]", + p2i(freeFinger()), pointer_delta(addr, freeFinger()), + lastFreeRangeCoalesced() ? 1 : 0); } // help the iterator loop finish @@ -7623,9 +7363,7 @@ assert(_sp->verify_chunk_in_free_list(fc), "free chunk is not in free lists"); } - if (CMSTraceSweeper) { - gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", p2i(fc), chunkSize); - } + log_develop_trace(gc, sweep)(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", p2i(fc), chunkSize); HeapWord* const fc_addr = (HeapWord*) fc; @@ -7726,16 +7464,12 @@ p2i(eob), p2i(eob-1), p2i(_limit), p2i(_sp->bottom()), p2i(_sp->end()), p2i(fc), chunk_size); if (eob >= _limit) { assert(eob == _limit || fc->is_free(), "Only a free chunk should allow us to cross over the limit"); - if (CMSTraceSweeper) { - gclog_or_tty->print_cr("_limit " PTR_FORMAT " reached or crossed by block " - "[" PTR_FORMAT "," PTR_FORMAT ") in space " - "[" PTR_FORMAT "," PTR_FORMAT ")", - p2i(_limit), p2i(fc), p2i(eob), p2i(_sp->bottom()), p2i(_sp->end())); - } + log_develop_trace(gc, sweep)("_limit " PTR_FORMAT " reached or crossed by block " + "[" PTR_FORMAT "," PTR_FORMAT ") in space " + "[" PTR_FORMAT "," PTR_FORMAT ")", + p2i(_limit), p2i(fc), p2i(eob), p2i(_sp->bottom()), p2i(_sp->end())); // Return the storage we are tracking back into the free lists. - if (CMSTraceSweeper) { - gclog_or_tty->print_cr("Flushing ... "); - } + log_develop_trace(gc, sweep)("Flushing ... "); assert(freeFinger() < eob, "Error"); flush_cur_free_chunk( freeFinger(), pointer_delta(eob, freeFinger())); } @@ -7752,10 +7486,7 @@ assert(!_sp->verify_chunk_in_free_list(fc), "chunk should not be in free lists yet"); } - if (CMSTraceSweeper) { - gclog_or_tty->print_cr(" -- add free block " PTR_FORMAT " (" SIZE_FORMAT ") to free lists", - p2i(chunk), size); - } + log_develop_trace(gc, sweep)(" -- add free block " PTR_FORMAT " (" SIZE_FORMAT ") to free lists", p2i(chunk), size); // A new free range is going to be starting. The current // free range has not been added to the free lists yet or // was removed so add it back. @@ -7766,8 +7497,8 @@ } _sp->addChunkAndRepairOffsetTable(chunk, size, lastFreeRangeCoalesced()); - } else if (CMSTraceSweeper) { - gclog_or_tty->print_cr("Already in free list: nothing to flush"); + } else { + log_develop_trace(gc, sweep)("Already in free list: nothing to flush"); } set_inFreeRange(false); set_freeRangeInFreeLists(false); @@ -7798,9 +7529,7 @@ _freelistLock->unlock(); ConcurrentMarkSweepThread::desynchronize(true); _collector->stopTimer(); - if (PrintCMSStatistics != 0) { - _collector->incrementYields(); - } + _collector->incrementYields(); // See the comment in coordinator_yield() for (unsigned i = 0; i < CMSYieldSleepCount && @@ -7825,10 +7554,8 @@ #endif void SweepClosure::print_free_block_coalesced(FreeChunk* fc) const { - if (CMSTraceSweeper) { - gclog_or_tty->print_cr("Sweep:coal_free_blk " PTR_FORMAT " (" SIZE_FORMAT ")", - p2i(fc), fc->size()); - } + log_develop_trace(gc, sweep)("Sweep:coal_free_blk " PTR_FORMAT " (" SIZE_FORMAT ")", + p2i(fc), fc->size()); } // CMSIsAliveClosure --- old/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp 2015-12-01 12:06:04.982930933 +0100 +++ new/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp 2015-12-01 12:06:04.866930937 +0100 @@ -35,6 +35,7 @@ #include "gc/shared/generationCounters.hpp" #include "gc/shared/space.hpp" #include "gc/shared/taskqueue.hpp" +#include "logging/log.hpp" #include "memory/freeBlockDictionary.hpp" #include "memory/iterator.hpp" #include "memory/virtualspace.hpp" @@ -308,9 +309,8 @@ void reset() { _index = 0; - if (_overflows > 0 && PrintCMSStatistics > 1) { - warning("CMS: ChunkArray[" SIZE_FORMAT "] overflowed " SIZE_FORMAT " times", - _capacity, _overflows); + if (_overflows > 0) { + log_trace(gc)("CMS: ChunkArray[" SIZE_FORMAT "] overflowed " SIZE_FORMAT " times", _capacity, _overflows); } _overflows = 0; } @@ -451,7 +451,7 @@ // Debugging. void print_on(outputStream* st) const PRODUCT_RETURN; - void print() const { print_on(gclog_or_tty); } + void print() const { print_on(tty); } }; // A closure related to weak references processing which @@ -935,7 +935,7 @@ void startTimer() { assert(!_timer.is_active(), "Error"); _timer.start(); } void stopTimer() { assert( _timer.is_active(), "Error"); _timer.stop(); } void resetTimer() { assert(!_timer.is_active(), "Error"); _timer.reset(); } - double timerValue() { assert(!_timer.is_active(), "Error"); return _timer.seconds(); } + jlong timerTicks() { assert(!_timer.is_active(), "Error"); return _timer.ticks(); } int yields() { return _numYields; } void resetYields() { _numYields = 0; } @@ -961,7 +961,7 @@ // Debugging void verify(); - bool verify_after_remark(bool silent = VerifySilently); + bool verify_after_remark(); void verify_ok_to_terminate() const PRODUCT_RETURN; void verify_work_stacks_empty() const PRODUCT_RETURN; void verify_overflow_empty() const PRODUCT_RETURN; @@ -1234,7 +1234,6 @@ const char* name() const; virtual const char* short_name() const { return "CMS"; } void print() const; - void printOccupancy(const char* s); // Resize the generation after a compacting GC. The // generation can be treated as a contiguous space --- old/src/share/vm/gc/cms/parNewGeneration.cpp 2015-12-01 12:06:05.170930927 +0100 +++ new/src/share/vm/gc/cms/parNewGeneration.cpp 2015-12-01 12:06:05.070930930 +0100 @@ -34,7 +34,7 @@ #include "gc/shared/gcHeapSummary.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/generation.hpp" @@ -45,6 +45,7 @@ #include "gc/shared/strongRootsScope.hpp" #include "gc/shared/taskqueue.inline.hpp" #include "gc/shared/workgroup.hpp" +#include "logging/log.hpp" #include "memory/resourceArea.hpp" #include "oops/objArrayOop.hpp" #include "oops/oop.inline.hpp" @@ -270,9 +271,9 @@ } void ParScanThreadState::print_promotion_failure_size() { - if (_promotion_failed_info.has_failed() && PrintPromotionFailure) { - gclog_or_tty->print(" (%d: promotion failure size = " SIZE_FORMAT ") ", - _thread_num, _promotion_failed_info.first_size()); + if (_promotion_failed_info.has_failed()) { + log_trace(gc, promotion)(" (%d: promotion failure size = " SIZE_FORMAT ") ", + _thread_num, _promotion_failed_info.first_size()); } } @@ -298,11 +299,11 @@ #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); + print_termination_stats_hdr(outputStream* const st); + void print_termination_stats(); static void - print_taskqueue_stats_hdr(outputStream* const st = gclog_or_tty); - void print_taskqueue_stats(outputStream* const st = gclog_or_tty); + print_taskqueue_stats_hdr(outputStream* const st); + void print_taskqueue_stats(); void reset_stats(); #endif // TASKQUEUE_STATS @@ -383,7 +384,15 @@ st->print_raw_cr("--- --------- --------- ------ --------- ------ --------"); } -void ParScanThreadStateSet::print_termination_stats(outputStream* const st) { +void ParScanThreadStateSet::print_termination_stats() { + LogHandle(gc, task, stats) log; + if (!log.is_debug()) { + return; + } + + ResourceMark rm; + outputStream* st = log.debug_stream(); + print_termination_stats_hdr(st); for (int i = 0; i < length(); ++i) { @@ -404,7 +413,13 @@ st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); } -void ParScanThreadStateSet::print_taskqueue_stats(outputStream* const st) { +void ParScanThreadStateSet::print_taskqueue_stats() { + if (!develop_log_is_enabled(Trace, gc, task, stats)) { + return; + } + LogHandle(gc, task, stats) log; + ResourceMark rm; + outputStream* st = log.trace_stream(); print_taskqueue_stats_hdr(st); TaskQueueStats totals; @@ -823,9 +838,7 @@ _promo_failure_scan_stack.clear(true); // Clear cached segments. remove_forwarding_pointers(); - if (PrintGCDetails) { - gclog_or_tty->print(" (promotion failed)"); - } + log_info(gc, promotion)("Promotion failed"); // All the spaces are in play for mark-sweep. swap_spaces(); // Make life simpler for CMS || rescan; see 6483690. from()->set_next_compaction_space(to()); @@ -882,9 +895,7 @@ size_policy->minor_collection_begin(); } - GCTraceTime t1(GCCauseString("GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL); - // Capture heap used before collection (for printing). - size_t gch_prev_used = gch->used(); + GCTraceTime(Trace, gc) t1("ParNew", NULL, gch->gc_cause()); age_table()->clear(); to()->clear(SpaceDecorator::Mangle); @@ -990,12 +1001,8 @@ plab_stats()->adjust_desired_plab_sz(); } - if (PrintGC && !PrintGCDetails) { - gch->print_heap_change(gch_prev_used); - } - - TASKQUEUE_STATS_ONLY(if (PrintTerminationStats) thread_state_set.print_termination_stats()); - TASKQUEUE_STATS_ONLY(if (PrintTaskqueue) thread_state_set.print_taskqueue_stats()); + 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()); @@ -1148,15 +1155,11 @@ } assert(new_obj != NULL, "just checking"); -#ifndef PRODUCT // This code must come after the CAS test, or it will print incorrect // information. - if (TraceScavenge) { - gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", + log_develop_trace(gc, scavenge)("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", is_in_reserved(new_obj) ? "copying" : "tenuring", new_obj->klass()->internal_name(), p2i(old), p2i(new_obj), new_obj->size()); - } -#endif if (forward_ptr == NULL) { oop obj_to_push = new_obj; @@ -1178,9 +1181,7 @@ ) if (simulate_overflow || !par_scan_state->work_queue()->push(obj_to_push)) { // Add stats for overflow pushes. - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("queue overflow!\n"); - } + log_develop_trace(gc)("Queue Overflow"); push_on_overflow_list(old, par_scan_state); TASKQUEUE_STATS_ONLY(par_scan_state->taskqueue_stats().record_overflow(0)); } --- old/src/share/vm/gc/cms/parOopClosures.inline.hpp 2015-12-01 12:06:05.354930920 +0100 +++ new/src/share/vm/gc/cms/parOopClosures.inline.hpp 2015-12-01 12:06:05.266930924 +0100 @@ -30,6 +30,7 @@ #include "gc/shared/cardTableRS.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/genOopClosures.inline.hpp" +#include "logging/log.hpp" template inline void ParScanWeakRefClosure::do_oop_work(T* p) { assert (!oopDesc::is_null(*p), "null weak reference?"); @@ -108,14 +109,8 @@ if (m->is_marked()) { // Contains forwarding pointer. new_obj = ParNewGeneration::real_forwardee(obj); oopDesc::encode_store_heap_oop_not_null(p, new_obj); -#ifndef PRODUCT - if (TraceScavenge) { - gclog_or_tty->print_cr("{%s %s ( " PTR_FORMAT " ) " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", - "forwarded ", + log_develop_trace(gc, scavenge)("{forwarded %s ( " PTR_FORMAT " ) " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", new_obj->klass()->internal_name(), p2i(p), p2i((void *)obj), p2i((void *)new_obj), new_obj->size()); - } -#endif - } else { size_t obj_sz = obj->size_given_klass(objK); new_obj = _g->copy_to_survivor_space(_par_scan_state, obj, obj_sz, m); --- old/src/share/vm/gc/cms/promotionInfo.hpp 2015-12-01 12:06:05.558930913 +0100 +++ new/src/share/vm/gc/cms/promotionInfo.hpp 2015-12-01 12:06:05.438930918 +0100 @@ -132,7 +132,7 @@ } void print_on(outputStream* st) const; - void print() const { print_on(gclog_or_tty); } + void print() const { print_on(tty); } }; class PromotionInfo VALUE_OBJ_CLASS_SPEC { --- old/src/share/vm/gc/cms/vmCMSOperations.cpp 2015-12-01 12:06:05.750930907 +0100 +++ new/src/share/vm/gc/cms/vmCMSOperations.cpp 2015-12-01 12:06:05.626930911 +0100 @@ -28,7 +28,7 @@ #include "gc/cms/vmCMSOperations.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTimer.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "runtime/interfaceSupport.hpp" #include "runtime/os.hpp" @@ -58,7 +58,7 @@ void VM_CMS_Operation::verify_before_gc() { if (VerifyBeforeGC && GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { - GCTraceTime tm("Verify Before", false, false, _collector->_gc_timer_cm); + GCTraceTime(Info, gc, verify) tm("Verify Before", _collector->_gc_timer_cm); HandleMark hm; FreelistLocker x(_collector); MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag); @@ -70,7 +70,7 @@ void VM_CMS_Operation::verify_after_gc() { if (VerifyAfterGC && GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) { - GCTraceTime tm("Verify After", false, false, _collector->_gc_timer_cm); + GCTraceTime(Info, gc, verify) tm("Verify After", _collector->_gc_timer_cm); HandleMark hm; FreelistLocker x(_collector); MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag); --- old/src/share/vm/gc/g1/collectionSetChooser.cpp 2015-12-01 12:06:05.918930901 +0100 +++ new/src/share/vm/gc/g1/collectionSetChooser.cpp 2015-12-01 12:06:05.818930904 +0100 @@ -26,7 +26,6 @@ #include "gc/g1/collectionSetChooser.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" #include "gc/shared/space.inline.hpp" #include "runtime/atomic.inline.hpp" @@ -136,8 +135,8 @@ assert(regions_at(i) != NULL, "Should be true by sorting!"); } #endif // ASSERT - if (G1PrintRegionLivenessInfo) { - G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); + if (log_is_enabled(Trace, gc, liveness)) { + G1PrintRegionLivenessInfoClosure cl("Post-Sorting"); for (uint i = 0; i < _end; ++i) { HeapRegion* r = regions_at(i); cl.doHeapRegion(r); --- old/src/share/vm/gc/g1/concurrentG1RefineThread.cpp 2015-12-01 12:06:06.114930894 +0100 +++ new/src/share/vm/gc/g1/concurrentG1RefineThread.cpp 2015-12-01 12:06:05.990930898 +0100 @@ -28,6 +28,7 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/suspendibleThreadSet.hpp" +#include "logging/log.hpp" #include "memory/resourceArea.hpp" #include "runtime/handles.inline.hpp" #include "runtime/mutexLocker.hpp" @@ -88,11 +89,8 @@ void ConcurrentG1RefineThread::activate() { MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag); if (!is_primary()) { - if (G1TraceConcRefinement) { - DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); - gclog_or_tty->print_cr("G1-Refine-activated worker %d, on threshold %d, current %d", - _worker_id, _threshold, (int)dcqs.completed_buffers_num()); - } + log_debug(gc, refine)("G1-Refine-activated worker %d, on threshold %d, current %d", + _worker_id, _threshold, JavaThread::dirty_card_queue_set().completed_buffers_num()); set_active(true); } else { DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); @@ -104,11 +102,8 @@ void ConcurrentG1RefineThread::deactivate() { MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag); if (!is_primary()) { - if (G1TraceConcRefinement) { - DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); - gclog_or_tty->print_cr("G1-Refine-deactivated worker %d, off threshold %d, current %d", - _worker_id, _deactivation_threshold, (int)dcqs.completed_buffers_num()); - } + log_debug(gc, refine)("G1-Refine-deactivated worker %d, off threshold %d, current %d", + _worker_id, _deactivation_threshold, JavaThread::dirty_card_queue_set().completed_buffers_num()); set_active(false); } else { DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); @@ -174,9 +169,7 @@ } } - if (G1TraceConcRefinement) { - gclog_or_tty->print_cr("G1-Refine-stop"); - } + log_debug(gc, refine)("G1-Refine-stop"); } void ConcurrentG1RefineThread::stop() { @@ -199,4 +192,4 @@ void ConcurrentG1RefineThread::stop_service() { MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag); _monitor->notify(); -} \ No newline at end of file +} --- old/src/share/vm/gc/g1/concurrentMark.cpp 2015-12-01 12:06:06.302930887 +0100 +++ new/src/share/vm/gc/g1/concurrentMark.cpp 2015-12-01 12:06:06.186930891 +0100 @@ -31,8 +31,6 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1CollectorState.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1OopClosures.inline.hpp" #include "gc/g1/g1RemSet.hpp" #include "gc/g1/g1StringDedup.hpp" @@ -44,12 +42,13 @@ #include "gc/shared/gcId.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/strongRootsScope.hpp" #include "gc/shared/taskqueue.inline.hpp" #include "gc/shared/vmGCOperations.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/resourceArea.hpp" #include "oops/oop.inline.hpp" @@ -232,9 +231,7 @@ // Clear expansion flag _should_expand = false; if (_capacity == (jint) MarkStackSizeMax) { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" (benign) Can't expand marking stack capacity, at max size limit"); - } + log_trace(gc)("(benign) Can't expand marking stack capacity, at max size limit"); return; } // Double capacity if possible @@ -254,12 +251,9 @@ _index = 0; _capacity = new_capacity; } else { - if (PrintGCDetails && Verbose) { - // Failed to double capacity, continue; - gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from " - SIZE_FORMAT "K to " SIZE_FORMAT "K", - _capacity / K, new_capacity / K); - } + // Failed to double capacity, continue; + log_trace(gc)("(benign) Failed to expand marking stack capacity from " SIZE_FORMAT "K to " SIZE_FORMAT "K", + _capacity / K, new_capacity / K); } } @@ -848,10 +842,7 @@ // marking. reset_marking_state(true /* clear_overflow */); - if (G1Log::fine()) { - gclog_or_tty->gclog_stamp(); - gclog_or_tty->print_cr("[GC concurrent-mark-reset-for-overflow]"); - } + log_info(gc)("Concurrent Mark reset for overflow"); } } @@ -987,8 +978,6 @@ }; void ConcurrentMark::scanRootRegions() { - double scan_start = os::elapsedTime(); - // Start of concurrent marking. ClassLoaderDataGraph::clear_claimed_marks(); @@ -996,10 +985,7 @@ // at least one root region to scan. So, if it's false, we // should not attempt to do any further work. if (root_regions()->scan_in_progress()) { - if (G1Log::fine()) { - gclog_or_tty->gclog_stamp(); - gclog_or_tty->print_cr("[GC concurrent-root-region-scan-start]"); - } + GCTraceConcTime(Info, gc) tt("Concurrent Root Region Scan"); _parallel_marking_threads = calc_parallel_marking_threads(); assert(parallel_marking_threads() <= max_parallel_marking_threads(), @@ -1010,11 +996,6 @@ _parallel_workers->set_active_workers(active_workers); _parallel_workers->run_task(&task); - if (G1Log::fine()) { - gclog_or_tty->gclog_stamp(); - gclog_or_tty->print_cr("[GC concurrent-root-region-scan-end, %1.7lf secs]", os::elapsedTime() - scan_start); - } - // It's possible that has_aborted() is true here without actually // aborting the survivor scan earlier. This is OK as it's // mainly used for sanity checking. @@ -1049,22 +1030,6 @@ print_stats(); } -// Helper class to get rid of some boilerplate code. -class G1CMTraceTime : public StackObj { - GCTraceTimeImpl _gc_trace_time; - static bool doit_and_prepend(bool doit) { - if (doit) { - gclog_or_tty->put(' '); - } - return doit; - } - - public: - G1CMTraceTime(const char* title, bool doit) - : _gc_trace_time(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm()) { - } -}; - void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) { // world is stopped at this checkpoint assert(SafepointSynchronize::is_at_safepoint(), @@ -1083,8 +1048,7 @@ if (VerifyDuringGC) { HandleMark hm; // handle scope g1h->prepare_for_verify(); - Universe::verify(VerifyOption_G1UsePrevMarking, - " VerifyDuringGC:(before)"); + Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (before)"); } g1h->check_bitmaps("Remark Start"); @@ -1102,16 +1066,13 @@ if (has_overflown()) { // Oops. We overflowed. Restart concurrent marking. _restart_for_overflow = true; - if (G1TraceMarkStackOverflow) { - gclog_or_tty->print_cr("\nRemark led to restart for overflow."); - } + log_develop_trace(gc)("Remark led to restart for overflow."); // Verify the heap w.r.t. the previous marking bitmap. if (VerifyDuringGC) { HandleMark hm; // handle scope g1h->prepare_for_verify(); - Universe::verify(VerifyOption_G1UsePrevMarking, - " VerifyDuringGC:(overflow)"); + Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (overflow)"); } // Clear the marking state because we will be restarting @@ -1119,7 +1080,7 @@ reset_marking_state(); } else { { - G1CMTraceTime trace("GC aggregate-data", G1Log::finer()); + GCTraceTime(Debug, gc) trace("GC Aggregate Data", g1h->gc_timer_cm()); // Aggregate the per-task counting data that we have accumulated // while marking. @@ -1136,8 +1097,7 @@ if (VerifyDuringGC) { HandleMark hm; // handle scope g1h->prepare_for_verify(); - Universe::verify(VerifyOption_G1UseNextMarking, - " VerifyDuringGC:(after)"); + Universe::verify(VerifyOption_G1UseNextMarking, "During GC (after)"); } g1h->check_bitmaps("Remark End"); assert(!restart_for_overflow(), "sanity"); @@ -1656,8 +1616,7 @@ if (VerifyDuringGC) { HandleMark hm; // handle scope g1h->prepare_for_verify(); - Universe::verify(VerifyOption_G1UsePrevMarking, - " VerifyDuringGC:(before)"); + Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (before)"); } g1h->check_bitmaps("Cleanup Start"); @@ -1699,8 +1658,8 @@ double this_final_counting_time = (count_end - start); _total_counting_time += this_final_counting_time; - if (G1PrintRegionLivenessInfo) { - G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Marking"); + if (log_is_enabled(Trace, gc, liveness)) { + G1PrintRegionLivenessInfoClosure cl("Post-Marking"); _g1h->heap_region_iterate(&cl); } @@ -1743,10 +1702,6 @@ double end = os::elapsedTime(); _cleanup_times.add((end - start) * 1000.0); - if (G1Log::fine()) { - g1h->g1_policy()->print_heap_transition(start_used_bytes); - } - // Clean up will have freed any regions completely full of garbage. // Update the soft reference policy with the new heap occupancy. Universe::update_heap_info_at_gc(); @@ -1754,8 +1709,7 @@ if (VerifyDuringGC) { HandleMark hm; // handle scope g1h->prepare_for_verify(); - Universe::verify(VerifyOption_G1UsePrevMarking, - " VerifyDuringGC:(after)"); + Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (after)"); } g1h->check_bitmaps("Cleanup End"); @@ -1788,11 +1742,9 @@ _cleanup_list.verify_optional(); FreeRegionList tmp_free_list("Tmp Free List"); - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : " - "cleanup list has %u entries", - _cleanup_list.length()); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [complete cleanup] : " + "cleanup list has %u entries", + _cleanup_list.length()); // No one else should be accessing the _cleanup_list at this point, // so it is not necessary to take any locks @@ -1810,13 +1762,11 @@ // region from the _cleanup_list). if ((tmp_free_list.length() % G1SecondaryFreeListAppendLength == 0) || _cleanup_list.is_empty()) { - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : " - "appending %u entries to the secondary_free_list, " - "cleanup list still has %u entries", - tmp_free_list.length(), - _cleanup_list.length()); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [complete cleanup] : " + "appending %u entries to the secondary_free_list, " + "cleanup list still has %u entries", + tmp_free_list.length(), + _cleanup_list.length()); { MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); @@ -2073,7 +2023,7 @@ // Inner scope to exclude the cleaning of the string and symbol // tables from the displayed time. { - G1CMTraceTime t("GC ref-proc", G1Log::finer()); + GCTraceTime(Debug, gc) trace("GC Ref Proc", g1h->gc_timer_cm()); ReferenceProcessor* rp = g1h->ref_processor_cm(); @@ -2163,24 +2113,24 @@ // Unload Klasses, String, Symbols, Code Cache, etc. { - G1CMTraceTime trace("Unloading", G1Log::finer()); + GCTraceTime(Debug, gc) trace("Unloading", g1h->gc_timer_cm()); if (ClassUnloadingWithConcurrentMark) { bool purged_classes; { - G1CMTraceTime trace("System Dictionary Unloading", G1Log::finest()); + GCTraceTime(Trace, gc) trace("System Dictionary Unloading", g1h->gc_timer_cm()); purged_classes = SystemDictionary::do_unloading(&g1_is_alive, false /* Defer klass cleaning */); } { - G1CMTraceTime trace("Parallel Unloading", G1Log::finest()); + GCTraceTime(Trace, gc) trace("Parallel Unloading", g1h->gc_timer_cm()); weakRefsWorkParallelPart(&g1_is_alive, purged_classes); } } if (G1StringDedup::is_enabled()) { - G1CMTraceTime trace("String Deduplication Unlink", G1Log::finest()); + GCTraceTime(Trace, gc) trace("String Deduplication Unlink", g1h->gc_timer_cm()); G1StringDedup::unlink(&g1_is_alive); } } @@ -2301,7 +2251,7 @@ HandleMark hm; G1CollectedHeap* g1h = G1CollectedHeap::heap(); - G1CMTraceTime trace("Finalize Marking", G1Log::finer()); + GCTraceTime(Debug, gc) trace("Finalize Marking", g1h->gc_timer_cm()); g1h->ensure_parsability(false); @@ -2614,12 +2564,13 @@ } void ConcurrentMark::print_stats() { - if (G1MarkingVerboseLevel > 0) { - gclog_or_tty->print_cr("---------------------------------------------------------------------"); - for (size_t i = 0; i < _active_tasks; ++i) { - _tasks[i]->print_stats(); - gclog_or_tty->print_cr("---------------------------------------------------------------------"); - } + if (!log_is_enabled(Debug, gc, stats)) { + return; + } + log_debug(gc, stats)("---------------------------------------------------------------------"); + for (size_t i = 0; i < _active_tasks; ++i) { + _tasks[i]->print_stats(); + log_debug(gc, stats)("---------------------------------------------------------------------"); } } @@ -2663,16 +2614,21 @@ static void print_ms_time_info(const char* prefix, const char* name, NumberSeq& ns) { - gclog_or_tty->print_cr("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).", + log_trace(gc, marking)("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).", prefix, ns.num(), name, ns.sum()/1000.0, ns.avg()); if (ns.num() > 0) { - gclog_or_tty->print_cr("%s [std. dev = %8.2f ms, max = %8.2f ms]", + log_trace(gc, marking)("%s [std. dev = %8.2f ms, max = %8.2f ms]", prefix, ns.sd(), ns.maximum()); } } void ConcurrentMark::print_summary_info() { - gclog_or_tty->print_cr(" Concurrent marking:"); + LogHandle(gc, marking) log; + if (!log.is_trace()) { + return; + } + + log.trace(" Concurrent marking:"); print_ms_time_info(" ", "init marks", _init_times); print_ms_time_info(" ", "remarks", _remark_times); { @@ -2681,25 +2637,16 @@ } print_ms_time_info(" ", "cleanups", _cleanup_times); - gclog_or_tty->print_cr(" Final counting total time = %8.2f s (avg = %8.2f ms).", - _total_counting_time, - (_cleanup_times.num() > 0 ? _total_counting_time * 1000.0 / - (double)_cleanup_times.num() - : 0.0)); + log.trace(" Final counting total time = %8.2f s (avg = %8.2f ms).", + _total_counting_time, (_cleanup_times.num() > 0 ? _total_counting_time * 1000.0 / (double)_cleanup_times.num() : 0.0)); if (G1ScrubRemSets) { - gclog_or_tty->print_cr(" RS scrub total time = %8.2f s (avg = %8.2f ms).", - _total_rs_scrub_time, - (_cleanup_times.num() > 0 ? _total_rs_scrub_time * 1000.0 / - (double)_cleanup_times.num() - : 0.0)); - } - gclog_or_tty->print_cr(" Total stop_world time = %8.2f s.", - (_init_times.sum() + _remark_times.sum() + - _cleanup_times.sum())/1000.0); - gclog_or_tty->print_cr(" Total concurrent time = %8.2f s " - "(%8.2f s marking).", - cmThread()->vtime_accum(), - cmThread()->vtime_mark_accum()); + log.trace(" RS scrub total time = %8.2f s (avg = %8.2f ms).", + _total_rs_scrub_time, (_cleanup_times.num() > 0 ? _total_rs_scrub_time * 1000.0 / (double)_cleanup_times.num() : 0.0)); + } + log.trace(" Total stop_world time = %8.2f s.", + (_init_times.sum() + _remark_times.sum() + _cleanup_times.sum())/1000.0); + log.trace(" Total concurrent time = %8.2f s (%8.2f s marking).", + cmThread()->vtime_accum(), cmThread()->vtime_mark_accum()); } void ConcurrentMark::print_worker_threads_on(outputStream* st) const { @@ -3079,15 +3026,15 @@ } void CMTask::print_stats() { - gclog_or_tty->print_cr("Marking Stats, task = %u, calls = %d", - _worker_id, _calls); - gclog_or_tty->print_cr(" Elapsed time = %1.2lfms, Termination time = %1.2lfms", - _elapsed_time_ms, _termination_time_ms); - gclog_or_tty->print_cr(" Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms", - _step_times_ms.num(), _step_times_ms.avg(), - _step_times_ms.sd()); - gclog_or_tty->print_cr(" max = %1.2lfms, total = %1.2lfms", - _step_times_ms.maximum(), _step_times_ms.sum()); + log_debug(gc, stats)("Marking Stats, task = %u, calls = %d", + _worker_id, _calls); + log_debug(gc, stats)(" Elapsed time = %1.2lfms, Termination time = %1.2lfms", + _elapsed_time_ms, _termination_time_ms); + log_debug(gc, stats)(" Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms", + _step_times_ms.num(), _step_times_ms.avg(), + _step_times_ms.sd()); + log_debug(gc, stats)(" max = %1.2lfms, total = %1.2lfms", + _step_times_ms.maximum(), _step_times_ms.sum()); } bool ConcurrentMark::try_stealing(uint worker_id, int* hash_seed, oop& obj) { @@ -3587,9 +3534,8 @@ #define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag) " / %1.2f %%" G1PrintRegionLivenessInfoClosure:: -G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name) - : _out(out), - _total_used_bytes(0), _total_capacity_bytes(0), +G1PrintRegionLivenessInfoClosure(const char* phase_name) + : _total_used_bytes(0), _total_capacity_bytes(0), _total_prev_live_bytes(0), _total_next_live_bytes(0), _hum_used_bytes(0), _hum_capacity_bytes(0), _hum_prev_live_bytes(0), _hum_next_live_bytes(0), @@ -3599,38 +3545,37 @@ double now = os::elapsedTime(); // Print the header of the output. - _out->cr(); - _out->print_cr(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now); - _out->print_cr(G1PPRL_LINE_PREFIX" HEAP" - G1PPRL_SUM_ADDR_FORMAT("reserved") - G1PPRL_SUM_BYTE_FORMAT("region-size"), - p2i(g1_reserved.start()), p2i(g1_reserved.end()), - HeapRegion::GrainBytes); - _out->print_cr(G1PPRL_LINE_PREFIX); - _out->print_cr(G1PPRL_LINE_PREFIX - G1PPRL_TYPE_H_FORMAT - G1PPRL_ADDR_BASE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_DOUBLE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT, - "type", "address-range", - "used", "prev-live", "next-live", "gc-eff", - "remset", "code-roots"); - _out->print_cr(G1PPRL_LINE_PREFIX - G1PPRL_TYPE_H_FORMAT - G1PPRL_ADDR_BASE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_DOUBLE_H_FORMAT - G1PPRL_BYTE_H_FORMAT - G1PPRL_BYTE_H_FORMAT, - "", "", - "(bytes)", "(bytes)", "(bytes)", "(bytes/ms)", - "(bytes)", "(bytes)"); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX" HEAP" + G1PPRL_SUM_ADDR_FORMAT("reserved") + G1PPRL_SUM_BYTE_FORMAT("region-size"), + p2i(g1_reserved.start()), p2i(g1_reserved.end()), + HeapRegion::GrainBytes); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX + G1PPRL_TYPE_H_FORMAT + G1PPRL_ADDR_BASE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_DOUBLE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT, + "type", "address-range", + "used", "prev-live", "next-live", "gc-eff", + "remset", "code-roots"); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX + G1PPRL_TYPE_H_FORMAT + G1PPRL_ADDR_BASE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_DOUBLE_H_FORMAT + G1PPRL_BYTE_H_FORMAT + G1PPRL_BYTE_H_FORMAT, + "", "", + "(bytes)", "(bytes)", "(bytes)", "(bytes/ms)", + "(bytes)", "(bytes)"); } // It takes as a parameter a reference to one of the _hum_* fields, it @@ -3701,18 +3646,18 @@ _total_strong_code_roots_bytes += strong_code_roots_bytes; // Print a line for this particular region. - _out->print_cr(G1PPRL_LINE_PREFIX - G1PPRL_TYPE_FORMAT - G1PPRL_ADDR_BASE_FORMAT - G1PPRL_BYTE_FORMAT - G1PPRL_BYTE_FORMAT - G1PPRL_BYTE_FORMAT - G1PPRL_DOUBLE_FORMAT - G1PPRL_BYTE_FORMAT - G1PPRL_BYTE_FORMAT, - type, p2i(bottom), p2i(end), - used_bytes, prev_live_bytes, next_live_bytes, gc_eff, - remset_bytes, strong_code_roots_bytes); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX + G1PPRL_TYPE_FORMAT + G1PPRL_ADDR_BASE_FORMAT + G1PPRL_BYTE_FORMAT + G1PPRL_BYTE_FORMAT + G1PPRL_BYTE_FORMAT + G1PPRL_DOUBLE_FORMAT + G1PPRL_BYTE_FORMAT + G1PPRL_BYTE_FORMAT, + type, p2i(bottom), p2i(end), + used_bytes, prev_live_bytes, next_live_bytes, gc_eff, + remset_bytes, strong_code_roots_bytes); return false; } @@ -3721,23 +3666,22 @@ // add static memory usages to remembered set sizes _total_remset_bytes += HeapRegionRemSet::fl_mem_size() + HeapRegionRemSet::static_mem_size(); // Print the footer of the output. - _out->print_cr(G1PPRL_LINE_PREFIX); - _out->print_cr(G1PPRL_LINE_PREFIX - " SUMMARY" - G1PPRL_SUM_MB_FORMAT("capacity") - G1PPRL_SUM_MB_PERC_FORMAT("used") - G1PPRL_SUM_MB_PERC_FORMAT("prev-live") - G1PPRL_SUM_MB_PERC_FORMAT("next-live") - G1PPRL_SUM_MB_FORMAT("remset") - G1PPRL_SUM_MB_FORMAT("code-roots"), - bytes_to_mb(_total_capacity_bytes), - bytes_to_mb(_total_used_bytes), - perc(_total_used_bytes, _total_capacity_bytes), - bytes_to_mb(_total_prev_live_bytes), - perc(_total_prev_live_bytes, _total_capacity_bytes), - bytes_to_mb(_total_next_live_bytes), - perc(_total_next_live_bytes, _total_capacity_bytes), - bytes_to_mb(_total_remset_bytes), - bytes_to_mb(_total_strong_code_roots_bytes)); - _out->cr(); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX); + log_trace(gc, liveness)(G1PPRL_LINE_PREFIX + " SUMMARY" + G1PPRL_SUM_MB_FORMAT("capacity") + G1PPRL_SUM_MB_PERC_FORMAT("used") + G1PPRL_SUM_MB_PERC_FORMAT("prev-live") + G1PPRL_SUM_MB_PERC_FORMAT("next-live") + G1PPRL_SUM_MB_FORMAT("remset") + G1PPRL_SUM_MB_FORMAT("code-roots"), + bytes_to_mb(_total_capacity_bytes), + bytes_to_mb(_total_used_bytes), + perc(_total_used_bytes, _total_capacity_bytes), + bytes_to_mb(_total_prev_live_bytes), + perc(_total_prev_live_bytes, _total_capacity_bytes), + bytes_to_mb(_total_next_live_bytes), + perc(_total_next_live_bytes, _total_capacity_bytes), + bytes_to_mb(_total_remset_bytes), + bytes_to_mb(_total_strong_code_roots_bytes)); } --- old/src/share/vm/gc/g1/concurrentMark.hpp 2015-12-01 12:06:06.554930879 +0100 +++ new/src/share/vm/gc/g1/concurrentMark.hpp 2015-12-01 12:06:06.458930882 +0100 @@ -978,8 +978,6 @@ // after we sort the old regions at the end of the cleanup operation. class G1PrintRegionLivenessInfoClosure: public HeapRegionClosure { private: - outputStream* _out; - // Accumulators for these values. size_t _total_used_bytes; size_t _total_capacity_bytes; @@ -1024,7 +1022,7 @@ public: // The header and footer are printed in the constructor and // destructor respectively. - G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name); + G1PrintRegionLivenessInfoClosure(const char* phase_name); virtual bool doHeapRegion(HeapRegion* r); ~G1PrintRegionLivenessInfoClosure(); }; --- old/src/share/vm/gc/g1/concurrentMarkThread.cpp 2015-12-01 12:06:06.758930872 +0100 +++ new/src/share/vm/gc/g1/concurrentMarkThread.cpp 2015-12-01 12:06:06.642930876 +0100 @@ -26,12 +26,13 @@ #include "gc/g1/concurrentMarkThread.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1MMUTracker.hpp" #include "gc/g1/suspendibleThreadSet.hpp" #include "gc/g1/vm_operations_g1.hpp" #include "gc/shared/gcId.hpp" #include "gc/shared/gcTrace.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" +#include "logging/log.hpp" #include "memory/resourceArea.hpp" #include "runtime/vmThread.hpp" @@ -78,20 +79,6 @@ } }; -// We want to avoid that the logging from the concurrent thread is mixed -// with the logging from a STW GC. So, if necessary join the STS to ensure -// that the logging is done either before or after the STW logging. -void ConcurrentMarkThread::cm_log(bool doit, bool join_sts, const char* fmt, ...) { - if (doit) { - SuspendibleThreadSetJoiner sts_joiner(join_sts); - va_list args; - va_start(args, fmt); - gclog_or_tty->gclog_stamp(); - gclog_or_tty->vprint_cr(fmt, args); - va_end(args); - } -} - // Marking pauses can be scheduled flexibly, so we might delay marking to meet MMU. void ConcurrentMarkThread::delay_to_keep_mmu(G1CollectorPolicy* g1_policy, bool remark) { if (g1_policy->adaptive_young_list_length()) { @@ -143,8 +130,11 @@ _cm->scanRootRegions(); } - double mark_start_sec = os::elapsedTime(); - cm_log(G1Log::fine(), true, "[GC concurrent-mark-start]"); + // It would be nice to use the GCTraceConcTime class here but + // the "end" logging is inside the loop and not at the end of + // a scope. Mimicking the same log output as GCTraceConcTime instead. + jlong mark_start = os::elapsed_counter(); + log_info(gc)("Concurrent Mark (%.3fs)", TimeHelper::counter_to_seconds(mark_start)); int iter = 0; do { @@ -154,20 +144,22 @@ } double mark_end_time = os::elapsedVTime(); - double mark_end_sec = os::elapsedTime(); + jlong mark_end = os::elapsed_counter(); _vtime_mark_accum += (mark_end_time - cycle_start); if (!cm()->has_aborted()) { delay_to_keep_mmu(g1_policy, true /* remark */); - - cm_log(G1Log::fine(), true, "[GC concurrent-mark-end, %1.7lf secs]", mark_end_sec - mark_start_sec); + log_info(gc)("Concurrent Mark (%.3fs, %.3fs) %.3fms", + TimeHelper::counter_to_seconds(mark_start), + TimeHelper::counter_to_seconds(mark_end), + TimeHelper::counter_to_millis(mark_end - mark_start)); CMCheckpointRootsFinalClosure final_cl(_cm); - VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */); + VM_CGC_Operation op(&final_cl, "Pause Remark", true /* needs_pll */); VMThread::execute(&op); } if (cm()->restart_for_overflow()) { - cm_log(G1TraceMarkStackOverflow, true, "Restarting conc marking because of MS overflow in remark (restart #%d).", iter); - cm_log(G1Log::fine(), true, "[GC concurrent-mark-restart-for-overflow]"); + log_debug(gc)("Restarting conc marking because of MS overflow in remark (restart #%d).", iter); + log_info(gc)("Concurrent Mark restart for overflow"); } } while (cm()->restart_for_overflow()); @@ -181,7 +173,7 @@ delay_to_keep_mmu(g1_policy, false /* cleanup */); CMCleanUp cl_cl(_cm); - VM_CGC_Operation op(&cl_cl, "GC cleanup", false /* needs_pll */); + VM_CGC_Operation op(&cl_cl, "Pause Cleanup", false /* needs_pll */); VMThread::execute(&op); } else { // We don't want to update the marking status if a GC pause @@ -201,8 +193,7 @@ // place, it would wait for us to process the regions // reclaimed by cleanup. - double cleanup_start_sec = os::elapsedTime(); - cm_log(G1Log::fine(), false, "[GC concurrent-cleanup-start]"); + GCTraceConcTime(Info, gc) tt("Concurrent Cleanup"); // Now do the concurrent cleanup operation. _cm->completeCleanup(); @@ -217,9 +208,6 @@ // while it's trying to join the STS, which is conditional on // the GC workers finishing. g1h->reset_free_regions_coming(); - - double cleanup_end_sec = os::elapsedTime(); - cm_log(G1Log::fine(), true, "[GC concurrent-cleanup-end, %1.7lf secs]", cleanup_end_sec - cleanup_start_sec); } guarantee(cm()->cleanup_list_is_empty(), "at this point there should be no regions on the cleanup list"); @@ -253,7 +241,7 @@ if (!cm()->has_aborted()) { g1_policy->record_concurrent_mark_cleanup_completed(); } else { - cm_log(G1Log::fine(), false, "[GC concurrent-mark-abort]"); + log_info(gc)("Concurrent Mark abort"); } } --- old/src/share/vm/gc/g1/concurrentMarkThread.hpp 2015-12-01 12:06:06.958930865 +0100 +++ new/src/share/vm/gc/g1/concurrentMarkThread.hpp 2015-12-01 12:06:06.842930869 +0100 @@ -40,7 +40,6 @@ double _vtime_accum; // Accumulated virtual time. double _vtime_mark_accum; - void cm_log(bool doit, bool join_sts, const char* fmt, ...) ATTRIBUTE_PRINTF(4, 5); public: virtual void run(); --- old/src/share/vm/gc/g1/g1BlockOffsetTable.cpp 2015-12-01 12:06:07.130930859 +0100 +++ new/src/share/vm/gc/g1/g1BlockOffsetTable.cpp 2015-12-01 12:06:07.030930862 +0100 @@ -27,6 +27,7 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/heapRegion.hpp" #include "gc/shared/space.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" #include "services/memTracker.hpp" @@ -50,14 +51,9 @@ storage->set_mapping_changed_listener(&_listener); - if (TraceBlockOffsetTable) { - gclog_or_tty->print_cr("G1BlockOffsetSharedArray::G1BlockOffsetSharedArray: "); - gclog_or_tty->print_cr(" " - " rs.base(): " PTR_FORMAT - " rs.size(): " SIZE_FORMAT - " rs end(): " PTR_FORMAT, - p2i(bot_reserved.start()), bot_reserved.byte_size(), p2i(bot_reserved.end())); - } + log_trace(gc, bot)("G1BlockOffsetSharedArray::G1BlockOffsetSharedArray: "); + log_trace(gc, bot)(" rs.base(): " PTR_FORMAT " rs.size(): " SIZE_FORMAT " rs end(): " PTR_FORMAT, + p2i(bot_reserved.start()), bot_reserved.byte_size(), p2i(bot_reserved.end())); } bool G1BlockOffsetSharedArray::is_card_boundary(HeapWord* p) const { --- old/src/share/vm/gc/g1/g1CollectedHeap.cpp 2015-12-01 12:06:07.330930852 +0100 +++ new/src/share/vm/gc/g1/g1CollectedHeap.cpp 2015-12-01 12:06:07.210930856 +0100 @@ -35,10 +35,8 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1CollectorState.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" #include "gc/g1/g1EvacStats.inline.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1MarkSweep.hpp" #include "gc/g1/g1OopClosures.inline.hpp" #include "gc/g1/g1ParScanThreadState.inline.hpp" @@ -58,11 +56,12 @@ #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/generationSpec.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/taskqueue.inline.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/iterator.hpp" #include "oops/oop.inline.hpp" @@ -223,11 +222,9 @@ MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); while (!_secondary_free_list.is_empty() || free_regions_coming()) { if (!_secondary_free_list.is_empty()) { - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "secondary_free_list has %u entries", - _secondary_free_list.length()); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [region alloc] : " + "secondary_free_list has %u entries", + _secondary_free_list.length()); // It looks as if there are free regions available on the // secondary_free_list. Let's move them to the free_list and try // again to allocate from it. @@ -236,11 +233,9 @@ assert(_hrm.num_free_regions() > 0, "if the secondary_free_list was not " "empty we should have moved at least one entry to the free_list"); HeapRegion* res = _hrm.allocate_free_region(is_old); - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "allocated " HR_FORMAT " from secondary_free_list", - HR_FORMAT_PARAMS(res)); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [region alloc] : " + "allocated " HR_FORMAT " from secondary_free_list", + HR_FORMAT_PARAMS(res)); return res; } @@ -250,10 +245,8 @@ SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); } - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "could not allocate from secondary_free_list"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [region alloc] : " + "could not allocate from secondary_free_list"); return NULL; } @@ -265,10 +258,8 @@ HeapRegion* res; if (G1StressConcRegionFreeing) { if (!_secondary_free_list.is_empty()) { - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "forced to look at the secondary_free_list"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [region alloc] : " + "forced to look at the secondary_free_list"); res = new_region_try_secondary_free_list(is_old); if (res != NULL) { return res; @@ -279,10 +270,8 @@ res = _hrm.allocate_free_region(is_old); if (res == NULL) { - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " - "res == NULL, trying the secondary_free_list"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [region alloc] : " + "res == NULL, trying the secondary_free_list"); res = new_region_try_secondary_free_list(is_old); } if (res == NULL && do_expand && _expand_heap_after_alloc_failure) { @@ -292,11 +281,9 @@ // reconsider the use of _expand_heap_after_alloc_failure. assert(SafepointSynchronize::is_at_safepoint(), "invariant"); - ergo_verbose1(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("region allocation request failed") - ergo_format_byte("allocation request"), - word_size * HeapWordSize); + log_debug(gc, ergo, heap)("Attempt heap expansion (region allocation request failed). Allocation request: " SIZE_FORMAT "B", + word_size * HeapWordSize); + if (expand(word_size * HeapWordSize)) { // Given that expand() succeeded in expanding the heap, and we // always expand the heap by an amount aligned to the heap @@ -484,11 +471,9 @@ if (first != G1_NO_HRM_INDEX) { // We found something. Make sure these regions are committed, i.e. expand // the heap. Alternatively we could do a defragmentation GC. - ergo_verbose1(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("humongous allocation request failed") - ergo_format_byte("allocation request"), - word_size * HeapWordSize); + log_debug(gc, ergo, heap)("Attempt heap expansion (humongous allocation request failed). Allocation request: " SIZE_FORMAT "B", + word_size * HeapWordSize); + _hrm.expand_at(first, obj_regions); g1_policy()->record_new_heap_size(num_regions()); @@ -807,11 +792,9 @@ } increase_used(word_size * HeapWordSize); if (commits != 0) { - ergo_verbose1(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("allocate archive regions") - ergo_format_byte("total size"), - HeapRegion::GrainWords * HeapWordSize * commits); + log_debug(gc, ergo, heap)("Attempt heap expansion (allocate archive regions). Total size: " SIZE_FORMAT "B", + HeapRegion::GrainWords * HeapWordSize * commits); + } // Mark each G1 region touched by the range as archive, add it to the old set, @@ -992,11 +975,8 @@ } if (uncommitted_regions != 0) { - ergo_verbose1(ErgoHeapSizing, - "attempt heap shrinking", - ergo_format_reason("uncommitted archive regions") - ergo_format_byte("total size"), - HeapRegion::GrainWords * HeapWordSize * uncommitted_regions); + log_debug(gc, ergo, heap)("Attempt heap shrinking (uncommitted archive regions). Total size: " SIZE_FORMAT "B", + HeapRegion::GrainWords * HeapWordSize * uncommitted_regions); } decrease_used(size_used); } @@ -1235,8 +1215,11 @@ }; void G1CollectedHeap::print_hrm_post_compaction() { - PostCompactionPrinterClosure cl(hr_printer()); - heap_region_iterate(&cl); + if (_hr_printer.is_active()) { + PostCompactionPrinterClosure cl(hr_printer()); + heap_region_iterate(&cl); + } + } bool G1CollectedHeap::do_full_collection(bool explicit_gc, @@ -1257,7 +1240,6 @@ SvcGCMarker sgcm(SvcGCMarker::FULL); ResourceMark rm; - G1Log::update_level(); print_heap_before_gc(); trace_heap_before_gc(gc_tracer); @@ -1275,10 +1257,10 @@ // Timing assert(!GCCause::is_user_requested_gc(gc_cause()) || explicit_gc, "invariant"); - TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); + GCTraceCPUTime tcpu; { - GCTraceTime t(GCCauseString("Full GC", gc_cause()), G1Log::fine(), true, NULL); + GCTraceTime(Info, gc) tm("Pause Full", NULL, gc_cause(), true); TraceCollectorStats tcs(g1mm()->full_collection_counters()); TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); @@ -1329,11 +1311,6 @@ _allocator->abandon_gc_alloc_regions(); g1_rem_set()->cleanupHRRS(); - // We should call this after we retire any currently active alloc - // regions so that all the ALLOC / RETIRE events are generated - // before the start GC event. - _hr_printer.start_gc(true /* full */, (size_t) total_collections()); - // We may have added regions to the current incremental collection // set between the last GC or pause and now. We need to clear the // incremental collection set and then start rebuilding it afresh @@ -1400,14 +1377,10 @@ resize_if_necessary_after_full_collection(); - if (_hr_printer.is_active()) { - // We should do this after we potentially resize the heap so - // that all the COMMIT / UNCOMMIT events are generated before - // the end GC event. - - print_hrm_post_compaction(); - _hr_printer.end_gc(true /* full */, (size_t) total_collections()); - } + // We should do this after we potentially resize the heap so + // that all the COMMIT / UNCOMMIT events are generated before + // the compaction events. + print_hrm_post_compaction(); G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); if (hot_card_cache->use_cache()) { @@ -1476,10 +1449,6 @@ g1_policy()->record_full_collection_end(); - if (G1Log::fine()) { - g1_policy()->print_heap_transition(); - } - // We must call G1MonitoringSupport::update_sizes() in the same scoping level // as an active TraceMemoryManagerStats object (i.e. before the destructor for the // TraceMemoryManagerStats is called) so that the G1 memory pools are updated @@ -1489,9 +1458,7 @@ gc_epilogue(true); } - if (G1Log::finer()) { - g1_policy()->print_detailed_heap_transition(true /* full */); - } + g1_policy()->print_detailed_heap_transition(); print_heap_after_gc(); trace_heap_after_gc(gc_tracer); @@ -1569,30 +1536,22 @@ if (capacity_after_gc < minimum_desired_capacity) { // Don't expand unless it's significant size_t expand_bytes = minimum_desired_capacity - capacity_after_gc; - ergo_verbose4(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("capacity lower than " - "min desired capacity after Full GC") - ergo_format_byte("capacity") - ergo_format_byte("occupancy") - ergo_format_byte_perc("min desired capacity"), - capacity_after_gc, used_after_gc, - minimum_desired_capacity, (double) MinHeapFreeRatio); + + log_debug(gc, ergo, heap)("Attempt heap expansion (capacity lower than min desired capacity after Full GC). " + "Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B min_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)", + capacity_after_gc, used_after_gc, minimum_desired_capacity, MinHeapFreeRatio); + expand(expand_bytes); // No expansion, now see if we want to shrink } else if (capacity_after_gc > maximum_desired_capacity) { // Capacity too large, compute shrinking size size_t shrink_bytes = capacity_after_gc - maximum_desired_capacity; - ergo_verbose4(ErgoHeapSizing, - "attempt heap shrinking", - ergo_format_reason("capacity higher than " - "max desired capacity after Full GC") - ergo_format_byte("capacity") - ergo_format_byte("occupancy") - ergo_format_byte_perc("max desired capacity"), - capacity_after_gc, used_after_gc, - maximum_desired_capacity, (double) MaxHeapFreeRatio); + + log_debug(gc, ergo, heap)("Attempt heap shrinking (capacity higher than max desired capacity after Full GC). " + "Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B min_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)", + capacity_after_gc, used_after_gc, minimum_desired_capacity, MinHeapFreeRatio); + shrink(shrink_bytes); } } @@ -1698,11 +1657,10 @@ verify_region_sets_optional(); size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes); - ergo_verbose1(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("allocation request failed") - ergo_format_byte("allocation request"), - word_size * HeapWordSize); + log_debug(gc, ergo, heap)("Attempt heap expansion (allocation request failed). Allocation request: " SIZE_FORMAT "B", + word_size * HeapWordSize); + + if (expand(expand_bytes)) { _hrm.verify_optional(); verify_region_sets_optional(); @@ -1717,16 +1675,12 @@ size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes); aligned_expand_bytes = align_size_up(aligned_expand_bytes, HeapRegion::GrainBytes); - ergo_verbose2(ErgoHeapSizing, - "expand the heap", - ergo_format_byte("requested expansion amount") - ergo_format_byte("attempted expansion amount"), - expand_bytes, aligned_expand_bytes); + + log_debug(gc, ergo, heap)("Expand the heap. requested expansion amount:" SIZE_FORMAT "B expansion amount:" SIZE_FORMAT "B", + expand_bytes, aligned_expand_bytes); if (is_maximal_no_gc()) { - ergo_verbose0(ErgoHeapSizing, - "did not expand the heap", - ergo_format_reason("heap already fully expanded")); + log_debug(gc, ergo, heap)("Did not expand the heap (heap already fully expanded)"); return false; } @@ -1744,9 +1698,8 @@ assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition"); g1_policy()->record_new_heap_size(num_regions()); } else { - ergo_verbose0(ErgoHeapSizing, - "did not expand the heap", - ergo_format_reason("heap expansion operation failed")); + log_debug(gc, ergo, heap)("Did not expand the heap (heap expansion operation failed)"); + // The expansion of the virtual storage space was unsuccessful. // Let's see if it was because we ran out of swap. if (G1ExitOnExpansionFailure && @@ -1768,18 +1721,13 @@ uint num_regions_removed = _hrm.shrink_by(num_regions_to_remove); size_t shrunk_bytes = num_regions_removed * HeapRegion::GrainBytes; - ergo_verbose3(ErgoHeapSizing, - "shrink the heap", - ergo_format_byte("requested shrinking amount") - ergo_format_byte("aligned shrinking amount") - ergo_format_byte("attempted shrinking amount"), - shrink_bytes, aligned_shrink_bytes, shrunk_bytes); + + log_debug(gc, ergo, heap)("Shrink the heap. requested shrinking amount: " SIZE_FORMAT "B aligned shrinking amount: " SIZE_FORMAT "B attempted shrinking amount: " SIZE_FORMAT "B", + shrink_bytes, aligned_shrink_bytes, shrunk_bytes); if (num_regions_removed > 0) { g1_policy()->record_new_heap_size(num_regions()); } else { - ergo_verbose0(ErgoHeapSizing, - "did not shrink the heap", - ergo_format_reason("heap shrinking operation failed")); + log_debug(gc, ergo, heap)("Did not expand the heap (heap shrinking operation failed)"); } } @@ -1891,8 +1839,8 @@ translation_factor, mtGC); if (TracePageSizes) { - gclog_or_tty->print_cr("G1 '%s': pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT " size=" SIZE_FORMAT " alignment=" SIZE_FORMAT " reqsize=" SIZE_FORMAT, - description, preferred_page_size, p2i(rs.base()), rs.size(), rs.alignment(), size); + tty->print_cr("G1 '%s': pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT " size=" SIZE_FORMAT " alignment=" SIZE_FORMAT " reqsize=" SIZE_FORMAT, + description, preferred_page_size, p2i(rs.base()), rs.size(), rs.alignment(), size); } return result; } @@ -1901,16 +1849,10 @@ CollectedHeap::pre_initialize(); os::enable_vtime(); - G1Log::init(); - // Necessary to satisfy locking discipline assertions. MutexLocker x(Heap_lock); - // We have to initialize the printer before committing the heap, as - // it will be used then. - _hr_printer.set_active(G1PrintHeapRegions); - // While there are no constraints in the GC code that HeapWordSize // be any particular value, there are multiple other areas in the // system which believe this to be true (e.g. oop->object_size in some @@ -2103,7 +2045,7 @@ void G1CollectedHeap::stop() { // Stop all concurrent threads. We do this to make sure these threads - // do not continue to execute and access resources (e.g. gclog_or_tty) + // do not continue to execute and access resources (e.g. logging) // that are destroyed during shutdown. _cg1r->stop(); _cmThread->stop(); @@ -2220,9 +2162,8 @@ virtual bool doHeapRegion(HeapRegion* hr) { unsigned region_gc_time_stamp = hr->get_gc_time_stamp(); if (_gc_time_stamp != region_gc_time_stamp) { - gclog_or_tty->print_cr("Region " HR_FORMAT " has GC time stamp = %d, " - "expected %d", HR_FORMAT_PARAMS(hr), - region_gc_time_stamp, _gc_time_stamp); + log_info(gc, verify)("Region " HR_FORMAT " has GC time stamp = %d, expected %d", HR_FORMAT_PARAMS(hr), + region_gc_time_stamp, _gc_time_stamp); _failures = true; } return false; @@ -2809,12 +2750,13 @@ if (!oopDesc::is_null(heap_oop)) { oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); if (_g1h->is_obj_dead_cond(obj, _vo)) { - gclog_or_tty->print_cr("Root location " PTR_FORMAT " " - "points to dead obj " PTR_FORMAT, p2i(p), p2i(obj)); + LogHandle(gc, verify) log; + log.info("Root location " PTR_FORMAT " points to dead obj " PTR_FORMAT, p2i(p), p2i(obj)); if (_vo == VerifyOption_G1UseMarkWord) { - gclog_or_tty->print_cr(" Mark word: " INTPTR_FORMAT, (intptr_t)obj->mark()); + log.info(" Mark word: " PTR_FORMAT, p2i(obj->mark())); } - obj->print_on(gclog_or_tty); + ResourceMark rm; + obj->print_on(log.info_stream()); _failures = true; } } @@ -2859,10 +2801,10 @@ // Verify that the strong code root list for this region // contains the nmethod if (!hrrs->strong_code_roots_list_contains(_nm)) { - gclog_or_tty->print_cr("Code root location " PTR_FORMAT " " - "from nmethod " PTR_FORMAT " not in strong " - "code roots for region [" PTR_FORMAT "," PTR_FORMAT ")", - p2i(p), p2i(_nm), p2i(hr->bottom()), p2i(hr->end())); + log_info(gc, verify)("Code root location " PTR_FORMAT " " + "from nmethod " PTR_FORMAT " not in strong " + "code roots for region [" PTR_FORMAT "," PTR_FORMAT ")", + p2i(p), p2i(_nm), p2i(hr->bottom()), p2i(hr->end())); _failures = true; } } @@ -3040,12 +2982,8 @@ r->object_iterate(¬_dead_yet_cl); if (_vo != VerifyOption_G1UseNextMarking) { if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { - gclog_or_tty->print_cr("[" PTR_FORMAT "," PTR_FORMAT "] " - "max_live_bytes " SIZE_FORMAT " " - "< calculated " SIZE_FORMAT, - p2i(r->bottom()), p2i(r->end()), - r->max_live_bytes(), - not_dead_yet_cl.live_bytes()); + log_info(gc, verify)("[" PTR_FORMAT "," PTR_FORMAT "] max_live_bytes " SIZE_FORMAT " < calculated " SIZE_FORMAT, + p2i(r->bottom()), p2i(r->end()), r->max_live_bytes(), not_dead_yet_cl.live_bytes()); _failures = true; } } else { @@ -3093,85 +3031,75 @@ } }; -void G1CollectedHeap::verify(bool silent, VerifyOption vo) { - if (SafepointSynchronize::is_at_safepoint()) { - assert(Thread::current()->is_VM_thread(), - "Expected to be executed serially by the VM thread at this point"); - - if (!silent) { gclog_or_tty->print("Roots "); } - VerifyRootsClosure rootsCl(vo); - VerifyKlassClosure klassCl(this, &rootsCl); - CLDToKlassAndOopClosure cldCl(&klassCl, &rootsCl, false); - - // We apply the relevant closures to all the oops in the - // system dictionary, class loader data graph, the string table - // and the nmethods in the code cache. - G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo); - G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl); +void G1CollectedHeap::verify(VerifyOption vo) { + if (!SafepointSynchronize::is_at_safepoint()) { + log_info(gc, verify)("Skipping verification. Not at safepoint."); + } + + assert(Thread::current()->is_VM_thread(), + "Expected to be executed serially by the VM thread at this point"); + + log_debug(gc, verify)("Roots"); + VerifyRootsClosure rootsCl(vo); + VerifyKlassClosure klassCl(this, &rootsCl); + CLDToKlassAndOopClosure cldCl(&klassCl, &rootsCl, false); + + // We apply the relevant closures to all the oops in the + // system dictionary, class loader data graph, the string table + // and the nmethods in the code cache. + G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo); + G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl); - { - G1RootProcessor root_processor(this, 1); - root_processor.process_all_roots(&rootsCl, - &cldCl, - &blobsCl); - } - - bool failures = rootsCl.failures() || codeRootsCl.failures(); - - if (vo != VerifyOption_G1UseMarkWord) { - // If we're verifying during a full GC then the region sets - // will have been torn down at the start of the GC. Therefore - // verifying the region sets will fail. So we only verify - // the region sets when not in a full GC. - if (!silent) { gclog_or_tty->print("HeapRegionSets "); } - verify_region_sets(); - } - - if (!silent) { gclog_or_tty->print("HeapRegions "); } - if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { - - G1ParVerifyTask task(this, vo); - workers()->run_task(&task); - if (task.failures()) { - failures = true; - } - - } else { - VerifyRegionClosure blk(false, vo); - heap_region_iterate(&blk); - if (blk.failures()) { - failures = true; - } - } - - if (G1StringDedup::is_enabled()) { - if (!silent) gclog_or_tty->print("StrDedup "); - G1StringDedup::verify(); + { + G1RootProcessor root_processor(this, 1); + root_processor.process_all_roots(&rootsCl, + &cldCl, + &blobsCl); + } + + bool failures = rootsCl.failures() || codeRootsCl.failures(); + + if (vo != VerifyOption_G1UseMarkWord) { + // If we're verifying during a full GC then the region sets + // will have been torn down at the start of the GC. Therefore + // verifying the region sets will fail. So we only verify + // the region sets when not in a full GC. + log_debug(gc, verify)("HeapRegionSets"); + verify_region_sets(); + } + + log_debug(gc, verify)("HeapRegions"); + if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { + + G1ParVerifyTask task(this, vo); + workers()->run_task(&task); + if (task.failures()) { + failures = true; } - if (failures) { - gclog_or_tty->print_cr("Heap:"); - // It helps to have the per-region information in the output to - // help us track down what went wrong. This is why we call - // print_extended_on() instead of print_on(). - print_extended_on(gclog_or_tty); - gclog_or_tty->cr(); - gclog_or_tty->flush(); - } - guarantee(!failures, "there should not have been any failures"); } else { - if (!silent) { - gclog_or_tty->print("(SKIPPING Roots, HeapRegionSets, HeapRegions, RemSet"); - if (G1StringDedup::is_enabled()) { - gclog_or_tty->print(", StrDedup"); - } - gclog_or_tty->print(") "); + VerifyRegionClosure blk(false, vo); + heap_region_iterate(&blk); + if (blk.failures()) { + failures = true; } } -} -void G1CollectedHeap::verify(bool silent) { - verify(silent, VerifyOption_G1UsePrevMarking); + if (G1StringDedup::is_enabled()) { + log_debug(gc, verify)("StrDedup"); + G1StringDedup::verify(); + } + + if (failures) { + log_info(gc, verify)("Heap after failed verification:"); + // It helps to have the per-region information in the output to + // help us track down what went wrong. This is why we call + // print_extended_on() instead of print_on(). + LogHandle(gc, verify) log; + ResourceMark rm; + print_extended_on(log.info_stream()); + } + guarantee(!failures, "there should not have been any failures"); } double G1CollectedHeap::verify(bool guard, const char* msg) { @@ -3189,12 +3117,12 @@ } void G1CollectedHeap::verify_before_gc() { - double verify_time_ms = verify(VerifyBeforeGC, " VerifyBeforeGC:"); + double verify_time_ms = verify(VerifyBeforeGC, "Before GC"); g1_policy()->phase_times()->record_verify_before_time_ms(verify_time_ms); } void G1CollectedHeap::verify_after_gc() { - double verify_time_ms = verify(VerifyAfterGC, " VerifyAfterGC:"); + double verify_time_ms = verify(VerifyAfterGC, "After GC"); g1_policy()->phase_times()->record_verify_after_time_ms(verify_time_ms); } @@ -3304,12 +3232,8 @@ // to that. g1_policy()->print_tracing_info(); } - if (G1SummarizeRSetStats) { - g1_rem_set()->print_summary_info(); - } - if (G1SummarizeConcMark) { - concurrent_mark()->print_summary_info(); - } + g1_rem_set()->print_summary_info(); + concurrent_mark()->print_summary_info(); g1_policy()->print_yg_surv_rate_info(); } @@ -3327,28 +3251,27 @@ size_t occupied = hrrs->occupied(); _occupied_sum += occupied; - gclog_or_tty->print_cr("Printing RSet for region " HR_FORMAT, - HR_FORMAT_PARAMS(r)); + tty->print_cr("Printing RSet for region " HR_FORMAT, HR_FORMAT_PARAMS(r)); if (occupied == 0) { - gclog_or_tty->print_cr(" RSet is empty"); + tty->print_cr(" RSet is empty"); } else { hrrs->print(); } - gclog_or_tty->print_cr("----------"); + tty->print_cr("----------"); return false; } PrintRSetsClosure(const char* msg) : _msg(msg), _occupied_sum(0) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("========================================"); - gclog_or_tty->print_cr("%s", msg); - gclog_or_tty->cr(); + tty->cr(); + tty->print_cr("========================================"); + tty->print_cr("%s", msg); + tty->cr(); } ~PrintRSetsClosure() { - gclog_or_tty->print_cr("Occupied Sum: " SIZE_FORMAT, _occupied_sum); - gclog_or_tty->print_cr("========================================"); - gclog_or_tty->cr(); + tty->print_cr("Occupied Sum: " SIZE_FORMAT, _occupied_sum); + tty->print_cr("========================================"); + tty->cr(); } }; @@ -3406,20 +3329,12 @@ accumulate_statistics_all_tlabs(); ensure_parsability(true); - if (G1SummarizeRSetStats && (G1SummarizeRSetStatsPeriod > 0) && - (total_collections() % G1SummarizeRSetStatsPeriod == 0)) { - g1_rem_set()->print_periodic_summary_info("Before GC RS summary"); - } + g1_rem_set()->print_periodic_summary_info("Before GC RS summary", total_collections()); } void G1CollectedHeap::gc_epilogue(bool full) { - - if (G1SummarizeRSetStats && - (G1SummarizeRSetStatsPeriod > 0) && - // we are at the end of the GC. Total collections has already been increased. - ((total_collections() - 1) % G1SummarizeRSetStatsPeriod == 0)) { - g1_rem_set()->print_periodic_summary_info("After GC RS summary"); - } + // we are at the end of the GC. Total collections has already been increased. + g1_rem_set()->print_periodic_summary_info("After GC RS summary", total_collections() - 1); // FIXME: what is this about? // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled" @@ -3665,7 +3580,14 @@ st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); } -void G1CollectedHeap::print_taskqueue_stats(outputStream* const st) const { +void G1CollectedHeap::print_taskqueue_stats() const { + if (!develop_log_is_enabled(Trace, gc, task, stats)) { + return; + } + LogHandle(gc, task, stats) log; + ResourceMark rm; + outputStream* st = log.trace_stream(); + print_taskqueue_stats_hdr(st); TaskQueueStats totals; @@ -3687,41 +3609,17 @@ } #endif // TASKQUEUE_STATS -void G1CollectedHeap::log_gc_header() { - if (!G1Log::fine()) { - return; +void G1CollectedHeap::log_gc_footer(double pause_time_counter) { + if (evacuation_failed()) { + log_info(gc)("To-space exhausted"); } - gclog_or_tty->gclog_stamp(); + double pause_time_sec = TimeHelper::counter_to_seconds(pause_time_counter); + g1_policy()->print_phases(pause_time_sec); - GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause()) - .append(collector_state()->gcs_are_young() ? "(young)" : "(mixed)") - .append(collector_state()->during_initial_mark_pause() ? " (initial-mark)" : ""); - - gclog_or_tty->print("[%s", (const char*)gc_cause_str); + g1_policy()->print_detailed_heap_transition(); } -void G1CollectedHeap::log_gc_footer(double pause_time_sec) { - if (!G1Log::fine()) { - return; - } - - if (G1Log::finer()) { - if (evacuation_failed()) { - gclog_or_tty->print(" (to-space exhausted)"); - } - gclog_or_tty->print_cr(", %3.7f secs]", pause_time_sec); - g1_policy()->print_phases(pause_time_sec); - g1_policy()->print_detailed_heap_transition(); - } else { - if (evacuation_failed()) { - gclog_or_tty->print("--"); - } - g1_policy()->print_heap_transition(); - gclog_or_tty->print_cr(", %3.7f secs]", pause_time_sec); - } - gclog_or_tty->flush(); -} void G1CollectedHeap::wait_for_root_region_scanning() { double scan_wait_start = os::elapsedTime(); @@ -3757,7 +3655,6 @@ wait_for_root_region_scanning(); - G1Log::update_level(); print_heap_before_gc(); trace_heap_before_gc(_gc_tracer_stw); @@ -3794,16 +3691,25 @@ _gc_tracer_stw->report_yc_type(collector_state()->yc_type()); - TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); + GCTraceCPUTime tcpu; uint active_workers = AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), workers()->active_workers(), Threads::number_of_non_daemon_threads()); workers()->set_active_workers(active_workers); + FormatBuffer<> gc_string("Pause "); + if (collector_state()->during_initial_mark_pause()) { + gc_string.append("Initial Mark"); + } else if (collector_state()->gcs_are_young()) { + gc_string.append("Young"); + } else { + gc_string.append("Mixed"); + } + GCTraceTime(Info, gc) tm(gc_string, NULL, gc_cause(), true); double pause_start_sec = os::elapsedTime(); + double pause_start_counter = os::elapsed_counter(); g1_policy()->note_gc_start(active_workers); - log_gc_header(); TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); @@ -3861,11 +3767,6 @@ // of the collection set!). _allocator->release_mutator_alloc_region(); - // We should call this after we retire the mutator alloc - // region(s) so that all the ALLOC / RETIRE events are generated - // before the start GC event. - _hr_printer.start_gc(false /* full */, (size_t) total_collections()); - // This timing is only used by the ergonomics to handle our pause target. // It is unclear why this should not include the full pause. We will // investigate this in CR 7178365. @@ -3989,7 +3890,7 @@ size_t expand_bytes = g1_policy()->expansion_amount(); if (expand_bytes > 0) { size_t bytes_before = capacity(); - // No need for an ergo verbose message here, + // No need for an ergo logging here, // expansion_amount() does this when it returns a value > 0. double expand_ms; if (!expand(expand_bytes, &expand_ms)) { @@ -4049,12 +3950,6 @@ // CM reference discovery will be re-enabled if necessary. } - // We should do this after we potentially expand the heap so - // that all the COMMIT events are generated before the end GC - // event, and after we retire the GC alloc regions so that all - // RETIRE events are generated before the end GC event. - _hr_printer.end_gc(false /* full */, (size_t) total_collections()); - #ifdef TRACESPINNING ParallelTaskTerminator::print_termination_counts(); #endif @@ -4063,7 +3958,7 @@ } // Print the remainder of the GC log output. - log_gc_footer(os::elapsedTime() - pause_start_sec); + log_gc_footer(os::elapsed_counter() - pause_start_counter); // It is not yet to safe to tell the concurrent mark to // start as we have some optional output below. We don't want the @@ -4073,7 +3968,7 @@ _hrm.verify_optional(); verify_region_sets_optional(); - TASKQUEUE_STATS_ONLY(if (PrintTaskqueue) print_taskqueue_stats()); + TASKQUEUE_STATS_ONLY(print_taskqueue_stats()); TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); print_heap_after_gc(); @@ -4228,13 +4123,12 @@ assert(pss->queue_is_empty(), "should be empty"); - if (PrintTerminationStats) { + if (log_is_enabled(Debug, gc, task, stats)) { MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); size_t lab_waste; size_t lab_undo_waste; pss->waste(lab_waste, lab_undo_waste); - _g1h->print_termination_stats(gclog_or_tty, - worker_id, + _g1h->print_termination_stats(worker_id, (os::elapsedTime() - start_sec) * 1000.0, /* elapsed time */ strong_roots_sec * 1000.0, /* strong roots time */ term_sec * 1000.0, /* evac term time */ @@ -4252,22 +4146,22 @@ } }; -void G1CollectedHeap::print_termination_stats_hdr(outputStream* const st) { - st->print_raw_cr("GC Termination Stats"); - st->print_raw_cr(" elapsed --strong roots-- -------termination------- ------waste (KiB)------"); - st->print_raw_cr("thr ms ms % ms % attempts total alloc undo"); - st->print_raw_cr("--- --------- --------- ------ --------- ------ -------- ------- ------- -------"); +void G1CollectedHeap::print_termination_stats_hdr() { + log_debug(gc, task, stats)("GC Termination Stats"); + log_debug(gc, task, stats)(" elapsed --strong roots-- -------termination------- ------waste (KiB)------"); + log_debug(gc, task, stats)("thr ms ms %% ms %% attempts total alloc undo"); + log_debug(gc, task, stats)("--- --------- --------- ------ --------- ------ -------- ------- ------- -------"); } -void G1CollectedHeap::print_termination_stats(outputStream* const st, - uint worker_id, +void G1CollectedHeap::print_termination_stats(uint worker_id, double elapsed_ms, double strong_roots_ms, double term_ms, size_t term_attempts, size_t alloc_buffer_waste, size_t undo_waste) const { - st->print_cr("%3d %9.2f %9.2f %6.2f " + log_debug(gc, task, stats) + ("%3d %9.2f %9.2f %6.2f " "%9.2f %6.2f " SIZE_FORMAT_W(8) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), worker_id, elapsed_ms, strong_roots_ms, strong_roots_ms * 100 / elapsed_ms, @@ -4316,13 +4210,11 @@ "claim value %d after unlink less than initial symbol table size %d", SymbolTable::parallel_claimed_index(), _initial_symbol_table_size); - if (G1TraceStringSymbolTableScrubbing) { - gclog_or_tty->print_cr("Cleaned string and symbol table, " - "strings: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed, " - "symbols: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed", - strings_processed(), strings_removed(), - symbols_processed(), symbols_removed()); - } + log_debug(gc, stringdedup)("Cleaned string and symbol table, " + "strings: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed, " + "symbols: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed", + strings_processed(), strings_removed(), + symbols_processed(), symbols_removed()); } void work(uint worker_id) { @@ -5162,10 +5054,7 @@ ClassLoaderDataGraph::clear_claimed_marks(); } - // The individual threads will set their evac-failure closures. - if (PrintTerminationStats) { - print_termination_stats_hdr(gclog_or_tty); - } + print_termination_stats_hdr(); workers()->run_task(&g1_par_task); end_par_time_sec = os::elapsedTime(); @@ -5404,11 +5293,8 @@ "tams: " PTR_FORMAT " end: " PTR_FORMAT, p2i(tams), p2i(end)); HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end); if (result < end) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("## wrong marked address on %s bitmap: " PTR_FORMAT, - bitmap_name, p2i(result)); - gclog_or_tty->print_cr("## %s tams: " PTR_FORMAT " end: " PTR_FORMAT, - bitmap_name, p2i(tams), p2i(end)); + log_info(gc, verify)("## wrong marked address on %s bitmap: " PTR_FORMAT, bitmap_name, p2i(result)); + log_info(gc, verify)("## %s tams: " PTR_FORMAT " end: " PTR_FORMAT, bitmap_name, p2i(tams), p2i(end)); return false; } return true; @@ -5433,9 +5319,8 @@ res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end); } if (!res_p || !res_n) { - gclog_or_tty->print_cr("#### Bitmap verification failed for " HR_FORMAT, - HR_FORMAT_PARAMS(hr)); - gclog_or_tty->print_cr("#### Caller: %s", caller); + log_info(gc, verify)("#### Bitmap verification failed for " HR_FORMAT, HR_FORMAT_PARAMS(hr)); + log_info(gc, verify)("#### Caller: %s", caller); return false; } return true; @@ -5487,42 +5372,42 @@ InCSetState cset_state = (InCSetState) G1CollectedHeap::heap()->_in_cset_fast_test.get_by_index(i); if (hr->is_humongous()) { if (hr->in_collection_set()) { - gclog_or_tty->print_cr("\n## humongous region %u in CSet", i); + log_info(gc, verify)("\n## humongous region %u in CSet", i); _failures = true; return true; } if (cset_state.is_in_cset()) { - gclog_or_tty->print_cr("\n## inconsistent cset state %d for humongous region %u", cset_state.value(), i); + log_info(gc, verify)("\n## inconsistent cset state %d for humongous region %u", cset_state.value(), i); _failures = true; return true; } if (hr->is_continues_humongous() && cset_state.is_humongous()) { - gclog_or_tty->print_cr("\n## inconsistent cset state %d for continues humongous region %u", cset_state.value(), i); + log_info(gc, verify)("\n## inconsistent cset state %d for continues humongous region %u", cset_state.value(), i); _failures = true; return true; } } else { if (cset_state.is_humongous()) { - gclog_or_tty->print_cr("\n## inconsistent cset state %d for non-humongous region %u", cset_state.value(), i); + log_info(gc, verify)("\n## inconsistent cset state %d for non-humongous region %u", cset_state.value(), i); _failures = true; return true; } if (hr->in_collection_set() != cset_state.is_in_cset()) { - gclog_or_tty->print_cr("\n## in CSet %d / cset state %d inconsistency for region %u", - hr->in_collection_set(), cset_state.value(), i); + log_info(gc, verify)("\n## in CSet %d / cset state %d inconsistency for region %u", + hr->in_collection_set(), cset_state.value(), i); _failures = true; return true; } if (cset_state.is_in_cset()) { if (hr->is_young() != (cset_state.is_young())) { - gclog_or_tty->print_cr("\n## is_young %d / cset state %d inconsistency for region %u", - hr->is_young(), cset_state.value(), i); + log_info(gc, verify)("\n## is_young %d / cset state %d inconsistency for region %u", + hr->is_young(), cset_state.value(), i); _failures = true; return true; } if (hr->is_old() != (cset_state.is_old())) { - gclog_or_tty->print_cr("\n## is_old %d / cset state %d inconsistency for region %u", - hr->is_old(), cset_state.value(), i); + log_info(gc, verify)("\n## is_old %d / cset state %d inconsistency for region %u", + hr->is_old(), cset_state.value(), i); _failures = true; return true; } @@ -5739,9 +5624,7 @@ uint region_idx = r->hrm_index(); if (!g1h->is_humongous_reclaim_candidate(region_idx) || !r->rem_set()->is_empty()) { - - if (G1TraceEagerReclaimHumongousObjects) { - gclog_or_tty->print_cr("Live humongous region %u object size " SIZE_FORMAT " start " PTR_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", + log_debug(gc, humongous)("Live humongous region %u object size " SIZE_FORMAT " start " PTR_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", region_idx, (size_t)obj->size() * HeapWordSize, p2i(r->bottom()), @@ -5751,8 +5634,6 @@ g1h->is_humongous_reclaim_candidate(region_idx), obj->is_typeArray() ); - } - return false; } @@ -5760,8 +5641,7 @@ "Only eagerly reclaiming type arrays is supported, but the object " PTR_FORMAT " is not.", p2i(r->bottom())); - if (G1TraceEagerReclaimHumongousObjects) { - gclog_or_tty->print_cr("Dead humongous region %u object size " SIZE_FORMAT " start " PTR_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", + log_debug(gc, humongous)("Dead humongous region %u object size " SIZE_FORMAT " start " PTR_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", region_idx, (size_t)obj->size() * HeapWordSize, p2i(r->bottom()), @@ -5771,7 +5651,7 @@ g1h->is_humongous_reclaim_candidate(region_idx), obj->is_typeArray() ); - } + // Need to clear mark bit of the humongous object if already set. if (next_bitmap->isMarked(r->bottom())) { next_bitmap->clear(r->bottom()); @@ -5805,7 +5685,7 @@ assert_at_safepoint(true); if (!G1EagerReclaimHumongousObjects || - (!_has_humongous_reclaim_candidates && !G1TraceEagerReclaimHumongousObjects)) { + (!_has_humongous_reclaim_candidates && !log_is_enabled(Debug, gc, humongous))) { g1_policy()->phase_times()->record_fast_reclaim_humongous_time_ms(0.0, 0); return; } @@ -5858,10 +5738,7 @@ } void G1CollectedHeap::set_free_regions_coming() { - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " - "setting free regions coming"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [cm thread] : setting free regions coming"); assert(!free_regions_coming(), "pre-condition"); _free_regions_coming = true; @@ -5876,10 +5753,7 @@ SecondaryFreeList_lock->notify_all(); } - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " - "reset free regions coming"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [cm thread] : reset free regions coming"); } void G1CollectedHeap::wait_while_free_regions_coming() { @@ -5889,10 +5763,7 @@ return; } - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " - "waiting for free regions"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [other] : waiting for free regions"); { MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); @@ -5901,10 +5772,7 @@ } } - if (G1ConcRegionFreeingVerbose) { - gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " - "done waiting for free regions"); - } + log_develop_trace(gc, freelist)("G1ConcRegionFreeing [other] : done waiting for free regions"); } bool G1CollectedHeap::is_old_gc_alloc_region(HeapRegion* hr) { @@ -5922,8 +5790,8 @@ NoYoungRegionsClosure() : _success(true) { } bool doHeapRegion(HeapRegion* r) { if (r->is_young()) { - gclog_or_tty->print_cr("Region [" PTR_FORMAT ", " PTR_FORMAT ") tagged as young", - p2i(r->bottom()), p2i(r->end())); + log_info(gc, verify)("Region [" PTR_FORMAT ", " PTR_FORMAT ") tagged as young", + p2i(r->bottom()), p2i(r->end())); _success = false; } return false; @@ -6173,11 +6041,8 @@ if (index != G1_NO_HRM_INDEX) { if (expanded) { - ergo_verbose1(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("requested address range outside heap bounds") - ergo_format_byte("region size"), - HeapRegion::GrainWords * HeapWordSize); + log_debug(gc, ergo, heap)("Attempt heap expansion (requested address range outside heap bounds). region size: " SIZE_FORMAT "B", + HeapRegion::GrainWords * HeapWordSize); } _hrm.allocate_free_regions_starting_at(index, 1); return region_at(index); --- old/src/share/vm/gc/g1/g1CollectedHeap.hpp 2015-12-01 12:06:07.650930840 +0100 +++ new/src/share/vm/gc/g1/g1CollectedHeap.hpp 2015-12-01 12:06:07.530930845 +0100 @@ -288,8 +288,7 @@ void verify_before_gc(); void verify_after_gc(); - void log_gc_header(); - void log_gc_footer(double pause_time_sec); + void log_gc_footer(double pause_time_counter); void trace_heap(GCWhen::Type when, const GCTracer* tracer); @@ -697,8 +696,8 @@ 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; + static void print_taskqueue_stats_hdr(outputStream* const st); + void print_taskqueue_stats() const; void reset_taskqueue_stats(); #endif // TASKQUEUE_STATS @@ -731,10 +730,9 @@ void post_evacuate_collection_set(EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* pss); // Print the header for the per-thread termination statistics. - static void print_termination_stats_hdr(outputStream* const st); + static void print_termination_stats_hdr(); // Print actual per-thread termination statistics. - void print_termination_stats(outputStream* const st, - uint worker_id, + void print_termination_stats(uint worker_id, double elapsed_ms, double strong_roots_ms, double term_ms, @@ -961,6 +959,10 @@ return CollectedHeap::G1CollectedHeap; } + virtual const char* name() const { + return "G1"; + } + const G1CollectorState* collector_state() const { return &_collector_state; } G1CollectorState* collector_state() { return &_collector_state; } @@ -1358,6 +1360,10 @@ YoungList* young_list() const { return _young_list; } + uint old_regions_count() const { return _old_set.length(); } + + uint humongous_regions_count() const { return _humongous_set.length(); } + // debugging bool check_young_list_well_formed() { return _young_list->check_list_well_formed(); @@ -1475,10 +1481,7 @@ // Currently there is only one place where this is called with // vo == UseMarkWord, which is to verify the marking during a // full GC. - void verify(bool silent, VerifyOption vo); - - // Override; it uses the "prev" marking information - virtual void verify(bool silent); + void verify(VerifyOption vo); // The methods below are here for convenience and dispatch the // appropriate method depending on value of the given VerifyOption --- old/src/share/vm/gc/g1/g1CollectorPolicy.cpp 2015-12-01 12:06:07.862930833 +0100 +++ new/src/share/vm/gc/g1/g1CollectorPolicy.cpp 2015-12-01 12:06:07.746930837 +0100 @@ -29,9 +29,7 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1IHOPControl.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/heapRegion.inline.hpp" #include "gc/g1/heapRegionRemSet.hpp" #include "gc/shared/gcPolicyCounters.hpp" @@ -121,6 +119,8 @@ _eden_used_bytes_before_gc(0), _survivor_used_bytes_before_gc(0), + _old_used_bytes_before_gc(0), + _humongous_used_bytes_before_gc(0), _heap_used_bytes_before_gc(0), _metaspace_used_bytes_before_gc(0), _eden_capacity_bytes_before_gc(0), @@ -177,18 +177,6 @@ HeapRegion::setup_heap_region_size(InitialHeapSize, MaxHeapSize); HeapRegionRemSet::setup_remset_size(); - G1ErgoVerbose::initialize(); - if (PrintAdaptiveSizePolicy) { - // Currently, we only use a single switch for all the heuristics. - G1ErgoVerbose::set_enabled(true); - // Given that we don't currently have a verboseness level - // parameter, we'll hardcode this to high. This can be easily - // changed in the future. - G1ErgoVerbose::set_level(ErgoHigh); - } else { - G1ErgoVerbose::set_enabled(false); - } - _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; @@ -790,7 +778,7 @@ curr = curr->get_next_young_region()) { SurvRateGroup* group = curr->surv_rate_group(); if (group == NULL && !curr->is_survivor()) { - gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); + log_info(gc, verify)("## %s: encountered NULL surv_rate_group", name); ret = false; } @@ -798,13 +786,12 @@ int age = curr->age_in_surv_rate_group(); if (age < 0) { - gclog_or_tty->print_cr("## %s: encountered negative age", name); + log_info(gc, verify)("## %s: encountered negative age", name); ret = false; } if (age <= prev_age) { - gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " - "(%d, %d)", name, age, prev_age); + log_info(gc, verify)("## %s: region ages are not strictly increasing (%d, %d)", name, age, prev_age); ret = false; } prev_age = age; @@ -983,38 +970,15 @@ size_t alloc_byte_size = alloc_word_size * HeapWordSize; size_t marking_request_bytes = cur_used_bytes + alloc_byte_size; + bool result = false; if (marking_request_bytes > marking_initiating_used_threshold) { - if (collector_state()->gcs_are_young() && !collector_state()->last_young_gc()) { - ergo_verbose5(ErgoConcCycles, - "request concurrent cycle initiation", - ergo_format_reason("occupancy higher than threshold") - ergo_format_byte("occupancy") - ergo_format_byte("allocation request") - ergo_format_byte_perc("threshold") - ergo_format_str("source"), - cur_used_bytes, - alloc_byte_size, - marking_initiating_used_threshold, - (double) marking_initiating_used_threshold / _g1->capacity() * 100, - source); - return true; - } else { - ergo_verbose5(ErgoConcCycles, - "do not request concurrent cycle initiation", - ergo_format_reason("still doing mixed collections") - ergo_format_byte("occupancy") - ergo_format_byte("allocation request") - ergo_format_byte_perc("threshold") - ergo_format_str("source"), - cur_used_bytes, - alloc_byte_size, - marking_initiating_used_threshold, - (double) InitiatingHeapOccupancyPercent, - source); - } + result = collector_state()->gcs_are_young() && !collector_state()->last_young_gc(); + log_debug(gc, ihop, ergo)("%s occupancy: " SIZE_FORMAT "B allocation request: " SIZE_FORMAT "B threshold: " SIZE_FORMAT "B (%1.2f) source: %s", + result ? "Request concurrent cycle initiation (occupancy higher than threshold)" : "Do not request concurrent cycle initiation (still doing mixed collections)", + cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, (double) marking_initiating_used_threshold / _g1->capacity() * 100, source); } - return false; + return result; } // Anything below that is considered to be zero @@ -1028,13 +992,7 @@ bool last_pause_included_initial_mark = false; bool update_stats = !_g1->evacuation_failed(); -#ifndef PRODUCT - if (G1YoungSurvRateVerbose) { - gclog_or_tty->cr(); - _short_lived_surv_rate_group->print(); - // do that for any other surv rate groups too - } -#endif // PRODUCT + NOT_PRODUCT(_short_lived_surv_rate_group->print()); record_pause(young_gc_pause_kind(), end_time_sec - pause_time_ms / 1000.0, end_time_sec); @@ -1221,13 +1179,9 @@ double scan_hcc_time_ms = average_time_ms(G1GCPhaseTimes::ScanHCC); if (update_rs_time_goal_ms < scan_hcc_time_ms) { - ergo_verbose2(ErgoTiming, - "adjust concurrent refinement thresholds", - ergo_format_reason("Scanning the HCC expected to take longer than Update RS time goal") - ergo_format_ms("Update RS time goal") - ergo_format_ms("Scan HCC time"), - update_rs_time_goal_ms, - scan_hcc_time_ms); + log_debug(gc, ergo, refine)("Adjust concurrent refinement thresholds (scanning the HCC expected to take longer than Update RS time goal)." + "Update RS time goal: %1.2fms Scan HCC time: %1.2fms", + update_rs_time_goal_ms, scan_hcc_time_ms); update_rs_time_goal_ms = 0; } else { @@ -1305,65 +1259,37 @@ _eden_used_bytes_before_gc = young_list->eden_used_bytes(); _survivor_used_bytes_before_gc = young_list->survivor_used_bytes(); _heap_capacity_bytes_before_gc = _g1->capacity(); + _old_used_bytes_before_gc = _g1->old_regions_count() * HeapRegion::GrainBytes; + _humongous_used_bytes_before_gc = _g1->humongous_regions_count() * HeapRegion::GrainBytes; _heap_used_bytes_before_gc = _g1->used(); - - _eden_capacity_bytes_before_gc = - (_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc; - - if (full) { - _metaspace_used_bytes_before_gc = MetaspaceAux::used_bytes(); - } -} - -void G1CollectorPolicy::print_heap_transition(size_t bytes_before) const { - size_t bytes_after = _g1->used(); - size_t capacity = _g1->capacity(); - - gclog_or_tty->print(" " SIZE_FORMAT "%s->" SIZE_FORMAT "%s(" SIZE_FORMAT "%s)", - byte_size_in_proper_unit(bytes_before), - proper_unit_for_byte_size(bytes_before), - byte_size_in_proper_unit(bytes_after), - proper_unit_for_byte_size(bytes_after), - byte_size_in_proper_unit(capacity), - proper_unit_for_byte_size(capacity)); -} - -void G1CollectorPolicy::print_heap_transition() const { - print_heap_transition(_heap_used_bytes_before_gc); + _eden_capacity_bytes_before_gc = (_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc; + _metaspace_used_bytes_before_gc = MetaspaceAux::used_bytes(); } -void G1CollectorPolicy::print_detailed_heap_transition(bool full) const { +void G1CollectorPolicy::print_detailed_heap_transition() const { YoungList* young_list = _g1->young_list(); size_t eden_used_bytes_after_gc = young_list->eden_used_bytes(); size_t survivor_used_bytes_after_gc = young_list->survivor_used_bytes(); size_t heap_used_bytes_after_gc = _g1->used(); + size_t old_used_bytes_after_gc = _g1->old_regions_count() * HeapRegion::GrainBytes; + size_t humongous_used_bytes_after_gc = _g1->humongous_regions_count() * HeapRegion::GrainBytes; size_t heap_capacity_bytes_after_gc = _g1->capacity(); size_t eden_capacity_bytes_after_gc = (_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc; + size_t survivor_capacity_bytes_after_gc = _max_survivor_regions * HeapRegion::GrainBytes; - gclog_or_tty->print( - " [Eden: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->" EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ") " - "Survivors: " EXT_SIZE_FORMAT "->" EXT_SIZE_FORMAT " " - "Heap: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->" - EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")]", - EXT_SIZE_PARAMS(_eden_used_bytes_before_gc), - EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc), - EXT_SIZE_PARAMS(eden_used_bytes_after_gc), - EXT_SIZE_PARAMS(eden_capacity_bytes_after_gc), - EXT_SIZE_PARAMS(_survivor_used_bytes_before_gc), - EXT_SIZE_PARAMS(survivor_used_bytes_after_gc), - EXT_SIZE_PARAMS(_heap_used_bytes_before_gc), - EXT_SIZE_PARAMS(_heap_capacity_bytes_before_gc), - EXT_SIZE_PARAMS(heap_used_bytes_after_gc), - EXT_SIZE_PARAMS(heap_capacity_bytes_after_gc)); - - if (full) { - MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc); - } + log_info(gc, heap)("Eden: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + _eden_used_bytes_before_gc / K, eden_used_bytes_after_gc /K, eden_capacity_bytes_after_gc /K); + log_info(gc, heap)("Survivor: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + _survivor_used_bytes_before_gc / K, survivor_used_bytes_after_gc /K, survivor_capacity_bytes_after_gc /K); + log_info(gc, heap)("Survivor: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + _survivor_used_bytes_before_gc / K, survivor_used_bytes_after_gc /K, survivor_capacity_bytes_after_gc /K); + log_info(gc, heap)("Humongous: " SIZE_FORMAT "K->" SIZE_FORMAT "K", + _humongous_used_bytes_before_gc / K, humongous_used_bytes_after_gc /K); - gclog_or_tty->cr(); + MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc); } void G1CollectorPolicy::print_phases(double pause_time_sec) { @@ -1618,17 +1544,9 @@ expand_bytes = MAX2(expand_bytes, min_expand_bytes); expand_bytes = MIN2(expand_bytes, uncommitted_bytes); - ergo_verbose5(ErgoHeapSizing, - "attempt heap expansion", - ergo_format_reason("recent GC overhead higher than " - "threshold after GC") - ergo_format_perc("recent GC overhead") - ergo_format_perc("threshold") - ergo_format_byte("uncommitted") - ergo_format_byte_perc("calculated expansion amount"), - recent_gc_overhead, threshold, - uncommitted_bytes, - expand_bytes_via_pct, (double) G1ExpandByPercentOfAvailable); + log_debug(gc, ergo, heap)("Attempt heap expansion (recent GC overhead higher than threshold after GC) " + "recent GC overhead: %1.2f %% threshold: %1.2f %% uncommitted: " SIZE_FORMAT "B calculated expansion amount: " SIZE_FORMAT "B (" INTX_FORMAT "%%)", + recent_gc_overhead, threshold, uncommitted_bytes, expand_bytes_via_pct, G1ExpandByPercentOfAvailable); return expand_bytes; } else { @@ -1693,19 +1611,11 @@ // even while we are still in the process of reclaiming memory. bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); if (!during_cycle) { - ergo_verbose1(ErgoConcCycles, - "request concurrent cycle initiation", - ergo_format_reason("requested by GC cause") - ergo_format_str("GC cause"), - GCCause::to_string(gc_cause)); + log_debug(gc, ergo)("Request concurrent cycle initiation (requested by GC cause). GC cause: %s", GCCause::to_string(gc_cause)); collector_state()->set_initiate_conc_mark_if_possible(true); return true; } else { - ergo_verbose1(ErgoConcCycles, - "do not request concurrent cycle initiation", - ergo_format_reason("concurrent cycle already in progress") - ergo_format_str("GC cause"), - GCCause::to_string(gc_cause)); + log_debug(gc, ergo)("Do not request concurrent cycle initiation (concurrent cycle already in progress). GC cause: %s", GCCause::to_string(gc_cause)); return false; } } @@ -1734,9 +1644,7 @@ // we've already acted on it. collector_state()->set_initiate_conc_mark_if_possible(false); - ergo_verbose0(ErgoConcCycles, - "initiate concurrent cycle", - ergo_format_reason("concurrent cycle initiation requested")); + log_debug(gc, ergo)("Initiate concurrent cycle (concurrent cycle initiation requested)"); } else { // The concurrent marking thread is still finishing up the // previous cycle. If we start one right now the two cycles @@ -1750,9 +1658,7 @@ // and, if it's in a yield point, it's waiting for us to // finish. So, at this point we will not start a cycle and we'll // let the concurrent marking thread complete the last one. - ergo_verbose0(ErgoConcCycles, - "do not initiate concurrent cycle", - ergo_format_reason("concurrent cycle already in progress")); + log_debug(gc, ergo)("Do not initiate concurrent cycle (concurrent cycle already in progress)"); } } } @@ -2098,9 +2004,7 @@ bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, const char* false_action_str) const { if (cset_chooser()->is_empty()) { - ergo_verbose0(ErgoMixedGCs, - false_action_str, - ergo_format_reason("candidate old regions not available")); + log_debug(gc, ergo)("%s (candidate old regions not available)", false_action_str); return false; } @@ -2109,27 +2013,12 @@ double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); double threshold = (double) G1HeapWastePercent; if (reclaimable_perc <= threshold) { - ergo_verbose4(ErgoMixedGCs, - false_action_str, - ergo_format_reason("reclaimable percentage not over threshold") - ergo_format_region("candidate old regions") - ergo_format_byte_perc("reclaimable") - ergo_format_perc("threshold"), - cset_chooser()->remaining_regions(), - reclaimable_bytes, - reclaimable_perc, threshold); + log_debug(gc, ergo)("%s (reclaimable percentage not over threshold). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT, + false_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent); return false; } - - ergo_verbose4(ErgoMixedGCs, - true_action_str, - ergo_format_reason("candidate old regions available") - ergo_format_region("candidate old regions") - ergo_format_byte_perc("reclaimable") - ergo_format_perc("threshold"), - cset_chooser()->remaining_regions(), - reclaimable_bytes, - reclaimable_perc, threshold); + log_debug(gc, ergo)("%s (candidate old regions available). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT, + true_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent); return true; } @@ -2185,13 +2074,8 @@ double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); double time_remaining_ms = MAX2(target_pause_time_ms - base_time_ms, 0.0); - ergo_verbose4(ErgoCSetConstruction | ErgoHigh, - "start choosing CSet", - ergo_format_size("_pending_cards") - ergo_format_ms("predicted base time") - ergo_format_ms("remaining time") - ergo_format_ms("target pause time"), - _pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms); + log_trace(gc, ergo, cset)("Start choosing CSet. pending cards: " SIZE_FORMAT " predicted base time: %1.2fms remaining time: %1.2fms target pause time: %1.2fms", + _pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms); collector_state()->set_last_gc_was_young(collector_state()->gcs_are_young()); @@ -2227,15 +2111,8 @@ _collection_set_bytes_used_before = _inc_cset_bytes_used_before; time_remaining_ms = MAX2(time_remaining_ms - _inc_cset_predicted_elapsed_time_ms, 0.0); - ergo_verbose4(ErgoCSetConstruction | ErgoHigh, - "add young regions to CSet", - ergo_format_region("eden") - ergo_format_region("survivors") - ergo_format_ms("predicted young region time") - ergo_format_ms("target pause time"), - eden_region_length, survivor_region_length, - _inc_cset_predicted_elapsed_time_ms, - target_pause_time_ms); + log_trace(gc, ergo, cset)("Add young regions to CSet. eden: %u regions, survivors: %u regions, predicted young region time: %1.2fms, target pause time: %1.2fms", + eden_region_length, survivor_region_length, _inc_cset_predicted_elapsed_time_ms, target_pause_time_ms); // The number of recorded young regions is the incremental // collection set's current size @@ -2264,12 +2141,8 @@ while (hr != NULL) { if (old_cset_region_length() >= max_old_cset_length) { // Added maximum number of old regions to the CSet. - ergo_verbose2(ErgoCSetConstruction, - "finish adding old regions to CSet", - ergo_format_reason("old CSet region num reached max") - ergo_format_region("old") - ergo_format_region("max"), - old_cset_region_length(), max_old_cset_length); + log_debug(gc, ergo, cset)("Finish adding old regions to CSet (old CSet region num reached max). old %u regions, max %u regions", + old_cset_region_length(), max_old_cset_length); break; } @@ -2283,17 +2156,9 @@ // We've added enough old regions that the amount of uncollected // reclaimable space is at or below the waste threshold. Stop // adding old regions to the CSet. - ergo_verbose5(ErgoCSetConstruction, - "finish adding old regions to CSet", - ergo_format_reason("reclaimable percentage not over threshold") - ergo_format_region("old") - ergo_format_region("max") - ergo_format_byte_perc("reclaimable") - ergo_format_perc("threshold"), - old_cset_region_length(), - max_old_cset_length, - reclaimable_bytes, - reclaimable_perc, threshold); + log_debug(gc, ergo, cset)("Finish adding old regions to CSet (reclaimable percentage not over threshold). " + "old %u regions, max %u regions, reclaimable: " SIZE_FORMAT "B (%1.2f%%) threshold: " UINTX_FORMAT "%%", + old_cset_region_length(), max_old_cset_length, reclaimable_bytes, reclaimable_perc, G1HeapWastePercent); break; } @@ -2305,15 +2170,9 @@ if (old_cset_region_length() >= min_old_cset_length) { // We have added the minimum number of old regions to the CSet, // we are done with this CSet. - ergo_verbose4(ErgoCSetConstruction, - "finish adding old regions to CSet", - ergo_format_reason("predicted time is too high") - ergo_format_ms("predicted time") - ergo_format_ms("remaining time") - ergo_format_region("old") - ergo_format_region("min"), - predicted_time_ms, time_remaining_ms, - old_cset_region_length(), min_old_cset_length); + log_debug(gc, ergo, cset)("Finish adding old regions to CSet (predicted time is too high). " + "predicted time: %1.2fms, remaining time: %1.2fms old %u regions, min %u regions", + predicted_time_ms, time_remaining_ms, old_cset_region_length(), min_old_cset_length); break; } @@ -2325,12 +2184,9 @@ if (old_cset_region_length() >= min_old_cset_length) { // In the non-auto-tuning case, we'll finish adding regions // to the CSet if we reach the minimum. - ergo_verbose2(ErgoCSetConstruction, - "finish adding old regions to CSet", - ergo_format_reason("old CSet region num reached min") - ergo_format_region("old") - ergo_format_region("min"), - old_cset_region_length(), min_old_cset_length); + + log_debug(gc, ergo, cset)("Finish adding old regions to CSet (old CSet region num reached min). old %u regions, min %u regions", + old_cset_region_length(), min_old_cset_length); break; } } @@ -2345,26 +2201,16 @@ hr = cset_chooser()->peek(); } if (hr == NULL) { - ergo_verbose0(ErgoCSetConstruction, - "finish adding old regions to CSet", - ergo_format_reason("candidate old regions not available")); + log_debug(gc, ergo, cset)("Finish adding old regions to CSet (candidate old regions not available)"); } if (expensive_region_num > 0) { // We print the information once here at the end, predicated on // whether we added any apparently expensive regions or not, to // avoid generating output per region. - ergo_verbose4(ErgoCSetConstruction, - "added expensive regions to CSet", - ergo_format_reason("old CSet region num not reached min") - ergo_format_region("old") - ergo_format_region("expensive") - ergo_format_region("min") - ergo_format_ms("remaining time"), - old_cset_region_length(), - expensive_region_num, - min_old_cset_length, - time_remaining_ms); + log_debug(gc, ergo, cset)("Added expensive regions to CSet (old CSet region num not reached min)." + "old %u regions, expensive: %u regions, min %u regions, remaining time: %1.2fms", + old_cset_region_length(), expensive_region_num, min_old_cset_length, time_remaining_ms); } cset_chooser()->verify(); @@ -2372,13 +2218,8 @@ stop_incremental_cset_building(); - ergo_verbose3(ErgoCSetConstruction, - "finish choosing CSet", - ergo_format_region("old") - ergo_format_ms("predicted old region time") - ergo_format_ms("time remaining"), - old_cset_region_length(), - predicted_old_time_ms, time_remaining_ms); + log_debug(gc, ergo, cset)("Finish choosing CSet. old %u regions, predicted old region time: %1.2fms, time remaining: %1.2f", + old_cset_region_length(), predicted_old_time_ms, time_remaining_ms); double non_young_end_time_sec = os::elapsedTime(); phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0); @@ -2437,14 +2278,14 @@ void TraceYoungGenTimeData::print_summary(const char* str, const NumberSeq* seq) const { double sum = seq->sum(); - gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", + tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", str, sum / 1000.0, seq->avg()); } void TraceYoungGenTimeData::print_summary_sd(const char* str, const NumberSeq* seq) const { print_summary(str, seq); - gclog_or_tty->print_cr("%45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", + tty->print_cr("%45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", "(num", seq->num(), seq->sd(), seq->maximum()); } @@ -2453,18 +2294,18 @@ return; } - gclog_or_tty->print_cr("ALL PAUSES"); + tty->print_cr("ALL PAUSES"); print_summary_sd(" Total", &_total); - gclog_or_tty->cr(); - gclog_or_tty->cr(); - gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); - gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); - gclog_or_tty->cr(); + tty->cr(); + tty->cr(); + tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); + tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); + tty->cr(); - gclog_or_tty->print_cr("EVACUATION PAUSES"); + tty->print_cr("EVACUATION PAUSES"); if (_young_pause_num == 0 && _mixed_pause_num == 0) { - gclog_or_tty->print_cr("none"); + tty->print_cr("none"); } else { print_summary_sd(" Evacuation Pauses", &_total); print_summary(" Root Region Scan Wait", &_root_region_scan_wait); @@ -2479,9 +2320,9 @@ print_summary(" Clear CT", &_clear_ct); print_summary(" Other", &_other); } - gclog_or_tty->cr(); + tty->cr(); - gclog_or_tty->print_cr("MISC"); + tty->print_cr("MISC"); print_summary_sd(" Stop World", &_all_stop_world_times_ms); print_summary_sd(" Yields", &_all_yield_times_ms); } @@ -2498,11 +2339,11 @@ } if (_all_full_gc_times.num() > 0) { - gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", + tty->print("\n%4d full_gcs: total time = %8.2f s", _all_full_gc_times.num(), _all_full_gc_times.sum() / 1000.0); - gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg()); - gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", + tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg()); + tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", _all_full_gc_times.sd(), _all_full_gc_times.maximum()); } --- old/src/share/vm/gc/g1/g1CollectorPolicy.hpp 2015-12-01 12:06:08.090930825 +0100 +++ new/src/share/vm/gc/g1/g1CollectorPolicy.hpp 2015-12-01 12:06:07.974930829 +0100 @@ -159,6 +159,7 @@ uint max_desired_young_length() { return _max_desired_young_length; } + bool adaptive_young_list_length() const { return _adaptive_size; } @@ -648,9 +649,7 @@ // Print heap sizing transition (with less and more detail). - void print_heap_transition(size_t bytes_before) const; - void print_heap_transition() const; - void print_detailed_heap_transition(bool full = false) const; + void print_detailed_heap_transition() const; virtual void print_phases(double pause_time_sec); @@ -809,6 +808,8 @@ size_t _eden_used_bytes_before_gc; // Eden occupancy before GC size_t _survivor_used_bytes_before_gc; // Survivor occupancy before GC + size_t _old_used_bytes_before_gc; // Old occupancy before GC + size_t _humongous_used_bytes_before_gc; // Humongous occupancy before GC size_t _heap_used_bytes_before_gc; // Heap occupancy before GC size_t _metaspace_used_bytes_before_gc; // Metaspace occupancy before GC --- old/src/share/vm/gc/g1/g1EvacStats.cpp 2015-12-01 12:06:08.290930818 +0100 +++ new/src/share/vm/gc/g1/g1EvacStats.cpp 2015-12-01 12:06:08.170930822 +0100 @@ -26,91 +26,97 @@ #include "memory/allocation.inline.hpp" #include "gc/g1/g1EvacStats.hpp" #include "gc/shared/gcId.hpp" +#include "logging/log.hpp" #include "trace/tracing.hpp" void G1EvacStats::adjust_desired_plab_sz() { - if (PrintPLAB) { - gclog_or_tty->print(" (allocated = " SIZE_FORMAT " wasted = " SIZE_FORMAT " " + if (!ResizePLAB) { + log_debug(gc, plab)(" (allocated = " SIZE_FORMAT " wasted = " SIZE_FORMAT " " "unused = " SIZE_FORMAT " used = " SIZE_FORMAT " " "undo_waste = " SIZE_FORMAT " region_end_waste = " SIZE_FORMAT " " "regions filled = %u direct_allocated = " SIZE_FORMAT " " "failure_used = " SIZE_FORMAT " failure_waste = " SIZE_FORMAT ") ", _allocated, _wasted, _unused, used(), _undo_wasted, _region_end_waste, _regions_filled, _direct_allocated, _failure_used, _failure_waste); + // Clear accumulators for next round. + reset(); + return; } - if (ResizePLAB) { + assert(is_object_aligned(max_size()) && min_size() <= max_size(), + "PLAB clipping computation may be incorrect"); - assert(is_object_aligned(max_size()) && min_size() <= max_size(), - "PLAB clipping computation may be incorrect"); - - if (_allocated == 0) { - assert((_unused == 0), - "Inconsistency in PLAB stats: " - "_allocated: " SIZE_FORMAT ", " - "_wasted: " SIZE_FORMAT ", " - "_region_end_waste: " SIZE_FORMAT ", " - "_unused: " SIZE_FORMAT ", " - "_used : " SIZE_FORMAT, - _allocated, _wasted, _region_end_waste, _unused, used()); - _allocated = 1; - } - // The size of the PLAB caps the amount of space that can be wasted at the - // end of the collection. In the worst case the last PLAB could be completely - // empty. - // This allows us to calculate the new PLAB size to achieve the - // TargetPLABWastePct given the latest memory usage and that the last buffer - // will be G1LastPLABAverageOccupancy full. - // - // E.g. assume that if in the current GC 100 words were allocated and a - // TargetPLABWastePct of 10 had been set. - // - // So we could waste up to 10 words to meet that percentage. Given that we - // also assume that that buffer is typically half-full, the new desired PLAB - // size is set to 20 words. - // - // The amount of allocation performed should be independent of the number of - // threads, so should the maximum waste we can spend in total. So if - // we used n threads to allocate, each of them can spend maximum waste/n words in - // a first rough approximation. The number of threads only comes into play later - // when actually retrieving the actual desired PLAB size. - // - // After calculating this optimal PLAB size the algorithm applies the usual - // exponential decaying average over this value to guess the next PLAB size. - // - // We account region end waste fully to PLAB allocation (in the calculation of - // what we consider as "used_for_waste_calculation" below). This is not - // completely fair, but is a conservative assumption because PLABs may be sized - // flexibly while we cannot adjust inline allocations. - // Allocation during GC will try to minimize region end waste so this impact - // should be minimal. - // - // We need to cover overflow when calculating the amount of space actually used - // by objects in PLABs when subtracting the region end waste. - // Region end waste may be higher than actual allocation. This may occur if many - // threads do not allocate anything but a few rather large objects. In this - // degenerate case the PLAB size would simply quickly tend to minimum PLAB size, - // which is an okay reaction. - size_t const used_for_waste_calculation = used() > _region_end_waste ? used() - _region_end_waste : 0; - - size_t const total_waste_allowed = used_for_waste_calculation * TargetPLABWastePct; - size_t const cur_plab_sz = (size_t)((double)total_waste_allowed / G1LastPLABAverageOccupancy); - // Take historical weighted average - _filter.sample(cur_plab_sz); - // Clip from above and below, and align to object boundary - size_t plab_sz; - plab_sz = MAX2(min_size(), (size_t)_filter.average()); - plab_sz = MIN2(max_size(), plab_sz); - plab_sz = align_object_size(plab_sz); - // Latch the result - _desired_net_plab_sz = plab_sz; - if (PrintPLAB) { - gclog_or_tty->print(" (plab_sz = " SIZE_FORMAT " desired_plab_sz = " SIZE_FORMAT ") ", cur_plab_sz, plab_sz); - } - } - if (PrintPLAB) { - gclog_or_tty->cr(); + if (_allocated == 0) { + assert((_unused == 0), + "Inconsistency in PLAB stats: " + "_allocated: " SIZE_FORMAT ", " + "_wasted: " SIZE_FORMAT ", " + "_region_end_waste: " SIZE_FORMAT ", " + "_unused: " SIZE_FORMAT ", " + "_used : " SIZE_FORMAT, + _allocated, _wasted, _region_end_waste, _unused, used()); + _allocated = 1; } + // The size of the PLAB caps the amount of space that can be wasted at the + // end of the collection. In the worst case the last PLAB could be completely + // empty. + // This allows us to calculate the new PLAB size to achieve the + // TargetPLABWastePct given the latest memory usage and that the last buffer + // will be G1LastPLABAverageOccupancy full. + // + // E.g. assume that if in the current GC 100 words were allocated and a + // TargetPLABWastePct of 10 had been set. + // + // So we could waste up to 10 words to meet that percentage. Given that we + // also assume that that buffer is typically half-full, the new desired PLAB + // size is set to 20 words. + // + // The amount of allocation performed should be independent of the number of + // threads, so should the maximum waste we can spend in total. So if + // we used n threads to allocate, each of them can spend maximum waste/n words in + // a first rough approximation. The number of threads only comes into play later + // when actually retrieving the actual desired PLAB size. + // + // After calculating this optimal PLAB size the algorithm applies the usual + // exponential decaying average over this value to guess the next PLAB size. + // + // We account region end waste fully to PLAB allocation (in the calculation of + // what we consider as "used_for_waste_calculation" below). This is not + // completely fair, but is a conservative assumption because PLABs may be sized + // flexibly while we cannot adjust inline allocations. + // Allocation during GC will try to minimize region end waste so this impact + // should be minimal. + // + // We need to cover overflow when calculating the amount of space actually used + // by objects in PLABs when subtracting the region end waste. + // Region end waste may be higher than actual allocation. This may occur if many + // threads do not allocate anything but a few rather large objects. In this + // degenerate case the PLAB size would simply quickly tend to minimum PLAB size, + // which is an okay reaction. + size_t const used_for_waste_calculation = used() > _region_end_waste ? used() - _region_end_waste : 0; + + size_t const total_waste_allowed = used_for_waste_calculation * TargetPLABWastePct; + size_t const cur_plab_sz = (size_t)((double)total_waste_allowed / G1LastPLABAverageOccupancy); + // Take historical weighted average + _filter.sample(cur_plab_sz); + // Clip from above and below, and align to object boundary + size_t plab_sz; + plab_sz = MAX2(min_size(), (size_t)_filter.average()); + plab_sz = MIN2(max_size(), plab_sz); + plab_sz = align_object_size(plab_sz); + // Latch the result + _desired_net_plab_sz = plab_sz; + + log_debug(gc, plab)(" (allocated = " SIZE_FORMAT " wasted = " SIZE_FORMAT " " + "unused = " SIZE_FORMAT " used = " SIZE_FORMAT " " + "undo_waste = " SIZE_FORMAT " region_end_waste = " SIZE_FORMAT " " + "regions filled = %u direct_allocated = " SIZE_FORMAT " " + "failure_used = " SIZE_FORMAT " failure_waste = " SIZE_FORMAT ") " + " (plab_sz = " SIZE_FORMAT " desired_plab_sz = " SIZE_FORMAT ")", + _allocated, _wasted, _unused, used(), _undo_wasted, _region_end_waste, + _regions_filled, _direct_allocated, _failure_used, _failure_waste, + cur_plab_sz, plab_sz); + // Clear accumulators for next round. reset(); } --- old/src/share/vm/gc/g1/g1GCPhaseTimes.cpp 2015-12-01 12:06:08.482930812 +0100 +++ new/src/share/vm/gc/g1/g1GCPhaseTimes.cpp 2015-12-01 12:06:08.366930816 +0100 @@ -26,10 +26,10 @@ #include "gc/g1/concurrentG1Refine.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1StringDedup.hpp" #include "gc/g1/workerDataArray.inline.hpp" #include "memory/allocation.hpp" +#include "logging/log.hpp" #include "runtime/os.hpp" // Helper class for avoiding interleaved logging @@ -73,66 +73,60 @@ va_end(ap); } - void print_cr() { - gclog_or_tty->print_cr("%s", _buffer); + const char* to_string() { _cur = _indent_level * INDENT_CHARS; - } - - void append_and_print_cr(const char* format, ...) ATTRIBUTE_PRINTF(2, 3) { - va_list ap; - va_start(ap, format); - vappend(format, ap); - va_end(ap); - print_cr(); + return _buffer; } }; +static const char* Indents[4] = {"", " ", " ", " "}; + G1GCPhaseTimes::G1GCPhaseTimes(uint max_gc_threads) : _max_gc_threads(max_gc_threads) { assert(max_gc_threads > 0, "Must have some GC threads"); - _gc_par_phases[GCWorkerStart] = new WorkerDataArray(max_gc_threads, "GC Worker Start (ms)", false, G1Log::LevelFiner, 2); - _gc_par_phases[ExtRootScan] = new WorkerDataArray(max_gc_threads, "Ext Root Scanning (ms)", true, G1Log::LevelFiner, 2); + _gc_par_phases[GCWorkerStart] = new WorkerDataArray(max_gc_threads, "GC Worker Start:", false, 2); + _gc_par_phases[ExtRootScan] = new WorkerDataArray(max_gc_threads, "Ext Root Scanning:", true, 2); // Root scanning phases - _gc_par_phases[ThreadRoots] = new WorkerDataArray(max_gc_threads, "Thread Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[StringTableRoots] = new WorkerDataArray(max_gc_threads, "StringTable Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[UniverseRoots] = new WorkerDataArray(max_gc_threads, "Universe Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[JNIRoots] = new WorkerDataArray(max_gc_threads, "JNI Handles Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray(max_gc_threads, "ObjectSynchronizer Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[FlatProfilerRoots] = new WorkerDataArray(max_gc_threads, "FlatProfiler Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[ManagementRoots] = new WorkerDataArray(max_gc_threads, "Management Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[SystemDictionaryRoots] = new WorkerDataArray(max_gc_threads, "SystemDictionary Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[CLDGRoots] = new WorkerDataArray(max_gc_threads, "CLDG Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[JVMTIRoots] = new WorkerDataArray(max_gc_threads, "JVMTI Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[CMRefRoots] = new WorkerDataArray(max_gc_threads, "CM RefProcessor Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[WaitForStrongCLD] = new WorkerDataArray(max_gc_threads, "Wait For Strong CLD (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[WeakCLDRoots] = new WorkerDataArray(max_gc_threads, "Weak CLD Roots (ms)", true, G1Log::LevelFinest, 3); - _gc_par_phases[SATBFiltering] = new WorkerDataArray(max_gc_threads, "SATB Filtering (ms)", true, G1Log::LevelFinest, 3); + _gc_par_phases[ThreadRoots] = new WorkerDataArray(max_gc_threads, "Thread Roots:", true, 3); + _gc_par_phases[StringTableRoots] = new WorkerDataArray(max_gc_threads, "StringTable Roots:", true, 3); + _gc_par_phases[UniverseRoots] = new WorkerDataArray(max_gc_threads, "Universe Roots:", true, 3); + _gc_par_phases[JNIRoots] = new WorkerDataArray(max_gc_threads, "JNI Handles Roots:", true, 3); + _gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray(max_gc_threads, "ObjectSynchronizer Roots:", true, 3); + _gc_par_phases[FlatProfilerRoots] = new WorkerDataArray(max_gc_threads, "FlatProfiler Roots:", true, 3); + _gc_par_phases[ManagementRoots] = new WorkerDataArray(max_gc_threads, "Management Roots:", true, 3); + _gc_par_phases[SystemDictionaryRoots] = new WorkerDataArray(max_gc_threads, "SystemDictionary Roots:", true, 3); + _gc_par_phases[CLDGRoots] = new WorkerDataArray(max_gc_threads, "CLDG Roots:", true, 3); + _gc_par_phases[JVMTIRoots] = new WorkerDataArray(max_gc_threads, "JVMTI Roots:", true, 3); + _gc_par_phases[CMRefRoots] = new WorkerDataArray(max_gc_threads, "CM RefProcessor Roots:", true, 3); + _gc_par_phases[WaitForStrongCLD] = new WorkerDataArray(max_gc_threads, "Wait For Strong CLD:", true, 3); + _gc_par_phases[WeakCLDRoots] = new WorkerDataArray(max_gc_threads, "Weak CLD Roots:", true, 3); + _gc_par_phases[SATBFiltering] = new WorkerDataArray(max_gc_threads, "SATB Filtering:", true, 3); - _gc_par_phases[UpdateRS] = new WorkerDataArray(max_gc_threads, "Update RS (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[ScanHCC] = new WorkerDataArray(max_gc_threads, "Scan HCC (ms)", true, G1Log::LevelFiner, 3); + _gc_par_phases[UpdateRS] = new WorkerDataArray(max_gc_threads, "Update RS:", true, 2); + _gc_par_phases[ScanHCC] = new WorkerDataArray(max_gc_threads, "Scan HCC:", true, 3); _gc_par_phases[ScanHCC]->set_enabled(ConcurrentG1Refine::hot_card_cache_enabled()); - _gc_par_phases[ScanRS] = new WorkerDataArray(max_gc_threads, "Scan RS (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[CodeRoots] = new WorkerDataArray(max_gc_threads, "Code Root Scanning (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[ObjCopy] = new WorkerDataArray(max_gc_threads, "Object Copy (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[Termination] = new WorkerDataArray(max_gc_threads, "Termination (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[GCWorkerTotal] = new WorkerDataArray(max_gc_threads, "GC Worker Total (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[GCWorkerEnd] = new WorkerDataArray(max_gc_threads, "GC Worker End (ms)", false, G1Log::LevelFiner, 2); - _gc_par_phases[Other] = new WorkerDataArray(max_gc_threads, "GC Worker Other (ms)", true, G1Log::LevelFiner, 2); + _gc_par_phases[ScanRS] = new WorkerDataArray(max_gc_threads, "Scan RS:", true, 2); + _gc_par_phases[CodeRoots] = new WorkerDataArray(max_gc_threads, "Code Root Scanning:", true, 2); + _gc_par_phases[ObjCopy] = new WorkerDataArray(max_gc_threads, "Object Copy:", true, 2); + _gc_par_phases[Termination] = new WorkerDataArray(max_gc_threads, "Termination:", true, 2); + _gc_par_phases[GCWorkerTotal] = new WorkerDataArray(max_gc_threads, "GC Worker Total:", true, 2); + _gc_par_phases[GCWorkerEnd] = new WorkerDataArray(max_gc_threads, "GC Worker End:", false, 2); + _gc_par_phases[Other] = new WorkerDataArray(max_gc_threads, "GC Worker Other:", true, 2); - _update_rs_processed_buffers = new WorkerDataArray(max_gc_threads, "Processed Buffers", true, G1Log::LevelFiner, 3); + _update_rs_processed_buffers = new WorkerDataArray(max_gc_threads, "Processed Buffers:", true, 3); _gc_par_phases[UpdateRS]->link_thread_work_items(_update_rs_processed_buffers); - _termination_attempts = new WorkerDataArray(max_gc_threads, "Termination Attempts", true, G1Log::LevelFinest, 3); + _termination_attempts = new WorkerDataArray(max_gc_threads, "Termination Attempts:", true, 3); _gc_par_phases[Termination]->link_thread_work_items(_termination_attempts); - _gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray(max_gc_threads, "Queue Fixup (ms)", true, G1Log::LevelFiner, 2); - _gc_par_phases[StringDedupTableFixup] = new WorkerDataArray(max_gc_threads, "Table Fixup (ms)", true, G1Log::LevelFiner, 2); + _gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray(max_gc_threads, "Queue Fixup:", true, 2); + _gc_par_phases[StringDedupTableFixup] = new WorkerDataArray(max_gc_threads, "Table Fixup:", true, 2); - _gc_par_phases[RedirtyCards] = new WorkerDataArray(max_gc_threads, "Parallel Redirty", true, G1Log::LevelFinest, 3); - _redirtied_cards = new WorkerDataArray(max_gc_threads, "Redirtied Cards", true, G1Log::LevelFinest, 3); + _gc_par_phases[RedirtyCards] = new WorkerDataArray(max_gc_threads, "Parallel Redirty", true, 3); + _redirtied_cards = new WorkerDataArray(max_gc_threads, "Redirtied Cards:", true, 3); _gc_par_phases[RedirtyCards]->link_thread_work_items(_redirtied_cards); } @@ -173,16 +167,8 @@ } } -void G1GCPhaseTimes::print_stats(int level, const char* str, double value) { - LineBuffer(level).append_and_print_cr("[%s: %.1lf ms]", str, value); -} - -void G1GCPhaseTimes::print_stats(int level, const char* str, size_t value) { - LineBuffer(level).append_and_print_cr("[%s: " SIZE_FORMAT "]", str, value); -} - -void G1GCPhaseTimes::print_stats(int level, const char* str, double value, uint workers) { - LineBuffer(level).append_and_print_cr("[%s: %.1lf ms, GC Workers: %u]", str, value, workers); +void G1GCPhaseTimes::print_stats(const char* indent, const char* str, double value) { + log_debug(gc, phases)("%s%s: %.1lf ms", indent, str, value); } double G1GCPhaseTimes::accounted_time_ms() { @@ -284,10 +270,6 @@ void print(G1GCPhaseTimes::GCParPhases phase_id) { WorkerDataArray* phase = _phase_times->_gc_par_phases[phase_id]; - if (phase->_log_level > G1Log::level() || !phase->_enabled) { - return; - } - if (phase->_length == 1) { print_single_length(phase_id, phase); } else { @@ -295,69 +277,71 @@ } } - private: + private: void print_single_length(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* phase) { // No need for min, max, average and sum for only one worker - LineBuffer buf(phase->_indent_level); - buf.append_and_print_cr("[%s: %.1lf]", phase->_title, _phase_times->get_time_ms(phase_id, 0)); + log_debug(gc, phases)("%s%s: %.1lf", Indents[phase->_indent_level], phase->_title, _phase_times->get_time_ms(phase_id, 0)); - if (phase->_thread_work_items != NULL) { - LineBuffer buf2(phase->_thread_work_items->_indent_level); - buf2.append_and_print_cr("[%s: " SIZE_FORMAT "]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id)); + WorkerDataArray* work_items = phase->_thread_work_items; + if (work_items != NULL) { + log_debug(gc, phases)("%s%s: " SIZE_FORMAT, Indents[work_items->_indent_level], work_items->_title, _phase_times->sum_thread_work_items(phase_id)); } } - void print_time_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* phase) { - uint active_length = _phase_times->_active_gc_threads; - for (uint i = 0; i < active_length; ++i) { - buf.append(" %.1lf", _phase_times->get_time_ms(phase_id, i)); + void print_time_values(const char* indent, G1GCPhaseTimes::GCParPhases phase_id) { + if (log_is_enabled(Trace, gc)) { + LineBuffer buf(0); + uint active_length = _phase_times->_active_gc_threads; + for (uint i = 0; i < active_length; ++i) { + buf.append(" %4.1lf", _phase_times->get_time_ms(phase_id, i)); + } + const char* line = buf.to_string(); + log_trace(gc, phases)("%s%-25s%s", indent, "", line); } - buf.print_cr(); } - void print_count_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* thread_work_items) { - uint active_length = _phase_times->_active_gc_threads; - for (uint i = 0; i < active_length; ++i) { - buf.append(" " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i)); + void print_count_values(const char* indent, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* thread_work_items) { + if (log_is_enabled(Trace, gc)) { + LineBuffer buf(0); + uint active_length = _phase_times->_active_gc_threads; + for (uint i = 0; i < active_length; ++i) { + buf.append(" " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i)); + } + const char* line = buf.to_string(); + log_trace(gc, phases)("%s%-25s%s", indent, "", line); } - buf.print_cr(); } void print_thread_work_items(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* thread_work_items) { - LineBuffer buf(thread_work_items->_indent_level); - buf.append("[%s:", thread_work_items->_title); - - if (G1Log::finest()) { - print_count_values(buf, phase_id, thread_work_items); - } + const char* indent = Indents[thread_work_items->_indent_level]; assert(thread_work_items->_print_sum, "%s does not have print sum true even though it is a count", thread_work_items->_title); - buf.append_and_print_cr(" Min: " SIZE_FORMAT ", Avg: %.1lf, Max: " SIZE_FORMAT ", Diff: " SIZE_FORMAT ", Sum: " SIZE_FORMAT "]", + log_debug(gc, phases)("%s%-25s Min: " SIZE_FORMAT ", Avg: %4.1lf, Max: " SIZE_FORMAT ", Diff: " SIZE_FORMAT ", Sum: " SIZE_FORMAT, + indent, thread_work_items->_title, _phase_times->min_thread_work_items(phase_id), _phase_times->average_thread_work_items(phase_id), _phase_times->max_thread_work_items(phase_id), _phase_times->max_thread_work_items(phase_id) - _phase_times->min_thread_work_items(phase_id), _phase_times->sum_thread_work_items(phase_id)); + + print_count_values(indent, phase_id, thread_work_items); } void print_multi_length(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray* phase) { - LineBuffer buf(phase->_indent_level); - buf.append("[%s:", phase->_title); - - if (G1Log::finest()) { - print_time_values(buf, phase_id, phase); - } - - buf.append(" Min: %.1lf, Avg: %.1lf, Max: %.1lf, Diff: %.1lf", - _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id), - _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id)); + const char* indent = Indents[phase->_indent_level]; if (phase->_print_sum) { - // for things like the start and end times the sum is not - // that relevant - buf.append(", Sum: %.1lf", _phase_times->sum_time_ms(phase_id)); + log_debug(gc, phases)("%s%-25s Min: %4.1lf, Avg: %4.1lf, Max: %4.1lf, Diff: %4.1lf, Sum: %4.1lf", + indent, phase->_title, + _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id), + _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id), _phase_times->sum_time_ms(phase_id)); + } else { + log_debug(gc, phases)("%s%-25s Min: %4.1lf, Avg: %4.1lf, Max: %4.1lf, Diff: %4.1lf", + indent, phase->_title, + _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id), + _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id)); } - buf.append_and_print_cr("]"); + print_time_values(indent, phase_id); if (phase->_thread_work_items != NULL) { print_thread_work_items(phase_id, phase->_thread_work_items); @@ -371,67 +355,59 @@ G1GCParPhasePrinter par_phase_printer(this); if (_root_region_scan_wait_time_ms > 0.0) { - print_stats(1, "Root Region Scan Waiting", _root_region_scan_wait_time_ms); + print_stats(Indents[1], "Root Region Scan Waiting", _root_region_scan_wait_time_ms); } - print_stats(1, "Parallel Time", _cur_collection_par_time_ms, _active_gc_threads); + print_stats(Indents[1], "Parallel Time", _cur_collection_par_time_ms); for (int i = 0; i <= GCMainParPhasesLast; i++) { par_phase_printer.print((GCParPhases) i); } - print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms); - print_stats(1, "Code Root Purge", _cur_strong_code_root_purge_time_ms); + print_stats(Indents[1], "Code Root Fixup", _cur_collection_code_root_fixup_time_ms); + print_stats(Indents[1], "Code Root Purge", _cur_strong_code_root_purge_time_ms); if (G1StringDedup::is_enabled()) { - print_stats(1, "String Dedup Fixup", _cur_string_dedup_fixup_time_ms, _active_gc_threads); + print_stats(Indents[1], "String Dedup Fixup", _cur_string_dedup_fixup_time_ms); for (int i = StringDedupPhasesFirst; i <= StringDedupPhasesLast; i++) { par_phase_printer.print((GCParPhases) i); } } - print_stats(1, "Clear CT", _cur_clear_ct_time_ms); - print_stats(1, "Expand Heap After Collection", _cur_expand_heap_time_ms); - + print_stats(Indents[1], "Clear CT", _cur_clear_ct_time_ms); + print_stats(Indents[1], "Expand Heap After Collection", _cur_expand_heap_time_ms); double misc_time_ms = pause_time_sec * MILLIUNITS - accounted_time_ms(); - print_stats(1, "Other", misc_time_ms); + print_stats(Indents[1], "Other", misc_time_ms); if (_cur_verify_before_time_ms > 0.0) { - print_stats(2, "Verify Before", _cur_verify_before_time_ms); + print_stats(Indents[2], "Verify Before", _cur_verify_before_time_ms); } if (G1CollectedHeap::heap()->evacuation_failed()) { double evac_fail_handling = _cur_evac_fail_recalc_used + _cur_evac_fail_remove_self_forwards + _cur_evac_fail_restore_remsets; - print_stats(2, "Evacuation Failure", evac_fail_handling); - if (G1Log::finest()) { - print_stats(3, "Recalculate Used", _cur_evac_fail_recalc_used); - print_stats(3, "Remove Self Forwards", _cur_evac_fail_remove_self_forwards); - print_stats(3, "Restore RemSet", _cur_evac_fail_restore_remsets); - } + print_stats(Indents[2], "Evacuation Failure", evac_fail_handling); + log_trace(gc, phases)("%sRecalculate Used: %.1lf ms", Indents[3], _cur_evac_fail_recalc_used); + log_trace(gc, phases)("%sRemove Self Forwards: %.1lf ms", Indents[3], _cur_evac_fail_remove_self_forwards); + log_trace(gc, phases)("%sRestore RemSet: %.1lf ms", Indents[3], _cur_evac_fail_restore_remsets); } - print_stats(2, "Choose CSet", + print_stats(Indents[2], "Choose CSet", (_recorded_young_cset_choice_time_ms + _recorded_non_young_cset_choice_time_ms)); - print_stats(2, "Ref Proc", _cur_ref_proc_time_ms); - print_stats(2, "Ref Enq", _cur_ref_enq_time_ms); - print_stats(2, "Redirty Cards", _recorded_redirty_logged_cards_time_ms); + print_stats(Indents[2], "Ref Proc", _cur_ref_proc_time_ms); + print_stats(Indents[2], "Ref Enq", _cur_ref_enq_time_ms); + print_stats(Indents[2], "Redirty Cards", _recorded_redirty_logged_cards_time_ms); par_phase_printer.print(RedirtyCards); if (G1EagerReclaimHumongousObjects) { - print_stats(2, "Humongous Register", _cur_fast_reclaim_humongous_register_time_ms); - if (G1Log::finest()) { - print_stats(3, "Humongous Total", _cur_fast_reclaim_humongous_total); - print_stats(3, "Humongous Candidate", _cur_fast_reclaim_humongous_candidates); - } - print_stats(2, "Humongous Reclaim", _cur_fast_reclaim_humongous_time_ms); - if (G1Log::finest()) { - print_stats(3, "Humongous Reclaimed", _cur_fast_reclaim_humongous_reclaimed); - } + print_stats(Indents[2], "Humongous Register", _cur_fast_reclaim_humongous_register_time_ms); + + log_trace(gc, phases)("%sHumongous Total: " SIZE_FORMAT, Indents[3], _cur_fast_reclaim_humongous_total); + log_trace(gc, phases)("%sHumongous Candidate: " SIZE_FORMAT, Indents[3], _cur_fast_reclaim_humongous_candidates); + print_stats(Indents[2], "Humongous Reclaim", _cur_fast_reclaim_humongous_time_ms); + log_trace(gc, phases)("%sHumongous Reclaimed: " SIZE_FORMAT, Indents[3], _cur_fast_reclaim_humongous_reclaimed); } - print_stats(2, "Free CSet", + print_stats(Indents[2], "Free CSet", (_recorded_young_free_cset_time_ms + _recorded_non_young_free_cset_time_ms)); - if (G1Log::finest()) { - print_stats(3, "Young Free CSet", _recorded_young_free_cset_time_ms); - print_stats(3, "Non-Young Free CSet", _recorded_non_young_free_cset_time_ms); - } + log_trace(gc, phases)("%sYoung Free CSet: %.1lf ms", Indents[3], _recorded_young_free_cset_time_ms); + log_trace(gc, phases)("%sNon-Young Free CSet: %.1lf ms", Indents[3], _recorded_non_young_free_cset_time_ms); if (_cur_verify_after_time_ms > 0.0) { - print_stats(2, "Verify After", _cur_verify_after_time_ms); + print_stats(Indents[2], "Verify After", _cur_verify_after_time_ms); } } --- old/src/share/vm/gc/g1/g1GCPhaseTimes.hpp 2015-12-01 12:06:08.666930805 +0100 +++ new/src/share/vm/gc/g1/g1GCPhaseTimes.hpp 2015-12-01 12:06:08.562930809 +0100 @@ -119,9 +119,7 @@ double _cur_verify_after_time_ms; // Helper methods for detailed logging - void print_stats(int level, const char* str, double value); - void print_stats(int level, const char* str, size_t value); - void print_stats(int level, const char* str, double value, uint workers); + void print_stats(const char*, const char* str, double value); void note_gc_end(); --- old/src/share/vm/gc/g1/g1HRPrinter.cpp 2015-12-01 12:06:08.858930798 +0100 +++ new/src/share/vm/gc/g1/g1HRPrinter.cpp 2015-12-01 12:06:08.738930803 +0100 @@ -60,18 +60,6 @@ return NULL; } -const char* G1HRPrinter::phase_name(PhaseType phase) { - switch (phase) { - case StartGC: return "StartGC"; - case EndGC: return "EndGC"; - case StartFullGC: return "StartFullGC"; - case EndFullGC: return "EndFullGC"; - default: ShouldNotReachHere(); - } - // trying to keep the Windows compiler happy - return NULL; -} - #define G1HR_PREFIX " G1HR" void G1HRPrinter::print(ActionType action, RegionType type, @@ -82,19 +70,19 @@ if (type_str != NULL) { if (top != NULL) { - gclog_or_tty->print_cr(G1HR_PREFIX " %s(%s) " PTR_FORMAT " " PTR_FORMAT, - action_str, type_str, p2i(bottom), p2i(top)); + log_trace(gc, region)(G1HR_PREFIX " %s(%s) " PTR_FORMAT " " PTR_FORMAT, + action_str, type_str, p2i(bottom), p2i(top)); } else { - gclog_or_tty->print_cr(G1HR_PREFIX " %s(%s) " PTR_FORMAT, - action_str, type_str, p2i(bottom)); + log_trace(gc, region)(G1HR_PREFIX " %s(%s) " PTR_FORMAT, + action_str, type_str, p2i(bottom)); } } else { if (top != NULL) { - gclog_or_tty->print_cr(G1HR_PREFIX " %s " PTR_FORMAT " " PTR_FORMAT, - action_str, p2i(bottom), p2i(top)); + log_trace(gc, region)(G1HR_PREFIX " %s " PTR_FORMAT " " PTR_FORMAT, + action_str, p2i(bottom), p2i(top)); } else { - gclog_or_tty->print_cr(G1HR_PREFIX " %s " PTR_FORMAT, - action_str, p2i(bottom)); + log_trace(gc, region)(G1HR_PREFIX " %s " PTR_FORMAT, + action_str, p2i(bottom)); } } } @@ -102,11 +90,6 @@ void G1HRPrinter::print(ActionType action, HeapWord* bottom, HeapWord* end) { const char* action_str = action_name(action); - gclog_or_tty->print_cr(G1HR_PREFIX " %s [" PTR_FORMAT "," PTR_FORMAT "]", - action_str, p2i(bottom), p2i(end)); -} - -void G1HRPrinter::print(PhaseType phase, size_t phase_num) { - const char* phase_str = phase_name(phase); - gclog_or_tty->print_cr(G1HR_PREFIX " #%s " SIZE_FORMAT, phase_str, phase_num); + log_trace(gc, region)(G1HR_PREFIX " %s [" PTR_FORMAT "," PTR_FORMAT "]", + action_str, p2i(bottom), p2i(end)); } --- old/src/share/vm/gc/g1/g1HRPrinter.hpp 2015-12-01 12:06:09.042930792 +0100 +++ new/src/share/vm/gc/g1/g1HRPrinter.hpp 2015-12-01 12:06:08.930930796 +0100 @@ -26,6 +26,7 @@ #define SHARE_VM_GC_G1_G1HRPRINTER_HPP #include "gc/g1/heapRegion.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #define SKIP_RETIRED_FULL_REGIONS 1 @@ -55,19 +56,9 @@ Archive } RegionType; - typedef enum { - StartGC, - EndGC, - StartFullGC, - EndFullGC - } PhaseType; - private: - bool _active; - static const char* action_name(ActionType action); static const char* region_type_name(RegionType type); - static const char* phase_name(PhaseType phase); // Print an action event. This version is used in most scenarios and // only prints the region's bottom. The parameters type and top are @@ -79,18 +70,11 @@ // bottom and end. Used for Commit / Uncommit events. static void print(ActionType action, HeapWord* bottom, HeapWord* end); - // Print a phase event. - static void print(PhaseType phase, size_t phase_num); - public: // In some places we iterate over a list in order to generate output // for the list's elements. By exposing this we can avoid this // iteration if the printer is not active. - const bool is_active() { return _active; } - - // Have to set this explicitly as we have to do this during the - // heap's initialize() method, not in the constructor. - void set_active(bool active) { _active = active; } + const bool is_active() { return log_is_enabled(Trace, gc, region); } // The methods below are convenient wrappers for the print() methods. @@ -155,28 +139,6 @@ print(Uncommit, bottom, end); } } - - void start_gc(bool full, size_t gc_num) { - if (is_active()) { - if (!full) { - print(StartGC, gc_num); - } else { - print(StartFullGC, gc_num); - } - } - } - - void end_gc(bool full, size_t gc_num) { - if (is_active()) { - if (!full) { - print(EndGC, gc_num); - } else { - print(EndFullGC, gc_num); - } - } - } - - G1HRPrinter() : _active(false) { } }; #endif // SHARE_VM_GC_G1_G1HRPRINTER_HPP --- old/src/share/vm/gc/g1/g1IHOPControl.cpp 2015-12-01 12:06:09.230930785 +0100 +++ new/src/share/vm/gc/g1/g1IHOPControl.cpp 2015-12-01 12:06:09.118930789 +0100 @@ -24,10 +24,10 @@ #include "precompiled.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" #include "gc/g1/g1IHOPControl.hpp" #include "gc/g1/g1Predictions.hpp" #include "gc/shared/gcTrace.hpp" +#include "logging/log.hpp" G1IHOPControl::G1IHOPControl(double initial_ihop_percent, size_t target_occupancy) : _initial_ihop_percent(initial_ihop_percent), @@ -47,20 +47,14 @@ void G1IHOPControl::print() { size_t cur_conc_mark_start_threshold = get_conc_mark_start_threshold(); - ergo_verbose6(ErgoIHOP, - "basic information", - ergo_format_reason("value update") - ergo_format_byte_perc("threshold") - ergo_format_byte("target occupancy") - ergo_format_byte("current occupancy") - ergo_format_double("recent old gen allocation rate") - ergo_format_double("recent marking phase length"), - cur_conc_mark_start_threshold, - cur_conc_mark_start_threshold * 100.0 / _target_occupancy, - _target_occupancy, - G1CollectedHeap::heap()->used(), - _last_allocation_time_s > 0.0 ? _last_allocated_bytes / _last_allocation_time_s : 0.0, - last_marking_length_s()); + log_debug(gc, ihop)("Basic information (value update), threshold: " SIZE_FORMAT "B (%1.2f), target occupancy: " SIZE_FORMAT "B, current occupancy: " SIZE_FORMAT "B," + " recent old gen allocation rate: %1.2f, recent marking phase length: %1.2f", + cur_conc_mark_start_threshold, + cur_conc_mark_start_threshold * 100.0 / _target_occupancy, + _target_occupancy, + G1CollectedHeap::heap()->used(), + _last_allocation_time_s > 0.0 ? _last_allocated_bytes / _last_allocation_time_s : 0.0, + last_marking_length_s()); } void G1IHOPControl::send_trace_event(G1NewTracer* tracer) { @@ -192,21 +186,14 @@ void G1AdaptiveIHOPControl::print() { G1IHOPControl::print(); size_t actual_target = actual_target_threshold(); - ergo_verbose6(ErgoIHOP, - "adaptive IHOP information", - ergo_format_reason("value update") - ergo_format_byte_perc("threshold") - ergo_format_byte("internal target occupancy") - ergo_format_double("predicted old gen allocation rate") - ergo_format_double("predicted marking phase length") - ergo_format_str("prediction active"), - get_conc_mark_start_threshold(), - percent_of(get_conc_mark_start_threshold(), actual_target), - actual_target, - _predictor->get_new_prediction(&_allocation_rate_s), - _predictor->get_new_prediction(&_marking_times_s), - have_enough_data_for_prediction() ? "true" : "false" - ); + log_debug(gc, ihop)("Adaptive IHOP information (value update), threshold: " SIZE_FORMAT "B (%1.2f), internal target occupancy: " SIZE_FORMAT "B," + " predicted old gen allocation rate: %1.2f, predicted marking phase length: %1.2f, prediction active: %s", + get_conc_mark_start_threshold(), + percent_of(get_conc_mark_start_threshold(), actual_target), + actual_target, + _predictor->get_new_prediction(&_allocation_rate_s), + _predictor->get_new_prediction(&_marking_times_s), + have_enough_data_for_prediction() ? "true" : "false"); } void G1AdaptiveIHOPControl::send_trace_event(G1NewTracer* tracer) { --- old/src/share/vm/gc/g1/g1MarkSweep.cpp 2015-12-01 12:06:09.390930780 +0100 +++ new/src/share/vm/gc/g1/g1MarkSweep.cpp 2015-12-01 12:06:09.302930783 +0100 @@ -29,7 +29,6 @@ #include "classfile/vmSymbols.hpp" #include "code/codeCache.hpp" #include "code/icBuffer.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1MarkSweep.hpp" #include "gc/g1/g1RootProcessor.hpp" #include "gc/g1/g1StringDedup.hpp" @@ -38,7 +37,7 @@ #include "gc/shared/gcLocker.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/modRefBarrierSet.hpp" #include "gc/shared/referencePolicy.hpp" @@ -123,7 +122,7 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading, bool clear_all_softrefs) { // Recursively traverse all live objects and mark them - GCTraceTime tm("phase 1", G1Log::fine() && Verbose, true, gc_timer()); + GCTraceTime(Trace, gc) tm("Phase 1: Mark live objects", gc_timer()); G1CollectedHeap* g1h = G1CollectedHeap::heap(); @@ -183,13 +182,8 @@ // fail. At the end of the GC, the original mark word values // (including hash values) are restored to the appropriate // objects. - if (!VerifySilently) { - gclog_or_tty->print(" VerifyDuringGC:(full)[Verifying "); - } - g1h->verify(VerifySilently, VerifyOption_G1UseMarkWord); - if (!VerifySilently) { - gclog_or_tty->print_cr("]"); - } + GCTraceTime(Info, gc, verify)("During GC (full)"); + g1h->verify(VerifyOption_G1UseMarkWord); } gc_tracer()->report_object_count_after_gc(&GenMarkSweep::is_alive); @@ -203,7 +197,7 @@ // phase2, phase3 and phase4, but the ValidateMarkSweep live oops // tracking expects us to do so. See comment under phase4. - GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer()); + GCTraceTime(Trace, gc) tm("Phase 2: Compute new object addresses", gc_timer()); prepare_compaction(); } @@ -236,7 +230,7 @@ G1CollectedHeap* g1h = G1CollectedHeap::heap(); // Adjust the pointers to reflect the new locations - GCTraceTime tm("phase 3", G1Log::fine() && Verbose, true, gc_timer()); + GCTraceTime(Trace, gc) tm("Phase 3: Adjust pointers", gc_timer()); // Need cleared claim bits for the roots processing ClassLoaderDataGraph::clear_claimed_marks(); @@ -297,7 +291,7 @@ // to use a higher index (saved from phase2) when verifying perm_gen. G1CollectedHeap* g1h = G1CollectedHeap::heap(); - GCTraceTime tm("phase 4", G1Log::fine() && Verbose, true, gc_timer()); + GCTraceTime(Trace, gc) tm("Phase 4: Move objects", gc_timer()); G1SpaceCompactClosure blk; g1h->heap_region_iterate(&blk); --- old/src/share/vm/gc/g1/g1RemSet.cpp 2015-12-01 12:06:09.590930773 +0100 +++ new/src/share/vm/gc/g1/g1RemSet.cpp 2015-12-01 12:06:09.478930777 +0100 @@ -52,7 +52,7 @@ for (uint i = 0; i < n_workers(); i++) { _cset_rs_update_cl[i] = NULL; } - if (G1SummarizeRSetStats) { + if (log_is_enabled(Trace, gc, remset)) { _prev_period_summary.initialize(this); } // Initialize the card queue set used to hold cards containing @@ -109,17 +109,6 @@ } } -void ScanRSClosure::printCard(HeapRegion* card_region, size_t card_index, - HeapWord* card_start) { - gclog_or_tty->print_cr("T %u Region [" PTR_FORMAT ", " PTR_FORMAT ") " - "RS names card " SIZE_FORMAT_HEX ": " - "[" PTR_FORMAT ", " PTR_FORMAT ")", - _worker_i, - p2i(card_region->bottom()), p2i(card_region->end()), - card_index, - p2i(card_start), p2i(card_start + G1BlockOffsetSharedArray::N_words)); -} - void ScanRSClosure::scan_strong_code_roots(HeapRegion* r) { double scan_start = os::elapsedTime(); r->strong_code_roots_do(_code_root_cl); @@ -152,10 +141,6 @@ } if (current_card < jump_to_card) continue; HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index); -#if 0 - gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n", - card_start, card_start + CardTableModRefBS::card_size_in_words); -#endif HeapRegion* card_region = _g1h->heap_region_containing(card_start); _cards++; @@ -526,31 +511,36 @@ return has_refs_into_cset; } -void G1RemSet::print_periodic_summary_info(const char* header) { - G1RemSetSummary current; - current.initialize(this); - - _prev_period_summary.subtract_from(¤t); - print_summary_info(&_prev_period_summary, header); +void G1RemSet::print_periodic_summary_info(const char* header, uint period_count) { + if ((G1SummarizeRSetStatsPeriod > 0) && log_is_enabled(Trace, gc, remset) && + (period_count % G1SummarizeRSetStatsPeriod == 0)) { - _prev_period_summary.set(¤t); -} + if (!_prev_period_summary.initialized()) { + _prev_period_summary.initialize(this); + } -void G1RemSet::print_summary_info() { - G1RemSetSummary current; - current.initialize(this); + G1RemSetSummary current; + current.initialize(this); + _prev_period_summary.subtract_from(¤t); + + LogHandle(gc, remset) log; + log.trace("%s", header); + ResourceMark rm; + _prev_period_summary.print_on(log.trace_stream()); - print_summary_info(¤t, " Cumulative RS summary"); + _prev_period_summary.set(¤t); + } } -void G1RemSet::print_summary_info(G1RemSetSummary * summary, const char * header) { - assert(summary != NULL, "just checking"); - - if (header != NULL) { - gclog_or_tty->print_cr("%s", header); +void G1RemSet::print_summary_info() { + LogHandle(gc, remset, exit) log; + if (log.is_trace()) { + log.trace(" Cumulative RS summary"); + G1RemSetSummary current; + current.initialize(this); + ResourceMark rm; + current.print_on(log.trace_stream()); } - - summary->print_on(gclog_or_tty); } void G1RemSet::prepare_for_verify() { --- old/src/share/vm/gc/g1/g1RemSet.hpp 2015-12-01 12:06:09.794930766 +0100 +++ new/src/share/vm/gc/g1/g1RemSet.hpp 2015-12-01 12:06:09.678930770 +0100 @@ -33,6 +33,7 @@ class G1CollectedHeap; class ConcurrentG1Refine; class G1ParPushHeapRSClosure; +class outputStream; // A G1RemSet in which each heap region has a rem set that records the // external heap references into it. Uses a mod ref bs to track updates, @@ -63,8 +64,6 @@ // references into the collection set. G1ParPushHeapRSClosure** _cset_rs_update_cl; - // Print the given summary info - virtual void print_summary_info(G1RemSetSummary * summary, const char * header = NULL); public: // This is called to reset dual hash tables after the gc pause // is finished and the initial hash table is no longer being @@ -135,7 +134,7 @@ virtual void print_summary_info(); // Print accumulated summary info from the last time called. - virtual void print_periodic_summary_info(const char* header); + virtual void print_periodic_summary_info(const char* header, uint period_count); // Prepare remembered set for verification. virtual void prepare_for_verify(); --- old/src/share/vm/gc/g1/g1RemSetSummary.cpp 2015-12-01 12:06:09.954930760 +0100 +++ new/src/share/vm/gc/g1/g1RemSetSummary.cpp 2015-12-01 12:06:09.866930763 +0100 @@ -271,7 +271,7 @@ void print_summary_on(outputStream* out) { RegionTypeCounter* counters[] = { &_young, &_humonguous, &_free, &_old, NULL }; - out->print_cr("\n Current rem set statistics"); + out->print_cr(" Current rem set statistics"); out->print_cr(" Total per region rem sets sizes = " SIZE_FORMAT "K." " Max = " SIZE_FORMAT "K.", round_to_K(total_rs_mem_sz()), round_to_K(max_rs_mem_sz())); @@ -323,7 +323,7 @@ }; void G1RemSetSummary::print_on(outputStream* out) { - out->print_cr("\n Recent concurrent refinement statistics"); + out->print_cr(" Recent concurrent refinement statistics"); out->print_cr(" Processed " SIZE_FORMAT " cards", num_concurrent_refined_cards()); out->print_cr(" Of " SIZE_FORMAT " completed buffers:", num_processed_buf_total()); --- old/src/share/vm/gc/g1/g1RemSetSummary.hpp 2015-12-01 12:06:10.142930754 +0100 +++ new/src/share/vm/gc/g1/g1RemSetSummary.hpp 2015-12-01 12:06:10.042930757 +0100 @@ -85,6 +85,7 @@ // initialize and get the first sampling void initialize(G1RemSet* remset); + bool const initialized() { return _rs_threads_vtimes != NULL; } void print_on(outputStream* out); --- old/src/share/vm/gc/g1/g1SATBCardTableModRefBS.cpp 2015-12-01 12:06:10.334930747 +0100 +++ new/src/share/vm/gc/g1/g1SATBCardTableModRefBS.cpp 2015-12-01 12:06:10.214930751 +0100 @@ -28,6 +28,7 @@ #include "gc/g1/heapRegion.hpp" #include "gc/g1/satbMarkQueue.hpp" #include "gc/shared/memset_with_concurrent_readers.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/mutexLocker.hpp" @@ -147,17 +148,10 @@ assert(byte_for(low_bound) == &_byte_map[0], "Checking start of map"); assert(byte_for(high_bound-1) <= &_byte_map[_last_valid_index], "Checking end of map"); - if (TraceCardTableModRefBS) { - gclog_or_tty->print_cr("G1SATBCardTableModRefBS::G1SATBCardTableModRefBS: "); - gclog_or_tty->print_cr(" " - " &_byte_map[0]: " INTPTR_FORMAT - " &_byte_map[_last_valid_index]: " INTPTR_FORMAT, - p2i(&_byte_map[0]), - p2i(&_byte_map[_last_valid_index])); - gclog_or_tty->print_cr(" " - " byte_map_base: " INTPTR_FORMAT, - p2i(byte_map_base)); - } + log_trace(gc, barrier)("G1SATBCardTableModRefBS::G1SATBCardTableModRefBS: "); + log_trace(gc, barrier)(" &_byte_map[0]: " INTPTR_FORMAT " &_byte_map[_last_valid_index]: " INTPTR_FORMAT, + p2i(&_byte_map[0]), p2i(&_byte_map[_last_valid_index])); + log_trace(gc, barrier)(" byte_map_base: " INTPTR_FORMAT, p2i(byte_map_base)); } void --- old/src/share/vm/gc/g1/g1StringDedupQueue.cpp 2015-12-01 12:06:10.534930740 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupQueue.cpp 2015-12-01 12:06:10.414930744 +0100 @@ -28,6 +28,7 @@ #include "gc/g1/g1StringDedup.hpp" #include "gc/g1/g1StringDedupQueue.hpp" #include "gc/shared/gcLocker.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/mutexLocker.hpp" @@ -152,10 +153,9 @@ } } -void G1StringDedupQueue::print_statistics(outputStream* st) { - st->print_cr( - " [Queue]\n" - " [Dropped: " UINTX_FORMAT "]", _queue->_dropped); +void G1StringDedupQueue::print_statistics() { + log_debug(gc, stringdedup)(" [Queue]"); + log_debug(gc, stringdedup)(" [Dropped: " UINTX_FORMAT "]", _queue->_dropped); } void G1StringDedupQueue::verify() { --- old/src/share/vm/gc/g1/g1StringDedupQueue.hpp 2015-12-01 12:06:10.726930733 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupQueue.hpp 2015-12-01 12:06:10.606930738 +0100 @@ -94,7 +94,7 @@ static void unlink_or_oops_do(G1StringDedupUnlinkOrOopsDoClosure* cl); - static void print_statistics(outputStream* st); + static void print_statistics(); static void verify(); }; --- old/src/share/vm/gc/g1/g1StringDedupStat.cpp 2015-12-01 12:06:10.918930727 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupStat.cpp 2015-12-01 12:06:10.802930731 +0100 @@ -24,6 +24,7 @@ #include "precompiled.hpp" #include "gc/g1/g1StringDedupStat.hpp" +#include "logging/log.hpp" G1StringDedupStat::G1StringDedupStat() : _inspected(0), @@ -68,7 +69,7 @@ _block_elapsed += stat._block_elapsed; } -void G1StringDedupStat::print_summary(outputStream* st, const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat) { +void G1StringDedupStat::print_summary(const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat) { double total_deduped_bytes_percent = 0.0; if (total_stat._new_bytes > 0) { @@ -76,10 +77,8 @@ total_deduped_bytes_percent = (double)total_stat._deduped_bytes / (double)total_stat._new_bytes * 100.0; } - st->date_stamp(PrintGCDateStamps); - st->stamp(PrintGCTimeStamps); - st->print_cr( - "[GC concurrent-string-deduplication, " + log_info(gc, stringdedup)( + "Concurrent String Deduplication " G1_STRDEDUP_BYTES_FORMAT_NS "->" G1_STRDEDUP_BYTES_FORMAT_NS "(" G1_STRDEDUP_BYTES_FORMAT_NS "), avg " G1_STRDEDUP_PERCENT_FORMAT_NS ", " G1_STRDEDUP_TIME_FORMAT "]", G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes), @@ -89,7 +88,7 @@ last_stat._exec_elapsed); } -void G1StringDedupStat::print_statistics(outputStream* st, const G1StringDedupStat& stat, bool total) { +void G1StringDedupStat::print_statistics(const G1StringDedupStat& stat, bool total) { double young_percent = 0.0; double old_percent = 0.0; double skipped_percent = 0.0; @@ -134,29 +133,24 @@ } if (total) { - st->print_cr( + log_debug(gc, stringdedup)( " [Total Exec: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Idle: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]", stat._exec, stat._exec_elapsed, stat._idle, stat._idle_elapsed, stat._block, stat._block_elapsed); } else { - st->print_cr( + log_debug(gc, stringdedup)( " [Last Exec: " G1_STRDEDUP_TIME_FORMAT ", Idle: " G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]", stat._exec_elapsed, stat._idle_elapsed, stat._block, stat._block_elapsed); } - st->print_cr( - " [Inspected: " G1_STRDEDUP_OBJECTS_FORMAT "]\n" - " [Skipped: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" - " [Hashed: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" - " [Known: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" - " [New: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "]\n" - " [Deduplicated: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" - " [Young: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" - " [Old: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", - stat._inspected, - stat._skipped, skipped_percent, - stat._hashed, hashed_percent, - stat._known, known_percent, - stat._new, new_percent, G1_STRDEDUP_BYTES_PARAM(stat._new_bytes), - stat._deduped, deduped_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_bytes), deduped_bytes_percent, - stat._deduped_young, deduped_young_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_young_bytes), deduped_young_bytes_percent, - stat._deduped_old, deduped_old_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_old_bytes), deduped_old_bytes_percent); + log_debug(gc, stringdedup)(" [Inspected: " G1_STRDEDUP_OBJECTS_FORMAT "]", stat._inspected); + log_debug(gc, stringdedup)(" [Skipped: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", stat._skipped, skipped_percent); + log_debug(gc, stringdedup)(" [Hashed: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", stat._hashed, hashed_percent); + log_debug(gc, stringdedup)(" [Known: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", stat._known, known_percent); + log_debug(gc, stringdedup)(" [New: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "]", + stat._new, new_percent, G1_STRDEDUP_BYTES_PARAM(stat._new_bytes)); + log_debug(gc, stringdedup)(" [Deduplicated: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", + stat._deduped, deduped_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_bytes), deduped_bytes_percent); + log_debug(gc, stringdedup)(" [Young: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", + stat._deduped_young, deduped_young_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_young_bytes), deduped_young_bytes_percent); + log_debug(gc, stringdedup)(" [Old: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", + stat._deduped_old, deduped_old_percent, G1_STRDEDUP_BYTES_PARAM(stat._deduped_old_bytes), deduped_old_bytes_percent); } --- old/src/share/vm/gc/g1/g1StringDedupStat.hpp 2015-12-01 12:06:11.110930720 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupStat.hpp 2015-12-01 12:06:10.994930724 +0100 @@ -135,8 +135,8 @@ void add(const G1StringDedupStat& stat); - static void print_summary(outputStream* st, const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat); - static void print_statistics(outputStream* st, const G1StringDedupStat& stat, bool total); + static void print_summary(const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat); + static void print_statistics(const G1StringDedupStat& stat, bool total); }; #endif // SHARE_VM_GC_G1_G1STRINGDEDUPSTAT_HPP --- old/src/share/vm/gc/g1/g1StringDedupTable.cpp 2015-12-01 12:06:11.298930713 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupTable.cpp 2015-12-01 12:06:11.182930717 +0100 @@ -30,6 +30,7 @@ #include "gc/g1/g1StringDedup.hpp" #include "gc/g1/g1StringDedupTable.hpp" #include "gc/shared/gcLocker.hpp" +#include "logging/log.hpp" #include "memory/padded.inline.hpp" #include "oops/oop.inline.hpp" #include "oops/typeArrayOop.hpp" @@ -568,19 +569,16 @@ _entry_cache->trim(max_cache_size); } -void G1StringDedupTable::print_statistics(outputStream* st) { - st->print_cr( - " [Table]\n" - " [Memory Usage: " G1_STRDEDUP_BYTES_FORMAT_NS "]\n" - " [Size: " SIZE_FORMAT ", Min: " SIZE_FORMAT ", Max: " SIZE_FORMAT "]\n" - " [Entries: " UINTX_FORMAT ", Load: " G1_STRDEDUP_PERCENT_FORMAT_NS ", Cached: " UINTX_FORMAT ", Added: " UINTX_FORMAT ", Removed: " UINTX_FORMAT "]\n" - " [Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS ")]\n" - " [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: 0x%x]\n" - " [Age Threshold: " UINTX_FORMAT "]", - G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry)), - _table->_size, _min_size, _max_size, - _table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed, - _resize_count, _table->_shrink_threshold, _shrink_load_factor * 100.0, _table->_grow_threshold, _grow_load_factor * 100.0, - _rehash_count, _rehash_threshold, _table->_hash_seed, - StringDeduplicationAgeThreshold); +void G1StringDedupTable::print_statistics() { + LogHandle(gc, stringdedup) log; + log.debug(" [Table]"); + log.debug(" [Memory Usage: " G1_STRDEDUP_BYTES_FORMAT_NS "]", + G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry))); + log.debug(" [Size: " SIZE_FORMAT ", Min: " SIZE_FORMAT ", Max: " SIZE_FORMAT "]", _table->_size, _min_size, _max_size); + log.debug(" [Entries: " UINTX_FORMAT ", Load: " G1_STRDEDUP_PERCENT_FORMAT_NS ", Cached: " UINTX_FORMAT ", Added: " UINTX_FORMAT ", Removed: " UINTX_FORMAT "]", + _table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed); + log.debug(" [Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS ")]", + _resize_count, _table->_shrink_threshold, _shrink_load_factor * 100.0, _table->_grow_threshold, _grow_load_factor * 100.0); + log.debug(" [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: 0x%x]", _rehash_count, _rehash_threshold, _table->_hash_seed); + log.debug(" [Age Threshold: " UINTX_FORMAT "]", StringDeduplicationAgeThreshold); } --- old/src/share/vm/gc/g1/g1StringDedupTable.hpp 2015-12-01 12:06:11.486930707 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupTable.hpp 2015-12-01 12:06:11.382930710 +0100 @@ -234,7 +234,7 @@ static void unlink_or_oops_do(G1StringDedupUnlinkOrOopsDoClosure* cl, uint worker_id); - static void print_statistics(outputStream* st); + static void print_statistics(); static void verify(); }; --- old/src/share/vm/gc/g1/g1StringDedupThread.cpp 2015-12-01 12:06:11.674930700 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupThread.cpp 2015-12-01 12:06:11.558930704 +0100 @@ -24,12 +24,12 @@ #include "precompiled.hpp" #include "classfile/stringTable.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/g1StringDedup.hpp" #include "gc/g1/g1StringDedupQueue.hpp" #include "gc/g1/g1StringDedupTable.hpp" #include "gc/g1/g1StringDedupThread.hpp" #include "gc/g1/suspendibleThreadSet.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" @@ -129,7 +129,7 @@ // Print statistics total_stat.add(stat); - print(gclog_or_tty, stat, total_stat); + print(stat, total_stat); } } @@ -152,14 +152,14 @@ } } -void G1StringDedupThread::print(outputStream* st, const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat) { - if (G1Log::fine() || PrintStringDeduplicationStatistics) { - G1StringDedupStat::print_summary(st, last_stat, total_stat); - if (PrintStringDeduplicationStatistics) { - G1StringDedupStat::print_statistics(st, last_stat, false); - G1StringDedupStat::print_statistics(st, total_stat, true); - G1StringDedupTable::print_statistics(st); - G1StringDedupQueue::print_statistics(st); +void G1StringDedupThread::print(const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat) { + if (log_is_enabled(Info, gc, stringdedup)) { + G1StringDedupStat::print_summary(last_stat, total_stat); + if (log_is_enabled(Debug, gc, stringdedup)) { + G1StringDedupStat::print_statistics(last_stat, false); + G1StringDedupStat::print_statistics(total_stat, true); + G1StringDedupTable::print_statistics(); + G1StringDedupQueue::print_statistics(); } } } --- old/src/share/vm/gc/g1/g1StringDedupThread.hpp 2015-12-01 12:06:11.870930693 +0100 +++ new/src/share/vm/gc/g1/g1StringDedupThread.hpp 2015-12-01 12:06:11.754930698 +0100 @@ -43,7 +43,7 @@ G1StringDedupThread(); ~G1StringDedupThread(); - void print(outputStream* st, const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat); + void print(const G1StringDedupStat& last_stat, const G1StringDedupStat& total_stat); public: static void create(); --- old/src/share/vm/gc/g1/g1_globals.hpp 2015-12-01 12:06:12.042930688 +0100 +++ new/src/share/vm/gc/g1/g1_globals.hpp 2015-12-01 12:06:11.942930691 +0100 @@ -51,32 +51,14 @@ "Overhead of concurrent marking") \ range(0, 100) \ \ - develop(intx, G1MarkingVerboseLevel, 0, \ - "Level (0-4) of verboseness of the marking code") \ - range(0, 4) \ - \ - develop(bool, G1TraceMarkStackOverflow, false, \ - "If true, extra debugging code for CM restart for ovflw.") \ - \ - diagnostic(bool, G1SummarizeConcMark, false, \ - "Summarize concurrent mark info") \ - \ - diagnostic(bool, G1SummarizeRSetStats, false, \ - "Summarize remembered set processing info") \ - \ diagnostic(intx, G1SummarizeRSetStatsPeriod, 0, \ "The period (in number of GCs) at which we will generate " \ "update buffer processing info " \ "(0 means do not periodically generate this info); " \ - "it also requires -XX:+G1SummarizeRSetStats") \ + "it also requires that logging is enabled on the trace" \ + "level for gc+remset") \ range(0, max_intx) \ \ - diagnostic(bool, G1TraceConcRefinement, false, \ - "Trace G1 concurrent refinement") \ - \ - experimental(bool, G1TraceStringSymbolTableScrubbing, false, \ - "Trace information string and symbol table scrubbing.") \ - \ product(double, G1ConcMarkStepDurationMillis, 10.0, \ "Target duration of individual concurrent marking steps " \ "in milliseconds.") \ @@ -119,10 +101,6 @@ develop(bool, G1RSBarrierRegionFilter, true, \ "If true, generate region filtering code in RS barrier") \ \ - diagnostic(bool, G1PrintRegionLivenessInfo, false, \ - "Prints the liveness information for all regions in the heap " \ - "at the end of a marking cycle.") \ - \ product(size_t, G1UpdateBufferSize, 256, \ "Size of an update buffer") \ range(1, NOT_LP64(32*M) LP64_ONLY(1*G)) \ @@ -202,12 +180,6 @@ develop(bool, G1ScrubRemSets, true, \ "When true, do RS scrubbing after cleanup.") \ \ - develop(bool, G1RSScrubVerbose, false, \ - "When true, do RS scrubbing with verbose output.") \ - \ - develop(bool, G1YoungSurvRateVerbose, false, \ - "print out the survival rate of young regions according to age.") \ - \ develop(intx, G1YoungSurvRateNumRegionsSummary, 0, \ "the number of regions for which we'll print a surv rate " \ "summary.") \ @@ -219,10 +191,6 @@ "to minimize the probability of promotion failure.") \ range(0, 50) \ \ - diagnostic(bool, G1PrintHeapRegions, false, \ - "If set G1 will print information on which regions are being " \ - "allocated and which are reclaimed.") \ - \ develop(bool, G1HRRSUseSparseTable, true, \ "When true, use sparse table to save space.") \ \ @@ -251,9 +219,6 @@ "The number of regions we will add to the secondary free list " \ "at every append operation") \ \ - develop(bool, G1ConcRegionFreeingVerbose, false, \ - "Enables verboseness during concurrent region freeing") \ - \ develop(bool, G1StressConcRegionFreeing, false, \ "It stresses the concurrent region freeing operation") \ \ @@ -306,18 +271,11 @@ "Try to reclaim dead large objects that have a few stale " \ "references at every young GC.") \ \ - experimental(bool, G1TraceEagerReclaimHumongousObjects, false, \ - "Print some information about large object liveness " \ - "at every young GC.") \ - \ experimental(uintx, G1OldCSetRegionThresholdPercent, 10, \ "An upper bound for the number of old CSet regions expressed " \ "as a percentage of the heap size.") \ range(0, 100) \ \ - experimental(ccstr, G1LogLevel, NULL, \ - "Log level for G1 logging: fine, finer, finest") \ - \ notproduct(bool, G1EvacuationFailureALot, false, \ "Force use of evacuation failure handling during certain " \ "evacuation pauses") \ --- old/src/share/vm/gc/g1/heapRegion.cpp 2015-12-01 12:06:12.218930681 +0100 +++ new/src/share/vm/gc/g1/heapRegion.cpp 2015-12-01 12:06:12.118930685 +0100 @@ -34,6 +34,7 @@ #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/liveRange.hpp" #include "gc/shared/space.inline.hpp" +#include "logging/log.hpp" #include "memory/iterator.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" @@ -479,10 +480,8 @@ // Object is in the region. Check that its less than top if (_hr->top() <= (HeapWord*)obj) { // Object is above top - gclog_or_tty->print_cr("Object " PTR_FORMAT " in region " - "[" PTR_FORMAT ", " PTR_FORMAT ") is above " - "top " PTR_FORMAT, - p2i(obj), p2i(_hr->bottom()), p2i(_hr->end()), p2i(_hr->top())); + log_info(gc, verify)("Object " PTR_FORMAT " in region [" PTR_FORMAT ", " PTR_FORMAT ") is above top " PTR_FORMAT, + p2i(obj), p2i(_hr->bottom()), p2i(_hr->end()), p2i(_hr->top())); _failures = true; return; } @@ -515,23 +514,19 @@ if (nm != NULL) { // Verify that the nemthod is live if (!nm->is_alive()) { - gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has dead nmethod " - PTR_FORMAT " in its strong code roots", - p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); + log_info(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has dead nmethod " PTR_FORMAT " in its strong code roots", + p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); _failures = true; } else { VerifyStrongCodeRootOopClosure oop_cl(_hr, nm); nm->oops_do(&oop_cl); if (!oop_cl.has_oops_in_region()) { - gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod " - PTR_FORMAT " in its strong code roots " - "with no pointers into region", - p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); + log_info(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod " PTR_FORMAT " in its strong code roots with no pointers into region", + p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); _failures = true; } else if (oop_cl.failures()) { - gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has other " - "failures for nmethod " PTR_FORMAT, - p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); + log_info(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has other failures for nmethod " PTR_FORMAT, + p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); _failures = true; } } @@ -564,9 +559,8 @@ // on its strong code root list if (is_empty()) { if (strong_code_roots_length > 0) { - gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] is empty " - "but has " SIZE_FORMAT " code root entries", - p2i(bottom()), p2i(end()), strong_code_roots_length); + log_info(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] is empty but has " SIZE_FORMAT " code root entries", + p2i(bottom()), p2i(end()), strong_code_roots_length); *failures = true; } return; @@ -574,9 +568,8 @@ if (is_continues_humongous()) { if (strong_code_roots_length > 0) { - gclog_or_tty->print_cr("region " HR_FORMAT " is a continuation of a humongous " - "region but has " SIZE_FORMAT " code root entries", - HR_FORMAT_PARAMS(this), strong_code_roots_length); + log_info(gc, verify)("region " HR_FORMAT " is a continuation of a humongous region but has " SIZE_FORMAT " code root entries", + HR_FORMAT_PARAMS(this), strong_code_roots_length); *failures = true; } return; @@ -590,7 +583,7 @@ } } -void HeapRegion::print() const { print_on(gclog_or_tty); } +void HeapRegion::print() const { print_on(tty); } void HeapRegion::print_on(outputStream* st) const { st->print("AC%4u", allocation_context()); @@ -648,6 +641,7 @@ assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo), "Precondition"); T heap_oop = oopDesc::load_heap_oop(p); + LogHandle(gc, verify) log; if (!oopDesc::is_null(heap_oop)) { oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); bool failed = false; @@ -656,35 +650,26 @@ Mutex::_no_safepoint_check_flag); if (!_failures) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("----------"); + log.info("----------"); } + ResourceMark rm; if (!_g1h->is_in_closed_subset(obj)) { HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); - gclog_or_tty->print_cr("Field " PTR_FORMAT - " of live obj " PTR_FORMAT " in region " - "[" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(p), p2i(_containing_obj), - p2i(from->bottom()), p2i(from->end())); - print_object(gclog_or_tty, _containing_obj); - gclog_or_tty->print_cr("points to obj " PTR_FORMAT " not in the heap", - p2i(obj)); + log.info("Field " PTR_FORMAT " of live obj " PTR_FORMAT " in region [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(p), p2i(_containing_obj), p2i(from->bottom()), p2i(from->end())); + print_object(log.info_stream(), _containing_obj); + log.info("points to obj " PTR_FORMAT " not in the heap", p2i(obj)); } else { HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj); - gclog_or_tty->print_cr("Field " PTR_FORMAT - " of live obj " PTR_FORMAT " in region " - "[" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(p), p2i(_containing_obj), - p2i(from->bottom()), p2i(from->end())); - print_object(gclog_or_tty, _containing_obj); - gclog_or_tty->print_cr("points to dead obj " PTR_FORMAT " in region " - "[" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(obj), p2i(to->bottom()), p2i(to->end())); - print_object(gclog_or_tty, obj); + log.info("Field " PTR_FORMAT " of live obj " PTR_FORMAT " in region [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(p), p2i(_containing_obj), p2i(from->bottom()), p2i(from->end())); + print_object(log.info_stream(), _containing_obj); + log.info("points to dead obj " PTR_FORMAT " in region [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(obj), p2i(to->bottom()), p2i(to->end())); + print_object(log.info_stream(), obj); } - gclog_or_tty->print_cr("----------"); - gclog_or_tty->flush(); + log.info("----------"); _failures = true; failed = true; _n_failures++; @@ -711,25 +696,17 @@ Mutex::_no_safepoint_check_flag); if (!_failures) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("----------"); + log.info("----------"); } - gclog_or_tty->print_cr("Missing rem set entry:"); - gclog_or_tty->print_cr("Field " PTR_FORMAT " " - "of obj " PTR_FORMAT ", " - "in region " HR_FORMAT, - p2i(p), p2i(_containing_obj), - HR_FORMAT_PARAMS(from)); - _containing_obj->print_on(gclog_or_tty); - gclog_or_tty->print_cr("points to obj " PTR_FORMAT " " - "in region " HR_FORMAT, - p2i(obj), - HR_FORMAT_PARAMS(to)); - obj->print_on(gclog_or_tty); - gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.", - cv_obj, cv_field); - gclog_or_tty->print_cr("----------"); - gclog_or_tty->flush(); + log.info("Missing rem set entry:"); + log.info("Field " PTR_FORMAT " of obj " PTR_FORMAT ", in region " HR_FORMAT, + p2i(p), p2i(_containing_obj), HR_FORMAT_PARAMS(from)); + ResourceMark rm; + _containing_obj->print_on(log.info_stream()); + log.info("points to obj " PTR_FORMAT " in region " HR_FORMAT, p2i(obj), HR_FORMAT_PARAMS(to)); + obj->print_on(log.info_stream()); + log.info("Obj head CTE = %d, field CTE = %d.", cv_obj, cv_field); + log.info("----------"); _failures = true; if (!failed) _n_failures++; } @@ -763,13 +740,13 @@ (vo == VerifyOption_G1UsePrevMarking && ClassLoaderDataGraph::unload_list_contains(klass)); if (!is_metaspace_object) { - gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " " - "not metadata", p2i(klass), p2i(obj)); + log_info(gc, verify)("klass " PTR_FORMAT " of object " PTR_FORMAT " " + "not metadata", p2i(klass), p2i(obj)); *failures = true; return; } else if (!klass->is_klass()) { - gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " " - "not a klass", p2i(klass), p2i(obj)); + log_info(gc, verify)("klass " PTR_FORMAT " of object " PTR_FORMAT " " + "not a klass", p2i(klass), p2i(obj)); *failures = true; return; } else { @@ -784,7 +761,7 @@ } } } else { - gclog_or_tty->print_cr(PTR_FORMAT " no an oop", p2i(obj)); + log_info(gc, verify)(PTR_FORMAT " no an oop", p2i(obj)); *failures = true; return; } @@ -800,13 +777,13 @@ if (is_region_humongous) { oop obj = oop(this->humongous_start_region()->bottom()); if ((HeapWord*)obj > bottom() || (HeapWord*)obj + obj->size() < bottom()) { - gclog_or_tty->print_cr("this humongous region is not part of its' humongous object " PTR_FORMAT, p2i(obj)); + log_info(gc, verify)("this humongous region is not part of its' humongous object " PTR_FORMAT, p2i(obj)); } } if (!is_region_humongous && p != top()) { - gclog_or_tty->print_cr("end of last object " PTR_FORMAT " " - "does not match top " PTR_FORMAT, p2i(p), p2i(top())); + log_info(gc, verify)("end of last object " PTR_FORMAT " " + "does not match top " PTR_FORMAT, p2i(p), p2i(top())); *failures = true; return; } @@ -820,9 +797,9 @@ HeapWord* addr_1 = p; HeapWord* b_start_1 = _offsets.block_start_const(addr_1); if (b_start_1 != p) { - gclog_or_tty->print_cr("BOT look up for top: " PTR_FORMAT " " - " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, - p2i(addr_1), p2i(b_start_1), p2i(p)); + log_info(gc, verify)("BOT look up for top: " PTR_FORMAT " " + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, + p2i(addr_1), p2i(b_start_1), p2i(p)); *failures = true; return; } @@ -832,9 +809,9 @@ if (addr_2 < the_end) { HeapWord* b_start_2 = _offsets.block_start_const(addr_2); if (b_start_2 != p) { - gclog_or_tty->print_cr("BOT look up for top + 1: " PTR_FORMAT " " - " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, - p2i(addr_2), p2i(b_start_2), p2i(p)); + log_info(gc, verify)("BOT look up for top + 1: " PTR_FORMAT " " + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, + p2i(addr_2), p2i(b_start_2), p2i(p)); *failures = true; return; } @@ -846,9 +823,9 @@ if (addr_3 < the_end) { HeapWord* b_start_3 = _offsets.block_start_const(addr_3); if (b_start_3 != p) { - gclog_or_tty->print_cr("BOT look up for top + diff: " PTR_FORMAT " " - " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, - p2i(addr_3), p2i(b_start_3), p2i(p)); + log_info(gc, verify)("BOT look up for top + diff: " PTR_FORMAT " " + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, + p2i(addr_3), p2i(b_start_3), p2i(p)); *failures = true; return; } @@ -858,9 +835,9 @@ HeapWord* addr_4 = the_end - 1; HeapWord* b_start_4 = _offsets.block_start_const(addr_4); if (b_start_4 != p) { - gclog_or_tty->print_cr("BOT look up for end - 1: " PTR_FORMAT " " - " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, - p2i(addr_4), p2i(b_start_4), p2i(p)); + log_info(gc, verify)("BOT look up for end - 1: " PTR_FORMAT " " + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, + p2i(addr_4), p2i(b_start_4), p2i(p)); *failures = true; return; } @@ -911,7 +888,7 @@ void G1OffsetTableContigSpace::print() const { print_short(); - gclog_or_tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " + tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", p2i(bottom()), p2i(top()), p2i(_offsets.threshold()), p2i(end())); } --- old/src/share/vm/gc/g1/heapRegionRemSet.cpp 2015-12-01 12:06:12.426930674 +0100 +++ new/src/share/vm/gc/g1/heapRegionRemSet.cpp 2015-12-01 12:06:12.310930678 +0100 @@ -560,20 +560,13 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm) { // First eliminated garbage regions from the coarse map. - if (G1RSScrubVerbose) { - gclog_or_tty->print_cr("Scrubbing region %u:", _hr->hrm_index()); - } + log_develop_trace(gc, remset, scrub)("Scrubbing region %u:", _hr->hrm_index()); assert(_coarse_map.size() == region_bm->size(), "Precondition"); - if (G1RSScrubVerbose) { - gclog_or_tty->print(" Coarse map: before = " SIZE_FORMAT "...", - _n_coarse_entries); - } + log_develop_trace(gc, remset, scrub)(" Coarse map: before = " SIZE_FORMAT "...", _n_coarse_entries); _coarse_map.set_intersection(*region_bm); _n_coarse_entries = _coarse_map.count_one_bits(); - if (G1RSScrubVerbose) { - gclog_or_tty->print_cr(" after = " SIZE_FORMAT ".", _n_coarse_entries); - } + log_develop_trace(gc, remset, scrub)(" after = " SIZE_FORMAT ".", _n_coarse_entries); // Now do the fine-grained maps. for (size_t i = 0; i < _max_fine_entries; i++) { @@ -582,28 +575,19 @@ while (cur != NULL) { PerRegionTable* nxt = cur->collision_list_next(); // If the entire region is dead, eliminate. - if (G1RSScrubVerbose) { - gclog_or_tty->print_cr(" For other region %u:", - cur->hr()->hrm_index()); - } + log_develop_trace(gc, remset, scrub)(" For other region %u:", cur->hr()->hrm_index()); if (!region_bm->at((size_t) cur->hr()->hrm_index())) { *prev = nxt; cur->set_collision_list_next(NULL); _n_fine_entries--; - if (G1RSScrubVerbose) { - gclog_or_tty->print_cr(" deleted via region map."); - } + log_develop_trace(gc, remset, scrub)(" deleted via region map."); unlink_from_all(cur); PerRegionTable::free(cur); } else { // Do fine-grain elimination. - if (G1RSScrubVerbose) { - gclog_or_tty->print(" occ: before = %4d.", cur->occupied()); - } + log_develop_trace(gc, remset, scrub)(" occ: before = %4d.", cur->occupied()); cur->scrub(ctbs, card_bm); - if (G1RSScrubVerbose) { - gclog_or_tty->print_cr(" after = %4d.", cur->occupied()); - } + log_develop_trace(gc, remset, scrub)(" after = %4d.", cur->occupied()); // Did that empty the table completely? if (cur->occupied() == 0) { *prev = nxt; @@ -799,15 +783,15 @@ while (iter.has_next(card_index)) { HeapWord* card_start = G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index); - gclog_or_tty->print_cr(" Card " PTR_FORMAT, p2i(card_start)); + tty->print_cr(" Card " PTR_FORMAT, p2i(card_start)); } if (iter.n_yielded() != occupied()) { - gclog_or_tty->print_cr("Yielded disagrees with occupied:"); - gclog_or_tty->print_cr(" " SIZE_FORMAT_W(6) " yielded (" SIZE_FORMAT_W(6) + tty->print_cr("Yielded disagrees with occupied:"); + tty->print_cr(" " SIZE_FORMAT_W(6) " yielded (" SIZE_FORMAT_W(6) " coarse, " SIZE_FORMAT_W(6) " fine).", iter.n_yielded(), iter.n_yielded_coarse(), iter.n_yielded_fine()); - gclog_or_tty->print_cr(" " SIZE_FORMAT_W(6) " occ (" SIZE_FORMAT_W(6) + tty->print_cr(" " SIZE_FORMAT_W(6) " occ (" SIZE_FORMAT_W(6) " coarse, " SIZE_FORMAT_W(6) " fine).", occupied(), occ_coarse(), occ_fine()); } @@ -1089,7 +1073,7 @@ while (iter.has_next(card_index)) { HeapWord* card_start = G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index); - gclog_or_tty->print_cr(" Card " PTR_FORMAT ".", p2i(card_start)); + tty->print_cr(" Card " PTR_FORMAT ".", p2i(card_start)); sum++; } guarantee(sum == 11 - 3 + 2048, "Failure"); --- old/src/share/vm/gc/g1/heapRegionRemSet.hpp 2015-12-01 12:06:12.618930667 +0100 +++ new/src/share/vm/gc/g1/heapRegionRemSet.hpp 2015-12-01 12:06:12.502930671 +0100 @@ -86,7 +86,7 @@ static void invalidate(uint start_idx, size_t num_regions); - static void print(outputStream* out = gclog_or_tty) PRODUCT_RETURN; + static void print(outputStream* out = tty) PRODUCT_RETURN; static size_t static_mem_size() { return _static_mem_size; --- old/src/share/vm/gc/g1/heapRegionSet.cpp 2015-12-01 12:06:12.786930662 +0100 +++ new/src/share/vm/gc/g1/heapRegionSet.cpp 2015-12-01 12:06:12.686930665 +0100 @@ -261,24 +261,6 @@ _last = NULL; } -void FreeRegionList::print_on(outputStream* out, bool print_contents) { - HeapRegionSetBase::print_on(out, print_contents); - out->print_cr(" Linking"); - out->print_cr(" head : " PTR_FORMAT, p2i(_head)); - out->print_cr(" tail : " PTR_FORMAT, p2i(_tail)); - - if (print_contents) { - out->print_cr(" Contents"); - FreeRegionListIterator iter(this); - while (iter.more_available()) { - HeapRegion* hr = iter.get_next(); - hr->print_on(out); - } - } - - out->cr(); -} - void FreeRegionList::verify_list() { HeapRegion* curr = _head; HeapRegion* prev1 = NULL; --- old/src/share/vm/gc/g1/heapRegionSet.hpp 2015-12-01 12:06:12.974930655 +0100 +++ new/src/share/vm/gc/g1/heapRegionSet.hpp 2015-12-01 12:06:12.858930659 +0100 @@ -250,8 +250,6 @@ void remove_starting_at(HeapRegion* first, uint num_regions); virtual void verify(); - - virtual void print_on(outputStream* out, bool print_contents = false); }; // Iterator class that provides a convenient way to iterate over the --- old/src/share/vm/gc/g1/satbMarkQueue.cpp 2015-12-01 12:06:13.154930649 +0100 +++ new/src/share/vm/gc/g1/satbMarkQueue.cpp 2015-12-01 12:06:13.042930653 +0100 @@ -199,9 +199,8 @@ void SATBMarkQueue::print(const char* name, void** buf, size_t index, size_t sz) { - gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: " PTR_FORMAT " " - "index: " SIZE_FORMAT " sz: " SIZE_FORMAT, - name, p2i(buf), index, sz); + tty->print_cr(" SATB BUFFER [%s] buf: " PTR_FORMAT " index: " SIZE_FORMAT " sz: " SIZE_FORMAT, + name, p2i(buf), index, sz); } #endif // PRODUCT @@ -222,16 +221,13 @@ #ifdef ASSERT void SATBMarkQueueSet::dump_active_states(bool expected_active) { - gclog_or_tty->print_cr("Expected SATB active state: %s", - expected_active ? "ACTIVE" : "INACTIVE"); - gclog_or_tty->print_cr("Actual SATB active states:"); - gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE"); + log_info(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE"); + log_info(gc, verify)("Actual SATB active states:"); + log_info(gc, verify)(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE"); for (JavaThread* t = Threads::first(); t; t = t->next()) { - gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(), - t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE"); + log_info(gc, verify)(" Thread \"%s\" queue: %s", t->name(), t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE"); } - gclog_or_tty->print_cr(" Shared queue: %s", - shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE"); + log_info(gc, verify)(" Shared queue: %s", shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE"); } void SATBMarkQueueSet::verify_active_states(bool expected_active) { @@ -318,8 +314,8 @@ char buffer[SATB_PRINTER_BUFFER_SIZE]; assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); - gclog_or_tty->cr(); - gclog_or_tty->print_cr("SATB BUFFERS [%s]", msg); + tty->cr(); + tty->print_cr("SATB BUFFERS [%s]", msg); BufferNode* nd = _completed_buffers_head; int i = 0; @@ -338,7 +334,7 @@ shared_satb_queue()->print("Shared"); - gclog_or_tty->cr(); + tty->cr(); } #endif // PRODUCT --- old/src/share/vm/gc/g1/survRateGroup.cpp 2015-12-01 12:06:13.334930643 +0100 +++ new/src/share/vm/gc/g1/survRateGroup.cpp 2015-12-01 12:06:13.222930646 +0100 @@ -27,6 +27,7 @@ #include "gc/g1/g1Predictions.hpp" #include "gc/g1/heapRegion.hpp" #include "gc/g1/survRateGroup.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" SurvRateGroup::SurvRateGroup(G1Predictions* predictor, @@ -163,12 +164,11 @@ #ifndef PRODUCT void SurvRateGroup::print() { - gclog_or_tty->print_cr("Surv Rate Group: %s (" SIZE_FORMAT " entries)", - _name, _region_num); + log_develop_trace(gc, survivor)("Surv Rate Group: %s (" SIZE_FORMAT " entries)", _name, _region_num); for (size_t i = 0; i < _region_num; ++i) { - gclog_or_tty->print_cr(" age " SIZE_FORMAT_W(4) " surv rate %6.2lf %% pred %6.2lf %%", - i, _surv_rate[i] * 100.0, - _predictor->get_new_prediction(_surv_rate_pred[i]) * 100.0); + log_develop_trace(gc, survivor)(" age " SIZE_FORMAT_W(4) " surv rate %6.2lf %% pred %6.2lf %%", + i, _surv_rate[i] * 100.0, + _predictor->get_new_prediction(_surv_rate_pred[i]) * 100.0); } } @@ -178,22 +178,20 @@ if (length == 0) return; - gclog_or_tty->cr(); - gclog_or_tty->print_cr("%s Rate Summary (for up to age " SIZE_FORMAT ")", _name, length-1); - gclog_or_tty->print_cr(" age range survival rate (avg) samples (avg)"); - gclog_or_tty->print_cr(" ---------------------------------------------------------"); + log_trace(gc, survivor)("%s Rate Summary (for up to age " SIZE_FORMAT ")", _name, length-1); + log_trace(gc, survivor)(" age range survival rate (avg) samples (avg)"); + log_trace(gc, survivor)(" ---------------------------------------------------------"); size_t index = 0; size_t limit = MIN2((int) length, 10); while (index < limit) { - gclog_or_tty->print_cr(" " SIZE_FORMAT_W(4) - " %6.2lf%% %6.2lf", - index, _summary_surv_rates[index]->avg() * 100.0, - (double) _summary_surv_rates[index]->num()); + log_trace(gc, survivor)(" " SIZE_FORMAT_W(4) " %6.2lf%% %6.2lf", + index, _summary_surv_rates[index]->avg() * 100.0, + (double) _summary_surv_rates[index]->num()); ++index; } - gclog_or_tty->print_cr(" ---------------------------------------------------------"); + log_trace(gc, survivor)(" ---------------------------------------------------------"); int num = 0; double sum = 0.0; @@ -205,16 +203,15 @@ ++index; if (index == length || num % 10 == 0) { - gclog_or_tty->print_cr(" " SIZE_FORMAT_W(4) " .. " SIZE_FORMAT_W(4) - " %6.2lf%% %6.2lf", - (index-1) / 10 * 10, index-1, sum / (double) num, - (double) samples / (double) num); + log_trace(gc, survivor)(" " SIZE_FORMAT_W(4) " .. " SIZE_FORMAT_W(4) " %6.2lf%% %6.2lf", + (index-1) / 10 * 10, index-1, sum / (double) num, + (double) samples / (double) num); sum = 0.0; num = 0; samples = 0; } } - gclog_or_tty->print_cr(" ---------------------------------------------------------"); + log_trace(gc, survivor)(" ---------------------------------------------------------"); } #endif // PRODUCT --- old/src/share/vm/gc/g1/vm_operations_g1.cpp 2015-12-01 12:06:13.526930636 +0100 +++ new/src/share/vm/gc/g1/vm_operations_g1.cpp 2015-12-01 12:06:13.406930640 +0100 @@ -27,10 +27,9 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/shared/gcId.hpp" -#include "gc/g1/g1Log.hpp" #include "gc/g1/vm_operations_g1.hpp" #include "gc/shared/gcTimer.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "runtime/interfaceSupport.hpp" @@ -226,10 +225,10 @@ } void VM_CGC_Operation::doit() { - TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); - G1CollectedHeap* g1h = G1CollectedHeap::heap(); GCIdMark gc_id_mark(_gc_id); - GCTraceTime t(_printGCMessage, G1Log::fine(), true, g1h->gc_timer_cm()); + GCTraceCPUTime tcpu; + G1CollectedHeap* g1h = G1CollectedHeap::heap(); + GCTraceTime(Info, gc) t(_printGCMessage, g1h->gc_timer_cm(), GCCause::_no_gc, true); IsGCActiveMark x; _cl->do_void(); } --- old/src/share/vm/gc/g1/workerDataArray.cpp 2015-12-01 12:06:13.718930629 +0100 +++ new/src/share/vm/gc/g1/workerDataArray.cpp 2015-12-01 12:06:13.598930633 +0100 @@ -30,13 +30,11 @@ const uint length = 3; const char* title = "Test array"; const bool print_sum = false; - const int log_level = 3; const uint indent_level = 2; - WorkerDataArray array(length, title, print_sum, log_level, indent_level); + WorkerDataArray array(length, title, print_sum, indent_level); assert(strncmp(array.title(), title, strlen(title)) == 0 , "Expected titles to match"); assert(array.should_print_sum() == print_sum, "Expected should_print_sum to match print_sum"); - assert(array.log_level() == log_level, "Expected log levels to match"); assert(array.indentation() == indent_level, "Expected indentation to match"); const size_t expected[length] = {5, 3, 7}; --- old/src/share/vm/gc/g1/workerDataArray.hpp 2015-12-01 12:06:13.898930623 +0100 +++ new/src/share/vm/gc/g1/workerDataArray.hpp 2015-12-01 12:06:13.786930627 +0100 @@ -32,7 +32,6 @@ uint _length; const char* _title; bool _print_sum; - int _log_level; uint _indent_level; bool _enabled; @@ -46,7 +45,6 @@ WorkerDataArray(uint length, const char* title, bool print_sum, - int log_level, uint indent_level); ~WorkerDataArray(); @@ -80,10 +78,6 @@ return _print_sum; } - int log_level() const { - return _log_level; - } - void clear(); void set_enabled(bool enabled) { _enabled = enabled; --- old/src/share/vm/gc/g1/workerDataArray.inline.hpp 2015-12-01 12:06:14.070930617 +0100 +++ new/src/share/vm/gc/g1/workerDataArray.inline.hpp 2015-12-01 12:06:13.966930620 +0100 @@ -29,12 +29,10 @@ WorkerDataArray::WorkerDataArray(uint length, const char* title, bool print_sum, - int log_level, uint indent_level) : _title(title), _length(0), _print_sum(print_sum), - _log_level(log_level), _indent_level(indent_level), _thread_work_items(NULL), _enabled(true) { --- old/src/share/vm/gc/g1/youngList.cpp 2015-12-01 12:06:14.250930611 +0100 +++ new/src/share/vm/gc/g1/youngList.cpp 2015-12-01 12:06:14.138930614 +0100 @@ -29,6 +29,7 @@ #include "gc/g1/heapRegion.inline.hpp" #include "gc/g1/heapRegionRemSet.hpp" #include "gc/g1/youngList.hpp" +#include "logging/log.hpp" #include "utilities/ostream.hpp" YoungList::YoungList(G1CollectedHeap* g1h) : @@ -98,10 +99,10 @@ HeapRegion* last = NULL; while (curr != NULL) { if (!curr->is_young()) { - gclog_or_tty->print_cr("### YOUNG REGION " PTR_FORMAT "-" PTR_FORMAT " " - "incorrectly tagged (y: %d, surv: %d)", - p2i(curr->bottom()), p2i(curr->end()), - curr->is_young(), curr->is_survivor()); + log_info(gc, verify)("### YOUNG REGION " PTR_FORMAT "-" PTR_FORMAT " " + "incorrectly tagged (y: %d, surv: %d)", + p2i(curr->bottom()), p2i(curr->end()), + curr->is_young(), curr->is_survivor()); ret = false; } ++length; @@ -111,9 +112,8 @@ ret = ret && (length == _length); if (!ret) { - gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!"); - gclog_or_tty->print_cr("### list has %u entries, _length is %u", - length, _length); + log_info(gc, verify)("### YOUNG LIST seems not well formed!"); + log_info(gc, verify)("### list has %u entries, _length is %u", length, _length); } return ret; @@ -123,20 +123,19 @@ bool ret = true; if (_length != 0) { - gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %u", - _length); + log_info(gc, verify)("### YOUNG LIST should have 0 length, not %u", _length); ret = false; } if (check_sample && _last_sampled_rs_lengths != 0) { - gclog_or_tty->print_cr("### YOUNG LIST has non-zero last sampled RS lengths"); + log_info(gc, verify)("### YOUNG LIST has non-zero last sampled RS lengths"); ret = false; } if (_head != NULL) { - gclog_or_tty->print_cr("### YOUNG LIST does not have a NULL head"); + log_info(gc, verify)("### YOUNG LIST does not have a NULL head"); ret = false; } if (!ret) { - gclog_or_tty->print_cr("### YOUNG LIST does not seem empty"); + log_info(gc, verify)("### YOUNG LIST does not seem empty"); } return ret; @@ -171,7 +170,6 @@ _curr = _curr->get_next_young_region(); if (_curr == NULL) { _last_sampled_rs_lengths = _sampled_rs_lengths; - // gclog_or_tty->print_cr("last sampled RS lengths = %d", _last_sampled_rs_lengths); } } @@ -222,13 +220,13 @@ const char* names[] = {"YOUNG", "SURVIVOR"}; for (uint list = 0; list < ARRAY_SIZE(lists); ++list) { - gclog_or_tty->print_cr("%s LIST CONTENTS", names[list]); + tty->print_cr("%s LIST CONTENTS", names[list]); HeapRegion *curr = lists[list]; if (curr == NULL) { - gclog_or_tty->print_cr(" empty"); + tty->print_cr(" empty"); } while (curr != NULL) { - gclog_or_tty->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT ", N: " PTR_FORMAT ", age: %4d", + tty->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT ", N: " PTR_FORMAT ", age: %4d", HR_FORMAT_PARAMS(curr), p2i(curr->prev_top_at_mark_start()), p2i(curr->next_top_at_mark_start()), @@ -237,5 +235,5 @@ } } - gclog_or_tty->cr(); + tty->cr(); } --- old/src/share/vm/gc/parallel/adjoiningGenerations.cpp 2015-12-01 12:06:14.426930604 +0100 +++ new/src/share/vm/gc/parallel/adjoiningGenerations.cpp 2015-12-01 12:06:14.322930608 +0100 @@ -27,6 +27,9 @@ #include "gc/parallel/adjoiningVirtualSpaces.hpp" #include "gc/parallel/generationSizer.hpp" #include "gc/parallel/parallelScavengeHeap.hpp" +#include "logging/log.hpp" +#include "memory/resourceArea.hpp" +#include "utilities/ostream.hpp" // If boundary moving is being used, create the young gen and old // gen with ASPSYoungGen and ASPSOldGen, respectively. Revert to @@ -116,6 +119,29 @@ return virtual_spaces()->reserved_space().size(); } +void log_before_expansion(bool old, size_t expand_in_bytes, size_t change_in_bytes, size_t max_size) { + LogHandle(heap, ergo) log; + if (!log.is_debug()) { + return; + } + log.debug("Before expansion of %s gen with boundary move", old ? "old" : "young"); + log.debug(" Requested change: " SIZE_FORMAT_HEX " Attempted change: " SIZE_FORMAT_HEX, + expand_in_bytes, change_in_bytes); + ResourceMark rm; + ParallelScavengeHeap::heap()->print_on(log.debug_stream()); + log.debug(" PS%sGen max size: " SIZE_FORMAT "K", old ? "Old" : "Young", max_size/K); +} + +void log_after_expansion(bool old, size_t max_size) { + LogHandle(heap, ergo) log; + if (!log.is_debug()) { + return; + } + log.debug("After expansion of %s gen with boundary move", old ? "old" : "young"); + ResourceMark rm; + ParallelScavengeHeap::heap()->print_on(log.debug_stream()); + log.debug(" PS%sGen max size: " SIZE_FORMAT "K", old ? "Old" : "Young", max_size/K); +} // Make checks on the current sizes of the generations and // the constraints on the sizes of the generations. Push @@ -141,17 +167,7 @@ return; } - if (TraceAdaptiveGCBoundary) { - gclog_or_tty->print_cr("Before expansion of old gen with boundary move"); - gclog_or_tty->print_cr(" Requested change: " SIZE_FORMAT_HEX - " Attempted change: " SIZE_FORMAT_HEX, - expand_in_bytes, change_in_bytes); - if (!PrintHeapAtGC) { - Universe::print_on(gclog_or_tty); - } - gclog_or_tty->print_cr(" PSOldGen max size: " SIZE_FORMAT "K", - old_gen()->max_gen_size()/K); - } + log_before_expansion(true, expand_in_bytes, change_in_bytes, old_gen()->max_gen_size()); // Move the boundary between the generations up (smaller young gen). if (virtual_spaces()->adjust_boundary_up(change_in_bytes)) { @@ -167,14 +183,7 @@ young_gen()->space_invariants(); old_gen()->space_invariants(); - if (TraceAdaptiveGCBoundary) { - gclog_or_tty->print_cr("After expansion of old gen with boundary move"); - if (!PrintHeapAtGC) { - Universe::print_on(gclog_or_tty); - } - gclog_or_tty->print_cr(" PSOldGen max size: " SIZE_FORMAT "K", - old_gen()->max_gen_size()/K); - } + log_after_expansion(true, old_gen()->max_gen_size()); } // See comments on request_old_gen_expansion() @@ -200,16 +209,7 @@ return false; } - if (TraceAdaptiveGCBoundary) { - gclog_or_tty->print_cr("Before expansion of young gen with boundary move"); - gclog_or_tty->print_cr(" Requested change: " SIZE_FORMAT_HEX " Attempted change: " SIZE_FORMAT_HEX, - expand_in_bytes, change_in_bytes); - if (!PrintHeapAtGC) { - Universe::print_on(gclog_or_tty); - } - gclog_or_tty->print_cr(" PSYoungGen max size: " SIZE_FORMAT "K", - young_gen()->max_size()/K); - } + log_before_expansion(false, expand_in_bytes, change_in_bytes, young_gen()->max_size()); // Move the boundary between the generations down (smaller old gen). MutexLocker x(ExpandHeap_lock); @@ -227,14 +227,7 @@ young_gen()->space_invariants(); old_gen()->space_invariants(); - if (TraceAdaptiveGCBoundary) { - gclog_or_tty->print_cr("After expansion of young gen with boundary move"); - if (!PrintHeapAtGC) { - Universe::print_on(gclog_or_tty); - } - gclog_or_tty->print_cr(" PSYoungGen max size: " SIZE_FORMAT "K", - young_gen()->max_size()/K); - } + log_after_expansion(false, young_gen()->max_size()); return result; } --- old/src/share/vm/gc/parallel/asPSOldGen.cpp 2015-12-01 12:06:14.622930598 +0100 +++ new/src/share/vm/gc/parallel/asPSOldGen.cpp 2015-12-01 12:06:14.506930602 +0100 @@ -125,25 +125,21 @@ size_t result = policy->promo_increment_aligned_down(max_contraction); // Also adjust for inter-generational alignment size_t result_aligned = align_size_down(result, gen_alignment); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("\nASPSOldGen::available_for_contraction:" - " " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, result_aligned/K, result_aligned); - gclog_or_tty->print_cr(" reserved().byte_size() " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - reserved().byte_size()/K, reserved().byte_size()); + + LogHandle(gc, ergo) log; + if (log.is_trace()) { size_t working_promoted = (size_t) policy->avg_promoted()->padded_average(); - gclog_or_tty->print_cr(" padded promoted " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - working_promoted/K, working_promoted); - gclog_or_tty->print_cr(" used " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - used_in_bytes()/K, used_in_bytes()); - gclog_or_tty->print_cr(" min_gen_size() " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - min_gen_size()/K, min_gen_size()); - gclog_or_tty->print_cr(" max_contraction " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - max_contraction/K, max_contraction); - gclog_or_tty->print_cr(" without alignment " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, - policy->promo_increment(max_contraction)/K, - policy->promo_increment(max_contraction)); - gclog_or_tty->print_cr(" alignment " SIZE_FORMAT_HEX, gen_alignment); + size_t promo_increment = policy->promo_increment(max_contraction); + log.trace("ASPSOldGen::available_for_contraction: " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, result_aligned/K, result_aligned); + log.trace(" reserved().byte_size() " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, reserved().byte_size()/K, reserved().byte_size()); + log.trace(" padded promoted " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, working_promoted/K, working_promoted); + log.trace(" used " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, used_in_bytes()/K, used_in_bytes()); + log.trace(" min_gen_size() " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, min_gen_size()/K, min_gen_size()); + log.trace(" max_contraction " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, max_contraction/K, max_contraction); + log.trace(" without alignment " SIZE_FORMAT " K / " SIZE_FORMAT_HEX, promo_increment/K, promo_increment); + log.trace(" alignment " SIZE_FORMAT_HEX, gen_alignment); } + assert(result_aligned <= max_contraction, "arithmetic is wrong"); return result_aligned; } --- old/src/share/vm/gc/parallel/asPSYoungGen.cpp 2015-12-01 12:06:14.814930591 +0100 +++ new/src/share/vm/gc/parallel/asPSYoungGen.cpp 2015-12-01 12:06:14.694930595 +0100 @@ -111,13 +111,12 @@ PSAdaptiveSizePolicy* policy = heap->size_policy(); size_t result = policy->eden_increment_aligned_down(max_contraction); size_t result_aligned = align_size_down(result, gen_alignment); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", - result_aligned/K); - gclog_or_tty->print_cr(" max_contraction " SIZE_FORMAT " K", max_contraction/K); - gclog_or_tty->print_cr(" eden_avail " SIZE_FORMAT " K", eden_avail/K); - gclog_or_tty->print_cr(" gen_avail " SIZE_FORMAT " K", gen_avail/K); - } + + log_trace(gc, ergo)("ASPSYoungGen::available_for_contraction: " SIZE_FORMAT " K", result_aligned/K); + log_trace(gc, ergo)(" max_contraction " SIZE_FORMAT " K", max_contraction/K); + log_trace(gc, ergo)(" eden_avail " SIZE_FORMAT " K", eden_avail/K); + log_trace(gc, ergo)(" gen_avail " SIZE_FORMAT " K", gen_avail/K); + return result_aligned; } @@ -199,25 +198,17 @@ virtual_space()->shrink_by(change); size_changed = true; } else { - if (Verbose && PrintGC) { - if (orig_size == gen_size_limit()) { - gclog_or_tty->print_cr("ASPSYoung generation size at maximum: " - SIZE_FORMAT "K", orig_size/K); - } else if (orig_size == min_gen_size()) { - gclog_or_tty->print_cr("ASPSYoung generation size at minium: " - SIZE_FORMAT "K", orig_size/K); - } + if (orig_size == gen_size_limit()) { + log_trace(gc)("ASPSYoung generation size at maximum: " SIZE_FORMAT "K", orig_size/K); + } else if (orig_size == min_gen_size()) { + log_trace(gc)("ASPSYoung generation size at minium: " SIZE_FORMAT "K", orig_size/K); } } if (size_changed) { reset_after_change(); - if (Verbose && PrintGC) { - size_t current_size = virtual_space()->committed_size(); - gclog_or_tty->print_cr("ASPSYoung generation size changed: " - SIZE_FORMAT "K->" SIZE_FORMAT "K", - orig_size/K, current_size/K); - } + log_trace(gc)("ASPSYoung generation size changed: " SIZE_FORMAT "K->" SIZE_FORMAT "K", + orig_size/K, virtual_space()->committed_size()/K); } guarantee(eden_plus_survivors <= virtual_space()->committed_size() || @@ -245,41 +236,31 @@ return; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("PSYoungGen::resize_spaces(requested_eden_size: " - SIZE_FORMAT - ", requested_survivor_size: " SIZE_FORMAT ")", - requested_eden_size, requested_survivor_size); - gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(eden_space()->bottom()), - p2i(eden_space()->end()), - pointer_delta(eden_space()->end(), - eden_space()->bottom(), - sizeof(char))); - gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(from_space()->bottom()), - p2i(from_space()->end()), - pointer_delta(from_space()->end(), - from_space()->bottom(), - sizeof(char))); - gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(to_space()->bottom()), - p2i(to_space()->end()), - pointer_delta( to_space()->end(), - to_space()->bottom(), - sizeof(char))); - } + log_trace(gc, ergo)("PSYoungGen::resize_spaces(requested_eden_size: " + SIZE_FORMAT + ", requested_survivor_size: " SIZE_FORMAT ")", + requested_eden_size, requested_survivor_size); + log_trace(gc, ergo)(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") " + SIZE_FORMAT, + p2i(eden_space()->bottom()), + p2i(eden_space()->end()), + pointer_delta(eden_space()->end(), eden_space()->bottom(), sizeof(char))); + log_trace(gc, ergo)(" from: [" PTR_FORMAT ".." PTR_FORMAT ") " + SIZE_FORMAT, + p2i(from_space()->bottom()), + p2i(from_space()->end()), + pointer_delta(from_space()->end(), from_space()->bottom(), sizeof(char))); + log_trace(gc, ergo)(" to: [" PTR_FORMAT ".." PTR_FORMAT ") " + SIZE_FORMAT, + p2i(to_space()->bottom()), + p2i(to_space()->end()), + pointer_delta( to_space()->end(), to_space()->bottom(), sizeof(char))); // There's nothing to do if the new sizes are the same as the current if (requested_survivor_size == to_space()->capacity_in_bytes() && requested_survivor_size == from_space()->capacity_in_bytes() && requested_eden_size == eden_space()->capacity_in_bytes()) { - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" capacities are the right sizes, returning"); - } + log_trace(gc, ergo)(" capacities are the right sizes, returning"); return; } @@ -302,9 +283,7 @@ if (eden_from_to_order) { // Eden, from, to - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" Eden, from, to:"); - } + log_trace(gc, ergo)(" Eden, from, to:"); // Set eden // "requested_eden_size" is a goal for the size of eden @@ -368,28 +347,24 @@ guarantee(to_start != to_end, "to space is zero sized"); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" [eden_start .. eden_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(eden_start), - p2i(eden_end), - pointer_delta(eden_end, eden_start, sizeof(char))); - gclog_or_tty->print_cr(" [from_start .. from_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(from_start), - p2i(from_end), - pointer_delta(from_end, from_start, sizeof(char))); - gclog_or_tty->print_cr(" [ to_start .. to_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(to_start), - p2i(to_end), - pointer_delta( to_end, to_start, sizeof(char))); - } + log_trace(gc, ergo)(" [eden_start .. eden_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(eden_start), + p2i(eden_end), + pointer_delta(eden_end, eden_start, sizeof(char))); + log_trace(gc, ergo)(" [from_start .. from_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(from_start), + p2i(from_end), + pointer_delta(from_end, from_start, sizeof(char))); + log_trace(gc, ergo)(" [ to_start .. to_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(to_start), + p2i(to_end), + pointer_delta( to_end, to_start, sizeof(char))); } else { // Eden, to, from - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" Eden, to, from:"); - } + log_trace(gc, ergo)(" Eden, to, from:"); // To space gets priority over eden resizing. Note that we position // to space as if we were able to resize from space, even though from @@ -422,23 +397,21 @@ eden_end = MAX2(eden_end, eden_start + alignment); to_start = MAX2(to_start, eden_end); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" [eden_start .. eden_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(eden_start), - p2i(eden_end), - pointer_delta(eden_end, eden_start, sizeof(char))); - gclog_or_tty->print_cr(" [ to_start .. to_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(to_start), - p2i(to_end), - pointer_delta( to_end, to_start, sizeof(char))); - gclog_or_tty->print_cr(" [from_start .. from_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(from_start), - p2i(from_end), - pointer_delta(from_end, from_start, sizeof(char))); - } + log_trace(gc, ergo)(" [eden_start .. eden_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(eden_start), + p2i(eden_end), + pointer_delta(eden_end, eden_start, sizeof(char))); + log_trace(gc, ergo)(" [ to_start .. to_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(to_start), + p2i(to_end), + pointer_delta( to_end, to_start, sizeof(char))); + log_trace(gc, ergo)(" [from_start .. from_end): " + "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(from_start), + p2i(from_end), + pointer_delta(from_end, from_start, sizeof(char))); } @@ -457,7 +430,7 @@ // Let's make sure the call to initialize doesn't reset "top"! DEBUG_ONLY(HeapWord* old_from_top = from_space()->top();) - // For PrintAdaptiveSizePolicy block below + // For logging block below size_t old_from = from_space()->capacity_in_bytes(); size_t old_to = to_space()->capacity_in_bytes(); @@ -506,19 +479,16 @@ assert(from_space()->top() == old_from_top, "from top changed!"); - if (PrintAdaptiveSizePolicy) { - ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); - gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: " - "collection: %d " - "(" SIZE_FORMAT ", " SIZE_FORMAT ") -> " - "(" SIZE_FORMAT ", " SIZE_FORMAT ") ", - heap->total_collections(), - old_from, old_to, - from_space()->capacity_in_bytes(), - to_space()->capacity_in_bytes()); - gclog_or_tty->cr(); - } - space_invariants(); + log_trace(gc, ergo)("AdaptiveSizePolicy::survivor space sizes: " + "collection: %d " + "(" SIZE_FORMAT ", " SIZE_FORMAT ") -> " + "(" SIZE_FORMAT ", " SIZE_FORMAT ") ", + ParallelScavengeHeap::heap()->total_collections(), + old_from, old_to, + from_space()->capacity_in_bytes(), + to_space()->capacity_in_bytes()); + + space_invariants(); } void ASPSYoungGen::reset_after_change() { assert_locked_or_safepoint(Heap_lock); --- old/src/share/vm/gc/parallel/cardTableExtension.cpp 2015-12-01 12:06:15.022930584 +0100 +++ new/src/share/vm/gc/parallel/cardTableExtension.cpp 2015-12-01 12:06:14.906930588 +0100 @@ -468,30 +468,17 @@ // Update the covered region resize_update_covered_table(changed_region, new_region); - if (TraceCardTableModRefBS) { - int ind = changed_region; - gclog_or_tty->print_cr("CardTableModRefBS::resize_covered_region: "); - gclog_or_tty->print_cr(" " - " _covered[%d].start(): " INTPTR_FORMAT - " _covered[%d].last(): " INTPTR_FORMAT, - ind, p2i(_covered[ind].start()), - ind, p2i(_covered[ind].last())); - gclog_or_tty->print_cr(" " - " _committed[%d].start(): " INTPTR_FORMAT - " _committed[%d].last(): " INTPTR_FORMAT, - ind, p2i(_committed[ind].start()), - ind, p2i(_committed[ind].last())); - gclog_or_tty->print_cr(" " - " byte_for(start): " INTPTR_FORMAT - " byte_for(last): " INTPTR_FORMAT, - p2i(byte_for(_covered[ind].start())), - p2i(byte_for(_covered[ind].last()))); - gclog_or_tty->print_cr(" " - " addr_for(start): " INTPTR_FORMAT - " addr_for(last): " INTPTR_FORMAT, - p2i(addr_for((jbyte*) _committed[ind].start())), - p2i(addr_for((jbyte*) _committed[ind].last()))); - } + int ind = changed_region; + log_trace(gc, barrier)("CardTableModRefBS::resize_covered_region: "); + log_trace(gc, barrier)(" _covered[%d].start(): " INTPTR_FORMAT " _covered[%d].last(): " INTPTR_FORMAT, + ind, p2i(_covered[ind].start()), ind, p2i(_covered[ind].last())); + log_trace(gc, barrier)(" _committed[%d].start(): " INTPTR_FORMAT " _committed[%d].last(): " INTPTR_FORMAT, + ind, p2i(_committed[ind].start()), ind, p2i(_committed[ind].last())); + log_trace(gc, barrier)(" byte_for(start): " INTPTR_FORMAT " byte_for(last): " INTPTR_FORMAT, + p2i(byte_for(_covered[ind].start())), p2i(byte_for(_covered[ind].last()))); + log_trace(gc, barrier)(" addr_for(start): " INTPTR_FORMAT " addr_for(last): " INTPTR_FORMAT, + p2i(addr_for((jbyte*) _committed[ind].start())), p2i(addr_for((jbyte*) _committed[ind].last()))); + debug_only(verify_guard();) } --- old/src/share/vm/gc/parallel/gcTaskManager.cpp 2015-12-01 12:06:15.230930576 +0100 +++ new/src/share/vm/gc/parallel/gcTaskManager.cpp 2015-12-01 12:06:15.106930581 +0100 @@ -27,6 +27,7 @@ #include "gc/parallel/gcTaskThread.hpp" #include "gc/shared/adaptiveSizePolicy.hpp" #include "gc/shared/gcId.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/allocation.inline.hpp" #include "runtime/mutex.hpp" @@ -465,13 +466,11 @@ "all_workers_active() is incorrect: " "active %d ParallelGCThreads %u", active_workers(), ParallelGCThreads); - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("GCTaskManager::set_active_gang(): " - "all_workers_active() %d workers %d " - "active %d ParallelGCThreads %u", - all_workers_active(), workers(), active_workers(), - ParallelGCThreads); - } + log_trace(gc, task)("GCTaskManager::set_active_gang(): " + "all_workers_active() %d workers %d " + "active %d ParallelGCThreads %u", + all_workers_active(), workers(), active_workers(), + ParallelGCThreads); } // Create IdleGCTasks for inactive workers. @@ -502,15 +501,12 @@ set_active_workers(reduced_active_workers); more_inactive_workers = 0; } - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("JT: %d workers %d active %d " - "idle %d more %d", - Threads::number_of_non_daemon_threads(), - workers(), - active_workers(), - idle_workers(), - more_inactive_workers); - } + log_trace(gc, task)("JT: %d workers %d active %d idle %d more %d", + Threads::number_of_non_daemon_threads(), + workers(), + active_workers(), + idle_workers(), + more_inactive_workers); } GCTaskQueue* q = GCTaskQueue::create(); for(uint i = 0; i < (uint) more_inactive_workers; i++) { @@ -536,6 +532,9 @@ } void GCTaskManager::print_task_time_stamps() { + if (!log_is_enabled(Debug, gc, task, time)) { + return; + } for(uint i=0; iprint_task_time_stamps(); @@ -828,38 +827,24 @@ void IdleGCTask::do_it(GCTaskManager* manager, uint which) { WaitHelper* wait_helper = manager->wait_helper(); - if (TraceGCTaskManager) { - tty->print_cr("[" INTPTR_FORMAT "]" - " IdleGCTask:::do_it()" - " should_wait: %s", + log_trace(gc, task)("[" INTPTR_FORMAT "] IdleGCTask:::do_it() should_wait: %s", p2i(this), wait_helper->should_wait() ? "true" : "false"); - } + MutexLockerEx ml(manager->monitor(), Mutex::_no_safepoint_check_flag); - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("--- idle %d", which); - } + log_trace(gc, task)("--- idle %d", which); // Increment has to be done when the idle tasks are created. // manager->increment_idle_workers(); manager->monitor()->notify_all(); while (wait_helper->should_wait()) { - if (TraceGCTaskManager) { - tty->print_cr("[" INTPTR_FORMAT "]" - " IdleGCTask::do_it()" - " [" INTPTR_FORMAT "] (%s)->wait()", - p2i(this), p2i(manager->monitor()), manager->monitor()->name()); - } + log_trace(gc, task)("[" INTPTR_FORMAT "] IdleGCTask::do_it() [" INTPTR_FORMAT "] (%s)->wait()", + p2i(this), p2i(manager->monitor()), manager->monitor()->name()); manager->monitor()->wait(Mutex::_no_safepoint_check_flag, 0); } manager->decrement_idle_workers(); - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("--- release %d", which); - } - if (TraceGCTaskManager) { - tty->print_cr("[" INTPTR_FORMAT "]" - " IdleGCTask::do_it() returns" - " should_wait: %s", - p2i(this), wait_helper->should_wait() ? "true" : "false"); - } + + log_trace(gc, task)("--- release %d", which); + log_trace(gc, task)("[" INTPTR_FORMAT "] IdleGCTask::do_it() returns should_wait: %s", + p2i(this), wait_helper->should_wait() ? "true" : "false"); // Release monitor(). } --- old/src/share/vm/gc/parallel/gcTaskThread.cpp 2015-12-01 12:06:15.446930569 +0100 +++ new/src/share/vm/gc/parallel/gcTaskThread.cpp 2015-12-01 12:06:15.318930573 +0100 @@ -27,9 +27,11 @@ #include "gc/parallel/gcTaskManager.hpp" #include "gc/parallel/gcTaskThread.hpp" #include "gc/shared/gcId.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/allocation.inline.hpp" #include "memory/resourceArea.hpp" +#include "runtime/atomic.inline.hpp" #include "runtime/handles.hpp" #include "runtime/handles.inline.hpp" #include "runtime/os.hpp" @@ -46,11 +48,6 @@ if (!os::create_thread(this, os::pgc_thread)) vm_exit_out_of_memory(0, OOM_MALLOC_ERROR, "Cannot create GC thread. Out of system resources."); - if (PrintGCTaskTimeStamps) { - _time_stamps = NEW_C_HEAP_ARRAY(GCTaskTimeStamp, GCTaskTimeStampEntries, mtGC); - - guarantee(_time_stamps != NULL, "Sanity"); - } set_id(which); set_name("ParGC Thread#%d", which); } @@ -67,21 +64,30 @@ GCTaskTimeStamp* GCTaskThread::time_stamp_at(uint index) { guarantee(index < GCTaskTimeStampEntries, "increase GCTaskTimeStampEntries"); + if (_time_stamps == NULL) { + // We allocate the _time_stamps array lazily since logging can be enabled dynamically + GCTaskTimeStamp* time_stamps = NEW_C_HEAP_ARRAY(GCTaskTimeStamp, GCTaskTimeStampEntries, mtGC); + void* old = Atomic::cmpxchg_ptr(time_stamps, &_time_stamps, NULL); + if (old != NULL) { + // Someone already setup the time stamps + FREE_C_HEAP_ARRAY(GCTaskTimeStamp, time_stamps); + } + } return &(_time_stamps[index]); } void GCTaskThread::print_task_time_stamps() { - assert(PrintGCTaskTimeStamps, "Sanity"); - assert(_time_stamps != NULL, "Sanity (Probably set PrintGCTaskTimeStamps late)"); + assert(log_is_enabled(Debug, gc, task, time), "Sanity"); + assert(_time_stamps != NULL, "Sanity"); - tty->print_cr("GC-Thread %u entries: %d", id(), _time_stamp_index); + log_debug(gc, task, time)("GC-Thread %u entries: %d", id(), _time_stamp_index); for(uint i=0; i<_time_stamp_index; i++) { GCTaskTimeStamp* time_stamp = time_stamp_at(i); - tty->print_cr("\t[ %s " JLONG_FORMAT " " JLONG_FORMAT " ]", - time_stamp->name(), - time_stamp->entry_time(), - time_stamp->exit_time()); + log_debug(gc, task, time)("\t[ %s " JLONG_FORMAT " " JLONG_FORMAT " ]", + time_stamp->name(), + time_stamp->entry_time(), + time_stamp->exit_time()); } // Reset after dumping the data @@ -129,7 +135,7 @@ // Record if this is an idle task for later use. bool is_idle_task = task->is_idle_task(); // In case the update is costly - if (PrintGCTaskTimeStamps) { + if (log_is_enabled(Debug, gc, task, time)) { timer.update(); } @@ -145,10 +151,7 @@ if (!is_idle_task) { manager()->note_completion(which()); - if (PrintGCTaskTimeStamps) { - assert(_time_stamps != NULL, - "Sanity (PrintGCTaskTimeStamps set late?)"); - + if (log_is_enabled(Debug, gc, task, time)) { timer.update(); GCTaskTimeStamp* time_stamp = time_stamp_at(_time_stamp_index++); --- old/src/share/vm/gc/parallel/parallelScavengeHeap.cpp 2015-12-01 12:06:15.638930562 +0100 +++ new/src/share/vm/gc/parallel/parallelScavengeHeap.cpp 2015-12-01 12:06:15.522930566 +0100 @@ -38,6 +38,7 @@ #include "gc/shared/gcHeapSummary.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcWhen.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/handles.inline.hpp" #include "runtime/java.hpp" @@ -307,10 +308,7 @@ if (limit_exceeded && softrefs_clear) { *gc_overhead_limit_was_exceeded = true; size_policy()->set_gc_overhead_limit_exceeded(false); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("ParallelScavengeHeap::mem_allocate: " - "return NULL because gc_overhead_limit_exceeded is set"); - } + log_trace(gc)("ParallelScavengeHeap::mem_allocate: return NULL because gc_overhead_limit_exceeded is set"); if (op.result() != NULL) { CollectedHeap::fill_with_object(op.result(), size); } @@ -584,35 +582,17 @@ } -void ParallelScavengeHeap::verify(bool silent, VerifyOption option /* ignored */) { +void ParallelScavengeHeap::verify(VerifyOption option /* ignored */) { // Why do we need the total_collections()-filter below? if (total_collections() > 0) { - if (!silent) { - gclog_or_tty->print("tenured "); - } + log_debug(gc, verify)("Tenured"); old_gen()->verify(); - if (!silent) { - gclog_or_tty->print("eden "); - } + log_debug(gc, verify)("Eden"); young_gen()->verify(); } } -void ParallelScavengeHeap::print_heap_change(size_t prev_used) { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" " SIZE_FORMAT - "->" SIZE_FORMAT - "(" SIZE_FORMAT ")", - prev_used, used(), capacity()); - } else { - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_used / K, used() / K, capacity() / K); - } -} - void ParallelScavengeHeap::trace_heap(GCWhen::Type when, const GCTracer* gc_tracer) { const PSHeapSummary& heap_summary = create_ps_heap_summary(); gc_tracer->report_gc_heap_summary(when, heap_summary); --- old/src/share/vm/gc/parallel/parallelScavengeHeap.hpp 2015-12-01 12:06:15.834930555 +0100 +++ new/src/share/vm/gc/parallel/parallelScavengeHeap.hpp 2015-12-01 12:06:15.718930559 +0100 @@ -35,6 +35,7 @@ #include "gc/shared/gcPolicyCounters.hpp" #include "gc/shared/gcWhen.hpp" #include "gc/shared/strongRootsScope.hpp" +#include "memory/metaspace.hpp" #include "utilities/ostream.hpp" class AdjoiningGenerations; @@ -87,6 +88,10 @@ return CollectedHeap::ParallelScavengeHeap; } + virtual const char* name() const { + return "Parallel"; + } + virtual CollectorPolicy* collector_policy() const { return _collector_policy; } static PSYoungGen* young_gen() { return _young_gen; } @@ -215,9 +220,7 @@ virtual void gc_threads_do(ThreadClosure* tc) const; virtual void print_tracing_info() const; - void verify(bool silent, VerifyOption option /* ignored */); - - void print_heap_change(size_t prev_used); + void verify(VerifyOption option /* ignored */); // Resize the young generation. The reserved space for the // generation may be expanded in preparation for the resize. @@ -241,4 +244,26 @@ }; }; +// Simple class for storing info about the heap at the start of GC, to be used +// after GC for comparison/printing. +class PreGCValues { +public: + PreGCValues(ParallelScavengeHeap* heap) : + _heap_used(heap->used()), + _young_gen_used(heap->young_gen()->used_in_bytes()), + _old_gen_used(heap->old_gen()->used_in_bytes()), + _metadata_used(MetaspaceAux::used_bytes()) { }; + + size_t heap_used() const { return _heap_used; } + size_t young_gen_used() const { return _young_gen_used; } + size_t old_gen_used() const { return _old_gen_used; } + size_t metadata_used() const { return _metadata_used; } + +private: + size_t _heap_used; + size_t _young_gen_used; + size_t _old_gen_used; + size_t _metadata_used; +}; + #endif // SHARE_VM_GC_PARALLEL_PARALLELSCAVENGEHEAP_HPP --- old/src/share/vm/gc/parallel/pcTasks.cpp 2015-12-01 12:06:16.010930549 +0100 +++ new/src/share/vm/gc/parallel/pcTasks.cpp 2015-12-01 12:06:15.906930553 +0100 @@ -31,7 +31,8 @@ #include "gc/parallel/psParallelCompact.hpp" #include "gc/shared/collectedHeap.hpp" #include "gc/shared/gcTimer.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" +#include "logging/log.hpp" #include "memory/universe.hpp" #include "oops/objArrayKlass.inline.hpp" #include "oops/oop.inline.hpp" @@ -251,14 +252,6 @@ cm->set_region_stack_index(which_stack_index); cm->set_region_stack(ParCompactionManager::region_list(which_stack_index)); - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("StealRegionCompactionTask::do_it " - "region_stack_index %d region_stack = " PTR_FORMAT " " - " empty (%d) use all workers %d", - which_stack_index, p2i(ParCompactionManager::region_list(which_stack_index)), - cm->region_stack()->is_empty(), - use_all_workers); - } // Has to drain stacks first because there may be regions on // preloaded onto the stack and this thread may never have @@ -323,14 +316,6 @@ } cm->set_region_stack(ParCompactionManager::region_list(which_stack_index)); - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("DrainStacksCompactionTask::do_it which = %d " - "which_stack_index = %d/empty(%d) " - "use all workers %d", - which, which_stack_index, - cm->region_stack()->is_empty(), - use_all_workers); - } cm->set_region_stack_index(which_stack_index); @@ -346,13 +331,6 @@ "region_stack and region_stack_index are inconsistent"); ParCompactionManager::push_recycled_stack_index(cm->region_stack_index()); - if (TraceDynamicGCThreads) { - void* old_region_stack = (void*) cm->region_stack(); - int old_region_stack_index = cm->region_stack_index(); - gclog_or_tty->print_cr("Pushing region stack " PTR_FORMAT "/%d", - p2i(old_region_stack), old_region_stack_index); - } - cm->set_region_stack(NULL); cm->set_region_stack_index((uint)max_uintx); } --- old/src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp 2015-12-01 12:06:16.194930543 +0100 +++ new/src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp 2015-12-01 12:06:16.090930546 +0100 @@ -30,6 +30,7 @@ #include "gc/shared/collectorPolicy.hpp" #include "gc/shared/gcCause.hpp" #include "gc/shared/gcPolicyCounters.hpp" +#include "logging/log.hpp" #include "runtime/timer.hpp" #include "utilities/top.hpp" @@ -159,14 +160,10 @@ _major_pause_young_estimator->update(eden_size_in_mbytes, major_pause_in_ms); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print("psAdaptiveSizePolicy::major_collection_end: " - "major gc cost: %f average: %f", collection_cost, - avg_major_gc_cost()->average()); - gclog_or_tty->print_cr(" major pause: %f major period %f", - major_pause_in_ms, - _latest_major_mutator_interval_seconds * MILLIUNITS); - } + log_trace(gc, ergo)("psAdaptiveSizePolicy::major_collection_end: major gc cost: %f average: %f", + collection_cost,avg_major_gc_cost()->average()); + log_trace(gc, ergo)(" major pause: %f major period %f", + major_pause_in_ms, _latest_major_mutator_interval_seconds * MILLIUNITS); // Calculate variable used to estimate collection cost vs. gen sizes assert(collection_cost >= 0.0, "Expected to be non-negative"); @@ -197,19 +194,11 @@ // A similar test is done in the scavenge's should_attempt_scavenge(). If // this is changed, decide if that test should also be changed. bool result = padded_average_promoted_in_bytes() > (float) old_free_in_bytes; - if (PrintGCDetails && Verbose) { - if (result) { - gclog_or_tty->print(" full after scavenge: "); - } else { - gclog_or_tty->print(" no full after scavenge: "); - } - gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT - " padded_average_promoted " SIZE_FORMAT - " free in old gen " SIZE_FORMAT, - (size_t) average_promoted_in_bytes(), - (size_t) padded_average_promoted_in_bytes(), - old_free_in_bytes); - } + log_trace(gc, ergo)("%s after scavenge average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen " SIZE_FORMAT, + result ? "Full" : "No full", + (size_t) average_promoted_in_bytes(), + (size_t) padded_average_promoted_in_bytes(), + old_free_in_bytes); return result; } @@ -361,26 +350,24 @@ // Note we make the same tests as in the code block below; the code // seems a little easier to read with the printing in another block. - if (PrintAdaptiveSizePolicy) { - if (desired_eden_size > eden_limit) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::compute_eden_space_size limits:" - " desired_eden_size: " SIZE_FORMAT - " old_eden_size: " SIZE_FORMAT - " eden_limit: " SIZE_FORMAT - " cur_eden: " SIZE_FORMAT - " max_eden_size: " SIZE_FORMAT - " avg_young_live: " SIZE_FORMAT, - desired_eden_size, _eden_size, eden_limit, cur_eden, - max_eden_size, (size_t)avg_young_live()->average()); - } - if (gc_cost() > gc_cost_limit) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::compute_eden_space_size: gc time limit" - " gc_cost: %f " - " GCTimeLimit: " UINTX_FORMAT, - gc_cost(), GCTimeLimit); - } + if (desired_eden_size > eden_limit) { + log_debug(gc, ergo)( + "PSAdaptiveSizePolicy::compute_eden_space_size limits:" + " desired_eden_size: " SIZE_FORMAT + " old_eden_size: " SIZE_FORMAT + " eden_limit: " SIZE_FORMAT + " cur_eden: " SIZE_FORMAT + " max_eden_size: " SIZE_FORMAT + " avg_young_live: " SIZE_FORMAT, + desired_eden_size, _eden_size, eden_limit, cur_eden, + max_eden_size, (size_t)avg_young_live()->average()); + } + if (gc_cost() > gc_cost_limit) { + log_debug(gc, ergo)( + "PSAdaptiveSizePolicy::compute_eden_space_size: gc time limit" + " gc_cost: %f " + " GCTimeLimit: " UINTX_FORMAT, + gc_cost(), GCTimeLimit); } // Align everything and make a final limit check @@ -399,51 +386,26 @@ desired_eden_size = MAX2(eden_limit, cur_eden); } - if (PrintAdaptiveSizePolicy) { - // Timing stats - gclog_or_tty->print( - "PSAdaptiveSizePolicy::compute_eden_space_size: costs" - " minor_time: %f" - " major_cost: %f" - " mutator_cost: %f" - " throughput_goal: %f", - minor_gc_cost(), major_gc_cost(), mutator_cost(), - _throughput_goal); - - // We give more details if Verbose is set - if (Verbose) { - gclog_or_tty->print( " minor_pause: %f" - " major_pause: %f" - " minor_interval: %f" - " major_interval: %f" - " pause_goal: %f", - _avg_minor_pause->padded_average(), - _avg_major_pause->padded_average(), - _avg_minor_interval->average(), - _avg_major_interval->average(), - gc_pause_goal_sec()); - } + log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_eden_space_size: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f", + minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal); - // Footprint stats - gclog_or_tty->print( " live_space: " SIZE_FORMAT - " free_space: " SIZE_FORMAT, - live_space(), free_space()); - // More detail - if (Verbose) { - gclog_or_tty->print( " base_footprint: " SIZE_FORMAT - " avg_young_live: " SIZE_FORMAT - " avg_old_live: " SIZE_FORMAT, - (size_t)_avg_base_footprint->average(), - (size_t)avg_young_live()->average(), - (size_t)avg_old_live()->average()); - } + log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %fpause_goal: %f", + _avg_minor_pause->padded_average(), + _avg_major_pause->padded_average(), + _avg_minor_interval->average(), + _avg_major_interval->average(), + gc_pause_goal_sec()); + + log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT, + live_space(), free_space()); + + log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT, + (size_t)_avg_base_footprint->average(), + (size_t)avg_young_live()->average(), + (size_t)avg_old_live()->average()); - // And finally, our old and new sizes. - gclog_or_tty->print(" old_eden_size: " SIZE_FORMAT - " desired_eden_size: " SIZE_FORMAT, - _eden_size, desired_eden_size); - gclog_or_tty->cr(); - } + log_debug(gc, ergo)("Old eden_size: " SIZE_FORMAT " desired_eden_size: " SIZE_FORMAT, + _eden_size, desired_eden_size); set_eden_size(desired_eden_size); } @@ -564,27 +526,25 @@ // Note we make the same tests as in the code block below; the code // seems a little easier to read with the printing in another block. - if (PrintAdaptiveSizePolicy) { - if (desired_promo_size > promo_limit) { - // "free_in_old_gen" was the original value for used for promo_limit - size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average()); - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::compute_old_gen_free_space limits:" - " desired_promo_size: " SIZE_FORMAT - " promo_limit: " SIZE_FORMAT - " free_in_old_gen: " SIZE_FORMAT - " max_old_gen_size: " SIZE_FORMAT - " avg_old_live: " SIZE_FORMAT, - desired_promo_size, promo_limit, free_in_old_gen, - max_old_gen_size, (size_t) avg_old_live()->average()); - } - if (gc_cost() > gc_cost_limit) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::compute_old_gen_free_space: gc time limit" - " gc_cost: %f " - " GCTimeLimit: " UINTX_FORMAT, - gc_cost(), GCTimeLimit); - } + if (desired_promo_size > promo_limit) { + // "free_in_old_gen" was the original value for used for promo_limit + size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average()); + log_debug(gc, ergo)( + "PSAdaptiveSizePolicy::compute_old_gen_free_space limits:" + " desired_promo_size: " SIZE_FORMAT + " promo_limit: " SIZE_FORMAT + " free_in_old_gen: " SIZE_FORMAT + " max_old_gen_size: " SIZE_FORMAT + " avg_old_live: " SIZE_FORMAT, + desired_promo_size, promo_limit, free_in_old_gen, + max_old_gen_size, (size_t) avg_old_live()->average()); + } + if (gc_cost() > gc_cost_limit) { + log_debug(gc, ergo)( + "PSAdaptiveSizePolicy::compute_old_gen_free_space: gc time limit" + " gc_cost: %f " + " GCTimeLimit: " UINTX_FORMAT, + gc_cost(), GCTimeLimit); } // Align everything and make a final limit check @@ -596,51 +556,28 @@ // And one last limit check, now that we've aligned things. desired_promo_size = MIN2(desired_promo_size, promo_limit); - if (PrintAdaptiveSizePolicy) { - // Timing stats - gclog_or_tty->print( - "PSAdaptiveSizePolicy::compute_old_gen_free_space: costs" - " minor_time: %f" - " major_cost: %f" - " mutator_cost: %f" - " throughput_goal: %f", - minor_gc_cost(), major_gc_cost(), mutator_cost(), - _throughput_goal); - - // We give more details if Verbose is set - if (Verbose) { - gclog_or_tty->print( " minor_pause: %f" - " major_pause: %f" - " minor_interval: %f" - " major_interval: %f" - " pause_goal: %f", - _avg_minor_pause->padded_average(), - _avg_major_pause->padded_average(), - _avg_minor_interval->average(), - _avg_major_interval->average(), - gc_pause_goal_sec()); - } + // Timing stats + log_debug(gc, ergo)("PSAdaptiveSizePolicy::compute_old_gen_free_space: costs minor_time: %f major_cost: %f mutator_cost: %f throughput_goal: %f", + minor_gc_cost(), major_gc_cost(), mutator_cost(), _throughput_goal); + + log_trace(gc, ergo)("Minor_pause: %f major_pause: %f minor_interval: %f major_interval: %f pause_goal: %f", + _avg_minor_pause->padded_average(), + _avg_major_pause->padded_average(), + _avg_minor_interval->average(), + _avg_major_interval->average(), + gc_pause_goal_sec()); + + // Footprint stats + log_debug(gc, ergo)("Live_space: " SIZE_FORMAT " free_space: " SIZE_FORMAT, + live_space(), free_space()); + + log_trace(gc, ergo)("Base_footprint: " SIZE_FORMAT " avg_young_live: " SIZE_FORMAT " avg_old_live: " SIZE_FORMAT, + (size_t)_avg_base_footprint->average(), + (size_t)avg_young_live()->average(), + (size_t)avg_old_live()->average()); - // Footprint stats - gclog_or_tty->print( " live_space: " SIZE_FORMAT - " free_space: " SIZE_FORMAT, - live_space(), free_space()); - // More detail - if (Verbose) { - gclog_or_tty->print( " base_footprint: " SIZE_FORMAT - " avg_young_live: " SIZE_FORMAT - " avg_old_live: " SIZE_FORMAT, - (size_t)_avg_base_footprint->average(), - (size_t)avg_young_live()->average(), - (size_t)avg_old_live()->average()); - } - - // And finally, our old and new sizes. - gclog_or_tty->print(" old_promo_size: " SIZE_FORMAT - " desired_promo_size: " SIZE_FORMAT, - _promo_size, desired_promo_size); - gclog_or_tty->cr(); - } + log_debug(gc, ergo)("Old promo_size: " SIZE_FORMAT " desired_promo_size: " SIZE_FORMAT, + _promo_size, desired_promo_size); set_promo_size(desired_promo_size); } @@ -719,14 +656,12 @@ } } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::adjust_promo_for_pause_time " - "adjusting gen sizes for major pause (avg %f goal %f). " - "desired_promo_size " SIZE_FORMAT " promo delta " SIZE_FORMAT, - _avg_major_pause->average(), gc_pause_goal_sec(), - *desired_promo_size_ptr, promo_heap_delta); - } + log_trace(gc, ergo)( + "PSAdaptiveSizePolicy::adjust_promo_for_pause_time " + "adjusting gen sizes for major pause (avg %f goal %f). " + "desired_promo_size " SIZE_FORMAT " promo delta " SIZE_FORMAT, + _avg_major_pause->average(), gc_pause_goal_sec(), + *desired_promo_size_ptr, promo_heap_delta); } void PSAdaptiveSizePolicy::adjust_eden_for_pause_time(bool is_full_gc, @@ -740,14 +675,12 @@ if (_avg_minor_pause->padded_average() > _avg_major_pause->padded_average()) { adjust_eden_for_minor_pause_time(is_full_gc, desired_eden_size_ptr); } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::adjust_eden_for_pause_time " - "adjusting gen sizes for major pause (avg %f goal %f). " - "desired_eden_size " SIZE_FORMAT " eden delta " SIZE_FORMAT, - _avg_major_pause->average(), gc_pause_goal_sec(), - *desired_eden_size_ptr, eden_heap_delta); - } + log_trace(gc, ergo)( + "PSAdaptiveSizePolicy::adjust_eden_for_pause_time " + "adjusting gen sizes for major pause (avg %f goal %f). " + "desired_eden_size " SIZE_FORMAT " eden delta " SIZE_FORMAT, + _avg_major_pause->average(), gc_pause_goal_sec(), + *desired_eden_size_ptr, eden_heap_delta); } void PSAdaptiveSizePolicy::adjust_promo_for_throughput(bool is_full_gc, @@ -761,13 +694,8 @@ return; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_promo_for_throughput(" - "is_full: %d, promo: " SIZE_FORMAT "): ", - is_full_gc, *desired_promo_size_ptr); - gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f " - "minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost()); - } + log_trace(gc, ergo)("PSAdaptiveSizePolicy::adjust_promo_for_throughput(is_full: %d, promo: " SIZE_FORMAT "): mutator_cost %f major_gc_cost %f minor_gc_cost %f", + is_full_gc, *desired_promo_size_ptr, mutator_cost(), major_gc_cost(), minor_gc_cost()); // Tenured generation if (is_full_gc) { @@ -780,12 +708,8 @@ double scale_by_ratio = major_gc_cost() / gc_cost(); scaled_promo_heap_delta = (size_t) (scale_by_ratio * (double) promo_heap_delta); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "Scaled tenured increment: " SIZE_FORMAT " by %f down to " - SIZE_FORMAT, - promo_heap_delta, scale_by_ratio, scaled_promo_heap_delta); - } + log_trace(gc, ergo)("Scaled tenured increment: " SIZE_FORMAT " by %f down to " SIZE_FORMAT, + promo_heap_delta, scale_by_ratio, scaled_promo_heap_delta); } else if (major_gc_cost() >= 0.0) { // Scaling is not going to work. If the major gc time is the // larger, give it a full increment. @@ -839,13 +763,10 @@ _old_gen_change_for_major_throughput++; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "adjusting tenured gen for throughput (avg %f goal %f). " - "desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT , - mutator_cost(), _throughput_goal, - *desired_promo_size_ptr, scaled_promo_heap_delta); - } + log_trace(gc, ergo)("Adjusting tenured gen for throughput (avg %f goal %f). desired_promo_size " SIZE_FORMAT " promo_delta " SIZE_FORMAT , + mutator_cost(), + _throughput_goal, + *desired_promo_size_ptr, scaled_promo_heap_delta); } } @@ -860,13 +781,8 @@ return; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print("\nPSAdaptiveSizePolicy::adjust_eden_for_throughput(" - "is_full: %d, cur_eden: " SIZE_FORMAT "): ", - is_full_gc, *desired_eden_size_ptr); - gclog_or_tty->print_cr("mutator_cost %f major_gc_cost %f " - "minor_gc_cost %f", mutator_cost(), major_gc_cost(), minor_gc_cost()); - } + log_trace(gc, ergo)("PSAdaptiveSizePolicy::adjust_eden_for_throughput(is_full: %d, cur_eden: " SIZE_FORMAT "): mutator_cost %f major_gc_cost %f minor_gc_cost %f", + is_full_gc, *desired_eden_size_ptr, mutator_cost(), major_gc_cost(), minor_gc_cost()); // Young generation size_t scaled_eden_heap_delta = 0; @@ -878,12 +794,8 @@ assert(scale_by_ratio <= 1.0 && scale_by_ratio >= 0.0, "Scaling is wrong"); scaled_eden_heap_delta = (size_t) (scale_by_ratio * (double) eden_heap_delta); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "Scaled eden increment: " SIZE_FORMAT " by %f down to " - SIZE_FORMAT, - eden_heap_delta, scale_by_ratio, scaled_eden_heap_delta); - } + log_trace(gc, ergo)("Scaled eden increment: " SIZE_FORMAT " by %f down to " SIZE_FORMAT, + eden_heap_delta, scale_by_ratio, scaled_eden_heap_delta); } else if (minor_gc_cost() >= 0.0) { // Scaling is not going to work. If the minor gc time is the // larger, give it a full increment. @@ -936,13 +848,8 @@ _young_gen_change_for_minor_throughput++; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "adjusting eden for throughput (avg %f goal %f). desired_eden_size " - SIZE_FORMAT " eden delta " SIZE_FORMAT "\n", - mutator_cost(), _throughput_goal, - *desired_eden_size_ptr, scaled_eden_heap_delta); - } + log_trace(gc, ergo)("Adjusting eden for throughput (avg %f goal %f). desired_eden_size " SIZE_FORMAT " eden delta " SIZE_FORMAT, + mutator_cost(), _throughput_goal, *desired_eden_size_ptr, scaled_eden_heap_delta); } size_t PSAdaptiveSizePolicy::adjust_promo_for_footprint( @@ -955,15 +862,13 @@ size_t reduced_size = desired_promo_size - change; - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "AdaptiveSizePolicy::adjust_promo_for_footprint " - "adjusting tenured gen for footprint. " - "starting promo size " SIZE_FORMAT - " reduced promo size " SIZE_FORMAT - " promo delta " SIZE_FORMAT, - desired_promo_size, reduced_size, change ); - } + log_trace(gc, ergo)( + "AdaptiveSizePolicy::adjust_promo_for_footprint " + "adjusting tenured gen for footprint. " + "starting promo size " SIZE_FORMAT + " reduced promo size " SIZE_FORMAT + " promo delta " SIZE_FORMAT, + desired_promo_size, reduced_size, change ); assert(reduced_size <= desired_promo_size, "Inconsistent result"); return reduced_size; @@ -979,15 +884,13 @@ size_t reduced_size = desired_eden_size - change; - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr( - "AdaptiveSizePolicy::adjust_eden_for_footprint " - "adjusting eden for footprint. " - " starting eden size " SIZE_FORMAT - " reduced eden size " SIZE_FORMAT - " eden delta " SIZE_FORMAT, - desired_eden_size, reduced_size, change); - } + log_trace(gc, ergo)( + "AdaptiveSizePolicy::adjust_eden_for_footprint " + "adjusting eden for footprint. " + " starting eden size " SIZE_FORMAT + " reduced eden size " SIZE_FORMAT + " eden delta " SIZE_FORMAT, + desired_eden_size, reduced_size, change); assert(reduced_size <= desired_eden_size, "Inconsistent result"); return reduced_size; @@ -1187,33 +1090,14 @@ // the amount of old gen free space is less than what we expect to // promote). - if (PrintAdaptiveSizePolicy) { - // A little more detail if Verbose is on - if (Verbose) { - gclog_or_tty->print( " avg_survived: %f" - " avg_deviation: %f", - _avg_survived->average(), - _avg_survived->deviation()); - } + log_trace(gc, ergo)("avg_survived: %f avg_deviation: %f", _avg_survived->average(), _avg_survived->deviation()); + log_debug(gc, ergo)("avg_survived_padded_avg: %f", _avg_survived->padded_average()); - gclog_or_tty->print( " avg_survived_padded_avg: %f", - _avg_survived->padded_average()); - - if (Verbose) { - gclog_or_tty->print( " avg_promoted_avg: %f" - " avg_promoted_dev: %f", - avg_promoted()->average(), - avg_promoted()->deviation()); - } - - gclog_or_tty->print_cr( " avg_promoted_padded_avg: %f" - " avg_pretenured_padded_avg: %f" - " tenuring_thresh: %d" - " target_size: " SIZE_FORMAT, - avg_promoted()->padded_average(), - _avg_pretenured->padded_average(), - tenuring_threshold, target_size); - } + log_trace(gc, ergo)("avg_promoted_avg: %f avg_promoted_dev: %f", avg_promoted()->average(), avg_promoted()->deviation()); + log_debug(gc, ergo)("avg_promoted_padded_avg: %f avg_pretenured_padded_avg: %f tenuring_thresh: %d target_size: " SIZE_FORMAT, + avg_promoted()->padded_average(), + _avg_pretenured->padded_average(), + tenuring_threshold, target_size); set_survivor_size(target_size); @@ -1233,24 +1117,22 @@ } avg_promoted()->sample(promoted); - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print_cr( - "AdaptiveSizePolicy::update_averages:" - " survived: " SIZE_FORMAT - " promoted: " SIZE_FORMAT - " overflow: %s", - survived, promoted, is_survivor_overflow ? "true" : "false"); - } + log_trace(gc, ergo)("AdaptiveSizePolicy::update_averages: survived: " SIZE_FORMAT " promoted: " SIZE_FORMAT " overflow: %s", + survived, promoted, is_survivor_overflow ? "true" : "false"); } -bool PSAdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st) - const { +bool PSAdaptiveSizePolicy::print() const { + + if (!UseAdaptiveSizePolicy) { + return false; + } - if (!UseAdaptiveSizePolicy) return false; + if (AdaptiveSizePolicy::print()) { + AdaptiveSizePolicy::print_tenuring_threshold(PSScavenge::tenuring_threshold()); + return true; + } - return AdaptiveSizePolicy::print_adaptive_size_policy_on( - st, - PSScavenge::tenuring_threshold()); + return false; } #ifndef PRODUCT --- old/src/share/vm/gc/parallel/psAdaptiveSizePolicy.hpp 2015-12-01 12:06:16.394930536 +0100 +++ new/src/share/vm/gc/parallel/psAdaptiveSizePolicy.hpp 2015-12-01 12:06:16.294930539 +0100 @@ -395,7 +395,7 @@ size_t promoted); // Printing support - virtual bool print_adaptive_size_policy_on(outputStream* st) const; + virtual bool print() const; // Decay the supplemental growth additive. void decay_supplemental_growth(bool is_full_gc); --- old/src/share/vm/gc/parallel/psCompactionManager.cpp 2015-12-01 12:06:16.574930530 +0100 +++ new/src/share/vm/gc/parallel/psCompactionManager.cpp 2015-12-01 12:06:16.470930533 +0100 @@ -32,6 +32,7 @@ #include "gc/parallel/psOldGen.hpp" #include "gc/parallel/psParallelCompact.inline.hpp" #include "gc/shared/taskqueue.inline.hpp" +#include "logging/log.hpp" #include "memory/iterator.inline.hpp" #include "oops/instanceKlass.inline.hpp" #include "oops/instanceMirrorKlass.inline.hpp" @@ -229,30 +230,18 @@ static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); T heap_oop = oopDesc::load_heap_oop(referent_addr); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj)); - } - ) + log_develop_trace(gc, ref)("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj)); if (!oopDesc::is_null(heap_oop)) { oop referent = oopDesc::decode_heap_oop_not_null(heap_oop); if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) && PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) { // reference already enqueued, referent will be traversed later klass->InstanceKlass::oop_pc_follow_contents(obj, cm); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Non NULL enqueued " PTR_FORMAT, p2i(obj)); - } - ) + log_develop_trace(gc, ref)(" Non NULL enqueued " PTR_FORMAT, p2i(obj)); return; } else { // treat referent as normal oop - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Non NULL normal " PTR_FORMAT, p2i(obj)); - } - ) + log_develop_trace(gc, ref)(" Non NULL normal " PTR_FORMAT, p2i(obj)); cm->mark_and_push(referent_addr); } } @@ -262,12 +251,7 @@ T next_oop = oopDesc::load_heap_oop(next_addr); if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) + log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(discovered_addr)); cm->mark_and_push(discovered_addr); } cm->mark_and_push(next_addr); --- old/src/share/vm/gc/parallel/psMarkSweep.cpp 2015-12-01 12:06:16.746930524 +0100 +++ new/src/share/vm/gc/parallel/psMarkSweep.cpp 2015-12-01 12:06:16.646930527 +0100 @@ -40,11 +40,12 @@ #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/biasedLocking.hpp" #include "runtime/fprofiler.hpp" @@ -136,8 +137,6 @@ // We need to track unique mark sweep invocations as well. _total_invocations++; - AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); - heap->print_heap_before_gc(); heap->trace_heap_before_gc(_gc_tracer); @@ -147,7 +146,7 @@ if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyBeforeGC:"); + Universe::verify("Before GC"); } // Verify object start arrays @@ -166,8 +165,8 @@ { HandleMark hm; - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - GCTraceTime t1(GCCauseString("Full GC", gc_cause), PrintGC, !PrintGCDetails, NULL); + GCTraceCPUTime tcpu; + GCTraceTime(Info, gc) t("Pause Full", NULL, gc_cause, true); TraceCollectorStats tcs(counters()); TraceMemoryManagerStats tms(true /* Full GC */,gc_cause); @@ -179,13 +178,9 @@ CodeCache::gc_prologue(); BiasedLocking::preserve_marks(); - // Capture heap size before collection for printing. - size_t prev_used = heap->used(); - // Capture metadata size before collection for sizing. size_t metadata_prev_used = MetaspaceAux::used_bytes(); - // For PrintGCDetails size_t old_gen_prev_used = old_gen->used_in_bytes(); size_t young_gen_prev_used = young_gen->used_in_bytes(); @@ -265,17 +260,9 @@ if (UseAdaptiveSizePolicy) { - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print("AdaptiveSizeStart: "); - gclog_or_tty->stamp(); - gclog_or_tty->print_cr(" collection: %d ", - heap->total_collections()); - if (Verbose) { - gclog_or_tty->print("old_gen_capacity: " SIZE_FORMAT - " young_gen_capacity: " SIZE_FORMAT, - old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); - } - } + log_debug(gc, ergo)("AdaptiveSizeStart: collection: %d ", heap->total_collections()); + log_trace(gc, ergo)("old_gen_capacity: " SIZE_FORMAT " young_gen_capacity: " SIZE_FORMAT, + old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); // Don't check if the size_policy is ready here. Let // the size_policy check that internally. @@ -332,10 +319,7 @@ heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), size_policy->calculated_survivor_size_in_bytes()); } - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", - heap->total_collections()); - } + log_debug(gc, ergo)("AdaptiveSizeStop: collection: %d ", heap->total_collections()); } if (UsePerfData) { @@ -353,18 +337,9 @@ if (TraceOldGenTime) accumulated_time()->stop(); - if (PrintGC) { - if (PrintGCDetails) { - // Don't print a GC timestamp here. This is after the GC so - // would be confusing. - young_gen->print_used_change(young_gen_prev_used); - old_gen->print_used_change(old_gen_prev_used); - } - heap->print_heap_change(prev_used); - if (PrintGCDetails) { - MetaspaceAux::print_metaspace_change(metadata_prev_used); - } - } + young_gen->print_used_change(young_gen_prev_used); + old_gen->print_used_change(old_gen_prev_used); + MetaspaceAux::print_metaspace_change(metadata_prev_used); // Track memory usage and detect low memory MemoryService::track_memory_usage(); @@ -373,7 +348,7 @@ if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyAfterGC:"); + Universe::verify("After GC"); } // Re-verify object start arrays @@ -397,6 +372,8 @@ ParallelTaskTerminator::print_termination_counts(); #endif + AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections()); + _gc_timer->register_gc_end(); _gc_tracer->report_gc_end(_gc_timer->gc_end(), _gc_timer->time_partitions()); @@ -442,8 +419,7 @@ return false; // Respect young gen minimum size. } - if (TraceAdaptiveGCBoundary && Verbose) { - gclog_or_tty->print(" absorbing " SIZE_FORMAT "K: " + log_trace(heap, ergo)(" absorbing " SIZE_FORMAT "K: " "eden " SIZE_FORMAT "K->" SIZE_FORMAT "K " "from " SIZE_FORMAT "K, to " SIZE_FORMAT "K " "young_gen " SIZE_FORMAT "K->" SIZE_FORMAT "K ", @@ -452,7 +428,6 @@ young_gen->from_space()->used_in_bytes() / K, young_gen->to_space()->used_in_bytes() / K, young_gen->capacity_in_bytes() / K, new_young_size / K); - } // Fill the unused part of the old gen. MutableSpace* const old_space = old_gen->object_space(); @@ -516,7 +491,7 @@ void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) { // Recursively traverse all live objects and mark them - GCTraceTime tm("phase 1", PrintGCDetails && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 1: Mark live objects", _gc_timer); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); @@ -575,7 +550,7 @@ void PSMarkSweep::mark_sweep_phase2() { - GCTraceTime tm("phase 2", PrintGCDetails && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 2: Compute new object addresses", _gc_timer); // Now all live objects are marked, compute the new object addresses. @@ -602,7 +577,7 @@ void PSMarkSweep::mark_sweep_phase3() { // Adjust the pointers to reflect the new locations - GCTraceTime tm("phase 3", PrintGCDetails && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 3: Adjust pointers", _gc_timer); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); PSYoungGen* young_gen = heap->young_gen(); @@ -642,7 +617,7 @@ void PSMarkSweep::mark_sweep_phase4() { EventMark m("4 compact heap"); - GCTraceTime tm("phase 4", PrintGCDetails && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 4: Move objects", _gc_timer); // All pointers are now adjusted, move objects accordingly --- old/src/share/vm/gc/parallel/psOldGen.cpp 2015-12-01 12:06:16.930930517 +0100 +++ new/src/share/vm/gc/parallel/psOldGen.cpp 2015-12-01 12:06:16.830930521 +0100 @@ -30,6 +30,7 @@ #include "gc/shared/cardTableModRefBS.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" @@ -256,10 +257,8 @@ success = expand_to_reserved(); } - if (PrintGC && Verbose) { - if (success && GC_locker::is_active_and_needs_gc()) { - gclog_or_tty->print_cr("Garbage collection disabled, expanded heap instead"); - } + if (success && GC_locker::is_active_and_needs_gc()) { + log_debug(gc)("Garbage collection disabled, expanded heap instead"); } } @@ -291,13 +290,11 @@ } } - if (result && Verbose && PrintGC) { + if (result) { size_t new_mem_size = virtual_space()->committed_size(); size_t old_mem_size = new_mem_size - bytes; - gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by " - SIZE_FORMAT "K to " - SIZE_FORMAT "K", - name(), old_mem_size/K, bytes/K, new_mem_size/K); + log_debug(gc)("Expanding %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K", + name(), old_mem_size/K, bytes/K, new_mem_size/K); } return result; @@ -326,14 +323,10 @@ virtual_space()->shrink_by(bytes); post_resize(); - if (Verbose && PrintGC) { - size_t new_mem_size = virtual_space()->committed_size(); - size_t old_mem_size = new_mem_size + bytes; - gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K by " - SIZE_FORMAT "K to " - SIZE_FORMAT "K", - name(), old_mem_size/K, bytes/K, new_mem_size/K); - } + size_t new_mem_size = virtual_space()->committed_size(); + size_t old_mem_size = new_mem_size + bytes; + log_debug(gc)("Shrinking %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K", + name(), old_mem_size/K, bytes/K, new_mem_size/K); } } @@ -353,14 +346,12 @@ const size_t current_size = capacity_in_bytes(); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("AdaptiveSizePolicy::old generation size: " - "desired free: " SIZE_FORMAT " used: " SIZE_FORMAT - " new size: " SIZE_FORMAT " current size " SIZE_FORMAT - " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT, - desired_free_space, used_in_bytes(), new_size, current_size, - gen_size_limit(), min_gen_size()); - } + log_trace(gc, ergo)("AdaptiveSizePolicy::old generation size: " + "desired free: " SIZE_FORMAT " used: " SIZE_FORMAT + " new size: " SIZE_FORMAT " current size " SIZE_FORMAT + " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT, + desired_free_space, used_in_bytes(), new_size, current_size, + gen_size_limit(), min_gen_size()); if (new_size == current_size) { // No change requested @@ -376,14 +367,10 @@ shrink(change_bytes); } - if (PrintAdaptiveSizePolicy) { - ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); - gclog_or_tty->print_cr("AdaptiveSizePolicy::old generation size: " - "collection: %d " - "(" SIZE_FORMAT ") -> (" SIZE_FORMAT ") ", - heap->total_collections(), - size_before, virtual_space()->committed_size()); - } + log_trace(gc, ergo)("AdaptiveSizePolicy::old generation size: collection: %d (" SIZE_FORMAT ") -> (" SIZE_FORMAT ") ", + ParallelScavengeHeap::heap()->total_collections(), + size_before, + virtual_space()->committed_size()); } // NOTE! We need to be careful about resizing. During a GC, multiple @@ -430,13 +417,8 @@ void PSOldGen::print() const { print_on(tty);} void PSOldGen::print_on(outputStream* st) const { st->print(" %-15s", name()); - if (PrintGCDetails && Verbose) { - st->print(" total " SIZE_FORMAT ", used " SIZE_FORMAT, - capacity_in_bytes(), used_in_bytes()); - } else { - st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", - capacity_in_bytes()/K, used_in_bytes()/K); - } + st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", + capacity_in_bytes()/K, used_in_bytes()/K); st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", p2i(virtual_space()->low_boundary()), p2i(virtual_space()->high()), @@ -446,13 +428,8 @@ } void PSOldGen::print_used_change(size_t prev_used) const { - gclog_or_tty->print(" [%s:", name()); - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_used / K, used_in_bytes() / K, - capacity_in_bytes() / K); - gclog_or_tty->print("]"); + log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + name(), prev_used / K, used_in_bytes() / K, capacity_in_bytes() / K); } void PSOldGen::update_counters() { --- old/src/share/vm/gc/parallel/psParallelCompact.cpp 2015-12-01 12:06:17.110930511 +0100 +++ new/src/share/vm/gc/parallel/psParallelCompact.cpp 2015-12-01 12:06:17.006930515 +0100 @@ -44,11 +44,12 @@ #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "oops/instanceKlass.inline.hpp" #include "oops/instanceMirrorKlass.inline.hpp" #include "oops/methodData.hpp" @@ -106,7 +107,6 @@ ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift; SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id]; -bool PSParallelCompact::_print_phases = false; ReferenceProcessor* PSParallelCompact::_ref_processor = NULL; @@ -193,21 +193,26 @@ "old ", "eden", "from", "to " }; -void PSParallelCompact::print_region_ranges() -{ - tty->print_cr("space bottom top end new_top"); - tty->print_cr("------ ---------- ---------- ---------- ----------"); +void PSParallelCompact::print_region_ranges() { + if (!develop_log_is_enabled(Trace, gc, compaction, phases)) { + return; + } + LogHandle(gc, compaction, phases) log; + ResourceMark rm; + Universe::print_on(log.trace_stream()); + log.trace("space bottom top end new_top"); + log.trace("------ ---------- ---------- ---------- ----------"); for (unsigned int id = 0; id < last_space_id; ++id) { const MutableSpace* space = _space_info[id].space(); - tty->print_cr("%u %s " - SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " " - SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " ", - id, space_names[id], - summary_data().addr_to_region_idx(space->bottom()), - summary_data().addr_to_region_idx(space->top()), - summary_data().addr_to_region_idx(space->end()), - summary_data().addr_to_region_idx(_space_info[id].new_top())); + log.trace("%u %s " + SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " " + SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " ", + id, space_names[id], + summary_data().addr_to_region_idx(space->bottom()), + summary_data().addr_to_region_idx(space->top()), + summary_data().addr_to_region_idx(space->end()), + summary_data().addr_to_region_idx(_space_info[id].new_top())); } } @@ -219,13 +224,14 @@ ParallelCompactData& sd = PSParallelCompact::summary_data(); size_t dci = c->destination() ? sd.addr_to_region_idx(c->destination()) : 0; - tty->print_cr(REGION_IDX_FORMAT " " PTR_FORMAT " " - REGION_IDX_FORMAT " " PTR_FORMAT " " - REGION_DATA_FORMAT " " REGION_DATA_FORMAT " " - REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d", - i, p2i(c->data_location()), dci, p2i(c->destination()), - c->partial_obj_size(), c->live_obj_size(), - c->data_size(), c->source_region(), c->destination_count()); + log_develop_trace(gc, compaction, phases)( + REGION_IDX_FORMAT " " PTR_FORMAT " " + REGION_IDX_FORMAT " " PTR_FORMAT " " + REGION_DATA_FORMAT " " REGION_DATA_FORMAT " " + REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d", + i, p2i(c->data_location()), dci, p2i(c->destination()), + c->partial_obj_size(), c->live_obj_size(), + c->data_size(), c->source_region(), c->destination_count()); #undef REGION_IDX_FORMAT #undef REGION_DATA_FORMAT @@ -251,13 +257,17 @@ ++i; } - tty->print_cr("summary_data_bytes=" SIZE_FORMAT, total_words * HeapWordSize); + log_develop_trace(gc, compaction, phases)("summary_data_bytes=" SIZE_FORMAT, total_words * HeapWordSize); } void print_generic_summary_data(ParallelCompactData& summary_data, SpaceInfo* space_info) { + if (!develop_log_is_enabled(Trace, gc, compaction, phases)) { + return; + } + for (unsigned int id = 0; id < PSParallelCompact::last_space_id; ++id) { const MutableSpace* space = space_info[id].space(); print_generic_summary_data(summary_data, space->bottom(), @@ -266,20 +276,6 @@ } void -print_initial_summary_region(size_t i, - const ParallelCompactData::RegionData* c, - bool newline = true) -{ - tty->print(SIZE_FORMAT_W(5) " " PTR_FORMAT " " - SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " - SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d", - i, p2i(c->destination()), - c->partial_obj_size(), c->live_obj_size(), - c->data_size(), c->source_region(), c->destination_count()); - if (newline) tty->cr(); -} - -void print_initial_summary_data(ParallelCompactData& summary_data, const MutableSpace* space) { if (space->top() == space->bottom()) { @@ -298,7 +294,12 @@ size_t full_region_count = 0; size_t i = summary_data.addr_to_region_idx(space->bottom()); while (i < end_region && summary_data.region(i)->data_size() == region_size) { - print_initial_summary_region(i, summary_data.region(i)); + ParallelCompactData::RegionData* c = summary_data.region(i); + log_develop_trace(gc, compaction, phases)( + SIZE_FORMAT_W(5) " " PTR_FORMAT " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d", + i, p2i(c->destination()), + c->partial_obj_size(), c->live_obj_size(), + c->data_size(), c->source_region(), c->destination_count()); ++full_region_count; ++i; } @@ -327,9 +328,15 @@ max_live_to_right = live_to_right; } - print_initial_summary_region(i, c, false); - tty->print_cr(" %12.10f " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10), - reclaimed_ratio, dead_to_right, live_to_right); + ParallelCompactData::RegionData* c = summary_data.region(i); + log_develop_trace(gc, compaction, phases)( + SIZE_FORMAT_W(5) " " PTR_FORMAT " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d" + "%12.10f " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10), + i, p2i(c->destination()), + c->partial_obj_size(), c->live_obj_size(), + c->data_size(), c->source_region(), c->destination_count(), + reclaimed_ratio, dead_to_right, live_to_right); + live_to_right -= c->data_size(); ++i; @@ -337,18 +344,25 @@ // Any remaining regions are empty. Print one more if there is one. if (i < end_region) { - print_initial_summary_region(i, summary_data.region(i)); + ParallelCompactData::RegionData* c = summary_data.region(i); + log_develop_trace(gc, compaction, phases)( + SIZE_FORMAT_W(5) " " PTR_FORMAT " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d", + i, p2i(c->destination()), + c->partial_obj_size(), c->live_obj_size(), + c->data_size(), c->source_region(), c->destination_count()); } - tty->print_cr("max: " SIZE_FORMAT_W(4) " d2r=" SIZE_FORMAT_W(10) " " - "l2r=" SIZE_FORMAT_W(10) " max_ratio=%14.12f", - max_reclaimed_ratio_region, max_dead_to_right, - max_live_to_right, max_reclaimed_ratio); + log_develop_trace(gc, compaction, phases)("max: " SIZE_FORMAT_W(4) " d2r=" SIZE_FORMAT_W(10) " l2r=" SIZE_FORMAT_W(10) " max_ratio=%14.12f", + max_reclaimed_ratio_region, max_dead_to_right, max_live_to_right, max_reclaimed_ratio); } void print_initial_summary_data(ParallelCompactData& summary_data, SpaceInfo* space_info) { + if (!develop_log_is_enabled(Trace, gc, compaction, phases)) { + return; + } + unsigned int id = PSParallelCompact::old_space_id; const MutableSpace* space; do { @@ -606,11 +620,7 @@ sr->partial_obj_size())); const size_t end_idx = addr_to_region_idx(target_end); - if (TraceParallelOldGCSummaryPhase) { - gclog_or_tty->print_cr("split: clearing source_region field in [" - SIZE_FORMAT ", " SIZE_FORMAT ")", - beg_idx, end_idx); - } + log_develop_trace(gc, compaction, phases)("split: clearing source_region field in [" SIZE_FORMAT ", " SIZE_FORMAT ")", beg_idx, end_idx); for (size_t idx = beg_idx; idx < end_idx; ++idx) { _region_data[idx].set_source_region(0); } @@ -630,27 +640,22 @@ *target_next = split_destination + partial_obj_size; HeapWord* const source_next = region_to_addr(split_region) + partial_obj_size; - if (TraceParallelOldGCSummaryPhase) { + if (develop_log_is_enabled(Trace, gc, compaction, phases)) { const char * split_type = partial_obj_size == 0 ? "easy" : "hard"; - gclog_or_tty->print_cr("%s split: src=" PTR_FORMAT " src_c=" SIZE_FORMAT - " pos=" SIZE_FORMAT, - split_type, p2i(source_next), split_region, - partial_obj_size); - gclog_or_tty->print_cr("%s split: dst=" PTR_FORMAT " dst_c=" SIZE_FORMAT - " tn=" PTR_FORMAT, - split_type, p2i(split_destination), - addr_to_region_idx(split_destination), - p2i(*target_next)); + log_develop_trace(gc, compaction, phases)("%s split: src=" PTR_FORMAT " src_c=" SIZE_FORMAT " pos=" SIZE_FORMAT, + split_type, p2i(source_next), split_region, partial_obj_size); + log_develop_trace(gc, compaction, phases)("%s split: dst=" PTR_FORMAT " dst_c=" SIZE_FORMAT " tn=" PTR_FORMAT, + split_type, p2i(split_destination), + addr_to_region_idx(split_destination), + p2i(*target_next)); if (partial_obj_size != 0) { HeapWord* const po_beg = split_info.destination(); HeapWord* const po_end = po_beg + split_info.partial_obj_size(); - gclog_or_tty->print_cr("%s split: " - "po_beg=" PTR_FORMAT " " SIZE_FORMAT " " - "po_end=" PTR_FORMAT " " SIZE_FORMAT, - split_type, - p2i(po_beg), addr_to_region_idx(po_beg), - p2i(po_end), addr_to_region_idx(po_end)); + log_develop_trace(gc, compaction, phases)("%s split: po_beg=" PTR_FORMAT " " SIZE_FORMAT " po_end=" PTR_FORMAT " " SIZE_FORMAT, + split_type, + p2i(po_beg), addr_to_region_idx(po_beg), + p2i(po_end), addr_to_region_idx(po_end)); } } @@ -663,13 +668,12 @@ HeapWord* target_beg, HeapWord* target_end, HeapWord** target_next) { - if (TraceParallelOldGCSummaryPhase) { - HeapWord* const source_next_val = source_next == NULL ? NULL : *source_next; - tty->print_cr("sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT - "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT, - p2i(source_beg), p2i(source_end), p2i(source_next_val), - p2i(target_beg), p2i(target_end), p2i(*target_next)); - } + HeapWord* const source_next_val = source_next == NULL ? NULL : *source_next; + log_develop_trace(gc, compaction, phases)( + "sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT + "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT, + p2i(source_beg), p2i(source_end), p2i(source_next_val), + p2i(target_beg), p2i(target_end), p2i(*target_next)); size_t cur_region = addr_to_region_idx(source_beg); const size_t end_region = addr_to_region_idx(region_align_up(source_end)); @@ -900,32 +904,6 @@ _dwl_adjustment = normal_distribution(1.0); } -// Simple class for storing info about the heap at the start of GC, to be used -// after GC for comparison/printing. -class PreGCValues { -public: - PreGCValues() { } - PreGCValues(ParallelScavengeHeap* heap) { fill(heap); } - - void fill(ParallelScavengeHeap* heap) { - _heap_used = heap->used(); - _young_gen_used = heap->young_gen()->used_in_bytes(); - _old_gen_used = heap->old_gen()->used_in_bytes(); - _metadata_used = MetaspaceAux::used_bytes(); - }; - - size_t heap_used() const { return _heap_used; } - size_t young_gen_used() const { return _young_gen_used; } - size_t old_gen_used() const { return _old_gen_used; } - size_t metadata_used() const { return _metadata_used; } - -private: - size_t _heap_used; - size_t _young_gen_used; - size_t _old_gen_used; - size_t _metadata_used; -}; - void PSParallelCompact::clear_data_covering_space(SpaceId id) { @@ -955,19 +933,17 @@ DEBUG_ONLY(split_info.verify_clear();) } -void PSParallelCompact::pre_compact(PreGCValues* pre_gc_values) +void PSParallelCompact::pre_compact() { // Update the from & to space pointers in space_info, since they are swapped // at each young gen gc. Do the update unconditionally (even though a // promotion failure does not swap spaces) because an unknown number of young // collections will have swapped the spaces an unknown number of times. - GCTraceTime tm("pre compact", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Pre Compact", &_gc_timer); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); _space_info[from_space_id].set_space(heap->young_gen()->from_space()); _space_info[to_space_id].set_space(heap->young_gen()->to_space()); - pre_gc_values->fill(heap); - DEBUG_ONLY(add_obj_count = add_obj_size = 0;) DEBUG_ONLY(mark_bitmap_count = mark_bitmap_size = 0;) @@ -986,7 +962,7 @@ if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyBeforeGC:"); + Universe::verify("Before GC"); } // Verify object start arrays @@ -1004,7 +980,7 @@ void PSParallelCompact::post_compact() { - GCTraceTime tm("post compact", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Post Compact", &_gc_timer); for (unsigned int id = old_space_id; id < last_space_id; ++id) { // Clear the marking bitmap, summary data and split info. @@ -1558,7 +1534,7 @@ } } - if (TraceParallelOldGCSummaryPhase) { + if (develop_log_is_enabled(Trace, gc, compaction, phases)) { const size_t region_size = ParallelCompactData::RegionSize; HeapWord* const dense_prefix_end = _space_info[id].dense_prefix(); const size_t dp_region = _summary_data.addr_to_region_idx(dense_prefix_end); @@ -1566,12 +1542,13 @@ HeapWord* const new_top = _space_info[id].new_top(); const HeapWord* nt_aligned_up = _summary_data.region_align_up(new_top); const size_t cr_words = pointer_delta(nt_aligned_up, dense_prefix_end); - tty->print_cr("id=%d cap=" SIZE_FORMAT " dp=" PTR_FORMAT " " - "dp_region=" SIZE_FORMAT " " "dp_count=" SIZE_FORMAT " " - "cr_count=" SIZE_FORMAT " " "nt=" PTR_FORMAT, - id, space->capacity_in_words(), p2i(dense_prefix_end), - dp_region, dp_words / region_size, - cr_words / region_size, p2i(new_top)); + log_develop_trace(gc, compaction, phases)( + "id=%d cap=" SIZE_FORMAT " dp=" PTR_FORMAT " " + "dp_region=" SIZE_FORMAT " " "dp_count=" SIZE_FORMAT " " + "cr_count=" SIZE_FORMAT " " "nt=" PTR_FORMAT, + id, space->capacity_in_words(), p2i(dense_prefix_end), + dp_region, dp_words / region_size, + cr_words / region_size, p2i(new_top)); } } @@ -1581,29 +1558,27 @@ SpaceId src_space_id, HeapWord* src_beg, HeapWord* src_end) { - if (TraceParallelOldGCSummaryPhase) { - tty->print_cr("summarizing %d [%s] into %d [%s]: " - "src=" PTR_FORMAT "-" PTR_FORMAT " " - SIZE_FORMAT "-" SIZE_FORMAT " " - "dst=" PTR_FORMAT "-" PTR_FORMAT " " - SIZE_FORMAT "-" SIZE_FORMAT, - src_space_id, space_names[src_space_id], - dst_space_id, space_names[dst_space_id], - p2i(src_beg), p2i(src_end), - _summary_data.addr_to_region_idx(src_beg), - _summary_data.addr_to_region_idx(src_end), - p2i(dst_beg), p2i(dst_end), - _summary_data.addr_to_region_idx(dst_beg), - _summary_data.addr_to_region_idx(dst_end)); - } + log_develop_trace(gc, compaction, phases)( + "Summarizing %d [%s] into %d [%s]: " + "src=" PTR_FORMAT "-" PTR_FORMAT " " + SIZE_FORMAT "-" SIZE_FORMAT " " + "dst=" PTR_FORMAT "-" PTR_FORMAT " " + SIZE_FORMAT "-" SIZE_FORMAT, + src_space_id, space_names[src_space_id], + dst_space_id, space_names[dst_space_id], + p2i(src_beg), p2i(src_end), + _summary_data.addr_to_region_idx(src_beg), + _summary_data.addr_to_region_idx(src_end), + p2i(dst_beg), p2i(dst_end), + _summary_data.addr_to_region_idx(dst_beg), + _summary_data.addr_to_region_idx(dst_end)); } #endif // #ifndef PRODUCT void PSParallelCompact::summary_phase(ParCompactionManager* cm, bool maximum_compaction) { - GCTraceTime tm("summary phase", print_phases(), true, &_gc_timer); - // trace("2"); + GCTraceTime(Trace, gc, phases) tm("Summary Phase", &_gc_timer); #ifdef ASSERT if (TraceParallelOldGCMarkingPhase) { @@ -1619,14 +1594,9 @@ // Quick summarization of each space into itself, to see how much is live. summarize_spaces_quick(); - if (TraceParallelOldGCSummaryPhase) { - tty->print_cr("summary_phase: after summarizing each space to self"); - Universe::print(); - NOT_PRODUCT(print_region_ranges()); - if (Verbose) { - NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info)); - } - } + log_develop_trace(gc, compaction, phases)("summary phase: after summarizing each space to self"); + NOT_PRODUCT(print_region_ranges()); + NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info)); // The amount of live data that will end up in old space (assuming it fits). size_t old_space_total_live = 0; @@ -1700,14 +1670,9 @@ } } - if (TraceParallelOldGCSummaryPhase) { - tty->print_cr("summary_phase: after final summarization"); - Universe::print(); - NOT_PRODUCT(print_region_ranges()); - if (Verbose) { - NOT_PRODUCT(print_generic_summary_data(_summary_data, _space_info)); - } - } + log_develop_trace(gc, compaction, phases)("Summary_phase: after final summarization"); + NOT_PRODUCT(print_region_ranges()); + NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info)); } // This method should contain all heap-specific policy for invoking a full @@ -1782,20 +1747,16 @@ heap->pre_full_gc_dump(&_gc_timer); - _print_phases = PrintGCDetails && PrintParallelOldGCPhaseTimes; - // Make sure data structures are sane, make the heap parsable, and do other // miscellaneous bookkeeping. - PreGCValues pre_gc_values; - pre_compact(&pre_gc_values); + pre_compact(); + + PreGCValues pre_gc_values(heap); // Get the compaction manager reserved for the VM thread. ParCompactionManager* const vmthread_cm = ParCompactionManager::manager_array(gc_task_manager()->workers()); - // Place after pre_compact() where the number of invocations is incremented. - AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); - { ResourceMark rm; HandleMark hm; @@ -1804,8 +1765,8 @@ gc_task_manager()->set_active_gang(); gc_task_manager()->task_idle_workers(); - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - GCTraceTime t1(GCCauseString("Full GC", gc_cause), PrintGC, !PrintGCDetails, NULL); + GCTraceCPUTime tcpu; + GCTraceTime(Info, gc) tm("Pause Full", NULL, gc_cause, true); TraceCollectorStats tcs(counters()); TraceMemoryManagerStats tms(true /* Full GC */,gc_cause); @@ -1852,17 +1813,9 @@ size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause); if (UseAdaptiveSizePolicy) { - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print("AdaptiveSizeStart: "); - gclog_or_tty->stamp(); - gclog_or_tty->print_cr(" collection: %d ", - heap->total_collections()); - if (Verbose) { - gclog_or_tty->print("old_gen_capacity: " SIZE_FORMAT - " young_gen_capacity: " SIZE_FORMAT, - old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); - } - } + log_debug(gc, ergo)("AdaptiveSizeStart: collection: %d ", heap->total_collections()); + log_trace(gc, ergo)("old_gen_capacity: " SIZE_FORMAT " young_gen_capacity: " SIZE_FORMAT, + old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); // Don't check if the size_policy is ready here. Let // the size_policy check that internally. @@ -1920,10 +1873,8 @@ heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), size_policy->calculated_survivor_size_in_bytes()); } - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", - heap->total_collections()); - } + + log_debug(gc, ergo)("AdaptiveSizeStop: collection: %d ", heap->total_collections()); } if (UsePerfData) { @@ -1938,20 +1889,14 @@ // Resize the metaspace capacity after a collection MetaspaceGC::compute_new_size(); - if (TraceOldGenTime) accumulated_time()->stop(); - - if (PrintGC) { - if (PrintGCDetails) { - // No GC timestamp here. This is after GC so it would be confusing. - young_gen->print_used_change(pre_gc_values.young_gen_used()); - old_gen->print_used_change(pre_gc_values.old_gen_used()); - heap->print_heap_change(pre_gc_values.heap_used()); - MetaspaceAux::print_metaspace_change(pre_gc_values.metadata_used()); - } else { - heap->print_heap_change(pre_gc_values.heap_used()); - } + if (TraceOldGenTime) { + accumulated_time()->stop(); } + young_gen->print_used_change(pre_gc_values.young_gen_used()); + old_gen->print_used_change(pre_gc_values.old_gen_used()); + MetaspaceAux::print_metaspace_change(pre_gc_values.metadata_used()); + // Track memory usage and detect low memory MemoryService::track_memory_usage(); heap->update_counters(); @@ -1969,7 +1914,7 @@ if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyAfterGC:"); + Universe::verify("After GC"); } // Re-verify object start arrays @@ -1989,13 +1934,10 @@ heap->print_heap_after_gc(); heap->trace_heap_after_gc(&_gc_tracer); - if (PrintGCTaskTimeStamps) { - gclog_or_tty->print_cr("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " - JLONG_FORMAT, - marking_start.ticks(), compaction_start.ticks(), - collection_exit.ticks()); - gc_task_manager()->print_task_time_stamps(); - } + log_debug(gc, task, time)("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT, + marking_start.ticks(), compaction_start.ticks(), + collection_exit.ticks()); + gc_task_manager()->print_task_time_stamps(); heap->post_full_gc_dump(&_gc_timer); @@ -2003,6 +1945,8 @@ ParallelTaskTerminator::print_termination_counts(); #endif + AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections()); + _gc_timer.register_gc_end(); _gc_tracer.report_dense_prefix(dense_prefix(old_space_id)); @@ -2049,8 +1993,7 @@ return false; // Respect young gen minimum size. } - if (TraceAdaptiveGCBoundary && Verbose) { - gclog_or_tty->print(" absorbing " SIZE_FORMAT "K: " + log_trace(heap, ergo)(" absorbing " SIZE_FORMAT "K: " "eden " SIZE_FORMAT "K->" SIZE_FORMAT "K " "from " SIZE_FORMAT "K, to " SIZE_FORMAT "K " "young_gen " SIZE_FORMAT "K->" SIZE_FORMAT "K ", @@ -2059,7 +2002,6 @@ young_gen->from_space()->used_in_bytes() / K, young_gen->to_space()->used_in_bytes() / K, young_gen->capacity_in_bytes() / K, new_young_size / K); - } // Fill the unused part of the old gen. MutableSpace* const old_space = old_gen->object_space(); @@ -2109,7 +2051,7 @@ bool maximum_heap_compaction, ParallelOldTracer *gc_tracer) { // Recursively traverse all live objects and mark them - GCTraceTime tm("marking phase", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Marking Phase", &_gc_timer); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); uint parallel_gc_threads = heap->gc_task_manager()->workers(); @@ -2124,7 +2066,7 @@ ClassLoaderDataGraph::clear_claimed_marks(); { - GCTraceTime tm_m("par mark", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Par Mark", &_gc_timer); ParallelScavengeHeap::ParStrongRootsScope psrs; @@ -2153,7 +2095,7 @@ // Process reference objects found during marking { - GCTraceTime tm_r("reference processing", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Reference Processing", &_gc_timer); ReferenceProcessorStats stats; if (ref_processor()->processing_is_mt()) { @@ -2170,7 +2112,7 @@ gc_tracer->report_gc_reference_stats(stats); } - GCTraceTime tm_c("class unloading", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc) tm_m("Class Unloading", &_gc_timer); // This is the point where the entire marking should have completed. assert(cm->marking_stacks_empty(), "Marking should have completed"); @@ -2201,7 +2143,7 @@ void PSParallelCompact::adjust_roots() { // Adjust the pointers to reflect the new locations - GCTraceTime tm("adjust roots", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Adjust Roots", &_gc_timer); // Need new claim bits when tracing through and adjusting pointers. ClassLoaderDataGraph::clear_claimed_marks(); @@ -2234,10 +2176,49 @@ PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure()); } +// Helper class to print 8 region numbers per line and then print the total at the end. +class FillableRegionLogger : public StackObj { +private: + LogHandle(gc, compaction) log; + static const int LineLength = 8; + size_t _regions[LineLength]; + int _next_index; + bool _enabled; + size_t _total_regions; +public: + FillableRegionLogger() : _next_index(0), _total_regions(0), _enabled(develop_log_is_enabled(Trace, gc, compaction)) { } + ~FillableRegionLogger() { + log.trace(SIZE_FORMAT " initially fillable regions", _total_regions); + } + + void print_line() { + if (!_enabled || _next_index == 0) { + return; + } + FormatBuffer<> line("Fillable: "); + for (int i = 0; i < _next_index; i++) { + line.append(" " SIZE_FORMAT_W(7), _regions[i]); + } + log.trace("%s", line.buffer()); + _next_index = 0; + } + + void handle(size_t region) { + if (!_enabled) { + return; + } + _regions[_next_index++] = region; + if (_next_index == LineLength) { + print_line(); + } + _total_regions++; + } +}; + void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q, uint parallel_gc_threads) { - GCTraceTime tm("drain task setup", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Drain Task Setup", &_gc_timer); // Find the threads that are active unsigned int which = 0; @@ -2262,13 +2243,13 @@ const ParallelCompactData& sd = PSParallelCompact::summary_data(); - size_t fillable_regions = 0; // A count for diagnostic purposes. // A region index which corresponds to the tasks created above. // "which" must be 0 <= which < task_count which = 0; // id + 1 is used to test termination so unsigned can // be used with an old_space_id == 0. + FillableRegionLogger region_logger; for (unsigned int id = to_space_id; id + 1 > old_space_id; --id) { SpaceInfo* const space_info = _space_info + id; MutableSpace* const space = space_info->space(); @@ -2281,16 +2262,7 @@ for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) { if (sd.region(cur)->claim_unsafe()) { ParCompactionManager::region_list_push(which, cur); - - if (TraceParallelOldGCCompactionPhase && Verbose) { - const size_t count_mod_8 = fillable_regions & 7; - if (count_mod_8 == 0) gclog_or_tty->print("fillable: "); - gclog_or_tty->print(" " SIZE_FORMAT_W(7), cur); - if (count_mod_8 == 7) gclog_or_tty->cr(); - } - - NOT_PRODUCT(++fillable_regions;) - + region_logger.handle(cur); // Assign regions to tasks in round-robin fashion. if (++which == task_count) { assert(which <= parallel_gc_threads, @@ -2299,11 +2271,7 @@ } } } - } - - if (TraceParallelOldGCCompactionPhase) { - if (Verbose && (fillable_regions & 7) != 0) gclog_or_tty->cr(); - gclog_or_tty->print_cr(SIZE_FORMAT " initially fillable regions", fillable_regions); + region_logger.print_line(); } } @@ -2311,7 +2279,7 @@ void PSParallelCompact::enqueue_dense_prefix_tasks(GCTaskQueue* q, uint parallel_gc_threads) { - GCTraceTime tm("dense prefix task setup", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Dense Prefix Task Setup", &_gc_timer); ParallelCompactData& sd = PSParallelCompact::summary_data(); @@ -2393,7 +2361,7 @@ GCTaskQueue* q, ParallelTaskTerminator* terminator_ptr, uint parallel_gc_threads) { - GCTraceTime tm("steal task setup", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Steal Task Setup", &_gc_timer); // Once a thread has drained it's stack, it should try to steal regions from // other threads. @@ -2407,9 +2375,15 @@ #ifdef ASSERT // Write a histogram of the number of times the block table was filled for a // region. -void PSParallelCompact::write_block_fill_histogram(outputStream* const out) +void PSParallelCompact::write_block_fill_histogram() { - if (!TraceParallelOldGCCompactionPhase) return; + if (!develop_log_is_enabled(Trace, gc, compaction)) { + return; + } + + LogHandle(gc, compaction) log; + ResourceMark rm; + outputStream* out = log.trace_stream(); typedef ParallelCompactData::RegionData rd_t; ParallelCompactData& sd = summary_data(); @@ -2428,7 +2402,7 @@ for (const rd_t* cur = beg; cur < end; ++cur) { ++histo[MIN2(cur->blocks_filled_count(), histo_len - 1)]; } - out->print("%u %-4s" SIZE_FORMAT_W(5), id, space_names[id], region_cnt); + out->print("Block fill histogram: %u %-4s" SIZE_FORMAT_W(5), id, space_names[id], region_cnt); for (size_t i = 0; i < histo_len; ++i) { out->print(" " SIZE_FORMAT_W(5) " %5.1f%%", histo[i], 100.0 * histo[i] / region_cnt); @@ -2440,8 +2414,7 @@ #endif // #ifdef ASSERT void PSParallelCompact::compact() { - // trace("5"); - GCTraceTime tm("compaction phase", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Compaction Phase", &_gc_timer); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); PSOldGen* old_gen = heap->old_gen(); @@ -2457,7 +2430,7 @@ enqueue_region_stealing_tasks(q, &terminator, active_gc_threads); { - GCTraceTime tm_pc("par compact", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Par Compact", &_gc_timer); gc_task_manager()->execute_and_wait(q); @@ -2471,14 +2444,14 @@ { // Update the deferred objects, if any. Any compaction manager can be used. - GCTraceTime tm_du("deferred updates", print_phases(), true, &_gc_timer); + GCTraceTime(Trace, gc, phases) tm("Deferred Updates", &_gc_timer); ParCompactionManager* cm = ParCompactionManager::manager_array(0); for (unsigned int id = old_space_id; id < last_space_id; ++id) { update_deferred_objects(cm, SpaceId(id)); } } - DEBUG_ONLY(write_block_fill_histogram(gclog_or_tty)); + DEBUG_ONLY(write_block_fill_histogram()); } #ifdef ASSERT @@ -3107,18 +3080,13 @@ T* referent_addr, T* next_addr, T* discovered_addr) { - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj)); - gclog_or_tty->print_cr(" referent_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(referent_addr), - referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL); - gclog_or_tty->print_cr(" next_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(next_addr), - next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL); - gclog_or_tty->print_cr(" discovered_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(discovered_addr), - discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL); - } + log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj)); + log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(referent_addr), referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL); + log_develop_trace(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(next_addr), next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL); + log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(discovered_addr), discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL); } #endif --- old/src/share/vm/gc/parallel/psParallelCompact.hpp 2015-12-01 12:06:17.350930503 +0100 +++ new/src/share/vm/gc/parallel/psParallelCompact.hpp 2015-12-01 12:06:17.234930507 +0100 @@ -966,7 +966,6 @@ static ParallelCompactData _summary_data; static IsAliveClosure _is_alive_closure; static SpaceInfo _space_info[last_space_id]; - static bool _print_phases; static AdjustPointerClosure _adjust_pointer_closure; static AdjustKlassClosure _adjust_klass_closure; @@ -989,13 +988,10 @@ static void initialize_space_info(); - // Return true if details about individual phases should be printed. - static inline bool print_phases(); - // Clear the marking bitmap and summary data that cover the specified space. static void clear_data_covering_space(SpaceId id); - static void pre_compact(PreGCValues* pre_gc_values); + static void pre_compact(); static void post_compact(); // Mark live objects @@ -1069,7 +1065,7 @@ // Adjust addresses in roots. Does not adjust addresses in heap. static void adjust_roots(); - DEBUG_ONLY(static void write_block_fill_histogram(outputStream* const out);) + DEBUG_ONLY(static void write_block_fill_histogram();) // Move objects to new locations. static void compact_perm(ParCompactionManager* cm); @@ -1260,10 +1256,6 @@ return mark_bitmap()->is_marked(obj); } -inline bool PSParallelCompact::print_phases() { - return _print_phases; -} - inline double PSParallelCompact::normal_distribution(double density) { assert(_dwl_initialized, "uninitialized"); const double squared_term = (density - _dwl_mean) / _dwl_std_dev; --- old/src/share/vm/gc/parallel/psPromotionManager.cpp 2015-12-01 12:06:17.546930496 +0100 +++ new/src/share/vm/gc/parallel/psPromotionManager.cpp 2015-12-01 12:06:17.442930499 +0100 @@ -30,6 +30,7 @@ #include "gc/parallel/psScavenge.inline.hpp" #include "gc/shared/gcTrace.hpp" #include "gc/shared/taskqueue.inline.hpp" +#include "logging/log.hpp" #include "memory/allocation.inline.hpp" #include "memory/memRegion.hpp" #include "memory/padded.inline.hpp" @@ -99,7 +100,7 @@ bool PSPromotionManager::post_scavenge(YoungGCTracer& gc_tracer) { bool promotion_failure_occurred = false; - TASKQUEUE_STATS_ONLY(if (PrintTaskqueue) print_taskqueue_stats()); + TASKQUEUE_STATS_ONLY(print_taskqueue_stats()); for (uint i = 0; i < ParallelGCThreads + 1; i++) { PSPromotionManager* manager = manager_array(i); assert(manager->claimed_stack_depth()->is_empty(), "should be empty"); @@ -128,7 +129,13 @@ }; void -PSPromotionManager::print_taskqueue_stats(outputStream* const out) { +PSPromotionManager::print_taskqueue_stats() { + if (!develop_log_is_enabled(Trace, gc, task, stats)) { + return; + } + LogHandle(gc, task, stats) log; + ResourceMark rm; + outputStream* out = log.trace_stream(); out->print_cr("== GC Tasks Stats, GC %3d", ParallelScavengeHeap::heap()->total_collections()); @@ -368,12 +375,7 @@ T next_oop = oopDesc::load_heap_oop(next_addr); if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) + log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(discovered_addr)); if (PSScavenge::should_scavenge(discovered_addr)) { pm->claim_or_forward_depth(discovered_addr); } @@ -430,15 +432,7 @@ obj = obj->forwardee(); } -#ifndef PRODUCT - if (TraceScavenge) { - gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " (%d)}", - "promotion-failure", - obj->klass()->internal_name(), - p2i(obj), obj->size()); - - } -#endif + log_develop_trace(gc, scavenge)("{promotion-failure %s " PTR_FORMAT " (%d)}", obj->klass()->internal_name(), p2i(obj), obj->size()); return obj; } --- old/src/share/vm/gc/parallel/psPromotionManager.hpp 2015-12-01 12:06:17.742930489 +0100 +++ new/src/share/vm/gc/parallel/psPromotionManager.hpp 2015-12-01 12:06:17.626930493 +0100 @@ -65,7 +65,7 @@ size_t _array_chunks_processed; void print_local_stats(outputStream* const out, uint i) const; - static void print_taskqueue_stats(outputStream* const out = gclog_or_tty); + static void print_taskqueue_stats(); void reset_stats(); #endif // TASKQUEUE_STATS --- old/src/share/vm/gc/parallel/psPromotionManager.inline.hpp 2015-12-01 12:06:17.930930482 +0100 +++ new/src/share/vm/gc/parallel/psPromotionManager.inline.hpp 2015-12-01 12:06:17.810930487 +0100 @@ -31,6 +31,7 @@ #include "gc/parallel/psPromotionManager.hpp" #include "gc/parallel/psScavenge.hpp" #include "gc/shared/taskqueue.inline.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" inline PSPromotionManager* PSPromotionManager::manager_array(uint index) { @@ -260,15 +261,9 @@ new_obj = o->forwardee(); } -#ifndef PRODUCT - // This code must come after the CAS test, or it will print incorrect - // information. - if (TraceScavenge) { - gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", + log_develop_trace(gc, scavenge)("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", should_scavenge(&new_obj) ? "copying" : "tenuring", new_obj->klass()->internal_name(), p2i((void *)o), p2i((void *)new_obj), new_obj->size()); - } -#endif return new_obj; } @@ -288,9 +283,8 @@ #ifndef PRODUCT // This code must come after the CAS test, or it will print incorrect // information. - if (TraceScavenge && o->is_forwarded()) { - gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", - "forwarding", + if (o->is_forwarded()) { + log_develop_trace(gc, scavenge)("{forwarding %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}", new_obj->klass()->internal_name(), p2i((void *)o), p2i((void *)new_obj), new_obj->size()); } #endif --- old/src/share/vm/gc/parallel/psScavenge.cpp 2015-12-01 12:06:18.130930475 +0100 +++ new/src/share/vm/gc/parallel/psScavenge.cpp 2015-12-01 12:06:18.014930479 +0100 @@ -40,12 +40,13 @@ #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/isGCActiveMark.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/spaceDecorator.hpp" #include "memory/resourceArea.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/biasedLocking.hpp" #include "runtime/fprofiler.hpp" @@ -290,8 +291,6 @@ heap->increment_total_collections(); - AdaptiveSizePolicyOutput(size_policy, heap->total_collections()); - if (AdaptiveSizePolicy::should_update_eden_stats(gc_cause)) { // Gather the feedback data for eden occupancy. young_gen->eden_space()->accumulate_statistics(); @@ -303,23 +302,21 @@ assert(!NeverTenure || _tenuring_threshold == markOopDesc::max_age + 1, "Sanity"); assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity"); - size_t prev_used = heap->used(); - // Fill in TLABs heap->accumulate_statistics_all_tlabs(); heap->ensure_parsability(true); // retire TLABs if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyBeforeGC:"); + Universe::verify("Before GC"); } { ResourceMark rm; HandleMark hm; - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - GCTraceTime t1(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL); + GCTraceCPUTime tcpu; + GCTraceTime(Info, gc) tm("Pause Young", NULL, gc_cause, true); TraceCollectorStats tcs(counters()); TraceMemoryManagerStats tms(false /* not full GC */,gc_cause); @@ -352,12 +349,7 @@ reference_processor()->enable_discovery(); reference_processor()->setup_policy(false); - // We track how much was promoted to the next generation for - // the AdaptiveSizePolicy. - size_t old_gen_used_before = old_gen->used_in_bytes(); - - // For PrintGCDetails - size_t young_gen_used_before = young_gen->used_in_bytes(); + PreGCValues pre_gc_values(heap); // Reset our survivor overflow. set_survivor_overflow(false); @@ -383,7 +375,7 @@ // We'll use the promotion manager again later. PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager(); { - GCTraceTime tm("Scavenge", false, false, &_gc_timer); + GCTraceTime(Debug, gc, phases) tm("Scavenge", &_gc_timer); ParallelScavengeHeap::ParStrongRootsScope psrs; GCTaskQueue* q = GCTaskQueue::create(); @@ -425,7 +417,7 @@ // Process reference objects discovered during scavenge { - GCTraceTime tm("References", false, false, &_gc_timer); + GCTraceTime(Debug, gc, phases) tm("References", &_gc_timer); reference_processor()->setup_policy(false); // not always_clear reference_processor()->set_active_mt_degree(active_workers); @@ -454,7 +446,7 @@ } { - GCTraceTime tm("StringTable", false, false, &_gc_timer); + GCTraceTime(Debug, gc, phases) tm("StringTable", &_gc_timer); // Unlink any dead interned Strings and process the remaining live ones. PSScavengeRootsClosure root_closure(promotion_manager); StringTable::unlink_or_oops_do(&_is_alive_closure, &root_closure); @@ -464,9 +456,7 @@ promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer); if (promotion_failure_occurred) { clean_up_failed_promotion(); - if (PrintGC) { - gclog_or_tty->print("--"); - } + log_info(gc)("Promotion failed"); } _gc_tracer.report_tenuring_threshold(tenuring_threshold()); @@ -483,7 +473,7 @@ young_gen->swap_spaces(); size_t survived = young_gen->from_space()->used_in_bytes(); - size_t promoted = old_gen->used_in_bytes() - old_gen_used_before; + size_t promoted = old_gen->used_in_bytes() - pre_gc_values.old_gen_used(); size_policy->update_averages(_survivor_overflow, survived, promoted); // A successful scavenge should restart the GC time limit count which is @@ -492,19 +482,9 @@ if (UseAdaptiveSizePolicy) { // Calculate the new survivor size and tenuring threshold - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print("AdaptiveSizeStart: "); - gclog_or_tty->stamp(); - gclog_or_tty->print_cr(" collection: %d ", - heap->total_collections()); - - if (Verbose) { - gclog_or_tty->print("old_gen_capacity: " SIZE_FORMAT - " young_gen_capacity: " SIZE_FORMAT, - old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); - } - } - + log_debug(gc, ergo)("AdaptiveSizeStart: collection: %d ", heap->total_collections()); + log_trace(gc, ergo)("old_gen_capacity: " SIZE_FORMAT " young_gen_capacity: " SIZE_FORMAT, + old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); if (UsePerfData) { PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); @@ -538,13 +518,9 @@ _tenuring_threshold, survivor_limit); - if (PrintTenuringDistribution) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u" - " (max threshold " UINTX_FORMAT ")", - size_policy->calculated_survivor_size_in_bytes(), - _tenuring_threshold, MaxTenuringThreshold); - } + log_debug(gc, age)("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u (max threshold " UINTX_FORMAT ")", + size_policy->calculated_survivor_size_in_bytes(), + _tenuring_threshold, MaxTenuringThreshold); if (UsePerfData) { PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters(); @@ -602,10 +578,7 @@ heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), size_policy->calculated_survivor_size_in_bytes()); - if (PrintAdaptiveSizePolicy) { - gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ", - heap->total_collections()); - } + log_debug(gc, ergo)("AdaptiveSizeStop: collection: %d ", heap->total_collections()); } // Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can @@ -628,7 +601,7 @@ NOT_PRODUCT(reference_processor()->verify_no_references_recorded()); { - GCTraceTime tm("Prune Scavenge Root Methods", false, false, &_gc_timer); + GCTraceTime(Debug, gc, phases) tm("Prune Scavenge Root Methods", &_gc_timer); CodeCache::prune_scavenge_root_nmethods(); } @@ -649,14 +622,9 @@ if (TraceYoungGenTime) accumulated_time()->stop(); - if (PrintGC) { - if (PrintGCDetails) { - // Don't print a GC timestamp here. This is after the GC so - // would be confusing. - young_gen->print_used_change(young_gen_used_before); - } - heap->print_heap_change(prev_used); - } + young_gen->print_used_change(pre_gc_values.young_gen_used()); + old_gen->print_used_change(pre_gc_values.old_gen_used()); + MetaspaceAux::print_metaspace_change(pre_gc_values.metadata_used()); // Track memory usage and detect low memory MemoryService::track_memory_usage(); @@ -667,7 +635,7 @@ if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyAfterGC:"); + Universe::verify("After GC"); } heap->print_heap_after_gc(); @@ -675,17 +643,16 @@ scavenge_exit.update(); - if (PrintGCTaskTimeStamps) { - tty->print_cr("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT, - scavenge_entry.ticks(), scavenge_midpoint.ticks(), - scavenge_exit.ticks()); - gc_task_manager()->print_task_time_stamps(); - } + log_debug(gc, task, time)("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT, + scavenge_entry.ticks(), scavenge_midpoint.ticks(), + scavenge_exit.ticks()); + gc_task_manager()->print_task_time_stamps(); #ifdef TRACESPINNING ParallelTaskTerminator::print_termination_counts(); #endif + AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections()); _gc_timer.register_gc_end(); @@ -708,9 +675,7 @@ PSPromotionFailedClosure unforward_closure; young_gen->object_iterate(&unforward_closure); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks", _preserved_oop_stack.size()); - } + log_trace(gc, ergo)("Restoring " SIZE_FORMAT " marks", _preserved_oop_stack.size()); // Restore any saved marks. while (!_preserved_oop_stack.is_empty()) { @@ -772,19 +737,12 @@ size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes()); bool result = promotion_estimate < old_gen->free_in_bytes(); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(result ? " do scavenge: " : " skip scavenge: "); - gclog_or_tty->print_cr(" average_promoted " SIZE_FORMAT - " padded_average_promoted " SIZE_FORMAT - " free in old gen " SIZE_FORMAT, - (size_t) policy->average_promoted_in_bytes(), - (size_t) policy->padded_average_promoted_in_bytes(), - old_gen->free_in_bytes()); - if (young_gen->used_in_bytes() < - (size_t) policy->padded_average_promoted_in_bytes()) { - gclog_or_tty->print_cr(" padded_promoted_average is greater" - " than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()); - } + log_trace(ergo)("%s scavenge: average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen " SIZE_FORMAT, + result ? "Do" : "Skip", (size_t) policy->average_promoted_in_bytes(), + (size_t) policy->padded_average_promoted_in_bytes(), + old_gen->free_in_bytes()); + if (young_gen->used_in_bytes() < (size_t) policy->padded_average_promoted_in_bytes()) { + log_trace(ergo)(" padded_promoted_average is greater than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()); } if (result) { --- old/src/share/vm/gc/parallel/psScavenge.inline.hpp 2015-12-01 12:06:18.338930468 +0100 +++ new/src/share/vm/gc/parallel/psScavenge.inline.hpp 2015-12-01 12:06:18.222930472 +0100 @@ -29,6 +29,7 @@ #include "gc/parallel/parallelScavengeHeap.hpp" #include "gc/parallel/psPromotionManager.inline.hpp" #include "gc/parallel/psScavenge.hpp" +#include "logging/log.hpp" #include "memory/iterator.hpp" #include "utilities/globalDefinitions.hpp" @@ -139,13 +140,11 @@ // no references into the young gen and we can skip it. #ifndef PRODUCT - if (TraceScavenge) { ResourceMark rm; - gclog_or_tty->print_cr("PSScavengeKlassClosure::do_klass " PTR_FORMAT ", %s, dirty: %s", - p2i(klass), - klass->external_name(), - klass->has_modified_oops() ? "true" : "false"); - } + log_develop_trace(gc, scavenge)("PSScavengeKlassClosure::do_klass " PTR_FORMAT ", %s, dirty: %s", + p2i(klass), + klass->external_name(), + klass->has_modified_oops() ? "true" : "false"); #endif if (klass->has_modified_oops()) { --- old/src/share/vm/gc/parallel/psVirtualspace.cpp 2015-12-01 12:06:18.502930462 +0100 +++ new/src/share/vm/gc/parallel/psVirtualspace.cpp 2015-12-01 12:06:18.414930466 +0100 @@ -213,20 +213,6 @@ } } -void PSVirtualSpace::print() const { - gclog_or_tty->print_cr("virtual space [" PTR_FORMAT "]: alignment=" - SIZE_FORMAT "K grows %s%s", - p2i(this), alignment() / K, grows_up() ? "up" : "down", - special() ? " (pinned in memory)" : ""); - gclog_or_tty->print_cr(" reserved=" SIZE_FORMAT "K" - " [" PTR_FORMAT "," PTR_FORMAT "]" - " committed=" SIZE_FORMAT "K" - " [" PTR_FORMAT "," PTR_FORMAT "]", - reserved_size() / K, - p2i(reserved_low_addr()), p2i(reserved_high_addr()), - committed_size() / K, - p2i(committed_low_addr()), p2i(committed_high_addr())); -} #endif // #ifndef PRODUCT void PSVirtualSpace::print_space_boundaries_on(outputStream* st) const { --- old/src/share/vm/gc/parallel/psVirtualspace.hpp 2015-12-01 12:06:18.690930456 +0100 +++ new/src/share/vm/gc/parallel/psVirtualspace.hpp 2015-12-01 12:06:18.586930460 +0100 @@ -96,7 +96,6 @@ bool is_aligned(size_t val) const; bool is_aligned(char* val) const; void verify() const; - void print() const; virtual bool grows_up() const { return true; } bool grows_down() const { return !grows_up(); } --- old/src/share/vm/gc/parallel/psYoungGen.cpp 2015-12-01 12:06:18.886930449 +0100 +++ new/src/share/vm/gc/parallel/psYoungGen.cpp 2015-12-01 12:06:18.774930453 +0100 @@ -30,6 +30,7 @@ #include "gc/parallel/psYoungGen.hpp" #include "gc/shared/gcUtil.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" @@ -268,14 +269,12 @@ space_invariants(); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("Young generation size: " - "desired eden: " SIZE_FORMAT " survivor: " SIZE_FORMAT - " used: " SIZE_FORMAT " capacity: " SIZE_FORMAT - " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT, - eden_size, survivor_size, used_in_bytes(), capacity_in_bytes(), - _max_gen_size, min_gen_size()); - } + log_trace(gc, ergo)("Young generation size: " + "desired eden: " SIZE_FORMAT " survivor: " SIZE_FORMAT + " used: " SIZE_FORMAT " capacity: " SIZE_FORMAT + " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT, + eden_size, survivor_size, used_in_bytes(), capacity_in_bytes(), + _max_gen_size, min_gen_size()); } } @@ -330,26 +329,17 @@ size_changed = true; } } else { - if (Verbose && PrintGC) { - if (orig_size == gen_size_limit()) { - gclog_or_tty->print_cr("PSYoung generation size at maximum: " - SIZE_FORMAT "K", orig_size/K); - } else if (orig_size == min_gen_size()) { - gclog_or_tty->print_cr("PSYoung generation size at minium: " - SIZE_FORMAT "K", orig_size/K); - } + if (orig_size == gen_size_limit()) { + log_trace(gc)("PSYoung generation size at maximum: " SIZE_FORMAT "K", orig_size/K); + } else if (orig_size == min_gen_size()) { + log_trace(gc)("PSYoung generation size at minium: " SIZE_FORMAT "K", orig_size/K); } } if (size_changed) { post_resize(); - - if (Verbose && PrintGC) { - size_t current_size = virtual_space()->committed_size(); - gclog_or_tty->print_cr("PSYoung generation size changed: " - SIZE_FORMAT "K->" SIZE_FORMAT "K", - orig_size/K, current_size/K); - } + log_trace(gc)("PSYoung generation size changed: " SIZE_FORMAT "K->" SIZE_FORMAT "K", + orig_size/K, virtual_space()->committed_size()/K); } guarantee(eden_plus_survivors <= virtual_space()->committed_size() || @@ -412,28 +402,25 @@ s2->mangle_region(delta2_right); } - if (TraceZapUnusedHeapArea) { - // s1 - gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") " - "New region: [" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(s1->bottom()), p2i(s1->end()), - p2i(s1MR.start()), p2i(s1MR.end())); - gclog_or_tty->print_cr(" Mangle before: [" PTR_FORMAT ", " - PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(delta1_left.start()), p2i(delta1_left.end()), - p2i(delta1_right.start()), p2i(delta1_right.end())); - - // s2 - gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") " - "New region: [" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(s2->bottom()), p2i(s2->end()), - p2i(s2MR.start()), p2i(s2MR.end())); - gclog_or_tty->print_cr(" Mangle before: [" PTR_FORMAT ", " - PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")", - p2i(delta2_left.start()), p2i(delta2_left.end()), - p2i(delta2_right.start()), p2i(delta2_right.end())); - } - + // s1 + log_develop_trace(gc)("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") " + "New region: [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(s1->bottom()), p2i(s1->end()), + p2i(s1MR.start()), p2i(s1MR.end())); + log_develop_trace(gc)(" Mangle before: [" PTR_FORMAT ", " + PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(delta1_left.start()), p2i(delta1_left.end()), + p2i(delta1_right.start()), p2i(delta1_right.end())); + + // s2 + log_develop_trace(gc)("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") " + "New region: [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(s2->bottom()), p2i(s2->end()), + p2i(s2MR.start()), p2i(s2MR.end())); + log_develop_trace(gc)(" Mangle before: [" PTR_FORMAT ", " + PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")", + p2i(delta2_left.start()), p2i(delta2_left.end()), + p2i(delta2_right.start()), p2i(delta2_right.end())); } #endif // NOT PRODUCT @@ -448,41 +435,32 @@ return; } - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr("PSYoungGen::resize_spaces(requested_eden_size: " - SIZE_FORMAT - ", requested_survivor_size: " SIZE_FORMAT ")", - requested_eden_size, requested_survivor_size); - gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(eden_space()->bottom()), - p2i(eden_space()->end()), - pointer_delta(eden_space()->end(), - eden_space()->bottom(), - sizeof(char))); - gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(from_space()->bottom()), - p2i(from_space()->end()), - pointer_delta(from_space()->end(), - from_space()->bottom(), - sizeof(char))); - gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") " - SIZE_FORMAT, - p2i(to_space()->bottom()), - p2i(to_space()->end()), - pointer_delta( to_space()->end(), - to_space()->bottom(), - sizeof(char))); - } + log_trace(gc, ergo)("PSYoungGen::resize_spaces(requested_eden_size: " SIZE_FORMAT ", requested_survivor_size: " SIZE_FORMAT ")", + requested_eden_size, requested_survivor_size); + log_trace(gc, ergo)(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT, + p2i(eden_space()->bottom()), + p2i(eden_space()->end()), + pointer_delta(eden_space()->end(), + eden_space()->bottom(), + sizeof(char))); + log_trace(gc, ergo)(" from: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT, + p2i(from_space()->bottom()), + p2i(from_space()->end()), + pointer_delta(from_space()->end(), + from_space()->bottom(), + sizeof(char))); + log_trace(gc, ergo)(" to: [" PTR_FORMAT ".." PTR_FORMAT ") " SIZE_FORMAT, + p2i(to_space()->bottom()), + p2i(to_space()->end()), + pointer_delta( to_space()->end(), + to_space()->bottom(), + sizeof(char))); // There's nothing to do if the new sizes are the same as the current if (requested_survivor_size == to_space()->capacity_in_bytes() && requested_survivor_size == from_space()->capacity_in_bytes() && requested_eden_size == eden_space()->capacity_in_bytes()) { - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" capacities are the right sizes, returning"); - } + log_trace(gc, ergo)(" capacities are the right sizes, returning"); return; } @@ -503,9 +481,7 @@ if (eden_from_to_order) { // Eden, from, to eden_from_to_order = true; - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" Eden, from, to:"); - } + log_trace(gc, ergo)(" Eden, from, to:"); // Set eden // "requested_eden_size" is a goal for the size of eden @@ -566,28 +542,21 @@ guarantee(to_start != to_end, "to space is zero sized"); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" [eden_start .. eden_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(eden_start), - p2i(eden_end), - pointer_delta(eden_end, eden_start, sizeof(char))); - gclog_or_tty->print_cr(" [from_start .. from_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(from_start), - p2i(from_end), - pointer_delta(from_end, from_start, sizeof(char))); - gclog_or_tty->print_cr(" [ to_start .. to_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(to_start), - p2i(to_end), - pointer_delta( to_end, to_start, sizeof(char))); - } + log_trace(gc, ergo)(" [eden_start .. eden_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(eden_start), + p2i(eden_end), + pointer_delta(eden_end, eden_start, sizeof(char))); + log_trace(gc, ergo)(" [from_start .. from_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(from_start), + p2i(from_end), + pointer_delta(from_end, from_start, sizeof(char))); + log_trace(gc, ergo)(" [ to_start .. to_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(to_start), + p2i(to_end), + pointer_delta( to_end, to_start, sizeof(char))); } else { // Eden, to, from - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" Eden, to, from:"); - } + log_trace(gc, ergo)(" Eden, to, from:"); // To space gets priority over eden resizing. Note that we position // to space as if we were able to resize from space, even though from @@ -623,23 +592,18 @@ eden_end = MAX2(eden_end, eden_start + alignment); to_start = MAX2(to_start, eden_end); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print_cr(" [eden_start .. eden_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(eden_start), - p2i(eden_end), - pointer_delta(eden_end, eden_start, sizeof(char))); - gclog_or_tty->print_cr(" [ to_start .. to_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(to_start), - p2i(to_end), - pointer_delta( to_end, to_start, sizeof(char))); - gclog_or_tty->print_cr(" [from_start .. from_end): " - "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, - p2i(from_start), - p2i(from_end), - pointer_delta(from_end, from_start, sizeof(char))); - } + log_trace(gc, ergo)(" [eden_start .. eden_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(eden_start), + p2i(eden_end), + pointer_delta(eden_end, eden_start, sizeof(char))); + log_trace(gc, ergo)(" [ to_start .. to_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(to_start), + p2i(to_end), + pointer_delta( to_end, to_start, sizeof(char))); + log_trace(gc, ergo)(" [from_start .. from_end): [" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT, + p2i(from_start), + p2i(from_end), + pointer_delta(from_end, from_start, sizeof(char))); } @@ -658,7 +622,7 @@ // Let's make sure the call to initialize doesn't reset "top"! HeapWord* old_from_top = from_space()->top(); - // For PrintAdaptiveSizePolicy block below + // For logging block below size_t old_from = from_space()->capacity_in_bytes(); size_t old_to = to_space()->capacity_in_bytes(); @@ -704,18 +668,11 @@ assert(from_space()->top() == old_from_top, "from top changed!"); - if (PrintAdaptiveSizePolicy) { - ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); - gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: " - "collection: %d " - "(" SIZE_FORMAT ", " SIZE_FORMAT ") -> " - "(" SIZE_FORMAT ", " SIZE_FORMAT ") ", - heap->total_collections(), - old_from, old_to, - from_space()->capacity_in_bytes(), - to_space()->capacity_in_bytes()); - gclog_or_tty->cr(); - } + log_trace(gc, ergo)("AdaptiveSizePolicy::survivor space sizes: collection: %d (" SIZE_FORMAT ", " SIZE_FORMAT ") -> (" SIZE_FORMAT ", " SIZE_FORMAT ") ", + ParallelScavengeHeap::heap()->total_collections(), + old_from, old_to, + from_space()->capacity_in_bytes(), + to_space()->capacity_in_bytes()); } void PSYoungGen::swap_spaces() { @@ -794,13 +751,8 @@ void PSYoungGen::print() const { print_on(tty); } void PSYoungGen::print_on(outputStream* st) const { st->print(" %-15s", "PSYoungGen"); - if (PrintGCDetails && Verbose) { - st->print(" total " SIZE_FORMAT ", used " SIZE_FORMAT, - capacity_in_bytes(), used_in_bytes()); - } else { - st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", - capacity_in_bytes()/K, used_in_bytes()/K); - } + st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", + capacity_in_bytes()/K, used_in_bytes()/K); virtual_space()->print_space_boundaries_on(st); st->print(" eden"); eden_space()->print_on(st); st->print(" from"); from_space()->print_on(st); @@ -809,13 +761,8 @@ // Note that a space is not printed before the [NAME: void PSYoungGen::print_used_change(size_t prev_used) const { - gclog_or_tty->print("[%s:", name()); - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_used / K, used_in_bytes() / K, - capacity_in_bytes() / K); - gclog_or_tty->print("]"); + log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + name(), prev_used / K, used_in_bytes() / K, capacity_in_bytes() / K); } size_t PSYoungGen::available_for_expansion() { --- old/src/share/vm/gc/serial/defNewGeneration.cpp 2015-12-01 12:06:19.094930442 +0100 +++ new/src/share/vm/gc/serial/defNewGeneration.cpp 2015-12-01 12:06:18.982930446 +0100 @@ -31,7 +31,7 @@ #include "gc/shared/gcPolicyCounters.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/generationSpec.hpp" @@ -39,6 +39,7 @@ #include "gc/shared/space.inline.hpp" #include "gc/shared/spaceDecorator.hpp" #include "gc/shared/strongRootsScope.hpp" +#include "logging/log.hpp" #include "memory/iterator.hpp" #include "oops/instanceRefKlass.hpp" #include "oops/oop.inline.hpp" @@ -135,13 +136,11 @@ void KlassScanClosure::do_klass(Klass* klass) { #ifndef PRODUCT - if (TraceScavenge) { ResourceMark rm; - gclog_or_tty->print_cr("KlassScanClosure::do_klass " PTR_FORMAT ", %s, dirty: %s", - p2i(klass), - klass->external_name(), - klass->has_modified_oops() ? "true" : "false"); - } + log_develop_trace(gc, scavenge)("KlassScanClosure::do_klass " PTR_FORMAT ", %s, dirty: %s", + p2i(klass), + klass->external_name(), + klass->has_modified_oops() ? "true" : "false"); #endif // If the klass has not been dirtied we know that there's @@ -361,10 +360,7 @@ // but the second succeeds and expands the heap to its maximum // value. if (GC_locker::is_active()) { - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("Garbage collection disabled, " - "expanded heap instead"); - } + log_debug(gc)("Garbage collection disabled, expanded heap instead"); } return success; @@ -431,22 +427,15 @@ MemRegion cmr((HeapWord*)_virtual_space.low(), (HeapWord*)_virtual_space.high()); gch->barrier_set()->resize_covered_region(cmr); - if (Verbose && PrintGC) { - size_t new_size_after = _virtual_space.committed_size(); - size_t eden_size_after = eden()->capacity(); - size_t survivor_size_after = from()->capacity(); - gclog_or_tty->print("New generation size " SIZE_FORMAT "K->" - SIZE_FORMAT "K [eden=" - SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]", - new_size_before/K, new_size_after/K, - eden_size_after/K, survivor_size_after/K); - if (WizardMode) { - gclog_or_tty->print("[allowed " SIZE_FORMAT "K extra for %d threads]", + + log_debug(gc, heap, ergo)( + "New generation size " SIZE_FORMAT "K->" SIZE_FORMAT "K [eden=" SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]", + new_size_before/K, _virtual_space.committed_size()/K, + eden()->capacity()/K, from()->capacity()/K); + log_trace(gc, heap, ergo)( + " [allowed " SIZE_FORMAT "K extra for %d threads]", thread_increase_size/K, threads_count); } - gclog_or_tty->cr(); - } - } } void DefNewGeneration::younger_refs_iterate(OopsInGenClosure* cl, uint n_threads) { @@ -509,34 +498,27 @@ // The last collection bailed out, we are running out of heap space, // so we try to allocate the from-space, too. HeapWord* DefNewGeneration::allocate_from_space(size_t size) { + bool should_try_alloc = should_allocate_from_space() || GC_locker::is_active_and_needs_gc(); + + // If the Heap_lock is not locked by this thread, this will be called + // again later with the Heap_lock held. + bool do_alloc = should_try_alloc && (Heap_lock->owned_by_self() || (SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread())); + HeapWord* result = NULL; - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("DefNewGeneration::allocate_from_space(" SIZE_FORMAT "):" - " will_fail: %s" - " heap_lock: %s" - " free: " SIZE_FORMAT, + if (do_alloc) { + result = from()->allocate(size); + } + + log_trace(gc, alloc)("DefNewGeneration::allocate_from_space(" SIZE_FORMAT "): will_fail: %s heap_lock: %s free: " SIZE_FORMAT "%s%s returns %s", size, GenCollectedHeap::heap()->incremental_collection_will_fail(false /* don't consult_young */) ? "true" : "false", Heap_lock->is_locked() ? "locked" : "unlocked", - from()->free()); - } - if (should_allocate_from_space() || GC_locker::is_active_and_needs_gc()) { - if (Heap_lock->owned_by_self() || - (SafepointSynchronize::is_at_safepoint() && - Thread::current()->is_VM_thread())) { - // If the Heap_lock is not locked by this thread, this will be called - // again later with the Heap_lock held. - result = from()->allocate(size); - } else if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" Heap_lock is not owned by self"); - } - } else if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" should_allocate_from_space: NOT"); - } - if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" returns %s", result == NULL ? "NULL" : "object"); - } + from()->free(), + should_try_alloc ? "" : " should_allocate_from_space: NOT", + do_alloc ? " Heap_lock is not owned by self" : "", + result == NULL ? "NULL" : "object"); + return result; } @@ -572,9 +554,7 @@ // from this generation, pass on collection; let the next generation // do it. if (!collection_attempt_is_safe()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print(" :: Collection attempt not safe :: "); - } + log_trace(gc)(":: Collection attempt not safe ::"); gch->set_incremental_collection_failed(); // Slight lie: we did not even attempt one return; } @@ -582,9 +562,7 @@ init_assuming_no_promotion_failure(); - GCTraceTime t1(GCCauseString("GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL); - // Capture heap used before collection (for printing). - size_t gch_prev_used = gch->used(); + GCTraceTime(Trace, gc) tm("DefNew", NULL, gch->gc_cause()); gch->trace_heap_before_gc(&gc_tracer); @@ -679,9 +657,7 @@ _promo_failure_scan_stack.clear(true); // Clear cached segments. remove_forwarding_pointers(); - if (PrintGCDetails) { - gclog_or_tty->print(" (promotion failed) "); - } + log_debug(gc)("Promotion failed"); // Add to-space to the list of space to compact // when a promotion failure has occurred. In that // case there can be live objects in to-space @@ -698,9 +674,6 @@ // Reset the PromotionFailureALot counters. NOT_PRODUCT(gch->reset_promotion_should_fail();) } - if (PrintGC && !PrintGCDetails) { - gch->print_heap_change(gch_prev_used); - } // set new iteration safe limit for the survivor spaces from()->set_concurrent_iteration_safe_limit(from()->top()); to()->set_concurrent_iteration_safe_limit(to()->top()); @@ -762,10 +735,8 @@ } void DefNewGeneration::handle_promotion_failure(oop old) { - if (PrintPromotionFailure && !_promotion_failed) { - gclog_or_tty->print(" (promotion failure size = %d) ", - old->size()); - } + log_debug(gc, promotion)("Promotion failure size = %d) ", old->size()); + _promotion_failed = true; _promotion_failed_info.register_copy_failure(old->size()); preserve_mark_if_necessary(old, old->mark()); @@ -897,9 +868,7 @@ bool DefNewGeneration::collection_attempt_is_safe() { if (!to()->is_empty()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print(" :: to is not empty :: "); - } + log_trace(gc)(":: to is not empty ::"); return false; } if (_old_gen == NULL) { @@ -921,17 +890,13 @@ if (full) { DEBUG_ONLY(seen_incremental_collection_failed = false;) if (!collection_attempt_is_safe() && !_eden_space->is_empty()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("DefNewEpilogue: cause(%s), full, not safe, set_failed, set_alloc_from, clear_seen", + log_trace(gc)("DefNewEpilogue: cause(%s), full, not safe, set_failed, set_alloc_from, clear_seen", GCCause::to_string(gch->gc_cause())); - } gch->set_incremental_collection_failed(); // Slight lie: a full gc left us in that state set_should_allocate_from_space(); // we seem to be running out of space } else { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("DefNewEpilogue: cause(%s), full, safe, clear_failed, clear_alloc_from, clear_seen", + log_trace(gc)("DefNewEpilogue: cause(%s), full, safe, clear_failed, clear_alloc_from, clear_seen", GCCause::to_string(gch->gc_cause())); - } gch->clear_incremental_collection_failed(); // We just did a full collection clear_should_allocate_from_space(); // if set } @@ -945,16 +910,12 @@ // a full collection in between. if (!seen_incremental_collection_failed && gch->incremental_collection_failed()) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("DefNewEpilogue: cause(%s), not full, not_seen_failed, failed, set_seen_failed", + log_trace(gc)("DefNewEpilogue: cause(%s), not full, not_seen_failed, failed, set_seen_failed", GCCause::to_string(gch->gc_cause())); - } seen_incremental_collection_failed = true; } else if (seen_incremental_collection_failed) { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print("DefNewEpilogue: cause(%s), not full, seen_failed, will_clear_seen_failed", + log_trace(gc)("DefNewEpilogue: cause(%s), not full, seen_failed, will_clear_seen_failed", GCCause::to_string(gch->gc_cause())); - } assert(gch->gc_cause() == GCCause::_scavenge_alot || (GCCause::is_user_requested_gc(gch->gc_cause()) && UseConcMarkSweepGC && ExplicitGCInvokesConcurrent) || !gch->incremental_collection_failed(), --- old/src/share/vm/gc/serial/defNewGeneration.hpp 2015-12-01 12:06:19.298930435 +0100 +++ new/src/share/vm/gc/serial/defNewGeneration.hpp 2015-12-01 12:06:19.182930439 +0100 @@ -339,7 +339,6 @@ virtual const char* name() const; virtual const char* short_name() const { return "DefNew"; } - // PrintHeapAtGC support. void print_on(outputStream* st) const; void verify(); --- old/src/share/vm/gc/serial/genMarkSweep.cpp 2015-12-01 12:06:19.470930429 +0100 +++ new/src/share/vm/gc/serial/genMarkSweep.cpp 2015-12-01 12:06:19.370930432 +0100 @@ -34,7 +34,7 @@ #include "gc/shared/gcHeapSummary.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/generation.hpp" #include "gc/shared/genOopClosures.inline.hpp" @@ -70,8 +70,6 @@ set_ref_processor(rp); rp->setup_policy(clear_all_softrefs); - GCTraceTime t1(GCCauseString("Full GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL); - gch->trace_heap_before_gc(_gc_tracer); // When collecting the permanent generation Method*s may be moving, @@ -81,9 +79,6 @@ // Increment the invocation count _total_invocations++; - // Capture heap size before collection for printing. - size_t gch_prev_used = gch->used(); - // Capture used regions for each generation that will be // subject to collection, so that card table adjustments can // be made intelligently (see clear / invalidate further below). @@ -133,10 +128,6 @@ CodeCache::gc_epilogue(); JvmtiExport::gc_epilogue(); - if (PrintGC && !PrintGCDetails) { - gch->print_heap_change(gch_prev_used); - } - // refs processing: clean slate set_ref_processor(NULL); @@ -188,7 +179,7 @@ void GenMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) { // Recursively traverse all live objects and mark them - GCTraceTime tm("phase 1", PrintGC && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 1: Mark live objects", _gc_timer); GenCollectedHeap* gch = GenCollectedHeap::heap(); @@ -261,7 +252,7 @@ GenCollectedHeap* gch = GenCollectedHeap::heap(); - GCTraceTime tm("phase 2", PrintGC && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 2: Compute new object addresses", _gc_timer); gch->prepare_for_compaction(); } @@ -277,7 +268,7 @@ GenCollectedHeap* gch = GenCollectedHeap::heap(); // Adjust the pointers to reflect the new locations - GCTraceTime tm("phase 3", PrintGC && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 3: Adjust pointers", _gc_timer); // Need new claim bits for the pointer adjustment tracing. ClassLoaderDataGraph::clear_claimed_marks(); @@ -329,7 +320,7 @@ // to use a higher index (saved from phase2) when verifying perm_gen. GenCollectedHeap* gch = GenCollectedHeap::heap(); - GCTraceTime tm("phase 4", PrintGC && Verbose, true, _gc_timer); + GCTraceTime(Trace, gc) tm("Phase 4: Move objects", _gc_timer); GenCompactClosure blk; gch->generation_iterate(&blk, true); --- old/src/share/vm/gc/serial/markSweep.cpp 2015-12-01 12:06:19.658930422 +0100 +++ new/src/share/vm/gc/serial/markSweep.cpp 2015-12-01 12:06:19.546930426 +0100 @@ -250,10 +250,7 @@ void MarkSweep::restore_marks() { assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), "inconsistent preserved oop stacks"); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks", - _preserved_count + _preserved_oop_stack.size()); - } + log_trace(gc)("Restoring " SIZE_FORMAT " marks", _preserved_count + _preserved_oop_stack.size()); // restore the marks we saved earlier for (size_t i = 0; i < _preserved_count; i++) { @@ -305,20 +302,13 @@ T* referent_addr, T* next_addr, T* discovered_addr) { - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj)); - gclog_or_tty->print_cr(" referent_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(referent_addr), - p2i(referent_addr ? - (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL)); - gclog_or_tty->print_cr(" next_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(next_addr), - p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL)); - gclog_or_tty->print_cr(" discovered_addr/* " PTR_FORMAT " / " - PTR_FORMAT, p2i(discovered_addr), - p2i(discovered_addr ? - (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL)); - } + log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj)); + log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(referent_addr), p2i(referent_addr ? (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL)); + log_develop_trace(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(next_addr), p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL)); + log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT, + p2i(discovered_addr), p2i(discovered_addr ? (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL)); } #endif --- old/src/share/vm/gc/serial/tenuredGeneration.cpp 2015-12-01 12:06:19.846930416 +0100 +++ new/src/share/vm/gc/serial/tenuredGeneration.cpp 2015-12-01 12:06:19.730930420 +0100 @@ -32,6 +32,7 @@ #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/generationSpec.hpp" #include "gc/shared/space.hpp" +#include "logging/log.hpp" #include "memory/allocation.inline.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" @@ -81,42 +82,28 @@ // why it returns what it returns (without re-evaluating the conditionals // in case they aren't idempotent), so I'm doing it this way. // DeMorgan says it's okay. - bool result = false; - if (!result && full) { - result = true; - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("TenuredGeneration::should_collect: because" - " full"); - } - } - if (!result && should_allocate(size, is_tlab)) { - result = true; - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("TenuredGeneration::should_collect: because" - " should_allocate(" SIZE_FORMAT ")", - size); - } + if (full) { + log_trace(gc)("TenuredGeneration::should_collect: because full"); + return true; + } + if (should_allocate(size, is_tlab)) { + log_trace(gc)("TenuredGeneration::should_collect: because should_allocate(" SIZE_FORMAT ")", size); + return true; } // If we don't have very much free space. // XXX: 10000 should be a percentage of the capacity!!! - if (!result && free() < 10000) { - result = true; - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("TenuredGeneration::should_collect: because" - " free(): " SIZE_FORMAT, - free()); - } + if (free() < 10000) { + log_trace(gc)("TenuredGeneration::should_collect: because free(): " SIZE_FORMAT, free()); + return true; } // If we had to expand to accommodate promotions from the young generation - if (!result && _capacity_at_prologue < capacity()) { - result = true; - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("TenuredGeneration::should_collect: because" - "_capacity_at_prologue: " SIZE_FORMAT " < capacity(): " SIZE_FORMAT, - _capacity_at_prologue, capacity()); - } + if (_capacity_at_prologue < capacity()) { + log_trace(gc)("TenuredGeneration::should_collect: because_capacity_at_prologue: " SIZE_FORMAT " < capacity(): " SIZE_FORMAT, + _capacity_at_prologue, capacity()); + return true; } - return result; + + return false; } void TenuredGeneration::compute_new_size() { @@ -165,13 +152,10 @@ size_t available = max_contiguous_available(); size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average(); bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr( - "Tenured: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT ")," - "max_promo(" SIZE_FORMAT ")", - res? "":" not", available, res? ">=":"<", - av_promo, max_promotion_in_bytes); - } + + log_trace(gc)("Tenured: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "), max_promo(" SIZE_FORMAT ")", + res? "":" not", available, res? ">=":"<", av_promo, max_promotion_in_bytes); + return res; } --- old/src/share/vm/gc/shared/adaptiveSizePolicy.cpp 2015-12-01 12:06:20.042930409 +0100 +++ new/src/share/vm/gc/shared/adaptiveSizePolicy.cpp 2015-12-01 12:06:19.926930413 +0100 @@ -27,6 +27,7 @@ #include "gc/shared/collectorPolicy.hpp" #include "gc/shared/gcCause.hpp" #include "gc/shared/workgroup.hpp" +#include "logging/log.hpp" #include "runtime/timer.hpp" #include "utilities/ostream.hpp" elapsedTimer AdaptiveSizePolicy::_minor_timer; @@ -166,14 +167,12 @@ "Jiggled active workers too much"); } - if (TraceDynamicGCThreads) { - gclog_or_tty->print_cr("GCTaskManager::calc_default_active_workers() : " - "active_workers(): " UINTX_FORMAT " new_active_workers: " UINTX_FORMAT " " - "prev_active_workers: " UINTX_FORMAT "\n" - " active_workers_by_JT: " UINTX_FORMAT " active_workers_by_heap_size: " UINTX_FORMAT, - active_workers, new_active_workers, prev_active_workers, - active_workers_by_JT, active_workers_by_heap_size); - } + log_trace(gc, task)("GCTaskManager::calc_default_active_workers() : " + "active_workers(): " UINTX_FORMAT " new_active_workers: " UINTX_FORMAT " " + "prev_active_workers: " UINTX_FORMAT "\n" + " active_workers_by_JT: " UINTX_FORMAT " active_workers_by_heap_size: " UINTX_FORMAT, + active_workers, new_active_workers, prev_active_workers, + active_workers_by_JT, active_workers_by_heap_size); assert(new_active_workers > 0, "Always need at least 1"); return new_active_workers; } @@ -275,14 +274,10 @@ update_minor_pause_young_estimator(minor_pause_in_ms); update_minor_pause_old_estimator(minor_pause_in_ms); - if (PrintAdaptiveSizePolicy && Verbose) { - gclog_or_tty->print("AdaptiveSizePolicy::minor_collection_end: " - "minor gc cost: %f average: %f", collection_cost, - _avg_minor_gc_cost->average()); - gclog_or_tty->print_cr(" minor pause: %f minor period %f", - minor_pause_in_ms, - _latest_minor_mutator_interval_seconds * MILLIUNITS); - } + log_trace(gc, ergo)("AdaptiveSizePolicy::minor_collection_end: minor gc cost: %f average: %f", + collection_cost, _avg_minor_gc_cost->average()); + log_trace(gc, ergo)(" minor pause: %f minor period %f", + minor_pause_in_ms, _latest_minor_mutator_interval_seconds * MILLIUNITS); // Calculate variable used to estimate collection cost vs. gen sizes assert(collection_cost >= 0.0, "Expected to be non-negative"); @@ -388,13 +383,10 @@ // Decay using the time-since-last-major-gc decayed_major_gc_cost = decaying_major_gc_cost(); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("\ndecaying_gc_cost: major interval average:" - " %f time since last major gc: %f", - avg_major_interval, time_since_last_major_gc); - gclog_or_tty->print_cr(" major gc cost: %f decayed major gc cost: %f", - major_gc_cost(), decayed_major_gc_cost); - } + log_trace(gc, ergo)("decaying_gc_cost: major interval average: %f time since last major gc: %f", + avg_major_interval, time_since_last_major_gc); + log_trace(gc, ergo)(" major gc cost: %f decayed major gc cost: %f", + major_gc_cost(), decayed_major_gc_cost); } } double result = MIN2(1.0, decayed_major_gc_cost + minor_gc_cost()); @@ -461,21 +453,17 @@ promo_limit = MAX2(promo_limit, _promo_size); - if (PrintAdaptiveSizePolicy && (Verbose || - (free_in_old_gen < (size_t) mem_free_old_limit && - free_in_eden < (size_t) mem_free_eden_limit))) { - gclog_or_tty->print_cr( - "PSAdaptiveSizePolicy::check_gc_overhead_limit:" - " promo_limit: " SIZE_FORMAT - " max_eden_size: " SIZE_FORMAT - " total_free_limit: " SIZE_FORMAT - " max_old_gen_size: " SIZE_FORMAT - " max_eden_size: " SIZE_FORMAT - " mem_free_limit: " SIZE_FORMAT, - promo_limit, max_eden_size, total_free_limit, - max_old_gen_size, max_eden_size, - (size_t) mem_free_limit); - } + log_trace(gc, ergo)( + "PSAdaptiveSizePolicy::check_gc_overhead_limit:" + " promo_limit: " SIZE_FORMAT + " max_eden_size: " SIZE_FORMAT + " total_free_limit: " SIZE_FORMAT + " max_old_gen_size: " SIZE_FORMAT + " max_eden_size: " SIZE_FORMAT + " mem_free_limit: " SIZE_FORMAT, + promo_limit, max_eden_size, total_free_limit, + max_old_gen_size, max_eden_size, + (size_t) mem_free_limit); bool print_gc_overhead_limit_would_be_exceeded = false; if (is_full_gc) { @@ -521,10 +509,7 @@ bool near_limit = gc_overhead_limit_near(); if (near_limit) { collector_policy->set_should_clear_all_soft_refs(true); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" Nearing GC overhead limit, " - "will be clearing all SoftReference"); - } + log_trace(gc, ergo)("Nearing GC overhead limit, will be clearing all SoftReference"); } } } @@ -540,26 +525,25 @@ } } - if (UseGCOverheadLimit && PrintGCDetails && Verbose) { + if (UseGCOverheadLimit) { if (gc_overhead_limit_exceeded()) { - gclog_or_tty->print_cr(" GC is exceeding overhead limit " - "of " UINTX_FORMAT "%%", GCTimeLimit); + log_trace(gc, ergo)("GC is exceeding overhead limit of " UINTX_FORMAT "%%", GCTimeLimit); reset_gc_overhead_limit_count(); } else if (print_gc_overhead_limit_would_be_exceeded) { assert(gc_overhead_limit_count() > 0, "Should not be printing"); - gclog_or_tty->print_cr(" GC would exceed overhead limit " - "of " UINTX_FORMAT "%% %d consecutive time(s)", - GCTimeLimit, gc_overhead_limit_count()); + log_trace(gc, ergo)("GC would exceed overhead limit of " UINTX_FORMAT "%% %d consecutive time(s)", + GCTimeLimit, gc_overhead_limit_count()); } } } // Printing -bool AdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st) const { +bool AdaptiveSizePolicy::print() const { + assert(UseAdaptiveSizePolicy, "UseAdaptiveSizePolicy need to be enabled."); - // Should only be used with adaptive size policy turned on. - // Otherwise, there may be variables that are undefined. - if (!UseAdaptiveSizePolicy) return false; + if (!log_is_enabled(Debug, gc, ergo)) { + return false; + } // Print goal for which action is needed. char* action = NULL; @@ -627,41 +611,24 @@ tenured_gen_action = shrink_msg; } - st->print_cr(" UseAdaptiveSizePolicy actions to meet %s", action); - st->print_cr(" GC overhead (%%)"); - st->print_cr(" Young generation: %7.2f\t %s", - 100.0 * avg_minor_gc_cost()->average(), - young_gen_action); - st->print_cr(" Tenured generation: %7.2f\t %s", - 100.0 * avg_major_gc_cost()->average(), - tenured_gen_action); + log_debug(gc, ergo)("UseAdaptiveSizePolicy actions to meet %s", action); + log_debug(gc, ergo)(" GC overhead (%%)"); + log_debug(gc, ergo)(" Young generation: %7.2f\t %s", + 100.0 * avg_minor_gc_cost()->average(), young_gen_action); + log_debug(gc, ergo)(" Tenured generation: %7.2f\t %s", + 100.0 * avg_major_gc_cost()->average(), tenured_gen_action); return true; } -bool AdaptiveSizePolicy::print_adaptive_size_policy_on( - outputStream* st, - uint tenuring_threshold_arg) const { - if (!AdaptiveSizePolicy::print_adaptive_size_policy_on(st)) { - return false; - } - +void AdaptiveSizePolicy::print_tenuring_threshold( uint new_tenuring_threshold_arg) const { // Tenuring threshold - bool tenuring_threshold_changed = true; if (decrement_tenuring_threshold_for_survivor_limit()) { - st->print(" Tenuring threshold: (attempted to decrease to avoid" - " survivor space overflow) = "); + log_debug(gc, ergo)("Tenuring threshold: (attempted to decrease to avoid survivor space overflow) = %u", new_tenuring_threshold_arg); } else if (decrement_tenuring_threshold_for_gc_cost()) { - st->print(" Tenuring threshold: (attempted to decrease to balance" - " GC costs) = "); + log_debug(gc, ergo)("Tenuring threshold: (attempted to decrease to balance GC costs) = %u", new_tenuring_threshold_arg); } else if (increment_tenuring_threshold_for_gc_cost()) { - st->print(" Tenuring threshold: (attempted to increase to balance" - " GC costs) = "); + log_debug(gc, ergo)("Tenuring threshold: (attempted to increase to balance GC costs) = %u", new_tenuring_threshold_arg); } else { - tenuring_threshold_changed = false; assert(!tenuring_threshold_change(), "(no change was attempted)"); } - if (tenuring_threshold_changed) { - st->print_cr("%u", tenuring_threshold_arg); - } - return true; } --- old/src/share/vm/gc/shared/adaptiveSizePolicy.hpp 2015-12-01 12:06:20.234930402 +0100 +++ new/src/share/vm/gc/shared/adaptiveSizePolicy.hpp 2015-12-01 12:06:20.118930406 +0100 @@ -28,6 +28,7 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/gcCause.hpp" #include "gc/shared/gcUtil.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/universe.hpp" @@ -500,9 +501,8 @@ } // Printing support - virtual bool print_adaptive_size_policy_on(outputStream* st) const; - bool print_adaptive_size_policy_on(outputStream* st, - uint tenuring_threshold) const; + virtual bool print() const; + void print_tenuring_threshold(uint new_tenuring_threshold) const; }; // Class that can be used to print information about the @@ -510,46 +510,26 @@ // AdaptiveSizePolicyOutputInterval. Only print information // if an adaptive size policy is in use. class AdaptiveSizePolicyOutput : StackObj { - AdaptiveSizePolicy* _size_policy; - bool _do_print; - bool print_test(uint count) { - // A count of zero is a special value that indicates that the - // interval test should be ignored. An interval is of zero is - // a special value that indicates that the interval test should - // always fail (never do the print based on the interval test). - return PrintGCDetails && + static bool enabled() { + return UseParallelGC && UseAdaptiveSizePolicy && - UseParallelGC && - (AdaptiveSizePolicyOutputInterval > 0) && - ((count == 0) || - ((count % AdaptiveSizePolicyOutputInterval) == 0)); + log_is_enabled(Debug, gc, ergo); } public: - // The special value of a zero count can be used to ignore - // the count test. - AdaptiveSizePolicyOutput(uint count) { - if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) { - CollectedHeap* heap = Universe::heap(); - _size_policy = heap->size_policy(); - _do_print = print_test(count); - } else { - _size_policy = NULL; - _do_print = false; + static void print() { + if (enabled()) { + Universe::heap()->size_policy()->print(); } } - AdaptiveSizePolicyOutput(AdaptiveSizePolicy* size_policy, - uint count) : - _size_policy(size_policy) { - if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) { - _do_print = print_test(count); - } else { - _do_print = false; - } - } - ~AdaptiveSizePolicyOutput() { - if (_do_print) { - assert(UseAdaptiveSizePolicy, "Should not be in use"); - _size_policy->print_adaptive_size_policy_on(gclog_or_tty); + + static void print(AdaptiveSizePolicy* size_policy, uint count) { + bool do_print = + enabled() && + (AdaptiveSizePolicyOutputInterval > 0) && + (count % AdaptiveSizePolicyOutputInterval) == 0; + + if (do_print) { + size_policy->print(); } } }; --- old/src/share/vm/gc/shared/ageTable.cpp 2015-12-01 12:06:20.438930395 +0100 +++ new/src/share/vm/gc/shared/ageTable.cpp 2015-12-01 12:06:20.322930399 +0100 @@ -28,6 +28,7 @@ #include "gc/shared/collectorPolicy.hpp" #include "gc/shared/gcPolicyCounters.hpp" #include "memory/resourceArea.hpp" +#include "logging/log.hpp" #include "utilities/copy.hpp" /* Copyright (c) 1992, 2015, Oracle and/or its affiliates, and Stanford University. @@ -94,24 +95,18 @@ result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold; } - if (PrintTenuringDistribution || UsePerfData) { - if (PrintTenuringDistribution) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold " - UINTX_FORMAT " (max threshold " UINTX_FORMAT ")", - desired_survivor_size*oopSize, (uintx) result, MaxTenuringThreshold); - } + log_debug(gc, age)("Desired survivor size " SIZE_FORMAT " bytes, new threshold " UINTX_FORMAT " (max threshold " UINTX_FORMAT ")", + desired_survivor_size*oopSize, (uintx) result, MaxTenuringThreshold); + if (log_is_enabled(Trace, gc, age) || UsePerfData) { size_t total = 0; uint age = 1; while (age < table_size) { total += sizes[age]; if (sizes[age] > 0) { - if (PrintTenuringDistribution) { - gclog_or_tty->print_cr("- age %3u: " SIZE_FORMAT_W(10) " bytes, " SIZE_FORMAT_W(10) " total", - age, sizes[age]*oopSize, total*oopSize); - } + log_trace(gc, age)("- age %3u: " SIZE_FORMAT_W(10) " bytes, " SIZE_FORMAT_W(10) " total", + age, sizes[age]*oopSize, total*oopSize); } if (UsePerfData) { _perf_sizes[age]->set_value(sizes[age]*oopSize); --- old/src/share/vm/gc/shared/blockOffsetTable.cpp 2015-12-01 12:06:20.646930388 +0100 +++ new/src/share/vm/gc/shared/blockOffsetTable.cpp 2015-12-01 12:06:20.522930392 +0100 @@ -28,6 +28,7 @@ #include "gc/shared/space.inline.hpp" #include "memory/iterator.hpp" #include "memory/universe.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" #include "services/memTracker.hpp" @@ -53,19 +54,11 @@ } _offset_array = (u_char*)_vs.low_boundary(); resize(init_word_size); - if (TraceBlockOffsetTable) { - gclog_or_tty->print_cr("BlockOffsetSharedArray::BlockOffsetSharedArray: "); - gclog_or_tty->print_cr(" " - " rs.base(): " INTPTR_FORMAT - " rs.size(): " INTPTR_FORMAT - " rs end(): " INTPTR_FORMAT, - p2i(rs.base()), rs.size(), p2i(rs.base() + rs.size())); - gclog_or_tty->print_cr(" " - " _vs.low_boundary(): " INTPTR_FORMAT - " _vs.high_boundary(): " INTPTR_FORMAT, - p2i(_vs.low_boundary()), - p2i(_vs.high_boundary())); - } + log_trace(gc, bot)("BlockOffsetSharedArray::BlockOffsetSharedArray: "); + log_trace(gc, bot)(" rs.base(): " INTPTR_FORMAT " rs.size(): " INTPTR_FORMAT " rs end(): " INTPTR_FORMAT, + p2i(rs.base()), rs.size(), p2i(rs.base() + rs.size())); + log_trace(gc, bot)(" _vs.low_boundary(): " INTPTR_FORMAT " _vs.high_boundary(): " INTPTR_FORMAT, + p2i(_vs.low_boundary()), p2i(_vs.high_boundary())); } void BlockOffsetSharedArray::resize(size_t new_word_size) { --- old/src/share/vm/gc/shared/cardGeneration.cpp 2015-12-01 12:06:20.854930381 +0100 +++ new/src/share/vm/gc/shared/cardGeneration.cpp 2015-12-01 12:06:20.734930385 +0100 @@ -33,6 +33,7 @@ #include "gc/shared/space.inline.hpp" #include "memory/iterator.hpp" #include "memory/memRegion.hpp" +#include "logging/log.hpp" #include "runtime/java.hpp" CardGeneration::CardGeneration(ReservedSpace rs, @@ -96,13 +97,10 @@ // update the space and generation capacity counters update_counters(); - if (Verbose && PrintGC) { - size_t new_mem_size = _virtual_space.committed_size(); - size_t old_mem_size = new_mem_size - bytes; - gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by " - SIZE_FORMAT "K to " SIZE_FORMAT "K", - name(), old_mem_size/K, bytes/K, new_mem_size/K); - } + size_t new_mem_size = _virtual_space.committed_size(); + size_t old_mem_size = new_mem_size - bytes; + log_trace(gc, heap)("Expanding %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K", + name(), old_mem_size/K, bytes/K, new_mem_size/K); } return result; } @@ -133,10 +131,8 @@ if (!success) { success = grow_to_reserved(); } - if (PrintGC && Verbose) { - if (success && GC_locker::is_active_and_needs_gc()) { - gclog_or_tty->print_cr("Garbage collection disabled, expanded heap instead"); - } + if (success && GC_locker::is_active_and_needs_gc()) { + log_trace(gc, heap)("Garbage collection disabled, expanded heap instead"); } return success; @@ -172,12 +168,10 @@ // Shrink the card table GenCollectedHeap::heap()->barrier_set()->resize_covered_region(mr); - if (Verbose && PrintGC) { - size_t new_mem_size = _virtual_space.committed_size(); - size_t old_mem_size = new_mem_size + size; - gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K to " SIZE_FORMAT "K", - name(), old_mem_size/K, new_mem_size/K); - } + size_t new_mem_size = _virtual_space.committed_size(); + size_t old_mem_size = new_mem_size + size; + log_trace(gc, heap)("Shrinking %s from " SIZE_FORMAT "K to " SIZE_FORMAT "K", + name(), old_mem_size/K, new_mem_size/K); } // No young generation references, clear this generation's cards. @@ -211,26 +205,17 @@ minimum_desired_capacity = MAX2(minimum_desired_capacity, initial_size()); assert(used_after_gc <= minimum_desired_capacity, "sanity check"); - if (PrintGC && Verbose) { const size_t free_after_gc = free(); const double free_percentage = ((double)free_after_gc) / capacity_after_gc; - gclog_or_tty->print_cr("TenuredGeneration::compute_new_size: "); - gclog_or_tty->print_cr(" " - " minimum_free_percentage: %6.2f" - " maximum_used_percentage: %6.2f", + log_trace(gc, heap)("TenuredGeneration::compute_new_size:"); + log_trace(gc, heap)(" minimum_free_percentage: %6.2f maximum_used_percentage: %6.2f", minimum_free_percentage, maximum_used_percentage); - gclog_or_tty->print_cr(" " - " free_after_gc : %6.1fK" - " used_after_gc : %6.1fK" - " capacity_after_gc : %6.1fK", + log_trace(gc, heap)(" free_after_gc : %6.1fK used_after_gc : %6.1fK capacity_after_gc : %6.1fK", free_after_gc / (double) K, used_after_gc / (double) K, capacity_after_gc / (double) K); - gclog_or_tty->print_cr(" " - " free_percentage: %6.2f", - free_percentage); - } + log_trace(gc, heap)(" free_percentage: %6.2f", free_percentage); if (capacity_after_gc < minimum_desired_capacity) { // If we have less free space than we want then expand @@ -239,15 +224,10 @@ if (expand_bytes >= _min_heap_delta_bytes) { expand(expand_bytes, 0); // safe if expansion fails } - if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" expanding:" - " minimum_desired_capacity: %6.1fK" - " expand_bytes: %6.1fK" - " _min_heap_delta_bytes: %6.1fK", - minimum_desired_capacity / (double) K, - expand_bytes / (double) K, - _min_heap_delta_bytes / (double) K); - } + log_trace(gc, heap)(" expanding: minimum_desired_capacity: %6.1fK expand_bytes: %6.1fK _min_heap_delta_bytes: %6.1fK", + minimum_desired_capacity / (double) K, + expand_bytes / (double) K, + _min_heap_delta_bytes / (double) K); return; } @@ -262,20 +242,12 @@ const double max_tmp = used_after_gc / minimum_used_percentage; size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx)); maximum_desired_capacity = MAX2(maximum_desired_capacity, initial_size()); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" " - " maximum_free_percentage: %6.2f" - " minimum_used_percentage: %6.2f", - maximum_free_percentage, - minimum_used_percentage); - gclog_or_tty->print_cr(" " - " _capacity_at_prologue: %6.1fK" - " minimum_desired_capacity: %6.1fK" - " maximum_desired_capacity: %6.1fK", + log_trace(gc, heap)(" maximum_free_percentage: %6.2f minimum_used_percentage: %6.2f", + maximum_free_percentage, minimum_used_percentage); + log_trace(gc, heap)(" _capacity_at_prologue: %6.1fK minimum_desired_capacity: %6.1fK maximum_desired_capacity: %6.1fK", _capacity_at_prologue / (double) K, minimum_desired_capacity / (double) K, maximum_desired_capacity / (double) K); - } assert(minimum_desired_capacity <= maximum_desired_capacity, "sanity check"); @@ -295,23 +267,13 @@ } else { _shrink_factor = MIN2(current_shrink_factor * 4, (size_t) 100); } - if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" " - " shrinking:" - " initSize: %.1fK" - " maximum_desired_capacity: %.1fK", - initial_size() / (double) K, - maximum_desired_capacity / (double) K); - gclog_or_tty->print_cr(" " - " shrink_bytes: %.1fK" - " current_shrink_factor: " SIZE_FORMAT - " new shrink factor: " SIZE_FORMAT - " _min_heap_delta_bytes: %.1fK", + log_trace(gc, heap)(" shrinking: initSize: %.1fK maximum_desired_capacity: %.1fK", + initial_size() / (double) K, maximum_desired_capacity / (double) K); + log_trace(gc, heap)(" shrink_bytes: %.1fK current_shrink_factor: " SIZE_FORMAT " new shrink factor: " SIZE_FORMAT " _min_heap_delta_bytes: %.1fK", shrink_bytes / (double) K, current_shrink_factor, _shrink_factor, _min_heap_delta_bytes / (double) K); - } } } @@ -324,18 +286,11 @@ // We have two shrinking computations, take the largest shrink_bytes = MAX2(shrink_bytes, expansion_for_promotion); assert(shrink_bytes <= max_shrink_bytes, "invalid shrink size"); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr(" " - " aggressive shrinking:" - " _capacity_at_prologue: %.1fK" - " capacity_after_gc: %.1fK" - " expansion_for_promotion: %.1fK" - " shrink_bytes: %.1fK", - capacity_after_gc / (double) K, - _capacity_at_prologue / (double) K, - expansion_for_promotion / (double) K, - shrink_bytes / (double) K); - } + log_trace(gc, heap)(" aggressive shrinking: _capacity_at_prologue: %.1fK capacity_after_gc: %.1fK expansion_for_promotion: %.1fK shrink_bytes: %.1fK", + capacity_after_gc / (double) K, + _capacity_at_prologue / (double) K, + expansion_for_promotion / (double) K, + shrink_bytes / (double) K); } // Don't shrink unless it's significant if (shrink_bytes >= _min_heap_delta_bytes) { --- old/src/share/vm/gc/shared/cardTableModRefBS.cpp 2015-12-01 12:06:21.034930374 +0100 +++ new/src/share/vm/gc/shared/cardTableModRefBS.cpp 2015-12-01 12:06:20.918930378 +0100 @@ -28,6 +28,7 @@ #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/space.inline.hpp" #include "memory/virtualspace.hpp" +#include "logging/log.hpp" #include "services/memTracker.hpp" #include "utilities/macros.hpp" @@ -115,17 +116,10 @@ !ExecMem, "card table last card"); *guard_card = last_card; - if (TraceCardTableModRefBS) { - gclog_or_tty->print_cr("CardTableModRefBS::CardTableModRefBS: "); - gclog_or_tty->print_cr(" " - " &_byte_map[0]: " INTPTR_FORMAT - " &_byte_map[_last_valid_index]: " INTPTR_FORMAT, - p2i(&_byte_map[0]), - p2i(&_byte_map[_last_valid_index])); - gclog_or_tty->print_cr(" " - " byte_map_base: " INTPTR_FORMAT, - p2i(byte_map_base)); - } + log_trace(gc, barrier)("CardTableModRefBS::CardTableModRefBS: "); + log_trace(gc, barrier)(" &_byte_map[0]: " INTPTR_FORMAT " &_byte_map[_last_valid_index]: " INTPTR_FORMAT, + p2i(&_byte_map[0]), p2i(&_byte_map[_last_valid_index])); + log_trace(gc, barrier)(" byte_map_base: " INTPTR_FORMAT, p2i(byte_map_base)); } CardTableModRefBS::~CardTableModRefBS() { @@ -350,29 +344,17 @@ } // In any case, the covered size changes. _covered[ind].set_word_size(new_region.word_size()); - if (TraceCardTableModRefBS) { - gclog_or_tty->print_cr("CardTableModRefBS::resize_covered_region: "); - gclog_or_tty->print_cr(" " - " _covered[%d].start(): " INTPTR_FORMAT - " _covered[%d].last(): " INTPTR_FORMAT, - ind, p2i(_covered[ind].start()), - ind, p2i(_covered[ind].last())); - gclog_or_tty->print_cr(" " - " _committed[%d].start(): " INTPTR_FORMAT - " _committed[%d].last(): " INTPTR_FORMAT, - ind, p2i(_committed[ind].start()), - ind, p2i(_committed[ind].last())); - gclog_or_tty->print_cr(" " - " byte_for(start): " INTPTR_FORMAT - " byte_for(last): " INTPTR_FORMAT, - p2i(byte_for(_covered[ind].start())), - p2i(byte_for(_covered[ind].last()))); - gclog_or_tty->print_cr(" " - " addr_for(start): " INTPTR_FORMAT - " addr_for(last): " INTPTR_FORMAT, - p2i(addr_for((jbyte*) _committed[ind].start())), - p2i(addr_for((jbyte*) _committed[ind].last()))); - } + + log_trace(gc, barrier)("CardTableModRefBS::resize_covered_region: "); + log_trace(gc, barrier)(" _covered[%d].start(): " INTPTR_FORMAT " _covered[%d].last(): " INTPTR_FORMAT, + ind, p2i(_covered[ind].start()), ind, p2i(_covered[ind].last())); + log_trace(gc, barrier)(" _committed[%d].start(): " INTPTR_FORMAT " _committed[%d].last(): " INTPTR_FORMAT, + ind, p2i(_committed[ind].start()), ind, p2i(_committed[ind].last())); + log_trace(gc, barrier)(" byte_for(start): " INTPTR_FORMAT " byte_for(last): " INTPTR_FORMAT, + p2i(byte_for(_covered[ind].start())), p2i(byte_for(_covered[ind].last()))); + log_trace(gc, barrier)(" addr_for(start): " INTPTR_FORMAT " addr_for(last): " INTPTR_FORMAT, + p2i(addr_for((jbyte*) _committed[ind].start())), p2i(addr_for((jbyte*) _committed[ind].last()))); + // Touch the last card of the covered region to show that it // is committed (or SEGV). debug_only((void) (*byte_for(_covered[ind].last()));) --- old/src/share/vm/gc/shared/collectedHeap.cpp 2015-12-01 12:06:21.242930367 +0100 +++ new/src/share/vm/gc/shared/collectedHeap.cpp 2015-12-01 12:06:21.126930371 +0100 @@ -30,9 +30,10 @@ #include "gc/shared/collectedHeap.inline.hpp" #include "gc/shared/gcHeapSummary.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/gcWhen.hpp" #include "gc/shared/vmGCOperations.hpp" +#include "logging/log.hpp" #include "memory/metaspace.hpp" #include "oops/instanceMirrorKlass.hpp" #include "oops/oop.inline.hpp" @@ -53,7 +54,7 @@ st->print_raw(m); } -void GCHeapLog::log_heap(bool before) { +void GCHeapLog::log_heap(CollectedHeap* heap, bool before) { if (!should_log()) { return; } @@ -65,11 +66,14 @@ _records[index].timestamp = timestamp; _records[index].data.is_before = before; stringStream st(_records[index].data.buffer(), _records[index].data.size()); - if (before) { - Universe::print_heap_before_gc(&st, true); - } else { - Universe::print_heap_after_gc(&st, true); - } + + st.print_cr("{Heap %s GC invocations=%u (full %u):", + before ? "before" : "after", + heap->total_collections(), + heap->total_full_collections()); + + heap->print_on(&st); + st.print_cr("}"); } VirtualSpaceSummary CollectedHeap::create_heap_space_summary() { @@ -108,20 +112,16 @@ } void CollectedHeap::print_heap_before_gc() { - if (PrintHeapAtGC) { - Universe::print_heap_before_gc(); - } + Universe::print_heap_before_gc(); if (_gc_heap_log != NULL) { - _gc_heap_log->log_heap_before(); + _gc_heap_log->log_heap_before(this); } } void CollectedHeap::print_heap_after_gc() { - if (PrintHeapAtGC) { - Universe::print_heap_after_gc(); - } + Universe::print_heap_after_gc(); if (_gc_heap_log != NULL) { - _gc_heap_log->log_heap_after(); + _gc_heap_log->log_heap_after(this); } } @@ -571,34 +571,30 @@ } } -void CollectedHeap::pre_full_gc_dump(GCTimer* timer) { - if (HeapDumpBeforeFullGC) { +void CollectedHeap::full_gc_dump(GCTimer* timer, const char* when) { + if (HeapDumpBeforeFullGC || HeapDumpAfterFullGC) { GCIdMarkAndRestore gc_id_mark; - GCTraceTime tt("Heap Dump (before full gc): ", PrintGCDetails, false, timer); - // We are doing a full collection and a heap dump before - // full collection has been requested. + FormatBuffer<> title("Heap Dump (%s full gc)", when); + GCTraceTime(Info, gc) tm(title.buffer(), timer); HeapDumper::dump_heap(); } - if (PrintClassHistogramBeforeFullGC) { + LogHandle(gc, classhisto) log; + if (log.is_trace()) { + ResourceMark rm; GCIdMarkAndRestore gc_id_mark; - GCTraceTime tt("Class Histogram (before full gc): ", PrintGCDetails, true, timer); - VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */); + FormatBuffer<> title("Class Histogram (%s full gc)", when); + GCTraceTime(Trace, gc, classhisto) tm(title.buffer(), timer); + VM_GC_HeapInspection inspector(log.trace_stream(), false /* ! full gc */); inspector.doit(); } } +void CollectedHeap::pre_full_gc_dump(GCTimer* timer) { + full_gc_dump(timer, "before"); +} + void CollectedHeap::post_full_gc_dump(GCTimer* timer) { - if (HeapDumpAfterFullGC) { - GCIdMarkAndRestore gc_id_mark; - GCTraceTime tt("Heap Dump (after full gc): ", PrintGCDetails, false, timer); - HeapDumper::dump_heap(); - } - if (PrintClassHistogramAfterFullGC) { - GCIdMarkAndRestore gc_id_mark; - GCTraceTime tt("Class Histogram (after full gc): ", PrintGCDetails, true, timer); - VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */); - inspector.doit(); - } + full_gc_dump(timer, "after"); } void CollectedHeap::initialize_reserved_region(HeapWord *start, HeapWord *end) { --- old/src/share/vm/gc/shared/collectedHeap.hpp 2015-12-01 12:06:21.450930360 +0100 +++ new/src/share/vm/gc/shared/collectedHeap.hpp 2015-12-01 12:06:21.334930364 +0100 @@ -58,18 +58,20 @@ GCMessage() {} }; +class CollectedHeap; + class GCHeapLog : public EventLogBase { private: - void log_heap(bool before); + void log_heap(CollectedHeap* heap, bool before); public: GCHeapLog() : EventLogBase("GC Heap History") {} - void log_heap_before() { - log_heap(true); + void log_heap_before(CollectedHeap* heap) { + log_heap(heap, true); } - void log_heap_after() { - log_heap(false); + void log_heap_after(CollectedHeap* heap) { + log_heap(heap, false); } }; @@ -195,6 +197,8 @@ virtual Name kind() const = 0; + virtual const char* name() const = 0; + /** * Returns JNI error code JNI_ENOMEM if memory could not be allocated, * and JNI_OK on success. @@ -519,6 +523,9 @@ virtual void prepare_for_verify() = 0; // Generate any dumps preceding or following a full gc + private: + void full_gc_dump(GCTimer* timer, const char* when); + public: void pre_full_gc_dump(GCTimer* timer); void post_full_gc_dump(GCTimer* timer); @@ -569,7 +576,7 @@ void trace_heap_after_gc(const GCTracer* gc_tracer); // Heap verification - virtual void verify(bool silent, VerifyOption option) = 0; + virtual void verify(VerifyOption option) = 0; // Non product verification and debugging. #ifndef PRODUCT --- old/src/share/vm/gc/shared/collectorPolicy.cpp 2015-12-01 12:06:21.658930353 +0100 +++ new/src/share/vm/gc/shared/collectorPolicy.cpp 2015-12-01 12:06:21.538930357 +0100 @@ -32,6 +32,7 @@ #include "gc/shared/generationSpec.hpp" #include "gc/shared/space.hpp" #include "gc/shared/vmGCOperations.hpp" +#include "logging/log.hpp" #include "memory/universe.hpp" #include "runtime/arguments.hpp" #include "runtime/globals_extension.hpp" @@ -137,11 +138,8 @@ } void CollectorPolicy::initialize_size_info() { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " - SIZE_FORMAT " Maximum heap " SIZE_FORMAT, - _min_heap_byte_size, _initial_heap_byte_size, _max_heap_byte_size); - } + log_debug(gc, heap)("Minimum heap " SIZE_FORMAT " Initial heap " SIZE_FORMAT " Maximum heap " SIZE_FORMAT, + _min_heap_byte_size, _initial_heap_byte_size, _max_heap_byte_size); DEBUG_ONLY(CollectorPolicy::assert_size_info();) } @@ -488,11 +486,8 @@ } } - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("1: Minimum young " SIZE_FORMAT " Initial young " - SIZE_FORMAT " Maximum young " SIZE_FORMAT, - _min_young_size, _initial_young_size, _max_young_size); - } + log_trace(gc, heap)("1: Minimum young " SIZE_FORMAT " Initial young " SIZE_FORMAT " Maximum young " SIZE_FORMAT, + _min_young_size, _initial_young_size, _max_young_size); // At this point the minimum, initial and maximum sizes // of the overall heap and of the young generation have been determined. @@ -558,11 +553,8 @@ _initial_young_size = desired_young_size; } - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("2: Minimum young " SIZE_FORMAT " Initial young " - SIZE_FORMAT " Maximum young " SIZE_FORMAT, - _min_young_size, _initial_young_size, _max_young_size); - } + log_trace(heap)("2: Minimum young " SIZE_FORMAT " Initial young " SIZE_FORMAT " Maximum young " SIZE_FORMAT, + _min_young_size, _initial_young_size, _max_young_size); } // Write back to flags if necessary. @@ -578,11 +570,8 @@ FLAG_SET_ERGO(size_t, OldSize, _initial_old_size); } - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("Minimum old " SIZE_FORMAT " Initial old " - SIZE_FORMAT " Maximum old " SIZE_FORMAT, - _min_old_size, _initial_old_size, _max_old_size); - } + log_trace(heap)("Minimum old " SIZE_FORMAT " Initial old " SIZE_FORMAT " Maximum old " SIZE_FORMAT, + _min_old_size, _initial_old_size, _max_old_size); DEBUG_ONLY(GenCollectorPolicy::assert_size_info();) } @@ -620,10 +609,7 @@ uint gc_count_before; // Read inside the Heap_lock locked region. { MutexLocker ml(Heap_lock); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("GenCollectorPolicy::mem_allocate_work:" - " attempting locked slow path allocation"); - } + log_trace(gc, alloc)("GenCollectorPolicy::mem_allocate_work: attempting locked slow path allocation"); // Note that only large objects get a shot at being // allocated in later generations. bool first_only = ! should_try_older_generation_allocation(size); @@ -757,9 +743,7 @@ is_tlab, // is_tlab GenCollectedHeap::OldGen); // max_generation } else { - if (Verbose && PrintGCDetails) { - gclog_or_tty->print(" :: Trying full because partial may fail :: "); - } + log_trace(gc)(" :: Trying full because partial may fail :: "); // Try a full collection; see delta for bug id 6266275 // for the original code and why this has been simplified // with from-space allocation criteria modified and --- old/src/share/vm/gc/shared/gcCause.hpp 2015-12-01 12:06:21.862930345 +0100 +++ new/src/share/vm/gc/shared/gcCause.hpp 2015-12-01 12:06:21.742930350 +0100 @@ -125,36 +125,4 @@ static const char* to_string(GCCause::Cause cause); }; -// Helper class for doing logging that includes the GC Cause -// as a string. -class GCCauseString : StackObj { - private: - static const int _length = 128; - char _buffer[_length]; - int _position; - - public: - GCCauseString(const char* prefix, GCCause::Cause cause) { - if (PrintGCCause) { - _position = jio_snprintf(_buffer, _length, "%s (%s) ", prefix, GCCause::to_string(cause)); - } else { - _position = jio_snprintf(_buffer, _length, "%s ", prefix); - } - assert(_position >= 0 && _position <= _length, - "Need to increase the buffer size in GCCauseString? %d", _position); - } - - GCCauseString& append(const char* str) { - int res = jio_snprintf(_buffer + _position, _length - _position, "%s", str); - _position += res; - assert(res >= 0 && _position <= _length, - "Need to increase the buffer size in GCCauseString? %d", res); - return *this; - } - - operator const char*() { - return _buffer; - } -}; - #endif // SHARE_VM_GC_SHARED_GCCAUSE_HPP --- old/src/share/vm/gc/shared/gcId.cpp 2015-12-01 12:06:22.046930339 +0100 +++ new/src/share/vm/gc/shared/gcId.cpp 2015-12-01 12:06:21.926930343 +0100 @@ -26,6 +26,7 @@ #include "gc/shared/gcId.hpp" #include "runtime/safepoint.hpp" #include "runtime/thread.inline.hpp" +#include "runtime/threadLocalStorage.hpp" uint GCId::_next_id = 0; @@ -47,6 +48,19 @@ return currentNamedthread()->gc_id(); } +size_t GCId::print_prefix(char* buf, size_t len) { + Thread* thread = ThreadLocalStorage::thread(); + if (thread != NULL && thread->is_Named_thread()) { + uint gc_id = current_raw(); + if (gc_id != undefined()) { + int ret = jio_snprintf(buf, len, "GC(%u) ", gc_id); + assert(ret > 0, "Failed to print prefix. Log buffer too small?"); + return (size_t)ret; + } + } + return 0; +} + GCIdMark::GCIdMark() : _gc_id(GCId::create()) { currentNamedthread()->set_gc_id(_gc_id); } --- old/src/share/vm/gc/shared/gcId.hpp 2015-12-01 12:06:22.230930333 +0100 +++ new/src/share/vm/gc/shared/gcId.hpp 2015-12-01 12:06:22.114930337 +0100 @@ -40,6 +40,7 @@ // Same as current() but can return undefined() if no GC id is currently active static const uint current_raw(); static const uint undefined() { return UNDEFINED; } + static size_t print_prefix(char* buf, size_t len); }; class GCIdMark : public StackObj { --- old/src/share/vm/gc/shared/gcLocker.cpp 2015-12-01 12:06:22.414930326 +0100 +++ new/src/share/vm/gc/shared/gcLocker.cpp 2015-12-01 12:06:22.298930330 +0100 @@ -26,6 +26,7 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "memory/resourceArea.hpp" +#include "logging/log.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/thread.inline.hpp" @@ -73,17 +74,20 @@ } #endif +void GC_locker::log_debug_jni(const char* msg) { + LogHandle(gc, jni) log; + if (log.is_debug()) { + ResourceMark rm; // JavaThread::name() allocates to convert to UTF8 + log.debug("%s Thread \"%s\" %d locked.", msg, Thread::current()->name(), _jni_lock_count); + } +} + bool GC_locker::check_active_before_gc() { assert(SafepointSynchronize::is_at_safepoint(), "only read at safepoint"); if (is_active() && !_needs_gc) { verify_critical_count(); _needs_gc = true; - if (PrintJNIGCStalls && PrintGCDetails) { - ResourceMark rm; // JavaThread::name() allocates to convert to UTF8 - gclog_or_tty->print_cr("%.3f: Setting _needs_gc. Thread \"%s\" %d locked.", - gclog_or_tty->time_stamp().seconds(), Thread::current()->name(), _jni_lock_count); - } - + log_debug_jni("Setting _needs_gc."); } return is_active(); } @@ -93,11 +97,7 @@ MutexLocker ml(JNICritical_lock); if (needs_gc()) { - if (PrintJNIGCStalls && PrintGCDetails) { - ResourceMark rm; // JavaThread::name() allocates to convert to UTF8 - gclog_or_tty->print_cr("%.3f: Allocation failed. Thread \"%s\" is stalled by JNI critical section, %d locked.", - gclog_or_tty->time_stamp().seconds(), Thread::current()->name(), _jni_lock_count); - } + log_debug_jni("Allocation failed. Thread stalled by JNI critical section."); } // Wait for _needs_gc to be cleared @@ -134,11 +134,7 @@ { // Must give up the lock while at a safepoint MutexUnlocker munlock(JNICritical_lock); - if (PrintJNIGCStalls && PrintGCDetails) { - ResourceMark rm; // JavaThread::name() allocates to convert to UTF8 - gclog_or_tty->print_cr("%.3f: Thread \"%s\" is performing GC after exiting critical section, %d locked", - gclog_or_tty->time_stamp().seconds(), Thread::current()->name(), _jni_lock_count); - } + log_debug_jni("Performing GC after exiting critical section."); Universe::heap()->collect(GCCause::_gc_locker); } _doing_gc = false; --- old/src/share/vm/gc/shared/gcLocker.hpp 2015-12-01 12:06:22.614930319 +0100 +++ new/src/share/vm/gc/shared/gcLocker.hpp 2015-12-01 12:06:22.490930324 +0100 @@ -64,6 +64,7 @@ return _jni_lock_count > 0; } + static void log_debug_jni(const char* msg); public: // Accessors static bool is_active() { --- old/src/share/vm/gc/shared/gcTraceTime.cpp 2015-12-01 12:06:22.822930312 +0100 +++ new/src/share/vm/gc/shared/gcTraceTime.cpp 2015-12-01 12:06:22.706930316 +0100 @@ -23,57 +23,38 @@ */ #include "precompiled.hpp" -#include "gc/shared/gcTimer.hpp" -#include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" -#include "runtime/globals.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" +#include "logging/log.hpp" #include "runtime/os.hpp" -#include "runtime/safepoint.hpp" -#include "runtime/thread.inline.hpp" -#include "runtime/timer.hpp" -#include "utilities/ostream.hpp" -#include "utilities/ticks.inline.hpp" - -GCTraceTimeImpl::GCTraceTimeImpl(const char* title, bool doit, bool print_cr, GCTimer* timer) : - _title(title), _doit(doit), _print_cr(print_cr), _timer(timer), _start_counter() { - if (_doit || _timer != NULL) { - _start_counter.stamp(); - } - - if (_timer != NULL) { - assert(SafepointSynchronize::is_at_safepoint(), "Tracing currently only supported at safepoints"); - assert(Thread::current()->is_VM_thread(), "Tracing currently only supported from the VM thread"); - - _timer->register_gc_phase_start(title, _start_counter); - } - - if (_doit) { - gclog_or_tty->gclog_stamp(); - gclog_or_tty->print("[%s", title); - gclog_or_tty->flush(); +GCTraceCPUTime::GCTraceCPUTime() : + _active(log_is_enabled(Info, gc, cpu)), + _starting_user_time(0.0), + _starting_system_time(0.0), + _starting_real_time(0.0) +{ + if (_active) { + bool valid = os::getTimesSecs(&_starting_real_time, + &_starting_user_time, + &_starting_system_time); + if (!valid) { + log_warning(gc, cpu)("TraceCPUTime: os::getTimesSecs() returned invalid result"); + _active = false; + } } } -GCTraceTimeImpl::~GCTraceTimeImpl() { - Ticks stop_counter; - - if (_doit || _timer != NULL) { - stop_counter.stamp(); - } - - if (_timer != NULL) { - _timer->register_gc_phase_end(stop_counter); - } - - if (_doit) { - const Tickspan duration = stop_counter - _start_counter; - double duration_in_seconds = TicksToTimeHelper::seconds(duration); - if (_print_cr) { - gclog_or_tty->print_cr(", %3.7f secs]", duration_in_seconds); +GCTraceCPUTime::~GCTraceCPUTime() { + if (_active) { + double real_time, user_time, system_time; + bool valid = os::getTimesSecs(&real_time, &user_time, &system_time); + if (valid) { + log_info(gc, cpu)("User=%3.2fs Sys=%3.2fs Real=%3.2fs", + user_time - _starting_user_time, + system_time - _starting_system_time, + real_time - _starting_real_time); } else { - gclog_or_tty->print(", %3.7f secs]", duration_in_seconds); + log_warning(gc, cpu)("TraceCPUTime: os::getTimesSecs() returned invalid result"); } - gclog_or_tty->flush(); } } --- old/src/share/vm/gc/shared/gcTraceTime.hpp 2015-12-01 12:06:23.014930305 +0100 +++ new/src/share/vm/gc/shared/gcTraceTime.hpp 2015-12-01 12:06:22.898930309 +0100 @@ -25,31 +25,55 @@ #ifndef SHARE_VM_GC_SHARED_GCTRACETIME_HPP #define SHARE_VM_GC_SHARED_GCTRACETIME_HPP -#include "gc/shared/gcTrace.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" -#include "prims/jni_md.h" #include "utilities/ticks.hpp" +class GCTraceCPUTime : public StackObj { + bool _active; // true if times will be measured and printed + double _starting_user_time; // user time at start of measurement + double _starting_system_time; // system time at start of measurement + double _starting_real_time; // real time at start of measurement + public: + GCTraceCPUTime(); + ~GCTraceCPUTime(); +}; + class GCTimer; -class GCTraceTimeImpl VALUE_OBJ_CLASS_SPEC { +template +class GCTraceTimeImpl : public StackObj { + private: + bool _enabled; + Ticks _start_ticks; const char* _title; - bool _doit; - bool _print_cr; + GCCause::Cause _gc_cause; GCTimer* _timer; - Ticks _start_counter; + size_t _heap_usage_before; + + void log_start(jlong start_counter); + void log_stop(jlong start_counter, jlong stop_counter); + void time_stamp(Ticks& ticks); public: - GCTraceTimeImpl(const char* title, bool doit, bool print_cr, GCTimer* timer); + GCTraceTimeImpl(const char* title, GCTimer* timer = NULL, GCCause::Cause gc_cause = GCCause::_no_gc, bool log_heap_usage = false); ~GCTraceTimeImpl(); }; -class GCTraceTime : public StackObj { - GCTraceTimeImpl _gc_trace_time_impl; - +// Similar to GCTraceTimeImpl but is intended for concurrent phase logging, +// which is a bit simpler and should always print the start line, i.e. not add the "start" tag. +template +class GCTraceConcTimeImpl : public StackObj { + private: + bool _enabled; + jlong _start_time; + const char* _title; public: - GCTraceTime(const char* title, bool doit, bool print_cr, GCTimer* timer) : - _gc_trace_time_impl(title, doit, print_cr, timer) {}; + GCTraceConcTimeImpl(const char* title); + ~GCTraceConcTimeImpl(); + jlong start_time() { return _start_time; } }; #endif // SHARE_VM_GC_SHARED_GCTRACETIME_HPP --- old/src/share/vm/gc/shared/genCollectedHeap.cpp 2015-12-01 12:06:23.210930298 +0100 +++ new/src/share/vm/gc/shared/genCollectedHeap.cpp 2015-12-01 12:06:23.090930303 +0100 @@ -33,7 +33,7 @@ #include "gc/shared/gcId.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/gcTrace.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/genOopClosures.inline.hpp" #include "gc/shared/generationSpec.hpp" @@ -314,13 +314,11 @@ void GenCollectedHeap::collect_generation(Generation* gen, bool full, size_t size, bool is_tlab, bool run_verification, bool clear_soft_refs, bool restore_marks_for_biased_locking) { - // Timer for individual generations. Last argument is false: no CR - // FIXME: We should try to start the timing earlier to cover more of the GC pause - GCTraceTime t1(gen->short_name(), PrintGCDetails, false, NULL); + FormatBuffer<> title("Collect gen: %s", gen->short_name()); + GCTraceTime(Debug, gc) t1(title); TraceCollectorStats tcs(gen->counters()); TraceMemoryManagerStats tmms(gen->kind(),gc_cause()); - size_t prev_used = gen->used(); gen->stat_record()->invocations++; gen->stat_record()->accumulated_time.start(); @@ -329,24 +327,11 @@ // change top of some spaces. record_gen_tops_before_GC(); - if (PrintGC && Verbose) { - // I didn't want to change the logging when removing the level concept, - // but I guess this logging could say young/old or something instead of 0/1. - uint level; - if (heap()->is_young_gen(gen)) { - level = 0; - } else { - level = 1; - } - gclog_or_tty->print("level=%u invoke=%d size=" SIZE_FORMAT, - level, - gen->stat_record()->invocations, - size * HeapWordSize); - } + log_trace(gc)("%s invoke=%d size=" SIZE_FORMAT, heap()->is_young_gen(gen) ? "Young" : "Old", gen->stat_record()->invocations, size * HeapWordSize); if (run_verification && VerifyBeforeGC) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyBeforeGC:"); + Universe::verify("Before GC"); } COMPILER2_PRESENT(DerivedPointerTable::clear()); @@ -404,12 +389,7 @@ if (run_verification && VerifyAfterGC) { HandleMark hm; // Discard invalid handles created during verification - Universe::verify(" VerifyAfterGC:"); - } - - if (PrintGCDetails) { - gclog_or_tty->print(":"); - gen->print_heap_change(prev_used); + Universe::verify("After GC"); } } @@ -448,21 +428,31 @@ FlagSetting fl(_is_gc_active, true); bool complete = full && (max_generation == OldGen); - const char* gc_cause_prefix = complete ? "Full GC" : "GC"; - TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); - GCTraceTime t(GCCauseString(gc_cause_prefix, gc_cause()), PrintGCDetails, false, NULL); + bool old_collects_young = complete && !ScavengeBeforeFullGC; + bool do_young_collection = !old_collects_young && _young_gen->should_collect(full, size, is_tlab); + + FormatBuffer<> gc_string("%s", "Pause "); + if (do_young_collection) { + gc_string.append("Young"); + } else { + gc_string.append("Full"); + } + + GCTraceCPUTime tcpu; + GCTraceTime(Info, gc) t(gc_string, NULL, gc_cause(), true); gc_prologue(complete); increment_total_collections(complete); - size_t gch_prev_used = used(); + size_t young_prev_used = _young_gen->used(); + size_t old_prev_used = _old_gen->used(); + bool run_verification = total_collections() >= VerifyGCStartAt; bool prepared_for_verification = false; bool collected_old = false; - bool old_collects_young = complete && !ScavengeBeforeFullGC; - if (!old_collects_young && _young_gen->should_collect(full, size, is_tlab)) { + if (do_young_collection) { if (run_verification && VerifyGCLevel <= 0 && VerifyBeforeGC) { prepare_for_verify(); prepared_for_verification = true; @@ -487,7 +477,6 @@ bool must_restore_marks_for_biased_locking = false; if (max_generation == OldGen && _old_gen->should_collect(full, size, is_tlab)) { - GCIdMarkAndRestore gc_id_mark; if (!complete) { // The full_collections increment was missed above. increment_total_full_collections(); @@ -501,13 +490,16 @@ } assert(_old_gen->performs_in_place_marking(), "All old generations do in place marking"); - collect_generation(_old_gen, - full, - size, - is_tlab, - run_verification && VerifyGCLevel <= 1, - do_clear_all_soft_refs, - true); + + if (do_young_collection) { + // We did a young GC. Need a new GC id for the old GC. + GCIdMarkAndRestore gc_id_mark; + GCTraceTime(Info, gc) t("Pause Full", NULL, gc_cause(), true); + collect_generation(_old_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 1, do_clear_all_soft_refs, true); + } else { + // No young GC done. Use the same GC id as was set up earlier in this method. + collect_generation(_old_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 1, do_clear_all_soft_refs, true); + } must_restore_marks_for_biased_locking = true; collected_old = true; @@ -523,14 +515,8 @@ post_full_gc_dump(NULL); // do any post full gc dumps } - if (PrintGCDetails) { - print_heap_change(gch_prev_used); - - // Print metaspace info for full GC with PrintGCDetails flag. - if (complete) { - MetaspaceAux::print_metaspace_change(metadata_prev_used); - } - } + print_heap_change(young_prev_used, old_prev_used); + MetaspaceAux::print_metaspace_change(metadata_prev_used); // Adjust generation sizes. if (collected_old) { @@ -874,10 +860,7 @@ // been attempted and failed, because the old gen was too full if (local_last_generation == YoungGen && gc_cause() == GCCause::_gc_locker && incremental_collection_will_fail(false /* don't consult_young */)) { - if (PrintGCDetails) { - gclog_or_tty->print_cr("GC locker: Trying a full collection " - "because scavenge failed"); - } + log_debug(gc, jni)("GC locker: Trying a full collection because scavenge failed"); // This time allow the old gen to be collected as well do_collection(true, // full clear_all_soft_refs, // clear_all_soft_refs @@ -1106,22 +1089,14 @@ _young_gen->prepare_for_compaction(&cp); } -void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { - if (!silent) { - gclog_or_tty->print("%s", _old_gen->name()); - gclog_or_tty->print(" "); - } +void GenCollectedHeap::verify(VerifyOption option /* ignored */) { + log_debug(gc, verify)("%s", _old_gen->name()); _old_gen->verify(); - if (!silent) { - gclog_or_tty->print("%s", _young_gen->name()); - gclog_or_tty->print(" "); - } + log_debug(gc, verify)("%s", _old_gen->name()); _young_gen->verify(); - if (!silent) { - gclog_or_tty->print("remset "); - } + log_debug(gc, verify)("RemSet"); rem_set()->verify(); } @@ -1171,18 +1146,11 @@ } } -void GenCollectedHeap::print_heap_change(size_t prev_used) const { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" " SIZE_FORMAT - "->" SIZE_FORMAT - "(" SIZE_FORMAT ")", - prev_used, used(), capacity()); - } else { - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_used / K, used() / K, capacity() / K); - } +void GenCollectedHeap::print_heap_change(size_t young_prev_used, size_t old_prev_used) const { + log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + _young_gen->short_name(), young_prev_used / K, _young_gen->used() /K, _young_gen->capacity() /K); + log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + _old_gen->short_name(), old_prev_used / K, _old_gen->used() /K, _old_gen->capacity() /K); } class GenGCPrologueClosure: public GenCollectedHeap::GenClosure { --- old/src/share/vm/gc/shared/genCollectedHeap.hpp 2015-12-01 12:06:23.422930291 +0100 +++ new/src/share/vm/gc/shared/genCollectedHeap.hpp 2015-12-01 12:06:23.310930295 +0100 @@ -142,6 +142,14 @@ return CollectedHeap::GenCollectedHeap; } + virtual const char* name() const { + if (UseConcMarkSweepGC) { + return "Concurrent Mark Sweep"; + } else { + return "Serial"; + } + } + Generation* young_gen() const { return _young_gen; } Generation* old_gen() const { return _old_gen; } @@ -329,7 +337,7 @@ void prepare_for_verify(); // Override. - void verify(bool silent, VerifyOption option); + void verify(VerifyOption option); // Override. virtual void print_on(outputStream* st) const; @@ -338,8 +346,7 @@ virtual void print_tracing_info() const; virtual void print_on_error(outputStream* st) const; - // PrintGC, PrintGCDetails support - void print_heap_change(size_t prev_used) const; + void print_heap_change(size_t young_prev_used, size_t old_prev_used) const; // The functions below are helper functions that a subclass of // "CollectedHeap" can use in the implementation of its virtual --- old/src/share/vm/gc/shared/generation.cpp 2015-12-01 12:06:23.622930284 +0100 +++ new/src/share/vm/gc/shared/generation.cpp 2015-12-01 12:06:23.506930288 +0100 @@ -36,6 +36,7 @@ #include "gc/shared/generation.hpp" #include "gc/shared/space.inline.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "memory/allocation.inline.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" @@ -70,20 +71,6 @@ return reserved().byte_size(); } -void Generation::print_heap_change(size_t prev_used) const { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" " SIZE_FORMAT - "->" SIZE_FORMAT - "(" SIZE_FORMAT ")", - prev_used, used(), capacity()); - } else { - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_used / K, used() / K, capacity() / K); - } -} - // By default we get a single threaded default reference processor; // generations needing multi-threaded refs processing or discovery override this method. void Generation::ref_processor_init() { @@ -171,12 +158,8 @@ bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { size_t available = max_contiguous_available(); bool res = (available >= max_promotion_in_bytes); - if (PrintGC && Verbose) { - gclog_or_tty->print_cr( - "Generation: promo attempt is%s safe: available(" SIZE_FORMAT ") %s max_promo(" SIZE_FORMAT ")", - res? "":" not", available, res? ">=":"<", - max_promotion_in_bytes); - } + log_trace(gc)("Generation: promo attempt is%s safe: available(" SIZE_FORMAT ") %s max_promo(" SIZE_FORMAT ")", + res? "":" not", available, res? ">=":"<", max_promotion_in_bytes); return res; } --- old/src/share/vm/gc/shared/generation.hpp 2015-12-01 12:06:23.802930278 +0100 +++ new/src/share/vm/gc/shared/generation.hpp 2015-12-01 12:06:23.702930281 +0100 @@ -536,11 +536,8 @@ // the block is an object. virtual bool block_is_obj(const HeapWord* addr) const; - - // PrintGC, PrintGCDetails support void print_heap_change(size_t prev_used) const; - // PrintHeapAtGC support virtual void print() const; virtual void print_on(outputStream* st) const; --- old/src/share/vm/gc/shared/plab.cpp 2015-12-01 12:06:23.990930271 +0100 +++ new/src/share/vm/gc/shared/plab.cpp 2015-12-01 12:06:23.882930275 +0100 @@ -26,6 +26,7 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/plab.inline.hpp" #include "gc/shared/threadLocalAllocBuffer.hpp" +#include "logging/log.hpp" #include "oops/arrayOop.hpp" #include "oops/oop.inline.hpp" @@ -149,18 +150,8 @@ new_plab_sz = MIN2(max_size(), new_plab_sz); new_plab_sz = align_object_size(new_plab_sz); // Latch the result - if (PrintPLAB) { - gclog_or_tty->print(" (plab_sz = " SIZE_FORMAT " desired_net_plab_sz = " SIZE_FORMAT ") ", recent_plab_sz, new_plab_sz); - } + log_trace(gc, plab)("plab_size = " SIZE_FORMAT " desired_net_plab_sz = " SIZE_FORMAT ") ", recent_plab_sz, new_plab_sz); _desired_net_plab_sz = new_plab_sz; reset(); } - -#ifndef PRODUCT -void PLAB::print() { - gclog_or_tty->print_cr("PLAB: _bottom: " PTR_FORMAT " _top: " PTR_FORMAT - " _end: " PTR_FORMAT " _hard_end: " PTR_FORMAT ")", - p2i(_bottom), p2i(_top), p2i(_end), p2i(_hard_end)); -} -#endif // !PRODUCT --- old/src/share/vm/gc/shared/plab.hpp 2015-12-01 12:06:24.178930265 +0100 +++ new/src/share/vm/gc/shared/plab.hpp 2015-12-01 12:06:24.066930269 +0100 @@ -141,8 +141,6 @@ // Fills in the unallocated portion of the buffer with a garbage object and updates // statistics. To be called during GC. virtual void retire(); - - void print() PRODUCT_RETURN; }; // PLAB book-keeping. --- old/src/share/vm/gc/shared/referenceProcessor.cpp 2015-12-01 12:06:24.354930259 +0100 +++ new/src/share/vm/gc/shared/referenceProcessor.cpp 2015-12-01 12:06:24.254930262 +0100 @@ -28,9 +28,10 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/collectedHeap.inline.hpp" #include "gc/shared/gcTimer.hpp" -#include "gc/shared/gcTraceTime.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/referencePolicy.hpp" #include "gc/shared/referenceProcessor.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" @@ -186,21 +187,6 @@ return total; } -static void log_ref_count(size_t count, bool doit) { - if (doit) { - gclog_or_tty->print(", " SIZE_FORMAT " refs", count); - } -} - -class GCRefTraceTime : public StackObj { - GCTraceTimeImpl _gc_trace_time; - public: - GCRefTraceTime(const char* title, bool doit, GCTimer* timer, size_t count) : - _gc_trace_time(title, doit, false, timer) { - log_ref_count(count, doit); - } -}; - ReferenceProcessorStats ReferenceProcessor::process_discovered_references( BoolObjectClosure* is_alive, OopClosure* keep_alive, @@ -222,8 +208,6 @@ _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock(); - bool trace_time = PrintGCDetails && PrintReferenceGC; - // Include cleaners in phantom statistics. We expect Cleaner // references to be temporary, and don't want to deal with // possible incompatibilities arising from making it more visible. @@ -235,7 +219,7 @@ // Soft references { - GCRefTraceTime tt("SoftReference", trace_time, gc_timer, stats.soft_count()); + GCTraceTime(Debug, gc, ref) tt("SoftReference", gc_timer); process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true, is_alive, keep_alive, complete_gc, task_executor); } @@ -244,21 +228,21 @@ // Weak references { - GCRefTraceTime tt("WeakReference", trace_time, gc_timer, stats.weak_count()); + GCTraceTime(Debug, gc, ref) tt("WeakReference", gc_timer); process_discovered_reflist(_discoveredWeakRefs, NULL, true, is_alive, keep_alive, complete_gc, task_executor); } // Final references { - GCRefTraceTime tt("FinalReference", trace_time, gc_timer, stats.final_count()); + GCTraceTime(Debug, gc, ref) tt("FinalReference", gc_timer); process_discovered_reflist(_discoveredFinalRefs, NULL, false, is_alive, keep_alive, complete_gc, task_executor); } // Phantom references { - GCRefTraceTime tt("PhantomReference", trace_time, gc_timer, stats.phantom_count()); + GCTraceTime(Debug, gc, ref) tt("PhantomReference", gc_timer); process_discovered_reflist(_discoveredPhantomRefs, NULL, false, is_alive, keep_alive, complete_gc, task_executor); @@ -275,20 +259,23 @@ // thus use JNI weak references to circumvent the phantom references and // resurrect a "post-mortem" object. { - GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer); - NOT_PRODUCT(log_ref_count(count_jni_refs(), trace_time);) + GCTraceTime(Debug, gc, ref) tt("JNI Weak Reference", gc_timer); if (task_executor != NULL) { task_executor->set_single_threaded_mode(); } process_phaseJNI(is_alive, keep_alive, complete_gc); } + log_debug(gc, ref)("Ref Counts: Soft: " SIZE_FORMAT " Weak: " SIZE_FORMAT " Final: " SIZE_FORMAT " Phantom: " SIZE_FORMAT, + stats.soft_count(), stats.weak_count(), stats.final_count(), stats.phantom_count()); + log_develop_trace(gc, ref)("JNI Weak Reference count: " SIZE_FORMAT, count_jni_refs()); + return stats; } #ifndef PRODUCT // Calculate the number of jni handles. -uint ReferenceProcessor::count_jni_refs() { +size_t ReferenceProcessor::count_jni_refs() { class AlwaysAliveClosure: public BoolObjectClosure { public: virtual bool do_object_b(oop obj) { return true; } @@ -296,12 +283,12 @@ class CountHandleClosure: public OopClosure { private: - int _count; + size_t _count; public: CountHandleClosure(): _count(0) {} void do_oop(oop* unused) { _count++; } void do_oop(narrowOop* unused) { ShouldNotReachHere(); } - int count() { return _count; } + size_t count() { return _count; } }; CountHandleClosure global_handle_count; AlwaysAliveClosure always_alive; @@ -362,10 +349,7 @@ // all linked Reference objects. Note that it is important to not dirty any // cards during reference processing since this will cause card table // verification to fail for G1. - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list " - INTPTR_FORMAT, p2i(refs_list.head())); - } + log_develop_trace(gc, ref)("ReferenceProcessor::enqueue_discovered_reflist list " INTPTR_FORMAT, p2i(refs_list.head())); oop obj = NULL; oop next_d = refs_list.head(); @@ -376,10 +360,7 @@ assert(obj->is_instance(), "should be an instance object"); assert(InstanceKlass::cast(obj->klass())->is_reference_instance_klass(), "should be reference object"); next_d = java_lang_ref_Reference::discovered(obj); - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, - p2i(obj), p2i(next_d)); - } + log_develop_trace(gc, ref)(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT, p2i(obj), p2i(next_d)); assert(java_lang_ref_Reference::next(obj) == NULL, "Reference not active; should not be discovered"); // Self-loop next, so as to make Ref not active. @@ -517,10 +498,8 @@ bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive(); if (referent_is_dead && !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) { - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy", - p2i(iter.obj()), iter.obj()->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy", + p2i(iter.obj()), iter.obj()->klass()->internal_name()); // Remove Reference object from list iter.remove(); // keep the referent around @@ -532,14 +511,9 @@ } // Close the reachable set complete_gc->do_void(); - NOT_PRODUCT( - if (PrintGCDetails && TraceReferenceGC) { - gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " dead Refs out of " SIZE_FORMAT - " discovered Refs by policy, from list " INTPTR_FORMAT, - iter.removed(), iter.processed(), p2i(refs_list.head())); + log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " dead Refs out of " SIZE_FORMAT " discovered Refs by policy, from list " INTPTR_FORMAT, + iter.removed(), iter.processed(), p2i(refs_list.head())); } - ) -} // Traverse the list and remove any Refs that are not active, or // whose referents are either alive or NULL. @@ -554,10 +528,8 @@ DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());) assert(next == NULL, "Should not discover inactive Reference"); if (iter.is_referent_alive()) { - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)", - p2i(iter.obj()), iter.obj()->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)", + p2i(iter.obj()), iter.obj()->klass()->internal_name()); // The referent is reachable after all. // Remove Reference object from list. iter.remove(); @@ -571,8 +543,8 @@ } } NOT_PRODUCT( - if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) { - gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT + if (iter.processed() > 0) { + log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT " Refs in discovered list " INTPTR_FORMAT, iter.removed(), iter.processed(), p2i(refs_list.head())); } @@ -610,8 +582,8 @@ // Now close the newly reachable set complete_gc->do_void(); NOT_PRODUCT( - if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) { - gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT + if (iter.processed() > 0) { + log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT " Refs in discovered list " INTPTR_FORMAT, iter.removed(), iter.processed(), p2i(refs_list.head())); } @@ -638,11 +610,8 @@ // keep the referent around iter.make_referent_alive(); } - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Adding %sreference (" INTPTR_FORMAT ": %s) as pending", - clear_referent ? "cleared " : "", - p2i(iter.obj()), iter.obj()->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Adding %sreference (" INTPTR_FORMAT ": %s) as pending", + clear_referent ? "cleared " : "", p2i(iter.obj()), iter.obj()->klass()->internal_name()); assert(iter.obj()->is_oop(UseConcMarkSweepGC), "Adding a bad reference"); iter.next(); } @@ -666,8 +635,8 @@ void ReferenceProcessor::abandon_partial_discovery() { // loop over the lists for (uint i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) { - if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) { - gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i)); + if ((i % _max_num_q) == 0) { + log_develop_trace(gc, ref)("Abandoning %s discovered list", list_name(i)); } clear_discovered_references(_discovered_refs[i]); } @@ -736,6 +705,20 @@ bool _clear_referent; }; +#ifndef PRODUCT +void ReferenceProcessor::log_reflist_counts(DiscoveredList ref_lists[], size_t total_refs) { + if (!log_is_enabled(Trace, gc, ref)) { + return; + } + + stringStream st; + for (uint i = 0; i < _max_num_q; ++i) { + st.print(SIZE_FORMAT " ", ref_lists[i].length()); + } + log_develop_trace(gc, ref)("%s= " SIZE_FORMAT, st.as_string(), total_refs); +} +#endif + // Balances reference queues. // Move entries from all queues[0, 1, ..., _max_num_q-1] to // queues[0, 1, ..., _num_q-1] because only the first _num_q @@ -744,19 +727,12 @@ { // calculate total length size_t total_refs = 0; - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("\nBalance ref_lists "); - } + log_develop_trace(gc, ref)("Balance ref_lists "); for (uint i = 0; i < _max_num_q; ++i) { total_refs += ref_lists[i].length(); - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print(SIZE_FORMAT " ", ref_lists[i].length()); } - } - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" = " SIZE_FORMAT, total_refs); - } + log_reflist_counts(ref_lists, total_refs); size_t avg_refs = total_refs / _num_q + 1; uint to_idx = 0; for (uint from_idx = 0; from_idx < _max_num_q; from_idx++) { @@ -820,14 +796,8 @@ size_t balanced_total_refs = 0; for (uint i = 0; i < _max_num_q; ++i) { balanced_total_refs += ref_lists[i].length(); - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print(SIZE_FORMAT " ", ref_lists[i].length()); } - } - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" = " SIZE_FORMAT, balanced_total_refs); - gclog_or_tty->flush(); - } + log_reflist_counts(ref_lists, balanced_total_refs); assert(total_refs == balanced_total_refs, "Balancing was incomplete"); #endif } @@ -950,9 +920,7 @@ default: ShouldNotReachHere(); } - if (TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, p2i(list)); - } + log_develop_trace(gc, ref)("Thread %d gets list " INTPTR_FORMAT, id, p2i(list)); return list; } @@ -976,19 +944,15 @@ refs_list.set_head(obj); refs_list.inc_length(1); - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)", - p2i(obj), obj->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Discovered reference (mt) (" INTPTR_FORMAT ": %s)", + p2i(obj), obj->klass()->internal_name()); } else { // If retest was non NULL, another thread beat us to it: // The reference has already been discovered... - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)", - p2i(obj), obj->klass()->internal_name()); + log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)", + p2i(obj), obj->klass()->internal_name()); } } -} #ifndef PRODUCT // Non-atomic (i.e. concurrent) discovery might allow us @@ -1078,10 +1042,8 @@ assert(discovered->is_oop_or_null(), "Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered)); if (discovered != NULL) { // The reference has already been discovered... - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)", - p2i(obj), obj->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Already discovered reference (" INTPTR_FORMAT ": %s)", + p2i(obj), obj->klass()->internal_name()); if (RefDiscoveryPolicy == ReferentBasedDiscovery) { // assumes that an object is not processed twice; // if it's been already discovered it must be on another @@ -1136,10 +1098,7 @@ list->set_head(obj); list->inc_length(1); - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Discovered reference (" INTPTR_FORMAT ": %s)", - p2i(obj), obj->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Discovered reference (" INTPTR_FORMAT ": %s)", p2i(obj), obj->klass()->internal_name()); } assert(obj->is_oop(), "Discovered a bad reference"); verify_referent(obj); @@ -1159,8 +1118,7 @@ // Soft references { - GCTraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC, - false, gc_timer); + GCTraceTime(Debug, gc, ref) tm("Preclean SoftReferences", gc_timer); for (uint i = 0; i < _max_num_q; i++) { if (yield->should_return()) { return; @@ -1172,8 +1130,7 @@ // Weak references { - GCTraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC, - false, gc_timer); + GCTraceTime(Debug, gc, ref) tm("Preclean WeakReferences", gc_timer); for (uint i = 0; i < _max_num_q; i++) { if (yield->should_return()) { return; @@ -1185,8 +1142,7 @@ // Final references { - GCTraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC, - false, gc_timer); + GCTraceTime(Debug, gc, ref) tm("Preclean FinalReferences", gc_timer); for (uint i = 0; i < _max_num_q; i++) { if (yield->should_return()) { return; @@ -1198,8 +1154,7 @@ // Phantom references { - GCTraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC, - false, gc_timer); + GCTraceTime(Debug, gc, ref) tm("Preclean PhantomReferences", gc_timer); for (uint i = 0; i < _max_num_q; i++) { if (yield->should_return()) { return; @@ -1244,10 +1199,8 @@ next != NULL) { // The referent has been cleared, or is alive, or the Reference is not // active; we need to trace and mark its cohort. - if (TraceReferenceGC) { - gclog_or_tty->print_cr("Precleaning Reference (" INTPTR_FORMAT ": %s)", - p2i(iter.obj()), iter.obj()->klass()->internal_name()); - } + log_develop_trace(gc, ref)("Precleaning Reference (" INTPTR_FORMAT ": %s)", + p2i(iter.obj()), iter.obj()->klass()->internal_name()); // Remove Reference object from list iter.remove(); // Keep alive its cohort. @@ -1268,9 +1221,8 @@ complete_gc->do_void(); NOT_PRODUCT( - if (PrintGCDetails && PrintReferenceGC && (iter.processed() > 0)) { - gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " Refs out of " SIZE_FORMAT - " Refs in discovered list " INTPTR_FORMAT, + if (iter.processed() > 0) { + log_develop_trace(gc, ref)(" Dropped " SIZE_FORMAT " Refs out of " SIZE_FORMAT " Refs in discovered list " INTPTR_FORMAT, iter.removed(), iter.processed(), p2i(refs_list.head())); } ) --- old/src/share/vm/gc/shared/referenceProcessor.hpp 2015-12-01 12:06:24.554930252 +0100 +++ new/src/share/vm/gc/shared/referenceProcessor.hpp 2015-12-01 12:06:24.454930255 +0100 @@ -364,7 +364,9 @@ void clear_discovered_references(DiscoveredList& refs_list); // Calculate the number of jni handles. - unsigned int count_jni_refs(); + size_t count_jni_refs(); + + void log_reflist_counts(DiscoveredList ref_lists[], size_t total_count) PRODUCT_RETURN; // Balances reference queues. void balance_queues(DiscoveredList ref_lists[]); --- old/src/share/vm/gc/shared/space.hpp 2015-12-01 12:06:24.750930245 +0100 +++ new/src/share/vm/gc/shared/space.hpp 2015-12-01 12:06:24.634930249 +0100 @@ -220,7 +220,6 @@ // moving as a part of compaction. virtual void adjust_pointers() = 0; - // PrintHeapAtGC support virtual void print() const; virtual void print_on(outputStream* st) const; virtual void print_short() const; @@ -659,7 +658,6 @@ // Overrides for more efficient compaction support. void prepare_for_compaction(CompactPoint* cp); - // PrintHeapAtGC support. virtual void print_on(outputStream* st) const; // Checked dynamic downcasts. --- old/src/share/vm/gc/shared/spaceDecorator.cpp 2015-12-01 12:06:24.938930238 +0100 +++ new/src/share/vm/gc/shared/spaceDecorator.cpp 2015-12-01 12:06:24.826930242 +0100 @@ -25,6 +25,7 @@ #include "precompiled.hpp" #include "gc/shared/space.inline.hpp" #include "gc/shared/spaceDecorator.hpp" +#include "logging/log.hpp" #include "utilities/copy.hpp" // Catch-all file for utility classes @@ -83,13 +84,9 @@ void SpaceMangler::mangle_region(MemRegion mr) { assert(ZapUnusedHeapArea, "Mangling should not be in use"); #ifdef ASSERT - if(TraceZapUnusedHeapArea) { - gclog_or_tty->print("Mangling [" PTR_FORMAT " to " PTR_FORMAT ")", p2i(mr.start()), p2i(mr.end())); - } + log_develop_trace(gc)("Mangling [" PTR_FORMAT " to " PTR_FORMAT ")", p2i(mr.start()), p2i(mr.end())); Copy::fill_to_words(mr.start(), mr.word_size(), badHeapWord); - if(TraceZapUnusedHeapArea) { - gclog_or_tty->print_cr(" done"); - } + log_develop_trace(gc)("Mangling done."); #endif } --- old/src/share/vm/gc/shared/taskqueue.cpp 2015-12-01 12:06:25.110930232 +0100 +++ new/src/share/vm/gc/shared/taskqueue.cpp 2015-12-01 12:06:25.010930236 +0100 @@ -25,6 +25,7 @@ #include "precompiled.hpp" #include "gc/shared/taskqueue.hpp" #include "oops/oop.inline.hpp" +#include "logging/log.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/os.hpp" #include "runtime/thread.inline.hpp" @@ -212,11 +213,8 @@ #endif } } else { - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("ParallelTaskTerminator::offer_termination() " - "thread " PTR_FORMAT " sleeps after %u yields", - p2i(Thread::current()), yield_count); - } + log_develop_trace(gc, task)("ParallelTaskTerminator::offer_termination() thread " PTR_FORMAT " sleeps after %u yields", + p2i(Thread::current()), yield_count); yield_count = 0; // A sleep will cause this processor to seek work on another processor's // runqueue, if it has nothing else to run (as opposed to the yield @@ -240,7 +238,7 @@ #ifdef TRACESPINNING void ParallelTaskTerminator::print_termination_counts() { - gclog_or_tty->print_cr("ParallelTaskTerminator Total yields: %u" + log_trace(gc, task)("ParallelTaskTerminator Total yields: %u" " Total spins: %u Total peeks: %u", total_yields(), total_spins(), --- old/src/share/vm/gc/shared/threadLocalAllocBuffer.cpp 2015-12-01 12:06:25.302930226 +0100 +++ new/src/share/vm/gc/shared/threadLocalAllocBuffer.cpp 2015-12-01 12:06:25.182930230 +0100 @@ -25,6 +25,7 @@ #include "precompiled.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/threadLocalAllocBuffer.inline.hpp" +#include "logging/log.hpp" #include "memory/resourceArea.hpp" #include "memory/universe.inline.hpp" #include "oops/oop.inline.hpp" @@ -54,9 +55,7 @@ // Publish new stats if some allocation occurred. if (global_stats()->allocation() != 0) { global_stats()->publish(); - if (PrintTLAB) { - global_stats()->print(); - } + global_stats()->print(); } } @@ -70,9 +69,7 @@ size_t allocated_since_last_gc = total_allocated - _allocated_before_last_gc; _allocated_before_last_gc = total_allocated; - if (PrintTLAB && (_number_of_refills > 0 || Verbose)) { - print_stats("gc"); - } + print_stats("gc"); if (_number_of_refills > 0) { // Update allocation history if a reasonable amount of eden was allocated. @@ -149,12 +146,11 @@ size_t aligned_new_size = align_object_size(new_size); - if (PrintTLAB && Verbose) { - gclog_or_tty->print("TLAB new size: thread: " INTPTR_FORMAT " [id: %2d]" - " refills %d alloc: %8.6f desired_size: " SIZE_FORMAT " -> " SIZE_FORMAT "\n", - p2i(myThread()), myThread()->osthread()->thread_id(), - _target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size); - } + log_trace(gc, tlab)("TLAB new size: thread: " INTPTR_FORMAT " [id: %2d]" + " refills %d alloc: %8.6f desired_size: " SIZE_FORMAT " -> " SIZE_FORMAT, + p2i(myThread()), myThread()->osthread()->thread_id(), + _target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size); + set_desired_size(aligned_new_size); set_refill_waste_limit(initial_refill_waste_limit()); } @@ -171,9 +167,7 @@ HeapWord* top, size_t new_size) { _number_of_refills++; - if (PrintTLAB && Verbose) { - print_stats("fill"); - } + print_stats("fill"); assert(top <= start + new_size - alignment_reserve(), "size too small"); initialize(start, top, start + new_size - alignment_reserve()); @@ -226,10 +220,8 @@ guarantee(Thread::current()->is_Java_thread(), "tlab initialization thread not Java thread"); Thread::current()->tlab().initialize(); - if (PrintTLAB && Verbose) { - gclog_or_tty->print("TLAB min: " SIZE_FORMAT " initial: " SIZE_FORMAT " max: " SIZE_FORMAT "\n", - min_size(), Thread::current()->tlab().initial_desired_size(), max_size()); - } + log_develop_trace(gc, tlab)("TLAB min: " SIZE_FORMAT " initial: " SIZE_FORMAT " max: " SIZE_FORMAT, + min_size(), Thread::current()->tlab().initial_desired_size(), max_size()); } size_t ThreadLocalAllocBuffer::initial_desired_size() { @@ -250,26 +242,31 @@ } void ThreadLocalAllocBuffer::print_stats(const char* tag) { + LogHandle(gc, tlab) log; + if (!log.is_trace()) { + return; + } + Thread* thrd = myThread(); size_t waste = _gc_waste + _slow_refill_waste + _fast_refill_waste; size_t alloc = _number_of_refills * _desired_size; double waste_percent = alloc == 0 ? 0.0 : 100.0 * waste / alloc; size_t tlab_used = Universe::heap()->tlab_used(thrd); - gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]" - " desired_size: " SIZE_FORMAT "KB" - " slow allocs: %d refill waste: " SIZE_FORMAT "B" - " alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB" - " slow: %dB fast: %dB\n", - tag, p2i(thrd), thrd->osthread()->thread_id(), - _desired_size / (K / HeapWordSize), - _slow_allocations, _refill_waste_limit * HeapWordSize, - _allocation_fraction.average(), - _allocation_fraction.average() * tlab_used / K, - _number_of_refills, waste_percent, - _gc_waste * HeapWordSize, - _slow_refill_waste * HeapWordSize, - _fast_refill_waste * HeapWordSize); + log.trace("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]" + " desired_size: " SIZE_FORMAT "KB" + " slow allocs: %d refill waste: " SIZE_FORMAT "B" + " alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB" + " slow: %dB fast: %dB", + tag, p2i(thrd), thrd->osthread()->thread_id(), + _desired_size / (K / HeapWordSize), + _slow_allocations, _refill_waste_limit * HeapWordSize, + _allocation_fraction.average(), + _allocation_fraction.average() * tlab_used / K, + _number_of_refills, waste_percent, + _gc_waste * HeapWordSize, + _slow_refill_waste * HeapWordSize, + _fast_refill_waste * HeapWordSize); } void ThreadLocalAllocBuffer::verify() { @@ -388,22 +385,27 @@ } void GlobalTLABStats::print() { + LogHandle(gc, tlab) log; + if (!log.is_debug()) { + return; + } + size_t waste = _total_gc_waste + _total_slow_refill_waste + _total_fast_refill_waste; double waste_percent = _total_allocation == 0 ? 0.0 : 100.0 * waste / _total_allocation; - gclog_or_tty->print("TLAB totals: thrds: %d refills: %d max: %d" - " slow allocs: %d max %d waste: %4.1f%%" - " gc: " SIZE_FORMAT "B max: " SIZE_FORMAT "B" - " slow: " SIZE_FORMAT "B max: " SIZE_FORMAT "B" - " fast: " SIZE_FORMAT "B max: " SIZE_FORMAT "B\n", - _allocating_threads, - _total_refills, _max_refills, - _total_slow_allocations, _max_slow_allocations, - waste_percent, - _total_gc_waste * HeapWordSize, - _max_gc_waste * HeapWordSize, - _total_slow_refill_waste * HeapWordSize, - _max_slow_refill_waste * HeapWordSize, - _total_fast_refill_waste * HeapWordSize, - _max_fast_refill_waste * HeapWordSize); + log.debug("TLAB totals: thrds: %d refills: %d max: %d" + " slow allocs: %d max %d waste: %4.1f%%" + " gc: " SIZE_FORMAT "B max: " SIZE_FORMAT "B" + " slow: " SIZE_FORMAT "B max: " SIZE_FORMAT "B" + " fast: " SIZE_FORMAT "B max: " SIZE_FORMAT "B", + _allocating_threads, + _total_refills, _max_refills, + _total_slow_allocations, _max_slow_allocations, + waste_percent, + _total_gc_waste * HeapWordSize, + _max_gc_waste * HeapWordSize, + _total_slow_refill_waste * HeapWordSize, + _max_slow_refill_waste * HeapWordSize, + _total_fast_refill_waste * HeapWordSize, + _max_fast_refill_waste * HeapWordSize); } --- old/src/share/vm/gc/shared/threadLocalAllocBuffer.inline.hpp 2015-12-01 12:06:25.490930219 +0100 +++ new/src/share/vm/gc/shared/threadLocalAllocBuffer.inline.hpp 2015-12-01 12:06:25.374930223 +0100 @@ -27,6 +27,7 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/threadLocalAllocBuffer.hpp" +#include "logging/log.hpp" #include "runtime/thread.hpp" #include "utilities/copy.hpp" @@ -66,18 +67,12 @@ const size_t obj_plus_filler_size = aligned_obj_size + alignment_reserve(); if (new_tlab_size < obj_plus_filler_size) { // If there isn't enough room for the allocation, return failure. - if (PrintTLAB && Verbose) { - gclog_or_tty->print_cr("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ")" - " returns failure", - obj_size); - } + log_trace(gc, tlab)("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ") returns failure", + obj_size); return 0; } - if (PrintTLAB && Verbose) { - gclog_or_tty->print_cr("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ")" - " returns " SIZE_FORMAT, - obj_size, new_tlab_size); - } + log_trace(gc, tlab)("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ") returns " SIZE_FORMAT, + obj_size, new_tlab_size); return new_tlab_size; } @@ -91,15 +86,12 @@ _slow_allocations++; - if (PrintTLAB && Verbose) { - Thread* thrd = myThread(); - gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]" - " obj: " SIZE_FORMAT - " free: " SIZE_FORMAT - " waste: " SIZE_FORMAT "\n", - "slow", p2i(thrd), thrd->osthread()->thread_id(), - obj_size, free(), refill_waste_limit()); - } + log_develop_trace(gc, tlab)("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]" + " obj: " SIZE_FORMAT + " free: " SIZE_FORMAT + " waste: " SIZE_FORMAT, + "slow", p2i(myThread()), myThread()->osthread()->thread_id(), + obj_size, free(), refill_waste_limit()); } #endif // SHARE_VM_GC_SHARED_THREADLOCALALLOCBUFFER_INLINE_HPP --- old/src/share/vm/gc/shared/vmGCOperations.cpp 2015-12-01 12:06:25.670930213 +0100 +++ new/src/share/vm/gc/shared/vmGCOperations.cpp 2015-12-01 12:06:25.558930217 +0100 @@ -29,6 +29,7 @@ #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/vmGCOperations.hpp" #include "memory/oopFactory.hpp" +#include "logging/log.hpp" #include "oops/instanceKlass.hpp" #include "oops/instanceRefKlass.hpp" #include "runtime/handles.inline.hpp" @@ -216,16 +217,6 @@ return false; } -static void log_metaspace_alloc_failure_for_concurrent_GC() { - if (Verbose && PrintGCDetails) { - if (UseConcMarkSweepGC) { - gclog_or_tty->print_cr("\nCMS full GC for Metaspace"); - } else if (UseG1GC) { - gclog_or_tty->print_cr("\nG1 full GC for Metaspace"); - } - } -} - void VM_CollectForMetadataAllocation::doit() { SvcGCMarker sgcm(SvcGCMarker::FULL); @@ -249,7 +240,7 @@ return; } - log_metaspace_alloc_failure_for_concurrent_GC(); + log_debug(gc)("%s full GC for Metaspace", UseConcMarkSweepGC ? "CMS" : "G1"); } // Don't clear the soft refs yet. @@ -282,10 +273,7 @@ return; } - if (Verbose && PrintGCDetails) { - gclog_or_tty->print_cr("\nAfter Metaspace GC failed to allocate size " - SIZE_FORMAT, _size); - } + log_debug(gc)("After Metaspace GC failed to allocate size " SIZE_FORMAT, _size); if (GC_locker::is_active_and_needs_gc()) { set_gc_locked(); --- old/src/share/vm/logging/logPrefix.hpp 2015-12-01 12:06:25.838930207 +0100 +++ new/src/share/vm/logging/logPrefix.hpp 2015-12-01 12:06:25.734930211 +0100 @@ -38,7 +38,36 @@ // List of prefixes for specific tags and/or tagsets. // Syntax: LOG_PREFIX(, LOG_TAGS()) // Where the prefixer function matches the following signature: size_t (*)(char*, size_t) -#define LOG_PREFIX_LIST // Currently unused/empty +#define LOG_PREFIX_LIST \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, age)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, alloc)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, barrier)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, compaction)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, compaction, phases)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, cpu)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, ergo)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, ergo, cset)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, ergo, heap)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, heap)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, freelist)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, liveness)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, metaspace)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, phases)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, phases, start)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, plab)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, region)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, remset)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, ref)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, ref, start)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, start)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, sweep)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, task)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, task, start)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, task, stats)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, task, time)) \ + LOG_PREFIX(GCId::print_prefix, LOG_TAGS(gc, tlab)) + // The empty prefix, used when there's no prefix defined. template --- old/src/share/vm/logging/logTag.hpp 2015-12-01 12:06:26.026930200 +0100 +++ new/src/share/vm/logging/logTag.hpp 2015-12-01 12:06:25.902930205 +0100 @@ -31,9 +31,51 @@ // (The tags 'all', 'disable' and 'help' are special tags that can // not be used in log calls, and should not be listed below.) #define LOG_TAG_LIST \ + LOG_TAG(alloc) \ + LOG_TAG(age) \ + LOG_TAG(barrier) \ + LOG_TAG(bot) \ + LOG_TAG(census) \ + LOG_TAG(classhisto) \ + LOG_TAG(comp) \ + LOG_TAG(compaction) \ + LOG_TAG(cpu) \ + LOG_TAG(cset) \ LOG_TAG(defaultmethods) \ + LOG_TAG(ergo) \ + LOG_TAG(exit) \ + LOG_TAG(freelist) \ + LOG_TAG(gc) \ + LOG_TAG(heap) \ + LOG_TAG(humongous) \ + LOG_TAG(ihop) \ + LOG_TAG(jni) \ + LOG_TAG(liveness) \ LOG_TAG(logging) \ + LOG_TAG(marking) \ + LOG_TAG(metaspace) \ + LOG_TAG(phases) \ + LOG_TAG(plab) \ + LOG_TAG(promotion) \ + LOG_TAG(ref) \ + LOG_TAG(refine) \ + LOG_TAG(region) \ + LOG_TAG(remset) \ + LOG_TAG(rt) \ LOG_TAG(safepoint) \ + LOG_TAG(scavenge) \ + LOG_TAG(scrub) \ + LOG_TAG(start) \ + LOG_TAG(state) \ + LOG_TAG(svc) \ + LOG_TAG(sweep) \ + LOG_TAG(stats) \ + LOG_TAG(stringdedup) \ + LOG_TAG(survivor) \ + LOG_TAG(task) \ + LOG_TAG(tlab) \ + LOG_TAG(time) \ + LOG_TAG(verify) \ LOG_TAG(vmoperation) #define PREFIX_LOG_TAG(T) (LogTag::T) --- old/src/share/vm/memory/binaryTreeDictionary.cpp 2015-12-01 12:06:26.190930195 +0100 +++ new/src/share/vm/memory/binaryTreeDictionary.cpp 2015-12-01 12:06:26.086930198 +0100 @@ -29,6 +29,7 @@ #include "memory/freeBlockDictionary.hpp" #include "memory/freeList.hpp" #include "memory/metachunk.hpp" +#include "memory/resourceArea.hpp" #include "runtime/globals.hpp" #include "utilities/macros.hpp" #include "utilities/ostream.hpp" @@ -1189,27 +1190,29 @@ // Does walking the tree 3 times hurt? set_tree_surplus(splitSurplusPercent); set_tree_hints(); - if (PrintGC && Verbose) { - report_statistics(); + LogHandle(gc, freelist, stats) log; + if (log.is_trace()) { + ResourceMark rm; + report_statistics(log.trace_stream()); } clear_tree_census(); } // Print summary statistics template -void BinaryTreeDictionary::report_statistics() const { +void BinaryTreeDictionary::report_statistics(outputStream* st) const { FreeBlockDictionary::verify_par_locked(); - gclog_or_tty->print("Statistics for BinaryTreeDictionary:\n" - "------------------------------------\n"); + st->print_cr("Statistics for BinaryTreeDictionary:"); + st->print_cr("------------------------------------"); size_t total_size = total_chunk_size(debug_only(NULL)); - size_t free_blocks = num_free_blocks(); - gclog_or_tty->print("Total Free Space: " SIZE_FORMAT "\n", total_size); - gclog_or_tty->print("Max Chunk Size: " SIZE_FORMAT "\n", max_chunk_size()); - gclog_or_tty->print("Number of Blocks: " SIZE_FORMAT "\n", free_blocks); + size_t free_blocks = num_free_blocks(); + st->print_cr("Total Free Space: " SIZE_FORMAT, total_size); + st->print_cr("Max Chunk Size: " SIZE_FORMAT, max_chunk_size()); + st->print_cr("Number of Blocks: " SIZE_FORMAT, free_blocks); if (free_blocks > 0) { - gclog_or_tty->print("Av. Block Size: " SIZE_FORMAT "\n", total_size/free_blocks); + st->print_cr("Av. Block Size: " SIZE_FORMAT, total_size/free_blocks); } - gclog_or_tty->print("Tree Height: " SIZE_FORMAT "\n", tree_height()); + st->print_cr("Tree Height: " SIZE_FORMAT, tree_height()); } // Print census information - counts, births, deaths, etc. @@ -1229,22 +1232,27 @@ FreeList_t* total() { return &_total; } size_t total_free() { return _total_free; } void do_list(FreeList* fl) { + LogHandle(gc, freelist, census) log; + outputStream* out = log.debug_stream(); if (++_print_line >= 40) { - FreeList_t::print_labels_on(gclog_or_tty, "size"); + ResourceMark rm; + FreeList_t::print_labels_on(out, "size"); _print_line = 0; } - fl->print_on(gclog_or_tty); - _total_free += fl->count() * fl->size() ; - total()->set_count( total()->count() + fl->count() ); + fl->print_on(out); + _total_free += fl->count() * fl->size(); + total()->set_count(total()->count() + fl->count()); } #if INCLUDE_ALL_GCS void do_list(AdaptiveFreeList* fl) { + LogHandle(gc, freelist, census) log; + outputStream* out = log.debug_stream(); if (++_print_line >= 40) { - FreeList_t::print_labels_on(gclog_or_tty, "size"); + FreeList_t::print_labels_on(out, "size"); _print_line = 0; } - fl->print_on(gclog_or_tty); + fl->print_on(out); _total_free += fl->count() * fl->size() ; total()->set_count( total()->count() + fl->count() ); total()->set_bfr_surp( total()->bfr_surp() + fl->bfr_surp() ); @@ -1261,38 +1269,36 @@ }; template -void BinaryTreeDictionary::print_dict_census(void) const { +void BinaryTreeDictionary::print_dict_census(outputStream* st) const { - gclog_or_tty->print("\nBinaryTree\n"); - FreeList_t::print_labels_on(gclog_or_tty, "size"); + st->print("BinaryTree"); + FreeList_t::print_labels_on(st, "size"); PrintTreeCensusClosure ptc; ptc.do_tree(root()); FreeList_t* total = ptc.total(); - FreeList_t::print_labels_on(gclog_or_tty, " "); + FreeList_t::print_labels_on(st, " "); } #if INCLUDE_ALL_GCS template <> -void AFLBinaryTreeDictionary::print_dict_census(void) const { +void AFLBinaryTreeDictionary::print_dict_census(outputStream* st) const { - gclog_or_tty->print("\nBinaryTree\n"); - AdaptiveFreeList::print_labels_on(gclog_or_tty, "size"); + st->print_cr("BinaryTree"); + AdaptiveFreeList::print_labels_on(st, "size"); PrintTreeCensusClosure > ptc; ptc.do_tree(root()); AdaptiveFreeList* total = ptc.total(); - AdaptiveFreeList::print_labels_on(gclog_or_tty, " "); - total->print_on(gclog_or_tty, "TOTAL\t"); - gclog_or_tty->print( - "total_free(words): " SIZE_FORMAT_W(16) - " growth: %8.5f deficit: %8.5f\n", - ptc.total_free(), - (double)(total->split_births() + total->coal_births() - - total->split_deaths() - total->coal_deaths()) - /(total->prev_sweep() != 0 ? (double)total->prev_sweep() : 1.0), - (double)(total->desired() - total->count()) - /(total->desired() != 0 ? (double)total->desired() : 1.0)); + AdaptiveFreeList::print_labels_on(st, " "); + total->print_on(st, "TOTAL\t"); + st->print_cr("total_free(words): " SIZE_FORMAT_W(16) " growth: %8.5f deficit: %8.5f", + ptc.total_free(), + (double)(total->split_births() + total->coal_births() + - total->split_deaths() - total->coal_deaths()) + /(total->prev_sweep() != 0 ? (double)total->prev_sweep() : 1.0), + (double)(total->desired() - total->count()) + /(total->desired() != 0 ? (double)total->desired() : 1.0)); } #endif // INCLUDE_ALL_GCS @@ -1311,7 +1317,7 @@ FreeList_t::print_labels_on(_st, "size"); _print_line = 0; } - fl->print_on(gclog_or_tty); + fl->print_on(_st); size_t sz = fl->size(); for (Chunk_t* fc = fl->head(); fc != NULL; fc = fc->next()) { --- old/src/share/vm/memory/binaryTreeDictionary.hpp 2015-12-01 12:06:26.390930188 +0100 +++ new/src/share/vm/memory/binaryTreeDictionary.hpp 2015-12-01 12:06:26.290930191 +0100 @@ -324,7 +324,7 @@ void clear_tree_census(void); // Print the statistics for all the lists in the tree. Also may // print out summaries. - void print_dict_census(void) const; + void print_dict_census(outputStream* st) const; void print_free_lists(outputStream* st) const; // For debugging. Returns the sum of the _returned_bytes for @@ -335,7 +335,7 @@ // For debugging. Return the total number of chunks in the dictionary. size_t total_count() PRODUCT_RETURN0; - void report_statistics() const; + void report_statistics(outputStream* st) const; void verify() const; }; --- old/src/share/vm/memory/filemap.cpp 2015-12-01 12:06:26.582930181 +0100 +++ new/src/share/vm/memory/filemap.cpp 2015-12-01 12:06:26.462930185 +0100 @@ -953,11 +953,11 @@ } void FileMapInfo::print_shared_spaces() { - gclog_or_tty->print_cr("Shared Spaces:"); + tty->print_cr("Shared Spaces:"); for (int i = 0; i < MetaspaceShared::n_regions; i++) { struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[i]; char *base = _header->region_addr(i); - gclog_or_tty->print(" %s " INTPTR_FORMAT "-" INTPTR_FORMAT, + tty->print(" %s " INTPTR_FORMAT "-" INTPTR_FORMAT, shared_region_name[i], p2i(base), p2i(base + si->_used)); } --- old/src/share/vm/memory/freeBlockDictionary.hpp 2015-12-01 12:06:26.770930174 +0100 +++ new/src/share/vm/memory/freeBlockDictionary.hpp 2015-12-01 12:06:26.654930179 +0100 @@ -89,11 +89,11 @@ virtual size_t total_count() = 0; ) - virtual void report_statistics() const { - gclog_or_tty->print("No statistics available"); + virtual void report_statistics(outputStream* st) const { + st->print_cr("No statistics available"); } - virtual void print_dict_census() const = 0; + virtual void print_dict_census(outputStream* st) const = 0; virtual void print_free_lists(outputStream* st) const = 0; virtual void verify() const = 0; --- old/src/share/vm/memory/metaspace.cpp 2015-12-01 12:06:26.958930168 +0100 +++ new/src/share/vm/memory/metaspace.cpp 2015-12-01 12:06:26.842930172 +0100 @@ -25,6 +25,7 @@ #include "gc/shared/collectedHeap.hpp" #include "gc/shared/collectorPolicy.hpp" #include "gc/shared/gcLocker.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "memory/binaryTreeDictionary.hpp" #include "memory/filemap.hpp" @@ -811,8 +812,10 @@ BlockFreelist::BlockFreelist() : _dictionary(new BlockTreeDictionary()) {} BlockFreelist::~BlockFreelist() { - if (Verbose && TraceMetadataChunkAllocation) { - dictionary()->print_free_lists(gclog_or_tty); + LogHandle(gc, metaspace, freelist) log; + if (log.is_trace()) { + ResourceMark rm; + dictionary()->print_free_lists(log.trace_stream()); } delete _dictionary; } @@ -892,11 +895,11 @@ "The committed memory doesn't match the expanded memory."); if (!is_available(chunk_word_size)) { - if (TraceMetadataChunkAllocation) { - gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available " SIZE_FORMAT " words ", chunk_word_size); - // Dump some information about the virtual space that is nearly full - print_on(gclog_or_tty); - } + LogHandle(gc, metaspace, freelist) log; + log.debug("VirtualSpaceNode::take_from_committed() not available " SIZE_FORMAT " words ", chunk_word_size); + // Dump some information about the virtual space that is nearly full + ResourceMark rm; + print_on(log.debug_stream()); return NULL; } @@ -1231,9 +1234,11 @@ #ifdef ASSERT new_entry->mangle(); #endif - if (TraceMetavirtualspaceAllocation && Verbose) { + if (develop_log_is_enabled(Trace, gc, metaspace)) { + LogHandle(gc, metaspace) log; VirtualSpaceNode* vsl = current_virtual_space(); - vsl->print_on(gclog_or_tty); + ResourceMark rm; + vsl->print_on(log.trace_stream()); } } @@ -1330,12 +1335,10 @@ } void VirtualSpaceList::print_on(outputStream* st) const { - if (TraceMetadataChunkAllocation && Verbose) { - VirtualSpaceListIterator iter(virtual_space_list()); - while (iter.repeat()) { - VirtualSpaceNode* node = iter.get_next(); - node->print_on(st); - } + VirtualSpaceListIterator iter(virtual_space_list()); + while (iter.repeat()) { + VirtualSpaceNode* node = iter.get_next(); + node->print_on(st); } } @@ -1497,17 +1500,10 @@ minimum_desired_capacity = MAX2(minimum_desired_capacity, MetaspaceSize); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("\nMetaspaceGC::compute_new_size: "); - gclog_or_tty->print_cr(" " - " minimum_free_percentage: %6.2f" - " maximum_used_percentage: %6.2f", - minimum_free_percentage, - maximum_used_percentage); - gclog_or_tty->print_cr(" " - " used_after_gc : %6.1fKB", - used_after_gc / (double) K); - } + log_trace(gc, metaspace)("MetaspaceGC::compute_new_size: "); + log_trace(gc, metaspace)(" minimum_free_percentage: %6.2f maximum_used_percentage: %6.2f", + minimum_free_percentage, maximum_used_percentage); + log_trace(gc, metaspace)(" used_after_gc : %6.1fKB", used_after_gc / (double) K); size_t shrink_bytes = 0; @@ -1525,17 +1521,11 @@ Metaspace::tracer()->report_gc_threshold(capacity_until_GC, new_capacity_until_GC, MetaspaceGCThresholdUpdater::ComputeNewSize); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" expanding:" - " minimum_desired_capacity: %6.1fKB" - " expand_bytes: %6.1fKB" - " MinMetaspaceExpansion: %6.1fKB" - " new metaspace HWM: %6.1fKB", - minimum_desired_capacity / (double) K, - expand_bytes / (double) K, - MinMetaspaceExpansion / (double) K, - new_capacity_until_GC / (double) K); - } + log_trace(gc, metaspace)(" expanding: minimum_desired_capacity: %6.1fKB expand_bytes: %6.1fKB MinMetaspaceExpansion: %6.1fKB new metaspace HWM: %6.1fKB", + minimum_desired_capacity / (double) K, + expand_bytes / (double) K, + MinMetaspaceExpansion / (double) K, + new_capacity_until_GC / (double) K); } return; } @@ -1555,18 +1545,10 @@ size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx)); maximum_desired_capacity = MAX2(maximum_desired_capacity, MetaspaceSize); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" " - " maximum_free_percentage: %6.2f" - " minimum_used_percentage: %6.2f", - maximum_free_percentage, - minimum_used_percentage); - gclog_or_tty->print_cr(" " - " minimum_desired_capacity: %6.1fKB" - " maximum_desired_capacity: %6.1fKB", - minimum_desired_capacity / (double) K, - maximum_desired_capacity / (double) K); - } + log_trace(gc, metaspace)(" maximum_free_percentage: %6.2f minimum_used_percentage: %6.2f", + maximum_free_percentage, minimum_used_percentage); + log_trace(gc, metaspace)(" minimum_desired_capacity: %6.1fKB maximum_desired_capacity: %6.1fKB", + minimum_desired_capacity / (double) K, maximum_desired_capacity / (double) K); assert(minimum_desired_capacity <= maximum_desired_capacity, "sanity check"); @@ -1592,23 +1574,10 @@ } else { _shrink_factor = MIN2(current_shrink_factor * 4, (uint) 100); } - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" " - " shrinking:" - " initSize: %.1fK" - " maximum_desired_capacity: %.1fK", - MetaspaceSize / (double) K, - maximum_desired_capacity / (double) K); - gclog_or_tty->print_cr(" " - " shrink_bytes: %.1fK" - " current_shrink_factor: %d" - " new shrink factor: %d" - " MinMetaspaceExpansion: %.1fK", - shrink_bytes / (double) K, - current_shrink_factor, - _shrink_factor, - MinMetaspaceExpansion / (double) K); - } + log_trace(gc, metaspace)(" shrinking: initSize: %.1fK maximum_desired_capacity: %.1fK", + MetaspaceSize / (double) K, maximum_desired_capacity / (double) K); + log_trace(gc, metaspace)(" shrink_bytes: %.1fK current_shrink_factor: %d new shrink factor: %d MinMetaspaceExpansion: %.1fK", + shrink_bytes / (double) K, current_shrink_factor, _shrink_factor, MinMetaspaceExpansion / (double) K); } } @@ -1638,10 +1607,7 @@ if (_allocation_fail_alot_count > 0) { _allocation_fail_alot_count--; } else { - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("Metadata allocation failing for " - "MetadataAllocationFailALot"); - } + log_trace(gc, metaspace, freelist)("Metadata allocation failing for MetadataAllocationFailALot"); init_allocation_fail_alot_count(); return true; } @@ -1786,11 +1752,8 @@ // Remove the chunk as the head of the list. free_list->remove_chunk(chunk); - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list " - PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT, - p2i(free_list), p2i(chunk), chunk->word_size()); - } + log_trace(gc, metaspace, freelist)("ChunkManager::free_chunks_get: free_list " PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT, + p2i(free_list), p2i(chunk), chunk->word_size()); } else { chunk = humongous_dictionary()->get_chunk( word_size, @@ -1800,13 +1763,8 @@ return NULL; } - if (TraceMetadataHumongousAllocation) { - size_t waste = chunk->word_size() - word_size; - gclog_or_tty->print_cr("Free list allocate humongous chunk size " - SIZE_FORMAT " for requested size " SIZE_FORMAT - " waste " SIZE_FORMAT, - chunk->word_size(), word_size, waste); - } + log_debug(gc, metaspace, alloc)("Free list allocate humongous chunk size " SIZE_FORMAT " for requested size " SIZE_FORMAT " waste " SIZE_FORMAT, + chunk->word_size(), word_size, chunk->word_size() - word_size); } // Chunk is being removed from the chunks free list. @@ -1839,7 +1797,8 @@ assert((word_size <= chunk->word_size()) || list_index(chunk->word_size() == HumongousIndex), "Non-humongous variable sized chunk"); - if (TraceMetadataChunkAllocation) { + LogHandle(gc, metaspace, freelist) log; + if (log.is_debug()) { size_t list_count; if (list_index(word_size) < HumongousIndex) { ChunkList* list = find_free_chunks_list(word_size); @@ -1847,19 +1806,17 @@ } else { list_count = humongous_dictionary()->total_count(); } - gclog_or_tty->print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk " - PTR_FORMAT " size " SIZE_FORMAT " count " SIZE_FORMAT " ", - p2i(this), p2i(chunk), chunk->word_size(), list_count); - locked_print_free_chunks(gclog_or_tty); + log.debug("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk " PTR_FORMAT " size " SIZE_FORMAT " count " SIZE_FORMAT " ", + p2i(this), p2i(chunk), chunk->word_size(), list_count); + ResourceMark rm; + locked_print_free_chunks(log.debug_stream()); } return chunk; } void ChunkManager::print_on(outputStream* out) const { - if (PrintFLSStatistics != 0) { - const_cast(this)->humongous_dictionary()->report_statistics(); - } + const_cast(this)->humongous_dictionary()->report_statistics(out); } // SpaceManager methods @@ -2039,14 +1996,12 @@ "Size calculation is wrong, word_size " SIZE_FORMAT " chunk_word_size " SIZE_FORMAT, word_size, chunk_word_size); - if (TraceMetadataHumongousAllocation && - SpaceManager::is_humongous(word_size)) { - gclog_or_tty->print_cr("Metadata humongous allocation:"); - gclog_or_tty->print_cr(" word_size " PTR_FORMAT, word_size); - gclog_or_tty->print_cr(" chunk_word_size " PTR_FORMAT, - chunk_word_size); - gclog_or_tty->print_cr(" chunk overhead " PTR_FORMAT, - Metachunk::overhead()); + LogHandle(gc, metaspace, alloc) log; + if (log.is_debug() && SpaceManager::is_humongous(word_size)) { + log.debug("Metadata humongous allocation:"); + log.debug(" word_size " PTR_FORMAT, word_size); + log.debug(" chunk_word_size " PTR_FORMAT, chunk_word_size); + log.debug(" chunk overhead " PTR_FORMAT, Metachunk::overhead()); } return chunk_word_size; } @@ -2068,17 +2023,15 @@ "Don't need to expand"); MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); - if (TraceMetadataChunkAllocation && Verbose) { + if (log_is_enabled(Trace, gc, metaspace, freelist)) { size_t words_left = 0; size_t words_used = 0; if (current_chunk() != NULL) { words_left = current_chunk()->free_word_size(); words_used = current_chunk()->used_word_size(); } - gclog_or_tty->print_cr("SpaceManager::grow_and_allocate for " SIZE_FORMAT - " words " SIZE_FORMAT " words used " SIZE_FORMAT - " words left", - word_size, words_used, words_left); + log_trace(gc, metaspace, freelist)("SpaceManager::grow_and_allocate for " SIZE_FORMAT " words " SIZE_FORMAT " words used " SIZE_FORMAT " words left", + word_size, words_used, words_left); } // Get another chunk @@ -2169,9 +2122,7 @@ _chunks_in_use[i] = NULL; } _current_chunk = NULL; - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, p2i(this)); - } + log_trace(gc, metaspace, freelist)("SpaceManager(): " PTR_FORMAT, p2i(this)); } void ChunkManager::return_chunks(ChunkIndex index, Metachunk* chunks) { @@ -2213,9 +2164,11 @@ dec_total_from_size_metrics(); - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, p2i(this)); - locked_print_chunks_in_use_on(gclog_or_tty); + LogHandle(gc, metaspace, freelist) log; + if (log.is_trace()) { + log.trace("~SpaceManager(): " PTR_FORMAT, p2i(this)); + ResourceMark rm; + locked_print_chunks_in_use_on(log.trace_stream()); } // Do not mangle freed Metachunks. The chunk size inside Metachunks @@ -2233,19 +2186,11 @@ // free lists. Each list is NULL terminated. for (ChunkIndex i = ZeroIndex; i < HumongousIndex; i = next_chunk_index(i)) { - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s chunks to freelist", - sum_count_in_chunks_in_use(i), - chunk_size_name(i)); - } + log.trace("returned " SIZE_FORMAT " %s chunks to freelist", sum_count_in_chunks_in_use(i), chunk_size_name(i)); Metachunk* chunks = chunks_in_use(i); chunk_manager()->return_chunks(i, chunks); set_chunks_in_use(i, NULL); - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("updated freelist count " SSIZE_FORMAT " %s", - chunk_manager()->free_chunks(i)->count(), - chunk_size_name(i)); - } + log.trace("updated freelist count " SSIZE_FORMAT " %s", chunk_manager()->free_chunks(i)->count(), chunk_size_name(i)); assert(i != HumongousIndex, "Humongous chunks are handled explicitly later"); } @@ -2254,12 +2199,9 @@ // the current chunk but there are probably exceptions. // Humongous chunks - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s humongous chunks to dictionary", - sum_count_in_chunks_in_use(HumongousIndex), - chunk_size_name(HumongousIndex)); - gclog_or_tty->print("Humongous chunk dictionary: "); - } + log.trace("returned " SIZE_FORMAT " %s humongous chunks to dictionary", + sum_count_in_chunks_in_use(HumongousIndex), chunk_size_name(HumongousIndex)); + log.trace("Humongous chunk dictionary: "); // Humongous chunks are never the current chunk. Metachunk* humongous_chunks = chunks_in_use(HumongousIndex); @@ -2267,11 +2209,7 @@ #ifdef ASSERT humongous_chunks->set_is_tagged_free(true); #endif - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print(PTR_FORMAT " (" SIZE_FORMAT ") ", - p2i(humongous_chunks), - humongous_chunks->word_size()); - } + log.trace(PTR_FORMAT " (" SIZE_FORMAT ") ", p2i(humongous_chunks), humongous_chunks->word_size()); assert(humongous_chunks->word_size() == (size_t) align_size_up(humongous_chunks->word_size(), smallest_chunk_size()), @@ -2283,12 +2221,7 @@ chunk_manager()->humongous_dictionary()->return_chunk(humongous_chunks); humongous_chunks = next_humongous_chunks; } - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->cr(); - gclog_or_tty->print_cr("updated dictionary count " SIZE_FORMAT " %s", - chunk_manager()->humongous_dictionary()->total_count(), - chunk_size_name(HumongousIndex)); - } + log.trace("updated dictionary count " SIZE_FORMAT " %s", chunk_manager()->humongous_dictionary()->total_count(), chunk_size_name(HumongousIndex)); chunk_manager()->slow_locked_verify(); } @@ -2374,11 +2307,13 @@ inc_size_metrics(new_chunk->word_size()); assert(new_chunk->is_empty(), "Not ready for reuse"); - if (TraceMetadataChunkAllocation && Verbose) { - gclog_or_tty->print("SpaceManager::add_chunk: " SIZE_FORMAT ") ", - sum_count_in_chunks_in_use()); - new_chunk->print_on(gclog_or_tty); - chunk_manager()->locked_print_free_chunks(gclog_or_tty); + LogHandle(gc, metaspace, freelist) log; + if (log.is_trace()) { + log.trace("SpaceManager::add_chunk: " SIZE_FORMAT ") ", sum_count_in_chunks_in_use()); + ResourceMark rm; + outputStream* out = log.trace_stream(); + new_chunk->print_on(out); + chunk_manager()->locked_print_free_chunks(out); } } @@ -2403,10 +2338,10 @@ medium_chunk_bunch()); } - if (TraceMetadataHumongousAllocation && next != NULL && + LogHandle(gc, metaspace, alloc) log; + if (log.is_debug() && next != NULL && SpaceManager::is_humongous(next->word_size())) { - gclog_or_tty->print_cr(" new humongous chunk word size " - PTR_FORMAT, next->word_size()); + log.debug(" new humongous chunk word size " PTR_FORMAT, next->word_size()); } return next; @@ -2571,7 +2506,7 @@ } } - if (TraceMetadataChunkAllocation && Verbose) { + if (log_is_enabled(Trace, gc, metaspace, freelist)) { block_freelists()->print_on(out); } @@ -2756,27 +2691,10 @@ } void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) { - gclog_or_tty->print(", [Metaspace:"); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print(" " SIZE_FORMAT - "->" SIZE_FORMAT - "(" SIZE_FORMAT ")", - prev_metadata_used, - used_bytes(), - reserved_bytes()); - } else { - gclog_or_tty->print(" " SIZE_FORMAT "K" - "->" SIZE_FORMAT "K" - "(" SIZE_FORMAT "K)", - prev_metadata_used/K, - used_bytes()/K, - reserved_bytes()/K); - } - - gclog_or_tty->print("]"); + log_info(gc, metaspace)("Metaspace: " SIZE_FORMAT "K->" SIZE_FORMAT "K(" SIZE_FORMAT "K)", + prev_metadata_used/K, used_bytes()/K, reserved_bytes()/K); } -// This is printed when PrintGCDetails void MetaspaceAux::print_on(outputStream* out) { Metaspace::MetadataType nct = Metaspace::NonClassType; @@ -3133,8 +3051,10 @@ initialize_class_space(metaspace_rs); - if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) { - print_compressed_class_space(gclog_or_tty, requested_addr); + if (develop_log_is_enabled(Trace, gc, metaspace)) { + LogHandle(gc, metaspace) log; + ResourceMark rm; + print_compressed_class_space(log.trace_stream(), requested_addr); } } @@ -3256,10 +3176,8 @@ assert(UseCompressedOops && UseCompressedClassPointers, "UseCompressedOops and UseCompressedClassPointers must be set"); Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom()); - if (TraceMetavirtualspaceAllocation && Verbose) { - gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT, - p2i(_space_list->current_virtual_space()->bottom())); - } + log_develop_trace(gc, metaspace)("Setting_narrow_klass_base to Address: " PTR_FORMAT, + p2i(_space_list->current_virtual_space()->bottom())); Universe::set_narrow_klass_shift(0); #endif // _LP64 @@ -3446,10 +3364,7 @@ if (incremented) { tracer()->report_gc_threshold(before, after, MetaspaceGCThresholdUpdater::ExpandAndAllocate); - if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT - " to " SIZE_FORMAT, before, after); - } + log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after); } return res; @@ -3612,13 +3527,15 @@ tracer()->report_metadata_oom(loader_data, word_size, type, mdtype); // If result is still null, we are out of memory. - if (Verbose && TraceMetadataChunkAllocation) { - gclog_or_tty->print_cr("Metaspace allocation failed for size " - SIZE_FORMAT, word_size); + LogHandle(gc, metaspace, freelist) log; + if (log.is_trace()) { + log.trace("Metaspace allocation failed for size " SIZE_FORMAT, word_size); + ResourceMark rm; + outputStream* out = log.trace_stream(); if (loader_data->metaspace_or_null() != NULL) { - loader_data->dump(gclog_or_tty); + loader_data->dump(out); } - MetaspaceAux::dump(gclog_or_tty); + MetaspaceAux::dump(out); } bool out_of_compressed_class_space = false; --- old/src/share/vm/memory/universe.cpp 2015-12-01 12:06:27.230930158 +0100 +++ new/src/share/vm/memory/universe.cpp 2015-12-01 12:06:27.110930163 +0100 @@ -36,8 +36,10 @@ #include "gc/shared/gcLocker.inline.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/generation.hpp" +#include "gc/shared/gcTraceTime.inline.hpp" #include "gc/shared/space.hpp" #include "interpreter/interpreter.hpp" +#include "logging/log.hpp" #include "memory/filemap.hpp" #include "memory/metadataFactory.hpp" #include "memory/metaspaceShared.hpp" @@ -72,6 +74,7 @@ #include "utilities/events.hpp" #include "utilities/hashtable.inline.hpp" #include "utilities/macros.hpp" +#include "utilities/ostream.hpp" #include "utilities/preserveException.hpp" #if INCLUDE_ALL_GCS #include "gc/cms/cmsCollectorPolicy.hpp" @@ -520,7 +523,7 @@ has_run_finalizers_on_exit = true; // Called on VM exit. This ought to be run in a separate thread. - if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit"); + log_trace(ref)("Callback to run finalizers on exit"); { PRESERVE_EXCEPTION_MARK; KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass()); @@ -744,6 +747,7 @@ if (status != JNI_OK) { return status; } + log_info(gc)("Using %s", _collectedHeap->name()); ThreadLocalAllocBuffer::set_max_size(Universe::heap()->max_tlab_size()); @@ -1090,18 +1094,9 @@ _base_vtable_size = ClassLoader::compute_Object_vtable(); } - -void Universe::print() { - print_on(gclog_or_tty); -} - -void Universe::print_on(outputStream* st, bool extended) { +void Universe::print_on(outputStream* st) { st->print_cr("Heap"); - if (!extended) { - heap()->print_on(st); - } else { - heap()->print_extended_on(st); - } + heap()->print_on(st); } void Universe::print_heap_at_SIGBREAK() { @@ -1113,30 +1108,25 @@ } } -void Universe::print_heap_before_gc(outputStream* st, bool ignore_extended) { - st->print_cr("{Heap before GC invocations=%u (full %u):", - heap()->total_collections(), - heap()->total_full_collections()); - if (!PrintHeapAtGCExtended || ignore_extended) { - heap()->print_on(st); - } else { - heap()->print_extended_on(st); +void Universe::print_heap_before_gc() { + LogHandle(gc, heap) log; + if (log.is_trace()) { + log.trace("Heap before GC invocations=%u (full %u):", heap()->total_collections(), heap()->total_full_collections()); + ResourceMark rm; + heap()->print_on(log.trace_stream()); } } -void Universe::print_heap_after_gc(outputStream* st, bool ignore_extended) { - st->print_cr("Heap after GC invocations=%u (full %u):", - heap()->total_collections(), - heap()->total_full_collections()); - if (!PrintHeapAtGCExtended || ignore_extended) { - heap()->print_on(st); - } else { - heap()->print_extended_on(st); +void Universe::print_heap_after_gc() { + LogHandle(gc, heap) log; + if (log.is_trace()) { + log.trace("Heap after GC invocations=%u (full %u):", heap()->total_collections(), heap()->total_full_collections()); + ResourceMark rm; + heap()->print_on(log.trace_stream()); } - st->print_cr("}"); } -void Universe::verify(VerifyOption option, const char* prefix, bool silent) { +void Universe::verify(VerifyOption option, const char* prefix) { // The use of _verify_in_progress is a temporary work around for // 6320749. Don't bother with a creating a class to set and clear // it since it is only used in this method and the control flow is @@ -1153,36 +1143,35 @@ HandleMark hm; // Handles created during verification can be zapped _verify_count++; - if (!silent) gclog_or_tty->print("%s", prefix); - if (!silent) gclog_or_tty->print("[Verifying "); - if (!silent) gclog_or_tty->print("threads "); + FormatBuffer<> title("Verifying %s", prefix); + GCTraceTime(Info, gc, verify) tm(title.buffer()); + log_debug(gc, verify)("Threads"); Threads::verify(); - if (!silent) gclog_or_tty->print("heap "); - heap()->verify(silent, option); - if (!silent) gclog_or_tty->print("syms "); + log_debug(gc, verify)("Heap"); + heap()->verify(option); + log_debug(gc, verify)("SymbolTable"); SymbolTable::verify(); - if (!silent) gclog_or_tty->print("strs "); + log_debug(gc, verify)("StringTable"); StringTable::verify(); { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); - if (!silent) gclog_or_tty->print("zone "); + log_debug(gc, verify)("CodeCache"); CodeCache::verify(); } - if (!silent) gclog_or_tty->print("dict "); + log_debug(gc, verify)("SystemDictionary"); SystemDictionary::verify(); #ifndef PRODUCT - if (!silent) gclog_or_tty->print("cldg "); + log_debug(gc, verify)("ClassLoaderDataGraph"); ClassLoaderDataGraph::verify(); #endif - if (!silent) gclog_or_tty->print("metaspace chunks "); + log_debug(gc, verify)("MetaspaceAux"); MetaspaceAux::verify_free_chunks(); - if (!silent) gclog_or_tty->print("hand "); + log_debug(gc, verify)("JNIHandles"); JNIHandles::verify(); - if (!silent) gclog_or_tty->print("C-heap "); + log_debug(gc, verify)("C-heap"); os::check_heap(); - if (!silent) gclog_or_tty->print("code cache "); + log_debug(gc, verify)("CodeCache Oops"); CodeCache::verify_oops(); - if (!silent) gclog_or_tty->print_cr("]"); _verify_in_progress = false; } --- old/src/share/vm/memory/universe.hpp 2015-12-01 12:06:27.438930151 +0100 +++ new/src/share/vm/memory/universe.hpp 2015-12-01 12:06:27.322930155 +0100 @@ -460,26 +460,19 @@ // Debugging static bool verify_in_progress() { return _verify_in_progress; } - static void verify(VerifyOption option, const char* prefix, bool silent = VerifySilently); - static void verify(const char* prefix, bool silent = VerifySilently) { - verify(VerifyOption_Default, prefix, silent); + static void verify(VerifyOption option, const char* prefix); + static void verify(const char* prefix) { + verify(VerifyOption_Default, prefix); } - static void verify(bool silent = VerifySilently) { - verify("", silent); + static void verify() { + verify(""); } static int verify_count() { return _verify_count; } - // The default behavior is to call print_on() on gclog_or_tty. - static void print(); - // The extended parameter determines which method on the heap will - // be called: print_on() (extended == false) or print_extended_on() - // (extended == true). - static void print_on(outputStream* st, bool extended = false); + static void print_on(outputStream* st); static void print_heap_at_SIGBREAK(); - static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); } - static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); } - static void print_heap_before_gc(outputStream* st, bool ignore_extended = false); - static void print_heap_after_gc(outputStream* st, bool ignore_extended = false); + static void print_heap_before_gc(); + static void print_heap_after_gc(); // Change the number of dummy objects kept reachable by the full gc dummy // array; this should trigger relocation in a sliding compaction collector. --- old/src/share/vm/oops/instanceKlass.cpp 2015-12-01 12:06:27.618930145 +0100 +++ new/src/share/vm/oops/instanceKlass.cpp 2015-12-01 12:06:27.514930149 +0100 @@ -3084,7 +3084,7 @@ oop obj = oopDesc::load_decode_heap_oop(p); if (!obj->is_oop_or_null()) { tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p2i(p), p2i(obj)); - Universe::print(); + Universe::print_on(tty); guarantee(false, "boom"); } } --- old/src/share/vm/oops/instanceRefKlass.inline.hpp 2015-12-01 12:06:27.838930137 +0100 +++ new/src/share/vm/oops/instanceRefKlass.inline.hpp 2015-12-01 12:06:27.738930141 +0100 @@ -27,6 +27,7 @@ #include "classfile/javaClasses.hpp" #include "gc/shared/referenceProcessor.hpp" +#include "logging/log.hpp" #include "oops/instanceKlass.inline.hpp" #include "oops/instanceRefKlass.hpp" #include "oops/oop.inline.hpp" @@ -59,12 +60,7 @@ // Treat discovered as normal oop, if ref is not "active" (next non-NULL) if (!oopDesc::is_null(next_oop) && contains(disc_addr)) { // i.e. ref is not "active" - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(disc_addr)); - } - ) + log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(disc_addr)); Devirtualizer::do_oop(closure, disc_addr); } // treat next as normal oop --- old/src/share/vm/prims/jni.cpp 2015-12-01 12:06:27.998930132 +0100 +++ new/src/share/vm/prims/jni.cpp 2015-12-01 12:06:27.910930135 +0100 @@ -3914,7 +3914,6 @@ run_unit_test(QuickSort::test_quick_sort()); run_unit_test(GuardedMemory::test_guarded_memory()); run_unit_test(AltHashing::test_alt_hash()); - run_unit_test(test_loggc_filename()); run_unit_test(TestNewSize_test()); run_unit_test(TestOldSize_test()); run_unit_test(TestKlass_test()); --- old/src/share/vm/prims/jvmtiEnv.cpp 2015-12-01 12:06:28.246930123 +0100 +++ new/src/share/vm/prims/jvmtiEnv.cpp 2015-12-01 12:06:28.126930127 +0100 @@ -29,6 +29,7 @@ #include "interpreter/bytecodeStream.hpp" #include "interpreter/interpreter.hpp" #include "jvmtifiles/jvmtiEnv.hpp" +#include "logging/logConfiguration.hpp" #include "memory/resourceArea.hpp" #include "memory/universe.inline.hpp" #include "oops/instanceKlass.hpp" @@ -628,7 +629,14 @@ TraceClassUnloading = value != 0; break; case JVMTI_VERBOSE_GC: - PrintGC = value != 0; + { + MutexLocker ml(LogConfiguration_lock); + if (value == 0) { + LogConfiguration::parse_log_arguments("stdout", "gc=off", NULL, NULL, NULL); + } else { + LogConfiguration::parse_log_arguments("stdout", "gc", NULL, NULL, NULL); + } + } break; case JVMTI_VERBOSE_JNI: PrintJNIResolving = value != 0; --- old/src/share/vm/prims/whitebox.cpp 2015-12-01 12:06:28.478930115 +0100 +++ new/src/share/vm/prims/whitebox.cpp 2015-12-01 12:06:28.358930119 +0100 @@ -159,7 +159,7 @@ WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) { CollectorPolicy * p = Universe::heap()->collector_policy(); - gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " + tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT, p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(), p->space_alignment(), p->heap_alignment()); --- old/src/share/vm/runtime/arguments.cpp 2015-12-01 12:06:28.682930108 +0100 +++ new/src/share/vm/runtime/arguments.cpp 2015-12-01 12:06:28.574930112 +0100 @@ -32,6 +32,7 @@ #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/referenceProcessor.hpp" #include "gc/shared/taskqueue.hpp" +#include "logging/log.hpp" #include "logging/logConfiguration.hpp" #include "memory/allocation.inline.hpp" #include "memory/universe.inline.hpp" @@ -81,7 +82,6 @@ int Arguments::_num_jvm_args = 0; char* Arguments::_java_command = NULL; SystemProperty* Arguments::_system_properties = NULL; -const char* Arguments::_gc_log_filename = NULL; bool Arguments::_has_profile = false; size_t Arguments::_conservative_max_heap_alignment = 0; size_t Arguments::_min_heap_size = 0; @@ -1617,19 +1617,11 @@ } else { FLAG_SET_ERGO(size_t, MaxNewSize, preferred_max_new_size); } - if (PrintGCDetails && Verbose) { - // Too early to use gclog_or_tty - tty->print_cr("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize); - } + log_trace(gc, heap)("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize); // Code along this path potentially sets NewSize and OldSize - if (PrintGCDetails && Verbose) { - // Too early to use gclog_or_tty - tty->print_cr("CMS set min_heap_size: " SIZE_FORMAT - " initial_heap_size: " SIZE_FORMAT - " max_heap: " SIZE_FORMAT, - min_heap_size(), InitialHeapSize, max_heap); - } + log_trace(gc, heap)("CMS set min_heap_size: " SIZE_FORMAT " initial_heap_size: " SIZE_FORMAT " max_heap: " SIZE_FORMAT, + min_heap_size(), InitialHeapSize, max_heap); size_t min_new = preferred_max_new_size; if (FLAG_IS_CMDLINE(NewSize)) { min_new = NewSize; @@ -1640,20 +1632,14 @@ if (FLAG_IS_DEFAULT(NewSize)) { FLAG_SET_ERGO(size_t, NewSize, MAX2(NewSize, min_new)); FLAG_SET_ERGO(size_t, NewSize, MIN2(preferred_max_new_size, NewSize)); - if (PrintGCDetails && Verbose) { - // Too early to use gclog_or_tty - tty->print_cr("CMS ergo set NewSize: " SIZE_FORMAT, NewSize); - } + log_trace(gc, heap)("CMS ergo set NewSize: " SIZE_FORMAT, NewSize); } // Unless explicitly requested otherwise, size old gen // so it's NewRatio x of NewSize. if (FLAG_IS_DEFAULT(OldSize)) { if (max_heap > NewSize) { FLAG_SET_ERGO(size_t, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize)); - if (PrintGCDetails && Verbose) { - // Too early to use gclog_or_tty - tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize); - } + log_trace(gc, heap)("CMS ergo set OldSize: " SIZE_FORMAT, OldSize); } } } @@ -1697,11 +1683,8 @@ FLAG_SET_CMDLINE(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false); } - if (PrintGCDetails && Verbose) { - tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", - (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K)); - tty->print_cr("ConcGCThreads: %u", ConcGCThreads); - } + log_trace(gc)("MarkStackSize: %uk MarkStackSizeMax: %uk", (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K)); + log_trace(gc)("ConcGCThreads: %u", ConcGCThreads); } #endif // INCLUDE_ALL_GCS @@ -1748,11 +1731,7 @@ if (UseAutoGCSelectPolicy && !FLAG_IS_DEFAULT(MaxGCPauseMillis) && (MaxGCPauseMillis <= AutoGCSelectPauseMillis)) { - if (PrintGCDetails) { - // Cannot use gclog_or_tty yet. - tty->print_cr("Automatic selection of the low pause collector" - " based on pause goal of %d (ms)", (int) MaxGCPauseMillis); - } + log_trace(gc)("Automatic selection of the low pause collector based on pause goal of %d (ms)", (int) MaxGCPauseMillis); return true; } return false; @@ -1974,11 +1953,8 @@ FLAG_SET_DEFAULT(GCTimeRatio, 9); } - if (PrintGCDetails && Verbose) { - tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", - (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K)); - tty->print_cr("ConcGCThreads: %u", ConcGCThreads); - } + log_trace(gc)("MarkStackSize: %uk MarkStackSizeMax: %uk", (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K)); + log_trace(gc)("ConcGCThreads: %u", ConcGCThreads); } #if !INCLUDE_ALL_GCS @@ -2090,10 +2066,7 @@ reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize); } - if (PrintGCDetails && Verbose) { - // Cannot use gclog_or_tty yet. - tty->print_cr(" Maximum heap size " SIZE_FORMAT, (size_t) reasonable_max); - } + log_trace(gc, heap)(" Maximum heap size " SIZE_FORMAT, (size_t) reasonable_max); FLAG_SET_ERGO(size_t, MaxHeapSize, (size_t)reasonable_max); } @@ -2114,20 +2087,14 @@ reasonable_initial = limit_by_allocatable_memory(reasonable_initial); - if (PrintGCDetails && Verbose) { - // Cannot use gclog_or_tty yet. - tty->print_cr(" Initial heap size " SIZE_FORMAT, (size_t)reasonable_initial); - } + log_trace(gc, heap)(" Initial heap size " SIZE_FORMAT, (size_t)reasonable_initial); FLAG_SET_ERGO(size_t, InitialHeapSize, (size_t)reasonable_initial); } // If the minimum heap size has not been set (via -Xms), // synchronize with InitialHeapSize to avoid errors with the default value. if (min_heap_size() == 0) { set_min_heap_size(MIN2((size_t)reasonable_minimum, InitialHeapSize)); - if (PrintGCDetails && Verbose) { - // Cannot use gclog_or_tty yet. - tty->print_cr(" Minimum heap size " SIZE_FORMAT, min_heap_size()); - } + log_trace(gc, heap)(" Minimum heap size " SIZE_FORMAT, min_heap_size()); } } } @@ -2330,77 +2297,8 @@ //=========================================================================================================== // Parsing of main arguments -// check if do gclog rotation -// +UseGCLogFileRotation is a must, -// no gc log rotation when log file not supplied or -// NumberOfGCLogFiles is 0 -void check_gclog_consistency() { - if (UseGCLogFileRotation) { - if ((Arguments::gc_log_filename() == NULL) || (NumberOfGCLogFiles == 0)) { - jio_fprintf(defaultStream::output_stream(), - "To enable GC log rotation, use -Xloggc: -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=\n" - "where num_of_file > 0\n" - "GC log rotation is turned off\n"); - UseGCLogFileRotation = false; - } - } - - if (UseGCLogFileRotation && (GCLogFileSize != 0) && (GCLogFileSize < 8*K)) { - if (FLAG_SET_CMDLINE(size_t, GCLogFileSize, 8*K) == Flag::SUCCESS) { - jio_fprintf(defaultStream::output_stream(), - "GCLogFileSize changed to minimum 8K\n"); - } - } -} - -// This function is called for -Xloggc:, it can be used -// to check if a given file name(or string) conforms to the following -// specification: -// A valid string only contains "[A-Z][a-z][0-9].-_%[p|t]" -// %p and %t only allowed once. We only limit usage of filename not path -bool is_filename_valid(const char *file_name) { - const char* p = file_name; - char file_sep = os::file_separator()[0]; - const char* cp; - // skip prefix path - for (cp = file_name; *cp != '\0'; cp++) { - if (*cp == '/' || *cp == file_sep) { - p = cp + 1; - } - } - - int count_p = 0; - int count_t = 0; - while (*p != '\0') { - if ((*p >= '0' && *p <= '9') || - (*p >= 'A' && *p <= 'Z') || - (*p >= 'a' && *p <= 'z') || - *p == '-' || - *p == '_' || - *p == '.') { - p++; - continue; - } - if (*p == '%') { - if(*(p + 1) == 'p') { - p += 2; - count_p ++; - continue; - } - if (*(p + 1) == 't') { - p += 2; - count_t ++; - continue; - } - } - return false; - } - return count_p < 2 && count_t < 2; -} - // Check consistency of GC selection bool Arguments::check_gc_consistency() { - check_gclog_consistency(); // Ensure that the user has not selected conflicting sets // of collectors. uint i = 0; @@ -2750,7 +2648,9 @@ return JNI_EINVAL; } } else if (!strcmp(tail, ":gc")) { - if (FLAG_SET_CMDLINE(bool, PrintGC, true) != Flag::SUCCESS) { + // LogConfiguration_lock is not set up yet, but this code is executed by a single thread + bool ret = LogConfiguration::parse_log_arguments("stdout", "gc", NULL, NULL, NULL); + if (!ret) { return JNI_EINVAL; } } else if (!strcmp(tail, ":jni")) { @@ -3183,24 +3083,6 @@ // -Xnoagent } else if (match_option(option, "-Xnoagent")) { // For compatibility with classic. HotSpot refuses to load the old style agent.dll. - } else if (match_option(option, "-Xloggc:", &tail)) { - // Redirect GC output to the file. -Xloggc: - // ostream_init_log(), when called will use this filename - // to initialize a fileStream. - _gc_log_filename = os::strdup_check_oom(tail); - if (!is_filename_valid(_gc_log_filename)) { - jio_fprintf(defaultStream::output_stream(), - "Invalid file name for use with -Xloggc: Filename can only contain the " - "characters [A-Z][a-z][0-9]-_.%%[p|t] but it has been %s\n" - "Note %%p or %%t can only be used once\n", _gc_log_filename); - return JNI_EINVAL; - } - if (FLAG_SET_CMDLINE(bool, PrintGC, true) != Flag::SUCCESS) { - return JNI_EINVAL; - } - if (FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true) != Flag::SUCCESS) { - return JNI_EINVAL; - } } else if (match_option(option, "-Xlog", &tail)) { bool ret = false; if (strcmp(tail, ":help") == 0) { @@ -4205,11 +4087,6 @@ ScavengeRootsInCode = 1; } - if (PrintGCDetails) { - // Turn on -verbose:gc options as well - PrintGC = true; - } - // Set object alignment values. set_object_alignment(); --- old/src/share/vm/runtime/arguments.hpp 2015-12-01 12:06:28.926930099 +0100 +++ new/src/share/vm/runtime/arguments.hpp 2015-12-01 12:06:28.806930104 +0100 @@ -284,7 +284,6 @@ // Option flags static bool _has_profile; - static const char* _gc_log_filename; // Value of the conservative maximum heap alignment needed static size_t _conservative_max_heap_alignment; @@ -543,9 +542,6 @@ // -Dsun.java.launcher.pid static int sun_java_launcher_pid() { return _sun_java_launcher_pid; } - // -Xloggc:, if not specified will be NULL - static const char* gc_log_filename() { return _gc_log_filename; } - // -Xprof static bool has_profile() { return _has_profile; } --- old/src/share/vm/runtime/globals.hpp 2015-12-01 12:06:29.126930092 +0100 +++ new/src/share/vm/runtime/globals.hpp 2015-12-01 12:06:28.998930097 +0100 @@ -983,9 +983,6 @@ develop(bool, ZapUnusedHeapArea, trueInDebug, \ "Zap unused heap space with 0xBAADBABE") \ \ - develop(bool, TraceZapUnusedHeapArea, false, \ - "Trace zapping of unused heap space") \ - \ develop(bool, CheckZapUnusedHeapArea, false, \ "Check zapping of unused heap space") \ \ @@ -995,12 +992,6 @@ develop(bool, PrintVMMessages, true, \ "Print VM messages on console") \ \ - product(bool, PrintGCApplicationConcurrentTime, false, \ - "Print the time the application has been running") \ - \ - product(bool, PrintGCApplicationStoppedTime, false, \ - "Print the time the application has been stopped") \ - \ diagnostic(bool, VerboseVerification, false, \ "Display detailed verification details") \ \ @@ -1571,9 +1562,6 @@ "number of GC threads") \ range((size_t)os::vm_page_size(), (size_t)max_uintx) \ \ - product(bool, TraceDynamicGCThreads, false, \ - "Trace the dynamic GC thread usage") \ - \ product(uint, ConcGCThreads, 0, \ "Number of threads concurrent gc will use") \ constraint(ConcGCThreadsConstraintFunc,AfterErgo) \ @@ -1623,12 +1611,6 @@ product(bool, UseParNewGC, false, \ "Use parallel threads in the new generation") \ \ - product(bool, PrintTaskqueue, false, \ - "Print taskqueue statistics for parallel collectors") \ - \ - product(bool, PrintTerminationStats, false, \ - "Print termination statistics for parallel collectors") \ - \ product(uintx, ParallelGCBufferWastePct, 10, \ "Wasted fraction of parallel allocation buffer") \ range(0, 100) \ @@ -1646,9 +1628,6 @@ product(bool, ResizePLAB, true, \ "Dynamically resize (survivor space) promotion LAB's") \ \ - product(bool, PrintPLAB, false, \ - "Print (survivor space) promotion LAB's sizing decisions") \ - \ product(intx, ParGCArrayScanChunk, 50, \ "Scan a subset of object array and push remainder, if array is " \ "bigger than this") \ @@ -1691,9 +1670,6 @@ product(bool, ResizeOldPLAB, true, \ "Dynamically resize (old gen) promotion LAB's") \ \ - product(bool, PrintOldPLAB, false, \ - "Print (old gen) promotion LAB's sizing decisions") \ - \ product(size_t, CMSOldPLABMax, 1024, \ "Maximum size of CMS gen promotion LAB caches per worker " \ "per block size") \ @@ -1885,10 +1861,6 @@ "Always record eden chunks used for the parallel initial mark " \ "or remark of eden") \ \ - product(bool, CMSPrintEdenSurvivorChunks, false, \ - "Print the eden and the survivor chunks used for the parallel " \ - "initial mark or remark of the eden/survivor spaces") \ - \ product(bool, CMSConcurrentMTEnabled, true, \ "Whether multi-threaded concurrent work enabled " \ "(effective only if ParNewGC)") \ @@ -1956,9 +1928,6 @@ product(bool, CMSScavengeBeforeRemark, false, \ "Attempt scavenge before the CMS remark step") \ \ - develop(bool, CMSTraceSweeper, false, \ - "Trace some actions of the CMS sweeper") \ - \ product(uintx, CMSWorkQueueDrainThreshold, 10, \ "Don't drain below this size per parallel worker/thief") \ range(1, max_juint) \ @@ -1979,17 +1948,15 @@ "between yields") \ range(1, max_uintx) \ \ - product(bool, CMSDumpAtPromotionFailure, false, \ - "Dump useful information about the state of the CMS old " \ - "generation upon a promotion failure") \ - \ product(bool, CMSPrintChunksInDump, false, \ - "In a dump enabled by CMSDumpAtPromotionFailure, include " \ - "more detailed information about the free chunks") \ + "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ + "trace level include more detailed information about the" \ + "free chunks") \ \ product(bool, CMSPrintObjectsInDump, false, \ - "In a dump enabled by CMSDumpAtPromotionFailure, include " \ - "more detailed information about the allocated objects") \ + "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ + "trace level include more detailed information about the" \ + "allocated objects") \ \ diagnostic(bool, FLSVerifyAllHeapReferences, false, \ "Verify that all references across the FLS boundary " \ @@ -2011,9 +1978,6 @@ "Maintain _unallocated_block in BlockOffsetArray " \ "(currently applicable only to CMS collector)") \ \ - develop(bool, TraceCMSState, false, \ - "Trace the state of the CMS collection") \ - \ product(intx, RefDiscoveryPolicy, 0, \ "Select type of reference discovery policy: " \ "reference-based(0) or referent-based(1)") \ @@ -2081,10 +2045,6 @@ notproduct(bool, GCALotAtAllSafepoints, false, \ "Enforce ScavengeALot/GCALot at all potential safepoints") \ \ - product(bool, PrintPromotionFailure, false, \ - "Print additional diagnostic information following " \ - "promotion failure") \ - \ notproduct(bool, PromotionFailureALot, false, \ "Use promotion failure handling on every youngest generation " \ "collection") \ @@ -2124,12 +2084,6 @@ develop(bool, TraceMetadataChunkAllocation, false, \ "Trace chunk metadata allocations") \ \ - product(bool, TraceMetadataHumongousAllocation, false, \ - "Trace humongous metadata allocations") \ - \ - develop(bool, TraceMetavirtualspaceAllocation, false, \ - "Trace virtual space metadata allocations") \ - \ notproduct(bool, ExecuteInternalVMTests, false, \ "Enable execution of internal VM tests") \ \ @@ -2147,12 +2101,8 @@ product(bool, FastTLABRefill, true, \ "Use fast TLAB refill code") \ \ - product(bool, PrintTLAB, false, \ - "Print various TLAB related information") \ - \ product(bool, TLABStats, true, \ - "Provide more detailed and expensive TLAB statistics " \ - "(with PrintTLAB)") \ + "Provide more detailed and expensive TLAB statistics.") \ \ product_pd(bool, NeverActAsServerClassMachine, \ "Never act like a server-class machine") \ @@ -2210,9 +2160,6 @@ product(bool, UseAdaptiveGCBoundary, false, \ "Allow young-old boundary to move") \ \ - develop(bool, TraceAdaptiveGCBoundary, false, \ - "Trace young-old boundary moves") \ - \ develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \ "Resize the virtual spaces of the young or old generations") \ range(-1, 1) \ @@ -2337,9 +2284,6 @@ "Number of consecutive collections before gc time limit fires") \ range(1, max_uintx) \ \ - product(bool, PrintAdaptiveSizePolicy, false, \ - "Print information about AdaptiveSizePolicy") \ - \ product(intx, PrefetchCopyIntervalInBytes, -1, \ "How far ahead to prefetch destination area (<= 0 means off)") \ \ @@ -2349,9 +2293,6 @@ product(intx, PrefetchFieldsAhead, -1, \ "How many fields ahead to prefetch in oop scan (<= 0 means off)") \ \ - diagnostic(bool, VerifySilently, false, \ - "Do not print the verification progress") \ - \ diagnostic(bool, VerifyDuringStartup, false, \ "Verify memory system before executing any Java code " \ "during VM initialization") \ @@ -2413,37 +2354,11 @@ "Number of times a GC thread (minus the coordinator) " \ "will sleep while yielding before giving up and resuming GC") \ \ - /* gc tracing */ \ - manageable(bool, PrintGC, false, \ - "Print message at garbage collection") \ - \ - manageable(bool, PrintGCDetails, false, \ - "Print more details at garbage collection") \ - \ - manageable(bool, PrintGCDateStamps, false, \ - "Print date stamps at garbage collection") \ - \ - manageable(bool, PrintGCTimeStamps, false, \ - "Print timestamps at garbage collection") \ - \ - manageable(bool, PrintGCID, true, \ - "Print an identifier for each garbage collection") \ - \ - product(bool, PrintGCTaskTimeStamps, false, \ - "Print timestamps for individual gc worker thread tasks") \ - \ develop(intx, ConcGCYieldTimeout, 0, \ "If non-zero, assert that GC threads yield within this " \ "number of milliseconds") \ range(0, max_intx) \ \ - product(bool, PrintReferenceGC, false, \ - "Print times spent handling reference objects during GC " \ - "(enabled only when PrintGCDetails)") \ - \ - develop(bool, TraceReferenceGC, false, \ - "Trace handling of soft/weak/final/phantom references") \ - \ develop(bool, TraceFinalizerRegistration, false, \ "Trace registration of final references") \ \ @@ -2483,37 +2398,15 @@ product(bool, TraceOldGenTime, false, \ "Trace accumulated time for old collection") \ \ - product(bool, PrintTenuringDistribution, false, \ - "Print tenuring age information") \ - \ - product_rw(bool, PrintHeapAtGC, false, \ - "Print heap layout before and after each GC") \ - \ - product_rw(bool, PrintHeapAtGCExtended, false, \ - "Print extended information about the layout of the heap " \ - "when -XX:+PrintHeapAtGC is set") \ - \ product(bool, PrintHeapAtSIGBREAK, true, \ "Print heap layout in response to SIGBREAK") \ \ - manageable(bool, PrintClassHistogramBeforeFullGC, false, \ - "Print a class histogram before any major stop-world GC") \ - \ - manageable(bool, PrintClassHistogramAfterFullGC, false, \ - "Print a class histogram after any major stop-world GC") \ - \ manageable(bool, PrintClassHistogram, false, \ "Print a histogram of class instances") \ \ develop(bool, TraceWorkGang, false, \ "Trace activities of work gangs") \ \ - develop(bool, TraceBlockOffsetTable, false, \ - "Print BlockOffsetTable maps") \ - \ - develop(bool, TraceCardTableModRefBS, false, \ - "Print CardTableModRefBS maps") \ - \ develop(bool, TraceGCTaskManager, false, \ "Trace actions of the GC task manager") \ \ @@ -2523,48 +2416,20 @@ diagnostic(bool, TraceGCTaskThread, false, \ "Trace actions of the GC task threads") \ \ - product(bool, PrintParallelOldGCPhaseTimes, false, \ - "Print the time taken by each phase in ParallelOldGC " \ - "(PrintGCDetails must also be enabled)") \ - \ develop(bool, TraceParallelOldGCMarkingPhase, false, \ "Trace marking phase in ParallelOldGC") \ \ - develop(bool, TraceParallelOldGCSummaryPhase, false, \ - "Trace summary phase in ParallelOldGC") \ - \ - develop(bool, TraceParallelOldGCCompactionPhase, false, \ - "Trace compaction phase in ParallelOldGC") \ - \ develop(bool, TraceParallelOldGCDensePrefix, false, \ "Trace dense prefix computation for ParallelOldGC") \ \ develop(bool, IgnoreLibthreadGPFault, false, \ "Suppress workaround for libthread GP fault") \ \ - product(bool, PrintJNIGCStalls, false, \ - "Print diagnostic message when GC is stalled " \ - "by JNI critical section") \ - \ experimental(double, ObjectCountCutOffPercent, 0.5, \ "The percentage of the used heap that the instances of a class " \ "must occupy for the class to generate a trace event") \ range(0.0, 100.0) \ \ - /* GC log rotation setting */ \ - \ - product(bool, UseGCLogFileRotation, false, \ - "Rotate gclog files (for long running applications). It requires "\ - "-Xloggc:") \ - \ - product(uintx, NumberOfGCLogFiles, 0, \ - "Number of gclog files in rotation " \ - "(default: 0, no rotation)") \ - \ - product(size_t, GCLogFileSize, 8*K, \ - "GC log file size, requires UseGCLogFileRotation. " \ - "Set to 0 to only trigger rotation via jcmd") \ - \ /* JVMTI heap profiling */ \ \ diagnostic(bool, TraceJVMTIObjectTagging, false, \ @@ -3486,18 +3351,6 @@ "space parameters)") \ range(1, max_uintx) \ \ - product(intx, PrintCMSStatistics, 0, \ - "Statistics for CMS") \ - \ - product(bool, PrintCMSInitiationStatistics, false, \ - "Statistics for initiating a CMS collection") \ - \ - product(intx, PrintFLSStatistics, 0, \ - "Statistics for CMS' FreeListSpace") \ - \ - product(intx, PrintFLSCensus, 0, \ - "Census for CMS' FreeListSpace") \ - \ develop(uintx, GCExpandToAllocateDelayMillis, 0, \ "Delay between expansion and allocation (in milliseconds)") \ \ @@ -4191,9 +4044,6 @@ product(bool, UseStringDeduplication, false, \ "Use string deduplication") \ \ - product(bool, PrintStringDeduplicationStatistics, false, \ - "Print string deduplication statistics") \ - \ product(uintx, StringDeduplicationAgeThreshold, 3, \ "A string must reach this age (or be promoted to an old region) " \ "to be considered for deduplication") \ @@ -4208,9 +4058,6 @@ diagnostic(bool, WhiteBoxAPI, false, \ "Enable internal testing APIs") \ \ - product(bool, PrintGCCause, true, \ - "Include GC cause in GC logging") \ - \ experimental(intx, SurvivorAlignmentInBytes, 0, \ "Default survivor space alignment in bytes") \ constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \ --- old/src/share/vm/runtime/interfaceSupport.cpp 2015-12-01 12:06:29.378930084 +0100 +++ new/src/share/vm/runtime/interfaceSupport.cpp 2015-12-01 12:06:29.262930088 +0100 @@ -102,15 +102,13 @@ // Compute new interval if (FullGCALotInterval > 1) { _fullgc_alot_counter = 1+(long)((double)FullGCALotInterval*os::random()/(max_jint+1.0)); - if (PrintGCDetails && Verbose) { - tty->print_cr("Full gc no: %u\tInterval: %ld", invocations, _fullgc_alot_counter); - } + log_trace(gc)("Full gc no: %u\tInterval: %ld", invocations, _fullgc_alot_counter); } else { _fullgc_alot_counter = 1; } // Print progress message if (invocations % 100 == 0) { - if (PrintGCDetails && Verbose) tty->print_cr("Full gc no: %u", invocations); + log_trace(gc)("Full gc no: %u", invocations); } } else { if (ScavengeALot) _scavenge_alot_counter--; @@ -122,15 +120,13 @@ // Compute new interval if (ScavengeALotInterval > 1) { _scavenge_alot_counter = 1+(long)((double)ScavengeALotInterval*os::random()/(max_jint+1.0)); - if (PrintGCDetails && Verbose) { - tty->print_cr("Scavenge no: %u\tInterval: %ld", invocations, _scavenge_alot_counter); - } + log_trace(gc)("Scavenge no: %u\tInterval: %ld", invocations, _scavenge_alot_counter); } else { _scavenge_alot_counter = 1; } // Print progress message if (invocations % 1000 == 0) { - if (PrintGCDetails && Verbose) tty->print_cr("Scavenge no: %u", invocations); + log_trace(gc)("Scavenge no: %u", invocations); } } } --- old/src/share/vm/runtime/java.cpp 2015-12-01 12:06:29.586930076 +0100 +++ new/src/share/vm/runtime/java.cpp 2015-12-01 12:06:29.458930081 +0100 @@ -35,6 +35,7 @@ #include "jvmci/jvmciCompiler.hpp" #include "jvmci/jvmciRuntime.hpp" #endif +#include "logging/log.hpp" #include "memory/oopFactory.hpp" #include "memory/universe.hpp" #include "oops/constantPool.hpp" @@ -453,13 +454,15 @@ Universe::heap()->stop(); // Print GC/heap related information. - if (PrintGCDetails) { - Universe::print(); - AdaptiveSizePolicyOutput(0); - if (Verbose) { - ClassLoaderDataGraph::dump_on(gclog_or_tty); + LogHandle(gc, heap, exit) log; + if (log.is_info()) { + ResourceMark rm; + Universe::print_on(log.info_stream()); + if (log.is_trace()) { + ClassLoaderDataGraph::dump_on(log.trace_stream()); } } + AdaptiveSizePolicyOutput::print(); if (PrintBytecodeHistogram) { BytecodeHistogram::print(); --- old/src/share/vm/runtime/jniHandles.cpp 2015-12-01 12:06:29.774930070 +0100 +++ new/src/share/vm/runtime/jniHandles.cpp 2015-12-01 12:06:29.658930074 +0100 @@ -24,6 +24,7 @@ #include "precompiled.hpp" #include "classfile/systemDictionary.hpp" +#include "logging/log.hpp" #include "oops/oop.inline.hpp" #include "prims/jvmtiExport.hpp" #include "runtime/jniHandles.hpp" @@ -393,9 +394,7 @@ f->do_oop(root); } else { // The weakly referenced object is not alive, clear the reference by storing NULL - if (TraceReferenceGC) { - tty->print_cr("Clearing JNI weak reference (" INTPTR_FORMAT ")", p2i(root)); - } + log_develop_trace(gc, ref)("Clearing JNI weak reference (" INTPTR_FORMAT ")", p2i(root)); *root = NULL; } } --- old/src/share/vm/runtime/os.cpp 2015-12-01 12:06:29.978930063 +0100 +++ new/src/share/vm/runtime/os.cpp 2015-12-01 12:06:29.858930067 +0100 @@ -262,7 +262,7 @@ VMThread::execute(&op1); Universe::print_heap_at_SIGBREAK(); if (PrintClassHistogram) { - VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */); + VM_GC_HeapInspection op1(tty, true /* force full GC before heap inspection */); VMThread::execute(&op1); } if (JvmtiExport::should_post_data_dump()) { --- old/src/share/vm/runtime/safepoint.cpp 2015-12-01 12:06:30.202930055 +0100 +++ new/src/share/vm/runtime/safepoint.cpp 2015-12-01 12:06:30.086930059 +0100 @@ -514,11 +514,6 @@ StringTable::rehash_table(); } - // rotate log files? - if (UseGCLogFileRotation) { - gclog_or_tty->rotate_log(false); - } - { // CMS delays purging the CLDG until the beginning of the next safepoint and to // make sure concurrent sweep is done --- old/src/share/vm/runtime/timer.cpp 2015-12-01 12:06:30.406930048 +0100 +++ new/src/share/vm/runtime/timer.cpp 2015-12-01 12:06:30.290930052 +0100 @@ -120,7 +120,6 @@ if (_active) { _accum = NULL; - tty->stamp(PrintGCTimeStamps); tty->print("[%s", title); tty->flush(); _t.start(); @@ -135,7 +134,6 @@ _verbose = verbose; if (_active) { if (_verbose) { - tty->stamp(PrintGCTimeStamps); tty->print("[%s", title); tty->flush(); } --- old/src/share/vm/runtime/vmThread.cpp 2015-12-01 12:06:30.614930041 +0100 +++ new/src/share/vm/runtime/vmThread.cpp 2015-12-01 12:06:30.490930045 +0100 @@ -286,7 +286,7 @@ os::check_heap(); // Silent verification so as not to pollute normal output, // unless we really asked for it. - Universe::verify(!(PrintGCDetails || Verbose) || VerifySilently); + Universe::verify(); } CompileBroker::set_should_block(); --- old/src/share/vm/runtime/vm_operations.cpp 2015-12-01 12:06:30.822930033 +0100 +++ new/src/share/vm/runtime/vm_operations.cpp 2015-12-01 12:06:30.706930037 +0100 @@ -189,7 +189,7 @@ void VM_Verify::doit() { Universe::heap()->prepare_for_verify(); - Universe::verify(_silent); + Universe::verify(); } bool VM_PrintThreads::doit_prologue() { --- old/src/share/vm/runtime/vm_operations.hpp 2015-12-01 12:06:31.030930026 +0100 +++ new/src/share/vm/runtime/vm_operations.hpp 2015-12-01 12:06:30.910930030 +0100 @@ -311,10 +311,7 @@ }; class VM_Verify: public VM_Operation { - private: - bool _silent; public: - VM_Verify(bool silent = VerifySilently) : _silent(silent) {} VMOp_Type type() const { return VMOp_Verify; } void doit(); }; @@ -418,17 +415,6 @@ void doit(); }; - -class VM_RotateGCLog: public VM_Operation { - private: - outputStream* _out; - - public: - VM_RotateGCLog(outputStream* st) : _out(st) {} - VMOp_Type type() const { return VMOp_RotateGCLog; } - void doit() { gclog_or_tty->rotate_log(true, _out); } -}; - class VM_PrintCompileQueue: public VM_Operation { private: outputStream* _out; --- old/src/share/vm/services/diagnosticCommand.cpp 2015-12-01 12:06:31.250930018 +0100 +++ new/src/share/vm/services/diagnosticCommand.cpp 2015-12-01 12:06:31.130930023 +0100 @@ -73,7 +73,6 @@ DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); #endif // INCLUDE_JVMTI DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); - DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl(full_export, true, false)); @@ -825,15 +824,6 @@ output()->cr(); } -void RotateGCLogDCmd::execute(DCmdSource source, TRAPS) { - if (UseGCLogFileRotation) { - VM_RotateGCLog rotateop(output()); - VMThread::execute(&rotateop); - } else { - output()->print_cr("Target VM does not support GC log file rotation."); - } -} - void CompileQueueDCmd::execute(DCmdSource source, TRAPS) { VM_PrintCompileQueue printCompileQueueOp(output()); VMThread::execute(&printCompileQueueOp); --- old/src/share/vm/services/diagnosticCommand.hpp 2015-12-01 12:06:31.462930011 +0100 +++ new/src/share/vm/services/diagnosticCommand.hpp 2015-12-01 12:06:31.346930015 +0100 @@ -549,23 +549,6 @@ }; -class RotateGCLogDCmd : public DCmd { -public: - RotateGCLogDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} - static const char* name() { return "GC.rotate_log"; } - static const char* description() { - return "Force the GC log file to be rotated."; - } - static const char* impact() { return "Low"; } - virtual void execute(DCmdSource source, TRAPS); - static int num_arguments() { return 0; } - static const JavaPermission permission() { - JavaPermission p = {"java.lang.management.ManagementPermission", - "control", NULL}; - return p; - } -}; - class CompileQueueDCmd : public DCmd { public: CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {} --- old/src/share/vm/services/memoryService.cpp 2015-12-01 12:06:31.670930004 +0100 +++ new/src/share/vm/services/memoryService.cpp 2015-12-01 12:06:31.550930008 +0100 @@ -32,6 +32,7 @@ #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/generation.hpp" #include "gc/shared/generationSpec.hpp" +#include "logging/logConfiguration.hpp" #include "memory/heap.hpp" #include "memory/memRegion.hpp" #include "oops/oop.inline.hpp" @@ -517,8 +518,12 @@ bool MemoryService::set_verbose(bool verbose) { MutexLocker m(Management_lock); // verbose will be set to the previous value - Flag::Error error = CommandLineFlags::boolAtPut("PrintGC", &verbose, Flag::MANAGEMENT); - assert(error==Flag::SUCCESS, "Setting PrintGC flag failed with error %s", Flag::flag_error_str(error)); + MutexLocker ml(LogConfiguration_lock); + if (verbose) { + LogConfiguration::parse_log_arguments("stdout", "gc", NULL, NULL, NULL); + } else { + LogConfiguration::parse_log_arguments("stdout", "gc=off", NULL, NULL, NULL); + } ClassLoadingService::reset_trace_class_unloading(); return verbose; --- old/src/share/vm/services/memoryService.hpp 2015-12-01 12:06:31.874929997 +0100 +++ new/src/share/vm/services/memoryService.hpp 2015-12-01 12:06:31.758930001 +0100 @@ -27,6 +27,7 @@ #include "gc/shared/gcCause.hpp" #include "gc/shared/generation.hpp" +#include "logging/log.hpp" #include "memory/allocation.hpp" #include "runtime/handles.hpp" #include "services/memoryUsage.hpp" @@ -164,7 +165,7 @@ static void oops_do(OopClosure* f); - static bool get_verbose() { return PrintGC; } + static bool get_verbose() { return log_is_enabled(Info, gc); } static bool set_verbose(bool verbose); // Create an instance of java/lang/management/MemoryUsage --- old/src/share/vm/services/runtimeService.cpp 2015-12-01 12:06:32.074929990 +0100 +++ new/src/share/vm/services/runtimeService.cpp 2015-12-01 12:06:31.962929994 +0100 @@ -24,6 +24,7 @@ #include "precompiled.hpp" #include "classfile/classLoader.hpp" +#include "logging/log.hpp" #include "runtime/vm_version.hpp" #include "services/attachListener.hpp" #include "services/management.hpp" @@ -89,11 +90,8 @@ HS_PRIVATE_SAFEPOINT_BEGIN(); // Print the time interval in which the app was executing - if (PrintGCApplicationConcurrentTime && _app_timer.is_updated()) { - gclog_or_tty->date_stamp(PrintGCDateStamps); - gclog_or_tty->stamp(PrintGCTimeStamps); - gclog_or_tty->print_cr("Application time: %3.7f seconds", - last_application_time_sec()); + if (_app_timer.is_updated()) { + log_info(safepoint)("Application time: %3.7f seconds", last_application_time_sec()); } // update the time stamp to begin recording safepoint time @@ -111,7 +109,7 @@ if (UsePerfData) { _sync_time_ticks->inc(_safepoint_timer.ticks_since_update()); } - if (PrintGCApplicationStoppedTime) { + if (log_is_enabled(Info, safepoint)) { _last_safepoint_sync_time_sec = last_safepoint_time_sec(); } } @@ -121,15 +119,8 @@ // Print the time interval for which the app was stopped // during the current safepoint operation. - if (PrintGCApplicationStoppedTime) { - gclog_or_tty->date_stamp(PrintGCDateStamps); - gclog_or_tty->stamp(PrintGCTimeStamps); - gclog_or_tty->print_cr("Total time for which application threads " - "were stopped: %3.7f seconds, " - "Stopping threads took: %3.7f seconds", - last_safepoint_time_sec(), - _last_safepoint_sync_time_sec); - } + log_info(safepoint)("Total time for which application threads were stopped: %3.7f seconds, Stopping threads took: %3.7f seconds", + last_safepoint_time_sec(), _last_safepoint_sync_time_sec); // update the time stamp to begin recording app time _app_timer.update(); --- old/src/share/vm/utilities/debug.cpp 2015-12-01 12:06:32.278929983 +0100 +++ new/src/share/vm/utilities/debug.cpp 2015-12-01 12:06:32.162929987 +0100 @@ -495,7 +495,7 @@ extern "C" void universe() { Command c("universe"); - Universe::print(); + Universe::print_on(tty); } --- old/src/share/vm/utilities/numberSeq.cpp 2015-12-01 12:06:32.490929975 +0100 +++ new/src/share/vm/utilities/numberSeq.cpp 2015-12-01 12:06:32.370929979 +0100 @@ -234,7 +234,7 @@ // Printing/Debugging Support -void AbsSeq::dump() { dump_on(gclog_or_tty); } +void AbsSeq::dump() { dump_on(tty); } void AbsSeq::dump_on(outputStream* s) { s->print_cr("\t _num = %d, _sum = %7.3f, _sum_of_squares = %7.3f", --- old/src/share/vm/utilities/ostream.cpp 2015-12-01 12:06:32.686929968 +0100 +++ new/src/share/vm/utilities/ostream.cpp 2015-12-01 12:06:32.566929973 +0100 @@ -239,14 +239,6 @@ return; } -void outputStream::gclog_stamp() { - date_stamp(PrintGCDateStamps); - stamp(PrintGCTimeStamps); - if (PrintGCID) { - print("#%u: ", GCId::current()); - } -} - outputStream& outputStream::indent() { while (_position < _indentation) sp(); return *this; @@ -366,7 +358,6 @@ xmlStream* xtty; outputStream* tty; -outputStream* gclog_or_tty; CDS_ONLY(fileStream* classlist_file;) // Only dump the classes that can be stored into the CDS archive extern Mutex* tty_lock; @@ -482,7 +473,7 @@ return buf; } -// log_name comes from -XX:LogFile=log_name, -Xloggc:log_name or +// log_name comes from -XX:LogFile=log_name or // -XX:DumpLoadedClassList= // in log_name, %p => pid1234 and // %t => YYYY-MM-DD_HH-MM-SS @@ -493,95 +484,6 @@ timestr); } -#ifndef PRODUCT -void test_loggc_filename() { - int pid; - char tms[32]; - char i_result[JVM_MAXPATHLEN]; - const char* o_result; - get_datetime_string(tms, sizeof(tms)); - pid = os::current_process_id(); - - // test.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "test.log", tms); - o_result = make_log_name_internal("test.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - // test-%t-%p.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "test-%s-pid%u.log", tms, pid); - o_result = make_log_name_internal("test-%t-%p.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test-%%t-%%p.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - // test-%t%p.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "test-%spid%u.log", tms, pid); - o_result = make_log_name_internal("test-%t%p.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test-%%t%%p.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - // %p%t.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "pid%u%s.log", pid, tms); - o_result = make_log_name_internal("%p%t.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%p%%t.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - // %p-test.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "pid%u-test.log", pid); - o_result = make_log_name_internal("%p-test.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%p-test.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - // %t.log - jio_snprintf(i_result, JVM_MAXPATHLEN, "%s.log", tms); - o_result = make_log_name_internal("%t.log", NULL, pid, tms); - assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%t.log\", NULL)"); - FREE_C_HEAP_ARRAY(char, o_result); - - { - // longest filename - char longest_name[JVM_MAXPATHLEN]; - memset(longest_name, 'a', sizeof(longest_name)); - longest_name[JVM_MAXPATHLEN - 1] = '\0'; - o_result = make_log_name_internal((const char*)&longest_name, NULL, pid, tms); - assert(strcmp(longest_name, o_result) == 0, "longest name does not match. expected '%s' but got '%s'", longest_name, o_result); - FREE_C_HEAP_ARRAY(char, o_result); - } - - { - // too long file name - char too_long_name[JVM_MAXPATHLEN + 100]; - int too_long_length = sizeof(too_long_name); - memset(too_long_name, 'a', too_long_length); - too_long_name[too_long_length - 1] = '\0'; - o_result = make_log_name_internal((const char*)&too_long_name, NULL, pid, tms); - assert(o_result == NULL, "Too long file name should return NULL, but got '%s'", o_result); - } - - { - // too long with timestamp - char longest_name[JVM_MAXPATHLEN]; - memset(longest_name, 'a', JVM_MAXPATHLEN); - longest_name[JVM_MAXPATHLEN - 3] = '%'; - longest_name[JVM_MAXPATHLEN - 2] = 't'; - longest_name[JVM_MAXPATHLEN - 1] = '\0'; - o_result = make_log_name_internal((const char*)&longest_name, NULL, pid, tms); - assert(o_result == NULL, "Too long file name after timestamp expansion should return NULL, but got '%s'", o_result); - } - - { - // too long with pid - char longest_name[JVM_MAXPATHLEN]; - memset(longest_name, 'a', JVM_MAXPATHLEN); - longest_name[JVM_MAXPATHLEN - 3] = '%'; - longest_name[JVM_MAXPATHLEN - 2] = 'p'; - longest_name[JVM_MAXPATHLEN - 1] = '\0'; - o_result = make_log_name_internal((const char*)&longest_name, NULL, pid, tms); - assert(o_result == NULL, "Too long file name after pid expansion should return NULL, but got '%s'", o_result); - } -} -#endif // PRODUCT - fileStream::fileStream(const char* file_name) { _file = fopen(file_name, "w"); if (_file != NULL) { @@ -660,202 +562,6 @@ update_position(s, len); } -// dump vm version, os version, platform info, build id, -// memory usage and command line flags into header -void gcLogFileStream::dump_loggc_header() { - if (is_open()) { - print_cr("%s", Abstract_VM_Version::internal_vm_info_string()); - os::print_memory_info(this); - print("CommandLine flags: "); - CommandLineFlags::printSetFlags(this); - } -} - -gcLogFileStream::~gcLogFileStream() { - if (_file != NULL) { - if (_need_close) fclose(_file); - _file = NULL; - } - if (_file_name != NULL) { - FREE_C_HEAP_ARRAY(char, _file_name); - _file_name = NULL; - } -} - -gcLogFileStream::gcLogFileStream(const char* file_name) { - _cur_file_num = 0; - _bytes_written = 0L; - _file_name = make_log_name(file_name, NULL); - - if (_file_name == NULL) { - warning("Cannot open file %s: file name is too long.\n", file_name); - _need_close = false; - UseGCLogFileRotation = false; - return; - } - - // gc log file rotation - if (UseGCLogFileRotation && NumberOfGCLogFiles > 1) { - char tempbuf[JVM_MAXPATHLEN]; - jio_snprintf(tempbuf, sizeof(tempbuf), "%s.%d" CURRENTAPPX, _file_name, _cur_file_num); - _file = fopen(tempbuf, "w"); - } else { - _file = fopen(_file_name, "w"); - } - if (_file != NULL) { - _need_close = true; - dump_loggc_header(); - } else { - warning("Cannot open file %s due to %s\n", _file_name, strerror(errno)); - _need_close = false; - } -} - -void gcLogFileStream::write(const char* s, size_t len) { - if (_file != NULL) { - size_t count = fwrite(s, 1, len, _file); - _bytes_written += count; - } - update_position(s, len); -} - -// rotate_log must be called from VMThread at safepoint. In case need change parameters -// for gc log rotation from thread other than VMThread, a sub type of VM_Operation -// should be created and be submitted to VMThread's operation queue. DO NOT call this -// function directly. Currently, it is safe to rotate log at safepoint through VMThread. -// That is, no mutator threads and concurrent GC threads run parallel with VMThread to -// write to gc log file at safepoint. If in future, changes made for mutator threads or -// concurrent GC threads to run parallel with VMThread at safepoint, write and rotate_log -// must be synchronized. -void gcLogFileStream::rotate_log(bool force, outputStream* out) { - char time_msg[O_BUFLEN]; - char time_str[EXTRACHARLEN]; - char current_file_name[JVM_MAXPATHLEN]; - char renamed_file_name[JVM_MAXPATHLEN]; - - if (!should_rotate(force)) { - return; - } - -#ifdef ASSERT - Thread *thread = Thread::current(); - assert(thread == NULL || - (thread->is_VM_thread() && SafepointSynchronize::is_at_safepoint()), - "Must be VMThread at safepoint"); -#endif - if (NumberOfGCLogFiles == 1) { - // rotate in same file - rewind(); - _bytes_written = 0L; - jio_snprintf(time_msg, sizeof(time_msg), "File %s rotated at %s\n", - _file_name, os::local_time_string((char *)time_str, sizeof(time_str))); - write(time_msg, strlen(time_msg)); - - if (out != NULL) { - out->print("%s", time_msg); - } - - dump_loggc_header(); - return; - } - -#if defined(_WINDOWS) -#ifndef F_OK -#define F_OK 0 -#endif -#endif // _WINDOWS - - // rotate file in names extended_filename.0, extended_filename.1, ..., - // extended_filename.. Current rotation file name will - // have a form of extended_filename..current where i is the current rotation - // file number. After it reaches max file size, the file will be saved and renamed - // with .current removed from its tail. - if (_file != NULL) { - jio_snprintf(renamed_file_name, JVM_MAXPATHLEN, "%s.%d", - _file_name, _cur_file_num); - int result = jio_snprintf(current_file_name, JVM_MAXPATHLEN, - "%s.%d" CURRENTAPPX, _file_name, _cur_file_num); - if (result >= JVM_MAXPATHLEN) { - warning("Cannot create new log file name: %s: file name is too long.\n", current_file_name); - return; - } - - const char* msg = force ? "GC log rotation request has been received." - : "GC log file has reached the maximum size."; - jio_snprintf(time_msg, sizeof(time_msg), "%s %s Saved as %s\n", - os::local_time_string((char *)time_str, sizeof(time_str)), - msg, renamed_file_name); - write(time_msg, strlen(time_msg)); - - if (out != NULL) { - out->print("%s", time_msg); - } - - fclose(_file); - _file = NULL; - - bool can_rename = true; - if (access(current_file_name, F_OK) != 0) { - // current file does not exist? - warning("No source file exists, cannot rename\n"); - can_rename = false; - } - if (can_rename) { - if (access(renamed_file_name, F_OK) == 0) { - if (remove(renamed_file_name) != 0) { - warning("Could not delete existing file %s\n", renamed_file_name); - can_rename = false; - } - } else { - // file does not exist, ok to rename - } - } - if (can_rename && rename(current_file_name, renamed_file_name) != 0) { - warning("Could not rename %s to %s\n", _file_name, renamed_file_name); - } - } - - _cur_file_num++; - if (_cur_file_num > NumberOfGCLogFiles - 1) _cur_file_num = 0; - int result = jio_snprintf(current_file_name, JVM_MAXPATHLEN, "%s.%d" CURRENTAPPX, - _file_name, _cur_file_num); - if (result >= JVM_MAXPATHLEN) { - warning("Cannot create new log file name: %s: file name is too long.\n", current_file_name); - return; - } - - _file = fopen(current_file_name, "w"); - - if (_file != NULL) { - _bytes_written = 0L; - _need_close = true; - // reuse current_file_name for time_msg - jio_snprintf(current_file_name, JVM_MAXPATHLEN, - "%s.%d", _file_name, _cur_file_num); - jio_snprintf(time_msg, sizeof(time_msg), "%s GC log file created %s\n", - os::local_time_string((char *)time_str, sizeof(time_str)), current_file_name); - write(time_msg, strlen(time_msg)); - - if (out != NULL) { - out->print("%s", time_msg); - } - - dump_loggc_header(); - // remove the existing file - if (access(current_file_name, F_OK) == 0) { - if (remove(current_file_name) != 0) { - warning("Could not delete existing file %s\n", current_file_name); - } - } - } else { - warning("failed to open rotation log file %s due to %s\n" - "Turned off GC log file rotation\n", - _file_name, strerror(errno)); - _need_close = false; - FLAG_SET_DEFAULT(UseGCLogFileRotation, false); - } -} - defaultStream* defaultStream::instance = NULL; int defaultStream::_output_fd = 1; int defaultStream::_error_fd = 2; @@ -1194,21 +900,8 @@ } void ostream_init_log() { - // For -Xloggc: option - called in runtime/thread.cpp // Note : this must be called AFTER ostream_init() - gclog_or_tty = tty; // default to tty - if (Arguments::gc_log_filename() != NULL) { - fileStream * gclog = new(ResourceObj::C_HEAP, mtInternal) - gcLogFileStream(Arguments::gc_log_filename()); - if (gclog->is_open()) { - // now we update the time stamp of the GC log to be synced up - // with tty. - gclog->time_stamp().update_to(tty->time_stamp().ticks()); - } - gclog_or_tty = gclog; - } - #if INCLUDE_CDS // For -XX:DumpLoadedClassList= option if (DumpLoadedClassList != NULL) { @@ -1236,9 +929,6 @@ delete classlist_file; } #endif - if (gclog_or_tty != tty) { - delete gclog_or_tty; - } { // we temporaly disable PrintMallocFree here // as otherwise it'll lead to using of almost deleted @@ -1254,14 +944,12 @@ } tty = NULL; xtty = NULL; - gclog_or_tty = NULL; defaultStream::instance = NULL; } // ostream_abort() is called by os::abort() when VM is about to die. void ostream_abort() { - // Here we can't delete gclog_or_tty and tty, just flush their output - if (gclog_or_tty) gclog_or_tty->flush(); + // Here we can't delete tty, just flush its output if (tty) tty->flush(); if (defaultStream::instance != NULL) { --- old/src/share/vm/utilities/ostream.hpp 2015-12-01 12:06:32.894929961 +0100 +++ new/src/share/vm/utilities/ostream.hpp 2015-12-01 12:06:32.774929965 +0100 @@ -108,7 +108,6 @@ void date_stamp(bool guard) { date_stamp(guard, "", ": "); } - void gclog_stamp(); // portable printing of 64 bit integers void print_jlong(jlong value); @@ -127,7 +126,6 @@ // standard output // ANSI C++ name collision extern outputStream* tty; // tty output -extern outputStream* gclog_or_tty; // stream for gc log if -Xloggc:, or tty class streamIndentor : public StackObj { private: @@ -247,30 +245,6 @@ } }; -class gcLogFileStream : public fileStream { - protected: - const char* _file_name; - jlong _bytes_written; - uintx _cur_file_num; // current logfile rotation number, from 0 to NumberOfGCLogFiles-1 - public: - gcLogFileStream(const char* file_name); - ~gcLogFileStream(); - virtual void write(const char* c, size_t len); - virtual void rotate_log(bool force, outputStream* out = NULL); - void dump_loggc_header(); - - /* If "force" sets true, force log file rotation from outside JVM */ - bool should_rotate(bool force) { - return force || - ((GCLogFileSize != 0) && (_bytes_written >= (jlong)GCLogFileSize)); - } -}; - -#ifndef PRODUCT -// unit test for checking -Xloggc: parsing result -void test_loggc_filename(); -#endif - void ostream_init(); void ostream_init_log(); void ostream_exit(); --- old/test/TEST.groups 2015-12-01 12:06:33.094929954 +0100 +++ new/test/TEST.groups 2015-12-01 12:06:32.974929958 +0100 @@ -145,7 +145,6 @@ gc/g1/TestShrinkAuxiliaryData25.java \ gc/g1/TestShrinkAuxiliaryData30.java \ gc/survivorAlignment \ - gc/TestGCLogRotationViaJcmd.java \ runtime/InternalApi/ThreadCpuTimesDeadlock.java \ runtime/NMT/JcmdSummaryDiff.java \ runtime/RedefineTests/RedefineAnnotations.java --- old/test/gc/7072527/TestFullGCCount.java 2015-12-01 12:06:33.266929948 +0100 +++ new/test/gc/7072527/TestFullGCCount.java 2015-12-01 12:06:33.162929952 +0100 @@ -26,7 +26,7 @@ * @bug 7072527 * @summary CMS: JMM GC counters overcount in some cases * @modules java.management - * @run main/othervm -XX:+PrintGC TestFullGCCount + * @run main/othervm -Xlog:gc TestFullGCCount */ import java.util.*; import java.lang.management.*; --- old/test/gc/TestDisableExplicitGC.java 2015-12-01 12:06:33.462929941 +0100 +++ new/test/gc/TestDisableExplicitGC.java 2015-12-01 12:06:33.342929946 +0100 @@ -26,9 +26,9 @@ * @requires vm.opt.DisableExplicitGC == null * @summary Verify GC behavior with DisableExplicitGC flag. * @library /testlibrary - * @run main/othervm -XX:+PrintGCDetails TestDisableExplicitGC - * @run main/othervm/fail -XX:+DisableExplicitGC -XX:+PrintGCDetails TestDisableExplicitGC - * @run main/othervm -XX:-DisableExplicitGC -XX:+PrintGCDetails TestDisableExplicitGC + * @run main/othervm -Xlog:gc=debug TestDisableExplicitGC + * @run main/othervm/fail -XX:+DisableExplicitGC -Xlog:gc=debug TestDisableExplicitGC + * @run main/othervm -XX:-DisableExplicitGC -Xlog:gc=debug TestDisableExplicitGC */ import java.lang.management.GarbageCollectorMXBean; import java.util.List; --- old/test/gc/TestVerifyDuringStartup.java 2015-12-01 12:06:33.626929936 +0100 +++ new/test/gc/TestVerifyDuringStartup.java 2015-12-01 12:06:33.526929939 +0100 @@ -48,6 +48,7 @@ Collections.addAll(vmOpts, new String[] {"-XX:-UseTLAB", "-XX:+UnlockDiagnosticVMOptions", "-XX:+VerifyDuringStartup", + "-Xlog:gc+verify=debug", "-version"}); System.out.print("Testing:\n" + JDKToolFinder.getJDKTool("java")); @@ -62,7 +63,7 @@ System.out.println("Output:\n" + output.getOutput()); - output.shouldContain("[Verifying"); + output.shouldContain("Verifying"); output.shouldHaveExitValue(0); } } --- old/test/gc/TestVerifySilently.java 2015-12-01 12:06:33.810929929 +0100 +++ new/test/gc/TestVerifySilently.java 2015-12-01 12:06:33.694929933 +0100 @@ -60,7 +60,7 @@ "-XX:+VerifyDuringStartup", "-XX:+VerifyBeforeGC", "-XX:+VerifyAfterGC", - "-XX:" + (verifySilently ? "+":"-") + "VerifySilently", + (verifySilently ? "-Xlog:gc":"-Xlog:gc+verify=debug"), RunSystemGC.class.getName()}); ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()])); @@ -76,11 +76,11 @@ OutputAnalyzer output; output = runTest(false); - output.shouldContain("[Verifying"); + output.shouldContain("Verifying"); output.shouldHaveExitValue(0); output = runTest(true); - output.shouldNotContain("[Verifying"); + output.shouldNotContain("Verifying"); output.shouldHaveExitValue(0); } } --- old/test/gc/arguments/TestTargetSurvivorRatioFlag.java 2015-12-01 12:06:33.978929923 +0100 +++ new/test/gc/arguments/TestTargetSurvivorRatioFlag.java 2015-12-01 12:06:33.874929927 +0100 @@ -79,7 +79,7 @@ // Patterns used during log parsing public static final String TENURING_DISTRIBUTION = "Desired survivor size"; - public static final String AGE_TABLE_ENTRY = "-[\\s]+age[\\s]+([0-9]+):[\\s]+([0-9]+)[\\s]+bytes,[\\s]+([0-9]+)[\\s]+total"; + public static final String AGE_TABLE_ENTRY = ".*-[\\s]+age[\\s]+([0-9]+):[\\s]+([0-9]+)[\\s]+bytes,[\\s]+([0-9]+)[\\s]+total"; public static final String MAX_SURVIVOR_SIZE = "Max survivor size: ([0-9]+)"; public static void main(String args[]) throws Exception { @@ -133,7 +133,7 @@ "-XX:+UnlockDiagnosticVMOptions", "-XX:+WhiteBoxAPI", "-XX:+UseAdaptiveSizePolicy", - "-XX:+PrintTenuringDistribution", + "-Xlog:gc+age=trace", "-XX:MaxTenuringThreshold=" + MAX_TENURING_THRESHOLD, "-XX:NewSize=" + MAX_NEW_SIZE, "-XX:MaxNewSize=" + MAX_NEW_SIZE, --- old/test/gc/arguments/TestUnrecognizedVMOptionsHandling.java 2015-12-01 12:06:34.174929917 +0100 +++ new/test/gc/arguments/TestUnrecognizedVMOptionsHandling.java 2015-12-01 12:06:34.058929921 +0100 @@ -39,11 +39,11 @@ public static void main(String args[]) throws Exception { // The first two JAVA processes are expected to fail, but with a correct VM option suggestion ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( - "-XX:+PrintGc", + "-XX:+UseDynamicNumberOfGcThreads", "-version" ); OutputAnalyzer outputWithError = new OutputAnalyzer(pb.start()); - outputWithError.shouldContain("Did you mean '(+/-)PrintGC'?"); + outputWithError.shouldContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?"); if (outputWithError.getExitValue() == 0) { throw new RuntimeException("Not expected to get exit value 0"); } @@ -60,11 +60,11 @@ // The last JAVA process should run successfully for the purpose of sanity check pb = ProcessTools.createJavaProcessBuilder( - "-XX:+PrintGC", + "-XX:+UseDynamicNumberOfGCThreads", "-version" ); OutputAnalyzer outputWithNoError = new OutputAnalyzer(pb.start()); - outputWithNoError.shouldNotContain("Did you mean '(+/-)PrintGC'?"); + outputWithNoError.shouldNotContain("Did you mean '(+/-)UseDynamicNumberOfGCThreads'?"); outputWithNoError.shouldHaveExitValue(0); } } --- old/test/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java 2015-12-01 12:06:34.354929910 +0100 +++ new/test/gc/arguments/TestVerifyBeforeAndAfterGCFlags.java 2015-12-01 12:06:34.238929914 +0100 @@ -43,18 +43,18 @@ public class TestVerifyBeforeAndAfterGCFlags { // VerifyBeforeGC:[Verifying threads heap tenured eden syms strs zone dict metaspace chunks hand C-heap code cache ] - public static final String VERIFY_BEFORE_GC_PATTERN = "VerifyBeforeGC:\\[Verifying\\s+([^]\\s]+\\s+)+\\]"; + public static final String VERIFY_BEFORE_GC_PATTERN = "Verifying Before GC"; // VerifyBeforeGC: VerifyBeforeGC: VerifyBeforeGC: public static final String VERIFY_BEFORE_GC_CORRUPTED_PATTERN = "VerifyBeforeGC:(?!\\[Verifying[^]]+\\])"; // VerifyAfterGC:[Verifying threads heap tenured eden syms strs zone dict metaspace chunks hand C-heap code cache ] - public static final String VERIFY_AFTER_GC_PATTERN = "VerifyAfterGC:\\[Verifying\\s+([^]\\s]+\\s+)+\\]"; + public static final String VERIFY_AFTER_GC_PATTERN = "Verifying After GC"; // VerifyAfterGC: VerifyAfterGC: VerifyAfterGC: public static final String VERIFY_AFTER_GC_CORRUPTED_PATTERN = "VerifyAfterGC:(?!\\[Verifying[^]]+\\])"; public static void main(String args[]) throws Exception { String[] filteredOpts = Utils.getFilteredTestJavaOpts( - new String[] { "-Xloggc:", + new String[] { "-Xlog:gc+verify=debug", "-XX:+UseGCLogFileRotation", "-XX:-DisplayVMOutput", "VerifyBeforeGC", @@ -74,6 +74,7 @@ } Collections.addAll(vmOpts, new String[] { + "-Xlog:gc+verify=debug", "-Xmx5m", "-Xms5m", "-Xmn3m", --- old/test/gc/class_unloading/TestCMSClassUnloadingEnabledHWM.java 2015-12-01 12:06:34.526929904 +0100 +++ new/test/gc/class_unloading/TestCMSClassUnloadingEnabledHWM.java 2015-12-01 12:06:34.418929908 +0100 @@ -59,9 +59,7 @@ "-Xmn" + YoungGenSize, "-XX:+UseConcMarkSweepGC", "-XX:" + (enableUnloading ? "+" : "-") + "CMSClassUnloadingEnabled", - "-XX:+PrintHeapAtGC", - "-XX:+PrintGCDetails", - "-XX:+PrintGCTimeStamps", + "-Xlog:gc", TestCMSClassUnloadingEnabledHWM.AllocateBeyondMetaspaceSize.class.getName(), "" + MetaspaceSize); return new OutputAnalyzer(pb.start()); @@ -79,16 +77,16 @@ // -XX:-CMSClassUnloadingEnabled is used, so we expect a full GC instead of a concurrent cycle. OutputAnalyzer out = runWithoutCMSClassUnloading(); - out.shouldMatch(".*Full GC.*"); - out.shouldNotMatch(".*CMS Initial Mark.*"); + out.shouldMatch(".*Pause Full.*"); + out.shouldNotMatch(".*Pause Initial Mark.*"); } public static void testWithCMSClassUnloading() throws Exception { // -XX:+CMSClassUnloadingEnabled is used, so we expect a concurrent cycle instead of a full GC. OutputAnalyzer out = runWithCMSClassUnloading(); - out.shouldMatch(".*CMS Initial Mark.*"); - out.shouldNotMatch(".*Full GC.*"); + out.shouldMatch(".*Pause Initial Mark.*"); + out.shouldNotMatch(".*Pause Full.*"); } public static void main(String args[]) throws Exception { --- old/test/gc/class_unloading/TestG1ClassUnloadingHWM.java 2015-12-01 12:06:34.698929898 +0100 +++ new/test/gc/class_unloading/TestG1ClassUnloadingHWM.java 2015-12-01 12:06:34.598929902 +0100 @@ -54,8 +54,7 @@ "-Xmn" + YoungGenSize, "-XX:+UseG1GC", "-XX:" + (enableUnloading ? "+" : "-") + "ClassUnloadingWithConcurrentMark", - "-XX:+PrintHeapAtGC", - "-XX:+PrintGCDetails", + "-Xlog:gc", TestG1ClassUnloadingHWM.AllocateBeyondMetaspaceSize.class.getName(), "" + MetaspaceSize, "" + YoungGenSize); @@ -74,16 +73,16 @@ // -XX:-ClassUnloadingWithConcurrentMark is used, so we expect a full GC instead of a concurrent cycle. OutputAnalyzer out = runWithoutG1ClassUnloading(); - out.shouldMatch(".*Full GC.*"); - out.shouldNotMatch(".*initial-mark.*"); + out.shouldMatch(".*Pause Full.*"); + out.shouldNotMatch(".*Pause Initial Mark.*"); } public static void testWithG1ClassUnloading() throws Exception { // -XX:+ClassUnloadingWithConcurrentMark is used, so we expect a concurrent cycle instead of a full GC. OutputAnalyzer out = runWithG1ClassUnloading(); - out.shouldMatch(".*initial-mark.*"); - out.shouldNotMatch(".*Full GC.*"); + out.shouldMatch(".*Pause Initial Mark.*"); + out.shouldNotMatch(".*Pause Full.*"); } public static void main(String args[]) throws Exception { --- old/test/gc/cms/DisableResizePLAB.java 2015-12-01 12:06:34.886929892 +0100 +++ new/test/gc/cms/DisableResizePLAB.java 2015-12-01 12:06:34.774929896 +0100 @@ -28,7 +28,7 @@ * @author filipp.zhinkin@oracle.com, john.coomes@oracle.com * @requires vm.gc=="ConcMarkSweep" | vm.gc=="null" * @summary Run CMS with PLAB resizing disabled and a small OldPLABSize - * @run main/othervm -XX:+UseConcMarkSweepGC -XX:-ResizePLAB -XX:OldPLABSize=1k -Xmx256m -XX:+PrintGCDetails DisableResizePLAB + * @run main/othervm -XX:+UseConcMarkSweepGC -XX:-ResizePLAB -XX:OldPLABSize=1k -Xmx256m -Xlog:gc=debug DisableResizePLAB */ public class DisableResizePLAB { --- old/test/gc/cms/TestCMSScavengeBeforeRemark.java 2015-12-01 12:06:35.058929886 +0100 +++ new/test/gc/cms/TestCMSScavengeBeforeRemark.java 2015-12-01 12:06:34.958929889 +0100 @@ -27,7 +27,7 @@ * @bug 8139868 * @requires vm.gc=="ConcMarkSweep" | vm.gc=="null" * @summary Run CMS with CMSScavengeBeforeRemark - * @run main/othervm -XX:+UseConcMarkSweepGC -XX:+CMSScavengeBeforeRemark -XX:+ExplicitGCInvokesConcurrent -Xmx256m -XX:+PrintGCDetails TestCMSScavengeBeforeRemark + * @run main/othervm -XX:+UseConcMarkSweepGC -XX:+CMSScavengeBeforeRemark -XX:+ExplicitGCInvokesConcurrent -Xmx256m -Xlog:gc=debug TestCMSScavengeBeforeRemark */ public class TestCMSScavengeBeforeRemark { --- old/test/gc/ergonomics/TestDynamicNumberOfGCThreads.java 2015-12-01 12:06:35.250929879 +0100 +++ new/test/gc/ergonomics/TestDynamicNumberOfGCThreads.java 2015-12-01 12:06:35.134929883 +0100 @@ -50,7 +50,7 @@ private static void testDynamicNumberOfGCThreads(String gcFlag) throws Exception { // UseDynamicNumberOfGCThreads and TraceDynamicGCThreads enabled - String[] baseArgs = {"-XX:+" + gcFlag, "-Xmx10M", "-XX:+PrintGCDetails", "-XX:+UseDynamicNumberOfGCThreads", "-XX:+TraceDynamicGCThreads", GCTest.class.getName()}; + String[] baseArgs = {"-XX:+" + gcFlag, "-Xmx10M", "-XX:+UseDynamicNumberOfGCThreads", "-Xlog:gc+task=trace", GCTest.class.getName()}; // Base test with gc and +UseDynamicNumberOfGCThreads: ProcessBuilder pb_enabled = ProcessTools.createJavaProcessBuilder(baseArgs); --- old/test/gc/g1/TestEagerReclaimHumongousRegions.java 2015-12-01 12:06:35.418929873 +0100 +++ new/test/gc/g1/TestEagerReclaimHumongousRegions.java 2015-12-01 12:06:35.318929877 +0100 @@ -82,7 +82,7 @@ "-Xms128M", "-Xmx128M", "-Xmn16M", - "-XX:+PrintGC", + "-Xlog:gc", ReclaimRegionFast.class.getName()); Pattern p = Pattern.compile("Full GC"); --- old/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java 2015-12-01 12:06:35.610929867 +0100 +++ new/test/gc/g1/TestEagerReclaimHumongousRegionsClearMarkBits.java 2015-12-01 12:06:35.494929871 +0100 @@ -120,7 +120,7 @@ "-Xmn2M", "-XX:G1HeapRegionSize=1M", "-XX:InitiatingHeapOccupancyPercent=0", // Want to have as much as possible initial marks. - "-XX:+PrintGC", + "-Xlog:gc", "-XX:+UnlockDiagnosticVMOptions", "-XX:+VerifyAfterGC", "-XX:ConcGCThreads=1", // Want to make marking as slow as possible. --- old/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java 2015-12-01 12:06:35.786929860 +0100 +++ new/test/gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java 2015-12-01 12:06:35.682929864 +0100 @@ -94,7 +94,7 @@ "-Xms128M", "-Xmx128M", "-Xmn16M", - "-XX:+PrintGC", + "-Xlog:gc", ReclaimRegionFast.class.getName()); Pattern p = Pattern.compile("Full GC"); --- old/test/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java 2015-12-01 12:06:35.978929854 +0100 +++ new/test/gc/g1/TestG1TraceEagerReclaimHumongousObjects.java 2015-12-01 12:06:35.862929858 +0100 @@ -49,20 +49,18 @@ "-Xmx128M", "-Xmn16M", "-XX:G1HeapRegionSize=1M", - "-XX:+PrintGC", + "-Xlog:gc+phases=trace", "-XX:+UnlockExperimentalVMOptions", - "-XX:G1LogLevel=finest", - "-XX:+G1TraceEagerReclaimHumongousObjects", GCTest.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); // As G1EagerReclaimHumongousObjects is set(default), below logs should be displayed. // And GCTest doesn't have humongous objects, so values should be zero. - output.shouldContain("[Humongous Reclaim"); - output.shouldContain("[Humongous Total: 0]"); - output.shouldContain("[Humongous Candidate: 0]"); - output.shouldContain("[Humongous Reclaimed: 0]"); + output.shouldContain("Humongous Reclaim"); + output.shouldContain("Humongous Total: 0"); + output.shouldContain("Humongous Candidate: 0"); + output.shouldContain("Humongous Reclaimed: 0"); output.shouldHaveExitValue(0); } @@ -73,19 +71,17 @@ "-Xmx128M", "-Xmn16M", "-XX:G1HeapRegionSize=1M", - "-XX:+PrintGC", + "-Xlog:gc+phases=trace,gc+humongous=trace", "-XX:+UnlockExperimentalVMOptions", - "-XX:G1LogLevel=finest", - "-XX:+G1TraceEagerReclaimHumongousObjects", GCWithHumongousObjectTest.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); // As G1ReclaimDeadHumongousObjectsAtYoungGC is set(default), below logs should be displayed. - output.shouldContain("[Humongous Reclaim"); - output.shouldContain("[Humongous Total"); - output.shouldContain("[Humongous Candidate"); - output.shouldContain("[Humongous Reclaimed"); + output.shouldContain("Humongous Reclaim"); + output.shouldContain("Humongous Total"); + output.shouldContain("Humongous Candidate"); + output.shouldContain("Humongous Reclaimed"); // As G1TraceReclaimDeadHumongousObjectsAtYoungGC is set and GCWithHumongousObjectTest has humongous objects, // these logs should be displayed. --- old/test/gc/g1/TestGCLogMessages.java 2015-12-01 12:06:36.158929847 +0100 +++ new/test/gc/g1/TestGCLogMessages.java 2015-12-01 12:06:36.054929851 +0100 @@ -24,7 +24,7 @@ /* * @test TestGCLogMessages * @bug 8035406 8027295 8035398 8019342 8027959 8048179 8027962 8069330 - * @summary Ensure that the PrintGCDetails output for a minor GC with G1 + * @summary Ensure the output for a minor GC with G1 * includes the expected necessary messages. * @key gc * @library /testlibrary @@ -38,7 +38,7 @@ public class TestGCLogMessages { private enum Level { - OFF, FINER, FINEST; + OFF, DEBUG, TRACE; public boolean lessOrEqualTo(Level other) { return this.compareTo(other) < 0; } @@ -56,36 +56,36 @@ private LogMessageWithLevel allLogMessages[] = new LogMessageWithLevel[] { // Update RS - new LogMessageWithLevel("Scan HCC (ms)", Level.FINER), + new LogMessageWithLevel("Scan HCC", Level.DEBUG), // Ext Root Scan - new LogMessageWithLevel("Thread Roots (ms)", Level.FINEST), - new LogMessageWithLevel("StringTable Roots (ms)", Level.FINEST), - new LogMessageWithLevel("Universe Roots (ms)", Level.FINEST), - new LogMessageWithLevel("JNI Handles Roots (ms)", Level.FINEST), - new LogMessageWithLevel("ObjectSynchronizer Roots (ms)", Level.FINEST), - new LogMessageWithLevel("FlatProfiler Roots", Level.FINEST), - new LogMessageWithLevel("Management Roots", Level.FINEST), - new LogMessageWithLevel("SystemDictionary Roots", Level.FINEST), - new LogMessageWithLevel("CLDG Roots", Level.FINEST), - new LogMessageWithLevel("JVMTI Roots", Level.FINEST), - new LogMessageWithLevel("SATB Filtering", Level.FINEST), - new LogMessageWithLevel("CM RefProcessor Roots", Level.FINEST), - new LogMessageWithLevel("Wait For Strong CLD", Level.FINEST), - new LogMessageWithLevel("Weak CLD Roots", Level.FINEST), + new LogMessageWithLevel("Thread Roots:", Level.DEBUG), + new LogMessageWithLevel("StringTable Roots:", Level.DEBUG), + new LogMessageWithLevel("Universe Roots:", Level.DEBUG), + new LogMessageWithLevel("JNI Handles Roots:", Level.DEBUG), + new LogMessageWithLevel("ObjectSynchronizer Roots:", Level.DEBUG), + new LogMessageWithLevel("FlatProfiler Roots", Level.DEBUG), + new LogMessageWithLevel("Management Roots", Level.DEBUG), + new LogMessageWithLevel("SystemDictionary Roots", Level.DEBUG), + new LogMessageWithLevel("CLDG Roots", Level.DEBUG), + new LogMessageWithLevel("JVMTI Roots", Level.DEBUG), + new LogMessageWithLevel("SATB Filtering", Level.DEBUG), + new LogMessageWithLevel("CM RefProcessor Roots", Level.DEBUG), + new LogMessageWithLevel("Wait For Strong CLD", Level.DEBUG), + new LogMessageWithLevel("Weak CLD Roots", Level.DEBUG), // Redirty Cards - new LogMessageWithLevel("Redirty Cards", Level.FINER), - new LogMessageWithLevel("Parallel Redirty", Level.FINEST), - new LogMessageWithLevel("Redirtied Cards", Level.FINEST), + new LogMessageWithLevel("Redirty Cards", Level.DEBUG), + new LogMessageWithLevel("Parallel Redirty", Level.DEBUG), + new LogMessageWithLevel("Redirtied Cards", Level.DEBUG), // Misc Top-level - new LogMessageWithLevel("Code Root Purge", Level.FINER), - new LogMessageWithLevel("String Dedup Fixup", Level.FINER), - new LogMessageWithLevel("Expand Heap After Collection", Level.FINER), + new LogMessageWithLevel("Code Root Purge", Level.DEBUG), + new LogMessageWithLevel("String Dedup Fixup", Level.DEBUG), + new LogMessageWithLevel("Expand Heap After Collection", Level.DEBUG), // Free CSet - new LogMessageWithLevel("Young Free CSet", Level.FINEST), - new LogMessageWithLevel("Non-Young Free CSet", Level.FINEST), + new LogMessageWithLevel("Young Free CSet", Level.TRACE), + new LogMessageWithLevel("Non-Young Free CSet", Level.TRACE), // Humongous Eager Reclaim - new LogMessageWithLevel("Humongous Reclaim", Level.FINER), - new LogMessageWithLevel("Humongous Register", Level.FINER), + new LogMessageWithLevel("Humongous Reclaim", Level.DEBUG), + new LogMessageWithLevel("Humongous Register", Level.DEBUG), }; void checkMessagesAtLevel(OutputAnalyzer output, LogMessageWithLevel messages[], Level level) throws Exception { @@ -116,53 +116,49 @@ pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", "-XX:+UseStringDeduplication", "-Xmx10M", - "-XX:+PrintGCDetails", + "-Xlog:gc+phases=debug", GCTest.class.getName()); output = new OutputAnalyzer(pb.start()); - checkMessagesAtLevel(output, allLogMessages, Level.FINER); + checkMessagesAtLevel(output, allLogMessages, Level.DEBUG); pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", "-XX:+UseStringDeduplication", "-Xmx10M", - "-XX:+PrintGCDetails", - "-XX:+UnlockExperimentalVMOptions", - "-XX:G1LogLevel=finest", + "-Xlog:gc+phases=trace", GCTest.class.getName()); output = new OutputAnalyzer(pb.start()); - checkMessagesAtLevel(output, allLogMessages, Level.FINEST); + checkMessagesAtLevel(output, allLogMessages, Level.TRACE); output.shouldHaveExitValue(0); } LogMessageWithLevel exhFailureMessages[] = new LogMessageWithLevel[] { - new LogMessageWithLevel("Evacuation Failure", Level.FINER), - new LogMessageWithLevel("Recalculate Used", Level.FINEST), - new LogMessageWithLevel("Remove Self Forwards", Level.FINEST), - new LogMessageWithLevel("Restore RemSet", Level.FINEST), + new LogMessageWithLevel("Evacuation Failure", Level.DEBUG), + new LogMessageWithLevel("Recalculate Used", Level.TRACE), + new LogMessageWithLevel("Remove Self Forwards", Level.TRACE), + new LogMessageWithLevel("Restore RemSet", Level.TRACE), }; private void testWithToSpaceExhaustionLogs() throws Exception { ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", "-Xmx32M", "-Xmn16M", - "-XX:+PrintGCDetails", + "-Xlog:gc+phases=debug", GCTestWithToSpaceExhaustion.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); - checkMessagesAtLevel(output, exhFailureMessages, Level.FINER); + checkMessagesAtLevel(output, exhFailureMessages, Level.DEBUG); output.shouldHaveExitValue(0); pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", "-Xmx32M", "-Xmn16M", - "-XX:+PrintGCDetails", - "-XX:+UnlockExperimentalVMOptions", - "-XX:G1LogLevel=finest", + "-Xlog:gc+phases=trace", GCTestWithToSpaceExhaustion.class.getName()); output = new OutputAnalyzer(pb.start()); - checkMessagesAtLevel(output, exhFailureMessages, Level.FINEST); + checkMessagesAtLevel(output, exhFailureMessages, Level.TRACE); output.shouldHaveExitValue(0); } --- old/test/gc/g1/TestHumongousAllocInitialMark.java 2015-12-01 12:06:36.326929842 +0100 +++ new/test/gc/g1/TestHumongousAllocInitialMark.java 2015-12-01 12:06:36.222929845 +0100 @@ -46,11 +46,11 @@ "-Xmx" + heapSize + "m", "-XX:G1HeapRegionSize=" + heapRegionSize + "m", "-XX:InitiatingHeapOccupancyPercent=" + initiatingHeapOccupancyPercent, - "-XX:+PrintGC", + "-Xlog:gc", HumongousObjectAllocator.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); - output.shouldContain("GC pause (G1 Humongous Allocation) (young) (initial-mark)"); + output.shouldContain("Pause Initial Mark (G1 Humongous Allocation)"); output.shouldNotContain("Full GC"); output.shouldHaveExitValue(0); } --- old/test/gc/g1/TestHumongousAllocNearlyFullRegion.java 2015-12-01 12:06:36.514929835 +0100 +++ new/test/gc/g1/TestHumongousAllocNearlyFullRegion.java 2015-12-01 12:06:36.398929839 +0100 @@ -44,11 +44,11 @@ "-Xms" + heapSize + "m", "-Xmx" + heapSize + "m", "-XX:G1HeapRegionSize=" + heapRegionSize + "m", - "-XX:+PrintGC", + "-Xlog:gc", HumongousObjectAllocator.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); - output.shouldContain("GC pause (G1 Humongous Allocation) (young) (initial-mark)"); + output.shouldContain("Pause Initial Mark (G1 Humongous Allocation)"); output.shouldHaveExitValue(0); } --- old/test/gc/g1/TestNoEagerReclaimOfHumongousRegions.java 2015-12-01 12:06:36.706929828 +0100 +++ new/test/gc/g1/TestNoEagerReclaimOfHumongousRegions.java 2015-12-01 12:06:36.586929833 +0100 @@ -34,7 +34,7 @@ * @build TestNoEagerReclaimOfHumongousRegions * @run main ClassFileInstaller sun.hotspot.WhiteBox * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+PrintGC -XX:+UseG1GC -XX:MaxTenuringThreshold=0 -XX:G1RSetSparseRegionEntries=32 -XX:G1HeapRegionSize=1m -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:+UnlockExperimentalVMOptions -XX:+G1TraceEagerReclaimHumongousObjects TestNoEagerReclaimOfHumongousRegions + * @run main/othervm -Xbootclasspath/a:. -Xlog:gc,gc+humongous=debug -XX:+UseG1GC -XX:MaxTenuringThreshold=0 -XX:G1RSetSparseRegionEntries=32 -XX:G1HeapRegionSize=1m -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI TestNoEagerReclaimOfHumongousRegions */ import java.util.LinkedList; --- old/test/gc/g1/TestPLABOutput.java 2015-12-01 12:06:36.878929822 +0100 +++ new/test/gc/g1/TestPLABOutput.java 2015-12-01 12:06:36.774929826 +0100 @@ -54,8 +54,7 @@ "-XX:+WhiteBoxAPI", "-XX:+UseG1GC", "-Xmx10M", - "-XX:+PrintGC", - "-XX:+PrintPLAB", + "-Xlog:gc+plab=debug", GCTest.class.getName() }; @@ -66,7 +65,7 @@ System.out.println(output.getStdout()); - String pattern = "#0:.*allocated = (\\d+).*"; + String pattern = ".*GC\\(0\\) .*allocated = (\\d+).*"; Pattern r = Pattern.compile(pattern); Matcher m = r.matcher(output.getStdout()); --- old/test/gc/g1/TestPrintRegionRememberedSetInfo.java 2015-12-01 12:06:37.050929816 +0100 +++ new/test/gc/g1/TestPrintRegionRememberedSetInfo.java 2015-12-01 12:06:36.950929820 +0100 @@ -57,7 +57,6 @@ "-Xmx10m", "-XX:+ExplicitGCInvokesConcurrent", "-XX:+UnlockDiagnosticVMOptions", - "-XX:+G1PrintRegionLivenessInfo", "-XX:G1HeapRegionSize=1M", "-XX:InitiatingHeapOccupancyPercent=0", }; @@ -79,13 +78,13 @@ public static void main(String[] args) throws Exception { String result; - result = runTest("-XX:+G1PrintRegionLivenessInfo"); + result = runTest("-Xlog:gc+liveness=trace"); // check that we got region statistics output if (result.indexOf("PHASE") == -1) { throw new RuntimeException("Unexpected output from -XX:+PrintRegionLivenessInfo found."); } - result = runTest("-XX:-G1PrintRegionLivenessInfo"); + result = runTest("-Xlog:gc+liveness"); if (result.indexOf("remset") != -1) { throw new RuntimeException("Should find remembered set information in output."); } --- old/test/gc/g1/TestShrinkAuxiliaryData.java 2015-12-01 12:06:37.230929810 +0100 +++ new/test/gc/g1/TestShrinkAuxiliaryData.java 2015-12-01 12:06:37.126929814 +0100 @@ -49,7 +49,7 @@ "-XX:+UseG1GC", "-XX:G1HeapRegionSize=" + REGION_SIZE, "-XX:-ExplicitGCInvokesConcurrent", - "-XX:+PrintGCDetails", + "-Xlog:gc=debug", "-XX:+UnlockDiagnosticVMOptions", "-XX:+WhiteBoxAPI", "-Xbootclasspath/a:.", --- old/test/gc/g1/TestStringDeduplicationTools.java 2015-12-01 12:06:37.422929803 +0100 +++ new/test/gc/g1/TestStringDeduplicationTools.java 2015-12-01 12:06:37.306929807 +0100 @@ -304,10 +304,8 @@ } public static OutputAnalyzer run() throws Exception { - return runTest("-XX:+PrintGC", - "-XX:+PrintGCDetails", + return runTest("-Xlog:gc=debug,gc+stringdedup=trace", "-XX:+UseStringDeduplication", - "-XX:+PrintStringDeduplicationStatistics", "-XX:StringDeduplicationAgeThreshold=" + DefaultAgeThreshold, InternedTest.class.getName(), "" + DefaultAgeThreshold); @@ -333,11 +331,10 @@ OutputAnalyzer output = DeduplicationTest.run(LargeNumberOfStrings, DefaultAgeThreshold, YoungGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics"); + "-Xlog:gc,gc+stringdedup=trace"); output.shouldNotContain("Full GC"); - output.shouldContain("GC pause (G1 Evacuation Pause) (young)"); - output.shouldContain("GC concurrent-string-deduplication"); + output.shouldContain("Pause Young (G1 Evacuation Pause)"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldHaveExitValue(0); } @@ -347,11 +344,10 @@ OutputAnalyzer output = DeduplicationTest.run(LargeNumberOfStrings, DefaultAgeThreshold, FullGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics"); - output.shouldNotContain("GC pause (G1 Evacuation Pause) (young)"); + "-Xlog:gc,gc+stringdedup=trace"); + output.shouldNotContain("Pause Young (G1 Evacuation Pause)"); output.shouldContain("Full GC"); - output.shouldContain("GC concurrent-string-deduplication"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldHaveExitValue(0); } @@ -361,10 +357,9 @@ OutputAnalyzer output = DeduplicationTest.run(LargeNumberOfStrings, DefaultAgeThreshold, YoungGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics", + "-Xlog:gc,gc+stringdedup=trace", "-XX:+StringDeduplicationResizeALot"); - output.shouldContain("GC concurrent-string-deduplication"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldNotContain("Resize Count: 0"); output.shouldHaveExitValue(0); @@ -375,10 +370,9 @@ OutputAnalyzer output = DeduplicationTest.run(LargeNumberOfStrings, DefaultAgeThreshold, YoungGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics", + "-Xlog:gc,gc+stringdedup=trace", "-XX:+StringDeduplicationRehashALot"); - output.shouldContain("GC concurrent-string-deduplication"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldNotContain("Rehash Count: 0"); output.shouldNotContain("Hash Seed: 0x0"); @@ -392,9 +386,8 @@ output = DeduplicationTest.run(SmallNumberOfStrings, MaxAgeThreshold, YoungGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics"); - output.shouldContain("GC concurrent-string-deduplication"); + "-Xlog:gc,gc+stringdedup=trace"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldHaveExitValue(0); @@ -402,9 +395,8 @@ output = DeduplicationTest.run(SmallNumberOfStrings, MinAgeThreshold, YoungGC, - "-XX:+PrintGC", - "-XX:+PrintStringDeduplicationStatistics"); - output.shouldContain("GC concurrent-string-deduplication"); + "-Xlog:gc,gc+stringdedup=trace"); + output.shouldContain("Concurrent String Deduplication"); output.shouldContain("Deduplicated:"); output.shouldHaveExitValue(0); @@ -426,20 +418,20 @@ public static void testPrintOptions() throws Exception { OutputAnalyzer output; - // Test without PrintGC and without PrintStringDeduplicationStatistics + // Test without -Xlog:gc output = DeduplicationTest.run(SmallNumberOfStrings, DefaultAgeThreshold, YoungGC); - output.shouldNotContain("GC concurrent-string-deduplication"); + output.shouldNotContain("Concurrent String Deduplication"); output.shouldNotContain("Deduplicated:"); output.shouldHaveExitValue(0); - // Test with PrintGC but without PrintStringDeduplicationStatistics + // Test with -Xlog:gc+stringdedup output = DeduplicationTest.run(SmallNumberOfStrings, DefaultAgeThreshold, YoungGC, - "-XX:+PrintGC"); - output.shouldContain("GC concurrent-string-deduplication"); + "-Xlog:gc+stringdedup"); + output.shouldContain("Concurrent String Deduplication"); output.shouldNotContain("Deduplicated:"); output.shouldHaveExitValue(0); } --- old/test/gc/g1/TestStringSymbolTableStats.java 2015-12-01 12:06:37.598929797 +0100 +++ new/test/gc/g1/TestStringSymbolTableStats.java 2015-12-01 12:06:37.494929801 +0100 @@ -39,7 +39,7 @@ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", "-XX:+UnlockExperimentalVMOptions", - "-XX:+G1TraceStringSymbolTableScrubbing", + "-Xlog:gc+stringdedup=trace", SystemGCTest.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); --- old/test/gc/g1/mixedgc/TestLogging.java 2015-12-01 12:06:37.766929791 +0100 +++ new/test/gc/g1/mixedgc/TestLogging.java 2015-12-01 12:06:37.666929795 +0100 @@ -68,10 +68,10 @@ public static final int ALLOCATION_COUNT = 15; public static void main(String args[]) throws Exception { - // Test turns logging on by giving -XX:+PrintGC flag - test("-XX:+PrintGC"); - // Test turns logging on by giving -XX:+PrintGCDetails - test("-XX:+PrintGCDetails"); + // Test turns logging on by giving -Xlog:gc flag + test("-Xlog:gc"); + // Test turns logging on by giving -Xlog:gc=debug flag + test("-Xlog:gc=debug"); } private static void test(String vmFlag) throws Exception { @@ -79,7 +79,7 @@ OutputAnalyzer output = spawnMixedGCProvoker(vmFlag); System.out.println(output.getStdout()); output.shouldHaveExitValue(0); - output.shouldContain("GC pause (G1 Evacuation Pause) (mixed)"); + output.shouldContain("Pause Mixed (G1 Evacuation Pause)"); } /** --- old/test/gc/logging/TestGCId.java 2015-12-01 12:06:37.954929785 +0100 +++ new/test/gc/logging/TestGCId.java 2015-12-01 12:06:37.842929789 +0100 @@ -36,44 +36,21 @@ public class TestGCId { public static void main(String[] args) throws Exception { - testGCId("UseParallelGC", "PrintGC"); - testGCId("UseParallelGC", "PrintGCDetails"); - - testGCId("UseG1GC", "PrintGC"); - testGCId("UseG1GC", "PrintGCDetails"); - - testGCId("UseConcMarkSweepGC", "PrintGC"); - testGCId("UseConcMarkSweepGC", "PrintGCDetails"); - - testGCId("UseSerialGC", "PrintGC"); - testGCId("UseSerialGC", "PrintGCDetails"); + testGCId("UseParallelGC"); + testGCId("UseG1GC"); + testGCId("UseConcMarkSweepGC"); + testGCId("UseSerialGC"); } private static void verifyContainsGCIDs(OutputAnalyzer output) { - output.shouldMatch("^#0: \\["); - output.shouldMatch("^#1: \\["); - output.shouldHaveExitValue(0); - } - - private static void verifyContainsNoGCIDs(OutputAnalyzer output) { - output.shouldNotMatch("^#[0-9]+: \\["); + output.shouldMatch("\\[.*\\]\\[.*\\]\\[.*\\] GC\\(0\\) "); + output.shouldMatch("\\[.*\\]\\[.*\\]\\[.*\\] GC\\(1\\) "); output.shouldHaveExitValue(0); } - private static void testGCId(String gcFlag, String logFlag) throws Exception { - // GCID logging enabled - ProcessBuilder pb_enabled = - ProcessTools.createJavaProcessBuilder("-XX:+" + gcFlag, "-XX:+" + logFlag, "-Xmx10M", "-XX:+PrintGCID", GCTest.class.getName()); - verifyContainsGCIDs(new OutputAnalyzer(pb_enabled.start())); - - // GCID logging disabled - ProcessBuilder pb_disabled = - ProcessTools.createJavaProcessBuilder("-XX:+" + gcFlag, "-XX:+" + logFlag, "-Xmx10M", "-XX:-PrintGCID", GCTest.class.getName()); - verifyContainsNoGCIDs(new OutputAnalyzer(pb_disabled.start())); - - // GCID logging default + private static void testGCId(String gcFlag) throws Exception { ProcessBuilder pb_default = - ProcessTools.createJavaProcessBuilder("-XX:+" + gcFlag, "-XX:+" + logFlag, "-Xmx10M", GCTest.class.getName()); + ProcessTools.createJavaProcessBuilder("-XX:+" + gcFlag, "-Xlog:gc", "-Xmx10M", GCTest.class.getName()); verifyContainsGCIDs(new OutputAnalyzer(pb_default.start())); } --- old/test/gc/logging/TestPrintReferences.java 2015-12-01 12:06:38.126929779 +0100 +++ new/test/gc/logging/TestPrintReferences.java 2015-12-01 12:06:38.026929782 +0100 @@ -37,18 +37,18 @@ public class TestPrintReferences { public static void main(String[] args) throws Exception { ProcessBuilder pb_enabled = - ProcessTools.createJavaProcessBuilder("-XX:+PrintGCDetails", "-XX:+PrintReferenceGC", "-Xmx10M", GCTest.class.getName()); + ProcessTools.createJavaProcessBuilder("-Xlog:gc+ref=debug", "-Xmx10M", GCTest.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start()); String countRegex = "[0-9]+ refs"; - String timeRegex = "[0-9]+[.,][0-9]+ secs"; + String timeRegex = "\\([0-9]+[.,][0-9]+s, [0-9]+[.,][0-9]+s\\) [0-9]+[.,][0-9]+ms"; - output.shouldMatch( - "#[0-9]+: \\[SoftReference, " + countRegex + ", " + timeRegex + "\\]" + - "#[0-9]+: \\[WeakReference, " + countRegex + ", " + timeRegex + "\\]" + - "#[0-9]+: \\[FinalReference, " + countRegex + ", " + timeRegex + "\\]" + - "#[0-9]+: \\[PhantomReference, " + countRegex + ", " + timeRegex + "\\]" + - "#[0-9]+: \\[JNI Weak Reference, (" + countRegex + ", )?" + timeRegex + "\\]"); + output.shouldMatch(".* GC\\([0-9]+\\) SoftReference " + timeRegex + "\n" + + ".* GC\\([0-9]+\\) WeakReference " + timeRegex + "\n" + + ".* GC\\([0-9]+\\) FinalReference " + timeRegex + "\n" + + ".* GC\\([0-9]+\\) PhantomReference " + timeRegex + "\n" + + ".* GC\\([0-9]+\\) JNI Weak Reference " + timeRegex + "\n" + + ".* GC\\([0-9]+\\) Ref Counts: Soft: [0-9]+ Weak: [0-9]+ Final: [0-9]+ Phantom: [0-9]+\n"); output.shouldHaveExitValue(0); } --- old/test/gc/serial/HeapChangeLogging.java 2015-12-01 12:06:38.306929773 +0100 +++ new/test/gc/serial/HeapChangeLogging.java 2015-12-01 12:06:38.202929776 +0100 @@ -39,11 +39,11 @@ public class HeapChangeLogging { public static void main(String[] args) throws Exception { - ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-XX:+PrintGC", "HeapFiller"); + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-Xlog:gc", "HeapFiller"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); String stdout = output.getStdout(); System.out.println(stdout); - Matcher stdoutMatcher = Pattern.compile("\\[GC .Allocation Failure.*K->.*K\\(.*K\\), .* secs\\]", Pattern.MULTILINE).matcher(stdout); + Matcher stdoutMatcher = Pattern.compile(".*\\(Allocation Failure\\) [0-9]+[KMG]->[0-9]+[KMG]\\([0-9]+[KMG]\\)", Pattern.MULTILINE).matcher(stdout); if (!stdoutMatcher.find()) { throw new RuntimeException("No proper GC log line found"); } --- old/test/gc/whitebox/TestWBGC.java 2015-12-01 12:06:38.482929766 +0100 +++ new/test/gc/whitebox/TestWBGC.java 2015-12-01 12:06:38.382929770 +0100 @@ -44,7 +44,7 @@ "-XX:+UnlockDiagnosticVMOptions", "-XX:+WhiteBoxAPI", "-XX:MaxTenuringThreshold=1", - "-XX:+PrintGC", + "-Xlog:gc", GCYoungTest.class.getName()); OutputAnalyzer output = new OutputAnalyzer(pb.start()); --- old/test/runtime/7158988/FieldMonitor.java 2015-12-01 12:06:38.666929760 +0100 +++ new/test/runtime/7158988/FieldMonitor.java 2015-12-01 12:06:38.562929764 +0100 @@ -63,7 +63,7 @@ public static final String CLASS_NAME = "TestPostFieldModification"; public static final String FIELD_NAME = "value"; - public static final String ARGUMENTS = "-Xshare:off -XX:+PrintGC"; + public static final String ARGUMENTS = "-Xshare:off -Xlog:gc"; public static void main(String[] args) throws IOException, InterruptedException { --- old/test/runtime/CommandLine/PrintGCApplicationConcurrentTime.java 2015-12-01 12:06:38.850929754 +0100 +++ new/test/runtime/CommandLine/PrintGCApplicationConcurrentTime.java 2015-12-01 12:06:38.750929757 +0100 @@ -24,7 +24,7 @@ /* * @test * @bug 8026041 - * @run main/othervm -XX:+PrintGCApplicationConcurrentTime -Xcomp PrintGCApplicationConcurrentTime + * @run main/othervm -Xlog:safepoint -Xcomp PrintGCApplicationConcurrentTime */ public class PrintGCApplicationConcurrentTime { --- old/test/runtime/CommandLine/TestVMOptions.java 2015-12-01 12:06:39.042929747 +0100 +++ new/test/runtime/CommandLine/TestVMOptions.java 2015-12-01 12:06:38.926929751 +0100 @@ -41,7 +41,7 @@ "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+PrintFlagsInitial"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); - output.shouldContain("bool PrintGCDetails"); + output.shouldContain("bool VerifyDuringGC"); pb = ProcessTools.createJavaProcessBuilder( "-XX:-PrintVMOptions", "-version"); --- old/test/runtime/CompressedOops/CompressedClassPointers.java 2015-12-01 12:06:39.210929741 +0100 +++ new/test/runtime/CompressedOops/CompressedClassPointers.java 2015-12-01 12:06:39.110929745 +0100 @@ -39,7 +39,7 @@ "-XX:+UnlockDiagnosticVMOptions", "-XX:SharedBaseAddress=8g", "-Xmx128m", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-XX:+VerifyBeforeGC", "-version"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); output.shouldContain("Narrow klass base: 0x0000000000000000"); @@ -51,7 +51,7 @@ "-XX:+UnlockDiagnosticVMOptions", "-XX:CompressedClassSpaceSize=3g", "-Xmx128m", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-XX:+VerifyBeforeGC", "-version"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); output.shouldContain("Narrow klass base: 0x0000000000000000, Narrow klass shift: 3"); @@ -62,7 +62,7 @@ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( "-XX:+UnlockDiagnosticVMOptions", "-Xmx30g", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-XX:+VerifyBeforeGC", "-version"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); output.shouldNotContain("Narrow klass base: 0x0000000000000000"); @@ -75,7 +75,7 @@ "-XX:+UnlockDiagnosticVMOptions", "-Xmx128m", "-XX:+UseLargePages", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-XX:+VerifyBeforeGC", "-version"); OutputAnalyzer output = new OutputAnalyzer(pb.start()); output.shouldContain("Narrow klass base:"); --- old/test/runtime/CompressedOops/CompressedClassSpaceSize.java 2015-12-01 12:06:39.402929734 +0100 +++ new/test/runtime/CompressedOops/CompressedClassSpaceSize.java 2015-12-01 12:06:39.290929738 +0100 @@ -64,7 +64,7 @@ // Make sure the minimum size is set correctly and printed pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockDiagnosticVMOptions", "-XX:CompressedClassSpaceSize=1m", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-version"); output = new OutputAnalyzer(pb.start()); output.shouldContain("Compressed class space size: 1048576") @@ -74,7 +74,7 @@ // Make sure the maximum size is set correctly and printed pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockDiagnosticVMOptions", "-XX:CompressedClassSpaceSize=3g", - "-XX:+PrintCompressedOopsMode", + "-Xlog:gc+metaspace=trace", "-version"); output = new OutputAnalyzer(pb.start()); output.shouldContain("Compressed class space size: 3221225472") --- old/test/serviceability/dcmd/gc/RunGCTest.java 2015-12-01 12:06:39.586929728 +0100 +++ new/test/serviceability/dcmd/gc/RunGCTest.java 2015-12-01 12:06:39.474929732 +0100 @@ -43,7 +43,7 @@ * jdk.jvmstat/sun.jvmstat.monitor * @build jdk.test.lib.* * @build jdk.test.lib.dcmd.* - * @run testng/othervm -XX:+PrintGCDetails -Xloggc:RunGC.gclog -XX:-ExplicitGCInvokesConcurrent RunGCTest + * @run testng/othervm -Xlog:gc=debug:RunGC.gclog -XX:-ExplicitGCInvokesConcurrent RunGCTest */ public class RunGCTest { public void run(CommandExecutor executor) { @@ -59,7 +59,7 @@ } OutputAnalyzer output = new OutputAnalyzer(gcLog, ""); - output.shouldContain("[Full GC (Diagnostic Command)"); + output.shouldContain("Pause Full (Diagnostic Command)"); } @Test --- old/test/serviceability/dcmd/vm/FlagsTest.java 2015-12-01 12:06:39.758929722 +0100 +++ new/test/serviceability/dcmd/vm/FlagsTest.java 2015-12-01 12:06:39.654929726 +0100 @@ -36,14 +36,13 @@ * jdk.jvmstat/sun.jvmstat.monitor * @build jdk.test.lib.* * @build jdk.test.lib.dcmd.* - * @run testng/othervm -Xmx129m -XX:+PrintGC -XX:+UnlockDiagnosticVMOptions -XX:+IgnoreUnrecognizedVMOptions -XX:+ThereShouldNotBeAnyVMOptionNamedLikeThis_Right -XX:-TieredCompilation FlagsTest + * @run testng/othervm -Xmx129m -XX:+UnlockDiagnosticVMOptions -XX:+IgnoreUnrecognizedVMOptions -XX:+ThereShouldNotBeAnyVMOptionNamedLikeThis_Right -XX:-TieredCompilation FlagsTest */ public class FlagsTest { public void run(CommandExecutor executor) { OutputAnalyzer output = executor.execute("VM.flags"); /* The following are interpreted by the JVM as actual "flags" */ - output.shouldContain("-XX:+PrintGC"); output.shouldContain("-XX:+UnlockDiagnosticVMOptions"); output.shouldContain("-XX:+IgnoreUnrecognizedVMOptions"); output.shouldContain("-XX:-TieredCompilation"); --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/src/share/vm/gc/shared/gcTraceTime.inline.hpp 2015-12-01 12:06:39.834929719 +0100 @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2012, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_GC_SHARED_GCTRACETIME_INLINE_HPP +#define SHARE_VM_GC_SHARED_GCTRACETIME_INLINE_HPP + +#include "gc/shared/collectedHeap.hpp" +#include "gc/shared/gcTimer.hpp" +#include "gc/shared/gcTrace.hpp" +#include "gc/shared/gcTraceTime.hpp" +#include "logging/log.hpp" +#include "memory/universe.hpp" +#include "prims/jni_md.h" +#include "utilities/ticks.hpp" +#include "runtime/timer.hpp" + +#define LOG_STOP_TIME_FORMAT "(%.3fs, %.3fs) %.3fms" +#define LOG_STOP_HEAP_FORMAT SIZE_FORMAT "M->" SIZE_FORMAT "M(" SIZE_FORMAT "M)" + +template +void GCTraceTimeImpl::log_start(jlong start_counter) { + if (Log::is_level(Level)) { + FormatBuffer<> start_msg("%s", _title); + if (_gc_cause != GCCause::_no_gc) { + start_msg.append(" (%s)", GCCause::to_string(_gc_cause)); + } + start_msg.append(" (%.3fs)", TimeHelper::counter_to_seconds(start_counter)); + // Make sure to put the "start" tag last in the tag set + STATIC_ASSERT(T0 != LogTag::__NO_TAG); // Need some tag to log on. + STATIC_ASSERT(T4 == LogTag::__NO_TAG); // Need to leave at least the last tag for the "start" tag in log_start() + if (T1 == LogTag::__NO_TAG) { + Log::template write("%s", start_msg.buffer()); + } else if (T2 == LogTag::__NO_TAG) { + Log::template write("%s", start_msg.buffer()); + } else if (T3 == LogTag::__NO_TAG) { + Log::template write("%s", start_msg.buffer()); + } else { + Log::template write("%s", start_msg.buffer()); + } + } +} + +template +void GCTraceTimeImpl::log_stop(jlong start_counter, jlong stop_counter) { + double duration_in_ms = TimeHelper::counter_to_millis(stop_counter - start_counter); + double start_time_in_secs = TimeHelper::counter_to_seconds(start_counter); + double stop_time_in_secs = TimeHelper::counter_to_seconds(stop_counter); + FormatBuffer<> stop_msg("%s", _title); + if (_gc_cause != GCCause::_no_gc) { + stop_msg.append(" (%s)", GCCause::to_string(_gc_cause)); + } + if (_heap_usage_before == SIZE_MAX) { + Log::template write("%s " LOG_STOP_TIME_FORMAT, + stop_msg.buffer(), start_time_in_secs, stop_time_in_secs, duration_in_ms); + } else { + CollectedHeap* heap = Universe::heap(); + size_t used_before_m = _heap_usage_before / M; + size_t used_m = heap->used() / M; + size_t capacity_m = heap->capacity() / M; + Log::template write("%s " LOG_STOP_HEAP_FORMAT " " LOG_STOP_TIME_FORMAT, + stop_msg.buffer(), used_before_m, used_m, capacity_m, start_time_in_secs, stop_time_in_secs, duration_in_ms); + } +} + +template +void GCTraceTimeImpl::time_stamp(Ticks& ticks) { + if (_enabled || _timer != NULL) { + ticks.stamp(); + } +} + +template +GCTraceTimeImpl::GCTraceTimeImpl(const char* title, GCTimer* timer, GCCause::Cause gc_cause, bool log_heap_usage) : + _enabled(Log::is_level(Level)), + _start_ticks(), + _heap_usage_before(SIZE_MAX), + _title(title), + _gc_cause(gc_cause), + _timer(timer) { + + time_stamp(_start_ticks); + if (_enabled) { + if (log_heap_usage) { + _heap_usage_before = Universe::heap()->used(); + } + log_start(_start_ticks.value()); + } + if (_timer != NULL) { + _timer->register_gc_phase_start(_title, _start_ticks); + } +} + +template +GCTraceTimeImpl::~GCTraceTimeImpl() { + Ticks stop_ticks; + time_stamp(stop_ticks); + if (_enabled) { + log_stop(_start_ticks.value(), stop_ticks.value()); + } + if (_timer != NULL) { + _timer->register_gc_phase_end(stop_ticks); + } +} + +template +GCTraceConcTimeImpl::GCTraceConcTimeImpl(const char* title) : + _enabled(Log::is_level(Level)), _start_time(os::elapsed_counter()), _title(title) { + if (_enabled) { + Log::template write("%s (%.3fs)", _title, TimeHelper::counter_to_seconds(_start_time)); + } +} + +template +GCTraceConcTimeImpl::~GCTraceConcTimeImpl() { + if (_enabled) { + jlong stop_time = os::elapsed_counter(); + Log::template write("%s " LOG_STOP_TIME_FORMAT, + _title, + TimeHelper::counter_to_seconds(_start_time), + TimeHelper::counter_to_seconds(stop_time), + TimeHelper::counter_to_millis(stop_time - _start_time)); + } +} + +#define GCTraceTime(Level, ...) GCTraceTimeImpl +#define GCTraceConcTime(Level, ...) GCTraceConcTimeImpl + +#endif // SHARE_VM_GC_SHARED_GCTRACETIME_INLINE_HPP --- old/test/gc/g1/TestSummarizeRSetStats.java 2015-12-01 12:06:40.170929708 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,87 +0,0 @@ -/* - * Copyright (c) 2013, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test TestSummarizeRSetStats.java - * @bug 8013895 8129977 - * @library /testlibrary - * @modules java.base/sun.misc - * java.management/sun.management - * @build TestSummarizeRSetStatsTools TestSummarizeRSetStats - * @summary Verify output of -XX:+G1SummarizeRSetStats - * @run main TestSummarizeRSetStats - * - * Test the output of G1SummarizeRSetStats in conjunction with G1SummarizeRSetStatsPeriod. - */ - -public class TestSummarizeRSetStats { - - public static void main(String[] args) throws Exception { - String result; - - if (!TestSummarizeRSetStatsTools.testingG1GC()) { - return; - } - - // no remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(null, 0); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 0, 0); - - // no remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(null, 2); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 0, 0); - - // no remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:G1SummarizeRSetStatsPeriod=1" }, 3); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 0, 0); - - // single remembered set summary output at the end - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats" }, 0); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 0); - - // single remembered set summary output at the end - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats" }, 2); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 0); - - // single remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=1" }, 0); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 0); - - // two times remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=1" }, 1); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 2); - - // four times remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=1" }, 3); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 6); - - // three times remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=2" }, 3); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 4); - - // single remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=100" }, 3); - TestSummarizeRSetStatsTools.expectRSetSummaries(result, 1, 2); - } -} - --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/test/gc/g1/TestRemsetLogging.java 2015-12-01 12:06:39.982929714 +0100 @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2013, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestRemsetLogging.java + * @bug 8013895 8129977 + * @library /testlibrary + * @modules java.base/sun.misc + * java.management/sun.management + * @build TestRemsetLoggingTools TestRemsetLogging + * @summary Verify output of -Xlog:gc+remset*=trace + * @run main TestRemsetLogging + * + * Test the output of -Xlog:gc+remset*=trace in conjunction with G1SummarizeRSetStatsPeriod. + */ + +public class TestRemsetLogging { + + public static void main(String[] args) throws Exception { + String result; + + if (!TestRemsetLoggingTools.testingG1GC()) { + return; + } + + // no remembered set summary output + result = TestRemsetLoggingTools.runTest(null, 0); + TestRemsetLoggingTools.expectRSetSummaries(result, 0, 0); + + // no remembered set summary output + result = TestRemsetLoggingTools.runTest(null, 2); + TestRemsetLoggingTools.expectRSetSummaries(result, 0, 0); + + // no remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-XX:G1SummarizeRSetStatsPeriod=1" }, 3); + TestRemsetLoggingTools.expectRSetSummaries(result, 0, 0); + + // single remembered set summary output at the end + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace" }, 0); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 0); + + // single remembered set summary output at the end + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace" }, 2); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 0); + + // single remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=1" }, 0); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 0); + + // two times remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=1" }, 1); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 2); + + // four times remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=1" }, 3); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 6); + + // three times remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=2" }, 3); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 4); + + // single remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=100" }, 3); + TestRemsetLoggingTools.expectRSetSummaries(result, 1, 2); + } +} + --- old/test/gc/g1/TestSummarizeRSetStatsPerRegion.java 2015-12-01 12:06:40.442929698 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,57 +0,0 @@ -/* - * Copyright (c) 2013, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test TestSummarizeRSetStatsPerRegion.java - * @bug 8014078 8129977 - * @library /testlibrary - * @modules java.base/sun.misc - * java.management/sun.management - * @build TestSummarizeRSetStatsTools TestSummarizeRSetStatsPerRegion - * @summary Verify output of -XX:+G1SummarizeRSetStats in regards to per-region type output - * @run main TestSummarizeRSetStatsPerRegion - */ - -import jdk.test.lib.*; -import java.lang.Thread; -import java.util.ArrayList; -import java.util.Arrays; - -public class TestSummarizeRSetStatsPerRegion { - - public static void main(String[] args) throws Exception { - String result; - - if (!TestSummarizeRSetStatsTools.testingG1GC()) { - return; - } - - // single remembered set summary output at the end - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats" }, 0); - TestSummarizeRSetStatsTools.expectPerRegionRSetSummaries(result, 1, 0); - - // two times remembered set summary output - result = TestSummarizeRSetStatsTools.runTest(new String[] { "-XX:+G1SummarizeRSetStats", "-XX:G1SummarizeRSetStatsPeriod=1" }, 1); - TestSummarizeRSetStatsTools.expectPerRegionRSetSummaries(result, 1, 2); - } -} --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/test/gc/g1/TestRemsetLoggingPerRegion.java 2015-12-01 12:06:40.250929705 +0100 @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2013, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestRemsetLoggingPerRegion.java + * @bug 8014078 8129977 + * @library /testlibrary + * @modules java.base/sun.misc + * java.management/sun.management + * @build TestRemsetLoggingTools TestRemsetLoggingPerRegion + * @summary Verify output of -Xlog:gc+remset*=trace in regards to per-region type output + * @run main TestRemsetLoggingPerRegion + */ + +import jdk.test.lib.*; +import java.lang.Thread; +import java.util.ArrayList; +import java.util.Arrays; + +public class TestRemsetLoggingPerRegion { + + public static void main(String[] args) throws Exception { + String result; + + if (!TestRemsetLoggingTools.testingG1GC()) { + return; + } + + // single remembered set summary output at the end + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace" }, 0); + TestRemsetLoggingTools.expectPerRegionRSetSummaries(result, 1, 0); + + // two times remembered set summary output + result = TestRemsetLoggingTools.runTest(new String[] { "-Xlog:gc+remset*=trace", "-XX:G1SummarizeRSetStatsPeriod=1" }, 1); + TestRemsetLoggingTools.expectPerRegionRSetSummaries(result, 1, 2); + } +} --- old/test/gc/g1/TestSummarizeRSetStatsThreads.java 2015-12-01 12:06:40.718929689 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2013, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test TestSummarizeRSetStatsThreads - * @bug 8025441 - * @summary Ensure that various values of worker threads/concurrent - * refinement threads do not crash the VM. - * @key gc - * @library /testlibrary - * @modules java.base/sun.misc - * java.management/sun.management - */ - -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import jdk.test.lib.ProcessTools; -import jdk.test.lib.OutputAnalyzer; - -public class TestSummarizeRSetStatsThreads { - - private static void runTest(int refinementThreads, int workerThreads) throws Exception { - ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", - "-XX:+UnlockDiagnosticVMOptions", - "-XX:+G1SummarizeRSetStats", - "-XX:G1ConcRefinementThreads=" + refinementThreads, - "-XX:ParallelGCThreads=" + workerThreads, - "-version"); - - OutputAnalyzer output = new OutputAnalyzer(pb.start()); - - // check output to contain the string "Concurrent RS threads times (s)" followed by - // the correct number of values in the next line. - - // a zero in refinement thread numbers indicates that the value in ParallelGCThreads should be used. - // Additionally use at least one thread. - int expectedNumRefinementThreads = refinementThreads; - - // create the pattern made up of n copies of a floating point number pattern - String numberPattern = String.format("%0" + expectedNumRefinementThreads + "d", 0) - .replace("0", "\\s+\\d+\\.\\d+"); - String pattern = "Concurrent RS threads times \\(s\\)$" + numberPattern + "$"; - Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(output.getStdout()); - - if (!m.find()) { - throw new Exception("Could not find correct output for concurrent RS threads times in stdout," + - " should match the pattern \"" + pattern + "\", but stdout is \n" + output.getStdout()); - } - output.shouldHaveExitValue(0); - } - - public static void main(String[] args) throws Exception { - if (!TestSummarizeRSetStatsTools.testingG1GC()) { - return; - } - // different valid combinations of number of refinement and gc worker threads - runTest(1, 1); - runTest(1, 5); - runTest(5, 1); - runTest(10, 10); - runTest(1, 2); - runTest(4, 3); - } -} --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/test/gc/g1/TestRemsetLoggingThreads.java 2015-12-01 12:06:40.518929696 +0100 @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestRemsetLoggingThreads + * @bug 8025441 + * @summary Ensure that various values of worker threads/concurrent + * refinement threads do not crash the VM. + * @key gc + * @library /testlibrary + * @modules java.base/sun.misc + * java.management/sun.management + */ + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import jdk.test.lib.ProcessTools; +import jdk.test.lib.OutputAnalyzer; + +public class TestRemsetLoggingThreads { + + private static void runTest(int refinementThreads, int workerThreads) throws Exception { + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", + "-XX:+UnlockDiagnosticVMOptions", + "-Xlog:gc+remset+exit=trace", + "-XX:G1ConcRefinementThreads=" + refinementThreads, + "-XX:ParallelGCThreads=" + workerThreads, + "-version"); + + OutputAnalyzer output = new OutputAnalyzer(pb.start()); + + // a zero in refinement thread numbers indicates that the value in ParallelGCThreads should be used. + // Additionally use at least one thread. + int expectedNumRefinementThreads = refinementThreads; + + String pattern = "Concurrent RS threads times \\(s\\)$"; + Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(output.getStdout()); + + if (!m.find()) { + throw new Exception("Could not find correct output for concurrent RS threads times in stdout," + + " should match the pattern \"" + pattern + "\", but stdout is \n" + output.getStdout()); + } + output.shouldHaveExitValue(0); + } + + public static void main(String[] args) throws Exception { + if (!TestRemsetLoggingTools.testingG1GC()) { + return; + } + // different valid combinations of number of refinement and gc worker threads + runTest(1, 1); + runTest(1, 5); + runTest(5, 1); + runTest(10, 10); + runTest(1, 2); + runTest(4, 3); + } +} --- old/test/gc/g1/TestSummarizeRSetStatsTools.java 2015-12-01 12:06:40.990929679 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,151 +0,0 @@ -/* - * Copyright (c) 2013, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Common helpers for TestSummarizeRSetStats* tests - */ - -import com.sun.management.HotSpotDiagnosticMXBean; -import com.sun.management.VMOption; - -import jdk.test.lib.*; -import java.lang.management.ManagementFactory; -import java.util.ArrayList; -import java.util.Arrays; - -class VerifySummaryOutput { - // 4M size, both are directly allocated into the old gen - static Object[] largeObject1 = new Object[1024 * 1024]; - static Object[] largeObject2 = new Object[1024 * 1024]; - - static int[] temp; - - public static void main(String[] args) { - // create some cross-references between these objects - for (int i = 0; i < largeObject1.length; i++) { - largeObject1[i] = largeObject2; - } - - for (int i = 0; i < largeObject2.length; i++) { - largeObject2[i] = largeObject1; - } - - int numGCs = Integer.parseInt(args[0]); - - if (numGCs > 0) { - // try to force a minor collection: the young gen is 4M, the - // amount of data allocated below is roughly that (4*1024*1024 + - // some header data) - for (int i = 0; i < 1024 ; i++) { - temp = new int[1024]; - } - } - - for (int i = 0; i < numGCs - 1; i++) { - System.gc(); - } - } -} - -public class TestSummarizeRSetStatsTools { - - // the VM is currently run using G1GC, i.e. trying to test G1 functionality. - public static boolean testingG1GC() { - HotSpotDiagnosticMXBean diagnostic = - ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class); - - VMOption option = diagnostic.getVMOption("UseG1GC"); - if (option.getValue().equals("false")) { - System.out.println("Skipping this test. It is only a G1 test."); - return false; - } - return true; - } - - public static String runTest(String[] additionalArgs, int numGCs) throws Exception { - ArrayList finalargs = new ArrayList(); - String[] defaultArgs = new String[] { - "-XX:+UseG1GC", - "-Xmn4m", - "-Xms20m", - "-Xmx20m", - "-XX:InitiatingHeapOccupancyPercent=100", // we don't want the additional GCs due to initial marking - "-XX:+PrintGC", - "-XX:+UnlockDiagnosticVMOptions", - "-XX:G1HeapRegionSize=1M", - }; - - finalargs.addAll(Arrays.asList(defaultArgs)); - - if (additionalArgs != null) { - finalargs.addAll(Arrays.asList(additionalArgs)); - } - - finalargs.add(VerifySummaryOutput.class.getName()); - finalargs.add(String.valueOf(numGCs)); - - ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( - finalargs.toArray(new String[0])); - OutputAnalyzer output = new OutputAnalyzer(pb.start()); - - output.shouldHaveExitValue(0); - - String result = output.getStdout(); - return result; - } - - private static void checkCounts(int expected, int actual, String which) throws Exception { - if (expected != actual) { - throw new Exception("RSet summaries mention " + which + " regions an incorrect number of times. Expected " + expected + ", got " + actual); - } - } - - public static void expectPerRegionRSetSummaries(String result, int expectedCumulative, int expectedPeriodic) throws Exception { - expectRSetSummaries(result, expectedCumulative, expectedPeriodic); - int actualYoung = result.split("Young regions").length - 1; - int actualHumonguous = result.split("Humonguous regions").length - 1; - int actualFree = result.split("Free regions").length - 1; - int actualOther = result.split("Old regions").length - 1; - - // the strings we check for above are printed four times per summary - int expectedPerRegionTypeInfo = (expectedCumulative + expectedPeriodic) * 4; - - checkCounts(expectedPerRegionTypeInfo, actualYoung, "Young"); - checkCounts(expectedPerRegionTypeInfo, actualHumonguous, "Humonguous"); - checkCounts(expectedPerRegionTypeInfo, actualFree, "Free"); - checkCounts(expectedPerRegionTypeInfo, actualOther, "Old"); - } - - public static void expectRSetSummaries(String result, int expectedCumulative, int expectedPeriodic) throws Exception { - int actualTotal = result.split("concurrent refinement").length - 1; - int actualCumulative = result.split("Cumulative RS summary").length - 1; - - if (expectedCumulative != actualCumulative) { - throw new Exception("Incorrect amount of RSet summaries at the end. Expected " + expectedCumulative + ", got " + actualCumulative); - } - - if (expectedPeriodic != (actualTotal - actualCumulative)) { - throw new Exception("Incorrect amount of per-period RSet summaries at the end. Expected " + expectedPeriodic + ", got " + (actualTotal - actualCumulative)); - } - } -} --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/test/gc/g1/TestRemsetLoggingTools.java 2015-12-01 12:06:40.794929686 +0100 @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2013, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * Common helpers for TestRemsetLogging* tests + */ + +import com.sun.management.HotSpotDiagnosticMXBean; +import com.sun.management.VMOption; + +import jdk.test.lib.*; +import java.lang.management.ManagementFactory; +import java.util.ArrayList; +import java.util.Arrays; + +class VerifySummaryOutput { + // 4M size, both are directly allocated into the old gen + static Object[] largeObject1 = new Object[1024 * 1024]; + static Object[] largeObject2 = new Object[1024 * 1024]; + + static int[] temp; + + public static void main(String[] args) { + // create some cross-references between these objects + for (int i = 0; i < largeObject1.length; i++) { + largeObject1[i] = largeObject2; + } + + for (int i = 0; i < largeObject2.length; i++) { + largeObject2[i] = largeObject1; + } + + int numGCs = Integer.parseInt(args[0]); + + if (numGCs > 0) { + // try to force a minor collection: the young gen is 4M, the + // amount of data allocated below is roughly that (4*1024*1024 + + // some header data) + for (int i = 0; i < 1024 ; i++) { + temp = new int[1024]; + } + } + + for (int i = 0; i < numGCs - 1; i++) { + System.gc(); + } + } +} + +public class TestRemsetLoggingTools { + + // the VM is currently run using G1GC, i.e. trying to test G1 functionality. + public static boolean testingG1GC() { + HotSpotDiagnosticMXBean diagnostic = + ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class); + + VMOption option = diagnostic.getVMOption("UseG1GC"); + if (option.getValue().equals("false")) { + System.out.println("Skipping this test. It is only a G1 test."); + return false; + } + return true; + } + + public static String runTest(String[] additionalArgs, int numGCs) throws Exception { + ArrayList finalargs = new ArrayList(); + String[] defaultArgs = new String[] { + "-XX:+UseG1GC", + "-Xmn4m", + "-Xms20m", + "-Xmx20m", + "-XX:InitiatingHeapOccupancyPercent=100", // we don't want the additional GCs due to initial marking + "-XX:+UnlockDiagnosticVMOptions", + "-XX:G1HeapRegionSize=1M", + }; + + finalargs.addAll(Arrays.asList(defaultArgs)); + + if (additionalArgs != null) { + finalargs.addAll(Arrays.asList(additionalArgs)); + } + + finalargs.add(VerifySummaryOutput.class.getName()); + finalargs.add(String.valueOf(numGCs)); + + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( + finalargs.toArray(new String[0])); + OutputAnalyzer output = new OutputAnalyzer(pb.start()); + + output.shouldHaveExitValue(0); + + String result = output.getStdout(); + return result; + } + + private static void checkCounts(int expected, int actual, String which) throws Exception { + if (expected != actual) { + throw new Exception("RSet summaries mention " + which + " regions an incorrect number of times. Expected " + expected + ", got " + actual); + } + } + + public static void expectPerRegionRSetSummaries(String result, int expectedCumulative, int expectedPeriodic) throws Exception { + expectRSetSummaries(result, expectedCumulative, expectedPeriodic); + int actualYoung = result.split("Young regions").length - 1; + int actualHumonguous = result.split("Humonguous regions").length - 1; + int actualFree = result.split("Free regions").length - 1; + int actualOther = result.split("Old regions").length - 1; + + // the strings we check for above are printed four times per summary + int expectedPerRegionTypeInfo = (expectedCumulative + expectedPeriodic) * 4; + + checkCounts(expectedPerRegionTypeInfo, actualYoung, "Young"); + checkCounts(expectedPerRegionTypeInfo, actualHumonguous, "Humonguous"); + checkCounts(expectedPerRegionTypeInfo, actualFree, "Free"); + checkCounts(expectedPerRegionTypeInfo, actualOther, "Old"); + } + + public static void expectRSetSummaries(String result, int expectedCumulative, int expectedPeriodic) throws Exception { + int actualTotal = result.split("concurrent refinement").length - 1; + int actualCumulative = result.split("Cumulative RS summary").length - 1; + + if (expectedCumulative != actualCumulative) { + throw new Exception("Incorrect amount of RSet summaries at the end. Expected " + expectedCumulative + ", got " + actualCumulative); + } + + if (expectedPeriodic != (actualTotal - actualCumulative)) { + throw new Exception("Incorrect amount of per-period RSet summaries at the end. Expected " + expectedPeriodic + ", got " + (actualTotal - actualCumulative)); + } + } +} --- /dev/null 2015-08-17 09:33:10.330134408 +0200 +++ new/test/serviceability/logging/TestLogRotation.java 2015-12-01 12:06:41.078929676 +0100 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2012, 2015, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestLogRotation.java + * @summary test flags for log rotation + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + * @run main/othervm/timeout=600 TestLogRotation + * + */ +import jdk.test.lib.*; +import java.io.File; +import java.io.FilenameFilter; +import java.util.ArrayList; +import java.util.Arrays; + +class GCLoggingGenerator { + + public static void main(String[] args) throws Exception { + + long sizeOfLog = Long.parseLong(args[0]); + long lines = sizeOfLog / 80; + // full.GC generates ad least 1-line which is not shorter then 80 chars + // for some GC 2 shorter lines are generated + for (long i = 0; i < lines; i++) { + System.gc(); + } + } +} + +public class TestLogRotation { + + static final File currentDirectory = new File("."); + static final String logFileName = "test.log"; + static final int logFileSizeK = 16; + static FilenameFilter logFilter = new FilenameFilter() { + @Override + public boolean accept(File dir, String name) { + return name.startsWith(logFileName); + } + }; + + public static void cleanLogs() { + for (File log : currentDirectory.listFiles(logFilter)) { + if (!log.delete()) { + throw new Error("Unable to delete " + log.getAbsolutePath()); + } + } + } + + public static void runTest(int numberOfFiles) throws Exception { + + ArrayList args = new ArrayList(); + String[] logOpts = new String[]{ + "-cp", System.getProperty("java.class.path"), + "-Xlog:gc=debug:" + logFileName + "::filesize=" + logFileSizeK + ",filecount=" + numberOfFiles, + "-XX:-DisableExplicitGC", // to ensure that System.gc() works + "-Xmx128M"}; + // System.getProperty("test.java.opts") is '' if no options is set + // need to skip such empty + String[] externalVMopts = System.getProperty("test.java.opts").length() == 0 + ? new String[0] + : System.getProperty("test.java.opts").split(" "); + args.addAll(Arrays.asList(externalVMopts)); + args.addAll(Arrays.asList(logOpts)); + args.add(GCLoggingGenerator.class.getName()); + args.add(String.valueOf(numberOfFiles * logFileSizeK * 1024)); + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(args.toArray(new String[0])); + pb.redirectErrorStream(true); + pb.redirectOutput(new File(GCLoggingGenerator.class.getName() + ".log")); + Process process = pb.start(); + int result = process.waitFor(); + if (result != 0) { + throw new Error("Unexpected exit code = " + result); + } + File[] logs = currentDirectory.listFiles(logFilter); + int smallFilesNumber = 0; + for (File log : logs) { + if (log.length() < logFileSizeK * 1024) { + smallFilesNumber++; + } + } + if (logs.length != numberOfFiles) { + throw new Error("There are only " + logs.length + " logs instead " + numberOfFiles); + } + if (smallFilesNumber > 1) { + throw new Error("There should maximum one log with size < " + logFileSizeK + "K"); + } + } + + public static void main(String[] args) throws Exception { + cleanLogs(); + runTest(1); + cleanLogs(); + runTest(3); + cleanLogs(); + } +} --- old/src/share/vm/gc/g1/g1ErgoVerbose.cpp 2015-12-01 12:06:41.358929666 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,66 +0,0 @@ -/* - * Copyright (c) 2011, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "gc/g1/g1ErgoVerbose.hpp" -#include "utilities/ostream.hpp" - -ErgoLevel G1ErgoVerbose::_level; -bool G1ErgoVerbose::_enabled[ErgoHeuristicNum]; - -void G1ErgoVerbose::initialize() { - set_level(ErgoLow); - set_enabled(false); -} - -void G1ErgoVerbose::set_level(ErgoLevel level) { - _level = level; -} - -void G1ErgoVerbose::set_enabled(ErgoHeuristic n, bool enabled) { - assert(0 <= n && n < ErgoHeuristicNum, "pre-condition"); - _enabled[n] = enabled; -} - -void G1ErgoVerbose::set_enabled(bool enabled) { - for (int n = 0; n < ErgoHeuristicNum; n += 1) { - set_enabled((ErgoHeuristic) n, enabled); - } -} - -const char* G1ErgoVerbose::to_string(int tag) { - ErgoHeuristic n = extract_heuristic(tag); - switch (n) { - case ErgoHeapSizing: return "Heap Sizing"; - case ErgoCSetConstruction: return "CSet Construction"; - case ErgoConcCycles: return "Concurrent Cycles"; - case ErgoMixedGCs: return "Mixed GCs"; - case ErgoTiming: return "Timing"; - case ErgoIHOP: return "IHOP"; - default: - ShouldNotReachHere(); - // Keep the Windows compiler happy - return NULL; - } -} --- old/src/share/vm/gc/g1/g1ErgoVerbose.hpp 2015-12-01 12:06:41.510929661 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,204 +0,0 @@ -/* - * Copyright (c) 2011, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_GC_G1_G1ERGOVERBOSE_HPP -#define SHARE_VM_GC_G1_G1ERGOVERBOSE_HPP - -#include "memory/allocation.hpp" -#include "utilities/debug.hpp" - -// The log of G1's heuristic decisions comprises of a series of -// records which have a similar format in order to maintain -// consistency across records and ultimately easier parsing of the -// output, if we ever choose to do that. Each record consists of: -// * A time stamp to be able to easily correlate each record with -// other events. -// * A unique string to allow us to easily identify such records. -// * The name of the heuristic the record corresponds to. -// * An action string which describes the action that G1 did or is -// about to do. -// * An optional reason string which describes the reason for the -// action. -// * An optional number of name/value pairs which contributed to the -// decision to take the action described in the record. -// -// Each record is associated with a "tag" which is the combination of -// the heuristic the record corresponds to, as well as the min level -// of verboseness at which the record should be printed. The tag is -// checked against the current settings to determine whether the record -// should be printed or not. - -// The available verboseness levels. -typedef enum { - // Determine which part of the tag is occupied by the level. - ErgoLevelShift = 8, - ErgoLevelMask = ~((1 << ErgoLevelShift) - 1), - - // ErgoLow is 0 so that we don't have to explicitly or a heuristic - // id with ErgoLow to keep its use simpler. - ErgoLow = 0, - ErgoHigh = 1 << ErgoLevelShift -} ErgoLevel; - -// The available heuristics. -typedef enum { - // Determines which part of the tag is occupied by the heuristic id. - ErgoHeuristicMask = ~ErgoLevelMask, - - ErgoHeapSizing = 0, - ErgoCSetConstruction, - ErgoConcCycles, - ErgoMixedGCs, - ErgoTiming, - ErgoIHOP, - - ErgoHeuristicNum -} ErgoHeuristic; - -class G1ErgoVerbose : AllStatic { -private: - // Determines the minimum verboseness level at which records will be - // printed. - static ErgoLevel _level; - // Determines which heuristics are currently enabled. - static bool _enabled[ErgoHeuristicNum]; - - static ErgoLevel extract_level(int tag) { - return (ErgoLevel) (tag & ErgoLevelMask); - } - - static ErgoHeuristic extract_heuristic(int tag) { - return (ErgoHeuristic) (tag & ErgoHeuristicMask); - } - -public: - // Needs to be explicitly called at GC initialization. - static void initialize(); - - static void set_level(ErgoLevel level); - static void set_enabled(ErgoHeuristic h, bool enabled); - // It is applied to all heuristics. - static void set_enabled(bool enabled); - - static bool enabled(int tag) { - ErgoLevel level = extract_level(tag); - ErgoHeuristic n = extract_heuristic(tag); - return level <= _level && _enabled[n]; - } - - // Extract the heuristic id from the tag and return a string with - // its name. - static const char* to_string(int tag); -}; - -// The macros below generate the format string for values of different -// types and/or metrics. - -// The reason for the action is optional and is handled specially: the -// reason string is concatenated here so it's not necessary to pass it -// as a parameter. -#define ergo_format_reason(_reason_) ", reason: " _reason_ - -// Single parameter format strings -#define ergo_format_str(_name_) ", " _name_ ": %s" -#define ergo_format_region(_name_) ", " _name_ ": %u regions" -#define ergo_format_byte(_name_) ", " _name_ ": " SIZE_FORMAT " bytes" -#define ergo_format_double(_name_) ", " _name_ ": %1.2f" -#define ergo_format_perc(_name_) ", " _name_ ": %1.2f %%" -#define ergo_format_ms(_name_) ", " _name_ ": %1.2f ms" -#define ergo_format_size(_name_) ", " _name_ ": " SIZE_FORMAT - -// Double parameter format strings -#define ergo_format_byte_perc(_name_) \ - ", " _name_ ": " SIZE_FORMAT " bytes (%1.2f %%)" - -// Generates the format string -#define ergo_format(_extra_format_) \ - " %1.3f: [G1Ergonomics (%s) %s" _extra_format_ "]" - -// Conditionally, prints an ergonomic decision record. _extra_format_ -// is the format string for the optional items we'd like to print -// (i.e., the decision's reason and any associated values). This -// string should be built up using the ergo_*_format macros (see -// above) to ensure consistency. -// -// Since we cannot rely on the compiler supporting variable argument -// macros, this macro accepts a fixed number of arguments and passes -// them to the print method. For convenience, we have wrapper macros -// below which take a specific number of arguments and set the rest to -// a default value. -#define ergo_verbose_common(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_, _arg3_, _arg4_, _arg5_) \ - do { \ - if (G1ErgoVerbose::enabled((_tag_))) { \ - gclog_or_tty->print_cr(ergo_format(_extra_format_), \ - os::elapsedTime(), \ - G1ErgoVerbose::to_string((_tag_)), \ - (_action_), \ - (_arg0_), (_arg1_), (_arg2_), \ - (_arg3_), (_arg4_), (_arg5_)); \ - } \ - } while (0) - - -#define ergo_verbose6(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_, _arg3_, _arg4_, _arg5_) \ - ergo_verbose_common(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_, _arg3_, _arg4_, _arg5_) - -#define ergo_verbose5(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_, _arg3_, _arg4_) \ - ergo_verbose6(_tag_, _action_, _extra_format_ "%s", \ - _arg0_, _arg1_, _arg2_, _arg3_, _arg4_, "") - -#define ergo_verbose4(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_, _arg3_) \ - ergo_verbose5(_tag_, _action_, _extra_format_ "%s", \ - _arg0_, _arg1_, _arg2_, _arg3_, "") - -#define ergo_verbose3(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_, _arg2_) \ - ergo_verbose4(_tag_, _action_, _extra_format_ "%s", \ - _arg0_, _arg1_, _arg2_, "") - -#define ergo_verbose2(_tag_, _action_, _extra_format_, \ - _arg0_, _arg1_) \ - ergo_verbose3(_tag_, _action_, _extra_format_ "%s", \ - _arg0_, _arg1_, "") - -#define ergo_verbose1(_tag_, _action_, _extra_format_, \ - _arg0_) \ - ergo_verbose2(_tag_, _action_, _extra_format_ "%s", \ - _arg0_, "") - - -#define ergo_verbose0(_tag_, _action_, _extra_format_) \ - ergo_verbose1(_tag_, _action_, _extra_format_ "%s", \ - "") - -#define ergo_verbose(_tag_, _action_) \ - ergo_verbose0(_tag_, _action_, "") - - -#endif // SHARE_VM_GC_G1_G1ERGOVERBOSE_HPP --- old/src/share/vm/gc/g1/g1Log.cpp 2015-12-01 12:06:41.654929656 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2012, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "gc/g1/g1Log.hpp" -#include "gc/g1/g1_globals.hpp" -#include "runtime/globals_extension.hpp" - -G1Log::LogLevel G1Log::_level = G1Log::LevelNone; - - -// Updates _level based on PrintGC and PrintGCDetails values (unless -// G1LogLevel is set explicitly) -// - PrintGC maps to "fine". -// - PrintGCDetails maps to "finer". -void G1Log::update_level() { - if (FLAG_IS_DEFAULT(G1LogLevel)) { - _level = LevelNone; - if (PrintGCDetails) { - _level = LevelFiner; - } else if (PrintGC) { - _level = LevelFine; - } - } -} - - -// If G1LogLevel has not been set up we will use the values of PrintGC -// and PrintGCDetails for the logging level. -void G1Log::init() { - if (!FLAG_IS_DEFAULT(G1LogLevel)) { - // PrintGC flags change won't have any affect, because G1LogLevel - // is set explicitly - if (G1LogLevel[0] == '\0' || strncmp("none", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') { - _level = LevelNone; - } else if (strncmp("fine", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') { - _level = LevelFine; - } else if (strncmp("finer", G1LogLevel, 5) == 0 && G1LogLevel[5] == '\0') { - _level = LevelFiner; - } else if (strncmp("finest", G1LogLevel, 6) == 0 && G1LogLevel[6] == '\0') { - _level = LevelFinest; - } else { - warning("Unknown logging level '%s', should be one of 'fine', 'finer' or 'finest'.", G1LogLevel); - } - } else { - update_level(); - } -} - --- old/src/share/vm/gc/g1/g1Log.hpp 2015-12-01 12:06:41.798929651 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2012, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_GC_G1_G1LOG_HPP -#define SHARE_VM_GC_G1_G1LOG_HPP - -#include "memory/allocation.hpp" - -class G1Log : public AllStatic { - public: - typedef enum { - LevelNone, - LevelFine, - LevelFiner, - LevelFinest - } LogLevel; - - private: - static LogLevel _level; - - public: - inline static bool fine() { - return _level >= LevelFine; - } - - inline static bool finer() { - return _level >= LevelFiner; - } - - inline static bool finest() { - return _level == LevelFinest; - } - - static LogLevel level() { - return _level; - } - - static void init(); - - // Update to log level to reflect runtime changes to manageable flags - static void update_level(); -}; - -#endif // SHARE_VM_GC_G1_G1LOG_HPP --- old/test/gc/6941923/Test6941923.java 2015-12-01 12:06:41.942929646 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,123 +0,0 @@ -/* - * Copyright (c) 2012, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test Test6941923.java - * @bug 6941923 - * @summary test flags for gc log rotation - * @library /testlibrary - * @modules java.base/sun.misc - * java.management - * @run main/othervm/timeout=600 Test6941923 - * - */ -import jdk.test.lib.*; -import java.io.File; -import java.io.FilenameFilter; -import java.util.ArrayList; -import java.util.Arrays; - -class GCLoggingGenerator { - - public static void main(String[] args) throws Exception { - - long sizeOfLog = Long.parseLong(args[0]); - long lines = sizeOfLog / 80; - // full.GC generates ad least 1-line which is not shorter then 80 chars - // for some GC 2 shorter lines are generated - for (long i = 0; i < lines; i++) { - System.gc(); - } - } -} - -public class Test6941923 { - - static final File currentDirectory = new File("."); - static final String logFileName = "test.log"; - static final int logFileSizeK = 16; - static FilenameFilter logFilter = new FilenameFilter() { - @Override - public boolean accept(File dir, String name) { - return name.startsWith(logFileName); - } - }; - - public static void cleanLogs() { - for (File log : currentDirectory.listFiles(logFilter)) { - if (!log.delete()) { - throw new Error("Unable to delete " + log.getAbsolutePath()); - } - } - } - - public static void runTest(int numberOfFiles) throws Exception { - - ArrayList args = new ArrayList(); - String[] logOpts = new String[]{ - "-cp", System.getProperty("java.class.path"), - "-Xloggc:" + logFileName, - "-XX:-DisableExplicitGC", // to sure that System.gc() works - "-XX:+PrintGC", "-XX:+PrintGCDetails", "-XX:+UseGCLogFileRotation", - "-XX:NumberOfGCLogFiles=" + numberOfFiles, - "-XX:GCLogFileSize=" + logFileSizeK + "K", "-Xmx128M"}; - // System.getProperty("test.java.opts") is '' if no options is set - // need to skip such empty - String[] externalVMopts = System.getProperty("test.java.opts").length() == 0 - ? new String[0] - : System.getProperty("test.java.opts").split(" "); - args.addAll(Arrays.asList(externalVMopts)); - args.addAll(Arrays.asList(logOpts)); - args.add(GCLoggingGenerator.class.getName()); - args.add(String.valueOf(numberOfFiles * logFileSizeK * 1024)); - ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(args.toArray(new String[0])); - pb.redirectErrorStream(true); - pb.redirectOutput(new File(GCLoggingGenerator.class.getName() + ".log")); - Process process = pb.start(); - int result = process.waitFor(); - if (result != 0) { - throw new Error("Unexpected exit code = " + result); - } - File[] logs = currentDirectory.listFiles(logFilter); - int smallFilesNumber = 0; - for (File log : logs) { - if (log.length() < logFileSizeK * 1024) { - smallFilesNumber++; - } - } - if (logs.length != numberOfFiles) { - throw new Error("There are only " + logs.length + " logs instead " + numberOfFiles); - } - if (smallFilesNumber > 1) { - throw new Error("There should maximum one log with size < " + logFileSizeK + "K"); - } - } - - public static void main(String[] args) throws Exception { - cleanLogs(); - runTest(1); - cleanLogs(); - runTest(3); - cleanLogs(); - } -} --- old/test/gc/TestGCLogRotationViaJcmd.java 2015-12-01 12:06:42.098929641 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,79 +0,0 @@ -/* - * Copyright (c) 2014, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test TestGCLogRotationViaJcmd.java - * @bug 7090324 - * @summary test for gc log rotation via jcmd - * @library /testlibrary - * @modules java.base/sun.misc - * java.management - * @run main/othervm -Xloggc:test.log -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=3 TestGCLogRotationViaJcmd - * - */ -import jdk.test.lib.*; -import java.io.File; -import java.io.FilenameFilter; - -public class TestGCLogRotationViaJcmd { - - static final File currentDirectory = new File("."); - static final String LOG_FILE_NAME = "test.log"; - static final int NUM_LOGS = 3; - - static FilenameFilter logFilter = new FilenameFilter() { - @Override - public boolean accept(File dir, String name) { - return name.startsWith(LOG_FILE_NAME); - } - }; - - public static void main(String[] args) throws Exception { - // Grab the pid from the current java process - String pid = Integer.toString(ProcessTools.getProcessId()); - - // Create a JDKToolLauncher - JDKToolLauncher jcmd = JDKToolLauncher.create("jcmd") - .addToolArg(pid) - .addToolArg("GC.rotate_log"); - - for (int times = 1; times < NUM_LOGS; times++) { - // Run jcmd GC.rotate_log - ProcessBuilder pb = new ProcessBuilder(jcmd.getCommand()); - - // Make sure we didn't crash - OutputAnalyzer output = new OutputAnalyzer(pb.start()); - output.shouldHaveExitValue(0); - } - - // GC log check - File[] logs = currentDirectory.listFiles(logFilter); - if (logs.length != NUM_LOGS) { - throw new Error("There are only " + logs.length - + " logs instead " + NUM_LOGS); - } - - } - -} - --- old/test/gc/g1/TestPrintGCDetails.java 2015-12-01 12:06:42.242929636 +0100 +++ /dev/null 2015-08-17 09:33:10.330134408 +0200 @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2013, 2015, 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * @test TestPrintGCDetails - * @bug 8010738 - * @summary Ensure that the PrintGCDetails for a full GC with G1 includes Metaspace. - * @key gc - * @key regression - * @library /testlibrary - * @modules java.base/sun.misc - * java.management - */ - -import jdk.test.lib.ProcessTools; -import jdk.test.lib.OutputAnalyzer; - -public class TestPrintGCDetails { - public static void main(String[] args) throws Exception { - - ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UseG1GC", - "-XX:+PrintGCDetails", - SystemGCTest.class.getName()); - - OutputAnalyzer output = new OutputAnalyzer(pb.start()); - - System.out.println("Output:\n" + output.getOutput()); - - output.shouldContain("Metaspace"); - output.shouldHaveExitValue(0); - } - - static class SystemGCTest { - public static void main(String [] args) { - System.out.println("Calling System.gc()"); - System.gc(); - } - } -}