1 | /* |
2 | * Copyright (c) 2018, 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 "memory/virtualspace.hpp" |
26 | #include "runtime/os.hpp" |
27 | #include "oops/oop.hpp" |
28 | #include "utilities/align.hpp" |
29 | #include "unittest.hpp" |
30 | |
31 | namespace { |
32 | class MemoryReleaser { |
33 | ReservedSpace* const _rs; |
34 | public: |
35 | MemoryReleaser(ReservedSpace* rs) : _rs(rs) { } |
36 | ~MemoryReleaser() { |
37 | if (_rs->special()) { |
38 | EXPECT_TRUE(os::release_memory_special(_rs->base(), _rs->size())); |
39 | } else { |
40 | EXPECT_TRUE(os::release_memory(_rs->base(), _rs->size())); |
41 | } |
42 | } |
43 | }; |
44 | |
45 | static void small_page_write(void* addr, size_t size) { |
46 | size_t page_size = os::vm_page_size(); |
47 | |
48 | char* end = (char*) addr + size; |
49 | for (char* p = (char*) addr; p < end; p += page_size) { |
50 | *p = 1; |
51 | } |
52 | } |
53 | |
54 | // have to use these functions, as gtest's _PRED macros don't like is_aligned |
55 | // nor (is_aligned<size_t, size_t>) |
56 | static bool is_size_aligned(size_t size, size_t alignment) { |
57 | return is_aligned(size, alignment); |
58 | } |
59 | static bool is_ptr_aligned(void* ptr, size_t alignment) { |
60 | return is_aligned(ptr, alignment); |
61 | } |
62 | |
63 | static void test_reserved_size(size_t size) { |
64 | ASSERT_PRED2(is_size_aligned, size, os::vm_allocation_granularity()); |
65 | |
66 | ReservedSpace rs(size); |
67 | MemoryReleaser releaser(&rs); |
68 | |
69 | EXPECT_TRUE(rs.base() != NULL) << "rs.special: " << rs.special(); |
70 | EXPECT_EQ(size, rs.size()) << "rs.special: " << rs.special(); |
71 | |
72 | if (rs.special()) { |
73 | small_page_write(rs.base(), size); |
74 | } |
75 | } |
76 | |
77 | static void test_reserved_size_alignment(size_t size, size_t alignment) { |
78 | ASSERT_PRED2(is_size_aligned, size, alignment) << "Incorrect input parameters" ; |
79 | |
80 | ReservedSpace rs(size, alignment, UseLargePages, (char *) NULL); |
81 | |
82 | ASSERT_TRUE(rs.base() != NULL) << "rs.special = " << rs.special(); |
83 | ASSERT_EQ(size, rs.size()) << "rs.special = " << rs.special(); |
84 | |
85 | EXPECT_PRED2(is_ptr_aligned, rs.base(), alignment) |
86 | << "aligned sizes should always give aligned addresses" ; |
87 | EXPECT_PRED2(is_ptr_aligned, (void*) rs.size(), alignment) |
88 | << "aligned sizes should always give aligned addresses" ; |
89 | |
90 | if (rs.special()) { |
91 | small_page_write(rs.base(), size); |
92 | } |
93 | } |
94 | |
95 | static void test_reserved_size_alignment_page_type(size_t size, size_t alignment, bool maybe_large) { |
96 | if (size < alignment) { |
97 | // Tests might set -XX:LargePageSizeInBytes=<small pages> and cause unexpected input arguments for this test. |
98 | ASSERT_EQ((size_t) os::vm_page_size(), os::large_page_size()) << "Test needs further refinement" ; |
99 | return; |
100 | } |
101 | |
102 | ASSERT_PRED2(is_size_aligned, size, os::vm_allocation_granularity()) << "Must be at least AG aligned" ; |
103 | ASSERT_PRED2(is_size_aligned, size, alignment) << "Must be at least AG aligned" ; |
104 | |
105 | bool large = maybe_large && UseLargePages && size >= os::large_page_size(); |
106 | |
107 | ReservedSpace rs(size, alignment, large, false); |
108 | MemoryReleaser releaser(&rs); |
109 | |
110 | EXPECT_TRUE(rs.base() != NULL) << "rs.special: " << rs.special(); |
111 | EXPECT_EQ(size, rs.size()) << "rs.special: " << rs.special(); |
112 | |
113 | if (rs.special()) { |
114 | small_page_write(rs.base(), size); |
115 | } |
116 | } |
117 | } |
118 | |
119 | TEST_VM(ReservedSpace, size_alignment) { |
120 | size_t size = 2 * 1024 * 1024; |
121 | size_t ag = os::vm_allocation_granularity(); |
122 | |
123 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment(size, ag)); |
124 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment(size * 2, ag)); |
125 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment(size * 10, ag)); |
126 | } |
127 | |
128 | TEST_VM(ReservedSpace, size) { |
129 | size_t size = 2 * 1024 * 1024; |
130 | size_t ag = os::vm_allocation_granularity(); |
131 | |
132 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 1)); |
133 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 2)); |
134 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 10)); |
135 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(ag)); |
136 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size - ag)); |
137 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size)); |
138 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size + ag)); |
139 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 2)); |
140 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 2 - ag)); |
141 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 2 + ag)); |
142 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 3)); |
143 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 3 - ag)); |
144 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 3 + ag)); |
145 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 10)); |
146 | EXPECT_NO_FATAL_FAILURE(test_reserved_size(size * 10 + size / 2)); |
147 | } |
148 | |
149 | TEST_VM(ReservedSpace, size_alignment_page_type) { |
150 | size_t ag = os::vm_allocation_granularity(); |
151 | |
152 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag, ag , false)); |
153 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 2, ag , false)); |
154 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 3, ag , false)); |
155 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 2, ag * 2, false)); |
156 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 4, ag * 2, false)); |
157 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 8, ag * 2, false)); |
158 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 4, ag * 4, false)); |
159 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 8, ag * 4, false)); |
160 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(ag * 16, ag * 4, false)); |
161 | } |
162 | |
163 | TEST_VM(ReservedSpace, size_alignment_page_type_large_page) { |
164 | if (!UseLargePages) { |
165 | return; |
166 | } |
167 | |
168 | size_t ag = os::vm_allocation_granularity(); |
169 | size_t lp = os::large_page_size(); |
170 | |
171 | // Without large pages |
172 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp, ag * 4, false)); |
173 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, ag * 4, false)); |
174 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 4, ag * 4, false)); |
175 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp, lp , false)); |
176 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp , false)); |
177 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 3, lp , false)); |
178 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp * 2, false)); |
179 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 4, lp * 2, false)); |
180 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 8, lp * 2, false)); |
181 | |
182 | // With large pages |
183 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp, ag * 4 , true)); |
184 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, ag * 4, true)); |
185 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 4, ag * 4, true)); |
186 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp, lp , true)); |
187 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp , true)); |
188 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 3, lp , true)); |
189 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 2, lp * 2, true)); |
190 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 4, lp * 2, true)); |
191 | EXPECT_NO_FATAL_FAILURE(test_reserved_size_alignment_page_type(lp * 8, lp * 2, true)); |
192 | } |
193 | |
194 | namespace { |
195 | enum TestLargePages { |
196 | Default, |
197 | Disable, |
198 | Reserve, |
199 | Commit |
200 | }; |
201 | |
202 | class ReservedSpaceReleaser { |
203 | ReservedSpace* const _rs; |
204 | public: |
205 | ReservedSpaceReleaser(ReservedSpace* rs) : _rs(rs) { } |
206 | ~ReservedSpaceReleaser() { |
207 | _rs->release(); |
208 | } |
209 | }; |
210 | |
211 | ReservedSpace reserve_memory(size_t reserve_size_aligned, TestLargePages mode) { |
212 | switch(mode) { |
213 | default: |
214 | case Default: |
215 | case Reserve: |
216 | return ReservedSpace(reserve_size_aligned); |
217 | case Disable: |
218 | case Commit: |
219 | return ReservedSpace(reserve_size_aligned, |
220 | os::vm_allocation_granularity(), |
221 | /* large */ false, /* exec */ false); |
222 | } |
223 | } |
224 | |
225 | bool initialize_virtual_space(VirtualSpace& vs, ReservedSpace rs, TestLargePages mode) { |
226 | switch(mode) { |
227 | default: |
228 | case Default: |
229 | case Reserve: |
230 | return vs.initialize(rs, 0); |
231 | case Disable: |
232 | return vs.initialize_with_granularity(rs, 0, os::vm_page_size()); |
233 | case Commit: |
234 | return vs.initialize_with_granularity(rs, 0, os::page_size_for_region_unaligned(rs.size(), 1)); |
235 | } |
236 | } |
237 | |
238 | void test_virtual_space_actual_committed_space(size_t reserve_size, size_t commit_size, |
239 | TestLargePages mode = Default) { |
240 | size_t granularity = os::vm_allocation_granularity(); |
241 | size_t reserve_size_aligned = align_up(reserve_size, granularity); |
242 | |
243 | ReservedSpace reserved = reserve_memory(reserve_size_aligned, mode); |
244 | ReservedSpaceReleaser releaser(&reserved); |
245 | |
246 | ASSERT_TRUE(reserved.is_reserved()); |
247 | |
248 | VirtualSpace vs; |
249 | ASSERT_TRUE(initialize_virtual_space(vs, reserved, mode)) << "Failed to initialize VirtualSpace" ; |
250 | vs.expand_by(commit_size, false); |
251 | |
252 | if (vs.special()) { |
253 | EXPECT_EQ(reserve_size_aligned, vs.actual_committed_size()); |
254 | } else { |
255 | EXPECT_GE(vs.actual_committed_size(), commit_size); |
256 | // Approximate the commit granularity. |
257 | // Make sure that we don't commit using large pages |
258 | // if large pages has been disabled for this VirtualSpace. |
259 | size_t commit_granularity = (mode == Disable || !UseLargePages) ? |
260 | os::vm_page_size() : os::large_page_size(); |
261 | EXPECT_LT(vs.actual_committed_size(), commit_size + commit_granularity); |
262 | } |
263 | } |
264 | } |
265 | |
266 | TEST_VM(VirtualSpace, actual_committed_space) { |
267 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(4 * K, 0)); |
268 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(4 * K, 4 * K)); |
269 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(8 * K, 0)); |
270 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(8 * K, 4 * K)); |
271 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(8 * K, 8 * K)); |
272 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(12 * K, 0)); |
273 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(12 * K, 4 * K)); |
274 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(12 * K, 8 * K)); |
275 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(12 * K, 12 * K)); |
276 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(64 * K, 0)); |
277 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(64 * K, 32 * K)); |
278 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(64 * K, 64 * K)); |
279 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(2 * M, 0)); |
280 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(2 * M, 4 * K)); |
281 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(2 * M, 64 * K)); |
282 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(2 * M, 1 * M)); |
283 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(2 * M, 2 * M)); |
284 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 0)); |
285 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 4 * K)); |
286 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 8 * K)); |
287 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 1 * M)); |
288 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 2 * M)); |
289 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 5 * M)); |
290 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 10 * M)); |
291 | } |
292 | |
293 | TEST_VM(VirtualSpace, actual_committed_space_one_large_page) { |
294 | if (!UseLargePages) { |
295 | return; |
296 | } |
297 | |
298 | size_t large_page_size = os::large_page_size(); |
299 | |
300 | ReservedSpace reserved(large_page_size, large_page_size, true, false); |
301 | ReservedSpaceReleaser releaser(&reserved); |
302 | ASSERT_TRUE(reserved.is_reserved()); |
303 | |
304 | VirtualSpace vs; |
305 | ASSERT_TRUE(vs.initialize(reserved, 0)) << "Failed to initialize VirtualSpace" ; |
306 | vs.expand_by(large_page_size, false); |
307 | |
308 | EXPECT_EQ(large_page_size, vs.actual_committed_size()); |
309 | } |
310 | |
311 | TEST_VM(VirtualSpace, disable_large_pages) { |
312 | if (!UseLargePages) { |
313 | return; |
314 | } |
315 | // These test cases verify that if we force VirtualSpace to disable large pages |
316 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 0, Disable)); |
317 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 4 * K, Disable)); |
318 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 8 * K, Disable)); |
319 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 1 * M, Disable)); |
320 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 2 * M, Disable)); |
321 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 5 * M, Disable)); |
322 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 10 * M, Disable)); |
323 | |
324 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 0, Reserve)); |
325 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 4 * K, Reserve)); |
326 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 8 * K, Reserve)); |
327 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 1 * M, Reserve)); |
328 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 2 * M, Reserve)); |
329 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 5 * M, Reserve)); |
330 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 10 * M, Reserve)); |
331 | |
332 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 0, Commit)); |
333 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 4 * K, Commit)); |
334 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 8 * K, Commit)); |
335 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 1 * M, Commit)); |
336 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 2 * M, Commit)); |
337 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 5 * M, Commit)); |
338 | EXPECT_NO_FATAL_FAILURE(test_virtual_space_actual_committed_space(10 * M, 10 * M, Commit)); |
339 | } |
340 | |