8333211: NMT Reports: replace manual indentation handling with auto indent

Reviewed-by: jsjolen, asmehra

Author: tstuefe

src/hotspot/share/memory/arena.hpp

@@ -87,7 +87,7 @@ class Chunk {
 class Arena : public CHeapObjBase {
 public:
 
-  enum class Tag {
+  enum class Tag : uint8_t {
     tag_other = 0,
     tag_ra,   // resource area
     tag_ha,   // handle area
@@ -101,6 +101,7 @@ class Arena : public CHeapObjBase {
 
   MEMFLAGS    _flags;           // Memory tracking flags
   const Tag _tag;
+  uint32_t _init_size;
   Chunk* _first;                // First chunk
   Chunk* _chunk;                // current chunk
   char* _hwm;                   // High water mark

src/hotspot/share/nmt/memReporter.cpp

@@ -44,9 +44,8 @@ class MemReporterBase : public StackObj {
   // Default scale to use if no scale given.
   static const size_t default_scale = K;
 
-  MemReporterBase(outputStream* out, size_t scale = default_scale) :
-    _scale(scale), _output(out)
-  {}
+  MemReporterBase(outputStream* out, size_t scale = default_scale);
+  ~MemReporterBase();
 
   // Helper functions
   // Calculate total reserved and committed amount
@@ -109,10 +108,7 @@ class MemReporterBase : public StackObj {
   void print_total(size_t reserved, size_t committed, size_t peak = 0) const;
   void print_malloc(const MemoryCounter* c, MEMFLAGS flag = mtNone) const;
   void print_virtual_memory(size_t reserved, size_t committed, size_t peak) const;
-
-  void print_malloc_line(const MemoryCounter* c) const;
-  void print_virtual_memory_line(size_t reserved, size_t committed, size_t peak) const;
-  void print_arena_line(const MemoryCounter* c) const;
+  void print_arena(const MemoryCounter* c) const;
 
   void print_virtual_memory_region(const char* type, address base, size_t size) const;
 };

src/hotspot/share/nmt/memReporter.hpp

@@ -92,7 +92,10 @@ void MemoryFileTracker::print_report_on(const MemoryFile* file, outputStream* st
                        NMTUtil::amount_in_scale(end_addr - start_addr, scale),
                        NMTUtil::scale_name(scale),
                        NMTUtil::flag_to_name(prev->val().out.flag()));
-      _stack_storage.get(prev->val().out.stack()).print_on(stream, 4);
+      {
+        streamIndentor si(stream, 4);
+        _stack_storage.get(prev->val().out.stack()).print_on(stream);
+      }
       stream->cr();
     }
     prev = current;

src/hotspot/share/nmt/memoryFileTracker.cpp

@@ -71,24 +71,18 @@ int NativeCallStack::frames() const {
   return index;
 }
 
-void NativeCallStack::print_on(outputStream* out) const {
-  print_on(out, 0);
-}
-
 // Decode and print this call path
-void NativeCallStack::print_on(outputStream* out, int indent) const {
+void NativeCallStack::print_on(outputStream* out) const {
   DEBUG_ONLY(assert_not_fake();)
   address pc;
   char    buf[1024];
   int     offset;
   if (is_empty()) {
-    out->fill_to(indent);
     out->print("[BOOTSTRAP]");
   } else {
     for (int frame = 0; frame < NMT_TrackingStackDepth; frame ++) {
       pc = get_frame(frame);
       if (pc == nullptr) break;
-      out->fill_to(indent);
       out->print("[" PTR_FORMAT "]", p2i(pc));
       // Print function and library; shorten library name to just its last component
       // for brevity, and omit it completely for libjvm.so

src/hotspot/share/utilities/nativeCallStack.cpp

@@ -124,7 +124,6 @@ class NativeCallStack : public StackObj {
   }
 
   void print_on(outputStream* out) const;
-  void print_on(outputStream* out, int indent) const;
 };
 
 #define FAKE_CALLSTACK NativeCallStack(NativeCallStack::FakeMarker::its_fake)

src/hotspot/share/utilities/nativeCallStack.hpp

@@ -44,18 +44,11 @@
 extern "C" void jio_print(const char* s, size_t len);
 extern "C" int jio_printf(const char *fmt, ...);
 
-outputStream::outputStream() {
-  _position    = 0;
-  _precount    = 0;
-  _indentation = 0;
-  _scratch     = nullptr;
-  _scratch_len = 0;
-}
-
 outputStream::outputStream(bool has_time_stamps) {
   _position    = 0;
   _precount    = 0;
   _indentation = 0;
+  _autoindent  = false;
   _scratch     = nullptr;
   _scratch_len = 0;
   if (has_time_stamps)  _stamp.update();
@@ -159,6 +152,9 @@ void outputStream::do_vsnprintf_and_write_with_scratch_buffer(const char* format
 }
 
 void outputStream::do_vsnprintf_and_write(const char* format, va_list ap, bool add_cr) {
+  if (_autoindent && _position == 0) {
+    indent();
+  }
   if (_scratch) {
     do_vsnprintf_and_write_with_scratch_buffer(format, ap, add_cr);
   } else {
@@ -188,6 +184,13 @@ void outputStream::vprint_cr(const char* format, va_list argptr) {
   do_vsnprintf_and_write(format, argptr, true);
 }
 
+void outputStream::print_raw(const char* str, size_t len) {
+  if (_autoindent && _position == 0) {
+    indent();
+  }
+  write(str, len);
+}
+
 void outputStream::fill_to(int col) {
   int need_fill = col - position();
   sp(need_fill);

src/hotspot/share/utilities/ostream.cpp

@@ -46,9 +46,10 @@ DEBUG_ONLY(class ResourceMark;)
 class outputStream : public CHeapObjBase {
  private:
    NONCOPYABLE(outputStream);
+   int _indentation; // current indentation
+   bool _autoindent; // if true, every line starts with indentation
 
  protected:
-   int _indentation; // current indentation
    int _position;    // visual position on the current line
    uint64_t _precount; // number of chars output, less than _position
    TimeStamp _stamp; // for time stamps
@@ -90,8 +91,7 @@ class outputStream : public CHeapObjBase {
    class TestSupport;  // Unit test support
 
    // creation
-   outputStream();
-   outputStream(bool has_time_stamps);
+   outputStream(bool has_time_stamps = false);
 
    // indentation
    outputStream& indent();
@@ -104,6 +104,13 @@ class outputStream : public CHeapObjBase {
    void fill_to(int col);
    void move_to(int col, int slop = 6, int min_space = 2);
 
+   // Automatic indentation:
+   // If autoindent mode is on, the following APIs will automatically indent
+   // line starts depending on the current indentation level:
+   // print(), print_cr(), print_raw(), print_raw_cr()
+   // Other APIs are unaffected
+   void set_autoindent(bool value) { _autoindent = value; }
+
    // sizing
    int position() const { return _position; }
    julong count() const { return _precount + _position; }
@@ -119,10 +126,10 @@ class outputStream : public CHeapObjBase {
    void print_cr(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
    void vprint(const char *format, va_list argptr) ATTRIBUTE_PRINTF(2, 0);
    void vprint_cr(const char* format, va_list argptr) ATTRIBUTE_PRINTF(2, 0);
-   void print_raw(const char* str) { write(str, strlen(str)); }
-   void print_raw(const char* str, size_t len) { write(str, len); }
-   void print_raw_cr(const char* str) { write(str, strlen(str)); cr(); }
-   void print_raw_cr(const char* str, size_t len){ write(str, len); cr(); }
+   void print_raw(const char* str)                { print_raw(str, strlen(str)); }
+   void print_raw(const char* str, size_t len);
+   void print_raw_cr(const char* str)             { print_raw(str); cr(); }
+   void print_raw_cr(const char* str, size_t len) { print_raw(str, len); cr(); }
    void print_data(void* data, size_t len, bool with_ascii, bool rel_addr=true);
    void put(char ch);
    void sp(int count = 1);

src/hotspot/share/utilities/ostream.hpp

@@ -104,6 +104,53 @@ TEST_VM(ostream, bufferedStream_dynamic_small) {
   }
 }
 
+static void test_autoindent(bool on) {
+  stringStream ss;
+  ss.set_autoindent(on);
+  {
+    streamIndentor si(&ss, 5);
+    ss.print("ABC");
+    ss.print("DEF");
+    ss.cr();
+    ss.print_cr("0123");
+    {
+      streamIndentor si(&ss, 5);
+      ss.print_cr("4567");
+      ss.print_raw("89AB");
+      ss.print_raw("CDEXXXX", 3);
+      ss.print_raw_cr("XYZ");
+    }
+    ss.print("%u", 100);
+    ss.print_raw("KB");
+    ss.cr();
+  }
+  ss.print("end");
+
+  if (on) {
+    EXPECT_STREQ(ss.base(),
+        "     ABCDEF\n"
+        "     0123\n"
+        "          4567\n"
+        "          89ABCDEXYZ\n"
+        "     100KB\n"
+        "end"
+    );
+  } else {
+    // no autoindent: calls should work as always without indentation
+    EXPECT_STREQ(ss.base(),
+        "ABCDEF\n"
+        "0123\n"
+        "4567\n"
+        "89ABCDEXYZ\n"
+        "100KB\n"
+        "end"
+    );
+  }
+}
+
+TEST_VM(ostream, autoindent_on)  { test_autoindent(true);  }
+TEST_VM(ostream, autoindent_off) { test_autoindent(false); }
+
 /* Activate to manually test bufferedStream dynamic cap.
 
 TEST_VM(ostream, bufferedStream_dynamic_large) {