1/*
2 * Copyright (c) 2013, 2016, 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#include "precompiled.hpp"
25#include "gc/g1/g1BiasedArray.hpp"
26#include "unittest.hpp"
27
28class TestMappedArray : public G1BiasedMappedArray<int> {
29public:
30 virtual int default_value() const {
31 return 0xBAADBABE;
32 }
33 int* my_address_mapped_to(HeapWord* address) {
34 return address_mapped_to(address);
35 }
36};
37
38TEST_VM(G1BiasedArray, simple) {
39 const size_t REGION_SIZE_IN_WORDS = 512;
40 const size_t NUM_REGIONS = 20;
41 // Any value that is non-zero
42 HeapWord* fake_heap =
43 (HeapWord*) LP64_ONLY(0xBAAA00000) NOT_LP64(0xBA000000);
44
45 TestMappedArray array;
46 array.initialize(fake_heap, fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS,
47 REGION_SIZE_IN_WORDS * HeapWordSize);
48 const int DEFAULT_VALUE = array.default_value();
49
50 // Check address calculation (bounds)
51 ASSERT_EQ(fake_heap, array.bottom_address_mapped())
52 << "bottom mapped address should be "
53 << p2i(array.bottom_address_mapped())
54 << ", but is "
55 << p2i(fake_heap);
56 ASSERT_EQ(fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS,
57 array.end_address_mapped());
58
59 int* bottom = array.my_address_mapped_to(fake_heap);
60 ASSERT_EQ((void*) bottom, (void*) array.base());
61 int* end = array.my_address_mapped_to(fake_heap +
62 REGION_SIZE_IN_WORDS * NUM_REGIONS);
63 ASSERT_EQ((void*) end, (void*) (array.base() + array.length()));
64 // The entire array should contain default value elements
65 for (int* current = bottom; current < end; current++) {
66 ASSERT_EQ(DEFAULT_VALUE, *current);
67 }
68
69 // Test setting values in the table
70 HeapWord* region_start_address =
71 fake_heap + REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2);
72 HeapWord* region_end_address =
73 fake_heap + (REGION_SIZE_IN_WORDS * (NUM_REGIONS / 2) +
74 REGION_SIZE_IN_WORDS - 1);
75
76 // Set/get by address tests: invert some value; first retrieve one
77 int actual_value = array.get_by_index(NUM_REGIONS / 2);
78 array.set_by_index(NUM_REGIONS / 2, ~actual_value);
79 // Get the same value by address, should correspond to the start of the "region"
80 int value = array.get_by_address(region_start_address);
81 ASSERT_EQ(value, ~actual_value);
82 // Get the same value by address, at one HeapWord before the start
83 value = array.get_by_address(region_start_address - 1);
84 ASSERT_EQ(DEFAULT_VALUE, value);
85 // Get the same value by address, at the end of the "region"
86 value = array.get_by_address(region_end_address);
87 ASSERT_EQ(value, ~actual_value);
88 // Make sure the next value maps to another index
89 value = array.get_by_address(region_end_address + 1);
90 ASSERT_EQ(DEFAULT_VALUE, value);
91
92 // Reset the value in the array
93 array.set_by_address(region_start_address +
94 (region_end_address - region_start_address) / 2,
95 actual_value);
96
97 // The entire array should have the default value again
98 for (int* current = bottom; current < end; current++) {
99 ASSERT_EQ(DEFAULT_VALUE, *current);
100 }
101
102 // Set/get by index tests: invert some value
103 size_t index = NUM_REGIONS / 2;
104 actual_value = array.get_by_index(index);
105 array.set_by_index(index, ~actual_value);
106
107 value = array.get_by_index(index);
108 ASSERT_EQ(~actual_value, value);
109
110 value = array.get_by_index(index - 1);
111 ASSERT_EQ(DEFAULT_VALUE, value);
112
113 value = array.get_by_index(index + 1);
114 ASSERT_EQ(DEFAULT_VALUE, value);
115
116 array.set_by_index(0, 0);
117 value = array.get_by_index(0);
118 ASSERT_EQ(0, value);
119
120 array.set_by_index(array.length() - 1, 0);
121 value = array.get_by_index(array.length() - 1);
122 ASSERT_EQ(0, value);
123
124 array.set_by_index(index, 0);
125
126 // The array should have three zeros, and default values otherwise
127 size_t num_zeros = 0;
128 for (int* current = bottom; current < end; current++) {
129 ASSERT_TRUE(*current == DEFAULT_VALUE || *current == 0);
130 if (*current == 0) {
131 num_zeros++;
132 }
133 }
134 ASSERT_EQ((size_t) 3, num_zeros);
135}
136
137