TEST_VM(G1BiasedArray, simple) {
const size_t REGION_SIZE_IN_WORDS = 512;
const size_t NUM_REGIONS = 20;
// Any value that is non-zero
HeapWord* fake_heap =
(HeapWord*) LP64_ONLY(0xBAAA00000) NOT_LP64(0xBA000000);
TestMappedArray array;
array.initialize(fake_heap, fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS,
REGION_SIZE_IN_WORDS * HeapWordSize);
const int DEFAULT_VALUE = array.default_value();
// Check address calculation (bounds)
ASSERT_EQ(fake_heap, array.bottom_address_mapped())
<< "bottom mapped address should be "
<< p2i(array.bottom_address_mapped())
<< ", but is "
<< p2i(fake_heap);
ASSERT_EQ(fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS,
array.end_address_mapped());
int* bottom = array.my_address_mapped_to(fake_heap);
ASSERT_EQ((void*) bottom, (void*) array.base());
int* end = array.my_address_mapped_to(fake_heap +
REGION_SIZE_IN_WORDS * NUM_REGIONS);
ASSERT_EQ((void*) end, (void*) (array.base() + array.length()));
// The entire array should contain default value elements
for (int* current = bottom; current < end; current++) {
ASSERT_EQ(DEFAULT_VALUE, *current);
}
// Test setting values in the table
HeapWord* region_start_address =
fake_heap + REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2);
HeapWord* region_end_address =
fake_heap + (REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2) +
REGION_SIZE_IN_WORDS - 1);
// Set/get by address tests: invert some value; first retrieve one
int actual_value = array.get_by_index(NUM_REGIONS / 2);
array.set_by_index(NUM_REGIONS / 2, ~actual_value);
// Get the same value by address, should correspond to the start of the "region"
int value = array.get_by_address(region_start_address);
ASSERT_EQ(value, ~actual_value);
// Get the same value by address, at one HeapWord before the start
value = array.get_by_address(region_start_address - 1);
ASSERT_EQ(DEFAULT_VALUE, value);
// Get the same value by address, at the end of the "region"
value = array.get_by_address(region_end_address);
ASSERT_EQ(value, ~actual_value);
// Make sure the next value maps to another index
value = array.get_by_address(region_end_address + 1);
ASSERT_EQ(DEFAULT_VALUE, value);
// Reset the value in the array
array.set_by_address(region_start_address +
(region_end_address - region_start_address) / 2,
actual_value);
// The entire array should have the default value again
for (int* current = bottom; current < end; current++) {
ASSERT_EQ(DEFAULT_VALUE, *current);
}
// Set/get by index tests: invert some value
size_t index = NUM_REGIONS / 2;
actual_value = array.get_by_index(index);
array.set_by_index(index, ~actual_value);
value = array.get_by_index(index);
ASSERT_EQ(~actual_value, value);
value = array.get_by_index(index - 1);
ASSERT_EQ(DEFAULT_VALUE, value);
value = array.get_by_index(index + 1);
ASSERT_EQ(DEFAULT_VALUE, value);
array.set_by_index(0, 0);
value = array.get_by_index(0);
ASSERT_EQ(0, value);
array.set_by_index(array.length() - 1, 0);
value = array.get_by_index(array.length() - 1);
ASSERT_EQ(0, value);
array.set_by_index(index, 0);
// The array should have three zeros, and default values otherwise
size_t num_zeros = 0;
for (int* current = bottom; current < end; current++) {
ASSERT_TRUE(*current == DEFAULT_VALUE || *current == 0);
if (*current == 0) {
num_zeros++;
}
}
ASSERT_EQ((size_t) 3, num_zeros);
}
static void test_biasedarray() {
const size_t REGION_SIZE_IN_WORDS = 512;
const size_t NUM_REGIONS = 20;
HeapWord* fake_heap = (HeapWord*)LP64_ONLY(0xBAAA00000) NOT_LP64(0xBA000000); // Any value that is non-zero
TestMappedArray array;
array.initialize(fake_heap, fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS,
REGION_SIZE_IN_WORDS * HeapWordSize);
// Check address calculation (bounds)
assert(array.bottom_address_mapped() == fake_heap,
"bottom mapped address should be " PTR_FORMAT ", but is " PTR_FORMAT, p2i(fake_heap), p2i(array.bottom_address_mapped()));
assert(array.end_address_mapped() == (fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS), "must be");
int* bottom = array.address_mapped_to(fake_heap);
assert((void*)bottom == (void*) array.base(), "must be");
int* end = array.address_mapped_to(fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS);
assert((void*)end == (void*)(array.base() + array.length()), "must be");
// The entire array should contain default value elements
for (int* current = bottom; current < end; current++) {
assert(*current == array.default_value(), "must be");
}
// Test setting values in the table
HeapWord* region_start_address = fake_heap + REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2);
HeapWord* region_end_address = fake_heap + (REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2) + REGION_SIZE_IN_WORDS - 1);
// Set/get by address tests: invert some value; first retrieve one
int actual_value = array.get_by_index(NUM_REGIONS / 2);
array.set_by_index(NUM_REGIONS / 2, ~actual_value);
// Get the same value by address, should correspond to the start of the "region"
int value = array.get_by_address(region_start_address);
assert(value == ~actual_value, "must be");
// Get the same value by address, at one HeapWord before the start
value = array.get_by_address(region_start_address - 1);
assert(value == array.default_value(), "must be");
// Get the same value by address, at the end of the "region"
value = array.get_by_address(region_end_address);
assert(value == ~actual_value, "must be");
// Make sure the next value maps to another index
value = array.get_by_address(region_end_address + 1);
assert(value == array.default_value(), "must be");
// Reset the value in the array
array.set_by_address(region_start_address + (region_end_address - region_start_address) / 2, actual_value);
// The entire array should have the default value again
for (int* current = bottom; current < end; current++) {
assert(*current == array.default_value(), "must be");
}
// Set/get by index tests: invert some value
idx_t index = NUM_REGIONS / 2;
actual_value = array.get_by_index(index);
array.set_by_index(index, ~actual_value);
value = array.get_by_index(index);
assert(value == ~actual_value, "must be");
value = array.get_by_index(index - 1);
assert(value == array.default_value(), "must be");
value = array.get_by_index(index + 1);
assert(value == array.default_value(), "must be");
array.set_by_index(0, 0);
value = array.get_by_index(0);
assert(value == 0, "must be");
array.set_by_index(array.length() - 1, 0);
value = array.get_by_index(array.length() - 1);
assert(value == 0, "must be");
array.set_by_index(index, 0);
// The array should have three zeros, and default values otherwise
size_t num_zeros = 0;
for (int* current = bottom; current < end; current++) {
assert(*current == array.default_value() || *current == 0, "must be");
if (*current == 0) {
num_zeros++;
}
}
assert(num_zeros == 3, "must be");
}
