< prev index next >

src/hotspot/share/memory/metaspace/metaspaceStatistics.hpp

Print this page
rev 57380 : [mq]: metaspace-improvement

@@ -24,48 +24,43 @@
  */
 
 #ifndef SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
 #define SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
 
-#include "utilities/globalDefinitions.hpp"
 #include "memory/metaspace.hpp" // for MetadataType enum
-#include "memory/metaspace/metachunk.hpp" // for ChunkIndex enum
+#include "memory/metaspace/chunkLevel.hpp"
+#include "utilities/globalDefinitions.hpp"
 
 class outputStream;
 
 namespace metaspace {
 
 // Contains statistics for a number of free chunks.
-class FreeChunksStatistics {
-  uintx _num;         // Number of chunks
-  size_t _cap;        // Total capacity, in words
+struct FreeChunksStatistics {
 
-public:
-  FreeChunksStatistics();
+  uintx num;         // Number of chunks
+  size_t word_size;  // Total capacity, in words
 
-  void reset();
+  void reset() { num = 0; word_size = 0; }
+
+  void add(uintx n, size_t s) {
+    num += n; word_size += s;
+  }
 
-  uintx num() const { return _num; }
-  size_t cap() const { return _cap; }
+  void add(const FreeChunksStatistics& other) {
+    num += other.num; word_size += other.word_size;
+  }
 
-  void add(uintx n, size_t s);
-  void add(const FreeChunksStatistics& other);
   void print_on(outputStream* st, size_t scale) const;
 
 }; // end: FreeChunksStatistics
 
 
 // Contains statistics for a ChunkManager.
-class ChunkManagerStatistics {
+struct ChunkManagerStatistics {
 
-  FreeChunksStatistics _chunk_stats[NumberOfInUseLists];
-
-public:
-
-  // Free chunk statistics, by chunk index.
-  const FreeChunksStatistics& chunk_stats(ChunkIndex index) const   { return _chunk_stats[index]; }
-  FreeChunksStatistics& chunk_stats(ChunkIndex index)               { return _chunk_stats[index]; }
+  FreeChunksStatistics chunk_stats[chklvl::NUM_CHUNK_LEVELS];
 
   void reset();
   size_t total_capacity() const;
 
   void print_on(outputStream* st, size_t scale) const;

@@ -74,108 +69,68 @@
 
 // Contains statistics for a number of chunks in use.
 // Each chunk has a used and free portion; however, there are current chunks (serving
 // potential future metaspace allocations) and non-current chunks. Unused portion of the
 // former is counted as free, unused portion of the latter counts as waste.
-class UsedChunksStatistics {
-  uintx _num;     // Number of chunks
-  size_t _cap;    // Total capacity in words.
-  size_t _used;   // Total used area, in words
-  size_t _free;   // Total free area (unused portions of current chunks), in words
-  size_t _waste;  // Total waste area (unused portions of non-current chunks), in words
-  size_t _overhead; // Total sum of chunk overheads, in words.
-
-public:
-
-  UsedChunksStatistics();
-
-  void reset();
-
-  uintx num() const { return _num; }
-
-  // Total capacity, in words
-  size_t cap() const { return _cap; }
-
-  // Total used area, in words
-  size_t used() const { return _used; }
-
-  // Total free area (unused portions of current chunks), in words
-  size_t free() const { return _free; }
+struct UsedChunksStatistics {
 
-  // Total waste area (unused portions of non-current chunks), in words
-  size_t waste() const { return _waste; }
-
-  // Total area spent in overhead (chunk headers), in words
-  size_t overhead() const { return _overhead; }
-
-  void add_num(uintx n) { _num += n; }
-  void add_cap(size_t s) { _cap += s; }
-  void add_used(size_t s) { _used += s; }
-  void add_free(size_t s) { _free += s; }
-  void add_waste(size_t s) { _waste += s; }
-  void add_overhead(size_t s) { _overhead += s; }
-
-  void add(const UsedChunksStatistics& other);
+  uintx num;     // Number of chunks
+  size_t cap;    // Total capacity in words.
+  size_t used;   // Total used area, in words
+  size_t free;   // Total free area (unused portions of current chunks), in words
+  size_t waste;  // Total waste area (unused portions of non-current chunks), in words
+
+  void reset() {
+    num = 0;
+    cap = used = free = waste = 0;
+  }
+
+  void add(const UsedChunksStatistics& other) {
+    num = other.num; cap = other.cap; used = other.used; free = other.free; waste = other.waste;
+  }
 
   void print_on(outputStream* st, size_t scale) const;
 
-#ifdef ASSERT
-  void check_sanity() const;
-#endif
+  DEBUG_ONLY(void check_sanity() const;)
 
 }; // UsedChunksStatistics
 
 // Class containing statistics for one or more space managers.
-class SpaceManagerStatistics {
-
-  UsedChunksStatistics _chunk_stats[NumberOfInUseLists];
-  uintx _free_blocks_num;
-  size_t _free_blocks_cap_words;
-
-public:
-
-  SpaceManagerStatistics();
-
-  // Chunk statistics by chunk index
-  const UsedChunksStatistics& chunk_stats(ChunkIndex index) const   { return _chunk_stats[index]; }
-  UsedChunksStatistics& chunk_stats(ChunkIndex index)               { return _chunk_stats[index]; }
+struct SpaceManagerStatistics {
 
-  uintx free_blocks_num () const                                    { return _free_blocks_num; }
-  size_t free_blocks_cap_words () const                             { return _free_blocks_cap_words; }
+  UsedChunksStatistics chunk_stats[chklvl::NUM_CHUNK_LEVELS];
+  uintx free_blocks_num;
+  size_t free_blocks_word_size;
 
   void reset();
 
-  void add_free_blocks_info(uintx num, size_t cap);
+  void add_free_blocks_info(uintx num, size_t cap) {
+    free_blocks_num += num; free_blocks_word_size += cap;
+  }
 
-  // Returns total chunk statistics over all chunk types.
+  // Returns total chunk statistics over all chunk levels.
   UsedChunksStatistics totals() const;
 
   void add(const SpaceManagerStatistics& other);
 
   void print_on(outputStream* st, size_t scale,  bool detailed) const;
 
 }; // SpaceManagerStatistics
 
-class ClassLoaderMetaspaceStatistics {
+struct ClassLoaderMetaspaceStatistics {
 
-  SpaceManagerStatistics _sm_stats[Metaspace::MetadataTypeCount];
-
-public:
-
-  ClassLoaderMetaspaceStatistics();
-
-  const SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) const { return _sm_stats[mdType]; }
-  SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType)             { return _sm_stats[mdType]; }
-
-  const SpaceManagerStatistics& nonclass_sm_stats() const { return sm_stats(Metaspace::NonClassType); }
-  SpaceManagerStatistics& nonclass_sm_stats()             { return sm_stats(Metaspace::NonClassType); }
-  const SpaceManagerStatistics& class_sm_stats() const    { return sm_stats(Metaspace::ClassType); }
-  SpaceManagerStatistics& class_sm_stats()                { return sm_stats(Metaspace::ClassType); }
-
-  void reset();
+  SpaceManagerStatistics sm_stats[Metaspace::MetadataTypeCount];
 
-  void add(const ClassLoaderMetaspaceStatistics& other);
+  void reset() {
+    sm_stats[Metaspace::ClassType].reset();
+    sm_stats[Metaspace::NonClassType].reset();
+  }
+
+  void add(const ClassLoaderMetaspaceStatistics& other) {
+    sm_stats[Metaspace::ClassType].add(other.sm_stats[Metaspace::ClassType]);
+    sm_stats[Metaspace::NonClassType].add(other.sm_stats[Metaspace::NonClassType]);
+  }
 
   // Returns total space manager statistics for both class and non-class metaspace
   SpaceManagerStatistics totals() const;
 
   void print_on(outputStream* st, size_t scale, bool detailed) const;
< prev index next >