50 #include "runtime/os.inline.hpp" |
50 #include "runtime/os.inline.hpp" |
51 #include "runtime/stubRoutines.hpp" |
51 #include "runtime/stubRoutines.hpp" |
52 #include "runtime/thread.inline.hpp" |
52 #include "runtime/thread.inline.hpp" |
53 #include "runtime/vm_version.hpp" |
53 #include "runtime/vm_version.hpp" |
54 #include "services/attachListener.hpp" |
54 #include "services/attachListener.hpp" |
|
55 #include "services/nmtCommon.hpp" |
55 #include "services/memTracker.hpp" |
56 #include "services/memTracker.hpp" |
56 #include "services/threadService.hpp" |
57 #include "services/threadService.hpp" |
57 #include "utilities/defaultStream.hpp" |
58 #include "utilities/defaultStream.hpp" |
58 #include "utilities/events.hpp" |
59 #include "utilities/events.hpp" |
59 |
60 |
613 if (PrintMalloc && tty != NULL) { |
622 if (PrintMalloc && tty != NULL) { |
614 tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
623 tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
615 } |
624 } |
616 |
625 |
617 // we do not track guard memory |
626 // we do not track guard memory |
618 MemTracker::record_malloc((address)ptr, size, memflags, caller == 0 ? CALLER_PC : caller); |
627 return MemTracker::record_malloc((address)ptr, size, memflags, stack, level); |
619 |
628 } |
620 return ptr; |
629 |
621 } |
630 void* os::realloc(void *memblock, size_t size, MEMFLAGS flags) { |
622 |
631 return os::realloc(memblock, size, flags, CALLER_PC); |
623 |
632 } |
624 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { |
633 |
|
634 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCallStack& stack) { |
625 #ifndef ASSERT |
635 #ifndef ASSERT |
626 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
636 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); |
627 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); |
637 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); |
628 MemTracker::Tracker tkr = MemTracker::get_realloc_tracker(); |
638 // NMT support |
629 void* ptr = ::realloc(memblock, size); |
639 void* membase = MemTracker::record_free(memblock); |
630 if (ptr != NULL) { |
640 NMT_TrackingLevel level = MemTracker::tracking_level(); |
631 tkr.record((address)memblock, (address)ptr, size, memflags, |
641 size_t nmt_header_size = MemTracker::malloc_header_size(level); |
632 caller == 0 ? CALLER_PC : caller); |
642 void* ptr = ::realloc(membase, size + nmt_header_size); |
633 } else { |
643 return MemTracker::record_malloc(ptr, size, memflags, stack, level); |
634 tkr.discard(); |
|
635 } |
|
636 return ptr; |
|
637 #else |
644 #else |
638 if (memblock == NULL) { |
645 if (memblock == NULL) { |
639 return os::malloc(size, memflags, (caller == 0 ? CALLER_PC : caller)); |
646 return os::malloc(size, memflags, stack); |
640 } |
647 } |
641 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
648 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
642 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock); |
649 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock); |
643 breakpoint(); |
650 breakpoint(); |
644 } |
651 } |
645 verify_memory(memblock); |
652 // NMT support |
|
653 void* membase = MemTracker::malloc_base(memblock); |
|
654 verify_memory(membase); |
646 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
655 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
647 if (size == 0) { |
656 if (size == 0) { |
648 return NULL; |
657 return NULL; |
649 } |
658 } |
650 // always move the block |
659 // always move the block |
651 void* ptr = os::malloc(size, memflags, caller == 0 ? CALLER_PC : caller); |
660 void* ptr = os::malloc(size, memflags, stack); |
652 if (PrintMalloc) { |
661 if (PrintMalloc) { |
653 tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr); |
662 tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr); |
654 } |
663 } |
655 // Copy to new memory if malloc didn't fail |
664 // Copy to new memory if malloc didn't fail |
656 if ( ptr != NULL ) { |
665 if ( ptr != NULL ) { |
657 GuardedMemory guarded(memblock); |
666 GuardedMemory guarded(MemTracker::malloc_base(memblock)); |
658 memcpy(ptr, memblock, MIN2(size, guarded.get_user_size())); |
667 // Guard's user data contains NMT header |
659 if (paranoid) verify_memory(ptr); |
668 size_t memblock_size = guarded.get_user_size() - MemTracker::malloc_header_size(memblock); |
|
669 memcpy(ptr, memblock, MIN2(size, memblock_size)); |
|
670 if (paranoid) verify_memory(MemTracker::malloc_base(ptr)); |
660 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) { |
671 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) { |
661 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
672 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr); |
662 breakpoint(); |
673 breakpoint(); |
663 } |
674 } |
664 os::free(memblock); |
675 os::free(memblock); |
667 #endif |
678 #endif |
668 } |
679 } |
669 |
680 |
670 |
681 |
671 void os::free(void *memblock, MEMFLAGS memflags) { |
682 void os::free(void *memblock, MEMFLAGS memflags) { |
672 address trackp = (address) memblock; |
|
673 NOT_PRODUCT(inc_stat_counter(&num_frees, 1)); |
683 NOT_PRODUCT(inc_stat_counter(&num_frees, 1)); |
674 #ifdef ASSERT |
684 #ifdef ASSERT |
675 if (memblock == NULL) return; |
685 if (memblock == NULL) return; |
676 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
686 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) { |
677 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock); |
687 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock); |
678 breakpoint(); |
688 breakpoint(); |
679 } |
689 } |
680 verify_memory(memblock); |
690 void* membase = MemTracker::record_free(memblock); |
|
691 verify_memory(membase); |
681 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
692 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap()); |
682 |
693 |
683 GuardedMemory guarded(memblock); |
694 GuardedMemory guarded(membase); |
684 size_t size = guarded.get_user_size(); |
695 size_t size = guarded.get_user_size(); |
685 inc_stat_counter(&free_bytes, size); |
696 inc_stat_counter(&free_bytes, size); |
686 memblock = guarded.release_for_freeing(); |
697 membase = guarded.release_for_freeing(); |
687 if (PrintMalloc && tty != NULL) { |
698 if (PrintMalloc && tty != NULL) { |
688 fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)memblock); |
699 fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)membase); |
689 } |
700 } |
|
701 ::free(membase); |
|
702 #else |
|
703 void* membase = MemTracker::record_free(memblock); |
|
704 ::free(membase); |
690 #endif |
705 #endif |
691 MemTracker::record_free(trackp, memflags); |
|
692 |
|
693 ::free(memblock); |
|
694 } |
706 } |
695 |
707 |
696 void os::init_random(long initval) { |
708 void os::init_random(long initval) { |
697 _rand_seed = initval; |
709 _rand_seed = initval; |
698 } |
710 } |
1402 } |
1414 } |
1403 |
1415 |
1404 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { |
1416 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { |
1405 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1417 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1406 if (result != NULL) { |
1418 if (result != NULL) { |
1407 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1419 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1408 } |
1420 } |
1409 |
1421 |
1410 return result; |
1422 return result; |
1411 } |
1423 } |
1412 |
1424 |
1413 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, |
1425 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, |
1414 MEMFLAGS flags) { |
1426 MEMFLAGS flags) { |
1415 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1427 char* result = pd_reserve_memory(bytes, addr, alignment_hint); |
1416 if (result != NULL) { |
1428 if (result != NULL) { |
1417 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1429 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1418 MemTracker::record_virtual_memory_type((address)result, flags); |
1430 MemTracker::record_virtual_memory_type((address)result, flags); |
1419 } |
1431 } |
1420 |
1432 |
1421 return result; |
1433 return result; |
1422 } |
1434 } |
1423 |
1435 |
1424 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
1436 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { |
1425 char* result = pd_attempt_reserve_memory_at(bytes, addr); |
1437 char* result = pd_attempt_reserve_memory_at(bytes, addr); |
1426 if (result != NULL) { |
1438 if (result != NULL) { |
1427 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC); |
1439 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); |
1428 } |
1440 } |
1429 return result; |
1441 return result; |
1430 } |
1442 } |
1431 |
1443 |
1432 void os::split_reserved_memory(char *base, size_t size, |
1444 void os::split_reserved_memory(char *base, size_t size, |
1462 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg); |
1474 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg); |
1463 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
1475 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); |
1464 } |
1476 } |
1465 |
1477 |
1466 bool os::uncommit_memory(char* addr, size_t bytes) { |
1478 bool os::uncommit_memory(char* addr, size_t bytes) { |
1467 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker(); |
1479 bool res; |
1468 bool res = pd_uncommit_memory(addr, bytes); |
1480 if (MemTracker::tracking_level() > NMT_minimal) { |
1469 if (res) { |
1481 Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker(); |
1470 tkr.record((address)addr, bytes); |
1482 res = pd_uncommit_memory(addr, bytes); |
|
1483 if (res) { |
|
1484 tkr.record((address)addr, bytes); |
|
1485 } |
1471 } else { |
1486 } else { |
1472 tkr.discard(); |
1487 res = pd_uncommit_memory(addr, bytes); |
1473 } |
1488 } |
1474 return res; |
1489 return res; |
1475 } |
1490 } |
1476 |
1491 |
1477 bool os::release_memory(char* addr, size_t bytes) { |
1492 bool os::release_memory(char* addr, size_t bytes) { |
1478 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1493 bool res; |
1479 bool res = pd_release_memory(addr, bytes); |
1494 if (MemTracker::tracking_level() > NMT_minimal) { |
1480 if (res) { |
1495 Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1481 tkr.record((address)addr, bytes); |
1496 res = pd_release_memory(addr, bytes); |
|
1497 if (res) { |
|
1498 tkr.record((address)addr, bytes); |
|
1499 } |
1482 } else { |
1500 } else { |
1483 tkr.discard(); |
1501 res = pd_release_memory(addr, bytes); |
1484 } |
1502 } |
1485 return res; |
1503 return res; |
1486 } |
1504 } |
1487 |
1505 |
1488 |
1506 |
1489 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
1507 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
1490 char *addr, size_t bytes, bool read_only, |
1508 char *addr, size_t bytes, bool read_only, |
1491 bool allow_exec) { |
1509 bool allow_exec) { |
1492 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); |
1510 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); |
1493 if (result != NULL) { |
1511 if (result != NULL) { |
1494 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC); |
1512 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC); |
1495 } |
1513 } |
1496 return result; |
1514 return result; |
1497 } |
1515 } |
1498 |
1516 |
1499 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, |
1517 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, |
1502 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, |
1520 return pd_remap_memory(fd, file_name, file_offset, addr, bytes, |
1503 read_only, allow_exec); |
1521 read_only, allow_exec); |
1504 } |
1522 } |
1505 |
1523 |
1506 bool os::unmap_memory(char *addr, size_t bytes) { |
1524 bool os::unmap_memory(char *addr, size_t bytes) { |
1507 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1525 bool result; |
1508 bool result = pd_unmap_memory(addr, bytes); |
1526 if (MemTracker::tracking_level() > NMT_minimal) { |
1509 if (result) { |
1527 Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); |
1510 tkr.record((address)addr, bytes); |
1528 result = pd_unmap_memory(addr, bytes); |
|
1529 if (result) { |
|
1530 tkr.record((address)addr, bytes); |
|
1531 } |
1511 } else { |
1532 } else { |
1512 tkr.discard(); |
1533 result = pd_unmap_memory(addr, bytes); |
1513 } |
1534 } |
1514 return result; |
1535 return result; |
1515 } |
1536 } |
1516 |
1537 |
1517 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { |
1538 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) { |