memReporter.hpp revision 3465: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 */
38class 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 */
116class 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 */
154class 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
269