Mercurial > hg > truffle
comparison src/share/vm/services/memReporter.hpp @ 6197:d2a62e0f25eb
6995781: Native Memory Tracking (Phase 1)
7151532: DCmd for hotspot native memory tracking
Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd
Reviewed-by: acorn, coleenp, fparain
author | zgu |
---|---|
date | Thu, 28 Jun 2012 17:03:16 -0400 |
parents | |
children | fb19af007ffc |
comparison
equal
deleted
inserted
replaced
6174:74533f63b116 | 6197: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 |