Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1OopClosures.hpp @ 20804:7848fc12602b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with jdk8u40-b25
author Gilles Duboscq <gilles.m.duboscq@oracle.com>
date Tue, 07 Apr 2015 14:58:49 +0200
parents 52b4284cb496 2c6ef90f030a
children
comparison
equal deleted inserted replaced
20184:84105dcdb05b 20804:7848fc12602b
22 * 22 *
23 */ 23 */
24 24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
27
28 #include "memory/iterator.hpp"
27 29
28 class HeapRegion; 30 class HeapRegion;
29 class G1CollectedHeap; 31 class G1CollectedHeap;
30 class G1RemSet; 32 class G1RemSet;
31 class ConcurrentMark; 33 class ConcurrentMark;
49 protected: 51 protected:
50 G1CollectedHeap* _g1; 52 G1CollectedHeap* _g1;
51 G1ParScanThreadState* _par_scan_state; 53 G1ParScanThreadState* _par_scan_state;
52 uint _worker_id; 54 uint _worker_id;
53 public: 55 public:
56 // Initializes the instance, leaving _par_scan_state uninitialized. Must be done
57 // later using the set_par_scan_thread_state() method.
58 G1ParClosureSuper(G1CollectedHeap* g1);
54 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); 59 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
55 bool apply_to_weak_ref_discovered_field() { return true; } 60 bool apply_to_weak_ref_discovered_field() { return true; }
61
62 void set_par_scan_thread_state(G1ParScanThreadState* par_scan_state);
56 }; 63 };
57 64
58 class G1ParPushHeapRSClosure : public G1ParClosureSuper { 65 class G1ParPushHeapRSClosure : public G1ParClosureSuper {
59 public: 66 public:
60 G1ParPushHeapRSClosure(G1CollectedHeap* g1, 67 G1ParPushHeapRSClosure(G1CollectedHeap* g1,
66 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 73 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
67 }; 74 };
68 75
69 class G1ParScanClosure : public G1ParClosureSuper { 76 class G1ParScanClosure : public G1ParClosureSuper {
70 public: 77 public:
71 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : 78 G1ParScanClosure(G1CollectedHeap* g1, ReferenceProcessor* rp) :
72 G1ParClosureSuper(g1, par_scan_state) 79 G1ParClosureSuper(g1) {
73 {
74 assert(_ref_processor == NULL, "sanity"); 80 assert(_ref_processor == NULL, "sanity");
75 _ref_processor = rp; 81 _ref_processor = rp;
76 } 82 }
77 83
78 template <class T> void do_oop_nv(T* p); 84 template <class T> void do_oop_nv(T* p);
100 106
101 void set_scanned_klass(Klass* k) { _scanned_klass = k; } 107 void set_scanned_klass(Klass* k) { _scanned_klass = k; }
102 template <class T> void do_klass_barrier(T* p, oop new_obj); 108 template <class T> void do_klass_barrier(T* p, oop new_obj);
103 }; 109 };
104 110
105 template <G1Barrier barrier, bool do_mark_object> 111 template <G1Barrier barrier, G1Mark do_mark_object>
106 class G1ParCopyClosure : public G1ParCopyHelper { 112 class G1ParCopyClosure : public G1ParCopyHelper {
107 private: 113 private:
108 template <class T> void do_oop_work(T* p); 114 template <class T> void do_oop_work(T* p);
109 115
110 public: 116 public:
115 } 121 }
116 122
117 template <class T> void do_oop_nv(T* p) { do_oop_work(p); } 123 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
118 virtual void do_oop(oop* p) { do_oop_nv(p); } 124 virtual void do_oop(oop* p) { do_oop_nv(p); }
119 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 125 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
120 }; 126
121 127 G1CollectedHeap* g1() { return _g1; };
122 typedef G1ParCopyClosure<G1BarrierNone, false> G1ParScanExtRootClosure; 128 G1ParScanThreadState* pss() { return _par_scan_state; }
123 typedef G1ParCopyClosure<G1BarrierKlass, false> G1ParScanMetadataClosure; 129 ReferenceProcessor* rp() { return _ref_processor; };
124 130 };
125 131
126 typedef G1ParCopyClosure<G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; 132 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
127 typedef G1ParCopyClosure<G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; 133 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
128 134 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
129 // We use a separate closure to handle references during evacuation 135 // We use a separate closure to handle references during evacuation
130 // failure processing. 136 // failure processing.
131 137
132 typedef G1ParCopyClosure<G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; 138 typedef G1ParCopyClosure<G1BarrierEvac, G1MarkNone> G1ParScanHeapEvacFailureClosure;
133 139
134 class FilterIntoCSClosure: public ExtendedOopClosure { 140 class FilterIntoCSClosure: public ExtendedOopClosure {
135 G1CollectedHeap* _g1; 141 G1CollectedHeap* _g1;
136 OopClosure* _oc; 142 OopClosure* _oc;
137 DirtyCardToOopClosure* _dcto_cl; 143 DirtyCardToOopClosure* _dcto_cl;
158 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 164 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
159 bool apply_to_weak_ref_discovered_field() { return true; } 165 bool apply_to_weak_ref_discovered_field() { return true; }
160 }; 166 };
161 167
162 // Closure for iterating over object fields during concurrent marking 168 // Closure for iterating over object fields during concurrent marking
163 class G1CMOopClosure : public ExtendedOopClosure { 169 class G1CMOopClosure : public MetadataAwareOopClosure {
170 protected:
171 ConcurrentMark* _cm;
164 private: 172 private:
165 G1CollectedHeap* _g1h; 173 G1CollectedHeap* _g1h;
166 ConcurrentMark* _cm;
167 CMTask* _task; 174 CMTask* _task;
168 public: 175 public:
169 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); 176 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task);
170 template <class T> void do_oop_nv(T* p); 177 template <class T> void do_oop_nv(T* p);
171 virtual void do_oop( oop* p) { do_oop_nv(p); } 178 virtual void do_oop( oop* p) { do_oop_nv(p); }
172 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 179 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
173 }; 180 };
174 181
175 // Closure to scan the root regions during concurrent marking 182 // Closure to scan the root regions during concurrent marking
176 class G1RootRegionScanClosure : public ExtendedOopClosure { 183 class G1RootRegionScanClosure : public MetadataAwareOopClosure {
177 private: 184 private:
178 G1CollectedHeap* _g1h; 185 G1CollectedHeap* _g1h;
179 ConcurrentMark* _cm; 186 ConcurrentMark* _cm;
180 uint _worker_id; 187 uint _worker_id;
181 public: 188 public: