src/share/vm/runtime/os.cpp

*** 646,659 ****
  
  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));
    void* ptr = ::realloc(memblock, size);
    if (ptr != NULL) {
!     MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
       caller == 0 ? CALLER_PC : caller);
    }
    return ptr;
  #else
    if (memblock == NULL) {
      return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
--- 646,662 ----
  
  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));
+   MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
    void* ptr = ::realloc(memblock, size);
    if (ptr != NULL) {
!     tkr.record((address)memblock, (address)ptr, size, memflags,
       caller == 0 ? CALLER_PC : caller);
+   } else {
+     tkr.discard();
    }
    return ptr;
  #else
    if (memblock == NULL) {
      return malloc(size, memflags, (caller == 0 ? CALLER_PC : caller));
*** 1450,1480 ****
  
  
  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);
    }
  
    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);
    }
  
    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);
    }
    return result;
  }
  
  void os::split_reserved_memory(char *base, size_t size,
--- 1453,1483 ----
  
  
  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);
    }
  
    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_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);
    }
    return result;
  }
  
  void os::split_reserved_memory(char *base, size_t size,
*** 1498,1530 ****
    }
    return res;
  }
  
  bool os::uncommit_memory(char* addr, size_t bytes) {
    bool res = pd_uncommit_memory(addr, bytes);
    if (res) {
!     MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
    }
    return res;
  }
  
  bool os::release_memory(char* addr, size_t bytes) {
    bool res = pd_release_memory(addr, bytes);
    if (res) {
!     MemTracker::record_virtual_memory_release((address)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((address)result, bytes, CALLER_PC);
!     MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
    }
    return result;
  }
  
  char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
--- 1501,1538 ----
    }
    return res;
  }
  
  bool os::uncommit_memory(char* addr, size_t bytes) {
+   MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
    bool res = pd_uncommit_memory(addr, bytes);
    if (res) {
!     tkr.record((address)addr, bytes);
!   } else {
!     tkr.discard();
    }
    return res;
  }
  
  bool os::release_memory(char* addr, size_t bytes) {
+   MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
    bool res = pd_release_memory(addr, bytes);
    if (res) {
!     tkr.record((address)addr, bytes);
!   } else {
!     tkr.discard();
    }
    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);
    }
    return result;
  }
  
  char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
*** 1533,1546 ****
    return pd_remap_memory(fd, file_name, file_offset, addr, bytes,
                      read_only, allow_exec);
  }
  
  bool os::unmap_memory(char *addr, size_t bytes) {
    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);
    }
    return result;
  }
  
  void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
--- 1541,1556 ----
    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 = pd_unmap_memory(addr, bytes);
    if (result) {
!     tkr.record((address)addr, bytes);
!   } else {
!     tkr.discard();
    }
    return result;
  }
  
  void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {