698fba94ef
Rename INCLUDE_ALTERNATE_GCS to INCLUDE_ALL_GCS and replace SERIALGC with INCLUDE_ALL_GCS. Reviewed-by: coleenp, stefank
287 lines
10 KiB
C++
287 lines
10 KiB
C++
/*
|
|
* 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"
|
|
#include "utilities/macros.hpp"
|
|
|
|
#if INCLUDE_NMT
|
|
|
|
/*
|
|
* 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;
|
|
|
|
virtual void start_virtual_memory_map() = 0;
|
|
virtual void reserved_memory_region(MEMFLAGS type, address base, address end, size_t size, address pc) = 0;
|
|
virtual void committed_memory_region(address base, address end, size_t size, address pc) = 0;
|
|
virtual void done_virtual_memory_map() = 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_virtual_memory_map(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();
|
|
|
|
// 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
|