Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp @ 17753:191174b49bec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8035406: Improve data structure for Code Cache remembered sets Summary: Change the code cache remembered sets data structure from a GrowableArray to a chunked list of nmethods. This makes the data structure more amenable to parallelization, and decreases freeing time. Reviewed-by: mgerdin, brutisso
author tschatzl
date Mon, 24 Mar 2014 15:30:14 +0100
parents
children 78bbf4d43a14
comparison
equal deleted inserted replaced
17750:f53edbc2b728 17753:191174b49bec
1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
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
26 #include "precompiled.hpp"
27 #include "code/nmethod.hpp"
28 #include "gc_implementation/g1/g1CodeCacheRemSet.hpp"
29 #include "memory/iterator.hpp"
30
31 G1CodeRootChunk::G1CodeRootChunk() : _top(NULL), _next(NULL), _prev(NULL) {
32 _top = bottom();
33 }
34
35 void G1CodeRootChunk::reset() {
36 _next = _prev = NULL;
37 _top = bottom();
38 }
39
40 void G1CodeRootChunk::nmethods_do(CodeBlobClosure* cl) {
41 nmethod** cur = bottom();
42 while (cur != _top) {
43 cl->do_code_blob(*cur);
44 cur++;
45 }
46 }
47
48 FreeList<G1CodeRootChunk> G1CodeRootSet::_free_list;
49 size_t G1CodeRootSet::_num_chunks_handed_out = 0;
50
51 G1CodeRootChunk* G1CodeRootSet::new_chunk() {
52 G1CodeRootChunk* result = _free_list.get_chunk_at_head();
53 if (result == NULL) {
54 result = new G1CodeRootChunk();
55 }
56 G1CodeRootSet::_num_chunks_handed_out++;
57 result->reset();
58 return result;
59 }
60
61 void G1CodeRootSet::free_chunk(G1CodeRootChunk* chunk) {
62 _free_list.return_chunk_at_head(chunk);
63 G1CodeRootSet::_num_chunks_handed_out--;
64 }
65
66 void G1CodeRootSet::free_all_chunks(FreeList<G1CodeRootChunk>* list) {
67 G1CodeRootSet::_num_chunks_handed_out -= list->count();
68 _free_list.prepend(list);
69 }
70
71 void G1CodeRootSet::purge_chunks(size_t keep_ratio) {
72 size_t keep = G1CodeRootSet::_num_chunks_handed_out * keep_ratio / 100;
73
74 if (keep >= (size_t)_free_list.count()) {
75 return;
76 }
77
78 FreeList<G1CodeRootChunk> temp;
79 temp.initialize();
80 temp.set_size(G1CodeRootChunk::word_size());
81
82 _free_list.getFirstNChunksFromList((size_t)_free_list.count() - keep, &temp);
83
84 G1CodeRootChunk* cur = temp.get_chunk_at_head();
85 while (cur != NULL) {
86 delete cur;
87 cur = temp.get_chunk_at_head();
88 }
89 }
90
91 size_t G1CodeRootSet::static_mem_size() {
92 return sizeof(_free_list) + sizeof(_num_chunks_handed_out);
93 }
94
95 size_t G1CodeRootSet::fl_mem_size() {
96 return _free_list.count() * _free_list.size();
97 }
98
99 void G1CodeRootSet::initialize() {
100 _free_list.initialize();
101 _free_list.set_size(G1CodeRootChunk::word_size());
102 }
103
104 G1CodeRootSet::G1CodeRootSet() : _list(), _length(0) {
105 _list.initialize();
106 _list.set_size(G1CodeRootChunk::word_size());
107 }
108
109 G1CodeRootSet::~G1CodeRootSet() {
110 clear();
111 }
112
113 void G1CodeRootSet::add(nmethod* method) {
114 if (!contains(method)) {
115 // Try to add the nmethod. If there is not enough space, get a new chunk.
116 if (_list.head() == NULL || _list.head()->is_full()) {
117 G1CodeRootChunk* cur = new_chunk();
118 _list.return_chunk_at_head(cur);
119 }
120 bool result = _list.head()->add(method);
121 guarantee(result, err_msg("Not able to add nmethod "PTR_FORMAT" to newly allocated chunk.", method));
122 _length++;
123 }
124 }
125
126 void G1CodeRootSet::remove(nmethod* method) {
127 G1CodeRootChunk* found = find(method);
128 if (found != NULL) {
129 bool result = found->remove(method);
130 guarantee(result, err_msg("could not find nmethod "PTR_FORMAT" during removal although we previously found it", method));
131 // eventually free completely emptied chunk
132 if (found->is_empty()) {
133 _list.remove_chunk(found);
134 free(found);
135 }
136 _length--;
137 }
138 assert(!contains(method), err_msg(PTR_FORMAT" still contains nmethod "PTR_FORMAT, this, method));
139 }
140
141 nmethod* G1CodeRootSet::pop() {
142 do {
143 G1CodeRootChunk* cur = _list.head();
144 if (cur == NULL) {
145 assert(_length == 0, "when there are no chunks, there should be no elements");
146 return NULL;
147 }
148 nmethod* result = cur->pop();
149 if (result != NULL) {
150 _length--;
151 return result;
152 } else {
153 free(_list.get_chunk_at_head());
154 }
155 } while (true);
156 }
157
158 G1CodeRootChunk* G1CodeRootSet::find(nmethod* method) {
159 G1CodeRootChunk* cur = _list.head();
160 while (cur != NULL) {
161 if (cur->contains(method)) {
162 return cur;
163 }
164 cur = (G1CodeRootChunk*)cur->next();
165 }
166 return NULL;
167 }
168
169 void G1CodeRootSet::free(G1CodeRootChunk* chunk) {
170 free_chunk(chunk);
171 }
172
173 bool G1CodeRootSet::contains(nmethod* method) {
174 return find(method) != NULL;
175 }
176
177 void G1CodeRootSet::clear() {
178 free_all_chunks(&_list);
179 _length = 0;
180 }
181
182 void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const {
183 G1CodeRootChunk* cur = _list.head();
184 while (cur != NULL) {
185 cur->nmethods_do(blk);
186 cur = (G1CodeRootChunk*)cur->next();
187 }
188 }
189
190 size_t G1CodeRootSet::mem_size() {
191 return sizeof(this) + _list.count() * _list.size();
192 }
193
194 #ifndef PRODUCT
195
196 void G1CodeRootSet::test() {
197 initialize();
198
199 assert(_free_list.count() == 0, "Free List must be empty");
200 assert(_num_chunks_handed_out == 0, "No elements must have been handed out yet");
201
202 // The number of chunks that we allocate for purge testing.
203 size_t const num_chunks = 10;
204 {
205 G1CodeRootSet set1;
206 assert(set1.is_empty(), "Code root set must be initially empty but is not.");
207
208 set1.add((nmethod*)1);
209 assert(_num_chunks_handed_out == 1,
210 err_msg("Must have allocated and handed out one chunk, but handed out "
211 SIZE_FORMAT" chunks", _num_chunks_handed_out));
212 assert(set1.length() == 1, err_msg("Added exactly one element, but set contains "
213 SIZE_FORMAT" elements", set1.length()));
214
215 // G1CodeRootChunk::word_size() is larger than G1CodeRootChunk::num_entries which
216 // we cannot access.
217 for (uint i = 0; i < G1CodeRootChunk::word_size() + 1; i++) {
218 set1.add((nmethod*)1);
219 }
220 assert(_num_chunks_handed_out == 1,
221 err_msg("Duplicate detection must have prevented allocation of further "
222 "chunks but contains "SIZE_FORMAT, _num_chunks_handed_out));
223 assert(set1.length() == 1,
224 err_msg("Duplicate detection should not have increased the set size but "
225 "is "SIZE_FORMAT, set1.length()));
226
227 size_t num_total_after_add = G1CodeRootChunk::word_size() + 1;
228 for (size_t i = 0; i < num_total_after_add - 1; i++) {
229 set1.add((nmethod*)(2 + i));
230 }
231 assert(_num_chunks_handed_out > 1,
232 "After adding more code roots, more than one chunks should have been handed out");
233 assert(set1.length() == num_total_after_add,
234 err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they "
235 "need to be in the set, but there are only "SIZE_FORMAT,
236 num_total_after_add, set1.length()));
237
238 size_t num_popped = 0;
239 while (set1.pop() != NULL) {
240 num_popped++;
241 }
242 assert(num_popped == num_total_after_add,
243 err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" "
244 "were added", num_popped, num_total_after_add));
245 assert(_num_chunks_handed_out == 0,
246 err_msg("After popping all elements, all chunks must have been returned "
247 "but are still "SIZE_FORMAT, _num_chunks_handed_out));
248
249 purge_chunks(0);
250 assert(_free_list.count() == 0,
251 err_msg("After purging everything, the free list must be empty but still "
252 "contains "SIZE_FORMAT" chunks", _free_list.count()));
253
254 // Add some more handed out chunks.
255 size_t i = 0;
256 while (_num_chunks_handed_out < num_chunks) {
257 set1.add((nmethod*)i);
258 i++;
259 }
260
261 {
262 // Generate chunks on the free list.
263 G1CodeRootSet set2;
264 size_t i = 0;
265 while (_num_chunks_handed_out < num_chunks * 2) {
266 set2.add((nmethod*)i);
267 i++;
268 }
269 // Exit of the scope of the set2 object will call the destructor that generates
270 // num_chunks elements on the free list.
271 }
272
273 assert(_num_chunks_handed_out == num_chunks,
274 err_msg("Deletion of the second set must have resulted in giving back "
275 "those, but there is still "SIZE_FORMAT" handed out, expecting "
276 SIZE_FORMAT, _num_chunks_handed_out, num_chunks));
277 assert((size_t)_free_list.count() == num_chunks,
278 err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
279 "but there are only "SIZE_FORMAT, num_chunks, _free_list.count()));
280
281 size_t const test_percentage = 50;
282 purge_chunks(test_percentage);
283 assert(_num_chunks_handed_out == num_chunks,
284 err_msg("Purging must not hand out chunks but there are "SIZE_FORMAT,
285 _num_chunks_handed_out));
286 assert((size_t)_free_list.count() == (ssize_t)(num_chunks * test_percentage / 100),
287 err_msg("Must have purged "SIZE_FORMAT" percent of "SIZE_FORMAT" chunks"
288 "but there are "SSIZE_FORMAT, test_percentage, num_chunks,
289 _free_list.count()));
290 // Purge the remainder of the chunks on the free list.
291 purge_chunks(0);
292 assert(_free_list.count() == 0, "Free List must be empty");
293 assert(_num_chunks_handed_out == num_chunks,
294 err_msg("Expected to be "SIZE_FORMAT" chunks handed out from the first set "
295 "but there are "SIZE_FORMAT, num_chunks, _num_chunks_handed_out));
296
297 // Exit of the scope of the set1 object will call the destructor that generates
298 // num_chunks additional elements on the free list.
299 }
300
301 assert(_num_chunks_handed_out == 0,
302 err_msg("Deletion of the only set must have resulted in no chunks handed "
303 "out, but there is still "SIZE_FORMAT" handed out", _num_chunks_handed_out));
304 assert((size_t)_free_list.count() == num_chunks,
305 err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
306 "but there are only "SSIZE_FORMAT, num_chunks, _free_list.count()));
307
308 // Restore initial state.
309 purge_chunks(0);
310 assert(_free_list.count() == 0, "Free List must be empty");
311 assert(_num_chunks_handed_out == 0, "No elements must have been handed out yet");
312 }
313
314 void TestCodeCacheRemSet_test() {
315 G1CodeRootSet::test();
316 }
317 #endif