jdk-24/test/hotspot/gtest/metaspace/test_blocktree.cpp
Roman Kennke 44ec501a41 8305895: Implement JEP 450: Compact Object Headers (Experimental)
Co-authored-by: Sandhya Viswanathan <sviswanathan@openjdk.org>
Co-authored-by: Martin Doerr <mdoerr@openjdk.org>
Co-authored-by: Hamlin Li <mli@openjdk.org>
Co-authored-by: Thomas Stuefe <stuefe@openjdk.org>
Co-authored-by: Amit Kumar <amitkumar@openjdk.org>
Co-authored-by: Stefan Karlsson <stefank@openjdk.org>
Co-authored-by: Coleen Phillimore <coleenp@openjdk.org>
Co-authored-by: Axel Boldt-Christmas <aboldtch@openjdk.org>
Reviewed-by: coleenp, stefank, stuefe, phh, ihse, lmesnik, tschatzl, matsaave, rcastanedalo, vpaprotski, yzheng, egahlin
2024-11-08 17:21:39 +00:00

449 lines
12 KiB
C++

/*
* Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020 SAP SE. 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 "memory/metaspace/blockTree.hpp"
#include "memory/metaspace/counters.hpp"
#include "memory/metaspace/metablock.hpp"
#include "memory/resourceArea.hpp"
// #define LOG_PLEASE
#include "metaspaceGtestCommon.hpp"
using metaspace::BlockTree;
using metaspace::MemRangeCounter;
using metaspace::MetaBlock;
struct TestedBlockTree : public BlockTree {
void add_block(MetaWord* p, size_t word_size) {
BlockTree::add_block(MetaBlock(p, word_size));
}
MetaWord* remove_block(size_t requested_size, size_t* real_size) {
MetaBlock result = BlockTree::remove_block(requested_size);
(*real_size) = result.word_size();
return result.base();
}
};
// Small helper. Given a 0-terminated array of sizes, a feeder buffer and a tree,
// add blocks of these sizes to the tree in the order they appear in the array.
static void create_nodes(const size_t sizes[], FeederBuffer& fb, TestedBlockTree& bt) {
for (int i = 0; sizes[i] > 0; i ++) {
size_t s = sizes[i];
MetaWord* p = fb.get(s);
bt.add_block(p, s);
}
}
#define CHECK_BT_CONTENT(bt, expected_num, expected_size) { \
EXPECT_EQ(bt.count(), (unsigned)expected_num); \
EXPECT_EQ(bt.total_size(), (size_t)expected_size); \
if (expected_num == 0) { \
EXPECT_TRUE(bt.is_empty()); \
} else { \
EXPECT_FALSE(bt.is_empty()); \
} \
}
TEST_VM(metaspace, BlockTree_basic) {
TestedBlockTree bt;
CHECK_BT_CONTENT(bt, 0, 0);
size_t real_size = 0;
MetaWord* p = nullptr;
MetaWord arr[10000];
ASSERT_LE(BlockTree::MinWordSize, (size_t)6); // Sanity check. Adjust if Node is changed.
const size_t minws = BlockTree::MinWordSize;
// remove_block from empty tree should yield nothing
p = bt.remove_block(minws, &real_size);
EXPECT_NULL(p);
EXPECT_0(real_size);
CHECK_BT_CONTENT(bt, 0, 0);
// Add some blocks and retrieve them right away.
size_t sizes[] = {
minws, // smallest possible
minws + 10,
1024,
4711,
0
};
for (int i = 0; sizes[i] > 0; i++) {
bt.add_block(arr, sizes[i]);
CHECK_BT_CONTENT(bt, 1, sizes[i]);
DEBUG_ONLY(bt.verify();)
MetaWord* p = bt.remove_block(sizes[i], &real_size);
EXPECT_EQ(p, arr);
EXPECT_EQ(real_size, (size_t)sizes[i]);
CHECK_BT_CONTENT(bt, 0, 0);
}
}
// Helper for test_find_nearest_fit_with_tree.
// Out of an array of sizes return the closest upper match to a requested size.
// Returns SIZE_MAX if none found.
static size_t helper_find_nearest_fit(const size_t sizes[], size_t request_size) {
size_t best = SIZE_MAX;
for (int i = 0; sizes[i] > 0; i++) {
if (sizes[i] >= request_size && sizes[i] < best) {
best = sizes[i];
}
}
return best;
}
// Given a sequence of (0-terminated) sizes, add blocks of those sizes to the tree in the order given. Then, ask
// for a request size and check that it is the expected result.
static void test_find_nearest_fit_with_tree(const size_t sizes[], size_t request_size) {
TestedBlockTree bt;
FeederBuffer fb(4 * K);
create_nodes(sizes, fb, bt);
DEBUG_ONLY(bt.verify();)
size_t expected_size = helper_find_nearest_fit(sizes, request_size);
size_t real_size = 0;
MetaWord* p = bt.remove_block(request_size, &real_size);
if (expected_size != SIZE_MAX) {
EXPECT_NOT_NULL(p);
EXPECT_EQ(real_size, expected_size);
} else {
EXPECT_NULL(p);
EXPECT_0(real_size);
}
LOG(SIZE_FORMAT ": " SIZE_FORMAT ".", request_size, real_size);
}
TEST_VM(metaspace, BlockTree_find_nearest_fit) {
// Test tree for test_find_nearest_fit looks like this
// 30
// / \
// / \
// / \
// 17 50
// / \ / \
// / \ / \
// 10 28 32 51
// \
// 35
static const size_t sizes[] = {
30, 17, 10, 28,
50, 32, 51, 35,
0 // stop
};
TestedBlockTree bt;
FeederBuffer fb(4 * K);
create_nodes(sizes, fb, bt);
for (int i = BlockTree::MinWordSize; i <= 60; i ++) {
test_find_nearest_fit_with_tree(sizes, i);
}
}
// Test repeated adding and removing of blocks of the same size, which
// should exercise the list-part of the tree.
TEST_VM(metaspace, BlockTree_basic_siblings)
{
TestedBlockTree bt;
FeederBuffer fb(4 * K);
CHECK_BT_CONTENT(bt, 0, 0);
const size_t test_size = BlockTree::MinWordSize;
const int num = 10;
for (int i = 0; i < num; i++) {
bt.add_block(fb.get(test_size), test_size);
CHECK_BT_CONTENT(bt, i + 1, (i + 1) * test_size);
}
DEBUG_ONLY(bt.verify();)
for (int i = num; i > 0; i --) {
size_t real_size = 4711;
MetaWord* p = bt.remove_block(test_size, &real_size);
EXPECT_TRUE(fb.is_valid_pointer(p));
EXPECT_EQ(real_size, (size_t)test_size);
CHECK_BT_CONTENT(bt, i - 1, (i - 1) * test_size);
}
}
#ifdef ASSERT
TEST_VM(metaspace, BlockTree_print_test) {
static const size_t sizes[] = {
30, 17, 10, 28,
50, 32, 51, 35,
0 // stop
};
TestedBlockTree bt;
FeederBuffer fb(4 * K);
create_nodes(sizes, fb, bt);
ResourceMark rm;
stringStream ss;
bt.print_tree(&ss);
LOG("%s", ss.as_string());
}
// Test that an overwritten node would result in an assert and a printed tree
TEST_VM_ASSERT_MSG(metaspace, BlockTree_overwriter_test, ".*failed: Invalid node") {
static const size_t sizes1[] = { 30, 17, 0 };
static const size_t sizes2[] = { 12, 12, 0 };
TestedBlockTree bt;
FeederBuffer fb(4 * K);
// some nodes...
create_nodes(sizes1, fb, bt);
// a node we will break...
MetaWord* p_broken = fb.get(12);
bt.add_block(p_broken, 12);
// some more nodes...
create_nodes(sizes2, fb, bt);
// overwrite node memory (only the very first byte), then verify tree.
// Verification should catch the broken canary, print the tree,
// then assert.
LOG("Will break node at " PTR_FORMAT ".", p2i(p_broken));
tty->print_cr("Death test, please ignore the following \"Invalid node\" printout.");
*((char*)p_broken) = '\0';
bt.verify();
}
#endif
class BlockTreeTest {
FeederBuffer _fb;
TestedBlockTree _bt[2];
MemRangeCounter _cnt[2];
RandSizeGenerator _rgen;
#define CHECK_COUNTERS \
CHECK_BT_CONTENT(_bt[0], _cnt[0].count(), _cnt[0].total_size()) \
CHECK_BT_CONTENT(_bt[1], _cnt[1].count(), _cnt[1].total_size())
#define CHECK_COUNTERS_ARE_0 \
CHECK_BT_CONTENT(_bt[0], 0, 0) \
CHECK_BT_CONTENT(_bt[1], 0, 0)
#ifdef ASSERT
void verify_trees() {
_bt[0].verify();
_bt[1].verify();
}
#endif
enum feeding_pattern_t {
scatter = 1,
left_right = 2,
right_left = 3
};
// Feed the whole feeder buffer to the trees, according to feeding_pattern.
void feed_all(feeding_pattern_t feeding_pattern) {
MetaWord* p = nullptr;
unsigned added = 0;
// If we feed in small graining, we cap the number of blocks to limit test duration.
const unsigned max_blocks = 2000;
size_t old_feeding_size = feeding_pattern == right_left ? _rgen.max() : _rgen.min();
do {
size_t s = 0;
switch (feeding_pattern) {
case scatter:
// fill completely random
s =_rgen.get();
break;
case left_right:
// fill in ascending order to provoke a misformed tree.
s = MIN2(_rgen.get(), old_feeding_size);
old_feeding_size = s;
break;
case right_left:
// same, but descending.
s = MAX2(_rgen.get(), old_feeding_size);
old_feeding_size = s;
break;
}
// Get a block from the feeder buffer; feed it alternatingly to either tree.
p = _fb.get(s);
if (p != nullptr) {
int which = added % 2;
added++;
_bt[which].add_block(p, s);
_cnt[which].add(s);
CHECK_COUNTERS
}
} while (p != nullptr && added < max_blocks);
DEBUG_ONLY(verify_trees();)
// Trees should contain the same number of nodes (+-1)
EXPECT_TRUE(_bt[0].count() == _bt[1].count() ||
_bt[0].count() == _bt[1].count() + 1);
}
void ping_pong_loop(int iterations) {
// We loop and in each iteration randomly retrieve a block from one tree and add it to another.
for (int i = 0; i < iterations; i++) {
int taker = 0;
int giver = 1;
if ((os::random() % 10) > 5) {
giver = 0; taker = 1;
}
size_t s =_rgen.get();
size_t real_size = 0;
MetaWord* p = _bt[giver].remove_block(s, &real_size);
if (p != nullptr) {
ASSERT_TRUE(_fb.is_valid_range(p, real_size));
ASSERT_GE(real_size, s);
_bt[taker].add_block(p, real_size);
_cnt[giver].sub(real_size);
_cnt[taker].add(real_size);
CHECK_COUNTERS;
}
#ifdef ASSERT
if (true) {//i % 1000 == 0) {
verify_trees();
}
#endif
}
}
// Drain the trees. While draining, observe the order of the drained items.
void drain_all() {
for (int which = 0; which < 2; which++) {
TestedBlockTree* bt = _bt + which;
size_t last_size = 0;
while (!bt->is_empty()) {
// We only query for the minimal size. Actually returned size should be
// monotonously growing since remove_block should always return the closest fit.
size_t real_size = 4711;
MetaWord* p = bt->remove_block(BlockTree::MinWordSize, &real_size);
ASSERT_TRUE(_fb.is_valid_range(p, real_size));
ASSERT_GE(real_size, last_size);
last_size = real_size;
_cnt[which].sub(real_size);
CHECK_COUNTERS;
DEBUG_ONLY(bt->verify();)
}
}
}
void test(feeding_pattern_t feeding_pattern) {
CHECK_COUNTERS_ARE_0
feed_all(feeding_pattern);
LOG("Blocks in circulation: bt1=%d:" SIZE_FORMAT ", bt2=%d:" SIZE_FORMAT ".",
_bt[0].count(), _bt[0].total_size(),
_bt[1].count(), _bt[1].total_size());
ping_pong_loop(5000);
LOG("After Pingpong: bt1=%d:" SIZE_FORMAT ", bt2=%d:" SIZE_FORMAT ".",
_bt[0].count(), _bt[0].total_size(),
_bt[1].count(), _bt[1].total_size());
drain_all();
CHECK_COUNTERS_ARE_0
}
public:
BlockTreeTest(size_t min_word_size, size_t max_word_size) :
_fb(2 * M),
_bt(),
_rgen(min_word_size, max_word_size)
{
CHECK_COUNTERS;
DEBUG_ONLY(verify_trees();)
}
void test_scatter() { test(scatter); }
void test_right_left() { test(right_left); }
void test_left_right() { test(left_right); }
};
#define DO_TEST(name, feedingpattern, min, max) \
TEST_VM(metaspace, BlockTree_##name##_##feedingpattern) { \
BlockTreeTest btt(min, max); \
btt.test_##feedingpattern(); \
}
#define DO_TEST_ALL_PATTERNS(name, min, max) \
DO_TEST(name, scatter, min, max) \
DO_TEST(name, right_left, min, max) \
DO_TEST(name, left_right, min, max)
DO_TEST_ALL_PATTERNS(wide, BlockTree::MinWordSize, 128 * K);
DO_TEST_ALL_PATTERNS(narrow, BlockTree::MinWordSize, 16)
DO_TEST_ALL_PATTERNS(129, BlockTree::MinWordSize, 129)
DO_TEST_ALL_PATTERNS(4K, BlockTree::MinWordSize, 4*K)