jdk-sandbox: comparison src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 size_t
 ConcurrentMarkSweepGeneration::unsafe_max_alloc_nogc() const {
 return _cmsSpace->max_alloc_in_words() * HeapWordSize;
 }
+size_t ConcurrentMarkSweepGeneration::used_stable() const {
+return cmsSpace()->used_stable();
+}
 size_t ConcurrentMarkSweepGeneration::max_available() const {
 return free() + _virtual_space.uncommitted_size();
 }
 bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
 // size of an object that may not yet have been initialized.
 // Things to support parallel young-gen collection.
 oop
 ConcurrentMarkSweepGeneration::par_promote(int thread_num,
-oop old, markOop m,
+oop old, markWord m,
 size_t word_sz) {
 #ifndef PRODUCT
 if (CMSHeap::heap()->promotion_should_fail()) {
 return NULL;
 }
 void CMSCollector::compute_new_size() {
 assert_locked_or_safepoint(Heap_lock);
 FreelistLocker z(this);
 MetaspaceGC::compute_new_size();
 _cmsGen->compute_new_size_free_list();
+// recalculate CMS used space after CMS collection
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 // A work method used by the foreground collector to do
 // a mark-sweep-compact.
 void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
 void ConcurrentMarkSweepGeneration::gc_prologue(bool full) {
 _capacity_at_prologue = capacity();
 _used_at_prologue = used();
+_cmsSpace->recalculate_used_stable();
 // We enable promotion tracking so that card-scanning can recognize
 // which objects have been promoted during this GC and skip them.
 for (uint i = 0; i < ParallelGCThreads; i++) {
 _par_gc_thread_states[i]->promo.startTrackingPromotions();
 }
 // reset _eden_chunk_array so sampling starts afresh
 _eden_chunk_index = 0;
 size_t cms_used   = _cmsGen->cmsSpace()->used();
+_cmsGen->cmsSpace()->recalculate_used_stable();
 // update performance counters - this uses a special version of
 // update_counters() that allows the utilization to be passed as a
 // parameter, avoiding multiple calls to used().
 //
 CMSSynchronousYieldRequest yr;
 assert(!tlab, "Can't deal with TLAB allocation");
 MutexLocker x(freelistLock(), Mutex::_no_safepoint_check_flag);
 expand_for_gc_cause(word_size*HeapWordSize, MinHeapDeltaBytes, CMSExpansionCause::_satisfy_allocation);
 if (GCExpandToAllocateDelayMillis > 0) {
-os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
+os::naked_sleep(GCExpandToAllocateDelayMillis);
 }
 return have_lock_and_allocate(word_size, tlab);
 }
 void ConcurrentMarkSweepGeneration::expand_for_gc_cause(
 expand_for_gc_cause(word_sz*HeapWordSize, MinHeapDeltaBytes, CMSExpansionCause::_allocate_par_lab);
 // Now go around the loop and try alloc again;
 // A competing par_promote might beat us to the expansion space,
 // so we may go around the loop again if promotion fails again.
 if (GCExpandToAllocateDelayMillis > 0) {
-os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
+os::naked_sleep(GCExpandToAllocateDelayMillis);
 }
 }
 }
 expand_for_gc_cause(refill_size_bytes, MinHeapDeltaBytes, CMSExpansionCause::_allocate_par_spooling_space);
 // Now go around the loop and try alloc again;
 // A competing allocation might beat us to the expansion space,
 // so we may go around the loop again if allocation fails again.
 if (GCExpandToAllocateDelayMillis > 0) {
-os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
+os::naked_sleep(GCExpandToAllocateDelayMillis);
 }
 }
 }
 void ConcurrentMarkSweepGeneration::shrink(size_t bytes) {
 checkpointRootsInitialWork();
 // enable ("weak") refs discovery
 rp->enable_discovery();
 _collectorState = Marking;
 }
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 void CMSCollector::checkpointRootsInitialWork() {
 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped");
 assert(_collectorState == InitialMarking, "just checking");
 //
 // Tony 2006.06.29
 for (unsigned i = 0; i < CMSCoordinatorYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _bit_map_lock->lock_without_safepoint_check();
 _collector->startTimer();
 }
 FreelistLocker x(this);
 MutexLocker y(bitMapLock(),
 Mutex::_no_safepoint_check_flag);
 checkpointRootsFinalWork();
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 }
 verify_overflow_empty();
 if (should_unload_classes()) {
 heap->prune_scavengable_nmethods();
 }
