1.1 --- a/src/share/vm/runtime/os.cpp Wed Aug 27 09:36:55 2014 +0200
1.2 +++ b/src/share/vm/runtime/os.cpp Wed Aug 27 08:19:12 2014 -0400
1.3 @@ -49,6 +49,7 @@
1.4 #include "runtime/stubRoutines.hpp"
1.5 #include "runtime/thread.inline.hpp"
1.6 #include "services/attachListener.hpp"
1.7 +#include "services/nmtCommon.hpp"
1.8 #include "services/memTracker.hpp"
1.9 #include "services/threadService.hpp"
1.10 #include "utilities/defaultStream.hpp"
1.11 @@ -561,7 +562,11 @@
1.12 return ptr;
1.13 }
1.14
1.15 -void* os::malloc(size_t size, MEMFLAGS memflags, address caller) {
1.16 +void* os::malloc(size_t size, MEMFLAGS flags) {
1.17 + return os::malloc(size, flags, CALLER_PC);
1.18 +}
1.19 +
1.20 +void* os::malloc(size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
1.21 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
1.22 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
1.23
1.24 @@ -587,11 +592,15 @@
1.25 size = 1;
1.26 }
1.27
1.28 + // NMT support
1.29 + NMT_TrackingLevel level = MemTracker::tracking_level();
1.30 + size_t nmt_header_size = MemTracker::malloc_header_size(level);
1.31 +
1.32 #ifndef ASSERT
1.33 - const size_t alloc_size = size;
1.34 + const size_t alloc_size = size + nmt_header_size;
1.35 #else
1.36 - const size_t alloc_size = GuardedMemory::get_total_size(size);
1.37 - if (size > alloc_size) { // Check for rollover.
1.38 + const size_t alloc_size = GuardedMemory::get_total_size(size + nmt_header_size);
1.39 + if (size + nmt_header_size > alloc_size) { // Check for rollover.
1.40 return NULL;
1.41 }
1.42 #endif
1.43 @@ -610,7 +619,7 @@
1.44 return NULL;
1.45 }
1.46 // Wrap memory with guard
1.47 - GuardedMemory guarded(ptr, size);
1.48 + GuardedMemory guarded(ptr, size + nmt_header_size);
1.49 ptr = guarded.get_user_ptr();
1.50 #endif
1.51 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
1.52 @@ -623,48 +632,50 @@
1.53 }
1.54
1.55 // we do not track guard memory
1.56 - MemTracker::record_malloc((address)ptr, size, memflags, caller == 0 ? CALLER_PC : caller);
1.57 -
1.58 - return ptr;
1.59 + return MemTracker::record_malloc((address)ptr, size, memflags, stack, level);
1.60 }
1.61
1.62 +void* os::realloc(void *memblock, size_t size, MEMFLAGS flags) {
1.63 + return os::realloc(memblock, size, flags, CALLER_PC);
1.64 +}
1.65
1.66 -void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
1.67 +void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
1.68 #ifndef ASSERT
1.69 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
1.70 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
1.71 - MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
1.72 - void* ptr = ::realloc(memblock, size);
1.73 - if (ptr != NULL) {
1.74 - tkr.record((address)memblock, (address)ptr, size, memflags,
1.75 - caller == 0 ? CALLER_PC : caller);
1.76 - } else {
1.77 - tkr.discard();
1.78 - }
1.79 - return ptr;
1.80 + // NMT support
1.81 + void* membase = MemTracker::record_free(memblock);
1.82 + NMT_TrackingLevel level = MemTracker::tracking_level();
1.83 + size_t nmt_header_size = MemTracker::malloc_header_size(level);
1.84 + void* ptr = ::realloc(membase, size + nmt_header_size);
1.85 + return MemTracker::record_malloc(ptr, size, memflags, stack, level);
1.86 #else
1.87 if (memblock == NULL) {
1.88 - return os::malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
1.89 + return os::malloc(size, memflags, stack);
1.90 }
1.91 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
1.92 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock);
1.93 breakpoint();
1.94 }
1.95 - verify_memory(memblock);
1.96 + // NMT support
1.97 + void* membase = MemTracker::malloc_base(memblock);
1.98 + verify_memory(membase);
1.99 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
1.100 if (size == 0) {
1.101 return NULL;
1.102 }
1.103 // always move the block
1.104 - void* ptr = os::malloc(size, memflags, caller == 0 ? CALLER_PC : caller);
1.105 + void* ptr = os::malloc(size, memflags, stack);
1.106 if (PrintMalloc) {
1.107 tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);
1.108 }
1.109 // Copy to new memory if malloc didn't fail
1.110 if ( ptr != NULL ) {
1.111 - GuardedMemory guarded(memblock);
1.112 - memcpy(ptr, memblock, MIN2(size, guarded.get_user_size()));
1.113 - if (paranoid) verify_memory(ptr);
1.114 + GuardedMemory guarded(MemTracker::malloc_base(memblock));
1.115 + // Guard's user data contains NMT header
1.116 + size_t memblock_size = guarded.get_user_size() - MemTracker::malloc_header_size(memblock);
1.117 + memcpy(ptr, memblock, MIN2(size, memblock_size));
1.118 + if (paranoid) verify_memory(MemTracker::malloc_base(ptr));
1.119 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
1.120 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
1.121 breakpoint();
1.122 @@ -677,7 +688,6 @@
1.123
1.124
1.125 void os::free(void *memblock, MEMFLAGS memflags) {
1.126 - address trackp = (address) memblock;
1.127 NOT_PRODUCT(inc_stat_counter(&num_frees, 1));
1.128 #ifdef ASSERT
1.129 if (memblock == NULL) return;
1.130 @@ -685,20 +695,22 @@
1.131 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock);
1.132 breakpoint();
1.133 }
1.134 - verify_memory(memblock);
1.135 + void* membase = MemTracker::record_free(memblock);
1.136 + verify_memory(membase);
1.137 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
1.138
1.139 - GuardedMemory guarded(memblock);
1.140 + GuardedMemory guarded(membase);
1.141 size_t size = guarded.get_user_size();
1.142 inc_stat_counter(&free_bytes, size);
1.143 - memblock = guarded.release_for_freeing();
1.144 + membase = guarded.release_for_freeing();
1.145 if (PrintMalloc && tty != NULL) {
1.146 - fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)memblock);
1.147 + fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)membase);
1.148 }
1.149 + ::free(membase);
1.150 +#else
1.151 + void* membase = MemTracker::record_free(memblock);
1.152 + ::free(membase);
1.153 #endif
1.154 - MemTracker::record_free(trackp, memflags);
1.155 -
1.156 - ::free(memblock);
1.157 }
1.158
1.159 void os::init_random(long initval) {
1.160 @@ -1412,7 +1424,7 @@
1.161 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
1.162 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1.163 if (result != NULL) {
1.164 - MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1.165 + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1.166 }
1.167
1.168 return result;
1.169 @@ -1422,7 +1434,7 @@
1.170 MEMFLAGS flags) {
1.171 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1.172 if (result != NULL) {
1.173 - MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1.174 + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1.175 MemTracker::record_virtual_memory_type((address)result, flags);
1.176 }
1.177
1.178 @@ -1432,7 +1444,7 @@
1.179 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
1.180 char* result = pd_attempt_reserve_memory_at(bytes, addr);
1.181 if (result != NULL) {
1.182 - MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
1.183 + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1.184 }
1.185 return result;
1.186 }
1.187 @@ -1472,23 +1484,29 @@
1.188 }
1.189
1.190 bool os::uncommit_memory(char* addr, size_t bytes) {
1.191 - MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
1.192 - bool res = pd_uncommit_memory(addr, bytes);
1.193 - if (res) {
1.194 - tkr.record((address)addr, bytes);
1.195 + bool res;
1.196 + if (MemTracker::tracking_level() > NMT_minimal) {
1.197 + Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
1.198 + res = pd_uncommit_memory(addr, bytes);
1.199 + if (res) {
1.200 + tkr.record((address)addr, bytes);
1.201 + }
1.202 } else {
1.203 - tkr.discard();
1.204 + res = pd_uncommit_memory(addr, bytes);
1.205 }
1.206 return res;
1.207 }
1.208
1.209 bool os::release_memory(char* addr, size_t bytes) {
1.210 - MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1.211 - bool res = pd_release_memory(addr, bytes);
1.212 - if (res) {
1.213 - tkr.record((address)addr, bytes);
1.214 + bool res;
1.215 + if (MemTracker::tracking_level() > NMT_minimal) {
1.216 + Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1.217 + res = pd_release_memory(addr, bytes);
1.218 + if (res) {
1.219 + tkr.record((address)addr, bytes);
1.220 + }
1.221 } else {
1.222 - tkr.discard();
1.223 + res = pd_release_memory(addr, bytes);
1.224 }
1.225 return res;
1.226 }
1.227 @@ -1499,7 +1517,7 @@
1.228 bool allow_exec) {
1.229 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
1.230 if (result != NULL) {
1.231 - MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC);
1.232 + MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
1.233 }
1.234 return result;
1.235 }
1.236 @@ -1512,12 +1530,15 @@
1.237 }
1.238
1.239 bool os::unmap_memory(char *addr, size_t bytes) {
1.240 - MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1.241 - bool result = pd_unmap_memory(addr, bytes);
1.242 - if (result) {
1.243 - tkr.record((address)addr, bytes);
1.244 + bool result;
1.245 + if (MemTracker::tracking_level() > NMT_minimal) {
1.246 + Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
1.247 + result = pd_unmap_memory(addr, bytes);
1.248 + if (result) {
1.249 + tkr.record((address)addr, bytes);
1.250 + }
1.251 } else {
1.252 - tkr.discard();
1.253 + result = pd_unmap_memory(addr, bytes);
1.254 }
1.255 return result;
1.256 }
