645 |
645 |
646 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { |
646 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { |
647 #ifndef ASSERT |
647 #ifndef ASSERT |
648 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
648 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
649 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); |
649 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); |
|
650 MemTracker::Tracker tkr = MemTracker::get_realloc_tracker(); |
650 void* ptr = ::realloc(memblock, size); |
651 void* ptr = ::realloc(memblock, size); |
651 if (ptr != NULL) { |
652 if (ptr != NULL) { |
652 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags, |
653 tkr.record((address)memblock, (address)ptr, size, memflags, |
653 caller == 0 ? CALLER_PC : caller); |
654 caller == 0 ? CALLER_PC : caller); |
|
655 } else { |
|
656 tkr.discard(); |
654 } |
657 } |
655 return ptr; |
658 return ptr; |
656 #else |
659 #else |
657 if (memblock == NULL) { |
660 if (memblock == NULL) { |
658 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); |
661 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); |
1454 } |
1457 } |
1455 |
1458 |
1456 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { |
1459 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { |
1457 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1460 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1458 if (result != NULL) { |
1461 if (result != NULL) { |
1459 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1462 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1460 } |
1463 } |
1461 |
1464 |
1462 return result; |
1465 return result; |
1463 } |
1466 } |
1464 |
1467 |
1465 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, |
1468 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, |
1466 MEMFLAGS flags) { |
1469 MEMFLAGS flags) { |
1467 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1470 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1468 if (result != NULL) { |
1471 if (result != NULL) { |
1469 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1472 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1470 MemTracker::record_virtual_memory_type((address)result, flags); |
1473 MemTracker::record_virtual_memory_type((address)result, flags); |
1471 } |
1474 } |
1472 |
1475 |
1473 return result; |
1476 return result; |
1474 } |
1477 } |
1475 |
1478 |
1476 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
1479 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
1477 char* result = pd_attempt_reserve_memory_at(bytes, addr); |
1480 char* result = pd_attempt_reserve_memory_at(bytes, addr); |
1478 if (result != NULL) { |
1481 if (result != NULL) { |
1479 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1482 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1480 } |
1483 } |
1481 return result; |
1484 return result; |
1482 } |
1485 } |
1483 |
1486 |
1484 void os::split_reserved_memory(char *base, size_t size, |
1487 void os::split_reserved_memory(char *base, size_t size, |
1514 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg); |
1517 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg); |
1515 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
1518 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
1516 } |
1519 } |
1517 |
1520 |
1518 bool os::uncommit_memory(char* addr, size_t bytes) { |
1521 bool os::uncommit_memory(char* addr, size_t bytes) { |
|
1522 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker(); |
1519 bool res = pd_uncommit_memory(addr, bytes); |
1523 bool res = pd_uncommit_memory(addr, bytes); |
1520 if (res) { |
1524 if (res) { |
1521 MemTracker::record_virtual_memory_uncommit((address)addr, bytes); |
1525 tkr.record((address)addr, bytes); |
|
1526 } else { |
|
1527 tkr.discard(); |
1522 } |
1528 } |
1523 return res; |
1529 return res; |
1524 } |
1530 } |
1525 |
1531 |
1526 bool os::release_memory(char* addr, size_t bytes) { |
1532 bool os::release_memory(char* addr, size_t bytes) { |
|
1533 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1527 bool res = pd_release_memory(addr, bytes); |
1534 bool res = pd_release_memory(addr, bytes); |
1528 if (res) { |
1535 if (res) { |
1529 MemTracker::record_virtual_memory_release((address)addr, bytes); |
1536 tkr.record((address)addr, bytes); |
|
1537 } else { |
|
1538 tkr.discard(); |
1530 } |
1539 } |
1531 return res; |
1540 return res; |
1532 } |
1541 } |
1533 |
1542 |
1534 |
1543 |
1535 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
1544 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
1536 char *addr, size_t bytes, bool read_only, |
1545 char *addr, size_t bytes, bool read_only, |
1537 bool allow_exec) { |
1546 bool allow_exec) { |
1538 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); |
1547 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); |
1539 if (result != NULL) { |
1548 if (result != NULL) { |
1540 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1549 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC); |
1541 MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC); |
|
1542 } |
1550 } |
1543 return result; |
1551 return result; |
1544 } |
1552 } |
1545 |
1553 |
1546 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, |
1554 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, |
1549 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, |
1557 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, |
1550 read_only, allow_exec); |
1558 read_only, allow_exec); |
1551 } |
1559 } |
1552 |
1560 |
1553 bool os::unmap_memory(char *addr, size_t bytes) { |
1561 bool os::unmap_memory(char *addr, size_t bytes) { |
|
1562 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1554 bool result = pd_unmap_memory(addr, bytes); |
1563 bool result = pd_unmap_memory(addr, bytes); |
1555 if (result) { |
1564 if (result) { |
1556 MemTracker::record_virtual_memory_uncommit((address)addr, bytes); |
1565 tkr.record((address)addr, bytes); |
1557 MemTracker::record_virtual_memory_release((address)addr, bytes); |
1566 } else { |
|
1567 tkr.discard(); |
1558 } |
1568 } |
1559 return result; |
1569 return result; |
1560 } |
1570 } |
1561 |
1571 |
1562 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { |
1572 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { |