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