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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 1837:c99c53f07c14

6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time Summary: Inserted missing yield(check)s in closures used during the work-stealing phase of parallel concurrent marking, a missing synchronous yield-request in the cms perm gen allocation path, and a terminator-terminator for the offer_termination invocation that monitors the yield status of the concurrent marking task. Elaborated some documentation comments and made some task queue termination loop flags configurable at start-up to aid debugging in the field. Reviewed-by: jmasa, johnc, poonam

author	ysr
date	Wed, 29 Sep 2010 16:17:02 -0700
parents	894b1d7c7e01
children	a7214d79fcf1

comparison

equal deleted inserted replaced

-:894b1d7c7e01
+:c99c53f07c14
 HeapWord*
 ConcurrentMarkSweepGeneration::expand_and_allocate(size_t word_size,
 bool   tlab,
 bool   parallel) {
+CMSSynchronousYieldRequest yr;
 assert(!tlab, "Can't deal with TLAB allocation");
 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
 expand(word_size*HeapWordSize, MinHeapDeltaBytes,
 CMSExpansionCause::_satisfy_allocation);
 if (GCExpandToAllocateDelayMillis > 0) {
 class CMSConcMarkingTask;
 class CMSConcMarkingTerminator: public ParallelTaskTerminator {
 CMSCollector*       _collector;
 CMSConcMarkingTask* _task;
-bool _yield;
+public:
-protected:
 virtual void yield();
-public:
 // "n_threads" is the number of threads to be terminated.
 // "queue_set" is a set of work queues of other threads.
 // "collector" is the CMS collector associated with this task terminator.
 // "yield" indicates whether we need the gang as a whole to yield.
-CMSConcMarkingTerminator(int n_threads, TaskQueueSetSuper* queue_set,
+CMSConcMarkingTerminator(int n_threads, TaskQueueSetSuper* queue_set, CMSCollector* collector) :
-CMSCollector* collector, bool yield) :
 ParallelTaskTerminator(n_threads, queue_set),
-_collector(collector),
+_collector(collector) { }
-_yield(yield) { }
+void set_task(CMSConcMarkingTask* task) {
+_task = task;
+}
+};
+class CMSConcMarkingTerminatorTerminator: public TerminatorTerminator {
+CMSConcMarkingTask* _task;
+public:
+bool should_exit_termination();
 void set_task(CMSConcMarkingTask* task) {
 _task = task;
 }
 };
 int           _n_workers;                  // requested/desired # workers
 bool          _asynch;
 bool          _result;
 CompactibleFreeListSpace*  _cms_space;
 CompactibleFreeListSpace* _perm_space;
-HeapWord*     _global_finger;
+char          _pad_front[64];   // padding to ...
+HeapWord*     _global_finger;   // ... avoid sharing cache line
+char          _pad_back[64];
 HeapWord*     _restart_addr;
 //  Exposed here for yielding support
 Mutex* const _bit_map_lock;
 // The per thread work queues, available here for stealing
 OopTaskQueueSet*  _task_queues;
+// Termination (and yielding) support
 CMSConcMarkingTerminator _term;
+CMSConcMarkingTerminatorTerminator _term_term;
 public:
 CMSConcMarkingTask(CMSCollector* collector,
 CompactibleFreeListSpace* cms_space,
 CompactibleFreeListSpace* perm_space,
 _collector(collector),
 _cms_space(cms_space),
 _perm_space(perm_space),
 _asynch(asynch), _n_workers(0), _result(true),
 _task_queues(task_queues),
-_term(_n_workers, task_queues, _collector, asynch),
+_term(_n_workers, task_queues, _collector),
 _bit_map_lock(collector->bitMapLock())
 {
 _requested_size = _n_workers;
 _term.set_task(this);
+_term_term.set_task(this);
 assert(_cms_space->bottom() < _perm_space->bottom(),
 "Finger incorrectly initialized below");
 _restart_addr = _global_finger = _cms_space->bottom();
 }
 virtual void set_for_termination(int active_workers) {
 terminator()->reset_for_reuse(active_workers);
 }
 void work(int i);
+bool should_yield() {
+return    ConcurrentMarkSweepThread::should_yield()
+&& !_collector->foregroundGCIsActive()
+&& _asynch;
+}
 virtual void coordinator_yield();  // stuff done by coordinator
 bool result() { return _result; }
 void reset(HeapWord* ra) {
 void do_scan_and_mark(int i, CompactibleFreeListSpace* sp);
 void do_work_steal(int i);
 void bump_global_finger(HeapWord* f);
 };
+bool CMSConcMarkingTerminatorTerminator::should_exit_termination() {
+assert(_task != NULL, "Error");
+return _task->yielding();
+// Note that we do not need the disjunct || _task->should_yield() above
+// because we want terminating threads to yield only if the task
+// is already in the midst of yielding, which happens only after at least one
+// thread has yielded.
+}
 void CMSConcMarkingTerminator::yield() {
-if (ConcurrentMarkSweepThread::should_yield() &&
+if (_task->should_yield()) {
-!_collector->foregroundGCIsActive() &&
-_yield) {
 _task->yield();
 } else {
 ParallelTaskTerminator::yield();
 }
 }
 pst->all_tasks_completed();
 }
 class Par_ConcMarkingClosure: public Par_KlassRememberingOopClosure {
 private:
+CMSConcMarkingTask* _task;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 CMSMarkStack* _overflow_stack;
 OopTaskQueue* _work_queue;
 protected:
 DO_OOP_WORK_DEFN
 public:
-Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue,
+Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack,
 CMSMarkStack* revisit_stack):
 Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
-_span(_collector->_span),
+_task(task),
+_span(collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 _overflow_stack(overflow_stack)
 { }
 virtual void do_oop(oop* p);
 virtual void do_oop(narrowOop* p);
 void trim_queue(size_t max);
 void handle_stack_overflow(HeapWord* lost);
+void do_yield_check() {
+if (_task->should_yield()) {
+_task->yield();
+}
+}
 };
 // Grey object scanning during work stealing phase --
 // the salient assumption here is that any references
 // that are in these stolen objects being scanned must
 _work_queue->size() == _work_queue->max_elems(),
 "Else push should have succeeded");
 handle_stack_overflow(addr);
 }
 } // Else, some other thread got there first
