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_G1_G1OOPCLOSURES_HPP
26 #define SHARE_VM_GC_G1_G1OOPCLOSURES_HPP
27
28 #include "gc/g1/g1InCSetState.hpp"
29 #include "memory/iterator.hpp"
30 #include "oops/markOop.hpp"
31
32 class HeapRegion;
33 class G1CollectedHeap;
34 class G1RemSet;
35 class G1ConcurrentMark;
36 class DirtyCardToOopClosure;
37 class G1CMBitMap;
38 class G1ParScanThreadState;
39 class G1CMTask;
40 class ReferenceProcessor;
41
42 class G1ScanClosureBase : public BasicOopIterateClosure {
43 protected:
44 G1CollectedHeap* _g1h;
45 G1ParScanThreadState* _par_scan_state;
46
47 G1ScanClosureBase(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state);
48 ~G1ScanClosureBase() { }
49
50 template <class T>
51 inline void prefetch_and_push(T* p, oop const obj);
52
53 template <class T>
54 inline void handle_non_cset_obj_common(InCSetState const state, T* p, oop const obj);
55 public:
56 virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
57
58 inline void trim_queue_partially();
65 G1ParScanThreadState* pss) :
66 G1ScanClosureBase(g1h, pss) { }
67
68 template <class T> void do_oop_work(T* p);
69 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
70 virtual void do_oop(oop* p) { do_oop_work(p); }
71 };
72
73 // Used during the Scan RS phase to scan cards from the remembered set during garbage collection.
74 class G1ScanObjsDuringScanRSClosure : public G1ScanClosureBase {
75 public:
76 G1ScanObjsDuringScanRSClosure(G1CollectedHeap* g1h,
77 G1ParScanThreadState* par_scan_state):
78 G1ScanClosureBase(g1h, par_scan_state) { }
79
80 template <class T> void do_oop_work(T* p);
81 virtual void do_oop(oop* p) { do_oop_work(p); }
82 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
83 };
84
85 // This closure is applied to the fields of the objects that have just been copied during evacuation.
86 class G1ScanEvacuatedObjClosure : public G1ScanClosureBase {
87 bool _scanning_in_young;
88
89 public:
90 G1ScanEvacuatedObjClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :
91 G1ScanClosureBase(g1h, par_scan_state), _scanning_in_young(false) { }
92
93 void set_scanning_in_young(bool scanning_in_young) { _scanning_in_young = scanning_in_young; }
94
95 template <class T> void do_oop_work(T* p);
96 virtual void do_oop(oop* p) { do_oop_work(p); }
97 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
98
99 // We need to do reference discovery while processing evacuated objects.
100 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; }
101
102 void set_ref_discoverer(ReferenceDiscoverer* rd) {
103 set_ref_discoverer_internal(rd);
104 }
105 };
106
107 // Add back base class for metadata
108 class G1ParCopyHelper : public OopClosure {
109 protected:
110 G1CollectedHeap* _g1h;
111 G1ParScanThreadState* _par_scan_state;
112 uint _worker_id; // Cache value from par_scan_state.
113 ClassLoaderData* _scanned_cld;
114 G1ConcurrentMark* _cm;
115
116 // Mark the object if it's not already marked. This is used to mark
117 // objects pointed to by roots that are guaranteed not to move
118 // during the GC (i.e., non-CSet objects). It is MT-safe.
119 inline void mark_object(oop obj);
120
121 // Mark the object if it's not already marked. This is used to mark
122 // objects pointed to by roots that have been forwarded during a
123 // GC. It is MT-safe.
|
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_G1_G1OOPCLOSURES_HPP
26 #define SHARE_VM_GC_G1_G1OOPCLOSURES_HPP
27
28 #include "gc/g1/g1InCSetState.hpp"
29 #include "memory/iterator.hpp"
30 #include "oops/markOop.hpp"
31
32 class HeapRegion;
33 class G1CollectedHeap;
34 class G1RemSet;
35 class G1ConcurrentMark;
36 class DirtyCardToOopClosure;
37 class G1CMBitMap;
38 class G1ParScanThreadState;
39 class G1ScanEvacuatedObjClosure;
40 class G1CMTask;
41 class ReferenceProcessor;
42
43 class G1ScanClosureBase : public BasicOopIterateClosure {
44 protected:
45 G1CollectedHeap* _g1h;
46 G1ParScanThreadState* _par_scan_state;
47
48 G1ScanClosureBase(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state);
49 ~G1ScanClosureBase() { }
50
51 template <class T>
52 inline void prefetch_and_push(T* p, oop const obj);
53
54 template <class T>
55 inline void handle_non_cset_obj_common(InCSetState const state, T* p, oop const obj);
56 public:
57 virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
58
59 inline void trim_queue_partially();
66 G1ParScanThreadState* pss) :
67 G1ScanClosureBase(g1h, pss) { }
68
69 template <class T> void do_oop_work(T* p);
70 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
71 virtual void do_oop(oop* p) { do_oop_work(p); }
72 };
73
74 // Used during the Scan RS phase to scan cards from the remembered set during garbage collection.
75 class G1ScanObjsDuringScanRSClosure : public G1ScanClosureBase {
76 public:
77 G1ScanObjsDuringScanRSClosure(G1CollectedHeap* g1h,
78 G1ParScanThreadState* par_scan_state):
79 G1ScanClosureBase(g1h, par_scan_state) { }
80
81 template <class T> void do_oop_work(T* p);
82 virtual void do_oop(oop* p) { do_oop_work(p); }
83 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
84 };
85
86
87 // This closure is applied to the fields of the objects that have just been copied during evacuation.
88 class G1ScanEvacuatedObjClosure : public G1ScanClosureBase {
89 friend class G1ScanInYoungSetter;
90
91 enum ScanningInYoungValues {
92 False = 0,
93 True,
94 Uninitialized
95 };
96
97 ScanningInYoungValues _scanning_in_young;
98
99 public:
100 G1ScanEvacuatedObjClosure(G1CollectedHeap* g1h, G1ParScanThreadState* par_scan_state) :
101 G1ScanClosureBase(g1h, par_scan_state), _scanning_in_young(Uninitialized) { }
102
103 template <class T> void do_oop_work(T* p);
104 virtual void do_oop(oop* p) { do_oop_work(p); }
105 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
106
107 // We need to do reference discovery while processing evacuated objects.
108 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; }
109
110 void set_ref_discoverer(ReferenceDiscoverer* rd) {
111 set_ref_discoverer_internal(rd);
112 }
113 };
114
115 // RAII object to properly set the _scanning_in_young field in G1ScanEvacuatedObjClosure.
116 class G1ScanInYoungSetter : public StackObj {
117 G1ScanEvacuatedObjClosure* _closure;
118
119 public:
120 G1ScanInYoungSetter(G1ScanEvacuatedObjClosure* closure, bool new_value) : _closure(closure) {
121 assert(_closure->_scanning_in_young == G1ScanEvacuatedObjClosure::Uninitialized, "Must not be set");
122 _closure->_scanning_in_young = new_value ? G1ScanEvacuatedObjClosure::True : G1ScanEvacuatedObjClosure::False;
123 }
124
125 ~G1ScanInYoungSetter() {
126 DEBUG_ONLY(_closure->_scanning_in_young = G1ScanEvacuatedObjClosure::Uninitialized;)
127 }
128 };
129
130 // Add back base class for metadata
131 class G1ParCopyHelper : public OopClosure {
132 protected:
133 G1CollectedHeap* _g1h;
134 G1ParScanThreadState* _par_scan_state;
135 uint _worker_id; // Cache value from par_scan_state.
136 ClassLoaderData* _scanned_cld;
137 G1ConcurrentMark* _cm;
138
139 // Mark the object if it's not already marked. This is used to mark
140 // objects pointed to by roots that are guaranteed not to move
141 // during the GC (i.e., non-CSet objects). It is MT-safe.
142 inline void mark_object(oop obj);
143
144 // Mark the object if it's not already marked. This is used to mark
145 // objects pointed to by roots that have been forwarded during a
146 // GC. It is MT-safe.
|