120 if (size == 0) { 121 return; 122 } 123 124 // If OS doesn't support demand paging for large page memory, we need 125 // to use reserve_memory_special() to reserve and pin the entire region. 126 bool special = large && !os::can_commit_large_page_memory(); 127 char* base = NULL; 128 129 if (special) { 130 131 base = os::reserve_memory_special(size, alignment, requested_address, executable); 132 133 if (base != NULL) { 134 if (failed_to_reserve_as_requested(base, requested_address, size, true)) { 135 // OS ignored requested address. Try different address. 136 return; 137 } 138 // Check alignment constraints. 139 assert((uintptr_t) base % alignment == 0, 140 err_msg("Large pages returned a non-aligned address, base: " 141 PTR_FORMAT " alignment: " PTR_FORMAT, 142 base, (void*)(uintptr_t)alignment)); 143 _special = true; 144 } else { 145 // failed; try to reserve regular memory below 146 if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) || 147 !FLAG_IS_DEFAULT(LargePageSizeInBytes))) { 148 if (PrintCompressedOopsMode) { 149 tty->cr(); 150 tty->print_cr("Reserve regular memory without large pages."); 151 } 152 } 153 } 154 } 155 156 if (base == NULL) { 157 // Optimistically assume that the OSes returns an aligned base pointer. 158 // When reserving a large address range, most OSes seem to align to at 159 // least 64K. 160 161 // If the memory was requested at a particular address, use 162 // os::attempt_reserve_memory_at() to avoid over mapping something 317 // We tried before, but we didn't like the address delivered. 318 release(); 319 } 320 321 // If OS doesn't support demand paging for large page memory, we need 322 // to use reserve_memory_special() to reserve and pin the entire region. 323 bool special = large && !os::can_commit_large_page_memory(); 324 char* base = NULL; 325 326 if (PrintCompressedOopsMode && Verbose) { 327 tty->print("Trying to allocate at address " PTR_FORMAT " heap of size " PTR_FORMAT ".\n", 328 requested_address, (address)size); 329 } 330 331 if (special) { 332 base = os::reserve_memory_special(size, alignment, requested_address, false); 333 334 if (base != NULL) { 335 // Check alignment constraints. 336 assert((uintptr_t) base % alignment == 0, 337 err_msg("Large pages returned a non-aligned address, base: " 338 PTR_FORMAT " alignment: " PTR_FORMAT, 339 base, (void*)(uintptr_t)alignment)); 340 _special = true; 341 } 342 } 343 344 if (base == NULL) { 345 // Failed; try to reserve regular memory below 346 if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) || 347 !FLAG_IS_DEFAULT(LargePageSizeInBytes))) { 348 if (PrintCompressedOopsMode) { 349 tty->cr(); 350 tty->print_cr("Reserve regular memory without large pages."); 351 } 352 } 353 354 // Optimistically assume that the OSes returns an aligned base pointer. 355 // When reserving a large address range, most OSes seem to align to at 356 // least 64K. 357 358 // If the memory was requested at a particular address, use 359 // os::attempt_reserve_memory_at() to avoid over mapping something 1190 test_reserved_space3(lp * 3, lp , true); 1191 test_reserved_space3(lp * 2, lp * 2, true); 1192 test_reserved_space3(lp * 4, lp * 2, true); 1193 test_reserved_space3(lp * 8, lp * 2, true); 1194 } 1195 } 1196 1197 static void test_reserved_space() { 1198 test_reserved_space1(); 1199 test_reserved_space2(); 1200 test_reserved_space3(); 1201 } 1202 }; 1203 1204 void TestReservedSpace_test() { 1205 TestReservedSpace::test_reserved_space(); 1206 } 1207 1208 #define assert_equals(actual, expected) \ 1209 assert(actual == expected, \ 1210 err_msg("Got " SIZE_FORMAT " expected " \ 1211 SIZE_FORMAT, actual, expected)); 1212 1213 #define assert_ge(value1, value2) \ 1214 assert(value1 >= value2, \ 1215 err_msg("'" #value1 "': " SIZE_FORMAT " '" \ 1216 #value2 "': " SIZE_FORMAT, value1, value2)); 1217 1218 #define assert_lt(value1, value2) \ 1219 assert(value1 < value2, \ 1220 err_msg("'" #value1 "': " SIZE_FORMAT " '" \ 1221 #value2 "': " SIZE_FORMAT, value1, value2)); 1222 1223 1224 class TestVirtualSpace : AllStatic { 1225 enum TestLargePages { 1226 Default, 1227 Disable, 1228 Reserve, 1229 Commit 1230 }; 1231 1232 static ReservedSpace reserve_memory(size_t reserve_size_aligned, TestLargePages mode) { 1233 switch(mode) { 1234 default: 1235 case Default: 1236 case Reserve: 1237 return ReservedSpace(reserve_size_aligned); 1238 case Disable: 1239 case Commit: 1240 return ReservedSpace(reserve_size_aligned, 1241 os::vm_allocation_granularity(), | 120 if (size == 0) { 121 return; 122 } 123 124 // If OS doesn't support demand paging for large page memory, we need 125 // to use reserve_memory_special() to reserve and pin the entire region. 126 bool special = large && !os::can_commit_large_page_memory(); 127 char* base = NULL; 128 129 if (special) { 130 131 base = os::reserve_memory_special(size, alignment, requested_address, executable); 132 133 if (base != NULL) { 134 if (failed_to_reserve_as_requested(base, requested_address, size, true)) { 135 // OS ignored requested address. Try different address. 136 return; 137 } 138 // Check alignment constraints. 139 assert((uintptr_t) base % alignment == 0, 140 "Large pages returned a non-aligned address, base: " 141 PTR_FORMAT " alignment: " PTR_FORMAT, 142 base, (void*)(uintptr_t)alignment); 143 _special = true; 144 } else { 145 // failed; try to reserve regular memory below 146 if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) || 147 !FLAG_IS_DEFAULT(LargePageSizeInBytes))) { 148 if (PrintCompressedOopsMode) { 149 tty->cr(); 150 tty->print_cr("Reserve regular memory without large pages."); 151 } 152 } 153 } 154 } 155 156 if (base == NULL) { 157 // Optimistically assume that the OSes returns an aligned base pointer. 158 // When reserving a large address range, most OSes seem to align to at 159 // least 64K. 160 161 // If the memory was requested at a particular address, use 162 // os::attempt_reserve_memory_at() to avoid over mapping something 317 // We tried before, but we didn't like the address delivered. 318 release(); 319 } 320 321 // If OS doesn't support demand paging for large page memory, we need 322 // to use reserve_memory_special() to reserve and pin the entire region. 323 bool special = large && !os::can_commit_large_page_memory(); 324 char* base = NULL; 325 326 if (PrintCompressedOopsMode && Verbose) { 327 tty->print("Trying to allocate at address " PTR_FORMAT " heap of size " PTR_FORMAT ".\n", 328 requested_address, (address)size); 329 } 330 331 if (special) { 332 base = os::reserve_memory_special(size, alignment, requested_address, false); 333 334 if (base != NULL) { 335 // Check alignment constraints. 336 assert((uintptr_t) base % alignment == 0, 337 "Large pages returned a non-aligned address, base: " 338 PTR_FORMAT " alignment: " PTR_FORMAT, 339 base, (void*)(uintptr_t)alignment); 340 _special = true; 341 } 342 } 343 344 if (base == NULL) { 345 // Failed; try to reserve regular memory below 346 if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) || 347 !FLAG_IS_DEFAULT(LargePageSizeInBytes))) { 348 if (PrintCompressedOopsMode) { 349 tty->cr(); 350 tty->print_cr("Reserve regular memory without large pages."); 351 } 352 } 353 354 // Optimistically assume that the OSes returns an aligned base pointer. 355 // When reserving a large address range, most OSes seem to align to at 356 // least 64K. 357 358 // If the memory was requested at a particular address, use 359 // os::attempt_reserve_memory_at() to avoid over mapping something 1190 test_reserved_space3(lp * 3, lp , true); 1191 test_reserved_space3(lp * 2, lp * 2, true); 1192 test_reserved_space3(lp * 4, lp * 2, true); 1193 test_reserved_space3(lp * 8, lp * 2, true); 1194 } 1195 } 1196 1197 static void test_reserved_space() { 1198 test_reserved_space1(); 1199 test_reserved_space2(); 1200 test_reserved_space3(); 1201 } 1202 }; 1203 1204 void TestReservedSpace_test() { 1205 TestReservedSpace::test_reserved_space(); 1206 } 1207 1208 #define assert_equals(actual, expected) \ 1209 assert(actual == expected, \ 1210 "Got " SIZE_FORMAT " expected " \ 1211 SIZE_FORMAT, actual, expected); 1212 1213 #define assert_ge(value1, value2) \ 1214 assert(value1 >= value2, \ 1215 "'" #value1 "': " SIZE_FORMAT " '" \ 1216 #value2 "': " SIZE_FORMAT, value1, value2); 1217 1218 #define assert_lt(value1, value2) \ 1219 assert(value1 < value2, \ 1220 "'" #value1 "': " SIZE_FORMAT " '" \ 1221 #value2 "': " SIZE_FORMAT, value1, value2); 1222 1223 1224 class TestVirtualSpace : AllStatic { 1225 enum TestLargePages { 1226 Default, 1227 Disable, 1228 Reserve, 1229 Commit 1230 }; 1231 1232 static ReservedSpace reserve_memory(size_t reserve_size_aligned, TestLargePages mode) { 1233 switch(mode) { 1234 default: 1235 case Default: 1236 case Reserve: 1237 return ReservedSpace(reserve_size_aligned); 1238 case Disable: 1239 case Commit: 1240 return ReservedSpace(reserve_size_aligned, 1241 os::vm_allocation_granularity(), |