Mercurial > hg > truffle
comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | d2a62e0f25eb |
children | f64ffbf81af5 |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
39 #include "utilities/yieldingWorkgroup.hpp" | 39 #include "utilities/yieldingWorkgroup.hpp" |
40 | 40 |
41 // ConcurrentMarkSweepGeneration is in support of a concurrent | 41 // ConcurrentMarkSweepGeneration is in support of a concurrent |
42 // mark-sweep old generation in the Detlefs-Printezis--Boehm-Demers-Schenker | 42 // mark-sweep old generation in the Detlefs-Printezis--Boehm-Demers-Schenker |
43 // style. We assume, for now, that this generation is always the | 43 // style. We assume, for now, that this generation is always the |
44 // seniormost generation (modulo the PermGeneration), and for simplicity | 44 // seniormost generation and for simplicity |
45 // in the first implementation, that this generation is a single compactible | 45 // in the first implementation, that this generation is a single compactible |
46 // space. Neither of these restrictions appears essential, and will be | 46 // space. Neither of these restrictions appears essential, and will be |
47 // relaxed in the future when more time is available to implement the | 47 // relaxed in the future when more time is available to implement the |
48 // greater generality (and there's a need for it). | 48 // greater generality (and there's a need for it). |
49 // | 49 // |
608 AdaptivePaddedAverage _inter_sweep_estimate; | 608 AdaptivePaddedAverage _inter_sweep_estimate; |
609 AdaptivePaddedAverage _intra_sweep_estimate; | 609 AdaptivePaddedAverage _intra_sweep_estimate; |
610 | 610 |
611 protected: | 611 protected: |
612 ConcurrentMarkSweepGeneration* _cmsGen; // old gen (CMS) | 612 ConcurrentMarkSweepGeneration* _cmsGen; // old gen (CMS) |
613 ConcurrentMarkSweepGeneration* _permGen; // perm gen | |
614 MemRegion _span; // span covering above two | 613 MemRegion _span; // span covering above two |
615 CardTableRS* _ct; // card table | 614 CardTableRS* _ct; // card table |
616 | 615 |
617 // CMS marking support structures | 616 // CMS marking support structures |
618 CMSBitMap _markBitMap; | 617 CMSBitMap _markBitMap; |
619 CMSBitMap _modUnionTable; | 618 CMSBitMap _modUnionTable; |
620 CMSMarkStack _markStack; | 619 CMSMarkStack _markStack; |
621 CMSMarkStack _revisitStack; // used to keep track of klassKlass objects | |
622 // to revisit | |
623 CMSBitMap _perm_gen_verify_bit_map; // Mark bit map for perm gen verification support. | |
624 | 620 |
625 HeapWord* _restart_addr; // in support of marking stack overflow | 621 HeapWord* _restart_addr; // in support of marking stack overflow |
626 void lower_restart_addr(HeapWord* low); | 622 void lower_restart_addr(HeapWord* low); |
627 | 623 |
628 // Counters in support of marking stack / work queue overflow handling: | 624 // Counters in support of marking stack / work queue overflow handling: |
781 size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen, | 777 size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen, |
782 ScanMarkedObjectsAgainCarefullyClosure* cl); | 778 ScanMarkedObjectsAgainCarefullyClosure* cl); |
783 // Does precleaning work, returning a quantity indicative of | 779 // Does precleaning work, returning a quantity indicative of |
784 // the amount of "useful work" done. | 780 // the amount of "useful work" done. |
785 size_t preclean_work(bool clean_refs, bool clean_survivors); | 781 size_t preclean_work(bool clean_refs, bool clean_survivors); |
782 void preclean_klasses(MarkRefsIntoAndScanClosure* cl, Mutex* freelistLock); | |
786 void abortable_preclean(); // Preclean while looking for possible abort | 783 void abortable_preclean(); // Preclean while looking for possible abort |
787 void initialize_sequential_subtasks_for_young_gen_rescan(int i); | 784 void initialize_sequential_subtasks_for_young_gen_rescan(int i); |
788 // Helper function for above; merge-sorts the per-thread plab samples | 785 // Helper function for above; merge-sorts the per-thread plab samples |
789 void merge_survivor_plab_arrays(ContiguousSpace* surv, int no_of_gc_threads); | 786 void merge_survivor_plab_arrays(ContiguousSpace* surv, int no_of_gc_threads); |
790 // Resets (i.e. clears) the per-thread plab sample vectors | 787 // Resets (i.e. clears) the per-thread plab sample vectors |
853 HeapWord* next_card_start_after_block(HeapWord* addr) const; | 850 HeapWord* next_card_start_after_block(HeapWord* addr) const; |
854 | 851 |
855 void setup_cms_unloading_and_verification_state(); | 852 void setup_cms_unloading_and_verification_state(); |
856 public: | 853 public: |
857 CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, | 854 CMSCollector(ConcurrentMarkSweepGeneration* cmsGen, |
858 ConcurrentMarkSweepGeneration* permGen, | |
859 CardTableRS* ct, | 855 CardTableRS* ct, |
860 ConcurrentMarkSweepPolicy* cp); | 856 ConcurrentMarkSweepPolicy* cp); |
861 ConcurrentMarkSweepThread* cmsThread() { return _cmsThread; } | 857 ConcurrentMarkSweepThread* cmsThread() { return _cmsThread; } |
862 | 858 |
863 ReferenceProcessor* ref_processor() { return _ref_processor; } | 859 ReferenceProcessor* ref_processor() { return _ref_processor; } |
889 static void request_full_gc(unsigned int full_gc_count); | 885 static void request_full_gc(unsigned int full_gc_count); |
890 // Should we unload classes in a particular concurrent cycle? | 886 // Should we unload classes in a particular concurrent cycle? |
891 bool should_unload_classes() const { | 887 bool should_unload_classes() const { |
892 return _should_unload_classes; | 888 return _should_unload_classes; |
893 } | 889 } |
894 bool update_should_unload_classes(); | 890 void update_should_unload_classes(); |
895 | 891 |
896 void direct_allocated(HeapWord* start, size_t size); | 892 void direct_allocated(HeapWord* start, size_t size); |
897 | 893 |
898 // Object is dead if not marked and current phase is sweeping. | 894 // Object is dead if not marked and current phase is sweeping. |
899 bool is_dead_obj(oop obj) const; | 895 bool is_dead_obj(oop obj) const; |
999 HeapWord* block_start(const void* p) const PRODUCT_RETURN0; | 995 HeapWord* block_start(const void* p) const PRODUCT_RETURN0; |
1000 | 996 |
1001 // accessors | 997 // accessors |
1002 CMSMarkStack* verification_mark_stack() { return &_markStack; } | 998 CMSMarkStack* verification_mark_stack() { return &_markStack; } |
1003 CMSBitMap* verification_mark_bm() { return &_verification_mark_bm; } | 999 CMSBitMap* verification_mark_bm() { return &_verification_mark_bm; } |
1004 | |
1005 // Get the bit map with a perm gen "deadness" information. | |
1006 CMSBitMap* perm_gen_verify_bit_map() { return &_perm_gen_verify_bit_map; } | |
1007 | 1000 |
1008 // Initialization errors | 1001 // Initialization errors |
1009 bool completed_initialization() { return _completed_initialization; } | 1002 bool completed_initialization() { return _completed_initialization; } |
1010 }; | 1003 }; |
1011 | 1004 |
1251 | 1244 |
1252 // Iteration support specific to CMS generations | 1245 // Iteration support specific to CMS generations |
1253 void save_sweep_limit(); | 1246 void save_sweep_limit(); |
1254 | 1247 |
1255 // More iteration support | 1248 // More iteration support |
1256 virtual void oop_iterate(MemRegion mr, OopClosure* cl); | 1249 virtual void oop_iterate(MemRegion mr, ExtendedOopClosure* cl); |
1257 virtual void oop_iterate(OopClosure* cl); | 1250 virtual void oop_iterate(ExtendedOopClosure* cl); |
1258 virtual void safe_object_iterate(ObjectClosure* cl); | 1251 virtual void safe_object_iterate(ObjectClosure* cl); |
1259 virtual void object_iterate(ObjectClosure* cl); | 1252 virtual void object_iterate(ObjectClosure* cl); |
1260 | 1253 |
1261 // Need to declare the full complement of closures, whether we'll | 1254 // Need to declare the full complement of closures, whether we'll |
1262 // override them or not, or get message from the compiler: | 1255 // override them or not, or get message from the compiler: |
1271 | 1264 |
1272 // Get the chunk at the end of the space. Delagates to | 1265 // Get the chunk at the end of the space. Delagates to |
1273 // the space. | 1266 // the space. |
1274 FreeChunk* find_chunk_at_end(); | 1267 FreeChunk* find_chunk_at_end(); |
1275 | 1268 |
1276 // Overriding of unused functionality (sharing not yet supported with CMS) | |
1277 void pre_adjust_pointers(); | |
1278 void post_compact(); | 1269 void post_compact(); |
1279 | 1270 |
1280 // Debugging | 1271 // Debugging |
1281 void prepare_for_verify(); | 1272 void prepare_for_verify(); |
1282 void verify(); | 1273 void verify(); |
1357 CMSCollector* _collector; | 1348 CMSCollector* _collector; |
1358 MemRegion _span; | 1349 MemRegion _span; |
1359 CMSBitMap* _bitMap; | 1350 CMSBitMap* _bitMap; |
1360 CMSBitMap* _mut; | 1351 CMSBitMap* _mut; |
1361 CMSMarkStack* _markStack; | 1352 CMSMarkStack* _markStack; |
1362 CMSMarkStack* _revisitStack; | |
1363 bool _yield; | 1353 bool _yield; |
1364 int _skipBits; | 1354 int _skipBits; |
1365 HeapWord* _finger; | 1355 HeapWord* _finger; |
1366 HeapWord* _threshold; | 1356 HeapWord* _threshold; |
1367 DEBUG_ONLY(bool _verifying;) | 1357 DEBUG_ONLY(bool _verifying;) |
1368 | 1358 |
1369 public: | 1359 public: |
1370 MarkFromRootsClosure(CMSCollector* collector, MemRegion span, | 1360 MarkFromRootsClosure(CMSCollector* collector, MemRegion span, |
1371 CMSBitMap* bitMap, | 1361 CMSBitMap* bitMap, |
1372 CMSMarkStack* markStack, | 1362 CMSMarkStack* markStack, |
1373 CMSMarkStack* revisitStack, | |
1374 bool should_yield, bool verifying = false); | 1363 bool should_yield, bool verifying = false); |
1375 bool do_bit(size_t offset); | 1364 bool do_bit(size_t offset); |
1376 void reset(HeapWord* addr); | 1365 void reset(HeapWord* addr); |
1377 inline void do_yield_check(); | 1366 inline void do_yield_check(); |
1378 | 1367 |
1392 MemRegion _span; | 1381 MemRegion _span; |
1393 CMSBitMap* _bit_map; | 1382 CMSBitMap* _bit_map; |
1394 CMSBitMap* _mut; | 1383 CMSBitMap* _mut; |
1395 OopTaskQueue* _work_queue; | 1384 OopTaskQueue* _work_queue; |
1396 CMSMarkStack* _overflow_stack; | 1385 CMSMarkStack* _overflow_stack; |
1397 CMSMarkStack* _revisit_stack; | |
1398 bool _yield; | 1386 bool _yield; |
1399 int _skip_bits; | 1387 int _skip_bits; |
1400 HeapWord* _finger; | 1388 HeapWord* _finger; |
1401 HeapWord* _threshold; | 1389 HeapWord* _threshold; |
1402 CMSConcMarkingTask* _task; | 1390 CMSConcMarkingTask* _task; |
1404 Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, | 1392 Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, |
1405 MemRegion span, | 1393 MemRegion span, |
1406 CMSBitMap* bit_map, | 1394 CMSBitMap* bit_map, |
1407 OopTaskQueue* work_queue, | 1395 OopTaskQueue* work_queue, |
1408 CMSMarkStack* overflow_stack, | 1396 CMSMarkStack* overflow_stack, |
1409 CMSMarkStack* revisit_stack, | |
1410 bool should_yield); | 1397 bool should_yield); |
1411 bool do_bit(size_t offset); | 1398 bool do_bit(size_t offset); |
1412 inline void do_yield_check(); | 1399 inline void do_yield_check(); |
1413 | 1400 |
1414 private: | 1401 private: |
1417 bool get_work_from_overflow_stack(); | 1404 bool get_work_from_overflow_stack(); |
1418 }; | 1405 }; |
1419 | 1406 |
1420 // The following closures are used to do certain kinds of verification of | 1407 // The following closures are used to do certain kinds of verification of |
1421 // CMS marking. | 1408 // CMS marking. |
1422 class PushAndMarkVerifyClosure: public OopClosure { | 1409 class PushAndMarkVerifyClosure: public CMSOopClosure { |
1423 CMSCollector* _collector; | 1410 CMSCollector* _collector; |
1424 MemRegion _span; | 1411 MemRegion _span; |
1425 CMSBitMap* _verification_bm; | 1412 CMSBitMap* _verification_bm; |
1426 CMSBitMap* _cms_bm; | 1413 CMSBitMap* _cms_bm; |
1427 CMSMarkStack* _mark_stack; | 1414 CMSMarkStack* _mark_stack; |
1428 protected: | 1415 protected: |
1429 void do_oop(oop p); | 1416 void do_oop(oop p); |
1430 template <class T> inline void do_oop_work(T *p) { | 1417 template <class T> inline void do_oop_work(T *p) { |
1431 oop obj = oopDesc::load_decode_heap_oop_not_null(p); | 1418 oop obj = oopDesc::load_decode_heap_oop(p); |
1432 do_oop(obj); | 1419 do_oop(obj); |
1433 } | 1420 } |
1434 public: | 1421 public: |
1435 PushAndMarkVerifyClosure(CMSCollector* cms_collector, | 1422 PushAndMarkVerifyClosure(CMSCollector* cms_collector, |
1436 MemRegion span, | 1423 MemRegion span, |
1437 CMSBitMap* verification_bm, | 1424 CMSBitMap* verification_bm, |
1438 CMSBitMap* cms_bm, | 1425 CMSBitMap* cms_bm, |
1439 CMSMarkStack* mark_stack); | 1426 CMSMarkStack* mark_stack); |
1440 void do_oop(oop* p); | 1427 void do_oop(oop* p); |
1441 void do_oop(narrowOop* p); | 1428 void do_oop(narrowOop* p); |
1429 | |
1442 // Deal with a stack overflow condition | 1430 // Deal with a stack overflow condition |
1443 void handle_stack_overflow(HeapWord* lost); | 1431 void handle_stack_overflow(HeapWord* lost); |
1444 }; | 1432 }; |
1445 | 1433 |
1446 class MarkFromRootsVerifyClosure: public BitMapClosure { | 1434 class MarkFromRootsVerifyClosure: public BitMapClosure { |
1502 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | 1490 ScanMarkedObjectsAgainClosure(CMSCollector* collector, |
1503 MemRegion span, | 1491 MemRegion span, |
1504 ReferenceProcessor* rp, | 1492 ReferenceProcessor* rp, |
1505 CMSBitMap* bit_map, | 1493 CMSBitMap* bit_map, |
1506 CMSMarkStack* mark_stack, | 1494 CMSMarkStack* mark_stack, |
1507 CMSMarkStack* revisit_stack, | |
1508 MarkRefsIntoAndScanClosure* cl): | 1495 MarkRefsIntoAndScanClosure* cl): |
1509 #ifdef ASSERT | 1496 #ifdef ASSERT |
1510 _collector(collector), | 1497 _collector(collector), |
1511 _span(span), | 1498 _span(span), |
1512 _mark_stack(mark_stack), | 1499 _mark_stack(mark_stack), |
1518 ScanMarkedObjectsAgainClosure(CMSCollector* collector, | 1505 ScanMarkedObjectsAgainClosure(CMSCollector* collector, |
1519 MemRegion span, | 1506 MemRegion span, |
1520 ReferenceProcessor* rp, | 1507 ReferenceProcessor* rp, |
1521 CMSBitMap* bit_map, | 1508 CMSBitMap* bit_map, |
1522 OopTaskQueue* work_queue, | 1509 OopTaskQueue* work_queue, |
1523 CMSMarkStack* revisit_stack, | |
1524 Par_MarkRefsIntoAndScanClosure* cl): | 1510 Par_MarkRefsIntoAndScanClosure* cl): |
1525 #ifdef ASSERT | 1511 #ifdef ASSERT |
1526 _collector(collector), | 1512 _collector(collector), |
1527 _span(span), | 1513 _span(span), |
1528 _work_queue(work_queue), | 1514 _work_queue(work_queue), |
1556 MarkFromDirtyCardsClosure(CMSCollector* collector, | 1542 MarkFromDirtyCardsClosure(CMSCollector* collector, |
1557 MemRegion span, | 1543 MemRegion span, |
1558 CompactibleFreeListSpace* space, | 1544 CompactibleFreeListSpace* space, |
1559 CMSBitMap* bit_map, | 1545 CMSBitMap* bit_map, |
1560 CMSMarkStack* mark_stack, | 1546 CMSMarkStack* mark_stack, |
1561 CMSMarkStack* revisit_stack, | |
1562 MarkRefsIntoAndScanClosure* cl): | 1547 MarkRefsIntoAndScanClosure* cl): |
1563 _space(space), | 1548 _space(space), |
1564 _num_dirty_cards(0), | 1549 _num_dirty_cards(0), |
1565 _scan_cl(collector, span, collector->ref_processor(), bit_map, | 1550 _scan_cl(collector, span, collector->ref_processor(), bit_map, |
1566 mark_stack, revisit_stack, cl) { } | 1551 mark_stack, cl) { } |
1567 | 1552 |
1568 MarkFromDirtyCardsClosure(CMSCollector* collector, | 1553 MarkFromDirtyCardsClosure(CMSCollector* collector, |
1569 MemRegion span, | 1554 MemRegion span, |
1570 CompactibleFreeListSpace* space, | 1555 CompactibleFreeListSpace* space, |
1571 CMSBitMap* bit_map, | 1556 CMSBitMap* bit_map, |
1572 OopTaskQueue* work_queue, | 1557 OopTaskQueue* work_queue, |
1573 CMSMarkStack* revisit_stack, | |
1574 Par_MarkRefsIntoAndScanClosure* cl): | 1558 Par_MarkRefsIntoAndScanClosure* cl): |
1575 _space(space), | 1559 _space(space), |
1576 _num_dirty_cards(0), | 1560 _num_dirty_cards(0), |
1577 _scan_cl(collector, span, collector->ref_processor(), bit_map, | 1561 _scan_cl(collector, span, collector->ref_processor(), bit_map, |
1578 work_queue, revisit_stack, cl) { } | 1562 work_queue, cl) { } |
1579 | 1563 |
1580 void do_MemRegion(MemRegion mr); | 1564 void do_MemRegion(MemRegion mr); |
1581 void set_space(CompactibleFreeListSpace* space) { _space = space; } | 1565 void set_space(CompactibleFreeListSpace* space) { _space = space; } |
1582 size_t num_dirty_cards() { return _num_dirty_cards; } | 1566 size_t num_dirty_cards() { return _num_dirty_cards; } |
1583 }; | 1567 }; |
1607 public: | 1591 public: |
1608 ScanMarkedObjectsAgainCarefullyClosure(CMSCollector* collector, | 1592 ScanMarkedObjectsAgainCarefullyClosure(CMSCollector* collector, |
1609 MemRegion span, | 1593 MemRegion span, |
1610 CMSBitMap* bitMap, | 1594 CMSBitMap* bitMap, |
1611 CMSMarkStack* markStack, | 1595 CMSMarkStack* markStack, |
1612 CMSMarkStack* revisitStack, | |
1613 MarkRefsIntoAndScanClosure* cl, | 1596 MarkRefsIntoAndScanClosure* cl, |
1614 bool should_yield): | 1597 bool should_yield): |
1615 _collector(collector), | 1598 _collector(collector), |
1616 _span(span), | 1599 _span(span), |
1617 _yield(should_yield), | 1600 _yield(should_yield), |
1836 CMSInnerParMarkAndPushClosure _mark_and_push; | 1819 CMSInnerParMarkAndPushClosure _mark_and_push; |
1837 | 1820 |
1838 public: | 1821 public: |
1839 CMSParDrainMarkingStackClosure(CMSCollector* collector, | 1822 CMSParDrainMarkingStackClosure(CMSCollector* collector, |
1840 MemRegion span, CMSBitMap* bit_map, | 1823 MemRegion span, CMSBitMap* bit_map, |
1841 CMSMarkStack* revisit_stack, | |
1842 OopTaskQueue* work_queue): | 1824 OopTaskQueue* work_queue): |
1843 _collector(collector), | 1825 _collector(collector), |
1844 _span(span), | 1826 _span(span), |
1845 _bit_map(bit_map), | 1827 _bit_map(bit_map), |
1846 _work_queue(work_queue), | 1828 _work_queue(work_queue), |
1847 _mark_and_push(collector, span, bit_map, revisit_stack, work_queue) { } | 1829 _mark_and_push(collector, span, bit_map, work_queue) { } |
1848 | 1830 |
1849 public: | 1831 public: |
1850 void trim_queue(uint max); | 1832 void trim_queue(uint max); |
1851 void do_void(); | 1833 void do_void(); |
1852 }; | 1834 }; |