Mercurial > hg > truffle

comparison src/share/vm/runtime/os.cpp @ 6882:716c64bda5ba

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7199092: NMT: NMT needs to deal overlapped virtual memory ranges Summary: Enhanced virtual memory tracking to track committed regions as well as reserved regions, so NMT now can generate virtual memory map. Reviewed-by: acorn, coleenp
author zgu
date Fri, 19 Oct 2012 21:40:07 -0400
parents 87ac5c0a404d
children e522a00b91aa 6cb0d32b828b e4f764ddb06a
comparison
equal deleted inserted replaced
6879:8ebcedb7604d 6882:716c64bda5ba
598 } 598 }
599 debug_only(if (paranoid) verify_block(memblock)); 599 debug_only(if (paranoid) verify_block(memblock));
600 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock); 600 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
601 601
602 // we do not track MallocCushion memory 602 // we do not track MallocCushion memory
603 if (MemTracker::is_on()) {
604 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller); 603 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);
605 }
606 604
607 return memblock; 605 return memblock;
608 } 606 }
609 607
610 608
611 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) { 609 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
612 #ifndef ASSERT 610 #ifndef ASSERT
613 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1)); 611 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
614 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size)); 612 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
615 void* ptr = ::realloc(memblock, size); 613 void* ptr = ::realloc(memblock, size);
616 if (ptr != NULL && MemTracker::is_on()) { 614 if (ptr != NULL) {
617 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags, 615 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
618 caller == 0 ? CALLER_PC : caller); 616 caller == 0 ? CALLER_PC : caller);
619 } 617 }
620 return ptr; 618 return ptr;
621 #else 619 #else
1399 } 1397 }
1400 1398
1401 1399
1402 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 1400 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
1403 char* result = pd_reserve_memory(bytes, addr, alignment_hint); 1401 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1404 if (result != NULL && MemTracker::is_on()) { 1402 if (result != NULL) {
1405 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1403 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1406 } 1404 }
1407 1405
1408 return result; 1406 return result;
1409 } 1407 }
1410 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { 1408 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
1411 char* result = pd_attempt_reserve_memory_at(bytes, addr); 1409 char* result = pd_attempt_reserve_memory_at(bytes, addr);
1412 if (result != NULL && MemTracker::is_on()) { 1410 if (result != NULL) {
1413 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1411 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1414 } 1412 }
1415 return result; 1413 return result;
1416 } 1414 }
1417 1415
1420 pd_split_reserved_memory(base, size, split, realloc); 1418 pd_split_reserved_memory(base, size, split, realloc);
1421 } 1419 }
1422 1420
1423 bool os::commit_memory(char* addr, size_t bytes, bool executable) { 1421 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
1424 bool res = pd_commit_memory(addr, bytes, executable); 1422 bool res = pd_commit_memory(addr, bytes, executable);
1425 if (res && MemTracker::is_on()) { 1423 if (res) {
1426 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); 1424 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
1427 } 1425 }
1428 return res; 1426 return res;
1429 } 1427 }
1430 1428
1431 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 1429 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
1432 bool executable) { 1430 bool executable) {
1433 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable); 1431 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
1434 if (res && MemTracker::is_on()) { 1432 if (res) {
1435 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC); 1433 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
1436 } 1434 }
1437 return res; 1435 return res;
1438 } 1436 }
1439 1437
1456 1454
1457 char* os::map_memory(int fd, const char* file_name, size_t file_offset, 1455 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
1458 char *addr, size_t bytes, bool read_only, 1456 char *addr, size_t bytes, bool read_only,
1459 bool allow_exec) { 1457 bool allow_exec) {
1460 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); 1458 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
1461 if (result != NULL && MemTracker::is_on()) { 1459 if (result != NULL) {
1462 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1460 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1461 MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
1463 } 1462 }
1464 return result; 1463 return result;
1465 } 1464 }
1466 1465
1467 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 1466 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
1472 } 1471 }
1473 1472
1474 bool os::unmap_memory(char *addr, size_t bytes) { 1473 bool os::unmap_memory(char *addr, size_t bytes) {
1475 bool result = pd_unmap_memory(addr, bytes); 1474 bool result = pd_unmap_memory(addr, bytes);
1476 if (result) { 1475 if (result) {
1476 MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
1477 MemTracker::record_virtual_memory_release((address)addr, bytes); 1477 MemTracker::record_virtual_memory_release((address)addr, bytes);
1478 } 1478 }
1479 return result; 1479 return result;
1480 } 1480 }
1481 1481