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 #ifndef SHARE_VM_GC_CMS_PARNEWGENERATION_HPP
26 #define SHARE_VM_GC_CMS_PARNEWGENERATION_HPP
27
28 #include "gc/cms/parOopClosures.hpp"
29 #include "gc/serial/defNewGeneration.hpp"
30 #include "gc/shared/copyFailedInfo.hpp"
31 #include "gc/shared/gcTrace.hpp"
32 #include "gc/shared/plab.hpp"
33 #include "gc/shared/preservedMarks.hpp"
34 #include "gc/shared/taskqueue.hpp"
35 #include "memory/padded.hpp"
36
37 class ChunkArray;
38 class ParScanWithoutBarrierClosure;
39 class ParScanWithBarrierClosure;
40 class ParRootScanWithoutBarrierClosure;
41 class ParRootScanWithBarrierTwoGensClosure;
42 class ParEvacuateFollowersClosure;
43 class StrongRootsScope;
44
45 // It would be better if these types could be kept local to the .cpp file,
46 // but they must be here to allow ParScanClosure::do_oop_work to be defined
47 // in genOopClosures.inline.hpp.
48
49 typedef Padded<OopTaskQueue> ObjToScanQueue;
50 typedef GenericTaskQueueSet<ObjToScanQueue, mtGC> ObjToScanQueueSet;
51
52 class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
53 private:
54 ParScanWeakRefClosure* _par_cl;
55 protected:
56 template <class T> void do_oop_work(T* p);
57 public:
242 HeapWord* young_old_boundary,
243 ParScanThreadStateSet* state_set,
244 StrongRootsScope* strong_roots_scope);
245
246 HeapWord* young_old_boundary() { return _young_old_boundary; }
247
248 void work(uint worker_id);
249 };
250
251 class KeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
252 protected:
253 template <class T> void do_oop_work(T* p);
254 public:
255 KeepAliveClosure(ScanWeakRefClosure* cl);
256 virtual void do_oop(oop* p);
257 virtual void do_oop(narrowOop* p);
258 };
259
260 class EvacuateFollowersClosureGeneral: public VoidClosure {
261 private:
262 GenCollectedHeap* _gch;
263 OopsInGenClosure* _scan_cur_or_nonheap;
264 OopsInGenClosure* _scan_older;
265 public:
266 EvacuateFollowersClosureGeneral(GenCollectedHeap* gch,
267 OopsInGenClosure* cur,
268 OopsInGenClosure* older);
269 virtual void do_void();
270 };
271
272 // Closure for scanning ParNewGeneration.
273 // Same as ScanClosure, except does parallel GC barrier.
274 class ScanClosureWithParBarrier: public ScanClosure {
275 protected:
276 template <class T> void do_oop_work(T* p);
277 public:
278 ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier);
279 virtual void do_oop(oop* p);
280 virtual void do_oop(narrowOop* p);
281 };
282
283 // Implements AbstractRefProcTaskExecutor for ParNew.
284 class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
285 private:
286 ParNewGeneration& _young_gen;
319
320 // Desired size of survivor space plab's
321 PLABStats _plab_stats;
322
323 // A list of from-space images of to-be-scanned objects, threaded through
324 // klass-pointers (klass information already copied to the forwarded
325 // image.) Manipulated with CAS.
326 oopDesc* volatile _overflow_list;
327 NOT_PRODUCT(ssize_t _num_par_pushes;)
328
329 // This closure is used by the reference processor to filter out
330 // references to live referent.
331 DefNewGeneration::IsAliveClosure _is_alive_closure;
332
333 // GC tracer that should be used during collection.
334 ParNewTracer _gc_tracer;
335
336 static oop real_forwardee_slow(oop obj);
337 static void waste_some_time();
338
339 void handle_promotion_failed(GenCollectedHeap* gch, ParScanThreadStateSet& thread_state_set);
340
341 protected:
342
343 bool _survivor_overflow;
344
345 bool survivor_overflow() { return _survivor_overflow; }
346 void set_survivor_overflow(bool v) { _survivor_overflow = v; }
347
348 void restore_preserved_marks();
349
350 public:
351 ParNewGeneration(ReservedSpace rs, size_t initial_byte_size);
352
353 ~ParNewGeneration() {
354 for (uint i = 0; i < ParallelGCThreads; i++)
355 delete _task_queues->queue(i);
356
357 delete _task_queues;
358 }
359
|
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 #ifndef SHARE_VM_GC_CMS_PARNEWGENERATION_HPP
26 #define SHARE_VM_GC_CMS_PARNEWGENERATION_HPP
27
28 #include "gc/cms/parOopClosures.hpp"
29 #include "gc/serial/defNewGeneration.hpp"
30 #include "gc/shared/copyFailedInfo.hpp"
31 #include "gc/shared/gcTrace.hpp"
32 #include "gc/shared/plab.hpp"
33 #include "gc/shared/preservedMarks.hpp"
34 #include "gc/shared/taskqueue.hpp"
35 #include "memory/padded.hpp"
36
37 class ChunkArray;
38 class CMSHeap;
39 class ParScanWithoutBarrierClosure;
40 class ParScanWithBarrierClosure;
41 class ParRootScanWithoutBarrierClosure;
42 class ParRootScanWithBarrierTwoGensClosure;
43 class ParEvacuateFollowersClosure;
44 class StrongRootsScope;
45
46 // It would be better if these types could be kept local to the .cpp file,
47 // but they must be here to allow ParScanClosure::do_oop_work to be defined
48 // in genOopClosures.inline.hpp.
49
50 typedef Padded<OopTaskQueue> ObjToScanQueue;
51 typedef GenericTaskQueueSet<ObjToScanQueue, mtGC> ObjToScanQueueSet;
52
53 class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
54 private:
55 ParScanWeakRefClosure* _par_cl;
56 protected:
57 template <class T> void do_oop_work(T* p);
58 public:
243 HeapWord* young_old_boundary,
244 ParScanThreadStateSet* state_set,
245 StrongRootsScope* strong_roots_scope);
246
247 HeapWord* young_old_boundary() { return _young_old_boundary; }
248
249 void work(uint worker_id);
250 };
251
252 class KeepAliveClosure: public DefNewGeneration::KeepAliveClosure {
253 protected:
254 template <class T> void do_oop_work(T* p);
255 public:
256 KeepAliveClosure(ScanWeakRefClosure* cl);
257 virtual void do_oop(oop* p);
258 virtual void do_oop(narrowOop* p);
259 };
260
261 class EvacuateFollowersClosureGeneral: public VoidClosure {
262 private:
263 CMSHeap* _heap;
264 OopsInGenClosure* _scan_cur_or_nonheap;
265 OopsInGenClosure* _scan_older;
266 public:
267 EvacuateFollowersClosureGeneral(CMSHeap* heap,
268 OopsInGenClosure* cur,
269 OopsInGenClosure* older);
270 virtual void do_void();
271 };
272
273 // Closure for scanning ParNewGeneration.
274 // Same as ScanClosure, except does parallel GC barrier.
275 class ScanClosureWithParBarrier: public ScanClosure {
276 protected:
277 template <class T> void do_oop_work(T* p);
278 public:
279 ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier);
280 virtual void do_oop(oop* p);
281 virtual void do_oop(narrowOop* p);
282 };
283
284 // Implements AbstractRefProcTaskExecutor for ParNew.
285 class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
286 private:
287 ParNewGeneration& _young_gen;
320
321 // Desired size of survivor space plab's
322 PLABStats _plab_stats;
323
324 // A list of from-space images of to-be-scanned objects, threaded through
325 // klass-pointers (klass information already copied to the forwarded
326 // image.) Manipulated with CAS.
327 oopDesc* volatile _overflow_list;
328 NOT_PRODUCT(ssize_t _num_par_pushes;)
329
330 // This closure is used by the reference processor to filter out
331 // references to live referent.
332 DefNewGeneration::IsAliveClosure _is_alive_closure;
333
334 // GC tracer that should be used during collection.
335 ParNewTracer _gc_tracer;
336
337 static oop real_forwardee_slow(oop obj);
338 static void waste_some_time();
339
340 void handle_promotion_failed(CMSHeap* gch, ParScanThreadStateSet& thread_state_set);
341
342 protected:
343
344 bool _survivor_overflow;
345
346 bool survivor_overflow() { return _survivor_overflow; }
347 void set_survivor_overflow(bool v) { _survivor_overflow = v; }
348
349 void restore_preserved_marks();
350
351 public:
352 ParNewGeneration(ReservedSpace rs, size_t initial_byte_size);
353
354 ~ParNewGeneration() {
355 for (uint i = 0; i < ParallelGCThreads; i++)
356 delete _task_queues->queue(i);
357
358 delete _task_queues;
359 }
360
|