631 #endif
632 u_char* memblock = ptr + space_before;
633 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
634 tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
635 breakpoint();
636 }
637 debug_only(if (paranoid) verify_block(memblock));
638 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
639
640 // we do not track MallocCushion memory
641 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);
642
643 return memblock;
644 }
645
646
647 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
648 #ifndef ASSERT
649 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
650 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
651 void* ptr = ::realloc(memblock, size);
652 if (ptr != NULL) {
653 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
654 caller == 0 ? CALLER_PC : caller);
655 }
656 return ptr;
657 #else
658 if (memblock == NULL) {
659 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
660 }
661 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
662 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock);
663 breakpoint();
664 }
665 verify_block(memblock);
666 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
667 if (size == 0) return NULL;
668 // always move the block
669 void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller);
670 if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);
671 // Copy to new memory if malloc didn't fail
672 if ( ptr != NULL ) {
673 memcpy(ptr, memblock, MIN2(size, get_size(memblock)));
674 if (paranoid) verify_block(ptr);
1435 // line is longer than size of buf, skip to EOL
1436 char ch;
1437 while (read(fd, &ch, 1) == 1 && ch != '\n') {
1438 // Do nothing
1439 }
1440
1441 // return initial part of line that fits in buf.
1442 // If we reached EOF, it will be returned on next call.
1443
1444 return (int) i;
1445 }
1446
1447 bool os::create_stack_guard_pages(char* addr, size_t bytes) {
1448 return os::pd_create_stack_guard_pages(addr, bytes);
1449 }
1450
1451
1452 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
1453 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1454 if (result != NULL) {
1455 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1456 }
1457
1458 return result;
1459 }
1460
1461 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint,
1462 MEMFLAGS flags) {
1463 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1464 if (result != NULL) {
1465 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1466 MemTracker::record_virtual_memory_type((address)result, flags);
1467 }
1468
1469 return result;
1470 }
1471
1472 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
1473 char* result = pd_attempt_reserve_memory_at(bytes, addr);
1474 if (result != NULL) {
1475 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1476 }
1477 return result;
1478 }
1479
1480 void os::split_reserved_memory(char *base, size_t size,
1481 size_t split, bool realloc) {
1482 pd_split_reserved_memory(base, size, split, realloc);
1483 }
1484
1485 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
1486 bool res = pd_commit_memory(addr, bytes, executable);
1487 if (res) {
1488 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
1489 }
1490 return res;
1491 }
1492
1493 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
1494 bool executable) {
1495 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
1496 if (res) {
1497 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
1498 }
1499 return res;
1500 }
1501
1502 bool os::uncommit_memory(char* addr, size_t bytes) {
1503 bool res = pd_uncommit_memory(addr, bytes);
1504 if (res) {
1505 MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
1506 }
1507 return res;
1508 }
1509
1510 bool os::release_memory(char* addr, size_t bytes) {
1511 bool res = pd_release_memory(addr, bytes);
1512 if (res) {
1513 MemTracker::record_virtual_memory_release((address)addr, bytes);
1514 }
1515 return res;
1516 }
1517
1518
1519 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
1520 char *addr, size_t bytes, bool read_only,
1521 bool allow_exec) {
1522 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
1523 if (result != NULL) {
1524 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1525 MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
1526 }
1527 return result;
1528 }
1529
1530 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
1531 char *addr, size_t bytes, bool read_only,
1532 bool allow_exec) {
1533 return pd_remap_memory(fd, file_name, file_offset, addr, bytes,
1534 read_only, allow_exec);
1535 }
1536
1537 bool os::unmap_memory(char *addr, size_t bytes) {
1538 bool result = pd_unmap_memory(addr, bytes);
1539 if (result) {
1540 MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
1541 MemTracker::record_virtual_memory_release((address)addr, bytes);
1542 }
1543 return result;
1544 }
1545
1546 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
1547 pd_free_memory(addr, bytes, alignment_hint);
1548 }
1549
1550 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
1551 pd_realign_memory(addr, bytes, alignment_hint);
1552 }
1553
|
631 #endif
632 u_char* memblock = ptr + space_before;
633 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
634 tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
635 breakpoint();
636 }
637 debug_only(if (paranoid) verify_block(memblock));
638 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
639
640 // we do not track MallocCushion memory
641 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);
642
643 return memblock;
644 }
645
646
647 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
648 #ifndef ASSERT
649 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
650 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
651 MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
652 void* ptr = ::realloc(memblock, size);
653 if (ptr != NULL) {
654 tkr.record((address)memblock, (address)ptr, size, memflags,
655 caller == 0 ? CALLER_PC : caller);
656 } else {
657 tkr.discard();
658 }
659 return ptr;
660 #else
661 if (memblock == NULL) {
662 return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
663 }
664 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
665 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock);
666 breakpoint();
667 }
668 verify_block(memblock);
669 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
670 if (size == 0) return NULL;
671 // always move the block
672 void* ptr = malloc(size, memflags, caller == 0 ? CALLER_PC : caller);
673 if (PrintMalloc) tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);
674 // Copy to new memory if malloc didn't fail
675 if ( ptr != NULL ) {
676 memcpy(ptr, memblock, MIN2(size, get_size(memblock)));
677 if (paranoid) verify_block(ptr);
1438 // line is longer than size of buf, skip to EOL
1439 char ch;
1440 while (read(fd, &ch, 1) == 1 && ch != '\n') {
1441 // Do nothing
1442 }
1443
1444 // return initial part of line that fits in buf.
1445 // If we reached EOF, it will be returned on next call.
1446
1447 return (int) i;
1448 }
1449
1450 bool os::create_stack_guard_pages(char* addr, size_t bytes) {
1451 return os::pd_create_stack_guard_pages(addr, bytes);
1452 }
1453
1454
1455 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
1456 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1457 if (result != NULL) {
1458 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1459 }
1460
1461 return result;
1462 }
1463
1464 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint,
1465 MEMFLAGS flags) {
1466 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1467 if (result != NULL) {
1468 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1469 MemTracker::record_virtual_memory_type((address)result, flags);
1470 }
1471
1472 return result;
1473 }
1474
1475 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
1476 char* result = pd_attempt_reserve_memory_at(bytes, addr);
1477 if (result != NULL) {
1478 MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1479 }
1480 return result;
1481 }
1482
1483 void os::split_reserved_memory(char *base, size_t size,
1484 size_t split, bool realloc) {
1485 pd_split_reserved_memory(base, size, split, realloc);
1486 }
1487
1488 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
1489 bool res = pd_commit_memory(addr, bytes, executable);
1490 if (res) {
1491 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
1492 }
1493 return res;
1494 }
1495
1496 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
1497 bool executable) {
1498 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
1499 if (res) {
1500 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
1501 }
1502 return res;
1503 }
1504
1505 bool os::uncommit_memory(char* addr, size_t bytes) {
1506 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
1507 bool res = pd_uncommit_memory(addr, bytes);
1508 if (res) {
1509 tkr.record((address)addr, bytes);
1510 } else {
1511 tkr.discard();
1512 }
1513 return res;
1514 }
1515
1516 bool os::release_memory(char* addr, size_t bytes) {
1517 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1518 bool res = pd_release_memory(addr, bytes);
1519 if (res) {
1520 tkr.record((address)addr, bytes);
1521 } else {
1522 tkr.discard();
1523 }
1524 return res;
1525 }
1526
1527
1528 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
1529 char *addr, size_t bytes, bool read_only,
1530 bool allow_exec) {
1531 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
1532 if (result != NULL) {
1533 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC);
1534 }
1535 return result;
1536 }
1537
1538 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
1539 char *addr, size_t bytes, bool read_only,
1540 bool allow_exec) {
1541 return pd_remap_memory(fd, file_name, file_offset, addr, bytes,
1542 read_only, allow_exec);
1543 }
1544
1545 bool os::unmap_memory(char *addr, size_t bytes) {
1546 MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1547 bool result = pd_unmap_memory(addr, bytes);
1548 if (result) {
1549 tkr.record((address)addr, bytes);
1550 } else {
1551 tkr.discard();
1552 }
1553 return result;
1554 }
1555
1556 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
1557 pd_free_memory(addr, bytes, alignment_hint);
1558 }
1559
1560 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
1561 pd_realign_memory(addr, bytes, alignment_hint);
1562 }
1563
|