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

equal deleted inserted replaced

-:d2f118d3f8e7
+:bec57b4a6d69
 #include "gc/shared/gcTraceTime.inline.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
 #include "gc/shared/genOopClosures.inline.hpp"
 #include "gc/shared/isGCActiveMark.hpp"
 #include "gc/shared/oopStorageParState.hpp"
+#include "gc/shared/owstTaskTerminator.hpp"
 #include "gc/shared/referencePolicy.hpp"
 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
 #include "gc/shared/space.inline.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 #include "gc/shared/taskqueue.inline.hpp"
 }
 // Forward decl
 class CMSConcMarkingTask;
-class CMSConcMarkingTerminator: public ParallelTaskTerminator {
+class CMSConcMarkingParallelTerminator: public ParallelTaskTerminator {
 CMSCollector*       _collector;
 CMSConcMarkingTask* _task;
 public:
 virtual void yield();
 // "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, CMSCollector* collector) :
+CMSConcMarkingParallelTerminator(int n_threads, TaskQueueSetSuper* queue_set, CMSCollector* collector) :
 ParallelTaskTerminator(n_threads, queue_set),
 _collector(collector) { }
 void set_task(CMSConcMarkingTask* task) {
 _task = task;
 }
+};
+class CMSConcMarkingOWSTTerminator: public OWSTTaskTerminator {
+CMSCollector*       _collector;
+CMSConcMarkingTask* _task;
+public:
+virtual void yield();
+// "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.
+CMSConcMarkingOWSTTerminator(int n_threads, TaskQueueSetSuper* queue_set, CMSCollector* collector) :
+OWSTTaskTerminator(n_threads, queue_set),
+_collector(collector) { }
+void set_task(CMSConcMarkingTask* task) {
+_task = task;
+}
+};
+class CMSConcMarkingTaskTerminator {
+private:
+ParallelTaskTerminator* _term;
+public:
+CMSConcMarkingTaskTerminator(int n_threads, TaskQueueSetSuper* queue_set, CMSCollector* collector) {
+if (UseOWSTTaskTerminator) {
+_term = new CMSConcMarkingOWSTTerminator(n_threads, queue_set, collector);
+} else {
+_term = new CMSConcMarkingParallelTerminator(n_threads, queue_set, collector);
+}
+}
+~CMSConcMarkingTaskTerminator() {
+assert(_term != NULL, "Must not be NULL");
+delete _term;
+}
+void set_task(CMSConcMarkingTask* task);
+ParallelTaskTerminator* terminator() const { return _term; }
 };
 class CMSConcMarkingTerminatorTerminator: public TerminatorTerminator {
 CMSConcMarkingTask* _task;
 public:
 // The per thread work queues, available here for stealing
 OopTaskQueueSet*  _task_queues;
 // Termination (and yielding) support
-CMSConcMarkingTerminator _term;
+CMSConcMarkingTaskTerminator       _term;
 CMSConcMarkingTerminatorTerminator _term_term;
 public:
 CMSConcMarkingTask(CMSCollector* collector,
 CompactibleFreeListSpace* cms_space,
 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); }
 HeapWord* volatile* global_finger_addr() { return &_global_finger; }
-CMSConcMarkingTerminator* terminator() { return &_term; }
+ParallelTaskTerminator* terminator() { return _term.terminator(); }
 virtual void set_for_termination(uint active_workers) {
 terminator()->reset_for_reuse(active_workers);
 }
 bool result() { return _result; }
 void reset(HeapWord* ra) {
 assert(_global_finger >= _cms_space->end(),  "Postcondition of ::work(i)");
 _restart_addr = _global_finger = ra;
-_term.reset_for_reuse();
+_term.terminator()->reset_for_reuse();
 }
 static bool get_work_from_overflow_stack(CMSMarkStack* ovflw_stk,
 OopTaskQueue* work_q);
 // 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() {
+void CMSConcMarkingParallelTerminator::yield() {
 if (_task->should_yield()) {
 _task->yield();
 } else {
 ParallelTaskTerminator::yield();
+}
+}
+void CMSConcMarkingOWSTTerminator::yield() {
+if (_task->should_yield()) {
+_task->yield();
+} else {
+OWSTTaskTerminator::yield();
+}
+}
+void CMSConcMarkingTaskTerminator::set_task(CMSConcMarkingTask* task) {
+if (UseOWSTTaskTerminator) {
+((CMSConcMarkingOWSTTerminator*)_term)->set_task(task);
+} else {
+((CMSConcMarkingParallelTerminator*)_term)->set_task(task);
 }
 }
 ////////////////////////////////////////////////////////////////
 // Concurrent Marking Algorithm Sketch
 class CMSParRemarkTask: public CMSParMarkTask {
 CompactibleFreeListSpace* _cms_space;
 // The per-thread work queues, available here for stealing.
 OopTaskQueueSet*       _task_queues;
-ParallelTaskTerminator _term;
+TaskTerminator         _term;
 StrongRootsScope*      _strong_roots_scope;
 public:
 // A value of 0 passed to n_workers will cause the number of
 // workers to be taken from the active workers in the work gang.
 OopTaskQueueSet* task_queues() { return _task_queues; }
 OopTaskQueue* work_queue(int i) { return task_queues()->queue(i); }
-ParallelTaskTerminator* terminator() { return &_term; }
+ParallelTaskTerminator* terminator() { return _term.terminator(); }
 uint n_workers() { return _n_workers; }
 void work(uint worker_id);
 private:
 ////////////////////////////////////////////////////////
 // Parallel Reference Processing Task Proxy Class
 ////////////////////////////////////////////////////////
 class AbstractGangTaskWOopQueues : public AbstractGangTask {
 OopTaskQueueSet*       _queues;
-ParallelTaskTerminator _terminator;
+TaskTerminator         _terminator;
 public:
 AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues, uint n_threads) :
 AbstractGangTask(name), _queues(queues), _terminator(n_threads, _queues) {}
-ParallelTaskTerminator* terminator() { return &_terminator; }
+ParallelTaskTerminator* terminator() { return _terminator.terminator(); }
 OopTaskQueueSet* queues() { return _queues; }
 };
 class CMSRefProcTaskProxy: public AbstractGangTaskWOopQueues {
 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;

changeset 52905	bec57b4a6d69
parent 52904	d2f118d3f8e7
child 53536	482109fae02b