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"); }