1390 // the handler for stack overflow. 'instanceof' in the stack overflow
1391 // handler or a println uses at least 8k stack of VM and native code
1392 // respectively.
1393 const int framesize_in_bytes =
1394 Interpreter::size_top_interpreter_activation(method()) * wordSize;
1395 int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages)
1396 * vm_page_size()) + framesize_in_bytes;
1397 // The very lower end of the stack
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, bool must_be_aligned) {
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) {
1410 if (!must_be_aligned) {
1411 return page_size;
1412 }
1413 if (is_size_aligned(region_size, page_size)) {
1414 return page_size;
1415 }
1416 }
1417 }
1418 }
1419
1420 return vm_page_size();
1421 }
1422
1423 size_t os::page_size_for_region_aligned(size_t region_size, size_t min_pages) {
1424 return page_size_for_region(region_size, min_pages, true);
1425 }
1426
1427 size_t os::page_size_for_region_unaligned(size_t region_size, size_t min_pages) {
1428 return page_size_for_region(region_size, min_pages, false);
1429 }
1430
1431 #ifndef PRODUCT
1432 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
1433 {
1695
1696 static void test_page_size_for_region_alignment() {
1697 if (UseLargePages) {
1698 const size_t small_page = small_page_size();
1699 const size_t large_page = large_page_size();
1700 if (large_page > small_page) {
1701 const size_t unaligned_region = large_page + 17;
1702 size_t page = os::page_size_for_region_aligned(unaligned_region, 1);
1703 assert_eq(page, small_page);
1704
1705 const size_t num_pages = 5;
1706 const size_t aligned_region = large_page * num_pages;
1707 page = os::page_size_for_region_aligned(aligned_region, num_pages);
1708 assert_eq(page, large_page);
1709 }
1710 }
1711 }
1712
1713 static void test_page_size_for_region_unaligned() {
1714 if (UseLargePages) {
1715 // Given exact page size, should return that page size
1716 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1717 size_t expected = os::_page_sizes[i];
1718 size_t actual = os::page_size_for_region_unaligned(expected, 1);
1719 assert_eq(expected, actual);
1720 }
1721
1722 // Given slightly larger size than a page size, return the page size
1723 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1724 size_t expected = os::_page_sizes[i];
1725 size_t actual = os::page_size_for_region_unaligned(expected + 17, 1);
1726 assert_eq(expected, actual);
1727 }
1728
1729 // Given a slightly smaller size than a page size,
1730 // return the next smaller page size
1731 if (os::_page_sizes[1] > os::_page_sizes[0]) {
1732 size_t expected = os::_page_sizes[0];
1733 size_t actual = os::page_size_for_region_unaligned(os::_page_sizes[1] - 17, 1);
1734 assert_eq(actual, expected);
1735 }
1736
1737 // Return small page size for values less than a small page
1738 size_t small_page = small_page_size();
1739 size_t actual = os::page_size_for_region_unaligned(small_page - 17, 1);
1740 assert_eq(small_page, actual);
1741 }
1742 }
1743
1744 public:
1745 static void run_tests() {
1746 test_page_size_for_region_aligned();
1747 test_page_size_for_region_alignment();
1748 test_page_size_for_region_unaligned();
1749 }
1750 };
1751
1752 void TestOS_test() {
1753 TestOS::run_tests();
1754 }
1755
1756 #endif // PRODUCT
|
1390 // the handler for stack overflow. 'instanceof' in the stack overflow
1391 // handler or a println uses at least 8k stack of VM and native code
1392 // respectively.
1393 const int framesize_in_bytes =
1394 Interpreter::size_top_interpreter_activation(method()) * wordSize;
1395 int reserved_area = ((StackShadowPages + StackRedPages + StackYellowPages)
1396 * vm_page_size()) + framesize_in_bytes;
1397 // The very lower end of the stack
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, bool must_be_aligned) {
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) {
1410 if (!must_be_aligned || is_size_aligned(region_size, page_size)) {
1411 return page_size;
1412 }
1413 }
1414 }
1415 }
1416
1417 return vm_page_size();
1418 }
1419
1420 size_t os::page_size_for_region_aligned(size_t region_size, size_t min_pages) {
1421 return page_size_for_region(region_size, min_pages, true);
1422 }
1423
1424 size_t os::page_size_for_region_unaligned(size_t region_size, size_t min_pages) {
1425 return page_size_for_region(region_size, min_pages, false);
1426 }
1427
1428 #ifndef PRODUCT
1429 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
1430 {
1692
1693 static void test_page_size_for_region_alignment() {
1694 if (UseLargePages) {
1695 const size_t small_page = small_page_size();
1696 const size_t large_page = large_page_size();
1697 if (large_page > small_page) {
1698 const size_t unaligned_region = large_page + 17;
1699 size_t page = os::page_size_for_region_aligned(unaligned_region, 1);
1700 assert_eq(page, small_page);
1701
1702 const size_t num_pages = 5;
1703 const size_t aligned_region = large_page * num_pages;
1704 page = os::page_size_for_region_aligned(aligned_region, num_pages);
1705 assert_eq(page, large_page);
1706 }
1707 }
1708 }
1709
1710 static void test_page_size_for_region_unaligned() {
1711 if (UseLargePages) {
1712 // Given exact page size, should return that page size.
1713 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1714 size_t expected = os::_page_sizes[i];
1715 size_t actual = os::page_size_for_region_unaligned(expected, 1);
1716 assert_eq(expected, actual);
1717 }
1718
1719 // Given slightly larger size than a page size, return the page size.
1720 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1721 size_t expected = os::_page_sizes[i];
1722 size_t actual = os::page_size_for_region_unaligned(expected + 17, 1);
1723 assert_eq(expected, actual);
1724 }
1725
1726 // Given a slightly smaller size than a page size,
1727 // return the next smaller page size.
1728 if (os::_page_sizes[1] > os::_page_sizes[0]) {
1729 size_t expected = os::_page_sizes[0];
1730 size_t actual = os::page_size_for_region_unaligned(os::_page_sizes[1] - 17, 1);
1731 assert_eq(actual, expected);
1732 }
1733
1734 // Return small page size for values less than a small page.
1735 size_t small_page = small_page_size();
1736 size_t actual = os::page_size_for_region_unaligned(small_page - 17, 1);
1737 assert_eq(small_page, actual);
1738 }
1739 }
1740
1741 public:
1742 static void run_tests() {
1743 test_page_size_for_region_aligned();
1744 test_page_size_for_region_alignment();
1745 test_page_size_for_region_unaligned();
1746 }
1747 };
1748
1749 void TestOS_test() {
1750 TestOS::run_tests();
1751 }
1752
1753 #endif // PRODUCT
|