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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 11975:ca9dedeebdec

6412968: CMS Long initial mark pauses Reviewed-by: rasbold, tschatzl, jmasa Contributed-by: yamauchi@google.com

author	jmasa
date	Thu, 25 Jul 2013 11:07:23 -0700
parents	7b06ae405d7b
children	9766f73e770d

comparison

equal deleted inserted replaced

-:fb7010c7c011
+:ca9dedeebdec
 }
 }
 assert(_eden_chunk_array != NULL || _eden_chunk_capacity == 0, "Error");
 // Support for parallelizing survivor space rescan
-if (CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) {
+if ((CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) || CMSParallelInitialMarkEnabled) {
 const size_t max_plab_samples =
 ((DefNewGeneration*)_young_gen)->max_survivor_size()/MinTLABSize;
 _survivor_plab_array  = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads, mtGC);
 _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples, mtGC);
 }
 }
 // CMS work
+// The common parts of CMSParInitialMarkTask and CMSParRemarkTask.
+class CMSParMarkTask : public AbstractGangTask {
+protected:
+CMSCollector*     _collector;
+int               _n_workers;
+CMSParMarkTask(const char* name, CMSCollector* collector, int n_workers) :
+AbstractGangTask(name),
+_collector(collector),
+_n_workers(n_workers) {}
+// Work method in support of parallel rescan ... of young gen spaces
+void do_young_space_rescan(uint worker_id, OopsInGenClosure* cl,
+ContiguousSpace* space,
+HeapWord** chunk_array, size_t chunk_top);
+void work_on_young_gen_roots(uint worker_id, OopsInGenClosure* cl);
+};
+// Parallel initial mark task
+class CMSParInitialMarkTask: public CMSParMarkTask {
+public:
+CMSParInitialMarkTask(CMSCollector* collector, int n_workers) :
+CMSParMarkTask("Scan roots and young gen for initial mark in parallel",
+collector, n_workers) {}
+void work(uint worker_id);
+};
 // Checkpoint the roots into this generation from outside
 // this generation. [Note this initial checkpoint need only
 // be approximate -- we'll do a catch up phase subsequently.]
 void CMSCollector::checkpointRootsInitial(bool asynch) {
 assert(_collectorState == InitialMarking, "Wrong collector state");
 if (CMSPrintEdenSurvivorChunks) {
 print_eden_and_survivor_chunk_arrays();
 }
-CMKlassClosure klass_closure(&notOlder);
 {
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
-gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
+if (CMSParallelInitialMarkEnabled && CollectedHeap::use_parallel_gc_threads()) {
-gch->gen_process_strong_roots(_cmsGen->level(),
+// The parallel version.
-true,   // younger gens are roots
+FlexibleWorkGang* workers = gch->workers();
-true,   // activate StrongRootsScope
+assert(workers != NULL, "Need parallel worker threads.");
-false,  // not scavenging
+int n_workers = workers->active_workers();
-SharedHeap::ScanningOption(roots_scanning_options()),
+CMSParInitialMarkTask tsk(this, n_workers);
-&notOlder,
+gch->set_par_threads(n_workers);
-true,   // walk all of code cache if (so & SO_CodeCache)
+initialize_sequential_subtasks_for_young_gen_rescan(n_workers);
-NULL,
+if (n_workers > 1) {
-&klass_closure);
+GenCollectedHeap::StrongRootsScope srs(gch);
+workers->run_task(&tsk);
+} else {
+GenCollectedHeap::StrongRootsScope srs(gch);
+tsk.work(0);
+}
+gch->set_par_threads(0);
+} else {
+// The serial version.
+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);
+}
 }
 // Clear mod-union table; it will be dirtied in the prologue of
 // CMS generation per each younger generation collection.
 if (UseAdaptiveSizePolicy) {
 size_policy()->checkpoint_roots_final_end(gch->gc_cause());
 }
 }
