graal-compiler: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp comparison

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	d166675568f6
children	52b4284cb496

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 //
 // Unfortunately, i couldn't come up with a good abstraction to factor and
 // hide the naked CGC_lock manipulation in the baton-passing code
 // further below. That's something we should try to do. Also, the proof
 // of correctness of this 2-level locking scheme is far from obvious,
-// and potentially quite slippery. We have an uneasy suspicion, for instance,
+// and potentially quite slippery. We have an uneasy supsicion, for instance,
 // that there may be a theoretical possibility of delay/starvation in the
 // low-level lock/wait/notify scheme used for the baton-passing because of
-// potential interference with the priority scheme embodied in the
+// potential intereference with the priority scheme embodied in the
 // CMS-token-passing protocol. See related comments at a CGC_lock->wait()
 // invocation further below and marked with "XXX 20011219YSR".
 // Indeed, as we note elsewhere, this may become yet more slippery
 // in the presence of multiple CMS and/or multiple VM threads. XXX
 // generation may be larger than that in, say, a contiguous young
 //  generation.
 // Ideally, in the calculation below, we'd compute the dilatation
 // factor as: MinChunkSize/(promoting_gen's min object size)
 // Since we do not have such a general query interface for the
-// promoting generation, we'll instead just use the minimum
+// promoting generation, we'll instead just use the mimimum
 // object size (which today is a header's worth of space);
 // note that all arithmetic is in units of HeapWords.
 assert(MinChunkSize >= CollectedHeap::min_fill_size(), "just checking");
 assert(_dilatation_factor >= 1.0, "from previous assert");
 }
 // via CMSInitiatingOccupancyFraction (argument "io" below), it
 // is calculated by:
 //
 //   Let "f" be MinHeapFreeRatio in
 //
-//    _initiating_occupancy = 100-f +
+//    _intiating_occupancy = 100-f +
 //                           f * (CMSTriggerRatio/100)
 //   where CMSTriggerRatio is the argument "tr" below.
 //
 // That is, if we assume the heap is at its desired maximum occupancy at the
 // end of a collection, we let CMSTriggerRatio of the (purported) free
 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("  Capactiy "SIZE_FORMAT, capacity()/1000);
 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;
 // prologue delegate to the collector, which delegates back
 // some "local" work to a worker method in the individual generations
 // that it's responsible for collecting, while itself doing any
 // work common to all generations it's responsible for. A similar
 // comment applies to the  gc_epilogue()'s.
-// The role of the variable _between_prologue_and_epilogue is to
+// The role of the varaible _between_prologue_and_epilogue is to
 // enforce the invocation protocol.
 void CMSCollector::gc_prologue(bool full) {
 // Call gc_prologue_work() for the CMSGen
 // we are responsible for.
 #endif
 // Check reachability of the given heap address in CMS generation,
 // treating all other generations as roots.
 bool CMSCollector::is_cms_reachable(HeapWord* addr) {
-// We could "guarantee" below, rather than assert, but I'll
+// We could "guarantee" below, rather than assert, but i'll
 // leave these as "asserts" so that an adventurous debugger
 // could try this in the product build provided some subset of
-// the conditions were met, provided they were interested in the
+// the conditions were met, provided they were intersted in the
 // results and knew that the computation below wouldn't interfere
 // with other concurrent computations mutating the structures
 // being read or written.
 assert(SafepointSynchronize::is_at_safepoint(),
 "Else mutations in object graph will make answer suspect");
 // Turn off refs discovery -- so we will be tracing through refs.
 // This is as intended, because by this time
 // GC must already have cleared any refs that need to be cleared,
 // and traced those that need to be marked; moreover,
-// the marking done here is not going to interfere in any
+// the marking done here is not going to intefere in any
 // way with the marking information used by GC.
 NoRefDiscovery no_discovery(ref_processor());
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
 // Update the saved marks which may affect the root scans.
 gch->save_marks();
 if (CMSRemarkVerifyVariant == 1) {
 // In this first variant of verification, we complete
-// all marking, then check if the new marks-vector is
+// all marking, then check if the new marks-verctor is
 // a subset of the CMS marks-vector.
 verify_after_remark_work_1();
 } else if (CMSRemarkVerifyVariant == 2) {
 // In this second variant of verification, we flag an error
 // (i.e. an object reachable in the new marks-vector not reachable
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
+true,   // walk code active on stacks
 NULL,
 NULL); // SSS: Provide correct closure
 // Now mark from the roots
 MarkFromRootsClosure markFromRootsClosure(this, _span,
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
+true,   // walk code active on stacks
 NULL,
 &klass_closure);
 // Now mark from the roots
 MarkFromRootsVerifyClosure markFromRootsClosure(this, _span,
 }
 void CMSCollector::setup_cms_unloading_and_verification_state() {
 const  bool should_verify =   VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC
 || VerifyBeforeExit;
-const  int  rso           =   SharedHeap::SO_Strings | SharedHeap::SO_AllCodeCache;
+const  int  rso           =   SharedHeap::SO_Strings | SharedHeap::SO_CodeCache;
 // We set the proper root for this CMS cycle here.
 if (should_unload_classes()) {   // Should unload classes this cycle
 remove_root_scanning_option(SharedHeap::SO_AllClasses);
 add_root_scanning_option(SharedHeap::SO_SystemClasses);
 set_verifying(should_verify);    // Set verification state for this cycle
 return;                            // Nothing else needs to be done at this time
 }
 // Not unloading classes this cycle
-assert(!should_unload_classes(), "Inconsistency!");
+assert(!should_unload_classes(), "Inconsitency!");
 remove_root_scanning_option(SharedHeap::SO_SystemClasses);
 add_root_scanning_option(SharedHeap::SO_AllClasses);
 if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) {
 // Include symbols, strings and code cache elements to prevent their resurrection.
 // Otherwise, we try expansion.
 expand(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.
+// so we may go around the loop again if promotion fails agaion.
 if (GCExpandToAllocateDelayMillis > 0) {
 os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
 }
 }
 }
 }
 ResourceMark rm;
 HandleMark  hm;
+FalseClosure falseClosure;
+// In the case of a synchronous collection, we will elide the
+// remark step, so it's important to catch all the nmethod oops
+// in this step.
+// The final 'true' flag to gen_process_strong_roots will ensure this.
+// If 'async' is true, we can relax the nmethod tracing.
 MarkRefsIntoClosure notOlder(_span, &_markBitMap);
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 verify_work_stacks_empty();
 verify_overflow_empty();
 CMKlassClosure klass_closure(&notOlder);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
+true,   // walk all of code cache if (so & SO_CodeCache)
 NULL,
 &klass_closure);
 }
 }
 // We really need to reconsider the synchronization between the GC
 // thread and the yield-requesting threads in the future and we
 // should really use wait/notify, which is the recommended
 // way of doing this type of interaction. Additionally, we should
 // consolidate the eight methods that do the yield operation and they
