jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp@6cd6d394f280 (annotated)

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp@6cd6d394f280 (annotated)

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp

Tue, 07 Dec 2010 21:55:53 -0800

author: ysr
date: Tue, 07 Dec 2010 21:55:53 -0800
changeset 2336: 6cd6d394f280
parent 2314: f95d63e2154a
child 4037: da91efe96a93
permissions: -rw-r--r--

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp

 /*
  * Copyright (c) 2001, 2010, 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_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_INLINE_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_INLINE_HPP
 #include "gc_implementation/concurrentMarkSweep/cmsLockVerifier.hpp"
 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
 #include "gc_implementation/shared/gcUtil.hpp"
 #include "memory/defNewGeneration.hpp"
 inline void CMSBitMap::clear_all() {
   assert_locked();
   // CMS bitmaps are usually cover large memory regions
   _bm.clear_large();
   return;
 }
 inline size_t CMSBitMap::heapWordToOffset(HeapWord* addr) const {
   return (pointer_delta(addr, _bmStartWord)) >> _shifter;
 }
 inline HeapWord* CMSBitMap::offsetToHeapWord(size_t offset) const {
   return _bmStartWord + (offset << _shifter);
 }
 inline size_t CMSBitMap::heapWordDiffToOffsetDiff(size_t diff) const {
   assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
   return diff >> _shifter;
 }
 inline void CMSBitMap::mark(HeapWord* addr) {
   assert_locked();
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   _bm.set_bit(heapWordToOffset(addr));
 }
 inline bool CMSBitMap::par_mark(HeapWord* addr) {
   assert_locked();
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   return _bm.par_at_put(heapWordToOffset(addr), true);
 }
 inline void CMSBitMap::par_clear(HeapWord* addr) {
   assert_locked();
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   _bm.par_at_put(heapWordToOffset(addr), false);
 }
 inline void CMSBitMap::mark_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size is usually just 1 bit.
   _bm.set_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                 BitMap::small_range);
 }
 inline void CMSBitMap::clear_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size is usually just 1 bit.
   _bm.clear_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                   BitMap::small_range);
 }
 inline void CMSBitMap::par_mark_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size is usually just 1 bit.
   _bm.par_set_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                     BitMap::small_range);
 }
 inline void CMSBitMap::par_clear_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size is usually just 1 bit.
   _bm.par_clear_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                       BitMap::small_range);
 }
 inline void CMSBitMap::mark_large_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size must be greater than 32 bytes.
   _bm.set_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                 BitMap::large_range);
 }
 inline void CMSBitMap::clear_large_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size must be greater than 32 bytes.
   _bm.clear_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                   BitMap::large_range);
 }
 inline void CMSBitMap::par_mark_large_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size must be greater than 32 bytes.
   _bm.par_set_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                     BitMap::large_range);
 }
 inline void CMSBitMap::par_clear_large_range(MemRegion mr) {
   NOT_PRODUCT(region_invariant(mr));
   // Range size must be greater than 32 bytes.
   _bm.par_clear_range(heapWordToOffset(mr.start()), heapWordToOffset(mr.end()),
                       BitMap::large_range);
 }
 // Starting at "addr" (inclusive) return a memory region
 // corresponding to the first maximally contiguous marked ("1") region.
 inline MemRegion CMSBitMap::getAndClearMarkedRegion(HeapWord* addr) {
   return getAndClearMarkedRegion(addr, endWord());
 }
 // Starting at "start_addr" (inclusive) return a memory region
 // corresponding to the first maximal contiguous marked ("1") region
 // strictly less than end_addr.
 inline MemRegion CMSBitMap::getAndClearMarkedRegion(HeapWord* start_addr,
                                                     HeapWord* end_addr) {
   HeapWord *start, *end;
   assert_locked();
   start = getNextMarkedWordAddress  (start_addr, end_addr);
   end   = getNextUnmarkedWordAddress(start,      end_addr);
   assert(start <= end, "Consistency check");
   MemRegion mr(start, end);
   if (!mr.is_empty()) {
     clear_range(mr);
   }
   return mr;
 }
 inline bool CMSBitMap::isMarked(HeapWord* addr) const {
   assert_locked();
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   return _bm.at(heapWordToOffset(addr));
 }
 // The same as isMarked() but without a lock check.
 inline bool CMSBitMap::par_isMarked(HeapWord* addr) const {
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   return _bm.at(heapWordToOffset(addr));
 }
 inline bool CMSBitMap::isUnmarked(HeapWord* addr) const {
   assert_locked();
   assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize),
          "outside underlying space?");
   return !_bm.at(heapWordToOffset(addr));
 }
 // Return the HeapWord address corresponding to next "1" bit
 // (inclusive).
 inline HeapWord* CMSBitMap::getNextMarkedWordAddress(HeapWord* addr) const {
   return getNextMarkedWordAddress(addr, endWord());
 }
 // Return the least HeapWord address corresponding to next "1" bit
 // starting at start_addr (inclusive) but strictly less than end_addr.
 inline HeapWord* CMSBitMap::getNextMarkedWordAddress(
   HeapWord* start_addr, HeapWord* end_addr) const {
   assert_locked();
   size_t nextOffset = _bm.get_next_one_offset(
                         heapWordToOffset(start_addr),
                         heapWordToOffset(end_addr));
   HeapWord* nextAddr = offsetToHeapWord(nextOffset);
   assert(nextAddr >= start_addr &&
          nextAddr <= end_addr, "get_next_one postcondition");
   assert((nextAddr == end_addr) ||
          isMarked(nextAddr), "get_next_one postcondition");
   return nextAddr;
 }
 // Return the HeapWord address corrsponding to the next "0" bit
 // (inclusive).
 inline HeapWord* CMSBitMap::getNextUnmarkedWordAddress(HeapWord* addr) const {
   return getNextUnmarkedWordAddress(addr, endWord());
 }
 // Return the HeapWord address corrsponding to the next "0" bit
 // (inclusive).
 inline HeapWord* CMSBitMap::getNextUnmarkedWordAddress(
   HeapWord* start_addr, HeapWord* end_addr) const {
   assert_locked();
   size_t nextOffset = _bm.get_next_zero_offset(
                         heapWordToOffset(start_addr),
                         heapWordToOffset(end_addr));
   HeapWord* nextAddr = offsetToHeapWord(nextOffset);
   assert(nextAddr >= start_addr &&
          nextAddr <= end_addr, "get_next_zero postcondition");
   assert((nextAddr == end_addr) ||
           isUnmarked(nextAddr), "get_next_zero postcondition");
   return nextAddr;
 }
 inline bool CMSBitMap::isAllClear() const {
   assert_locked();
   return getNextMarkedWordAddress(startWord()) >= endWord();
 }
 inline void CMSBitMap::iterate(BitMapClosure* cl, HeapWord* left,
                             HeapWord* right) {
   assert_locked();
   left = MAX2(_bmStartWord, left);
   right = MIN2(_bmStartWord + _bmWordSize, right);
   if (right > left) {
     _bm.iterate(cl, heapWordToOffset(left), heapWordToOffset(right));
   }
 }
 inline void CMSCollector::start_icms() {
   if (CMSIncrementalMode) {
     ConcurrentMarkSweepThread::start_icms();
   }
 }
 inline void CMSCollector::stop_icms() {
   if (CMSIncrementalMode) {
     ConcurrentMarkSweepThread::stop_icms();
   }
 }
 inline void CMSCollector::disable_icms() {
   if (CMSIncrementalMode) {
     ConcurrentMarkSweepThread::disable_icms();
   }
 }
 inline void CMSCollector::enable_icms() {
   if (CMSIncrementalMode) {
     ConcurrentMarkSweepThread::enable_icms();
   }
 }
 inline void CMSCollector::icms_wait() {
   if (CMSIncrementalMode) {
     cmsThread()->icms_wait();
   }
 }
 inline void CMSCollector::save_sweep_limits() {
   _cmsGen->save_sweep_limit();
   _permGen->save_sweep_limit();
 }
 inline bool CMSCollector::is_dead_obj(oop obj) const {
   HeapWord* addr = (HeapWord*)obj;
   assert((_cmsGen->cmsSpace()->is_in_reserved(addr)
           && _cmsGen->cmsSpace()->block_is_obj(addr))
          ||
          (_permGen->cmsSpace()->is_in_reserved(addr)
           && _permGen->cmsSpace()->block_is_obj(addr)),
          "must be object");
   return  should_unload_classes() &&
           _collectorState == Sweeping &&
          !_markBitMap.isMarked(addr);
 }
 inline bool CMSCollector::should_abort_preclean() const {
   // We are in the midst of an "abortable preclean" and either
   // scavenge is done or foreground GC wants to take over collection
   return _collectorState == AbortablePreclean &&
          (_abort_preclean || _foregroundGCIsActive ||
           GenCollectedHeap::heap()->incremental_collection_will_fail(true /* consult_young */));
 }
 inline size_t CMSCollector::get_eden_used() const {
   return _young_gen->as_DefNewGeneration()->eden()->used();
 }
 inline size_t CMSCollector::get_eden_capacity() const {
   return _young_gen->as_DefNewGeneration()->eden()->capacity();
 }
 inline bool CMSStats::valid() const {
   return _valid_bits == _ALL_VALID;
 }
 inline void CMSStats::record_gc0_begin() {
   if (_gc0_begin_time.is_updated()) {
     float last_gc0_period = _gc0_begin_time.seconds();
     _gc0_period = AdaptiveWeightedAverage::exp_avg(_gc0_period,
       last_gc0_period, _gc0_alpha);
     _gc0_alpha = _saved_alpha;
     _valid_bits |= _GC0_VALID;
   }
   _cms_used_at_gc0_begin = _cms_gen->cmsSpace()->used();
   _gc0_begin_time.update();
 }
 inline void CMSStats::record_gc0_end(size_t cms_gen_bytes_used) {
   float last_gc0_duration = _gc0_begin_time.seconds();
   _gc0_duration = AdaptiveWeightedAverage::exp_avg(_gc0_duration,
     last_gc0_duration, _gc0_alpha);
   // Amount promoted.
   _cms_used_at_gc0_end = cms_gen_bytes_used;
   size_t promoted_bytes = 0;
   if (_cms_used_at_gc0_end >= _cms_used_at_gc0_begin) {
     promoted_bytes = _cms_used_at_gc0_end - _cms_used_at_gc0_begin;
   }
   // If the younger gen collections were skipped, then the
   // number of promoted bytes will be 0 and adding it to the
   // average will incorrectly lessen the average.  It is, however,
   // also possible that no promotion was needed.
   //
   // _gc0_promoted used to be calculated as
   // _gc0_promoted = AdaptiveWeightedAverage::exp_avg(_gc0_promoted,
   //  promoted_bytes, _gc0_alpha);
   _cms_gen->gc_stats()->avg_promoted()->sample(promoted_bytes);
   _gc0_promoted = (size_t) _cms_gen->gc_stats()->avg_promoted()->average();
   // Amount directly allocated.
   size_t allocated_bytes = _cms_gen->direct_allocated_words() * HeapWordSize;
   _cms_gen->reset_direct_allocated_words();
   _cms_allocated = AdaptiveWeightedAverage::exp_avg(_cms_allocated,
     allocated_bytes, _gc0_alpha);
 }
 inline void CMSStats::record_cms_begin() {
   _cms_timer.stop();
   // This is just an approximate value, but is good enough.
   _cms_used_at_cms_begin = _cms_used_at_gc0_end;
   _cms_period = AdaptiveWeightedAverage::exp_avg((float)_cms_period,
     (float) _cms_timer.seconds(), _cms_alpha);
   _cms_begin_time.update();
   _cms_timer.reset();
   _cms_timer.start();
 }
 inline void CMSStats::record_cms_end() {
   _cms_timer.stop();
   float cur_duration = _cms_timer.seconds();
   _cms_duration = AdaptiveWeightedAverage::exp_avg(_cms_duration,
     cur_duration, _cms_alpha);
   // Avoid division by 0.
   const size_t cms_used_mb = MAX2(_cms_used_at_cms_begin / M, (size_t)1);
   _cms_duration_per_mb = AdaptiveWeightedAverage::exp_avg(_cms_duration_per_mb,
                                  cur_duration / cms_used_mb,
                                  _cms_alpha);
   _cms_end_time.update();
   _cms_alpha = _saved_alpha;
   _allow_duty_cycle_reduction = true;
   _valid_bits |= _CMS_VALID;
   _cms_timer.start();
 }
 inline double CMSStats::cms_time_since_begin() const {
   return _cms_begin_time.seconds();
 }
 inline double CMSStats::cms_time_since_end() const {
   return _cms_end_time.seconds();
 }
 inline double CMSStats::promotion_rate() const {
   assert(valid(), "statistics not valid yet");
   return gc0_promoted() / gc0_period();
 }
 inline double CMSStats::cms_allocation_rate() const {
   assert(valid(), "statistics not valid yet");
   return cms_allocated() / gc0_period();
 }
 inline double CMSStats::cms_consumption_rate() const {
   assert(valid(), "statistics not valid yet");
   return (gc0_promoted() + cms_allocated()) / gc0_period();
 }
 inline unsigned int CMSStats::icms_update_duty_cycle() {
   // Update the duty cycle only if pacing is enabled and the stats are valid
   // (after at least one young gen gc and one cms cycle have completed).
   if (CMSIncrementalPacing && valid()) {
     return icms_update_duty_cycle_impl();
   }
   return _icms_duty_cycle;
 }
 inline void ConcurrentMarkSweepGeneration::save_sweep_limit() {
   cmsSpace()->save_sweep_limit();
 }
 inline size_t ConcurrentMarkSweepGeneration::capacity() const {
   return _cmsSpace->capacity();
 }
 inline size_t ConcurrentMarkSweepGeneration::used() const {
   return _cmsSpace->used();
 }
 inline size_t ConcurrentMarkSweepGeneration::free() const {
   return _cmsSpace->free();
 }
 inline MemRegion ConcurrentMarkSweepGeneration::used_region() const {
   return _cmsSpace->used_region();
 }
 inline MemRegion ConcurrentMarkSweepGeneration::used_region_at_save_marks() const {
   return _cmsSpace->used_region_at_save_marks();
 }
 inline void MarkFromRootsClosure::do_yield_check() {
   if (ConcurrentMarkSweepThread::should_yield() &&
       !_collector->foregroundGCIsActive() &&
       _yield) {
     do_yield_work();
   }
 }
 inline void Par_MarkFromRootsClosure::do_yield_check() {
   if (ConcurrentMarkSweepThread::should_yield() &&
       !_collector->foregroundGCIsActive() &&
       _yield) {
     do_yield_work();
   }
 }
 // Return value of "true" indicates that the on-going preclean
 // should be aborted.
 inline bool ScanMarkedObjectsAgainCarefullyClosure::do_yield_check() {
   if (ConcurrentMarkSweepThread::should_yield() &&
       !_collector->foregroundGCIsActive() &&
       _yield) {
     // Sample young gen size before and after yield
     _collector->sample_eden();
     do_yield_work();
     _collector->sample_eden();
     return _collector->should_abort_preclean();
   }
   return false;
 }
 inline void SurvivorSpacePrecleanClosure::do_yield_check() {
   if (ConcurrentMarkSweepThread::should_yield() &&
       !_collector->foregroundGCIsActive() &&
       _yield) {
     // Sample young gen size before and after yield
     _collector->sample_eden();
     do_yield_work();
     _collector->sample_eden();
   }
 }
 inline void SweepClosure::do_yield_check(HeapWord* addr) {
   if (ConcurrentMarkSweepThread::should_yield() &&
       !_collector->foregroundGCIsActive() &&
       _yield) {
     do_yield_work(addr);
   }
 }
 inline void MarkRefsIntoAndScanClosure::do_yield_check() {
   // The conditions are ordered for the remarking phase
   // when _yield is false.
   if (_yield &&
       !_collector->foregroundGCIsActive() &&
       ConcurrentMarkSweepThread::should_yield()) {
     do_yield_work();
   }
 }
 inline void ModUnionClosure::do_MemRegion(MemRegion mr) {
   // Align the end of mr so it's at a card boundary.
   // This is superfluous except at the end of the space;
   // we should do better than this XXX
   MemRegion mr2(mr.start(), (HeapWord*)round_to((intptr_t)mr.end(),
                  CardTableModRefBS::card_size /* bytes */));
   _t->mark_range(mr2);
 }
 inline void ModUnionClosurePar::do_MemRegion(MemRegion mr) {
   // Align the end of mr so it's at a card boundary.
   // This is superfluous except at the end of the space;
   // we should do better than this XXX
   MemRegion mr2(mr.start(), (HeapWord*)round_to((intptr_t)mr.end(),
                  CardTableModRefBS::card_size /* bytes */));
   _t->par_mark_range(mr2);
 }
 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_INLINE_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp@6cd6d394f280 (annotated)

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp