RFR: 8328944: NMT reports "unknown" memory [v2]

[Afshin Zafari]

On Tue, 19 Nov 2024 22:01:13 GMT, Gerard Ziemski <gziemski at openjdk.org> wrote:

>> We use `mtNone` value in several functions default parameters, which may show up in NMT reports.
>> 
>> We address this, by avoiding using `mtNone`.
>> 
>> Eventually the goal would be to eliminate using `mtNone` whenever possible.
>> TODO: update copyrights.
>> 
>> Testing: undergoing MARCH5 tier1-5 ...
>
> Gerard Ziemski has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains six additional commits since the last revision:
> 
>  - avoid using mtNone
>  - Merge remote-tracking branch 'upstream/master' into JDK-8328944
>  - revert, we will re-do with a smaller change
>  - remove more mtNone
>  - remove API that allows to change the mem_tag for virtual memory, feedback
>  - do not allow default parameter for mtNone

Thanks for taking this issue. I add my points here:

1) The `ReservedSpace` objects in these files have to have extra MemTag (`mtTest`) parameter:
  - test_freeRegionList.cpp
  - test_virtualspace.cpp
  - test_virtualMemoryTracker.cpp
 
2) The `mtNone` as default value for the parameter should be removed from the following functions, otherwise Unknown memory types can still be reported:



Source root • src/hotspot/os/windows/os_windows.cpp:
    3239: static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int file_desc, MemTag mem_tag = mtNone) {
  3239    assert(is_aligned(alignment, os::vm_allocation_granularity()),
  3240    assert(is_aligned(alignment, os::vm_allocation_granularity()),

Source root • src/hotspot/share/cds/filemap.cpp:
  1773                          char *addr, size_t bytes, bool read_only,
  1774:                         bool allow_exec, MemTag mem_tag = mtNone) {
  1775    char* mem = os::map_memory(fd, file_name, file_offset, addr, bytes,

Source root • src/hotspot/share/memory/virtualspace.hpp:
  63    void initialize(size_t size, size_t alignment, size_t page_size,
  64    void initialize(size_t size, size_t alignment, size_t page_size,
  65:                   char* requested_address, bool executable, MemTag mem_tag = mtNone);
  65  
  66  

Source root • src/hotspot/share/nmt/memReporter.hpp:
  110    void print_total(size_t reserved, size_t committed, size_t peak = 0) const;
  111:   void print_malloc(const MemoryCounter* c, MemTag mem_tag = mtNone) const;
  112    void print_virtual_memory(size_t reserved, size_t committed, size_t peak) const;

Source root • src/hotspot/share/nmt/memTracker.hpp:
  123    static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
  124:     MemTag mem_tag = mtNone) {
  125      assert_post_init();

  149    static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
  150:     const NativeCallStack& stack, MemTag mem_tag = mtNone) {

Source root • src/hotspot/share/nmt/virtualMemoryTracker.hpp:
  299    ReservedMemoryRegion(address base, size_t size, const NativeCallStack& stack,
  300:     MemTag mem_tag = mtNone) :

  383:   static bool add_reserved_region (address base_addr, size_t size, const NativeCallStack& stack, MemTag mem_tag = mtNone);
  384  

Source root • src/hotspot/share/runtime/os.hpp:
  453:   static char*  reserve_memory(size_t bytes, bool executable = false, MemTag mem_tag = mtNone);

  460:   static char*  attempt_reserve_memory_at(char* addr, size_t bytes, bool executable = false, MemTag mem_tag = mtNone);

  512:   static char* map_memory_to_file(size_t size, int fd, MemTag mem_tag = mtNone);
  513:   static char* map_memory_to_file_aligned(size_t size, size_t alignment, int fd, MemTag mem_tag = mtNone);

  515:   static char* attempt_map_memory_to_file_at(char* base, size_t size, int fd, MemTag mem_tag = mtNone);

  519  static char*  map_memory(int fd, const char* file_name, size_t file_offset,
                          char *addr, size_t bytes, bool read_only = false,
  520                             char *addr, size_t bytes, bool read_only = false,
  521:                            bool allow_exec = false, MemTag mem_tag = mtNone);



3) In virtualspace.cpp, the `result` in these functions has `mtNone` tag while the parent may have another tag:


ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment) {
  assert(partition_size <= size(), "partition failed");
  ReservedSpace result(base(), partition_size, alignment, page_size(), special(), executable());
  return result;
}

ReservedSpace ReservedSpace::last_part(size_t partition_size, size_t alignment) {
  assert(partition_size <= size(), "partition failed");
  ReservedSpace result(base() + partition_size, size() - partition_size,
                       alignment, page_size(), special(), executable());
  return result;
}

ReservedSpace ReservedSpace::partition(size_t offset, size_t partition_size, size_t alignment) {
  assert(offset + partition_size <= size(), "partition failed");
  ReservedSpace result(base() + offset, partition_size, alignment, page_size(), special(), executable());
  return result;
}

4) In virtualspace.cpp, the `space` has `mtNone` tag at this function:

ReservedSpace ReservedSpace::space_for_range(char* base, size_t size, size_t alignment,
                                             size_t page_size, bool special, bool executable) {
  assert(is_aligned(base, os::vm_allocation_granularity()), "Unaligned base");
  assert(is_aligned(size, os::vm_page_size()), "Unaligned size");
  assert(os::page_sizes().contains(page_size), "Invalid pagesize");
  ReservedSpace space;
  space.initialize_members(base, size, alignment, page_size, special, executable);
  return space;
}

-------------

PR Review: https://git.openjdk.org/jdk/pull/21843#pullrequestreview-2448359154