< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp

Print this page

  1 /*
  2  * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved.

  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #include "precompiled.hpp"
 26 
 27 #include "gc/shared/satbMarkQueue.hpp"
 28 #include "gc/shared/strongRootsScope.hpp"
 29 #include "gc/shared/taskTerminator.hpp"
 30 #include "gc/shenandoah/shenandoahBarrierSet.inline.hpp"
 31 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 32 #include "gc/shenandoah/shenandoahConcurrentMark.hpp"

 33 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 34 #include "gc/shenandoah/shenandoahMark.inline.hpp"
 35 #include "gc/shenandoah/shenandoahReferenceProcessor.hpp"
 36 #include "gc/shenandoah/shenandoahRootProcessor.inline.hpp"
 37 #include "gc/shenandoah/shenandoahOopClosures.inline.hpp"
 38 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
 39 #include "gc/shenandoah/shenandoahStringDedup.hpp"
 40 #include "gc/shenandoah/shenandoahTaskqueue.inline.hpp"
 41 #include "gc/shenandoah/shenandoahUtils.hpp"

 42 #include "memory/iterator.inline.hpp"
 43 #include "memory/resourceArea.hpp"
 44 #include "runtime/continuation.hpp"
 45 #include "runtime/threads.hpp"
 46 

 47 class ShenandoahConcurrentMarkingTask : public WorkerTask {
 48 private:
 49   ShenandoahConcurrentMark* const _cm;
 50   TaskTerminator* const           _terminator;
 51 
 52 public:
 53   ShenandoahConcurrentMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator) :
 54     WorkerTask("Shenandoah Concurrent Mark"), _cm(cm), _terminator(terminator) {
 55   }
 56 
 57   void work(uint worker_id) {
 58     ShenandoahHeap* heap = ShenandoahHeap::heap();
 59     ShenandoahConcurrentWorkerSession worker_session(worker_id);

 60     ShenandoahSuspendibleThreadSetJoiner stsj;
 61     ShenandoahReferenceProcessor* rp = heap->ref_processor();




 62     assert(rp != nullptr, "need reference processor");
 63     StringDedup::Requests requests;
 64     _cm->mark_loop(worker_id, _terminator, rp,
 65                    true /*cancellable*/,
 66                    ShenandoahStringDedup::is_enabled() ? ENQUEUE_DEDUP : NO_DEDUP,
 67                    &requests);
 68   }
 69 };
 70 
 71 class ShenandoahSATBAndRemarkThreadsClosure : public ThreadClosure {
 72 private:
 73   SATBMarkQueueSet& _satb_qset;
 74   OopClosure* const _cl;
 75 
 76 public:
 77   ShenandoahSATBAndRemarkThreadsClosure(SATBMarkQueueSet& satb_qset, OopClosure* cl) :
 78     _satb_qset(satb_qset),
 79     _cl(cl)  {}
 80 
 81   void do_thread(Thread* thread) {
 82     // Transfer any partial buffer to the qset for completed buffer processing.
 83     _satb_qset.flush_queue(ShenandoahThreadLocalData::satb_mark_queue(thread));
 84     if (thread->is_Java_thread()) {
 85       if (_cl != nullptr) {
 86         ResourceMark rm;
 87         thread->oops_do(_cl, nullptr);
 88       }
 89     }
 90   }
 91 };
 92 

 93 class ShenandoahFinalMarkingTask : public WorkerTask {
 94 private:
 95   ShenandoahConcurrentMark* _cm;
 96   TaskTerminator*           _terminator;
 97   bool                      _dedup_string;
 98 
 99 public:
100   ShenandoahFinalMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator, bool dedup_string) :
101     WorkerTask("Shenandoah Final Mark"), _cm(cm), _terminator(terminator), _dedup_string(dedup_string) {
102   }
103 
104   void work(uint worker_id) {
105     ShenandoahHeap* heap = ShenandoahHeap::heap();
106 
107     ShenandoahParallelWorkerSession worker_session(worker_id);
108     ShenandoahReferenceProcessor* rp = heap->ref_processor();
109     StringDedup::Requests requests;


110 
111     // First drain remaining SATB buffers.
112     {
113       ShenandoahObjToScanQueue* q = _cm->get_queue(worker_id);

114 
115       ShenandoahSATBBufferClosure cl(q);
116       SATBMarkQueueSet& satb_mq_set = ShenandoahBarrierSet::satb_mark_queue_set();
117       while (satb_mq_set.apply_closure_to_completed_buffer(&cl)) {}
118       assert(!heap->has_forwarded_objects(), "Not expected");
119 
120       ShenandoahMarkRefsClosure             mark_cl(q, rp);
121       ShenandoahSATBAndRemarkThreadsClosure tc(satb_mq_set,
122                                                ShenandoahIUBarrier ? &mark_cl : nullptr);
123       Threads::possibly_parallel_threads_do(true /* is_par */, &tc);
124     }
125     _cm->mark_loop(worker_id, _terminator, rp,
126                    false /*not cancellable*/,
127                    _dedup_string ? ENQUEUE_DEDUP : NO_DEDUP,
128                    &requests);
129     assert(_cm->task_queues()->is_empty(), "Should be empty");
130   }
131 };
132 
133 ShenandoahConcurrentMark::ShenandoahConcurrentMark() :
134   ShenandoahMark() {}
135 
136 // Mark concurrent roots during concurrent phases

