1404 // The very lower end of the stack |
1404 // The very lower end of the stack |
1405 address stack_limit = thread->stack_base() - thread->stack_size(); |
1405 address stack_limit = thread->stack_base() - thread->stack_size(); |
1406 return (sp > (stack_limit + reserved_area)); |
1406 return (sp > (stack_limit + reserved_area)); |
1407 } |
1407 } |
1408 |
1408 |
1409 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, |
1409 size_t os::page_size_for_region(size_t region_size, size_t min_pages) { |
1410 uint min_pages) |
|
1411 { |
|
1412 assert(min_pages > 0, "sanity"); |
1410 assert(min_pages > 0, "sanity"); |
1413 if (UseLargePages) { |
1411 if (UseLargePages) { |
1414 const size_t max_page_size = region_max_size / min_pages; |
1412 const size_t max_page_size = region_size / min_pages; |
1415 |
1413 |
1416 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { |
1414 for (size_t i = 0; _page_sizes[i] != 0; ++i) { |
1417 const size_t sz = _page_sizes[i]; |
1415 const size_t page_size = _page_sizes[i]; |
1418 const size_t mask = sz - 1; |
1416 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) { |
1419 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { |
1417 return page_size; |
1420 // The largest page size with no fragmentation. |
|
1421 return sz; |
|
1422 } |
|
1423 |
|
1424 if (sz <= max_page_size) { |
|
1425 // The largest page size that satisfies the min_pages requirement. |
|
1426 return sz; |
|
1427 } |
1418 } |
1428 } |
1419 } |
1429 } |
1420 } |
1430 |
1421 |
1431 return vm_page_size(); |
1422 return vm_page_size(); |
1658 return to; |
1649 return to; |
1659 } |
1650 } |
1660 return result; |
1651 return result; |
1661 } |
1652 } |
1662 #endif |
1653 #endif |
|
1654 |
|
1655 /////////////// Unit tests /////////////// |
|
1656 |
|
1657 #ifndef PRODUCT |
|
1658 |
|
1659 #define assert_eq(a,b) assert(a == b, err_msg(SIZE_FORMAT " != " SIZE_FORMAT, a, b)) |
|
1660 |
|
1661 class TestOS : AllStatic { |
|
1662 static size_t small_page_size() { |
|
1663 return os::vm_page_size(); |
|
1664 } |
|
1665 |
|
1666 static size_t large_page_size() { |
|
1667 const size_t large_page_size_example = 4 * M; |
|
1668 return os::page_size_for_region(large_page_size_example, 1); |
|
1669 } |
|
1670 |
|
1671 static void test_page_size_for_region() { |
|
1672 if (UseLargePages) { |
|
1673 const size_t small_page = small_page_size(); |
|
1674 const size_t large_page = large_page_size(); |
|
1675 |
|
1676 if (large_page > small_page) { |
|
1677 size_t num_small_pages_in_large = large_page / small_page; |
|
1678 size_t page = os::page_size_for_region(large_page, num_small_pages_in_large); |
|
1679 |
|
1680 assert_eq(page, small_page); |
|
1681 } |
|
1682 } |
|
1683 } |
|
1684 |
|
1685 static void test_page_size_for_region_alignment() { |
|
1686 if (UseLargePages) { |
|
1687 const size_t small_page = small_page_size(); |
|
1688 const size_t large_page = large_page_size(); |
|
1689 if (large_page > small_page) { |
|
1690 const size_t unaligned_region = large_page + 17; |
|
1691 size_t page = os::page_size_for_region(unaligned_region, 1); |
|
1692 assert_eq(page, small_page); |
|
1693 |
|
1694 const size_t num_pages = 5; |
|
1695 const size_t aligned_region = large_page * num_pages; |
|
1696 page = os::page_size_for_region(aligned_region, num_pages); |
|
1697 assert_eq(page, large_page); |
|
1698 } |
|
1699 } |
|
1700 } |
|
1701 |
|
1702 public: |
|
1703 static void run_tests() { |
|
1704 test_page_size_for_region(); |
|
1705 test_page_size_for_region_alignment(); |
|
1706 } |
|
1707 }; |
|
1708 |
|
1709 void TestOS_test() { |
|
1710 TestOS::run_tests(); |
|
1711 } |
|
1712 |
|
1713 #endif // PRODUCT |