1398 address stack_limit = thread->stack_base() - thread->stack_size();
1399 return (sp > (stack_limit + reserved_area));
1400 }
1401
1402 size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
1403 assert(min_pages > 0, "sanity");
1404 if (UseLargePages) {
1405 const size_t max_page_size = region_size / min_pages;
1406
1407 for (size_t i = 0; _page_sizes[i] != 0; ++i) {
1408 const size_t page_size = _page_sizes[i];
1409 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) {
1410 return page_size;
1411 }
1412 }
1413 }
1414
1415 return vm_page_size();
1416 }
1417
1418 #ifndef PRODUCT
1419 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
1420 {
1421 if (TracePageSizes) {
1422 tty->print("%s: ", str);
1423 for (int i = 0; i < count; ++i) {
1424 tty->print(" " SIZE_FORMAT, page_sizes[i]);
1425 }
1426 tty->cr();
1427 }
1428 }
1429
1430 void os::trace_page_sizes(const char* str, const size_t region_min_size,
1431 const size_t region_max_size, const size_t page_size,
1432 const char* base, const size_t size)
1433 {
1434 if (TracePageSizes) {
1435 tty->print_cr("%s: min=" SIZE_FORMAT " max=" SIZE_FORMAT
1436 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT
1437 " size=" SIZE_FORMAT,
1675 }
1676 }
1677
1678 static void test_page_size_for_region_alignment() {
1679 if (UseLargePages) {
1680 const size_t small_page = small_page_size();
1681 const size_t large_page = large_page_size();
1682 if (large_page > small_page) {
1683 const size_t unaligned_region = large_page + 17;
1684 size_t page = os::page_size_for_region(unaligned_region, 1);
1685 assert_eq(page, small_page);
1686
1687 const size_t num_pages = 5;
1688 const size_t aligned_region = large_page * num_pages;
1689 page = os::page_size_for_region(aligned_region, num_pages);
1690 assert_eq(page, large_page);
1691 }
1692 }
1693 }
1694
1695 public:
1696 static void run_tests() {
1697 test_page_size_for_region();
1698 test_page_size_for_region_alignment();
1699 }
1700 };
1701
1702 void TestOS_test() {
1703 TestOS::run_tests();
1704 }
1705
1706 #endif // PRODUCT
|
1398 address stack_limit = thread->stack_base() - thread->stack_size();
1399 return (sp > (stack_limit + reserved_area));
1400 }
1401
1402 size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
1403 assert(min_pages > 0, "sanity");
1404 if (UseLargePages) {
1405 const size_t max_page_size = region_size / min_pages;
1406
1407 for (size_t i = 0; _page_sizes[i] != 0; ++i) {
1408 const size_t page_size = _page_sizes[i];
1409 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) {
1410 return page_size;
1411 }
1412 }
1413 }
1414
1415 return vm_page_size();
1416 }
1417
1418 size_t os::largest_page_size_less_than(size_t sz) {
1419 if (UseLargePages) {
1420 // The page sizes are sorted descendingly.
1421 for (size_t i = 0; _page_sizes[i] != 0; ++i) {
1422 if (_page_sizes[i] <= sz) {
1423 return _page_sizes[i];
1424 }
1425 }
1426 }
1427 return vm_page_size();
1428 }
1429
1430 #ifndef PRODUCT
1431 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
1432 {
1433 if (TracePageSizes) {
1434 tty->print("%s: ", str);
1435 for (int i = 0; i < count; ++i) {
1436 tty->print(" " SIZE_FORMAT, page_sizes[i]);
1437 }
1438 tty->cr();
1439 }
1440 }
1441
1442 void os::trace_page_sizes(const char* str, const size_t region_min_size,
1443 const size_t region_max_size, const size_t page_size,
1444 const char* base, const size_t size)
1445 {
1446 if (TracePageSizes) {
1447 tty->print_cr("%s: min=" SIZE_FORMAT " max=" SIZE_FORMAT
1448 " pg_sz=" SIZE_FORMAT " base=" PTR_FORMAT
1449 " size=" SIZE_FORMAT,
1687 }
1688 }
1689
1690 static void test_page_size_for_region_alignment() {
1691 if (UseLargePages) {
1692 const size_t small_page = small_page_size();
1693 const size_t large_page = large_page_size();
1694 if (large_page > small_page) {
1695 const size_t unaligned_region = large_page + 17;
1696 size_t page = os::page_size_for_region(unaligned_region, 1);
1697 assert_eq(page, small_page);
1698
1699 const size_t num_pages = 5;
1700 const size_t aligned_region = large_page * num_pages;
1701 page = os::page_size_for_region(aligned_region, num_pages);
1702 assert_eq(page, large_page);
1703 }
1704 }
1705 }
1706
1707 static void test_largest_page_size_less_than() {
1708 if (UseLargePages) {
1709 // Given exact page size, should return that page size
1710 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1711 size_t expected = os::_page_sizes[i];
1712 size_t actual = os::largest_page_size_less_than(expected);
1713 assert_eq(expected, actual);
1714 }
1715
1716 // Given slightly larger size than a page size, return the page size
1717 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1718 size_t expected = os::_page_sizes[i];
1719 size_t actual = os::largest_page_size_less_than(expected + 17);
1720 assert_eq(expected, actual);
1721 }
1722
1723 // Given a slightly smaller size than a page size,
1724 // return the next smaller page size
1725 if (os::_page_sizes[1] > os::_page_sizes[0]) {
1726 size_t expected = os::_page_sizes[0];
1727 size_t actual = os::largest_page_size_less_than(os::_page_sizes[1] - 17);
1728 assert_eq(actual, expected);
1729 }
1730
1731 // Return small page size for values less than a small page
1732 size_t small_page = small_page_size();
1733 size_t actual = os::largest_page_size_less_than(small_page - 17);
1734 assert_eq(small_page, actual);
1735 }
1736 }
1737
1738 public:
1739 static void run_tests() {
1740 test_page_size_for_region();
1741 test_page_size_for_region_alignment();
1742 test_largest_page_size_less_than();
1743 }
1744 };
1745
1746 void TestOS_test() {
1747 TestOS::run_tests();
1748 }
1749
1750 #endif // PRODUCT
|