137 class ShenandoahMarkConcurrentRootsTask : public WorkerTask {
138 private:
139   SuspendibleThreadSetJoiner          _sts_joiner;
140   ShenandoahConcurrentRootScanner     _root_scanner;
141   ShenandoahObjToScanQueueSet* const  _queue_set;

142   ShenandoahReferenceProcessor* const _rp;
143 
144 public:
145   ShenandoahMarkConcurrentRootsTask(ShenandoahObjToScanQueueSet* qs,

146                                     ShenandoahReferenceProcessor* rp,
147                                     ShenandoahPhaseTimings::Phase phase,
148                                     uint nworkers);
149   void work(uint worker_id);
150 };
151 
152 ShenandoahMarkConcurrentRootsTask::ShenandoahMarkConcurrentRootsTask(ShenandoahObjToScanQueueSet* qs,
153                                                                      ShenandoahReferenceProcessor* rp,
154                                                                      ShenandoahPhaseTimings::Phase phase,
155                                                                      uint nworkers) :


156   WorkerTask("Shenandoah Concurrent Mark Roots"),
157   _root_scanner(nworkers, phase),
158   _queue_set(qs),

159   _rp(rp) {
160   assert(!ShenandoahHeap::heap()->has_forwarded_objects(), "Not expected");
161 }
162 
163 void ShenandoahMarkConcurrentRootsTask::work(uint worker_id) {

164   ShenandoahConcurrentWorkerSession worker_session(worker_id);
165   ShenandoahObjToScanQueue* q = _queue_set->queue(worker_id);
166   ShenandoahMarkRefsClosure cl(q, _rp);


167   _root_scanner.roots_do(&cl, worker_id);
168 }
169 
170 void ShenandoahConcurrentMark::mark_concurrent_roots() {
171   ShenandoahHeap* const heap = ShenandoahHeap::heap();
172   assert(!heap->has_forwarded_objects(), "Not expected");
173 
174   TASKQUEUE_STATS_ONLY(task_queues()->reset_taskqueue_stats());
175 
176   WorkerThreads* workers = heap->workers();
177   ShenandoahReferenceProcessor* rp = heap->ref_processor();
178   task_queues()->reserve(workers->active_workers());
179   ShenandoahMarkConcurrentRootsTask task(task_queues(), rp, ShenandoahPhaseTimings::conc_mark_roots, workers->active_workers());
180 
181   workers->run_task(&task);
182 }
183 
184 class ShenandoahFlushSATBHandshakeClosure : public HandshakeClosure {
185 private:
186   SATBMarkQueueSet& _qset;
187 public:
188   ShenandoahFlushSATBHandshakeClosure(SATBMarkQueueSet& qset) :
189     HandshakeClosure("Shenandoah Flush SATB Handshake"),
190     _qset(qset) {}
191 
192   void do_thread(Thread* thread) {
193     _qset.flush_queue(ShenandoahThreadLocalData::satb_mark_queue(thread));













194   }
195 };
196 
197 void ShenandoahConcurrentMark::concurrent_mark() {
198   ShenandoahHeap* const heap = ShenandoahHeap::heap();
199   WorkerThreads* workers = heap->workers();
200   uint nworkers = workers->active_workers();
201   task_queues()->reserve(nworkers);
202 

203   ShenandoahSATBMarkQueueSet& qset = ShenandoahBarrierSet::satb_mark_queue_set();
204   ShenandoahFlushSATBHandshakeClosure flush_satb(qset);
205   for (uint flushes = 0; flushes < ShenandoahMaxSATBBufferFlushes; flushes++) {
206     TaskTerminator terminator(nworkers, task_queues());
207     ShenandoahConcurrentMarkingTask task(this, &terminator);
208     workers->run_task(&task);

























209 
210     if (heap->cancelled_gc()) {
211       // GC is cancelled, break out.
212       break;
213     }
214 
215     size_t before = qset.completed_buffers_num();
216     Handshake::execute(&flush_satb);



217     size_t after = qset.completed_buffers_num();
218 
219     if (before == after) {
220       // No more retries needed, break out.
221       break;
222     }
223   }
224   assert(task_queues()->is_empty() || heap->cancelled_gc(), "Should be empty when not cancelled");
225 }
226 
227 void ShenandoahConcurrentMark::finish_mark() {
228   assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at a safepoint");
229   assert(Thread::current()->is_VM_thread(), "Must by VM Thread");
230   finish_mark_work();
231   assert(task_queues()->is_empty(), "Should be empty");
232   TASKQUEUE_STATS_ONLY(task_queues()->print_taskqueue_stats());
233   TASKQUEUE_STATS_ONLY(task_queues()->reset_taskqueue_stats());
234 
235   ShenandoahHeap* const heap = ShenandoahHeap::heap();
236   heap->set_concurrent_mark_in_progress(false);
237   heap->mark_complete_marking_context();
238 
239   end_mark();
240 }
241 
242 void ShenandoahConcurrentMark::finish_mark_work() {
243   // Finally mark everything else we've got in our queues during the previous steps.
244   // It does two different things for concurrent vs. mark-compact GC:
245   // - For concurrent GC, it starts with empty task queues, drains the remaining
246   //   SATB buffers, and then completes the marking closure.
247   // - For mark-compact GC, it starts out with the task queues seeded by initial
248   //   root scan, and completes the closure, thus marking through all live objects
249   // The implementation is the same, so it's shared here.
250   ShenandoahHeap* const heap = ShenandoahHeap::heap();
251   ShenandoahGCPhase phase(ShenandoahPhaseTimings::finish_mark);
252   uint nworkers = heap->workers()->active_workers();
253   task_queues()->reserve(nworkers);
254 
255   StrongRootsScope scope(nworkers);
256   TaskTerminator terminator(nworkers, task_queues());
257   ShenandoahFinalMarkingTask task(this, &terminator, ShenandoahStringDedup::is_enabled());
258   heap->workers()->run_task(&task);
259 
260   assert(task_queues()->is_empty(), "Should be empty");
261 }






