+void CMSParInitialMarkTask::work(uint worker_id) {
+elapsedTimer _timer;
+ResourceMark rm;
+HandleMark   hm;
+// ---------- scan from roots --------------
+_timer.start();
+GenCollectedHeap* gch = GenCollectedHeap::heap();
+Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
+CMKlassClosure klass_closure(&par_mri_cl);
+// ---------- young gen roots --------------
+{
+work_on_young_gen_roots(worker_id, &par_mri_cl);
+_timer.stop();
+if (PrintCMSStatistics != 0) {
+gclog_or_tty->print_cr(
+"Finished young gen initial mark scan work in %dth thread: %3.3f sec",
+worker_id, _timer.seconds());
+}
+}
+// ---------- remaining roots --------------
+_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_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",
+worker_id, _timer.seconds());
+}
+}
 // Parallel remark task
-class CMSParRemarkTask: public AbstractGangTask {
+class CMSParRemarkTask: public CMSParMarkTask {
-CMSCollector* _collector;
-int           _n_workers;
 CompactibleFreeListSpace* _cms_space;
 // The per-thread work queues, available here for stealing.
 OopTaskQueueSet*       _task_queues;
 ParallelTaskTerminator _term;
 // workers to be taken from the active workers in the work gang.
 CMSParRemarkTask(CMSCollector* collector,
 CompactibleFreeListSpace* cms_space,
 int n_workers, FlexibleWorkGang* workers,
 OopTaskQueueSet* task_queues):
-AbstractGangTask("Rescan roots and grey objects in parallel"),
+CMSParMarkTask("Rescan roots and grey objects in parallel",
-_collector(collector),
+collector, n_workers),
 _cms_space(cms_space),
-_n_workers(n_workers),
 _task_queues(task_queues),
 _term(n_workers, task_queues) { }
 OopTaskQueueSet* task_queues() { return _task_queues; }
 int n_workers() { return _n_workers; }
 void work(uint worker_id);
 private:
-// Work method in support of parallel rescan ... of young gen spaces
-void do_young_space_rescan(int i, Par_MarkRefsIntoAndScanClosure* cl,
-ContiguousSpace* space,
-HeapWord** chunk_array, size_t chunk_top);
 // ... of  dirty cards in old space
 void do_dirty_card_rescan_tasks(CompactibleFreeListSpace* sp, int i,
 Par_MarkRefsIntoAndScanClosure* cl);
 // ... work stealing for the above
 // The klass has modified fields, need to scan the klass.
 _cm_klass_closure.do_klass(k);
 }
 };
+void CMSParMarkTask::work_on_young_gen_roots(uint worker_id, OopsInGenClosure* cl) {
+DefNewGeneration* dng = _collector->_young_gen->as_DefNewGeneration();
+EdenSpace* eden_space = dng->eden();
+ContiguousSpace* from_space = dng->from();
+ContiguousSpace* to_space   = dng->to();
+HeapWord** eca = _collector->_eden_chunk_array;
+size_t     ect = _collector->_eden_chunk_index;
+HeapWord** sca = _collector->_survivor_chunk_array;
+size_t     sct = _collector->_survivor_chunk_index;
+assert(ect <= _collector->_eden_chunk_capacity, "out of bounds");
+assert(sct <= _collector->_survivor_chunk_capacity, "out of bounds");
+do_young_space_rescan(worker_id, cl, to_space, NULL, 0);
+do_young_space_rescan(worker_id, cl, from_space, sca, sct);
+do_young_space_rescan(worker_id, cl, eden_space, eca, ect);
+}
 // work_queue(i) is passed to the closure
 // Par_MarkRefsIntoAndScanClosure.  The "i" parameter
 // also is passed to do_dirty_card_rescan_tasks() and to
 // do_work_steal() to select the i-th task_queue.
 // coarsely partitioned and may, on that account, constitute
 // the critical path; thus, it's best to start off that
 // work first.
 // ---------- young gen roots --------------
 {
-DefNewGeneration* dng = _collector->_young_gen->as_DefNewGeneration();
+work_on_young_gen_roots(worker_id, &par_mrias_cl);
-EdenSpace* eden_space = dng->eden();
-ContiguousSpace* from_space = dng->from();
-ContiguousSpace* to_space   = dng->to();
-HeapWord** eca = _collector->_eden_chunk_array;
-size_t     ect = _collector->_eden_chunk_index;
-HeapWord** sca = _collector->_survivor_chunk_array;
-size_t     sct = _collector->_survivor_chunk_index;
-assert(ect <= _collector->_eden_chunk_capacity, "out of bounds");
-assert(sct <= _collector->_survivor_chunk_capacity, "out of bounds");
-do_young_space_rescan(worker_id, &par_mrias_cl, to_space, NULL, 0);
-do_young_space_rescan(worker_id, &par_mrias_cl, from_space, sca, sct);
-do_young_space_rescan(worker_id, &par_mrias_cl, eden_space, eca, ect);
 _timer.stop();
 if (PrintCMSStatistics != 0) {
 gclog_or_tty->print_cr(
 "Finished young gen rescan work in %dth thread: %3.3f sec",
 worker_id, _timer.seconds());
 }
 }
 // Note that parameter "i" is not used.
 void
