1289 // The very lower end of the stack |
1289 // The very lower end of the stack |
1290 address stack_limit = thread->stack_base() - thread->stack_size(); |
1290 address stack_limit = thread->stack_base() - thread->stack_size(); |
1291 return (sp > (stack_limit + reserved_area)); |
1291 return (sp > (stack_limit + reserved_area)); |
1292 } |
1292 } |
1293 |
1293 |
1294 size_t os::page_size_for_region(size_t region_size, size_t min_pages) { |
1294 size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size, |
|
1295 uint min_pages) |
|
1296 { |
1295 assert(min_pages > 0, "sanity"); |
1297 assert(min_pages > 0, "sanity"); |
1296 if (UseLargePages) { |
1298 if (UseLargePages) { |
1297 const size_t max_page_size = region_size / min_pages; |
1299 const size_t max_page_size = region_max_size / min_pages; |
1298 |
1300 |
1299 for (size_t i = 0; _page_sizes[i] != 0; ++i) { |
1301 for (unsigned int i = 0; _page_sizes[i] != 0; ++i) { |
1300 const size_t page_size = _page_sizes[i]; |
1302 const size_t sz = _page_sizes[i]; |
1301 if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) { |
1303 const size_t mask = sz - 1; |
1302 return page_size; |
1304 if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) { |
|
1305 // The largest page size with no fragmentation. |
|
1306 return sz; |
|
1307 } |
|
1308 |
|
1309 if (sz <= max_page_size) { |
|
1310 // The largest page size that satisfies the min_pages requirement. |
|
1311 return sz; |
1303 } |
1312 } |
1304 } |
1313 } |
1305 } |
1314 } |
1306 |
1315 |
1307 return vm_page_size(); |
1316 return vm_page_size(); |
1525 return to; |
1534 return to; |
1526 } |
1535 } |
1527 return result; |
1536 return result; |
1528 } |
1537 } |
1529 #endif |
1538 #endif |
1530 |
|
1531 /////////////// Unit tests /////////////// |
|
1532 |
|
1533 #ifndef PRODUCT |
|
1534 |
|
1535 #define assert_eq(a,b) assert(a == b, err_msg(SIZE_FORMAT " != " SIZE_FORMAT, a, b)) |
|
1536 |
|
1537 class TestOS : AllStatic { |
|
1538 static size_t small_page_size() { |
|
1539 return os::vm_page_size(); |
|
1540 } |
|
1541 |
|
1542 static size_t large_page_size() { |
|
1543 const size_t large_page_size_example = 4 * M; |
|
1544 return os::page_size_for_region(large_page_size_example, 1); |
|
1545 } |
|
1546 |
|
1547 static void test_page_size_for_region() { |
|
1548 if (UseLargePages) { |
|
1549 const size_t small_page = small_page_size(); |
|
1550 const size_t large_page = large_page_size(); |
|
1551 |
|
1552 if (large_page > small_page) { |
|
1553 size_t num_small_pages_in_large = large_page / small_page; |
|
1554 size_t page = os::page_size_for_region(large_page, num_small_pages_in_large); |
|
1555 |
|
1556 assert_eq(page, small_page); |
|
1557 } |
|
1558 } |
|
1559 } |
|
1560 |
|
1561 static void test_page_size_for_region_alignment() { |
|
1562 if (UseLargePages) { |
|
1563 const size_t small_page = small_page_size(); |
|
1564 const size_t large_page = large_page_size(); |
|
1565 if (large_page > small_page) { |
|
1566 const size_t unaligned_region = large_page + 17; |
|
1567 size_t page = os::page_size_for_region(unaligned_region, 1); |
|
1568 assert_eq(page, small_page); |
|
1569 |
|
1570 const size_t num_pages = 5; |
|
1571 const size_t aligned_region = large_page * num_pages; |
|
1572 page = os::page_size_for_region(aligned_region, num_pages); |
|
1573 assert_eq(page, large_page); |
|
1574 } |
|
1575 } |
|
1576 } |
|
1577 |
|
1578 public: |
|
1579 static void run_tests() { |
|
1580 test_page_size_for_region(); |
|
1581 test_page_size_for_region_alignment(); |
|
1582 } |
|
1583 }; |
|
1584 |
|
1585 void TestOS_test() { |
|
1586 TestOS::run_tests(); |
|
1587 } |
|
1588 |
|
1589 #endif // PRODUCT |
|