--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/services/memReporter.hpp Thu Jun 28 17:03:16 2012 -0400
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_VM_SERVICES_MEM_REPORTER_HPP
+#define SHARE_VM_SERVICES_MEM_REPORTER_HPP
+
+#include "runtime/mutexLocker.hpp"
+#include "services/memBaseline.hpp"
+#include "services/memTracker.hpp"
+#include "utilities/ostream.hpp"
+
+/*
+ * MemBaselineReporter reports data to this outputer class,
+ * ReportOutputer is responsible for format, store and redirect
+ * the data to the final destination.
+ */
+class BaselineOutputer : public StackObj {
+ public:
+ // start to report memory usage in specified scale.
+ // if report_diff = true, the reporter reports baseline comparison
+ // information.
+
+ virtual void start(size_t scale, bool report_diff = false) = 0;
+ // Done reporting
+ virtual void done() = 0;
+
+ /* report baseline summary information */
+ virtual void total_usage(size_t total_reserved,
+ size_t total_committed) = 0;
+ virtual void num_of_classes(size_t classes) = 0;
+ virtual void num_of_threads(size_t threads) = 0;
+
+ virtual void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) = 0;
+
+ /* report baseline summary comparison */
+ virtual void diff_total_usage(size_t total_reserved,
+ size_t total_committed,
+ int reserved_diff,
+ int committed_diff) = 0;
+ virtual void diff_num_of_classes(size_t classes, int diff) = 0;
+ virtual void diff_num_of_threads(size_t threads, int diff) = 0;
+
+ virtual void diff_thread_info(size_t stack_reserved, size_t stack_committed,
+ int stack_reserved_diff, int stack_committed_diff) = 0;
+
+
+ /*
+ * memory summary by memory types.
+ * for each memory type, following summaries are reported:
+ * - reserved amount, committed amount
+ * - malloc'd amount, malloc count
+ * - arena amount, arena count
+ */
+
+ // start reporting memory summary by memory type
+ virtual void start_category_summary() = 0;
+
+ virtual void category_summary(MEMFLAGS type, size_t reserved_amt,
+ size_t committed_amt,
+ size_t malloc_amt, size_t malloc_count,
+ size_t arena_amt, size_t arena_count) = 0;
+
+ virtual void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
+ size_t cur_committed_amt,
+ size_t cur_malloc_amt, size_t cur_malloc_count,
+ size_t cur_arena_amt, size_t cur_arena_count,
+ int reserved_diff, int committed_diff, int malloc_diff,
+ int malloc_count_diff, int arena_diff,
+ int arena_count_diff) = 0;
+
+ virtual void done_category_summary() = 0;
+
+ /*
+ * Report callsite information
+ */
+ virtual void start_callsite() = 0;
+ virtual void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count) = 0;
+ virtual void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt) = 0;
+
+ virtual void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
+ int malloc_diff, int malloc_count_diff) = 0;
+ virtual void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
+ int reserved_diff, int committed_diff) = 0;
+
+ virtual void done_callsite() = 0;
+
+ // return current scale in "KB", "MB" or "GB"
+ static const char* memory_unit(size_t scale);
+};
+
+/*
+ * This class reports processed data from a baseline or
+ * the changes between the two baseline.
+ */
+class BaselineReporter : public StackObj {
+ private:
+ BaselineOutputer& _outputer;
+ size_t _scale;
+
+ public:
+ // construct a reporter that reports memory usage
+ // in specified scale
+ BaselineReporter(BaselineOutputer& outputer, size_t scale = K):
+ _outputer(outputer) {
+ _scale = scale;
+ }
+ virtual void report_baseline(const MemBaseline& baseline, bool summary_only = false);
+ virtual void diff_baselines(const MemBaseline& cur, const MemBaseline& prev,
+ bool summary_only = false);
+
+ void set_scale(size_t scale);
+ size_t scale() const { return _scale; }
+
+ private:
+ void report_summaries(const MemBaseline& baseline);
+ void report_callsites(const MemBaseline& baseline);
+
+ void diff_summaries(const MemBaseline& cur, const MemBaseline& prev);
+ void diff_callsites(const MemBaseline& cur, const MemBaseline& prev);
+
+ // calculate memory size in current memory scale
+ size_t amount_in_current_scale(size_t amt) const;
+ // diff two unsigned values in current memory scale
+ int diff_in_current_scale(size_t value1, size_t value2) const;
+ // diff two unsigned value
+ int diff(size_t value1, size_t value2) const;
+};
+
+/*
+ * tty output implementation. Native memory tracking
+ * DCmd uses this outputer.
+ */
+class BaselineTTYOutputer : public BaselineOutputer {
+ private:
+ size_t _scale;
+
+ size_t _num_of_classes;
+ size_t _num_of_threads;
+ size_t _thread_stack_reserved;
+ size_t _thread_stack_committed;
+
+ int _num_of_classes_diff;
+ int _num_of_threads_diff;
+ int _thread_stack_reserved_diff;
+ int _thread_stack_committed_diff;
+
+ outputStream* _output;
+
+ public:
+ BaselineTTYOutputer(outputStream* st) {
+ _scale = K;
+ _num_of_classes = 0;
+ _num_of_threads = 0;
+ _thread_stack_reserved = 0;
+ _thread_stack_committed = 0;
+ _num_of_classes_diff = 0;
+ _num_of_threads_diff = 0;
+ _thread_stack_reserved_diff = 0;
+ _thread_stack_committed_diff = 0;
+ _output = st;
+ }
+
+ // begin reporting memory usage in specified scale
+ void start(size_t scale, bool report_diff = false);
+ // done reporting
+ void done();
+
+ // total memory usage
+ void total_usage(size_t total_reserved,
+ size_t total_committed);
+ // report total loaded classes
+ void num_of_classes(size_t classes) {
+ _num_of_classes = classes;
+ }
+
+ void num_of_threads(size_t threads) {
+ _num_of_threads = threads;
+ }
+
+ void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) {
+ _thread_stack_reserved = stack_reserved_amt;
+ _thread_stack_committed = stack_committed_amt;
+ }
+
+ void diff_total_usage(size_t total_reserved,
+ size_t total_committed,
+ int reserved_diff,
+ int committed_diff);
+
+ void diff_num_of_classes(size_t classes, int diff) {
+ _num_of_classes = classes;
+ _num_of_classes_diff = diff;
+ }
+
+ void diff_num_of_threads(size_t threads, int diff) {
+ _num_of_threads = threads;
+ _num_of_threads_diff = diff;
+ }
+
+ void diff_thread_info(size_t stack_reserved_amt, size_t stack_committed_amt,
+ int stack_reserved_diff, int stack_committed_diff) {
+ _thread_stack_reserved = stack_reserved_amt;
+ _thread_stack_committed = stack_committed_amt;
+ _thread_stack_reserved_diff = stack_reserved_diff;
+ _thread_stack_committed_diff = stack_committed_diff;
+ }
+
+ /*
+ * Report memory summary categoriuzed by memory types.
+ * For each memory type, following summaries are reported:
+ * - reserved amount, committed amount
+ * - malloc-ed amount, malloc count
+ * - arena amount, arena count
+ */
+ // start reporting memory summary by memory type
+ void start_category_summary();
+ void category_summary(MEMFLAGS type, size_t reserved_amt, size_t committed_amt,
+ size_t malloc_amt, size_t malloc_count,
+ size_t arena_amt, size_t arena_count);
+
+ void diff_category_summary(MEMFLAGS type, size_t cur_reserved_amt,
+ size_t cur_committed_amt,
+ size_t cur_malloc_amt, size_t cur_malloc_count,
+ size_t cur_arena_amt, size_t cur_arena_count,
+ int reserved_diff, int committed_diff, int malloc_diff,
+ int malloc_count_diff, int arena_diff,
+ int arena_count_diff);
+
+ void done_category_summary();
+
+ /*
+ * Report callsite information
+ */
+ void start_callsite();
+ void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count);
+ void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt);
+
+ void diff_malloc_callsite(address pc, size_t cur_malloc_amt, size_t cur_malloc_count,
+ int malloc_diff, int malloc_count_diff);
+ void diff_virtual_memory_callsite(address pc, size_t cur_reserved_amt, size_t cur_committed_amt,
+ int reserved_diff, int committed_diff);
+
+ void done_callsite();
+};
+
+
+#endif // SHARE_VM_SERVICES_MEM_REPORTER_HPP