-// are almost identical into one for better maintainability and
+// 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() &&
 assert(_collectorState == AbortablePreclean, "Inconsistent control state");
 // If Eden's current occupancy is below this threshold,
 // immediately schedule the remark; else preclean
 // past the next scavenge in an effort to
-// schedule the pause as described above. By choosing
+// schedule the pause as described avove. By choosing
 // 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);
 _timer.reset();
 _timer.start();
 gch->gen_process_strong_roots(_collector->_cmsGen->level(),
 false,     // yg was scanned above
 false,     // this is parallel code
+false,     // not scavenging
 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
 &par_mri_cl,
+true,   // walk all of code cache if (so & SO_CodeCache)
 NULL,
 &klass_closure);
 assert(_collector->should_unload_classes()
-|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
+|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache),
 "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",
 _timer.reset();
 _timer.start();
 gch->gen_process_strong_roots(_collector->_cmsGen->level(),
 false,     // yg was scanned above
 false,     // this is parallel code
+false,     // not scavenging
 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
 &par_mrias_cl,
+true,   // walk all of code cache if (so & SO_CodeCache)
 NULL,
 NULL);     // The dirty klasses will be handled below
 assert(_collector->should_unload_classes()
-|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
+|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache),
 "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",
 OopTaskQueue* work_q = work_queue(i);
 ModUnionClosure modUnionClosure(&(_collector->_modUnionTable));
 // CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION! CAUTION!
 // CAUTION: This closure has state that persists across calls to
 // the work method dirty_range_iterate_clear() in that it has
-// embedded in it a (subtype of) UpwardsObjectClosure. The
+// imbedded in it a (subtype of) UpwardsObjectClosure. The
-// use of that state in the embedded UpwardsObjectClosure instance
+// use of that state in the imbedded UpwardsObjectClosure instance
 // assumes that the cards are always iterated (even if in parallel
 // by several threads) in monotonically increasing order per each
 // thread. This is true of the implementation below which picks
 // card ranges (chunks) in monotonically increasing order globally
 // and, a-fortiori, in monotonically increasing order per thread
 // revisited and modified appropriately. See also related
 // bug 4756801 work on which should examine this code to make
 // sure that the changes there do not run counter to the
 // assumptions made here and necessary for correctness and
 // efficiency. Note also that this code might yield inefficient
