1301 // The very lower end of the stack |
1301 // The very lower end of the stack |
1302 address stack_limit = thread->stack_base() - thread->stack_size(); |
1302 address stack_limit = thread->stack_base() - thread->stack_size(); |
1303 return (sp > (stack_limit + reserved_area)); |
1303 return (sp > (stack_limit + reserved_area)); |
1304 } |
1304 } |
1305 |
1305 |
1306 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, |
1306 size_t os::page_size_for_region(size_t region_size, size_t min_pages) { |
1307 uint min_pages) |
|
1308 { |
|
1309 assert(min_pages > 0, "sanity"); |
1307 assert(min_pages > 0, "sanity"); |
1310 if (UseLargePages) { |
1308 if (UseLargePages) { |
1311 const size_t max_page_size = region_max_size / min_pages; |
1309 const size_t max_page_size = region_size / min_pages; |
1312 |
1310 |
1313 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { |
1311 for (size_t i = 0; _page_sizes[i] != 0; ++i) { |
1314 const size_t sz = _page_sizes[i]; |
1312 const size_t page_size = _page_sizes[i]; |
1315 const size_t mask = sz - 1; |
1313 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) { |
1316 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { |
1314 return page_size; |
1317 // The largest page size with no fragmentation. |
|
1318 return sz; |
|
1319 } |
|
1320 |
|
1321 if (sz <= max_page_size) { |
|
1322 // The largest page size that satisfies the min_pages requirement. |
|
1323 return sz; |
|
1324 } |
1315 } |
1325 } |
1316 } |
1326 } |
1317 } |
1327 |
1318 |
1328 return vm_page_size(); |
1319 return vm_page_size(); |
1546 return to; |
1537 return to; |
1547 } |
1538 } |
1548 return result; |
1539 return result; |
1549 } |
1540 } |
1550 #endif |
1541 #endif |
|
1542 |
|
1543 /////////////// Unit tests /////////////// |
|
1544 |
|
1545 #ifndef PRODUCT |
|
1546 |
|
1547 #define assert_eq(a,b) assert(a == b, err_msg(SIZE_FORMAT " != " SIZE_FORMAT, a, b)) |
|
1548 |
|
1549 class TestOS : AllStatic { |
|
1550 static size_t small_page_size() { |
|
1551 return os::vm_page_size(); |
|
1552 } |
|
1553 |
|
1554 static size_t large_page_size() { |
|
1555 const size_t large_page_size_example = 4 * M; |
|
1556 return os::page_size_for_region(large_page_size_example, 1); |
|
1557 } |
|
1558 |
|
1559 static void test_page_size_for_region() { |
|
1560 if (UseLargePages) { |
|
1561 const size_t small_page = small_page_size(); |
|
1562 const size_t large_page = large_page_size(); |
|
1563 |
|
1564 if (large_page > small_page) { |
|
1565 size_t num_small_pages_in_large = large_page / small_page; |
|
1566 size_t page = os::page_size_for_region(large_page, num_small_pages_in_large); |
|
1567 |
|
1568 assert_eq(page, small_page); |
|
1569 } |
|
1570 } |
|
1571 } |
|
1572 |
|
1573 static void test_page_size_for_region_alignment() { |
|
1574 if (UseLargePages) { |
|
1575 const size_t small_page = small_page_size(); |
|
1576 const size_t large_page = large_page_size(); |
|
1577 if (large_page > small_page) { |
|
1578 const size_t unaligned_region = large_page + 17; |
|
1579 size_t page = os::page_size_for_region(unaligned_region, 1); |
|
1580 assert_eq(page, small_page); |
|
1581 |
|
1582 const size_t num_pages = 5; |
|
1583 const size_t aligned_region = large_page * num_pages; |
|
1584 page = os::page_size_for_region(aligned_region, num_pages); |
|
1585 assert_eq(page, large_page); |
|
1586 } |
|
1587 } |
|
1588 } |
|
1589 |
|
1590 public: |
|
1591 static void run_tests() { |
|
1592 test_page_size_for_region(); |
|
1593 test_page_size_for_region_alignment(); |
|
1594 } |
|
1595 }; |
|
1596 |
|
1597 void TestOS_test() { |
|
1598 TestOS::run_tests(); |
|
1599 } |
|
1600 |
|
1601 #endif // PRODUCT |