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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 113:ba764ed4b6f2

6420645: Create a vm that uses compressed oops for up to 32gb heapsizes Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold

author	coleenp
date	Sun, 13 Apr 2008 17:43:42 -0400
parents	0834225a7916
children	b5489bb705c9

comparison

equal deleted inserted replaced

-:a49a647afe9a
+:ba764ed4b6f2
 }
 return NULL;
 }
-oop ConcurrentMarkSweepGeneration::promote(oop obj, size_t obj_size, oop* ref) {
+oop ConcurrentMarkSweepGeneration::promote(oop obj, size_t obj_size) {
 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in");
 // allocate, copy and if necessary update promoinfo --
 // delegate to underlying space.
 assert_lock_strong(freelistLock());
 if (Universe::heap()->promotion_should_fail()) {
 return NULL;
 }
 #endif  // #ifndef PRODUCT
-oop res = _cmsSpace->promote(obj, obj_size, ref);
+oop res = _cmsSpace->promote(obj, obj_size);
 if (res == NULL) {
 // expand and retry
 size_t s = _cmsSpace->expansionSpaceRequired(obj_size);  // HeapWords
 expand(s*HeapWordSize, MinHeapDeltaBytes,
 CMSExpansionCause::_satisfy_promotion);
 // Since there's currently no next generation, we don't try to promote
 // into a more senior generation.
 assert(next_gen() == NULL, "assumption, based upon which no attempt "
 "is made to pass on a possibly failing "
 "promotion to next generation");
-res = _cmsSpace->promote(obj, obj_size, ref);
+res = _cmsSpace->promote(obj, obj_size);
 }
 if (res != NULL) {
 // See comment in allocate() about when objects should
 // be allocated live.
 assert(obj->is_oop(), "Will dereference klass pointer below");
 // task.
 pst->all_tasks_completed();
 }
 class Par_ConcMarkingClosure: public OopClosure {
+private:
 CMSCollector* _collector;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 CMSMarkStack* _overflow_stack;
 CMSMarkStack* _revisit_stack;     // XXXXXX Check proper use
 OopTaskQueue* _work_queue;
+protected:
+DO_OOP_WORK_DEFN
 public:
 Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue,
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
 _collector(collector),
 _span(_collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 _overflow_stack(overflow_stack) { }   // need to initialize revisit stack etc.
+virtual void do_oop(oop* p);
-void do_oop(oop* p);
+virtual void do_oop(narrowOop* p);
 void trim_queue(size_t max);
 void handle_stack_overflow(HeapWord* lost);
 };
 // Grey object rescan during work stealing phase --
 // the salient assumption here is that stolen oops must
 // always be initialized, so we do not need to check for
 // uninitialized objects before scanning here.
-void Par_ConcMarkingClosure::do_oop(oop* p) {
+void Par_ConcMarkingClosure::do_oop(oop obj) {
-oop    this_oop = *p;
+assert(obj->is_oop_or_null(), "expected an oop or NULL");
-assert(this_oop->is_oop_or_null(),
+HeapWord* addr = (HeapWord*)obj;
-"expected an oop or NULL");
-HeapWord* addr = (HeapWord*)this_oop;
 // Check if oop points into the CMS generation
 // and is not marked
 if (_span.contains(addr) && !_bit_map->isMarked(addr)) {
 // a white object ...
 // If we manage to "claim" the object, by being the
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
 if (simulate_overflow ||
-!(_work_queue->push(this_oop) || _overflow_stack->par_push(this_oop))) {
+!(_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());
 }
 handle_stack_overflow(addr);
 }
 } // Else, some other thread got there first
 }
 }
+void Par_ConcMarkingClosure::do_oop(oop* p)       { Par_ConcMarkingClosure::do_oop_work(p); }
+void Par_ConcMarkingClosure::do_oop(narrowOop* p) { Par_ConcMarkingClosure::do_oop_work(p); }
 void Par_ConcMarkingClosure::trim_queue(size_t max) {
 while (_work_queue->size() > max) {
 oop new_oop;
 if (_work_queue->pop_local(new_oop)) {
 // are almost identical into one for better maintenability and
 // readability. See 6445193.
 //
 // Tony 2006.06.29
 for (unsigned i = 0; i < CMSCoordinatorYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
 os::sleep(Thread::current(), 1, false);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 }
 ConcurrentMarkSweepThread::synchronize(true);
 }
 icms_wait();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
 os::sleep(Thread::current(), 1, false);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 }
 ConcurrentMarkSweepThread::synchronize(true);
 {
 assert(_ref_processor == NULL, "deliberately left NULL");
 assert(_bitMap->covers(_span), "_bitMap/_span mismatch");
 }
-void MarkRefsIntoClosure::do_oop(oop* p) {
+void MarkRefsIntoClosure::do_oop(oop obj) {
 // if p points into _span, then mark corresponding bit in _markBitMap
-oop thisOop = *p;
+assert(obj->is_oop(), "expected an oop");
-if (thisOop != NULL) {
+HeapWord* addr = (HeapWord*)obj;
-assert(thisOop->is_oop(), "expected an oop");
+if (_span.contains(addr)) {
-HeapWord* addr = (HeapWord*)thisOop;
+// this should be made more efficient
-if (_span.contains(addr)) {
+_bitMap->mark(addr);
-// this should be made more efficient
+}
-_bitMap->mark(addr);
+}
-}
-}
+void MarkRefsIntoClosure::do_oop(oop* p)       { MarkRefsIntoClosure::do_oop_work(p); }
-}
+void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
 // A variant of the above, used for CMS marking verification.
 MarkRefsIntoVerifyClosure::MarkRefsIntoVerifyClosure(
 MemRegion span, CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 bool should_do_nmethods):
 _should_do_nmethods(should_do_nmethods) {
 assert(_ref_processor == NULL, "deliberately left NULL");
 assert(_verification_bm->covers(_span), "_verification_bm/_span mismatch");
 }
-void MarkRefsIntoVerifyClosure::do_oop(oop* p) {
+void MarkRefsIntoVerifyClosure::do_oop(oop obj) {
 // if p points into _span, then mark corresponding bit in _markBitMap
-oop this_oop = *p;
+assert(obj->is_oop(), "expected an oop");
-if (this_oop != NULL) {
+HeapWord* addr = (HeapWord*)obj;
-assert(this_oop->is_oop(), "expected an oop");
+if (_span.contains(addr)) {
-HeapWord* addr = (HeapWord*)this_oop;
+_verification_bm->mark(addr);
-if (_span.contains(addr)) {
+if (!_cms_bm->isMarked(addr)) {
-_verification_bm->mark(addr);
+oop(addr)->print();
-if (!_cms_bm->isMarked(addr)) {
+gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr);
-oop(addr)->print();
+fatal("... aborting");
-gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr);
+}
-fatal("... aborting");
+}
 }
-}
-}
+void MarkRefsIntoVerifyClosure::do_oop(oop* p)       { MarkRefsIntoVerifyClosure::do_oop_work(p); }
-}
+void MarkRefsIntoVerifyClosure::do_oop(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
 //////////////////////////////////////////////////
 // MarkRefsIntoAndScanClosure
 //////////////////////////////////////////////////
 // the unmarked oops. It is also used during the concurrent precleaning
 // phase while scanning objects on dirty cards in the CMS generation.
 // The marks are made in the marking bit map and the marking stack is
 // used for keeping the (newly) grey objects during the scan.
 // The parallel version (Par_...) appears further below.
-void MarkRefsIntoAndScanClosure::do_oop(oop* p) {
+void MarkRefsIntoAndScanClosure::do_oop(oop obj) {
-oop this_oop = *p;
+if (obj != NULL) {
-if (this_oop != NULL) {
+assert(obj->is_oop(), "expected an oop");
-assert(this_oop->is_oop(), "expected an oop");
+HeapWord* addr = (HeapWord*)obj;
-HeapWord* addr = (HeapWord*)this_oop;
+assert(_mark_stack->isEmpty(), "pre-condition (eager drainage)");
-assert(_mark_stack->isEmpty(), "post-condition (eager drainage)");
+assert(_collector->overflow_list_is_empty(),
-assert(_collector->overflow_list_is_empty(), "should be empty");
+"overflow list should be empty");
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 // mark bit map (object is now grey)
 _bit_map->mark(addr);
 // push on marking stack (stack should be empty), and drain the
 // stack by applying this closure to the oops in the oops popped
 // from the stack (i.e. blacken the grey objects)
-bool res = _mark_stack->push(this_oop);
+bool res = _mark_stack->push(obj);
 assert(res, "Should have space to push on empty stack");
 do {
 oop new_oop = _mark_stack->pop();
 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop");
 assert(new_oop->is_parsable(), "Found unparsable oop");
 assert(!CMSOverflowEarlyRestoration || _collector->no_preserved_marks(),
 "All preserved marks should have been restored above");
 }
 }
+void MarkRefsIntoAndScanClosure::do_oop(oop* p)       { MarkRefsIntoAndScanClosure::do_oop_work(p); }
+void MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
 void MarkRefsIntoAndScanClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bit_map->lock());
 _collector->incrementYields();
 }
 _collector->icms_wait();
 // See the comment in coordinator_yield()
-for (unsigned i = 0; i < CMSYieldSleepCount &&
+for (unsigned i = 0;
-ConcurrentMarkSweepThread::should_yield() &&
+i < CMSYieldSleepCount &&
-!CMSCollector::foregroundGCIsActive(); ++i) {
+ConcurrentMarkSweepThread::should_yield() &&
+!CMSCollector::foregroundGCIsActive();
+++i) {
 os::sleep(Thread::current(), 1, false);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 }
 ConcurrentMarkSweepThread::synchronize(true);
 // the unmarked oops. The marks are made in the marking bit map and
 // the work_queue is used for keeping the (newly) grey objects during
 // the scan phase whence they are also available for stealing by parallel
 // threads. Since the marking bit map is shared, updates are
 // synchronized (via CAS).
-void Par_MarkRefsIntoAndScanClosure::do_oop(oop* p) {
+void Par_MarkRefsIntoAndScanClosure::do_oop(oop obj) {
-oop this_oop = *p;
+if (obj != NULL) {
-if (this_oop != NULL) {
 // Ignore mark word because this could be an already marked oop
 // that may be chained at the end of the overflow list.
-assert(this_oop->is_oop(true /* ignore mark word */), "expected an oop");
+assert(obj->is_oop(), "expected an oop");
-HeapWord* addr = (HeapWord*)this_oop;
+HeapWord* addr = (HeapWord*)obj;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 // mark bit map (object will become grey):
 // It is possible for several threads to be
 // trying to "claim" this object concurrently;
 if (_bit_map->par_mark(addr)) {
 // push on work_queue (which may not be empty), and trim the
 // queue to an appropriate length by applying this closure to
 // the oops in the oops popped from the stack (i.e. blacken the
 // grey objects)
-bool res = _work_queue->push(this_oop);
+bool res = _work_queue->push(obj);
 assert(res, "Low water mark should be less than capacity?");
 trim_queue(_low_water_mark);
 } // Else, another thread claimed the object
 }
 }
 }
+void Par_MarkRefsIntoAndScanClosure::do_oop(oop* p)       { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
+void Par_MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
 // This closure is used to rescan the marked objects on the dirty cards
 // in the mod union table and the card table proper.
 size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m(
 oop p, MemRegion mr) {
 }
 _collector->icms_wait();
 // See the comment in coordinator_yield()
 for (unsigned i = 0; i < CMSYieldSleepCount &&
 ConcurrentMarkSweepThread::should_yield() &&
 !CMSCollector::foregroundGCIsActive(); ++i) {
 os::sleep(Thread::current(), 1, false);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 }
 ConcurrentMarkSweepThread::synchronize(true);
 void MarkFromRootsClosure::scanOopsInOop(HeapWord* ptr) {
 assert(_bitMap->isMarked(ptr), "expected bit to be set");
 assert(_markStack->isEmpty(),
 "should drain stack to limit stack usage");
 // convert ptr to an oop preparatory to scanning
-oop this_oop = oop(ptr);
+oop obj = oop(ptr);
 // Ignore mark word in verification below, since we
 // may be running concurrent with mutators.
-assert(this_oop->is_oop(true), "should be an oop");
+assert(obj->is_oop(true), "should be an oop");
 assert(_finger <= ptr, "_finger runneth ahead");
 // advance the finger to right end of this object
-_finger = ptr + this_oop->size();
+_finger = ptr + obj->size();
 assert(_finger > ptr, "we just incremented it above");
 // On large heaps, it may take us some time to get through
 // the marking phase (especially if running iCMS). During
 // this time it's possible that a lot of mutations have
 // accumulated in the card table and the mod union table --
 // the stack below.
 PushOrMarkClosure pushOrMarkClosure(_collector,
 _span, _bitMap, _markStack,
 _revisitStack,
 _finger, this);
-bool res = _markStack->push(this_oop);
+bool res = _markStack->push(obj);
 assert(res, "Empty non-zero size stack should have space for single push");
 while (!_markStack->isEmpty()) {
 oop new_oop = _markStack->pop();
 // Skip verifying header mark word below because we are
 // running concurrent with mutators.
 // Should we assert that our work queue is empty or
 // below some drain limit?
 assert(_work_queue->size() == 0,
 "should drain stack to limit stack usage");
 // convert ptr to an oop preparatory to scanning
-oop this_oop = oop(ptr);
+oop obj = oop(ptr);
 // Ignore mark word in verification below, since we
 // may be running concurrent with mutators.
-assert(this_oop->is_oop(true), "should be an oop");
+assert(obj->is_oop(true), "should be an oop");
 assert(_finger <= ptr, "_finger runneth ahead");
 // advance the finger to right end of this object
-_finger = ptr + this_oop->size();
+_finger = ptr + obj->size();
 assert(_finger > ptr, "we just incremented it above");
 // On large heaps, it may take us some time to get through
 // the marking phase (especially if running iCMS). During
 // this time it's possible that a lot of mutations have
 // accumulated in the card table and the mod union table --
 _work_queue,
 _overflow_stack,
 _revisit_stack,
 _finger,
 gfa, this);
-bool res = _work_queue->push(this_oop);   // overflow could occur here
+bool res = _work_queue->push(obj);   // overflow could occur here
 assert(res, "Will hold once we use workqueues");
 while (true) {
 oop new_oop;
 if (!_work_queue->pop_local(new_oop)) {
 // We emptied our work_queue; check if there's stuff that can
 assert(_cms_bm->isMarked(addr), "tautology");
 assert(_mark_stack->isEmpty(),
 "should drain stack to limit stack usage");
 // convert addr to an oop preparatory to scanning
-oop this_oop = oop(addr);
+oop obj = oop(addr);
-assert(this_oop->is_oop(), "should be an oop");
+assert(obj->is_oop(), "should be an oop");
 assert(_finger <= addr, "_finger runneth ahead");
 // advance the finger to right end of this object
-_finger = addr + this_oop->size();
+_finger = addr + obj->size();
 assert(_finger > addr, "we just incremented it above");
 // Note: the finger doesn't advance while we drain
 // the stack below.
-bool res = _mark_stack->push(this_oop);
+bool res = _mark_stack->push(obj);
 assert(res, "Empty non-zero size stack should have space for single push");
 while (!_mark_stack->isEmpty()) {
 oop new_oop = _mark_stack->pop();
 assert(new_oop->is_oop(), "Oops! expected to pop an oop");
 // now scan this oop's oops
 _verification_bm(verification_bm),
 _cms_bm(cms_bm),
 _mark_stack(mark_stack)
 { }
+void PushAndMarkVerifyClosure::do_oop(oop* p)       { PushAndMarkVerifyClosure::do_oop_work(p); }
+void PushAndMarkVerifyClosure::do_oop(narrowOop* p) { PushAndMarkVerifyClosure::do_oop_work(p); }
 // Upon stack overflow, we discard (part of) the stack,
 // remembering the least address amongst those discarded
 // in CMSCollector's _restart_address.
 void PushAndMarkVerifyClosure::handle_stack_overflow(HeapWord* lost) {
 _collector->lower_restart_addr(ra);
 _mark_stack->reset();  // discard stack contents
 _mark_stack->expand(); // expand the stack if possible
 }
-void PushAndMarkVerifyClosure::do_oop(oop* p) {
+void PushAndMarkVerifyClosure::do_oop(oop obj) {
-oop    this_oop = *p;
+assert(obj->is_oop_or_null(), "expected an oop or NULL");
-assert(this_oop->is_oop_or_null(), "expected an oop or NULL");
+HeapWord* addr = (HeapWord*)obj;
-HeapWord* addr = (HeapWord*)this_oop;
 if (_span.contains(addr) && !_verification_bm->isMarked(addr)) {
 // 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)", addr);
+gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)",
+addr);
 fatal("... aborting");
 }
-if (!_mark_stack->push(this_oop)) { // stack overflow
+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());
 }
 assert(_mark_stack->isFull(), "Else push should have succeeded");
 _global_finger_addr(global_finger_addr),
 _parent(parent),
 _should_remember_klasses(collector->should_unload_classes())
 { }
 void CMSCollector::lower_restart_addr(HeapWord* low) {
 assert(_span.contains(low), "Out of bounds addr");
 if (_restart_addr == NULL) {
 _restart_addr = low;
 } else {
 _collector->lower_restart_addr(ra);
 _overflow_stack->reset();  // discard stack contents
 _overflow_stack->expand(); // expand the stack if possible
 }
+void PushOrMarkClosure::do_oop(oop obj) {
-void PushOrMarkClosure::do_oop(oop* p) {
-oop    thisOop = *p;
 // Ignore mark word because we are running concurrent with mutators.
-assert(thisOop->is_oop_or_null(true), "expected an oop or NULL");
+assert(obj->is_oop_or_null(true), "expected an oop or NULL");
-HeapWord* addr = (HeapWord*)thisOop;
+HeapWord* addr = (HeapWord*)obj;
 if (_span.contains(addr) && !_bitMap->isMarked(addr)) {
 // Oop lies in _span and isn't yet grey or black
 _bitMap->mark(addr);            // now grey
 if (addr < _finger) {
 // the bit map iteration has already either passed, or
 _collector->simulate_overflow()) {
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
-if (simulate_overflow || !_markStack->push(thisOop)) { // stack overflow
+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());
 }
 assert(simulate_overflow || _markStack->isFull(), "Else push should have succeeded");
 // bit map
 do_yield_check();
 }
 }
-void Par_PushOrMarkClosure::do_oop(oop* p) {
+void PushOrMarkClosure::do_oop(oop* p)       { PushOrMarkClosure::do_oop_work(p); }
-oop    this_oop = *p;
+void PushOrMarkClosure::do_oop(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
+void Par_PushOrMarkClosure::do_oop(oop obj) {
 // Ignore mark word because we are running concurrent with mutators.
-assert(this_oop->is_oop_or_null(true), "expected an oop or NULL");
+assert(obj->is_oop_or_null(true), "expected an oop or NULL");
-HeapWord* addr = (HeapWord*)this_oop;
+HeapWord* addr = (HeapWord*)obj;
 if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) {
 // Oop lies in _span and isn't yet grey or black
 // We read the global_finger (volatile read) strictly after marking oop
 bool res = _bit_map->par_mark(addr);    // now grey
 volatile HeapWord** gfa = (volatile HeapWord**)_global_finger_addr;
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
 if (simulate_overflow ||
-!(_work_queue->push(this_oop) || _overflow_stack->par_push(this_oop))) {
+!(_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());
 }
 }
 do_yield_check();
 }
 }
+void Par_PushOrMarkClosure::do_oop(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }
+void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
 // Grey object rescan during pre-cleaning and second checkpoint phases --
 // the non-parallel version (the parallel version appears further below.)
-void PushAndMarkClosure::do_oop(oop* p) {
+void PushAndMarkClosure::do_oop(oop obj) {
-oop    this_oop = *p;
+// If _concurrent_precleaning, ignore mark word verification
-// Ignore mark word verification. If during concurrent precleaning
+assert(obj->is_oop_or_null(_concurrent_precleaning),
-// the object monitor may be locked. If during the checkpoint
-// phases, the object may already have been reached by a  different
-// path and may be at the end of the global overflow list (so
-// the mark word may be NULL).
-assert(this_oop->is_oop_or_null(true/* ignore mark word */),
 "expected an oop or NULL");
-HeapWord* addr = (HeapWord*)this_oop;
+HeapWord* addr = (HeapWord*)obj;
 // Check if oop points into the CMS generation
 // and is not marked
 if (_span.contains(addr) && !_bit_map->isMarked(addr)) {
 // a white object ...
 _bit_map->mark(addr);         // ... now grey
 _collector->simulate_overflow()) {
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
-if (simulate_overflow || !_mark_stack->push(this_oop)) {
+if (simulate_overflow || !_mark_stack->push(obj)) {
 if (_concurrent_precleaning) {
 // During precleaning we can just dirty the appropriate card
 // in the mod union table, thus ensuring that the object remains
 // in the grey set  and continue. Note that no one can be intefering
 // with us in this action of dirtying the mod union table, so
 _mod_union_table->mark(addr);
 _collector->_ser_pmc_preclean_ovflw++;
 } else {
 // During the remark phase, we need to remember this oop
 // in the overflow list.
-_collector->push_on_overflow_list(this_oop);
+_collector->push_on_overflow_list(obj);
 _collector->_ser_pmc_remark_ovflw++;
 }
 }
 }
 }
 _should_remember_klasses(collector->should_unload_classes())
 {
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
+void PushAndMarkClosure::do_oop(oop* p)       { PushAndMarkClosure::do_oop_work(p); }
+void PushAndMarkClosure::do_oop(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
 // Grey object rescan during second checkpoint phase --
 // the parallel version.
-void Par_PushAndMarkClosure::do_oop(oop* p) {
+void Par_PushAndMarkClosure::do_oop(oop obj) {
-oop    this_oop = *p;
 // In the assert below, we ignore the mark word because
 // this oop may point to an already visited object that is
 // on the overflow stack (in which case the mark word has
 // been hijacked for chaining into the overflow stack --
 // if this is the last object in the overflow stack then
 // have been subsequently popped off the global overflow
 // stack, and the mark word possibly restored to the prototypical
 // value, by the time we get to examined this failing assert in
 // the debugger, is_oop_or_null(false) may subsequently start
 // to hold.
-assert(this_oop->is_oop_or_null(true),
+assert(obj->is_oop_or_null(true),
 "expected an oop or NULL");
-HeapWord* addr = (HeapWord*)this_oop;
+HeapWord* addr = (HeapWord*)obj;
 // Check if oop points into the CMS generation
 // and is not marked
 if (_span.contains(addr) && !_bit_map->isMarked(addr)) {
 // a white object ...
 // If we manage to "claim" the object, by being the
 _collector->par_simulate_overflow()) {
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
-if (simulate_overflow || !_work_queue->push(this_oop)) {
+if (simulate_overflow || !_work_queue->push(obj)) {
-_collector->par_push_on_overflow_list(this_oop);
+_collector->par_push_on_overflow_list(obj);
 _collector->_par_pmc_remark_ovflw++; //  imprecise OK: no need to CAS
 }
 } // Else, some other thread got there first
 }
 }
+void Par_PushAndMarkClosure::do_oop(oop* p)       { Par_PushAndMarkClosure::do_oop_work(p); }
+void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
 void PushAndMarkClosure::remember_klass(Klass* k) {
 if (!_revisit_stack->push(oop(k))) {
 fatal("Revisit stack overflowed in PushAndMarkClosure");
 }
 return addr != NULL &&
 (!_span.contains(addr) || _bit_map->isMarked(addr));
 }
 // CMSKeepAliveClosure: the serial version
-void CMSKeepAliveClosure::do_oop(oop* p) {
+void CMSKeepAliveClosure::do_oop(oop obj) {
-oop this_oop = *p;
+HeapWord* addr = (HeapWord*)obj;
-HeapWord* addr = (HeapWord*)this_oop;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 _bit_map->mark(addr);
 bool simulate_overflow = false;
 NOT_PRODUCT(
 _collector->simulate_overflow()) {
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
-if (simulate_overflow || !_mark_stack->push(this_oop)) {
+if (simulate_overflow || !_mark_stack->push(obj)) {
-_collector->push_on_overflow_list(this_oop);
+_collector->push_on_overflow_list(obj);
 _collector->_ser_kac_ovflw++;
 }
 }
 }
+void CMSKeepAliveClosure::do_oop(oop* p)       { CMSKeepAliveClosure::do_oop_work(p); }
+void CMSKeepAliveClosure::do_oop(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
 // CMSParKeepAliveClosure: a parallel version of the above.
 // The work queues are private to each closure (thread),
 // but (may be) available for stealing by other threads.
-void CMSParKeepAliveClosure::do_oop(oop* p) {
+void CMSParKeepAliveClosure::do_oop(oop obj) {
-oop this_oop = *p;
+HeapWord* addr = (HeapWord*)obj;
-HeapWord* addr = (HeapWord*)this_oop;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 // In general, during recursive tracing, several threads
 // may be concurrently getting here; the first one to
 // "tag" it, claims it.
 if (_bit_map->par_mark(addr)) {
-bool res = _work_queue->push(this_oop);
+bool res = _work_queue->push(obj);
 assert(res, "Low water mark should be much less than capacity");
 // Do a recursive trim in the hope that this will keep
 // stack usage lower, but leave some oops for potential stealers
 trim_queue(_low_water_mark);
 } // Else, another thread got there first
 }
 }
+void CMSParKeepAliveClosure::do_oop(oop* p)       { CMSParKeepAliveClosure::do_oop_work(p); }
+void CMSParKeepAliveClosure::do_oop(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
 void CMSParKeepAliveClosure::trim_queue(uint max) {
 while (_work_queue->size() > max) {
 oop new_oop;
 if (_work_queue->pop_local(new_oop)) {
 new_oop->oop_iterate(&_mark_and_push);
 }
 }
 }
-void CMSInnerParMarkAndPushClosure::do_oop(oop* p) {
+void CMSInnerParMarkAndPushClosure::do_oop(oop obj) {
-oop this_oop = *p;
+HeapWord* addr = (HeapWord*)obj;
-HeapWord* addr = (HeapWord*)this_oop;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 if (_bit_map->par_mark(addr)) {
 bool simulate_overflow = false;
 NOT_PRODUCT(
 _collector->par_simulate_overflow()) {
 // simulate a stack overflow
 simulate_overflow = true;
 }
 )
-if (simulate_overflow || !_work_queue->push(this_oop)) {
+if (simulate_overflow || !_work_queue->push(obj)) {
-_collector->par_push_on_overflow_list(this_oop);
+_collector->par_push_on_overflow_list(obj);
 _collector->_par_kac_ovflw++;
 }
 } // Else another thread got there already
 }
 }
+void CMSInnerParMarkAndPushClosure::do_oop(oop* p)       { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
+void CMSInnerParMarkAndPushClosure::do_oop(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
 //////////////////////////////////////////////////////////////////
 //  CMSExpansionCause                /////////////////////////////
 //////////////////////////////////////////////////////////////////
 const char* CMSExpansionCause::to_string(CMSExpansionCause::Cause cause) {
 // the max number to take from overflow list at a time
 const size_t num = _mark_stack->capacity()/4;
 while (!_mark_stack->isEmpty() ||
 // if stack is empty, check the overflow list
 _collector->take_from_overflow_list(num, _mark_stack)) {
-oop this_oop = _mark_stack->pop();
+oop obj = _mark_stack->pop();
-HeapWord* addr = (HeapWord*)this_oop;
+HeapWord* addr = (HeapWord*)obj;
 assert(_span.contains(addr), "Should be within span");
 assert(_bit_map->isMarked(addr), "Should be marked");
-assert(this_oop->is_oop(), "Should be an oop");
+assert(obj->is_oop(), "Should be an oop");
-this_oop->oop_iterate(_keep_alive);
+obj->oop_iterate(_keep_alive);
 }
 }
 void CMSParDrainMarkingStackClosure::do_void() {
 // drain queue

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 113:ba764ed4b6f2