Mercurial > hg > truffle

comparison src/share/vm/runtime/os.cpp @ 10986:1f4355cee9a2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8013651: NMT: reserve/release sequence id's in incorrect order due to race Summary: Fixed NMT race condition for realloc, uncommit and release Reviewed-by: coleenp, ccheung
author zgu
date Tue, 18 Jun 2013 08:44:08 -0400
parents a837fa3d3f86
children 5e3b6f79d280 75ef1a499665
comparison
equal deleted inserted replaced
10984:cd2118b62475 10986:1f4355cee9a2
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) {