262 
263 
264 void ShenandoahConcurrentMark::cancel() {
265   clear();
266   ShenandoahReferenceProcessor* rp = ShenandoahHeap::heap()->ref_processor();
267   rp->abandon_partial_discovery();
268 }

  1 /*
  2  * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved.
  3  * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  *
 24  */
 25 
 26 #include "precompiled.hpp"
 27 
 28 #include "gc/shared/satbMarkQueue.hpp"
 29 #include "gc/shared/strongRootsScope.hpp"
 30 #include "gc/shared/taskTerminator.hpp"
 31 #include "gc/shenandoah/shenandoahBarrierSet.inline.hpp"
 32 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 33 #include "gc/shenandoah/shenandoahConcurrentMark.hpp"
 34 #include "gc/shenandoah/shenandoahGeneration.hpp"
 35 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 36 #include "gc/shenandoah/shenandoahMark.inline.hpp"
 37 #include "gc/shenandoah/shenandoahReferenceProcessor.hpp"
 38 #include "gc/shenandoah/shenandoahRootProcessor.inline.hpp"
 39 #include "gc/shenandoah/shenandoahOopClosures.inline.hpp"
 40 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
 41 #include "gc/shenandoah/shenandoahStringDedup.hpp"
 42 #include "gc/shenandoah/shenandoahTaskqueue.inline.hpp"
 43 #include "gc/shenandoah/shenandoahUtils.hpp"
 44 #include "gc/shenandoah/shenandoahScanRemembered.inline.hpp"
 45 #include "memory/iterator.inline.hpp"
 46 #include "memory/resourceArea.hpp"
 47 #include "runtime/continuation.hpp"
 48 #include "runtime/threads.hpp"
 49 
 50 template <ShenandoahGenerationType GENERATION>
 51 class ShenandoahConcurrentMarkingTask : public WorkerTask {
 52 private:
 53   ShenandoahConcurrentMark* const _cm;
 54   TaskTerminator* const           _terminator;
 55 
 56 public:
 57   ShenandoahConcurrentMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator) :
 58     WorkerTask("Shenandoah Concurrent Mark"), _cm(cm), _terminator(terminator) {
 59   }
 60 
 61   void work(uint worker_id) {
 62     ShenandoahHeap* heap = ShenandoahHeap::heap();
 63     ShenandoahConcurrentWorkerSession worker_session(worker_id);
 64     ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::conc_mark, ShenandoahPhaseTimings::ParallelMark, worker_id, true);
 65     ShenandoahSuspendibleThreadSetJoiner stsj;
 66     // Do not use active_generation() : we must use the gc_generation() set by
 67     // ShenandoahGCScope on the ControllerThread's stack; no safepoint may
 68     // intervene to update active_generation, so we can't
 69     // shenandoah_assert_generations_reconciled() here.
 70     ShenandoahReferenceProcessor* rp = heap->gc_generation()->ref_processor();
 71     assert(rp != nullptr, "need reference processor");
 72     StringDedup::Requests requests;
 73     _cm->mark_loop(worker_id, _terminator, rp, GENERATION, true /*cancellable*/,

 74                    ShenandoahStringDedup::is_enabled() ? ENQUEUE_DEDUP : NO_DEDUP,
 75                    &requests);
 76   }
 77 };
 78 
 79 class ShenandoahSATBAndRemarkThreadsClosure : public ThreadClosure {
 80 private:
 81   SATBMarkQueueSet& _satb_qset;

 82 
 83 public:
 84   explicit ShenandoahSATBAndRemarkThreadsClosure(SATBMarkQueueSet& satb_qset) :
 85     _satb_qset(satb_qset) {}

 86 
 87   void do_thread(Thread* thread) override {
 88     // Transfer any partial buffer to the qset for completed buffer processing.
 89     _satb_qset.flush_queue(ShenandoahThreadLocalData::satb_mark_queue(thread));






 90   }
 91 };
 92 
 93 template <ShenandoahGenerationType GENERATION>
 94 class ShenandoahFinalMarkingTask : public WorkerTask {
 95 private:
 96   ShenandoahConcurrentMark* _cm;
 97   TaskTerminator*           _terminator;
 98   bool                      _dedup_string;
 99 
100 public:
101   ShenandoahFinalMarkingTask(ShenandoahConcurrentMark* cm, TaskTerminator* terminator, bool dedup_string) :
102     WorkerTask("Shenandoah Final Mark"), _cm(cm), _terminator(terminator), _dedup_string(dedup_string) {
103   }
104 
105   void work(uint worker_id) {
106     ShenandoahHeap* heap = ShenandoahHeap::heap();
107 
108     ShenandoahParallelWorkerSession worker_session(worker_id);

109     StringDedup::Requests requests;
110     ShenandoahReferenceProcessor* rp = heap->gc_generation()->ref_processor();
111     shenandoah_assert_generations_reconciled();
112 
113     // First drain remaining SATB buffers.
114     {
115       ShenandoahObjToScanQueue* q = _cm->get_queue(worker_id);
116       ShenandoahObjToScanQueue* old_q = _cm->get_old_queue(worker_id);
117 
118       ShenandoahSATBBufferClosure<GENERATION> cl(q, old_q);
119       SATBMarkQueueSet& satb_mq_set = ShenandoahBarrierSet::satb_mark_queue_set();
120       while (satb_mq_set.apply_closure_to_completed_buffer(&cl)) {}
121       assert(!heap->has_forwarded_objects(), "Not expected");
122 
123       ShenandoahSATBAndRemarkThreadsClosure tc(satb_mq_set);


124       Threads::possibly_parallel_threads_do(true /* is_par */, &tc);
125     }
126     _cm->mark_loop(worker_id, _terminator, rp, GENERATION, false /*not cancellable*/,

127                    _dedup_string ? ENQUEUE_DEDUP : NO_DEDUP,
128                    &requests);
129     assert(_cm->task_queues()->is_empty(), "Should be empty");
130   }
131 };
132 
133 ShenandoahConcurrentMark::ShenandoahConcurrentMark(ShenandoahGeneration* generation) :
134   ShenandoahMark(generation) {}
135 
136 // Mark concurrent roots during concurrent phases
137 template <ShenandoahGenerationType GENERATION>
138 class ShenandoahMarkConcurrentRootsTask : public WorkerTask {
139 private:
140   SuspendibleThreadSetJoiner          _sts_joiner;
141   ShenandoahConcurrentRootScanner     _root_scanner;
142   ShenandoahObjToScanQueueSet* const  _queue_set;
143   ShenandoahObjToScanQueueSet* const  _old_queue_set;
144   ShenandoahReferenceProcessor* const _rp;
145 
146 public:
147   ShenandoahMarkConcurrentRootsTask(ShenandoahObjToScanQueueSet* qs,
148                                     ShenandoahObjToScanQueueSet* old,
149                                     ShenandoahReferenceProcessor* rp,
150                                     ShenandoahPhaseTimings::Phase phase,
151                                     uint nworkers);
152   void work(uint worker_id);
153 };
154 
155 template <ShenandoahGenerationType GENERATION>
156 ShenandoahMarkConcurrentRootsTask<GENERATION>::ShenandoahMarkConcurrentRootsTask(ShenandoahObjToScanQueueSet* qs,
157                                                                                  ShenandoahObjToScanQueueSet* old,
158                                                                                  ShenandoahReferenceProcessor* rp,
159                                                                                  ShenandoahPhaseTimings::Phase phase,
160                                                                                  uint nworkers) :
161   WorkerTask("Shenandoah Concurrent Mark Roots"),
162   _root_scanner(nworkers, phase),
163   _queue_set(qs),
164   _old_queue_set(old),
165   _rp(rp) {
166   assert(!ShenandoahHeap::heap()->has_forwarded_objects(), "Not expected");
167 }
168 
169 template <ShenandoahGenerationType GENERATION>
170 void ShenandoahMarkConcurrentRootsTask<GENERATION>::work(uint worker_id) {
171   ShenandoahConcurrentWorkerSession worker_session(worker_id);
172   ShenandoahObjToScanQueue* q = _queue_set->queue(worker_id);
173   ShenandoahObjToScanQueue* old_q = (_old_queue_set == nullptr) ?
174           nullptr : _old_queue_set->queue(worker_id);
175   ShenandoahMarkRefsClosure<GENERATION> cl(q, _rp, old_q);
176   _root_scanner.roots_do(&cl, worker_id);
177 }
178 
179 void ShenandoahConcurrentMark::mark_concurrent_roots() {
180   ShenandoahHeap* const heap = ShenandoahHeap::heap();
181   assert(!heap->has_forwarded_objects(), "Not expected");
182 


183   WorkerThreads* workers = heap->workers();
184   ShenandoahReferenceProcessor* rp = _generation->ref_processor();
185   _generation->reserve_task_queues(workers->active_workers());
186   switch (_generation->type()) {
187     case YOUNG: {
188       ShenandoahMarkConcurrentRootsTask<YOUNG> task(task_queues(), old_task_queues(), rp,
189                                                     ShenandoahPhaseTimings::conc_mark_roots, workers->active_workers());
190       workers->run_task(&task);
191       break;
192     }
193     case GLOBAL: {
194       assert(old_task_queues() == nullptr, "Global mark should not have old gen mark queues");
195       ShenandoahMarkConcurrentRootsTask<GLOBAL> task(task_queues(), nullptr, rp,
196                                                      ShenandoahPhaseTimings::conc_mark_roots, workers->active_workers());
197       workers->run_task(&task);
198       break;
199     }
200     case NON_GEN: {
201       assert(old_task_queues() == nullptr, "Non-generational mark should not have old gen mark queues");
202       ShenandoahMarkConcurrentRootsTask<NON_GEN> task(task_queues(), nullptr, rp,
203                                                       ShenandoahPhaseTimings::conc_mark_roots, workers->active_workers());
204       workers->run_task(&task);
205       break;
206     }
207     case OLD: {
208       // We use a YOUNG generation cycle to bootstrap concurrent old marking.
209       ShouldNotReachHere();
210       break;
211     }
212     default:
213       ShouldNotReachHere();
214   }
215 }
216 
217 void ShenandoahConcurrentMark::concurrent_mark() {
218   ShenandoahHeap* const heap = ShenandoahHeap::heap();
219   WorkerThreads* workers = heap->workers();
220   uint nworkers = workers->active_workers();
221   task_queues()->reserve(nworkers);
222 
223   ShenandoahGenerationType gen_type = _generation->type();
224   ShenandoahSATBMarkQueueSet& qset = ShenandoahBarrierSet::satb_mark_queue_set();
225   ShenandoahFlushSATBHandshakeClosure flush_satb(qset);
226   for (uint flushes = 0; flushes < ShenandoahMaxSATBBufferFlushes; flushes++) {
227     switch (gen_type) {
228       case YOUNG: {
229         TaskTerminator terminator(nworkers, task_queues());
230         ShenandoahConcurrentMarkingTask<YOUNG> task(this, &terminator);
231         workers->run_task(&task);
232         break;
233       }
234       case OLD: {
235         TaskTerminator terminator(nworkers, task_queues());
236         ShenandoahConcurrentMarkingTask<OLD> task(this, &terminator);
237         workers->run_task(&task);
238         break;
239       }
240       case GLOBAL: {
241         TaskTerminator terminator(nworkers, task_queues());
242         ShenandoahConcurrentMarkingTask<GLOBAL> task(this, &terminator);
243         workers->run_task(&task);
244         break;
245       }
246       case NON_GEN: {
247         TaskTerminator terminator(nworkers, task_queues());
248         ShenandoahConcurrentMarkingTask<NON_GEN> task(this, &terminator);
249         workers->run_task(&task);
250         break;
251       }
252       default:
253         ShouldNotReachHere();
254     }
255 
256     if (heap->cancelled_gc()) {
257       // GC is cancelled, break out.
258       break;
259     }
260 
261     size_t before = qset.completed_buffers_num();
262     {
263       ShenandoahTimingsTracker t(ShenandoahPhaseTimings::conc_mark_satb_flush, true);
264       Handshake::execute(&flush_satb);
265     }
266     size_t after = qset.completed_buffers_num();
267 
268     if (before == after) {
269       // No more retries needed, break out.
270       break;
271     }
272   }
273   assert(task_queues()->is_empty() || heap->cancelled_gc(), "Should be empty when not cancelled");
274 }
275 
276 void ShenandoahConcurrentMark::finish_mark() {
277   assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at a safepoint");
278   assert(Thread::current()->is_VM_thread(), "Must by VM Thread");
279   finish_mark_work();
280   assert(task_queues()->is_empty(), "Should be empty");
281   TASKQUEUE_STATS_ONLY(task_queues()->print_and_reset_taskqueue_stats(""));

282 
283   _generation->set_concurrent_mark_in_progress(false);
284   _generation->set_mark_complete();

285 
286   end_mark();
287 }
288 
289 void ShenandoahConcurrentMark::finish_mark_work() {
290   // Finally mark everything else we've got in our queues during the previous steps.
291   // It does two different things for concurrent vs. mark-compact GC:
292   // - For concurrent GC, it starts with empty task queues, drains the remaining
293   //   SATB buffers, and then completes the marking closure.
294   // - For mark-compact GC, it starts out with the task queues seeded by initial
295   //   root scan, and completes the closure, thus marking through all live objects
296   // The implementation is the same, so it's shared here.
297   ShenandoahHeap* const heap = ShenandoahHeap::heap();
298   ShenandoahGCPhase phase(ShenandoahPhaseTimings::finish_mark);
299   uint nworkers = heap->workers()->active_workers();
300   task_queues()->reserve(nworkers);
301 
302   StrongRootsScope scope(nworkers);
303   TaskTerminator terminator(nworkers, task_queues());


304 
305   switch (_generation->type()) {
306     case YOUNG:{
307       ShenandoahFinalMarkingTask<YOUNG> task(this, &terminator, ShenandoahStringDedup::is_enabled());
308       heap->workers()->run_task(&task);
309       break;
310     }
311     case OLD:{
312       ShenandoahFinalMarkingTask<OLD> task(this, &terminator, ShenandoahStringDedup::is_enabled());
313       heap->workers()->run_task(&task);
314       break;
315     }
316     case GLOBAL:{
317       ShenandoahFinalMarkingTask<GLOBAL> task(this, &terminator, ShenandoahStringDedup::is_enabled());
318       heap->workers()->run_task(&task);
319       break;
320     }
321     case NON_GEN:{
322       ShenandoahFinalMarkingTask<NON_GEN> task(this, &terminator, ShenandoahStringDedup::is_enabled());
323       heap->workers()->run_task(&task);
324       break;
325     }
326     default:
327       ShouldNotReachHere();
328   }
329 
330 
331   assert(task_queues()->is_empty(), "Should be empty");



332 }
< prev index next >