-JvmtiExport::gc_epilogue();
 // If we encountered any (marking stack / work queue) overflow
 // events during the current CMS cycle, take appropriate
 // remedial measures, where possible, so as to try and avoid
 // recurrence of that condition.
 // We need all the free list locks to make the abstract state
 // transition from Sweeping to Resetting. See detailed note
 // further below.
 {
 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock());
 // Update heap occupancy information which is used as
 // input to soft ref clearing policy at the next gc.
 Universe::update_heap_info_at_gc();
+// recalculate CMS used space after CMS collection
+_cmsGen->cmsSpace()->recalculate_used_stable();
 _collectorState = Resizing;
 }
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 bool current_is_young = CMSHeap::heap()->is_young_gen(current_generation);
 if (!full && current_is_young) {
 // Gather statistics on the young generation collection.
 collector()->stats().record_gc0_end(used());
 }
+_cmsSpace->recalculate_used_stable();
 }
 void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* old_gen) {
 // We iterate over the space(s) underlying this generation,
 // checking the mark bit map to see if the bits corresponding
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 bitMapLock()->lock_without_safepoint_check();
 startTimer();
 for (unsigned i = 0;
 i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive();
 ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _freelistLock->lock_without_safepoint_check();
 _bit_map->lock()->lock_without_safepoint_check();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _freelistLock->lock_without_safepoint_check();
 _bitMap->lock()->lock_without_safepoint_check();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _bit_map->lock()->lock_without_safepoint_check();
 _collector->startTimer();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _bitMap->lock()->lock_without_safepoint_check();
 _collector->startTimer();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
-bml->lock();
+bml->lock_without_safepoint_check();
 _collector->startTimer();
 }
 bool CMSPrecleanRefsYieldClosure::should_return() {
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
-os::sleep(Thread::current(), 1, false);
+os::naked_short_sleep(1);
 }
 ConcurrentMarkSweepThread::synchronize(true);
 _freelistLock->lock_without_safepoint_check();
 _bitMap->lock()->lock_without_safepoint_check();
 bool CMSCollector::take_from_overflow_list(size_t num, CMSMarkStack* stack) {
 assert(stack->isEmpty(), "Expected precondition");
 assert(stack->capacity() > num, "Shouldn't bite more than can chew");
 size_t i = num;
 oop  cur = _overflow_list;
-const markOop proto = markOopDesc::prototype();
+const markWord proto = markWord::prototype();
 NOT_PRODUCT(ssize_t n = 0;)
 for (oop next; i > 0 && cur != NULL; cur = next, i--) {
-next = oop(cur->mark_raw());
+next = oop(cur->mark_raw().to_pointer());
 cur->set_mark_raw(proto);   // until proven otherwise
 assert(oopDesc::is_oop(cur), "Should be an oop");
 bool res = stack->push(cur);
 assert(res, "Bit off more than can chew?");
 NOT_PRODUCT(n++;)
 if (_overflow_list == NULL) {
 return false;
 }
 // Grab the entire list; we'll put back a suffix
 oop prefix = cast_to_oop(Atomic::xchg((oopDesc*)BUSY, &_overflow_list));
-Thread* tid = Thread::current();
 // Before "no_of_gc_threads" was introduced CMSOverflowSpinCount was
 // set to ParallelGCThreads.
 size_t CMSOverflowSpinCount = (size_t) no_of_gc_threads; // was ParallelGCThreads;
 size_t sleep_time_millis = MAX2((size_t)1, num/100);
 // If the list is busy, we spin for a short while,
 // sleeping between attempts to get the list.
 for (size_t spin = 0; prefix == BUSY && spin < CMSOverflowSpinCount; spin++) {
-os::sleep(tid, sleep_time_millis, false);
+os::naked_sleep(sleep_time_millis);
 if (_overflow_list == NULL) {
 // Nothing left to take
 return false;
 } else if (_overflow_list != BUSY) {
 // Try and grab the prefix
 }
 assert(prefix != NULL && prefix != BUSY, "Error");
 size_t i = num;
 oop cur = prefix;
 // Walk down the first "num" objects, unless we reach the end.
-for (; i > 1 && cur->mark_raw() != NULL; cur = oop(cur->mark_raw()), i--);
+for (; i > 1 && cur->mark_raw().to_pointer() != NULL; cur = oop(cur->mark_raw().to_pointer()), i--);
-if (cur->mark_raw() == NULL) {
+if (cur->mark_raw().to_pointer() == NULL) {
 // We have "num" or fewer elements in the list, so there
 // is nothing to return to the global list.
 // Write back the NULL in lieu of the BUSY we wrote
 // above, if it is still the same value.
 if (_overflow_list == BUSY) {
 Atomic::cmpxchg((oopDesc*)NULL, &_overflow_list, (oopDesc*)BUSY);
 }
 } else {
 // Chop off the suffix and return it to the global list.
-assert(cur->mark_raw() != BUSY, "Error");
+assert(cur->mark_raw().to_pointer() != (void*)BUSY, "Error");
-oop suffix_head = cur->mark_raw(); // suffix will be put back on global list
+oop suffix_head = oop(cur->mark_raw().to_pointer()); // suffix will be put back on global list
-cur->set_mark_raw(NULL);           // break off suffix
+cur->set_mark_raw(markWord::from_pointer(NULL));     // break off suffix
 // It's possible that the list is still in the empty(busy) state
 // we left it in a short while ago; in that case we may be
 // able to place back the suffix without incurring the cost
 // of a walk down the list.
 oop observed_overflow_list = _overflow_list;
 }
 if (!attached) {
 // Too bad, someone else sneaked in (at least) an element; we'll need
 // to do a splice. Find tail of suffix so we can prepend suffix to global
 // list.
-for (cur = suffix_head; cur->mark_raw() != NULL; cur = (oop)(cur->mark_raw()));
+for (cur = suffix_head; cur->mark_raw().to_pointer() != NULL; cur = (oop)(cur->mark_raw().to_pointer()));
 oop suffix_tail = cur;
-assert(suffix_tail != NULL && suffix_tail->mark_raw() == NULL,
+assert(suffix_tail != NULL && suffix_tail->mark_raw().to_pointer() == NULL,
 "Tautology");
 observed_overflow_list = _overflow_list;
 do {
 cur_overflow_list = observed_overflow_list;
 if (cur_overflow_list != BUSY) {
 // Do the splice ...
-suffix_tail->set_mark_raw(markOop(cur_overflow_list));
+suffix_tail->set_mark_raw(markWord::from_pointer((void*)cur_overflow_list));
 } else { // cur_overflow_list == BUSY
-suffix_tail->set_mark_raw(NULL);
+suffix_tail->set_mark_raw(markWord::from_pointer(NULL));
 }
 // ... and try to place spliced list back on overflow_list ...
 observed_overflow_list =
 Atomic::cmpxchg((oopDesc*)suffix_head, &_overflow_list, (oopDesc*)cur_overflow_list);
 } while (cur_overflow_list != observed_overflow_list);
 }
 }
 // Push the prefix elements on work_q
 assert(prefix != NULL, "control point invariant");
-const markOop proto = markOopDesc::prototype();
+const markWord proto = markWord::prototype();
 oop next;
 NOT_PRODUCT(ssize_t n = 0;)
 for (cur = prefix; cur != NULL; cur = next) {
-next = oop(cur->mark_raw());
+next = oop(cur->mark_raw().to_pointer());
 cur->set_mark_raw(proto);   // until proven otherwise
 assert(oopDesc::is_oop(cur), "Should be an oop");
 bool res = work_q->push(cur);
 assert(res, "Bit off more than we can chew?");
 NOT_PRODUCT(n++;)
 // Single-threaded
 void CMSCollector::push_on_overflow_list(oop p) {
 NOT_PRODUCT(_num_par_pushes++;)
 assert(oopDesc::is_oop(p), "Not an oop");
 preserve_mark_if_necessary(p);
-p->set_mark_raw((markOop)_overflow_list);
+p->set_mark_raw(markWord::from_pointer(_overflow_list));
 _overflow_list = p;
 }
 // Multi-threaded; use CAS to prepend to overflow list
 void CMSCollector::par_push_on_overflow_list(oop p) {
 oop observed_overflow_list = _overflow_list;
 oop cur_overflow_list;
 do {
 cur_overflow_list = observed_overflow_list;
 if (cur_overflow_list != BUSY) {
-p->set_mark_raw(markOop(cur_overflow_list));
+p->set_mark_raw(markWord::from_pointer((void*)cur_overflow_list));
 } else {
-p->set_mark_raw(NULL);
+p->set_mark_raw(markWord::from_pointer(NULL));
 }
 observed_overflow_list =
 Atomic::cmpxchg((oopDesc*)p, &_overflow_list, (oopDesc*)cur_overflow_list);
 } while (cur_overflow_list != observed_overflow_list);
 }
 // an indication of success or failure with the assumption that
 // the caller may be able to recover from a failure; code in
 // the VM can then be changed, incrementally, to deal with such
 // failures where possible, thus, incrementally hardening the VM
 // in such low resource situations.
-void CMSCollector::preserve_mark_work(oop p, markOop m) {
+void CMSCollector::preserve_mark_work(oop p, markWord m) {
 _preserved_oop_stack.push(p);
 _preserved_mark_stack.push(m);
 assert(m == p->mark_raw(), "Mark word changed");
 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
 "bijection");
 }
 // Single threaded
 void CMSCollector::preserve_mark_if_necessary(oop p) {
-markOop m = p->mark_raw();
+markWord m = p->mark_raw();
-if (m->must_be_preserved(p)) {
+if (p->mark_must_be_preserved(m)) {
 preserve_mark_work(p, m);
 }
 }
 void CMSCollector::par_preserve_mark_if_necessary(oop p) {
-markOop m = p->mark_raw();
+markWord m = p->mark_raw();
-if (m->must_be_preserved(p)) {
+if (p->mark_must_be_preserved(m)) {
 MutexLocker x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
 // Even though we read the mark word without holding
 // the lock, we are assured that it will not change
 // because we "own" this oop, so no other thread can
 // be trying to push it on the overflow list; see
 while (!_preserved_oop_stack.is_empty()) {
 oop p = _preserved_oop_stack.pop();
 assert(oopDesc::is_oop(p), "Should be an oop");
 assert(_span.contains(p), "oop should be in _span");
-assert(p->mark_raw() == markOopDesc::prototype(),
+assert(p->mark_raw() == markWord::prototype(),
 "Set when taken from overflow list");
-markOop m = _preserved_mark_stack.pop();
+markWord m = _preserved_mark_stack.pop();
 p->set_mark_raw(m);
 }
 assert(_preserved_mark_stack.is_empty() && _preserved_oop_stack.is_empty(),
 "stacks were cleared above");
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54786	ebf733a324d4
child 58679	9c3209ff7550