-// behavior in the case of very large objects that span one or
+// behaviour in the case of very large objects that span one or
 // more work chunks. Such objects would potentially be scanned
 // several times redundantly. Work on 4756801 should try and
 // address that performance anomaly if at all possible. XXX
 MemRegion  full_span  = _collector->_span;
 CMSBitMap* bm    = &(_collector->_markBitMap);     // shared
 assert((size_t)round_to((intptr_t)chunk_size, alignment) ==
 chunk_size, "Check alignment");
 while (!pst->is_task_claimed(/* reference */ nth_task)) {
 // Having claimed the nth_task, compute corresponding mem-region,
-// which is a-fortiori aligned correctly (i.e. at a MUT boundary).
+// which is a-fortiori aligned correctly (i.e. at a MUT bopundary).
 // The alignment restriction ensures that we do not need any
 // synchronization with other gang-workers while setting or
 // clearing bits in thus chunk of the MUT.
 MemRegion this_span = MemRegion(start_addr + nth_task*chunk_size,
 start_addr + (nth_task+1)*chunk_size);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 GenCollectedHeap::StrongRootsScope srs(gch);
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,  // younger gens as roots
 false, // use the local StrongRootsScope
+false, // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &mrias_cl,
+true,   // walk code active on stacks
 NULL,
 NULL);  // The dirty klasses will be handled below
 assert(should_unload_classes()
-|| (roots_scanning_options() & SharedHeap::SO_AllCodeCache),
+|| (roots_scanning_options() & SharedHeap::SO_CodeCache),
 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
 }
 {
 GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm);
 _intra_sweep_estimate.sample(_intra_sweep_timer.seconds());
 _inter_sweep_timer.reset();
 _inter_sweep_timer.start();
-// We need to use a monotonically non-decreasing time in ms
+// We need to use a monotonically non-deccreasing time in ms
 // or we will see time-warp warnings and os::javaTimeMillis()
 // does not guarantee monotonicity.
 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 update_time_of_last_gc(now);
 (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1));
 if (!brs.is_reserved()) {
 warning("CMS bit map allocation failure");
 return false;
 }
-// For now we'll just commit all of the bit map up front.
+// For now we'll just commit all of the bit map up fromt.
 // Later on we'll try to be more parsimonious with swap.
 if (!_virtual_space.initialize(brs, brs.size())) {
 warning("CMS bit map backing store failure");
 return false;
 }
 return true;
 }
 // XXX FIX ME !!! In the MT case we come in here holding a
 // leaf lock. For printing we need to take a further lock
-// which has lower rank. We need to recalibrate the two
+// which has lower rank. We need to recallibrate the two
-// lock-ranks involved in order to be able to print the
+// lock-ranks involved in order to be able to rpint the
 // messages below. (Or defer the printing to the caller.
 // For now we take the expedient path of just disabling the
 // messages for the problematic case.)
 void CMSMarkStack::expand() {
 assert(_capacity <= MarkStackSizeMax, "stack bigger than permitted");
 assert(_bitMap->isMarked(addr+size-1),
 "inconsistent Printezis mark");
 }
 #endif // ASSERT
 } else {
-// An uninitialized object.
+// an unitialized object
 assert(_bitMap->isMarked(addr+1), "missing Printezis mark?");
 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
 size = pointer_delta(nextOneAddr + 1, addr);
 assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
 "alignment problem");
 // Note that pre-cleaning needn't redirty the card. OopDesc::set_klass()
 // will dirty the card when the klass pointer is installed in the
-// object (signaling the completion of initialization).
+// object (signalling the completion of initialization).
 }
 } else {
 // Either a not yet marked object or an uninitialized object
 if (p->klass_or_null() == NULL) {
 // An uninitialized object, skip to the next card, since
 size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) {
 HeapWord* addr = (HeapWord*)p;
 DEBUG_ONLY(_collector->verify_work_stacks_empty();)
 assert(!_span.contains(addr), "we are scanning the survivor spaces");
-assert(p->klass_or_null() != NULL, "object should be initialized");
+assert(p->klass_or_null() != NULL, "object should be initializd");
 // an initialized object; ignore mark word in verification below
 // since we are running concurrent with mutators
 assert(p->is_oop(true), "should be an oop");
 // Note that we do not yield while we iterate over
 // the interior oops of p, pushing the relevant ones
 // in the mod union table, thus ensuring that the object remains
 // in the grey set  and continue. In the case of object arrays
 // we need to dirty all of the cards that the object spans,
 // since the rescan of object arrays will be limited to the
 // dirty cards.
-// Note that no one can be interfering with us in this action
+// Note that no one can be intefering with us in this action
 // of dirtying the mod union table, so no locking or atomics
 // are required.
 if (obj->is_objArray()) {
 size_t sz = obj->size();
 HeapWord* end_card_addr = (HeapWord*)round_to(
 #ifndef PRODUCT
 // Debugging support for CMSStackOverflowALot
 // It's OK to call this multi-threaded;  the worst thing
 // that can happen is that we'll get a bunch of closely
-// spaced simulated overflows, but that's OK, in fact
+// spaced simulated oveflows, but that's OK, in fact
 // probably good as it would exercise the overflow code
 // under contention.
 bool CMSCollector::simulate_overflow() {
 if (_overflow_counter-- <= 0) { // just being defensive
 _overflow_counter = CMSMarkStackOverflowInterval;
 // above, if it is still the same value.
 if (_overflow_list == BUSY) {
 (void) Atomic::cmpxchg_ptr(NULL, &_overflow_list, BUSY);
 }
 } else {
-// Chop off the suffix and return it to the global list.
+// Chop off the suffix and rerturn it to the global list.
 assert(cur->mark() != BUSY, "Error");
 oop suffix_head = cur->mark(); // suffix will be put back on global list
 cur->set_mark(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

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 14909:4ca6dc0799b6