jdk8-mips64-public/hotspot: comparison src/share/vm/runtime/os.cpp

-:4d3a43351904
+:833b0f92429a
 #include "runtime/mutexLocker.hpp"
 #include "runtime/os.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/thread.inline.hpp"
 #include "services/attachListener.hpp"
+#include "services/nmtCommon.hpp"
 #include "services/memTracker.hpp"
 #include "services/threadService.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/events.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 (volatile jint *) &cur_malloc_words);
 }
 return ptr;
 }
-void* os::malloc(size_t size, MEMFLAGS memflags, address caller) {
+void* os::malloc(size_t size, MEMFLAGS flags) {
+return os::malloc(size, flags, CALLER_PC);
+}
+void* os::malloc(size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
 #ifdef ASSERT
 // checking for the WatcherThread and crash_protection first
 // return a valid pointer if size is zero
 // if NULL is returned the calling functions assume out of memory.
 size = 1;
 }
+// NMT support
+NMT_TrackingLevel level = MemTracker::tracking_level();
+size_t            nmt_header_size = MemTracker::malloc_header_size(level);
 #ifndef ASSERT
-const size_t alloc_size = size;
+const size_t alloc_size = size + nmt_header_size;
 #else
-const size_t alloc_size = GuardedMemory::get_total_size(size);
+const size_t alloc_size = GuardedMemory::get_total_size(size + nmt_header_size);
-if (size > alloc_size) { // Check for rollover.
+if (size + nmt_header_size > alloc_size) { // Check for rollover.
 return NULL;
 }
 #endif
 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
 #ifdef ASSERT
 if (ptr == NULL) {
 return NULL;
 }
 // Wrap memory with guard
-GuardedMemory guarded(ptr, size);
+GuardedMemory guarded(ptr, size + nmt_header_size);
 ptr = guarded.get_user_ptr();
 #endif
 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
 tty->print_cr("os::malloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
 breakpoint();
 if (PrintMalloc && tty != NULL) {
 tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
 }
 // we do not track guard memory
-MemTracker::record_malloc((address)ptr, size, memflags, caller == 0 ? CALLER_PC : caller);
+return MemTracker::record_malloc((address)ptr, size, memflags, stack, level);
+}
-return ptr;
-}
+void* os::realloc(void *memblock, size_t size, MEMFLAGS flags) {
+return os::realloc(memblock, size, flags, CALLER_PC);
+}
-void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
+void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
 #ifndef ASSERT
 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
-MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
+// NMT support
-void* ptr = ::realloc(memblock, size);
+void* membase = MemTracker::record_free(memblock);
-if (ptr != NULL) {
+NMT_TrackingLevel level = MemTracker::tracking_level();
-tkr.record((address)memblock, (address)ptr, size, memflags,
+size_t  nmt_header_size = MemTracker::malloc_header_size(level);
-caller == 0 ? CALLER_PC : caller);
+void* ptr = ::realloc(membase, size + nmt_header_size);
-} else {
+return MemTracker::record_malloc(ptr, size, memflags, stack, level);
-tkr.discard();
-}
-return ptr;
 #else
 if (memblock == NULL) {
-return os::malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
+return os::malloc(size, memflags, stack);
 }
 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
 tty->print_cr("os::realloc caught " PTR_FORMAT, memblock);
 breakpoint();
 }
-verify_memory(memblock);
+// NMT support
+void* membase = MemTracker::malloc_base(memblock);
+verify_memory(membase);
 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
 if (size == 0) {
 return NULL;
 }
 // always move the block
