329e55e7b0
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
318 lines
10 KiB
C++
318 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
|
|
#include "precompiled.hpp"
|
|
#include "code/nmethod.hpp"
|
|
#include "gc_implementation/g1/g1CodeCacheRemSet.hpp"
|
|
#include "memory/iterator.hpp"
|
|
|
|
G1CodeRootChunk::G1CodeRootChunk() : _top(NULL), _next(NULL), _prev(NULL) {
|
|
_top = bottom();
|
|
}
|
|
|
|
void G1CodeRootChunk::reset() {
|
|
_next = _prev = NULL;
|
|
_top = bottom();
|
|
}
|
|
|
|
void G1CodeRootChunk::nmethods_do(CodeBlobClosure* cl) {
|
|
nmethod** cur = bottom();
|
|
while (cur != _top) {
|
|
cl->do_code_blob(*cur);
|
|
cur++;
|
|
}
|
|
}
|
|
|
|
FreeList<G1CodeRootChunk> G1CodeRootSet::_free_list;
|
|
size_t G1CodeRootSet::_num_chunks_handed_out = 0;
|
|
|
|
G1CodeRootChunk* G1CodeRootSet::new_chunk() {
|
|
G1CodeRootChunk* result = _free_list.get_chunk_at_head();
|
|
if (result == NULL) {
|
|
result = new G1CodeRootChunk();
|
|
}
|
|
G1CodeRootSet::_num_chunks_handed_out++;
|
|
result->reset();
|
|
return result;
|
|
}
|
|
|
|
void G1CodeRootSet::free_chunk(G1CodeRootChunk* chunk) {
|
|
_free_list.return_chunk_at_head(chunk);
|
|
G1CodeRootSet::_num_chunks_handed_out--;
|
|
}
|
|
|
|
void G1CodeRootSet::free_all_chunks(FreeList<G1CodeRootChunk>* list) {
|
|
G1CodeRootSet::_num_chunks_handed_out -= list->count();
|
|
_free_list.prepend(list);
|
|
}
|
|
|
|
void G1CodeRootSet::purge_chunks(size_t keep_ratio) {
|
|
size_t keep = G1CodeRootSet::_num_chunks_handed_out * keep_ratio / 100;
|
|
|
|
if (keep >= (size_t)_free_list.count()) {
|
|
return;
|
|
}
|
|
|
|
FreeList<G1CodeRootChunk> temp;
|
|
temp.initialize();
|
|
temp.set_size(G1CodeRootChunk::word_size());
|
|
|
|
_free_list.getFirstNChunksFromList((size_t)_free_list.count() - keep, &temp);
|
|
|
|
G1CodeRootChunk* cur = temp.get_chunk_at_head();
|
|
while (cur != NULL) {
|
|
delete cur;
|
|
cur = temp.get_chunk_at_head();
|
|
}
|
|
}
|
|
|
|
size_t G1CodeRootSet::static_mem_size() {
|
|
return sizeof(_free_list) + sizeof(_num_chunks_handed_out);
|
|
}
|
|
|
|
size_t G1CodeRootSet::fl_mem_size() {
|
|
return _free_list.count() * _free_list.size();
|
|
}
|
|
|
|
void G1CodeRootSet::initialize() {
|
|
_free_list.initialize();
|
|
_free_list.set_size(G1CodeRootChunk::word_size());
|
|
}
|
|
|
|
G1CodeRootSet::G1CodeRootSet() : _list(), _length(0) {
|
|
_list.initialize();
|
|
_list.set_size(G1CodeRootChunk::word_size());
|
|
}
|
|
|
|
G1CodeRootSet::~G1CodeRootSet() {
|
|
clear();
|
|
}
|
|
|
|
void G1CodeRootSet::add(nmethod* method) {
|
|
if (!contains(method)) {
|
|
// Try to add the nmethod. If there is not enough space, get a new chunk.
|
|
if (_list.head() == NULL || _list.head()->is_full()) {
|
|
G1CodeRootChunk* cur = new_chunk();
|
|
_list.return_chunk_at_head(cur);
|
|
}
|
|
bool result = _list.head()->add(method);
|
|
guarantee(result, err_msg("Not able to add nmethod "PTR_FORMAT" to newly allocated chunk.", method));
|
|
_length++;
|
|
}
|
|
}
|
|
|
|
void G1CodeRootSet::remove(nmethod* method) {
|
|
G1CodeRootChunk* found = find(method);
|
|
if (found != NULL) {
|
|
bool result = found->remove(method);
|
|
guarantee(result, err_msg("could not find nmethod "PTR_FORMAT" during removal although we previously found it", method));
|
|
// eventually free completely emptied chunk
|
|
if (found->is_empty()) {
|
|
_list.remove_chunk(found);
|
|
free(found);
|
|
}
|
|
_length--;
|
|
}
|
|
assert(!contains(method), err_msg(PTR_FORMAT" still contains nmethod "PTR_FORMAT, this, method));
|
|
}
|
|
|
|
nmethod* G1CodeRootSet::pop() {
|
|
do {
|
|
G1CodeRootChunk* cur = _list.head();
|
|
if (cur == NULL) {
|
|
assert(_length == 0, "when there are no chunks, there should be no elements");
|
|
return NULL;
|
|
}
|
|
nmethod* result = cur->pop();
|
|
if (result != NULL) {
|
|
_length--;
|
|
return result;
|
|
} else {
|
|
free(_list.get_chunk_at_head());
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
G1CodeRootChunk* G1CodeRootSet::find(nmethod* method) {
|
|
G1CodeRootChunk* cur = _list.head();
|
|
while (cur != NULL) {
|
|
if (cur->contains(method)) {
|
|
return cur;
|
|
}
|
|
cur = (G1CodeRootChunk*)cur->next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void G1CodeRootSet::free(G1CodeRootChunk* chunk) {
|
|
free_chunk(chunk);
|
|
}
|
|
|
|
bool G1CodeRootSet::contains(nmethod* method) {
|
|
return find(method) != NULL;
|
|
}
|
|
|
|
void G1CodeRootSet::clear() {
|
|
free_all_chunks(&_list);
|
|
_length = 0;
|
|
}
|
|
|
|
void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const {
|
|
G1CodeRootChunk* cur = _list.head();
|
|
while (cur != NULL) {
|
|
cur->nmethods_do(blk);
|
|
cur = (G1CodeRootChunk*)cur->next();
|
|
}
|
|
}
|
|
|
|
size_t G1CodeRootSet::mem_size() {
|
|
return sizeof(this) + _list.count() * _list.size();
|
|
}
|
|
|
|
#ifndef PRODUCT
|
|
|
|
void G1CodeRootSet::test() {
|
|
initialize();
|
|
|
|
assert(_free_list.count() == 0, "Free List must be empty");
|
|
assert(_num_chunks_handed_out == 0, "No elements must have been handed out yet");
|
|
|
|
// The number of chunks that we allocate for purge testing.
|
|
size_t const num_chunks = 10;
|
|
{
|
|
G1CodeRootSet set1;
|
|
assert(set1.is_empty(), "Code root set must be initially empty but is not.");
|
|
|
|
set1.add((nmethod*)1);
|
|
assert(_num_chunks_handed_out == 1,
|
|
err_msg("Must have allocated and handed out one chunk, but handed out "
|
|
SIZE_FORMAT" chunks", _num_chunks_handed_out));
|
|
assert(set1.length() == 1, err_msg("Added exactly one element, but set contains "
|
|
SIZE_FORMAT" elements", set1.length()));
|
|
|
|
// G1CodeRootChunk::word_size() is larger than G1CodeRootChunk::num_entries which
|
|
// we cannot access.
|
|
for (uint i = 0; i < G1CodeRootChunk::word_size() + 1; i++) {
|
|
set1.add((nmethod*)1);
|
|
}
|
|
assert(_num_chunks_handed_out == 1,
|
|
err_msg("Duplicate detection must have prevented allocation of further "
|
|
"chunks but contains "SIZE_FORMAT, _num_chunks_handed_out));
|
|
assert(set1.length() == 1,
|
|
err_msg("Duplicate detection should not have increased the set size but "
|
|
"is "SIZE_FORMAT, set1.length()));
|
|
|
|
size_t num_total_after_add = G1CodeRootChunk::word_size() + 1;
|
|
for (size_t i = 0; i < num_total_after_add - 1; i++) {
|
|
set1.add((nmethod*)(2 + i));
|
|
}
|
|
assert(_num_chunks_handed_out > 1,
|
|
"After adding more code roots, more than one chunks should have been handed out");
|
|
assert(set1.length() == num_total_after_add,
|
|
err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they "
|
|
"need to be in the set, but there are only "SIZE_FORMAT,
|
|
num_total_after_add, set1.length()));
|
|
|
|
size_t num_popped = 0;
|
|
while (set1.pop() != NULL) {
|
|
num_popped++;
|
|
}
|
|
assert(num_popped == num_total_after_add,
|
|
err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" "
|
|
"were added", num_popped, num_total_after_add));
|
|
assert(_num_chunks_handed_out == 0,
|
|
err_msg("After popping all elements, all chunks must have been returned "
|
|
"but are still "SIZE_FORMAT, _num_chunks_handed_out));
|
|
|
|
purge_chunks(0);
|
|
assert(_free_list.count() == 0,
|
|
err_msg("After purging everything, the free list must be empty but still "
|
|
"contains "SIZE_FORMAT" chunks", _free_list.count()));
|
|
|
|
// Add some more handed out chunks.
|
|
size_t i = 0;
|
|
while (_num_chunks_handed_out < num_chunks) {
|
|
set1.add((nmethod*)i);
|
|
i++;
|
|
}
|
|
|
|
{
|
|
// Generate chunks on the free list.
|
|
G1CodeRootSet set2;
|
|
size_t i = 0;
|
|
while (_num_chunks_handed_out < num_chunks * 2) {
|
|
set2.add((nmethod*)i);
|
|
i++;
|
|
}
|
|
// Exit of the scope of the set2 object will call the destructor that generates
|
|
// num_chunks elements on the free list.
|
|
}
|
|
|
|
assert(_num_chunks_handed_out == num_chunks,
|
|
err_msg("Deletion of the second set must have resulted in giving back "
|
|
"those, but there is still "SIZE_FORMAT" handed out, expecting "
|
|
SIZE_FORMAT, _num_chunks_handed_out, num_chunks));
|
|
assert((size_t)_free_list.count() == num_chunks,
|
|
err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
|
|
"but there are only "SIZE_FORMAT, num_chunks, _free_list.count()));
|
|
|
|
size_t const test_percentage = 50;
|
|
purge_chunks(test_percentage);
|
|
assert(_num_chunks_handed_out == num_chunks,
|
|
err_msg("Purging must not hand out chunks but there are "SIZE_FORMAT,
|
|
_num_chunks_handed_out));
|
|
assert((size_t)_free_list.count() == (ssize_t)(num_chunks * test_percentage / 100),
|
|
err_msg("Must have purged "SIZE_FORMAT" percent of "SIZE_FORMAT" chunks"
|
|
"but there are "SSIZE_FORMAT, test_percentage, num_chunks,
|
|
_free_list.count()));
|
|
// Purge the remainder of the chunks on the free list.
|
|
purge_chunks(0);
|
|
assert(_free_list.count() == 0, "Free List must be empty");
|
|
assert(_num_chunks_handed_out == num_chunks,
|
|
err_msg("Expected to be "SIZE_FORMAT" chunks handed out from the first set "
|
|
"but there are "SIZE_FORMAT, num_chunks, _num_chunks_handed_out));
|
|
|
|
// Exit of the scope of the set1 object will call the destructor that generates
|
|
// num_chunks additional elements on the free list.
|
|
}
|
|
|
|
assert(_num_chunks_handed_out == 0,
|
|
err_msg("Deletion of the only set must have resulted in no chunks handed "
|
|
"out, but there is still "SIZE_FORMAT" handed out", _num_chunks_handed_out));
|
|
assert((size_t)_free_list.count() == num_chunks,
|
|
err_msg("After freeing "SIZE_FORMAT" chunks, they must be on the free list "
|
|
"but there are only "SSIZE_FORMAT, num_chunks, _free_list.count()));
|
|
|
|
// Restore initial state.
|
|
purge_chunks(0);
|
|
assert(_free_list.count() == 0, "Free List must be empty");
|
|
assert(_num_chunks_handed_out == 0, "No elements must have been handed out yet");
|
|
}
|
|
|
|
void TestCodeCacheRemSet_test() {
|
|
G1CodeRootSet::test();
|
|
}
|
|
#endif
|