Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 };