2565 VMThread::execute(&op);
2566 }
2567 }
2568 } while (retry_gc);
2569 }
2570
2571 bool G1CollectedHeap::is_in(const void* p) const {
2572 if (_g1_committed.contains(p)) {
2573 // Given that we know that p is in the committed space,
2574 // heap_region_containing_raw() should successfully
2575 // return the containing region.
2576 HeapRegion* hr = heap_region_containing_raw(p);
2577 return hr->is_in(p);
2578 } else {
2579 return false;
2580 }
2581 }
2582
2583 // Iteration functions.
2584
2585 // Iterates an OopClosure over all ref-containing fields of objects
2586 // within a HeapRegion.
2587
2588 class IterateOopClosureRegionClosure: public HeapRegionClosure {
2589 MemRegion _mr;
2590 ExtendedOopClosure* _cl;
2591 public:
2592 IterateOopClosureRegionClosure(MemRegion mr, ExtendedOopClosure* cl)
2593 : _mr(mr), _cl(cl) {}
2594 bool doHeapRegion(HeapRegion* r) {
2595 if (!r->continuesHumongous()) {
2596 r->oop_iterate(_cl);
2597 }
2598 return false;
2599 }
2600 };
2601
2602 void G1CollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
2603 IterateOopClosureRegionClosure blk(_g1_committed, cl);
2604 heap_region_iterate(&blk);
2605 }
2606
2607 void G1CollectedHeap::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) {
2608 IterateOopClosureRegionClosure blk(mr, cl);
2609 heap_region_iterate(&blk);
2610 }
2611
2612 // Iterates an ObjectClosure over all objects within a HeapRegion.
2613
2614 class IterateObjectClosureRegionClosure: public HeapRegionClosure {
2615 ObjectClosure* _cl;
2616 public:
2617 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {}
2618 bool doHeapRegion(HeapRegion* r) {
2619 if (! r->continuesHumongous()) {
2620 r->object_iterate(_cl);
2621 }
2622 return false;
2623 }
2624 };
2625
2626 void G1CollectedHeap::object_iterate(ObjectClosure* cl) {
2627 IterateObjectClosureRegionClosure blk(cl);
2628 heap_region_iterate(&blk);
4775 _closure->set_scanned_klass(klass);
4776
4777 klass->oops_do(_closure);
4778
4779 _closure->set_scanned_klass(NULL);
4780 }
4781 _count++;
4782 }
4783 };
4784
4785 class G1ParTask : public AbstractGangTask {
4786 protected:
4787 G1CollectedHeap* _g1h;
4788 RefToScanQueueSet *_queues;
4789 ParallelTaskTerminator _terminator;
4790 uint _n_workers;
4791
4792 Mutex _stats_lock;
4793 Mutex* stats_lock() { return &_stats_lock; }
4794
4795 size_t getNCards() {
4796 return (_g1h->capacity() + G1BlockOffsetSharedArray::N_bytes - 1)
4797 / G1BlockOffsetSharedArray::N_bytes;
4798 }
4799
4800 public:
4801 G1ParTask(G1CollectedHeap* g1h, RefToScanQueueSet *task_queues)
4802 : AbstractGangTask("G1 collection"),
4803 _g1h(g1h),
4804 _queues(task_queues),
4805 _terminator(0, _queues),
4806 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true)
4807 {}
4808
4809 RefToScanQueueSet* queues() { return _queues; }
4810
4811 RefToScanQueue *work_queue(int i) {
4812 return queues()->queue(i);
4813 }
4814
4815 ParallelTaskTerminator* terminator() { return &_terminator; }
4816
4817 virtual void set_for_termination(int active_workers) {
4818 // This task calls set_n_termination() in par_non_clean_card_iterate_work()
4819 // in the young space (_par_seq_tasks) in the G1 heap
|
2565 VMThread::execute(&op);
2566 }
2567 }
2568 } while (retry_gc);
2569 }
2570
2571 bool G1CollectedHeap::is_in(const void* p) const {
2572 if (_g1_committed.contains(p)) {
2573 // Given that we know that p is in the committed space,
2574 // heap_region_containing_raw() should successfully
2575 // return the containing region.
2576 HeapRegion* hr = heap_region_containing_raw(p);
2577 return hr->is_in(p);
2578 } else {
2579 return false;
2580 }
2581 }
2582
2583 // Iteration functions.
2584
2585 // Applies an ExtendedOopClosure onto all references of objects within a HeapRegion.
2586
2587 class IterateOopClosureRegionClosure: public HeapRegionClosure {
2588 ExtendedOopClosure* _cl;
2589 public:
2590 IterateOopClosureRegionClosure(ExtendedOopClosure* cl) : _cl(cl) {}
2591 bool doHeapRegion(HeapRegion* r) {
2592 if (!r->continuesHumongous()) {
2593 r->oop_iterate(_cl);
2594 }
2595 return false;
2596 }
2597 };
2598
2599 void G1CollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
2600 IterateOopClosureRegionClosure blk(cl);
2601 heap_region_iterate(&blk);
2602 }
2603
2604 // Iterates an ObjectClosure over all objects within a HeapRegion.
2605
2606 class IterateObjectClosureRegionClosure: public HeapRegionClosure {
2607 ObjectClosure* _cl;
2608 public:
2609 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {}
2610 bool doHeapRegion(HeapRegion* r) {
2611 if (! r->continuesHumongous()) {
2612 r->object_iterate(_cl);
2613 }
2614 return false;
2615 }
2616 };
2617
2618 void G1CollectedHeap::object_iterate(ObjectClosure* cl) {
2619 IterateObjectClosureRegionClosure blk(cl);
2620 heap_region_iterate(&blk);
4767 _closure->set_scanned_klass(klass);
4768
4769 klass->oops_do(_closure);
4770
4771 _closure->set_scanned_klass(NULL);
4772 }
4773 _count++;
4774 }
4775 };
4776
4777 class G1ParTask : public AbstractGangTask {
4778 protected:
4779 G1CollectedHeap* _g1h;
4780 RefToScanQueueSet *_queues;
4781 ParallelTaskTerminator _terminator;
4782 uint _n_workers;
4783
4784 Mutex _stats_lock;
4785 Mutex* stats_lock() { return &_stats_lock; }
4786
4787 public:
4788 G1ParTask(G1CollectedHeap* g1h, RefToScanQueueSet *task_queues)
4789 : AbstractGangTask("G1 collection"),
4790 _g1h(g1h),
4791 _queues(task_queues),
4792 _terminator(0, _queues),
4793 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true)
4794 {}
4795
4796 RefToScanQueueSet* queues() { return _queues; }
4797
4798 RefToScanQueue *work_queue(int i) {
4799 return queues()->queue(i);
4800 }
4801
4802 ParallelTaskTerminator* terminator() { return &_terminator; }
4803
4804 virtual void set_for_termination(int active_workers) {
4805 // This task calls set_n_termination() in par_non_clean_card_iterate_work()
4806 // in the young space (_par_seq_tasks) in the G1 heap
|