src/share/vm/runtime/os.cpp
Index
Unified diffs
Context diffs
Sdiffs
Wdiffs
Patch
New
Old
Previous File
Next File
*** old/src/share/vm/runtime/os.cpp Mon May 13 16:34:50 2013
--- new/src/share/vm/runtime/os.cpp Mon May 13 16:34:49 2013
*** 635,659 ****
--- 635,663 ----
breakpoint();
}
debug_only(if (paranoid) verify_block(memblock));
if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
! // we do not track MallocCushion memory
! MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);
! // we don't track MallocCushion memory
! NMTTrackOp op(NMTTrackOp::MallocOp);
+ op.execute_op((address)memblock, size, memflags, caller == NULL ? CALLER_PC : caller);
return memblock;
}
void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
#ifndef ASSERT
NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
+
+ NMTTrackOp op(NMTTrackOp::ReallocOp);
void* ptr = ::realloc(memblock, size);
if (ptr != NULL) {
! MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
! caller == 0 ? CALLER_PC : caller);
! op.execute_op((address)memblock, (address)ptr, size, memflags,
! caller == NULL ? CALLER_PC : caller);
+ } else {
+ op.abort_op();
}
return ptr;
#else
if (memblock == NULL) {
return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
*** 714,725 ****
--- 718,730 ----
} else if (PrintMalloc && tty != NULL) {
// tty->print_cr("os::free %p", memblock);
fprintf(stderr, "os::free " PTR_FORMAT "\n", (uintptr_t)memblock);
}
#endif
! MemTracker::record_free((address)memblock, memflags);
! NMTTrackOp op(NMTTrackOp::FreeOp);
+ // the op has to be executed before actually free to avoid race
+ op.execute_op((address)memblock);
::free((char*)memblock - space_before);
}
void os::init_random(long initval) {
_rand_seed = initval;
*** 1450,1480 ****
--- 1455,1487 ----
char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
char* result = pd_reserve_memory(bytes, addr, alignment_hint);
if (result != NULL) {
! MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
! NMTTrackOp op(NMTTrackOp::ReserveOp);
+ op.execute_op((address)result, bytes, 0, CALLER_PC);
}
return result;
}
char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint,
MEMFLAGS flags) {
char* result = pd_reserve_memory(bytes, addr, alignment_hint);
if (result != NULL) {
! MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
! MemTracker::record_virtual_memory_type((address)result, flags);
! NMTTrackOp op(NMTTrackOp::ReserveOp);
! op.execute_op((address)result, bytes, flags, CALLER_PC);
}
return result;
}
char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
char* result = pd_attempt_reserve_memory_at(bytes, addr);
if (result != NULL) {
! MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
! NMTTrackOp op(NMTTrackOp::ReserveOp);
+ op.execute_op((address)result, bytes, 0, CALLER_PC);
}
return result;
}
void os::split_reserved_memory(char *base, size_t size,
*** 1483,1530 ****
--- 1490,1547 ----
}
bool os::commit_memory(char* addr, size_t bytes, bool executable) {
bool res = pd_commit_memory(addr, bytes, executable);
if (res) {
! MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
! NMTTrackOp op(NMTTrackOp::CommitOp);
+ op.execute_op((address)addr, bytes, 0, CALLER_PC);
}
return res;
}
bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
bool executable) {
bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
if (res) {
! MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
! NMTTrackOp op(NMTTrackOp::CommitOp);
+ op.execute_op((address)addr, size, 0, CALLER_PC);
}
return res;
}
bool os::uncommit_memory(char* addr, size_t bytes) {
+ // The op has to be instantiated before actually uncommit
+ NMTTrackOp op(NMTTrackOp::UncommitOp);
bool res = pd_uncommit_memory(addr, bytes);
if (res) {
! MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
! op.execute_op((address)addr, bytes);
+ } else {
+ op.abort_op();
}
return res;
}
bool os::release_memory(char* addr, size_t bytes) {
+ // The op has to be instantiated before actully release
+ NMTTrackOp op(NMTTrackOp::ReleaseOp);
bool res = pd_release_memory(addr, bytes);
if (res) {
! MemTracker::record_virtual_memory_release((address)addr, bytes);
! op.execute_op((address)addr, bytes);
+ } else {
+ op.abort_op();
}
return res;
}
char* os::map_memory(int fd, const char* file_name, size_t file_offset,
char *addr, size_t bytes, bool read_only,
bool allow_exec) {
char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
if (result != NULL) {
! MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
! MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
! NMTTrackOp op(NMTTrackOp::ReserveAndCommitOp);
! op.execute_op((address)result, bytes, 0, CALLER_PC);
}
return result;
}
char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
*** 1533,1546 ****
--- 1550,1565 ----
return pd_remap_memory(fd, file_name, file_offset, addr, bytes,
read_only, allow_exec);
}
bool os::unmap_memory(char *addr, size_t bytes) {
+ NMTTrackOp op(NMTTrackOp::ReleaseOp);
bool result = pd_unmap_memory(addr, bytes);
if (result) {
! MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
MemTracker::record_virtual_memory_release((address)addr, bytes);
! op.execute_op((address)addr, bytes);
+ } else {
+ op.abort_op();
}
return result;
}
void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
src/share/vm/runtime/os.cpp
Index
Unified diffs
Context diffs
Sdiffs
Wdiffs
Patch
New
Old
Previous File
Next File