jdk8-mips64-public/hotspot: comparison src/share/vm/services/memReporter.hpp

-:4d3a43351904
+:833b0f92429a
 /*
-* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2014, 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.
 */
 #ifndef SHARE_VM_SERVICES_MEM_REPORTER_HPP
 #define SHARE_VM_SERVICES_MEM_REPORTER_HPP
-#include "runtime/mutexLocker.hpp"
+#if INCLUDE_NMT
+#include "oops/instanceKlass.hpp"
 #include "services/memBaseline.hpp"
-#include "services/memTracker.hpp"
+#include "services/nmtCommon.hpp"
-#include "utilities/ostream.hpp"
+#include "services/mallocTracker.hpp"
-#include "utilities/macros.hpp"
+#include "services/virtualMemoryTracker.hpp"
-#if INCLUDE_NMT
+/*
+* Base class that provides helpers
-/*
+*/
-* MemBaselineReporter reports data to this outputer class,
+class MemReporterBase : public StackObj {
-* ReportOutputer is responsible for format, store and redirect
+private:
-* the data to the final destination.
+size_t        _scale;  // report in this scale
-*/
+outputStream* _output; // destination
-class BaselineOutputer : public StackObj {
 public:
-// start to report memory usage in specified scale.
+MemReporterBase(outputStream* out = NULL, size_t scale = K)
-// if report_diff = true, the reporter reports baseline comparison
+: _scale(scale) {
-// information.
+_output = (out == NULL) ? tty : out;
+}
-virtual void start(size_t scale, bool report_diff = false) = 0;
-// Done reporting
+protected:
-virtual void done() = 0;
+inline outputStream* output() const {
+return _output;
-/* report baseline summary information */
+}
-virtual void total_usage(size_t total_reserved,
+// Current reporting scale
-size_t total_committed) = 0;
+inline const char* current_scale() const {
-virtual void num_of_classes(size_t classes) = 0;
+return NMTUtil::scale_name(_scale);
-virtual void num_of_threads(size_t threads) = 0;
+}
+// Convert memory amount in bytes to current reporting scale
-virtual void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) = 0;
+inline size_t amount_in_current_scale(size_t amount) const {
+return NMTUtil::amount_in_scale(amount, _scale);
-/* report baseline summary comparison */
+}
-virtual void diff_total_usage(size_t total_reserved,
-size_t total_committed,
+// Convert diff amount in bytes to current reporting scale
-int reserved_diff,
+inline long diff_in_current_scale(size_t s1, size_t s2) const {
-int committed_diff) = 0;
+long amount = (long)(s1 - s2);
-virtual void diff_num_of_classes(size_t classes, int diff) = 0;
+long scale = (long)_scale;
-virtual void diff_num_of_threads(size_t threads, int diff) = 0;
+amount = (amount > 0) ? (amount + scale / 2) : (amount - scale / 2);
+return amount / scale;
-virtual void diff_thread_info(size_t stack_reserved, size_t stack_committed,
+}
-int stack_reserved_diff, int stack_committed_diff) = 0;
+// Helper functions
+// Calculate total reserved and committed amount
-/*
+size_t reserved_total(const MallocMemory* malloc, const VirtualMemory* vm) const;
-* memory summary by memory types.
+size_t committed_total(const MallocMemory* malloc, const VirtualMemory* vm) const;
-* for each memory type, following summaries are reported:
-*  - reserved amount, committed amount
-*  - malloc'd amount, malloc count
+// Print summary total, malloc and virtual memory
-*  - arena amount, arena count
+void print_total(size_t reserved, size_t committed) const;
-*/
+void print_malloc(size_t amount, size_t count) const;
+void print_virtual_memory(size_t reserved, size_t committed) const;
-// start reporting memory summary by memory type
-virtual void start_category_summary() = 0;
+void print_malloc_line(size_t amount, size_t count) const;
+void print_virtual_memory_line(size_t reserved, size_t committed) const;
-virtual void category_summary(MEMFLAGS type, size_t reserved_amt,
+void print_arena_line(size_t amount, size_t count) const;
-size_t committed_amt,
-size_t malloc_amt, size_t malloc_count,
+void print_virtual_memory_region(const char* type, address base, size_t size) const;
-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,
+* The class is for generating summary tracking report.
-size_t cur_malloc_amt, size_t cur_malloc_count,
+*/
-size_t cur_arena_amt, size_t cur_arena_count,
+class MemSummaryReporter : public MemReporterBase {
-int reserved_diff, int committed_diff, int malloc_diff,
+private:
-int malloc_count_diff, int arena_diff,
+MallocMemorySnapshot*   _malloc_snapshot;
-int arena_count_diff) = 0;
+VirtualMemorySnapshot*  _vm_snapshot;
+size_t                  _class_count;
-virtual void done_category_summary() = 0;
+public:
-virtual void start_virtual_memory_map() = 0;
+// Report summary tracking data from global snapshots directly.
-virtual void reserved_memory_region(MEMFLAGS type, address base, address end, size_t size, address pc) = 0;
+// This constructor is used for final reporting and hs_err reporting.
-virtual void committed_memory_region(address base, address end, size_t size, address pc) = 0;
+MemSummaryReporter(MallocMemorySnapshot* malloc_snapshot,
-virtual void done_virtual_memory_map() = 0;
+VirtualMemorySnapshot* vm_snapshot, outputStream* output,
+size_t class_count = 0, size_t scale = K) :
-/*
+MemReporterBase(output, scale),
-*  Report callsite information
+_malloc_snapshot(malloc_snapshot),
-*/
+_vm_snapshot(vm_snapshot) {
-virtual void start_callsite() = 0;
+if (class_count == 0) {
-virtual void malloc_callsite(address pc, size_t malloc_amt, size_t malloc_count) = 0;
+_class_count = InstanceKlass::number_of_instance_classes();
-virtual void virtual_memory_callsite(address pc, size_t reserved_amt, size_t committed_amt) = 0;
+} else {
+_class_count = class_count;
-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,
+// This constructor is for normal reporting from a recent baseline.
-int reserved_diff, int committed_diff) = 0;
+MemSummaryReporter(MemBaseline& baseline, outputStream* output,
+size_t scale = K) : MemReporterBase(output, scale),
-virtual void done_callsite() = 0;
+_malloc_snapshot(baseline.malloc_memory_snapshot()),
+_vm_snapshot(baseline.virtual_memory_snapshot()),
-// return current scale in "KB", "MB" or "GB"
+_class_count(baseline.class_count()) { }
-static const char* memory_unit(size_t scale);
-};
+// Generate summary report
-/*
+virtual void report();
-* This class reports processed data from a baseline or
+private:
-* the changes between the two baseline.
+// Report summary for each memory type
-*/
+void report_summary_of_type(MEMFLAGS type, MallocMemory* malloc_memory,
-class BaselineReporter : public StackObj {
+VirtualMemory* virtual_memory);
-private:
+};
-BaselineOutputer&  _outputer;
-size_t             _scale;
+/*
+* The class is for generating detail tracking report.
-public:
+*/
-// construct a reporter that reports memory usage
+class MemDetailReporter : public MemSummaryReporter {
-// in specified scale
+private:
-BaselineReporter(BaselineOutputer& outputer, size_t scale = K):
+MemBaseline&   _baseline;
-_outputer(outputer) {
-_scale = scale;
+public:
-}
+MemDetailReporter(MemBaseline& baseline, outputStream* output, size_t scale = K) :
-virtual void report_baseline(const MemBaseline& baseline, bool summary_only = false);
+MemSummaryReporter(baseline, output, scale),
-virtual void diff_baselines(const MemBaseline& cur, const MemBaseline& prev,
+_baseline(baseline) { }
-bool summary_only = false);
+// Generate detail report.
-void set_scale(size_t scale);
+// The report contains summary and detail sections.
-size_t scale() const { return _scale; }
+virtual void report() {
+MemSummaryReporter::report();
-private:
+report_virtual_memory_map();
-void report_summaries(const MemBaseline& baseline);
+report_detail();
-void report_virtual_memory_map(const MemBaseline& baseline);
+}
-void report_callsites(const MemBaseline& baseline);
+private:
-void diff_summaries(const MemBaseline& cur, const MemBaseline& prev);
+// Report detail tracking data.
-void diff_callsites(const MemBaseline& cur, const MemBaseline& prev);
+void report_detail();
+// Report virtual memory map
-// calculate memory size in current memory scale
+void report_virtual_memory_map();
-size_t amount_in_current_scale(size_t amt) const;
+// Report malloc allocation sites
-// diff two unsigned values in current memory scale
+void report_malloc_sites();
-int    diff_in_current_scale(size_t value1, size_t value2) const;
+// Report virtual memory reservation sites
-// diff two unsigned value
+void report_virtual_memory_allocation_sites();
-int    diff(size_t value1, size_t value2) const;
-};
+// Report a virtual memory region
+void report_virtual_memory_region(const ReservedMemoryRegion* rgn);
-/*
+};
-* tty output implementation. Native memory tracking
-* DCmd uses this outputer.
+/*
-*/
+* The class is for generating summary comparison report.
-class BaselineTTYOutputer : public BaselineOutputer {
+* It compares current memory baseline against an early baseline.
-private:
+*/
-size_t         _scale;
+class MemSummaryDiffReporter : public MemReporterBase {
+protected:
-size_t         _num_of_classes;
+MemBaseline&      _early_baseline;
-size_t         _num_of_threads;
+MemBaseline&      _current_baseline;
-size_t         _thread_stack_reserved;
-size_t         _thread_stack_committed;
+public:
+MemSummaryDiffReporter(MemBaseline& early_baseline, MemBaseline& current_baseline,
-int            _num_of_classes_diff;
+outputStream* output, size_t scale = K) : MemReporterBase(output, scale),
-int            _num_of_threads_diff;
+_early_baseline(early_baseline), _current_baseline(current_baseline) {
-int            _thread_stack_reserved_diff;
+assert(early_baseline.baseline_type()   != MemBaseline::Not_baselined, "Not baselined");
-int            _thread_stack_committed_diff;
+assert(current_baseline.baseline_type() != MemBaseline::Not_baselined, "Not baselined");
+}
-outputStream*  _output;
+// Generate summary comparison report
-public:
+virtual void report_diff();
-BaselineTTYOutputer(outputStream* st) {
-_scale = K;
+private:
-_num_of_classes = 0;
+// report the comparison of each memory type
-_num_of_threads = 0;
+void diff_summary_of_type(MEMFLAGS type,
-_thread_stack_reserved = 0;
+const MallocMemory* early_malloc, const VirtualMemory* early_vm,
-_thread_stack_committed = 0;
+const MallocMemory* current_malloc, const VirtualMemory* current_vm) const;
-_num_of_classes_diff = 0;
-_num_of_threads_diff = 0;
+protected:
-_thread_stack_reserved_diff = 0;
+void print_malloc_diff(size_t current_amount, size_t current_count,
-_thread_stack_committed_diff = 0;
+size_t early_amount, size_t early_count) const;
-_output = st;
+void print_virtual_memory_diff(size_t current_reserved, size_t current_committed,
-}
+size_t early_reserved, size_t early_committed) const;
+void print_arena_diff(size_t current_amount, size_t current_count,
-// begin reporting memory usage in specified scale
+size_t early_amount, size_t early_count) const;
-void start(size_t scale, bool report_diff = false);
+};
-// done reporting
-void done();
+/*
+* The class is for generating detail comparison report.
-// total memory usage
+* It compares current memory baseline against an early baseline,
-void total_usage(size_t total_reserved,
+* both baselines have to be detail baseline.
-size_t total_committed);
+*/
-// report total loaded classes
+class MemDetailDiffReporter : public MemSummaryDiffReporter {
-void num_of_classes(size_t classes) {
+public:
-_num_of_classes = classes;
+MemDetailDiffReporter(MemBaseline& early_baseline, MemBaseline& current_baseline,
-}
+outputStream* output, size_t scale = K) :
+MemSummaryDiffReporter(early_baseline, current_baseline, output, scale) { }
-void num_of_threads(size_t threads) {
-_num_of_threads = threads;
+// Generate detail comparison report
-}
+virtual void report_diff();
-void thread_info(size_t stack_reserved_amt, size_t stack_committed_amt) {
+// Malloc allocation site comparison
-_thread_stack_reserved = stack_reserved_amt;
+void diff_malloc_sites() const;
-_thread_stack_committed = stack_committed_amt;
+// Virutal memory reservation site comparison
-}
+void diff_virtual_memory_sites() const;
-void diff_total_usage(size_t total_reserved,
+// New malloc allocation site in recent baseline
-size_t total_committed,
+void new_malloc_site (const MallocSite* site) const;
-int reserved_diff,
+// The malloc allocation site is not in recent baseline
-int committed_diff);
+void old_malloc_site (const MallocSite* site) const;
+// Compare malloc allocation site, it is in both baselines
-void diff_num_of_classes(size_t classes, int diff) {
+void diff_malloc_site(const MallocSite* early, const MallocSite* current)  const;
-_num_of_classes = classes;
-_num_of_classes_diff = diff;
+// New virtual memory allocation site in recent baseline
-}
+void new_virtual_memory_site (const VirtualMemoryAllocationSite* callsite) const;
+// The virtual memory allocation site is not in recent baseline
-void diff_num_of_threads(size_t threads, int diff) {
+void old_virtual_memory_site (const VirtualMemoryAllocationSite* callsite) const;
-_num_of_threads = threads;
+// Compare virtual memory allocation site, it is in both baseline
-_num_of_threads_diff = diff;
+void diff_virtual_memory_site(const VirtualMemoryAllocationSite* early,
-}
+const VirtualMemoryAllocationSite* current)  const;
-void diff_thread_info(size_t stack_reserved_amt, size_t stack_committed_amt,
+void diff_malloc_site(const NativeCallStack* stack, size_t current_size,
-int stack_reserved_diff, int stack_committed_diff) {
+size_t currrent_count, size_t early_size, size_t early_count) const;
-_thread_stack_reserved = stack_reserved_amt;
+void diff_virtual_memory_site(const NativeCallStack* stack, size_t current_reserved,
-_thread_stack_committed = stack_committed_amt;
+size_t current_committed, size_t early_reserved, size_t early_committed) const;
-_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();
-// virtual memory map
-void start_virtual_memory_map();
-void reserved_memory_region(MEMFLAGS type, address base, address end, size_t size, address pc);
-void committed_memory_region(address base, address end, size_t size, address pc);
-void done_virtual_memory_map();
-/*
-*  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 // INCLUDE_NMT
-#endif // SHARE_VM_SERVICES_MEM_REPORTER_HPP
+#endif

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

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

src/share/vm/services/memReporter.hpp