Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/bufferingOopClosure.hpp @ 845:df6caf649ff7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6700789: G1: Enable use of compressed oops with G1 heaps Summary: Modifications to G1 so as to allow the use of compressed oops. Reviewed-by: apetrusenko, coleenp, jmasa, kvn, never, phh, tonyp
author ysr
date Tue, 14 Jul 2009 15:40:39 -0700
parents 37f87013dfd8
children c18cbe5936b8
comparison
equal deleted inserted replaced
839:bb18957ad21e 845:df6caf649ff7
40 protected: 40 protected:
41 enum PrivateConstants { 41 enum PrivateConstants {
42 BufferLength = 1024 42 BufferLength = 1024
43 }; 43 };
44 44
45 oop *_buffer[BufferLength]; 45 StarTask _buffer[BufferLength];
46 oop **_buffer_top; 46 StarTask* _buffer_top;
47 oop **_buffer_curr; 47 StarTask* _buffer_curr;
48 48
49 OopClosure *_oc; 49 OopClosure* _oc;
50 double _closure_app_seconds; 50 double _closure_app_seconds;
51 51
52 void process_buffer () { 52 void process_buffer () {
53
54 double start = os::elapsedTime(); 53 double start = os::elapsedTime();
55 for (oop **curr = _buffer; curr < _buffer_curr; ++curr) { 54 for (StarTask* curr = _buffer; curr < _buffer_curr; ++curr) {
56 _oc->do_oop(*curr); 55 if (curr->is_narrow()) {
56 assert(UseCompressedOops, "Error");
57 _oc->do_oop((narrowOop*)(*curr));
58 } else {
59 _oc->do_oop((oop*)(*curr));
60 }
57 } 61 }
58 _buffer_curr = _buffer; 62 _buffer_curr = _buffer;
59 _closure_app_seconds += (os::elapsedTime() - start); 63 _closure_app_seconds += (os::elapsedTime() - start);
60 } 64 }
61 65
66 template <class T> inline void do_oop_work(T* p) {
67 if (_buffer_curr == _buffer_top) {
68 process_buffer();
69 }
70 StarTask new_ref(p);
71 *_buffer_curr = new_ref;
72 ++_buffer_curr;
73 }
74
62 public: 75 public:
63 virtual void do_oop(narrowOop* p) { 76 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
64 guarantee(false, "NYI"); 77 virtual void do_oop(oop* p) { do_oop_work(p); }
65 } 78
66 virtual void do_oop(oop *p) {
67 if (_buffer_curr == _buffer_top) {
68 process_buffer();
69 }
70
71 *_buffer_curr = p;
72 ++_buffer_curr;
73 }
74 void done () { 79 void done () {
75 if (_buffer_curr > _buffer) { 80 if (_buffer_curr > _buffer) {
76 process_buffer(); 81 process_buffer();
77 } 82 }
78 } 83 }
86 }; 91 };
87 92
88 class BufferingOopsInGenClosure: public OopsInGenClosure { 93 class BufferingOopsInGenClosure: public OopsInGenClosure {
89 BufferingOopClosure _boc; 94 BufferingOopClosure _boc;
90 OopsInGenClosure* _oc; 95 OopsInGenClosure* _oc;
91 public: 96 protected:
97 template <class T> inline void do_oop_work(T* p) {
98 assert(generation()->is_in_reserved((void*)p), "Must be in!");
99 _boc.do_oop(p);
100 }
101 public:
92 BufferingOopsInGenClosure(OopsInGenClosure *oc) : 102 BufferingOopsInGenClosure(OopsInGenClosure *oc) :
93 _boc(oc), _oc(oc) {} 103 _boc(oc), _oc(oc) {}
94 104
95 virtual void do_oop(narrowOop* p) { 105 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
96 guarantee(false, "NYI"); 106 virtual void do_oop(oop* p) { do_oop_work(p); }
97 }
98
99 virtual void do_oop(oop* p) {
100 assert(generation()->is_in_reserved(p), "Must be in!");
101 _boc.do_oop(p);
102 }
103 107
104 void done() { 108 void done() {
105 _boc.done(); 109 _boc.done();
106 } 110 }
107 111
128 private: 132 private:
129 enum PrivateConstants { 133 enum PrivateConstants {
130 BufferLength = 1024 134 BufferLength = 1024
131 }; 135 };
132 136
133 oop *_buffer[BufferLength]; 137 StarTask _buffer[BufferLength];
134 oop **_buffer_top; 138 StarTask* _buffer_top;
135 oop **_buffer_curr; 139 StarTask* _buffer_curr;
136 140
137 HeapRegion *_hr_buffer[BufferLength]; 141 HeapRegion* _hr_buffer[BufferLength];
138 HeapRegion **_hr_curr; 142 HeapRegion** _hr_curr;
139 143
140 OopsInHeapRegionClosure *_oc; 144 OopsInHeapRegionClosure* _oc;
141 double _closure_app_seconds; 145 double _closure_app_seconds;
142 146
143 void process_buffer () { 147 void process_buffer () {
144 148
145 assert((_hr_curr - _hr_buffer) == (_buffer_curr - _buffer), 149 assert((_hr_curr - _hr_buffer) == (_buffer_curr - _buffer),
146 "the two lengths should be the same"); 150 "the two lengths should be the same");
147 151
148 double start = os::elapsedTime(); 152 double start = os::elapsedTime();
149 HeapRegion **hr_curr = _hr_buffer; 153 HeapRegion** hr_curr = _hr_buffer;
150 HeapRegion *hr_prev = NULL; 154 HeapRegion* hr_prev = NULL;
151 for (oop **curr = _buffer; curr < _buffer_curr; ++curr) { 155 for (StarTask* curr = _buffer; curr < _buffer_curr; ++curr) {
152 HeapRegion *region = *hr_curr; 156 HeapRegion* region = *hr_curr;
153 if (region != hr_prev) { 157 if (region != hr_prev) {
154 _oc->set_region(region); 158 _oc->set_region(region);
155 hr_prev = region; 159 hr_prev = region;
156 } 160 }
157 _oc->do_oop(*curr); 161 if (curr->is_narrow()) {
162 assert(UseCompressedOops, "Error");
163 _oc->do_oop((narrowOop*)(*curr));
164 } else {
165 _oc->do_oop((oop*)(*curr));
166 }
158 ++hr_curr; 167 ++hr_curr;
159 } 168 }
160 _buffer_curr = _buffer; 169 _buffer_curr = _buffer;
161 _hr_curr = _hr_buffer; 170 _hr_curr = _hr_buffer;
162 _closure_app_seconds += (os::elapsedTime() - start); 171 _closure_app_seconds += (os::elapsedTime() - start);
163 } 172 }
164 173
165 public: 174 public:
166 virtual void do_oop(narrowOop *p) { 175 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
167 guarantee(false, "NYI"); 176 virtual void do_oop( oop* p) { do_oop_work(p); }
168 } 177
169 178 template <class T> void do_oop_work(T* p) {
170 virtual void do_oop(oop *p) {
171 if (_buffer_curr == _buffer_top) { 179 if (_buffer_curr == _buffer_top) {
172 assert(_hr_curr > _hr_buffer, "_hr_curr should be consistent with _buffer_curr"); 180 assert(_hr_curr > _hr_buffer, "_hr_curr should be consistent with _buffer_curr");
173 process_buffer(); 181 process_buffer();
174 } 182 }
175 183 StarTask new_ref(p);
176 *_buffer_curr = p; 184 *_buffer_curr = new_ref;
177 ++_buffer_curr; 185 ++_buffer_curr;
178 *_hr_curr = _from; 186 *_hr_curr = _from;
179 ++_hr_curr; 187 ++_hr_curr;
180 } 188 }
181 void done () { 189 void done () {