-CMSParRemarkTask::do_young_space_rescan(int i,
+CMSParMarkTask::do_young_space_rescan(uint worker_id,
-Par_MarkRefsIntoAndScanClosure* cl, ContiguousSpace* space,
+OopsInGenClosure* cl, ContiguousSpace* space,
 HeapWord** chunk_array, size_t chunk_top) {
 // Until all tasks completed:
 // . claim an unclaimed task
 // . compute region boundaries corresponding to task claimed
 //   using chunk_array
 }
 }
 // Merge the per-thread plab arrays into the global survivor chunk
 // array which will provide the partitioning of the survivor space
-// for CMS rescan.
+// for CMS initial scan and rescan.
 void CMSCollector::merge_survivor_plab_arrays(ContiguousSpace* surv,
 int no_of_gc_threads) {
 assert(_survivor_plab_array  != NULL, "Error");
 assert(_survivor_chunk_array != NULL, "Error");
-assert(_collectorState == FinalMarking, "Error");
+assert(_collectorState == FinalMarking ||
+(CMSParallelInitialMarkEnabled && _collectorState == InitialMarking), "Error");
 for (int j = 0; j < no_of_gc_threads; j++) {
 _cursor[j] = 0;
 }
 HeapWord* top = surv->top();
 size_t i;
 }
 #endif // ASSERT
 }
 // Set up the space's par_seq_tasks structure for work claiming
-// for parallel rescan of young gen.
+// for parallel initial scan and rescan of young gen.
 // See ParRescanTask where this is currently used.
 void
 CMSCollector::
 initialize_sequential_subtasks_for_young_gen_rescan(int n_threads) {
 assert(n_threads > 0, "Unexpected n_threads argument");
 }
 }
 void MarkRefsIntoClosure::do_oop(oop* p)       { MarkRefsIntoClosure::do_oop_work(p); }
 void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
+Par_MarkRefsIntoClosure::Par_MarkRefsIntoClosure(
+MemRegion span, CMSBitMap* bitMap):
+_span(span),
+_bitMap(bitMap)
+{
+assert(_ref_processor == NULL, "deliberately left NULL");
+assert(_bitMap->covers(_span), "_bitMap/_span mismatch");
+}
+void Par_MarkRefsIntoClosure::do_oop(oop obj) {
+// if p points into _span, then mark corresponding bit in _markBitMap
+assert(obj->is_oop(), "expected an oop");
+HeapWord* addr = (HeapWord*)obj;
+if (_span.contains(addr)) {
+// this should be made more efficient
+_bitMap->par_mark(addr);
+}
+}
+void Par_MarkRefsIntoClosure::do_oop(oop* p)       { Par_MarkRefsIntoClosure::do_oop_work(p); }
+void Par_MarkRefsIntoClosure::do_oop(narrowOop* p) { Par_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):
 _span(span),
 assert(chunk_at_end->end() == (uintptr_t*) _cmsSpace->end(),
 "Shrinking is inconsistent");
 return;
 }
 }
 // Transfer some number of overflown objects to usual marking
 // stack. Return true if some objects were transferred.
 bool MarkRefsIntoAndScanClosure::take_from_overflow_list() {
 size_t num = MIN2((size_t)(_mark_stack->capacity() - _mark_stack->length())/4,
 (size_t)ParGCDesiredObjsFromOverflowList);

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 11975:ca9dedeebdec