jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

-:efdbe9b904ad
+:f96fcd9e1e1b
 void ConcurrentMarkSweepGeneration::printOccupancy(const char *s) {
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 if (PrintGCDetails) {
 if (Verbose) {
-gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"("SIZE_FORMAT")]",
+gclog_or_tty->print("[%d %s-%s: " SIZE_FORMAT "(" SIZE_FORMAT ")]",
 level(), short_name(), s, used(), capacity());
 } else {
-gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"K("SIZE_FORMAT"K)]",
+gclog_or_tty->print("[%d %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")",
+gclog_or_tty->print(" " SIZE_FORMAT "(" SIZE_FORMAT ")",
 gch->used(), gch->capacity());
 } else {
-gclog_or_tty->print(" "SIZE_FORMAT"K("SIZE_FORMAT"K)",
+gclog_or_tty->print(" " SIZE_FORMAT "K(" SIZE_FORMAT "K)",
 gch->used() / K, gch->capacity() / K);
 }
 }
 size_t
 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"),"
+"CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "),"
-"max_promo("SIZE_FORMAT")",
+"max_promo(" SIZE_FORMAT ")",
 res? "":" not", available, res? ">=":"<",
 av_promo, max_promotion_in_bytes);
 }
 return res;
 }
 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("  Capactiy "SIZE_FORMAT, capacity()/1000);
+gclog_or_tty->print_cr("  Capactiy " SIZE_FORMAT, capacity()/1000);
-gclog_or_tty->print_cr("  Desired capacity "SIZE_FORMAT,
+gclog_or_tty->print_cr("  Desired capacity " SIZE_FORMAT,
 desired_capacity/1000);
 int prev_level = level() - 1;
 if (prev_level >= 0) {
 size_t prev_size = 0;
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 Generation* prev_gen = gch->_gens[prev_level];
 prev_size = prev_gen->capacity();
-gclog_or_tty->print_cr("  Younger gen size "SIZE_FORMAT,
+gclog_or_tty->print_cr("  Younger gen size " SIZE_FORMAT,
 prev_size/1000);
 }
-gclog_or_tty->print_cr("  unsafe_max_alloc_nogc "SIZE_FORMAT,
+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,
+gclog_or_tty->print_cr("  contiguous available " SIZE_FORMAT,
 contiguous_available()/1000);
-gclog_or_tty->print_cr("  Expand by "SIZE_FORMAT" (bytes)",
+gclog_or_tty->print_cr("  Expand by " SIZE_FORMAT " (bytes)",
 expand_bytes);
 }
 // safe if expansion fails
 expand(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio);
 if (PrintGCDetails && Verbose) {
 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("free=" SIZE_FORMAT, _cmsGen->free());
-gclog_or_tty->print_cr("contiguous_available="SIZE_FORMAT,
+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());
 // Clear stat counters
 NOT_PRODUCT(
 assert(_numObjectsPromoted == 0, "check");
 assert(_numWordsPromoted   == 0, "check");
 if (Verbose && PrintGC) {
-gclog_or_tty->print("Allocated "SIZE_FORMAT" objects, "
+gclog_or_tty->print("Allocated " SIZE_FORMAT " objects, "
-SIZE_FORMAT" bytes concurrently",
+SIZE_FORMAT " bytes concurrently",
 _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord));
 }
 _numObjectsAllocated = 0;
 _numWordsAllocated   = 0;
 )
 // Print stat counters
 NOT_PRODUCT(
 assert(_numObjectsAllocated == 0, "check");
 assert(_numWordsAllocated == 0, "check");
 if (Verbose && PrintGC) {
-gclog_or_tty->print("Promoted "SIZE_FORMAT" objects, "
+gclog_or_tty->print("Promoted " SIZE_FORMAT " objects, "
-SIZE_FORMAT" bytes",
+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 ",
+gclog_or_tty->print(" Contiguous available " SIZE_FORMAT " bytes ",
 contiguous_available());
 }
 }
 #ifndef PRODUCT
 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)", addr);
+gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr);
 _failed = true;
 }
 return true;
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 SpecializationStats::clear();
 if (PrintGCDetails) {
-gclog_or_tty->print("[YG occupancy: "SIZE_FORMAT" K ("SIZE_FORMAT" K)]",
+gclog_or_tty->print("[YG occupancy: " SIZE_FORMAT " K (" SIZE_FORMAT " K)]",
 _young_gen->used() / K,
 _young_gen->capacity() / K);
 }
 if (asynch) {
 if (CMSScavengeBeforeRemark) {
 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
+"(pmc_pc=" SIZE_FORMAT ", pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT
-", kac_preclean="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_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")",
+"(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")",
+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"),"
+gclog_or_tty->print_cr(" (benign) Failed stack doubling (" SIZE_FORMAT "),"
-" current capacity "SIZE_FORMAT,
+" current capacity " SIZE_FORMAT,
 _markStack._failed_double,
 _markStack.capacity());
 }
 }
 _markStack._hit_limit = 0;
 MemRegion cms_span(lb, ub);
 _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) ",
+gclog_or_tty->print(" (re-scanned " SIZE_FORMAT " dirty cards in cms gen) ",
 markFromDirtyCardsClosure.num_dirty_cards());
 }
 }
 }
 if (VerifyDuringGC &&
 _index = 0;
 _capacity = new_capacity;
 } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) {
 // 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 "
+gclog_or_tty->print(" (benign) Failed to expand marking stack from " SIZE_FORMAT "K to "
-SIZE_FORMAT"K",
+SIZE_FORMAT "K",
 _capacity / K, new_capacity / K);
 }
 }
 warning("inFreeRange() should have been reset; dumping state of SweepClosure");
 print();
 ShouldNotReachHere();
 }
 if (Verbose && PrintGC) {
-gclog_or_tty->print("Collected "SIZE_FORMAT" objects, " SIZE_FORMAT " bytes",
+gclog_or_tty->print("Collected " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes",
 _numObjectsFreed, _numWordsFreed*sizeof(HeapWord));
-gclog_or_tty->print_cr("\nLive "SIZE_FORMAT" objects,  "
+gclog_or_tty->print_cr("\nLive " SIZE_FORMAT " objects,  "
-SIZE_FORMAT" bytes  "
+SIZE_FORMAT " bytes  "
-"Already free "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);
+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("Returned " SIZE_FORMAT " bytes", returned_bytes);
-gclog_or_tty->print("   Indexed List Returned "SIZE_FORMAT" bytes",
+gclog_or_tty->print("   Indexed List Returned " SIZE_FORMAT " bytes",
 indexListReturnedBytes);
-gclog_or_tty->print_cr("        Dictionary Returned "SIZE_FORMAT" bytes",
+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================",
 assert(addr < _sp->end(), "addr out of bounds");
 // Flush any free range we might be holding as a single
 // coalesced chunk to the appropriate free list.
 if (inFreeRange()) {
 assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit,
-err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", freeFinger()));
+err_msg("freeFinger() " PTR_FORMAT " is out-of-bounds", 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 0x%x ("SIZE_FORMAT") "
+gclog_or_tty->print("put_free_blk 0x%x (" SIZE_FORMAT ") "
-"[coalesced:"SIZE_FORMAT"]\n",
+"[coalesced:" SIZE_FORMAT "]\n",
 freeFinger(), pointer_delta(addr, freeFinger()),
 lastFreeRangeCoalesced());
 }
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp