src/hotspot/share/services/memReporter.cpp

rev 60538 : imported patch jep387-all.patch

*** 21,31 ****
--- 21,34 ----
   * questions.
   *
   */
  #include "precompiled.hpp"
  
+ 
  #include "memory/allocation.hpp"
+ #include "memory/metaspace.hpp"
+ #include "memory/metaspace/metaspaceEnums.hpp"
  #include "services/mallocTracker.hpp"
  #include "services/memReporter.hpp"
  #include "services/threadStackTracker.hpp"
  #include "services/virtualMemoryTracker.hpp"
  #include "utilities/globalDefinitions.hpp"
*** 207,236 ****
      }
      out->print_cr(" ");
    }
  }
  
! void MemSummaryReporter::report_metadata(Metaspace::MetadataType type) const {
!   assert(type == Metaspace::NonClassType || type == Metaspace::ClassType,
!     "Invalid metadata type");
!   const char* name = (type == Metaspace::NonClassType) ?
!     "Metadata:   " : "Class space:";
  
    outputStream* out = output();
    const char* scale = current_scale();
!   size_t committed   = MetaspaceUtils::committed_bytes(type);
!   size_t used = MetaspaceUtils::used_bytes(type);
!   size_t free = (MetaspaceUtils::capacity_bytes(type) - used)
!               + MetaspaceUtils::free_chunks_total_bytes(type)
!               + MetaspaceUtils::free_in_vs_bytes(type);
  
    assert(committed >= used + free, "Sanity");
    size_t waste = committed - (used + free);
  
    out->print_cr("%27s (  %s)", " ", name);
    out->print("%27s (    ", " ");
!   print_total(MetaspaceUtils::reserved_bytes(type), committed);
    out->print_cr(")");
    out->print_cr("%27s (    used=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(used), scale);
    out->print_cr("%27s (    free=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(free), scale);
    out->print_cr("%27s (    waste=" SIZE_FORMAT "%s =%2.2f%%)", " ", amount_in_current_scale(waste),
      scale, ((float)waste * 100)/committed);
--- 210,239 ----
      }
      out->print_cr(" ");
    }
  }
  
! void MemSummaryReporter::report_metadata(Metaspace::MetadataType mdType) const {
!   DEBUG_ONLY(metaspace::check_valid_mdtype(mdType));
!   const char* const name = metaspace::describe_mdtype(mdType);
  
    outputStream* out = output();
    const char* scale = current_scale();
!   size_t committed   = MetaspaceUtils::committed_bytes(mdType);
!   size_t used = MetaspaceUtils::used_bytes(mdType);
!   size_t free = 0; //
!       // TODO think this thru. What is free in this context?
!       // (MetaspaceUtils::capacity_bytes(type) - used)
!   //         + MetaspaceUtils::free_chunks_total_bytes(type)
!   //          + MetaspaceUtils::free_in_vs_bytes(type);
  
    assert(committed >= used + free, "Sanity");
    size_t waste = committed - (used + free);
  
    out->print_cr("%27s (  %s)", " ", name);
    out->print("%27s (    ", " ");
!   print_total(MetaspaceUtils::reserved_bytes(mdType), committed);
    out->print_cr(")");
    out->print_cr("%27s (    used=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(used), scale);
    out->print_cr("%27s (    free=" SIZE_FORMAT "%s)", " ", amount_in_current_scale(free), scale);
    out->print_cr("%27s (    waste=" SIZE_FORMAT "%s =%2.2f%%)", " ", amount_in_current_scale(waste),
      scale, ((float)waste * 100)/committed);
*** 597,655 ****
    if (Metaspace::using_class_space()) {
      print_metaspace_diff(Metaspace::ClassType, current_ms, early_ms);
    }
  }
  
! void MemSummaryDiffReporter::print_metaspace_diff(Metaspace::MetadataType type,
                                                    const MetaspaceSnapshot* current_ms,
                                                    const MetaspaceSnapshot* early_ms) const {
!   const char* name = (type == Metaspace::NonClassType) ?
!     "Metadata:   " : "Class space:";
  
    outputStream* out = output();
    const char* scale = current_scale();
  
    out->print_cr("%27s (  %s)", " ", name);
    out->print("%27s (    ", " ");
!   print_virtual_memory_diff(current_ms->reserved_in_bytes(type),
!                             current_ms->committed_in_bytes(type),
!                             early_ms->reserved_in_bytes(type),
!                             early_ms->committed_in_bytes(type));
    out->print_cr(")");
  
!   long diff_used = diff_in_current_scale(current_ms->used_in_bytes(type),
!                                          early_ms->used_in_bytes(type));
!   long diff_free = diff_in_current_scale(current_ms->free_in_bytes(type),
!                                          early_ms->free_in_bytes(type));
! 
!   size_t current_waste = current_ms->committed_in_bytes(type)
!     - (current_ms->used_in_bytes(type) + current_ms->free_in_bytes(type));
!   size_t early_waste = early_ms->committed_in_bytes(type)
!     - (early_ms->used_in_bytes(type) + early_ms->free_in_bytes(type));
    long diff_waste = diff_in_current_scale(current_waste, early_waste);
  
    // Diff used
    out->print("%27s (    used=" SIZE_FORMAT "%s", " ",
!     amount_in_current_scale(current_ms->used_in_bytes(type)), scale);
    if (diff_used != 0) {
      out->print(" %+ld%s", diff_used, scale);
    }
    out->print_cr(")");
  
    // Diff free
    out->print("%27s (    free=" SIZE_FORMAT "%s", " ",
!     amount_in_current_scale(current_ms->free_in_bytes(type)), scale);
    if (diff_free != 0) {
      out->print(" %+ld%s", diff_free, scale);
    }
    out->print_cr(")");
  
  
    // Diff waste
    out->print("%27s (    waste=" SIZE_FORMAT "%s =%2.2f%%", " ",
      amount_in_current_scale(current_waste), scale,
!     ((float)current_waste * 100) / current_ms->committed_in_bytes(type));
    if (diff_waste != 0) {
      out->print(" %+ld%s", diff_waste, scale);
    }
    out->print_cr(")");
  }
--- 600,658 ----
    if (Metaspace::using_class_space()) {
      print_metaspace_diff(Metaspace::ClassType, current_ms, early_ms);
    }
  }
  
! void MemSummaryDiffReporter::print_metaspace_diff(Metaspace::MetadataType mdType,
                                                    const MetaspaceSnapshot* current_ms,
                                                    const MetaspaceSnapshot* early_ms) const {
!   DEBUG_ONLY(metaspace::check_valid_mdtype(mdType));
!   const char* const name = metaspace::describe_mdtype(mdType);
  
    outputStream* out = output();
    const char* scale = current_scale();
  
    out->print_cr("%27s (  %s)", " ", name);
    out->print("%27s (    ", " ");
!   print_virtual_memory_diff(current_ms->reserved_in_bytes(mdType),
!                             current_ms->committed_in_bytes(mdType),
!                             early_ms->reserved_in_bytes(mdType),
!                             early_ms->committed_in_bytes(mdType));
    out->print_cr(")");
  
!   long diff_used = diff_in_current_scale(current_ms->used_in_bytes(mdType),
!                                          early_ms->used_in_bytes(mdType));
!   long diff_free = diff_in_current_scale(current_ms->free_in_bytes(mdType),
!                                          early_ms->free_in_bytes(mdType));
! 
!   size_t current_waste = current_ms->committed_in_bytes(mdType)
!     - (current_ms->used_in_bytes(mdType) + current_ms->free_in_bytes(mdType));
!   size_t early_waste = early_ms->committed_in_bytes(mdType)
!     - (early_ms->used_in_bytes(mdType) + early_ms->free_in_bytes(mdType));
    long diff_waste = diff_in_current_scale(current_waste, early_waste);
  
    // Diff used
    out->print("%27s (    used=" SIZE_FORMAT "%s", " ",
!     amount_in_current_scale(current_ms->used_in_bytes(mdType)), scale);
    if (diff_used != 0) {
      out->print(" %+ld%s", diff_used, scale);
    }
    out->print_cr(")");
  
    // Diff free
    out->print("%27s (    free=" SIZE_FORMAT "%s", " ",
!     amount_in_current_scale(current_ms->free_in_bytes(mdType)), scale);
    if (diff_free != 0) {
      out->print(" %+ld%s", diff_free, scale);
    }
    out->print_cr(")");
  
  
    // Diff waste
    out->print("%27s (    waste=" SIZE_FORMAT "%s =%2.2f%%", " ",
      amount_in_current_scale(current_waste), scale,
!     ((float)current_waste * 100) / current_ms->committed_in_bytes(mdType));
    if (diff_waste != 0) {
      out->print(" %+ld%s", diff_waste, scale);
    }
    out->print_cr(")");
  }