+do_yield_check();
 }
 }
 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); }
 assert(new_oop->is_oop(), "Should be an oop");
 assert(_bit_map->isMarked((HeapWord*)new_oop), "Grey object");
 assert(_span.contains((HeapWord*)new_oop), "Not in span");
 assert(new_oop->is_parsable(), "Should be parsable");
 new_oop->oop_iterate(this);  // do_oop() above
+do_yield_check();
 }
 }
 }
 // Upon stack overflow, we discard (part of) the stack,
 oop obj_to_scan;
 CMSBitMap* bm = &(_collector->_markBitMap);
 CMSMarkStack* ovflw = &(_collector->_markStack);
 CMSMarkStack* revisit = &(_collector->_revisitStack);
 int* seed = _collector->hash_seed(i);
-Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw, revisit);
+Par_ConcMarkingClosure cl(_collector, this, work_q, bm, ovflw, revisit);
 while (true) {
 cl.trim_queue(0);
 assert(work_q->size() == 0, "Should have been emptied above");
 if (get_work_from_overflow_stack(ovflw, work_q)) {
 // Can't assert below because the work obtained from the
 continue;
 } else if (task_queues()->steal(i, seed, /* reference */ obj_to_scan)) {
 assert(obj_to_scan->is_oop(), "Should be an oop");
 assert(bm->isMarked((HeapWord*)obj_to_scan), "Grey object");
 obj_to_scan->oop_iterate(&cl);
-} else if (terminator()->offer_termination()) {
+} else if (terminator()->offer_termination(&_term_term)) {
 assert(work_q->size() == 0, "Impossible!");
 break;
+} else if (yielding() || should_yield()) {
+yield();
 }
 }
 }
 // This is run by the CMS (coordinator) thread.

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 1837:c99c53f07c14