9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
27 #define SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
28
29 #include "utilities/globalDefinitions.hpp"
30 #include "memory/metaspace.hpp" // for MetadataType enum
31 #include "memory/metaspace/metachunk.hpp" // for ChunkIndex enum
32
33 class outputStream;
34
35 namespace metaspace {
36
37 // Contains statistics for a number of free chunks.
38 class FreeChunksStatistics {
39 uintx _num; // Number of chunks
40 size_t _cap; // Total capacity, in words
41
42 public:
43 FreeChunksStatistics();
44
45 void reset();
46
47 uintx num() const { return _num; }
48 size_t cap() const { return _cap; }
49
50 void add(uintx n, size_t s);
51 void add(const FreeChunksStatistics& other);
52 void print_on(outputStream* st, size_t scale) const;
53
54 }; // end: FreeChunksStatistics
55
56
57 // Contains statistics for a ChunkManager.
58 class ChunkManagerStatistics {
59
60 FreeChunksStatistics _chunk_stats[NumberOfInUseLists];
61
62 public:
63
64 // Free chunk statistics, by chunk index.
65 const FreeChunksStatistics& chunk_stats(ChunkIndex index) const { return _chunk_stats[index]; }
66 FreeChunksStatistics& chunk_stats(ChunkIndex index) { return _chunk_stats[index]; }
67
68 void reset();
69 size_t total_capacity() const;
70
71 void print_on(outputStream* st, size_t scale) const;
72
73 }; // ChunkManagerStatistics
74
75 // Contains statistics for a number of chunks in use.
76 // Each chunk has a used and free portion; however, there are current chunks (serving
77 // potential future metaspace allocations) and non-current chunks. Unused portion of the
78 // former is counted as free, unused portion of the latter counts as waste.
79 class UsedChunksStatistics {
80 uintx _num; // Number of chunks
81 size_t _cap; // Total capacity in words.
82 size_t _used; // Total used area, in words
83 size_t _free; // Total free area (unused portions of current chunks), in words
84 size_t _waste; // Total waste area (unused portions of non-current chunks), in words
85 size_t _overhead; // Total sum of chunk overheads, in words.
86
87 public:
88
89 UsedChunksStatistics();
90
91 void reset();
92
93 uintx num() const { return _num; }
94
95 // Total capacity, in words
96 size_t cap() const { return _cap; }
97
98 // Total used area, in words
99 size_t used() const { return _used; }
100
101 // Total free area (unused portions of current chunks), in words
102 size_t free() const { return _free; }
103
104 // Total waste area (unused portions of non-current chunks), in words
105 size_t waste() const { return _waste; }
106
107 // Total area spent in overhead (chunk headers), in words
108 size_t overhead() const { return _overhead; }
109
110 void add_num(uintx n) { _num += n; }
111 void add_cap(size_t s) { _cap += s; }
112 void add_used(size_t s) { _used += s; }
113 void add_free(size_t s) { _free += s; }
114 void add_waste(size_t s) { _waste += s; }
115 void add_overhead(size_t s) { _overhead += s; }
116
117 void add(const UsedChunksStatistics& other);
118
119 void print_on(outputStream* st, size_t scale) const;
120
121 #ifdef ASSERT
122 void check_sanity() const;
123 #endif
124
125 }; // UsedChunksStatistics
126
127 // Class containing statistics for one or more space managers.
128 class SpaceManagerStatistics {
129
130 UsedChunksStatistics _chunk_stats[NumberOfInUseLists];
131 uintx _free_blocks_num;
132 size_t _free_blocks_cap_words;
133
134 public:
135
136 SpaceManagerStatistics();
137
138 // Chunk statistics by chunk index
139 const UsedChunksStatistics& chunk_stats(ChunkIndex index) const { return _chunk_stats[index]; }
140 UsedChunksStatistics& chunk_stats(ChunkIndex index) { return _chunk_stats[index]; }
141
142 uintx free_blocks_num () const { return _free_blocks_num; }
143 size_t free_blocks_cap_words () const { return _free_blocks_cap_words; }
144
145 void reset();
146
147 void add_free_blocks_info(uintx num, size_t cap);
148
149 // Returns total chunk statistics over all chunk types.
150 UsedChunksStatistics totals() const;
151
152 void add(const SpaceManagerStatistics& other);
153
154 void print_on(outputStream* st, size_t scale, bool detailed) const;
155
156 }; // SpaceManagerStatistics
157
158 class ClassLoaderMetaspaceStatistics {
159
160 SpaceManagerStatistics _sm_stats[Metaspace::MetadataTypeCount];
161
162 public:
163
164 ClassLoaderMetaspaceStatistics();
165
166 const SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) const { return _sm_stats[mdType]; }
167 SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) { return _sm_stats[mdType]; }
168
169 const SpaceManagerStatistics& nonclass_sm_stats() const { return sm_stats(Metaspace::NonClassType); }
170 SpaceManagerStatistics& nonclass_sm_stats() { return sm_stats(Metaspace::NonClassType); }
171 const SpaceManagerStatistics& class_sm_stats() const { return sm_stats(Metaspace::ClassType); }
172 SpaceManagerStatistics& class_sm_stats() { return sm_stats(Metaspace::ClassType); }
173
174 void reset();
175
176 void add(const ClassLoaderMetaspaceStatistics& other);
177
178 // Returns total space manager statistics for both class and non-class metaspace
179 SpaceManagerStatistics totals() const;
180
181 void print_on(outputStream* st, size_t scale, bool detailed) const;
182
183 }; // ClassLoaderMetaspaceStatistics
184
185 } // namespace metaspace
186
187 #endif // SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
|
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
27 #define SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
28
29 #include "memory/metaspace.hpp" // for MetadataType enum
30 #include "memory/metaspace/chunkLevel.hpp"
31 #include "utilities/globalDefinitions.hpp"
32
33 class outputStream;
34
35 namespace metaspace {
36
37 // Contains statistics for a number of free chunks.
38 struct FreeChunksStatistics {
39
40 uintx num; // Number of chunks
41 size_t word_size; // Total capacity, in words
42
43 void reset() { num = 0; word_size = 0; }
44
45 void add(uintx n, size_t s) {
46 num += n; word_size += s;
47 }
48
49 void add(const FreeChunksStatistics& other) {
50 num += other.num; word_size += other.word_size;
51 }
52
53 void print_on(outputStream* st, size_t scale) const;
54
55 }; // end: FreeChunksStatistics
56
57
58 // Contains statistics for a ChunkManager.
59 struct ChunkManagerStatistics {
60
61 FreeChunksStatistics chunk_stats[chklvl::NUM_CHUNK_LEVELS];
62
63 void reset();
64 size_t total_capacity() const;
65
66 void print_on(outputStream* st, size_t scale) const;
67
68 }; // ChunkManagerStatistics
69
70 // Contains statistics for a number of chunks in use.
71 // Each chunk has a used and free portion; however, there are current chunks (serving
72 // potential future metaspace allocations) and non-current chunks. Unused portion of the
73 // former is counted as free, unused portion of the latter counts as waste.
74 struct UsedChunksStatistics {
75
76 uintx num; // Number of chunks
77 size_t cap; // Total capacity in words.
78 size_t used; // Total used area, in words
79 size_t free; // Total free area (unused portions of current chunks), in words
80 size_t waste; // Total waste area (unused portions of non-current chunks), in words
81
82 void reset() {
83 num = 0;
84 cap = used = free = waste = 0;
85 }
86
87 void add(const UsedChunksStatistics& other) {
88 num = other.num; cap = other.cap; used = other.used; free = other.free; waste = other.waste;
89 }
90
91 void print_on(outputStream* st, size_t scale) const;
92
93 DEBUG_ONLY(void check_sanity() const;)
94
95 }; // UsedChunksStatistics
96
97 // Class containing statistics for one or more space managers.
98 struct SpaceManagerStatistics {
99
100 UsedChunksStatistics chunk_stats[chklvl::NUM_CHUNK_LEVELS];
101 uintx free_blocks_num;
102 size_t free_blocks_word_size;
103
104 void reset();
105
106 void add_free_blocks_info(uintx num, size_t cap) {
107 free_blocks_num += num; free_blocks_word_size += cap;
108 }
109
110 // Returns total chunk statistics over all chunk levels.
111 UsedChunksStatistics totals() const;
112
113 void add(const SpaceManagerStatistics& other);
114
115 void print_on(outputStream* st, size_t scale, bool detailed) const;
116
117 }; // SpaceManagerStatistics
118
119 struct ClassLoaderMetaspaceStatistics {
120
121 SpaceManagerStatistics sm_stats[Metaspace::MetadataTypeCount];
122
123 void reset() {
124 sm_stats[Metaspace::ClassType].reset();
125 sm_stats[Metaspace::NonClassType].reset();
126 }
127
128 void add(const ClassLoaderMetaspaceStatistics& other) {
129 sm_stats[Metaspace::ClassType].add(other.sm_stats[Metaspace::ClassType]);
130 sm_stats[Metaspace::NonClassType].add(other.sm_stats[Metaspace::NonClassType]);
131 }
132
133 // Returns total space manager statistics for both class and non-class metaspace
134 SpaceManagerStatistics totals() const;
135
136 void print_on(outputStream* st, size_t scale, bool detailed) const;
137
138 }; // ClassLoaderMetaspaceStatistics
139
140 } // namespace metaspace
141
142 #endif // SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
|