Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/services/memReporter.hpp

src/share/vm/services/memReporter.hpp

changeset 3900
d2a62e0f25eb
child 4165
fb19af007ffc
equal deleted inserted replaced
3877:74533f63b116 3900:d2a62e0f25eb
1 /*
2 * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_SERVICES_MEM_REPORTER_HPP
26 #define SHARE_VM_SERVICES_MEM_REPORTER_HPP
27
28 #include "runtime/mutexLocker.hpp"
29 #include "services/memBaseline.hpp"
30 #include "services/memTracker.hpp"
31 #include "utilities/ostream.hpp"
32
33 /*
34 * MemBaselineReporter reports data to this outputer class,
35 * ReportOutputer is responsible for format, store and redirect
36 * the data to the final destination.
37 */
38 class BaselineOutputer : public StackObj {
39 public:
40 // start to report memory usage in specified scale.
41 // if report_diff = true, the reporter reports baseline comparison
42 // information.
43
44 virtual void start(size_t scale, bool report_diff = false) = 0;
45 // Done reporting
46 virtual void done() = 0;
47
48 /* report baseline summary information */
49 virtual void total_usage(size_t total_reserved,
50 size_t total_committed) = 0;
51 virtual void num_of_classes(size_t classes) = 0;
52 virtual void num_of_threads(size_t threads) = 0;
53
54 virtual void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) = 0;
55
56 /* report baseline summary comparison */
57 virtual void diff_total_usage(size_t total_reserved,
58 size_t total_committed,
59 int reserved_diff,
60 int committed_diff) = 0;
61 virtual void diff_num_of_classes(size_t classes, int diff) = 0;
62 virtual void diff_num_of_threads(size_t threads, int diff) = 0;
63
64 virtual void diff_thread_info(size_t stack_reserved, size_t stack_committed,
65 int stack_reserved_diff, int stack_committed_diff) = 0;
66
67
68 /*
69 * memory summary by memory types.
70 * for each memory type, following summaries are reported:
71 * - reserved amount, committed amount
72 * - malloc'd amount, malloc count
73 * - arena amount, arena count
74 */
75
76 // start reporting memory summary by memory type
77 virtual void start_category_summary() = 0;
78
79 virtual void category_summary(MEMFLAGS type, size_t reserved_amt,
80 size_t committed_amt,
81 size_t malloc_amt, size_t malloc_count,
82 size_t arena_amt, size_t arena_count) = 0;
83
84 virtual void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
85 size_t cur_committed_amt,
86 size_t cur_malloc_amt, size_t cur_malloc_count,
87 size_t cur_arena_amt, size_t cur_arena_count,
88 int reserved_diff, int committed_diff, int malloc_diff,
89 int malloc_count_diff, int arena_diff,
90 int arena_count_diff) = 0;
91
92 virtual void done_category_summary() = 0;
93
94 /*
95 * Report callsite information
96 */
97 virtual void start_callsite() = 0;
98 virtual void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count) = 0;
99 virtual void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt) = 0;
100
101 virtual void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
102 int malloc_diff, int malloc_count_diff) = 0;
103 virtual void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
104 int reserved_diff, int committed_diff) = 0;
105
106 virtual void done_callsite() = 0;
107
108 // return current scale in "KB", "MB" or "GB"
109 static const char* memory_unit(size_t scale);
110 };
111
112 /*
113 * This class reports processed data from a baseline or
114 * the changes between the two baseline.
115 */
116 class BaselineReporter : public StackObj {
117 private:
118 BaselineOutputer& _outputer;
119 size_t _scale;
120
121 public:
122 // construct a reporter that reports memory usage
123 // in specified scale
124 BaselineReporter(BaselineOutputer& outputer, size_t scale = K):
125 _outputer(outputer) {
126 _scale = scale;
127 }
128 virtual void report_baseline(const MemBaseline& baseline, bool summary_only = false);
129 virtual void diff_baselines(const MemBaseline& cur, const MemBaseline& prev,
130 bool summary_only = false);
131
132 void set_scale(size_t scale);
133 size_t scale() const { return _scale; }
134
135 private:
136 void report_summaries(const MemBaseline& baseline);
137 void report_callsites(const MemBaseline& baseline);
138
139 void diff_summaries(const MemBaseline& cur, const MemBaseline& prev);
140 void diff_callsites(const MemBaseline& cur, const MemBaseline& prev);
141
142 // calculate memory size in current memory scale
143 size_t amount_in_current_scale(size_t amt) const;
144 // diff two unsigned values in current memory scale
145 int diff_in_current_scale(size_t value1, size_t value2) const;
146 // diff two unsigned value
147 int diff(size_t value1, size_t value2) const;
148 };
149
150 /*
151 * tty output implementation. Native memory tracking
152 * DCmd uses this outputer.
153 */
154 class BaselineTTYOutputer : public BaselineOutputer {
155 private:
156 size_t _scale;
157
158 size_t _num_of_classes;
159 size_t _num_of_threads;
160 size_t _thread_stack_reserved;
161 size_t _thread_stack_committed;
162
163 int _num_of_classes_diff;
164 int _num_of_threads_diff;
165 int _thread_stack_reserved_diff;
166 int _thread_stack_committed_diff;
167
168 outputStream* _output;
169
170 public:
171 BaselineTTYOutputer(outputStream* st) {
172 _scale = K;
173 _num_of_classes = 0;
174 _num_of_threads = 0;
175 _thread_stack_reserved = 0;
176 _thread_stack_committed = 0;
177 _num_of_classes_diff = 0;
178 _num_of_threads_diff = 0;
179 _thread_stack_reserved_diff = 0;
180 _thread_stack_committed_diff = 0;
181 _output = st;
182 }
183
184 // begin reporting memory usage in specified scale
185 void start(size_t scale, bool report_diff = false);
186 // done reporting
187 void done();
188
189 // total memory usage
190 void total_usage(size_t total_reserved,
191 size_t total_committed);
192 // report total loaded classes
193 void num_of_classes(size_t classes) {
194 _num_of_classes = classes;
195 }
196
197 void num_of_threads(size_t threads) {
198 _num_of_threads = threads;
199 }
200
201 void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) {
202 _thread_stack_reserved = stack_reserved_amt;
203 _thread_stack_committed = stack_committed_amt;
204 }
205
206 void diff_total_usage(size_t total_reserved,
207 size_t total_committed,
208 int reserved_diff,
209 int committed_diff);
210
211 void diff_num_of_classes(size_t classes, int diff) {
212 _num_of_classes = classes;
213 _num_of_classes_diff = diff;
214 }
215
216 void diff_num_of_threads(size_t threads, int diff) {
217 _num_of_threads = threads;
218 _num_of_threads_diff = diff;
219 }
220
221 void diff_thread_info(size_t stack_reserved_amt, size_t stack_committed_amt,
222 int stack_reserved_diff, int stack_committed_diff) {
223 _thread_stack_reserved = stack_reserved_amt;
224 _thread_stack_committed = stack_committed_amt;
225 _thread_stack_reserved_diff = stack_reserved_diff;
226 _thread_stack_committed_diff = stack_committed_diff;
227 }
228
229 /*
230 * Report memory summary categoriuzed by memory types.
231 * For each memory type, following summaries are reported:
232 * - reserved amount, committed amount
233 * - malloc-ed amount, malloc count
234 * - arena amount, arena count
235 */
236 // start reporting memory summary by memory type
237 void start_category_summary();
238 void category_summary(MEMFLAGS type, size_t reserved_amt, size_t committed_amt,
239 size_t malloc_amt, size_t malloc_count,
240 size_t arena_amt, size_t arena_count);
241
242 void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
243 size_t cur_committed_amt,
244 size_t cur_malloc_amt, size_t cur_malloc_count,
245 size_t cur_arena_amt, size_t cur_arena_count,
246 int reserved_diff, int committed_diff, int malloc_diff,
247 int malloc_count_diff, int arena_diff,
248 int arena_count_diff);
249
250 void done_category_summary();
251
252 /*
253 * Report callsite information
254 */
255 void start_callsite();
256 void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count);
257 void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt);
258
259 void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
260 int malloc_diff, int malloc_count_diff);
261 void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
262 int reserved_diff, int committed_diff);
263
264 void done_callsite();
265 };
266
267
268 #endif // SHARE_VM_SERVICES_MEM_REPORTER_HPP

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial