Mercurial > hg > graal-jvmci-8

comparison src/share/vm/runtime/os.cpp @ 22976:5788dbd1f2d6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8066875: VirtualSpace does not use large pages Reviewed-by: stefank, tschatzl, anoll, thartmann
author ehelin
date Fri, 16 Jan 2015 10:29:12 +0100
parents c2ce24504334
children dd9cc155639c d2dd79a4fd69
comparison
equal deleted inserted replaced
22975:cc5c3ef1f03a 22976:5788dbd1f2d6
1313 // The very lower end of the stack 1313 // The very lower end of the stack
1314 address stack_limit = thread->stack_base() - thread->stack_size(); 1314 address stack_limit = thread->stack_base() - thread->stack_size();
1315 return (sp > (stack_limit + reserved_area)); 1315 return (sp > (stack_limit + reserved_area));
1316 } 1316 }
1317 1317
1318 size_t os::page_size_for_region(size_t region_size, size_t min_pages) { 1318 size_t os::page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned) {
1319 assert(min_pages > 0, "sanity"); 1319 assert(min_pages > 0, "sanity");
1320 if (UseLargePages) { 1320 if (UseLargePages) {
1321 const size_t max_page_size = region_size / min_pages; 1321 const size_t max_page_size = region_size / min_pages;
1322 1322
1323 for (size_t i = 0; _page_sizes[i] != 0; ++i) { 1323 for (size_t i = 0; _page_sizes[i] != 0; ++i) {
1324 const size_t page_size = _page_sizes[i]; 1324 const size_t page_size = _page_sizes[i];
1325 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) { 1325 if (page_size <= max_page_size) {
1326 return page_size; 1326 if (!must_be_aligned || is_size_aligned(region_size, page_size)) {
1327 return page_size;
1328 }
1327 } 1329 }
1328 } 1330 }
1329 } 1331 }
1330 1332
1331 return vm_page_size(); 1333 return vm_page_size();
1334 }
1335
1336 size_t os::page_size_for_region_aligned(size_t region_size, size_t min_pages) {
1337 return page_size_for_region(region_size, min_pages, true);
1338 }
1339
1340 size_t os::page_size_for_region_unaligned(size_t region_size, size_t min_pages) {
1341 return page_size_for_region(region_size, min_pages, false);
1332 } 1342 }
1333 1343
1334 #ifndef PRODUCT 1344 #ifndef PRODUCT
1335 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count) 1345 void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
1336 { 1346 {
1577 return os::vm_page_size(); 1587 return os::vm_page_size();
1578 } 1588 }
1579 1589
1580 static size_t large_page_size() { 1590 static size_t large_page_size() {
1581 const size_t large_page_size_example = 4 * M; 1591 const size_t large_page_size_example = 4 * M;
1582 return os::page_size_for_region(large_page_size_example, 1); 1592 return os::page_size_for_region_aligned(large_page_size_example, 1);
1583 } 1593 }
1584 1594
1585 static void test_page_size_for_region() { 1595 static void test_page_size_for_region_aligned() {
1586 if (UseLargePages) { 1596 if (UseLargePages) {
1587 const size_t small_page = small_page_size(); 1597 const size_t small_page = small_page_size();
1588 const size_t large_page = large_page_size(); 1598 const size_t large_page = large_page_size();
1589 1599
1590 if (large_page > small_page) { 1600 if (large_page > small_page) {
1591 size_t num_small_pages_in_large = large_page / small_page; 1601 size_t num_small_pages_in_large = large_page / small_page;
1592 size_t page = os::page_size_for_region(large_page, num_small_pages_in_large); 1602 size_t page = os::page_size_for_region_aligned(large_page, num_small_pages_in_large);
1593 1603
1594 assert_eq(page, small_page); 1604 assert_eq(page, small_page);
1595 } 1605 }
1596 } 1606 }
1597 } 1607 }
1600 if (UseLargePages) { 1610 if (UseLargePages) {
1601 const size_t small_page = small_page_size(); 1611 const size_t small_page = small_page_size();
1602 const size_t large_page = large_page_size(); 1612 const size_t large_page = large_page_size();
1603 if (large_page > small_page) { 1613 if (large_page > small_page) {
1604 const size_t unaligned_region = large_page + 17; 1614 const size_t unaligned_region = large_page + 17;
1605 size_t page = os::page_size_for_region(unaligned_region, 1); 1615 size_t page = os::page_size_for_region_aligned(unaligned_region, 1);
1606 assert_eq(page, small_page); 1616 assert_eq(page, small_page);
1607 1617
1608 const size_t num_pages = 5; 1618 const size_t num_pages = 5;
1609 const size_t aligned_region = large_page * num_pages; 1619 const size_t aligned_region = large_page * num_pages;
1610 page = os::page_size_for_region(aligned_region, num_pages); 1620 page = os::page_size_for_region_aligned(aligned_region, num_pages);
1611 assert_eq(page, large_page); 1621 assert_eq(page, large_page);
1612 } 1622 }
1623 }
1624 }
1625
1626 static void test_page_size_for_region_unaligned() {
1627 if (UseLargePages) {
1628 // Given exact page size, should return that page size.
1629 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1630 size_t expected = os::_page_sizes[i];
1631 size_t actual = os::page_size_for_region_unaligned(expected, 1);
1632 assert_eq(expected, actual);
1633 }
1634
1635 // Given slightly larger size than a page size, return the page size.
1636 for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
1637 size_t expected = os::_page_sizes[i];
1638 size_t actual = os::page_size_for_region_unaligned(expected + 17, 1);
1639 assert_eq(expected, actual);
1640 }
1641
1642 // Given a slightly smaller size than a page size,
1643 // return the next smaller page size.
1644 if (os::_page_sizes[1] > os::_page_sizes[0]) {
1645 size_t expected = os::_page_sizes[0];
1646 size_t actual = os::page_size_for_region_unaligned(os::_page_sizes[1] - 17, 1);
1647 assert_eq(actual, expected);
1648 }
1649
1650 // Return small page size for values less than a small page.
1651 size_t small_page = small_page_size();
1652 size_t actual = os::page_size_for_region_unaligned(small_page - 17, 1);
1653 assert_eq(small_page, actual);
1613 } 1654 }
1614 } 1655 }
1615 1656
1616 public: 1657 public:
1617 static void run_tests() { 1658 static void run_tests() {
1618 test_page_size_for_region(); 1659 test_page_size_for_region_aligned();
1619 test_page_size_for_region_alignment(); 1660 test_page_size_for_region_alignment();
1661 test_page_size_for_region_unaligned();
1620 } 1662 }
1621 }; 1663 };
1622 1664
1623 void TestOS_test() { 1665 void TestOS_test() {
1624 TestOS::run_tests(); 1666 TestOS::run_tests();