-void* ptr = os::malloc(size, memflags, caller == 0 ? CALLER_PC : caller);
+void* ptr = os::malloc(size, memflags, stack);
 if (PrintMalloc) {
 tty->print_cr("os::remalloc " SIZE_FORMAT " bytes, " PTR_FORMAT " --> " PTR_FORMAT, size, memblock, ptr);
 }
 // Copy to new memory if malloc didn't fail
 if ( ptr != NULL ) {
-GuardedMemory guarded(memblock);
+GuardedMemory guarded(MemTracker::malloc_base(memblock));
-memcpy(ptr, memblock, MIN2(size, guarded.get_user_size()));
+// Guard's user data contains NMT header
-if (paranoid) verify_memory(ptr);
+size_t memblock_size = guarded.get_user_size() - MemTracker::malloc_header_size(memblock);
+memcpy(ptr, memblock, MIN2(size, memblock_size));
+if (paranoid) verify_memory(MemTracker::malloc_base(ptr));
 if ((intptr_t)ptr == (intptr_t)MallocCatchPtr) {
 tty->print_cr("os::realloc caught, " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, ptr);
 breakpoint();
 }
 os::free(memblock);
 #endif
 }
 void  os::free(void *memblock, MEMFLAGS memflags) {
-address trackp = (address) memblock;
 NOT_PRODUCT(inc_stat_counter(&num_frees, 1));
 #ifdef ASSERT
 if (memblock == NULL) return;
 if ((intptr_t)memblock == (intptr_t)MallocCatchPtr) {
 if (tty != NULL) tty->print_cr("os::free caught " PTR_FORMAT, memblock);
 breakpoint();
 }
-verify_memory(memblock);
+void* membase = MemTracker::record_free(memblock);
+verify_memory(membase);
 NOT_PRODUCT(if (MallocVerifyInterval > 0) check_heap());
-GuardedMemory guarded(memblock);
+GuardedMemory guarded(membase);
 size_t size = guarded.get_user_size();
 inc_stat_counter(&free_bytes, size);
-memblock = guarded.release_for_freeing();
+membase = guarded.release_for_freeing();
 if (PrintMalloc && tty != NULL) {
-fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)memblock);
+fprintf(stderr, "os::free " SIZE_FORMAT " bytes --> " PTR_FORMAT "\n", size, (uintptr_t)membase);
 }
-#endif
+::free(membase);
-MemTracker::record_free(trackp, memflags);
+#else
+void* membase = MemTracker::record_free(memblock);
-::free(memblock);
+::free(membase);
+#endif
 }
 void os::init_random(long initval) {
 _rand_seed = initval;
 }
 }
 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, mtNone, CALLER_PC);
+MemTracker::record_virtual_memory_reserve((address)result, bytes, 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, mtNone, CALLER_PC);
+MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
 MemTracker::record_virtual_memory_type((address)result, flags);
 }
 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, mtNone, CALLER_PC);
+MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
 }
 return result;
 }
 void os::split_reserved_memory(char *base, size_t size,
 os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg);
 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
 }
 bool os::uncommit_memory(char* addr, size_t bytes) {
-MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
+bool res;
-bool res = pd_uncommit_memory(addr, bytes);
+if (MemTracker::tracking_level() > NMT_minimal) {
-if (res) {
+Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
-tkr.record((address)addr, bytes);
+res = pd_uncommit_memory(addr, bytes);
+if (res) {
+tkr.record((address)addr, bytes);
+}
 } else {
-tkr.discard();
+res = pd_uncommit_memory(addr, bytes);
 }
 return res;
 }
 bool os::release_memory(char* addr, size_t bytes) {
-MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
+bool res;
-bool res = pd_release_memory(addr, bytes);
+if (MemTracker::tracking_level() > NMT_minimal) {
-if (res) {
+Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
-tkr.record((address)addr, bytes);
+res = pd_release_memory(addr, bytes);
+if (res) {
+tkr.record((address)addr, bytes);
+}
 } else {
-tkr.discard();
+res = pd_release_memory(addr, bytes);
 }
 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_and_commit((address)result, bytes, mtNone, CALLER_PC);
+MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
 }
 return result;
 }
 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
 return pd_remap_memory(fd, file_name, file_offset, addr, bytes,
 read_only, allow_exec);
 }
 bool os::unmap_memory(char *addr, size_t bytes) {
-MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
+bool result;
-bool result = pd_unmap_memory(addr, bytes);
+if (MemTracker::tracking_level() > NMT_minimal) {
-if (result) {
+Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
-tkr.record((address)addr, bytes);
+result = pd_unmap_memory(addr, bytes);
+if (result) {
+tkr.record((address)addr, bytes);
+}
 } else {
-tkr.discard();
+result = pd_unmap_memory(addr, bytes);
 }
 return result;
 }
 void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/runtime/os.cpp

src/share/vm/runtime/os.cpp