blob: d753a57ede7f1075014fa3cf88d3df4d7af00e3a [file]
/*
* Copyright (c) 2024, 2025, 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.
*
*/
#include "memory/allocation.hpp"
#include "nmt/memTracker.hpp"
#include "nmt/memoryFileTracker.hpp"
#include "nmt/nmtCommon.hpp"
#include "nmt/nmtNativeCallStackStorage.hpp"
#include "nmt/vmatree.hpp"
#include "utilities/growableArray.hpp"
#include "utilities/nativeCallStack.hpp"
#include "utilities/ostream.hpp"
Deferred<MemoryFileTracker> MemoryFileTracker::Instance::_tracker;
MemoryFileTracker::MemoryFileTracker(bool is_detailed_mode)
: _stack_storage(is_detailed_mode), _files() {}
void MemoryFileTracker::allocate_memory(MemoryFile* file, size_t offset,
size_t size, const NativeCallStack& stack,
MemTag mem_tag) {
NativeCallStackStorage::StackIndex sidx = _stack_storage.push(stack);
VMATree::RegionData regiondata(sidx, mem_tag);
VMATree::SummaryDiff diff = file->_tree.commit_mapping(offset, size, regiondata);
for (int i = 0; i < mt_number_of_tags; i++) {
VirtualMemory* summary = file->_summary.by_tag(NMTUtil::index_to_tag(i));
summary->reserve_memory(diff.tag[i].commit);
summary->commit_memory(diff.tag[i].commit);
}
}
void MemoryFileTracker::free_memory(MemoryFile* file, size_t offset, size_t size) {
VMATree::SummaryDiff diff = file->_tree.release_mapping(offset, size);
for (int i = 0; i < mt_number_of_tags; i++) {
VirtualMemory* summary = file->_summary.by_tag(NMTUtil::index_to_tag(i));
summary->reserve_memory(diff.tag[i].commit);
summary->commit_memory(diff.tag[i].commit);
}
}
void MemoryFileTracker::print_report_on(const MemoryFile* file, outputStream* stream, size_t scale) {
assert(MemTracker::tracking_level() == NMT_detail, "must");
stream->print_cr("Memory map of %s", file->_descriptive_name);
stream->cr();
VMATree::TreapNode* prev = nullptr;
#ifdef ASSERT
VMATree::TreapNode* broken_start = nullptr;
VMATree::TreapNode* broken_end = nullptr;
#endif
file->_tree.visit_in_order([&](VMATree::TreapNode* current) {
if (prev == nullptr) {
// Must be first node.
prev = current;
return;
}
#ifdef ASSERT
if (broken_start != nullptr && prev->val().out.mem_tag() != current->val().in.mem_tag()) {
broken_start = prev;
broken_end = current;
}
#endif
if (prev->val().out.type() == VMATree::StateType::Committed) {
const VMATree::position& start_addr = prev->key();
const VMATree::position& end_addr = current->key();
stream->print_cr("[" PTR_FORMAT " - " PTR_FORMAT "] allocated %zu%s" " for %s from",
start_addr, end_addr,
NMTUtil::amount_in_scale(end_addr - start_addr, scale),
NMTUtil::scale_name(scale),
NMTUtil::tag_to_name(prev->val().out.mem_tag()));
{
StreamIndentor si(stream, 4);
_stack_storage.get(prev->val().out.stack()).print_on(stream);
}
stream->cr();
}
prev = current;
});
#ifdef ASSERT
if (broken_start != nullptr) {
tty->print_cr("Broken tree found with first occurrence at nodes %zu, %zu",
broken_start->key(), broken_end->key());
tty->print_cr("Expected start out to have same type as end in, but was: %s, %s",
VMATree::statetype_to_string(broken_start->val().out.type()),
VMATree::statetype_to_string(broken_end->val().in.type()));
}
#endif
}
MemoryFileTracker::MemoryFile* MemoryFileTracker::make_file(const char* descriptive_name) {
MemoryFile* file_place = new MemoryFile{descriptive_name};
_files.push(file_place);
return file_place;
}
void MemoryFileTracker::free_file(MemoryFile* file) {
if (file == nullptr) return;
_files.remove(file);
delete file;
}
const GrowableArrayCHeap<MemoryFileTracker::MemoryFile*, mtNMT>& MemoryFileTracker::files() {
return _files;
}
bool MemoryFileTracker::Instance::initialize(NMT_TrackingLevel tracking_level) {
if (tracking_level == NMT_TrackingLevel::NMT_off) return true;
bool is_detailed_mode = tracking_level == NMT_TrackingLevel::NMT_detail;
_tracker.initialize(is_detailed_mode);
return true;
}
void MemoryFileTracker::Instance::allocate_memory(MemoryFile* file, size_t offset,
size_t size, const NativeCallStack& stack,
MemTag mem_tag) {
_tracker->allocate_memory(file, offset, size, stack, mem_tag);
}
void MemoryFileTracker::Instance::free_memory(MemoryFile* file, size_t offset, size_t size) {
_tracker->free_memory(file, offset, size);
}
MemoryFileTracker::MemoryFile*
MemoryFileTracker::Instance::make_file(const char* descriptive_name) {
return _tracker->make_file(descriptive_name);
}
void MemoryFileTracker::Instance::free_file(MemoryFileTracker::MemoryFile* file) {
return _tracker->free_file(file);
}
void MemoryFileTracker::Instance::print_report_on(const MemoryFile* file,
outputStream* stream, size_t scale) {
assert(file != nullptr, "must be");
assert(stream != nullptr, "must be");
_tracker->print_report_on(file, stream, scale);
}
void MemoryFileTracker::Instance::print_all_reports_on(outputStream* stream, size_t scale) {
const GrowableArrayCHeap<MemoryFileTracker::MemoryFile*, mtNMT>& files =
MemoryFileTracker::Instance::files();
stream->cr();
stream->print_cr("Memory file details");
stream->cr();
for (int i = 0; i < files.length(); i++) {
MemoryFileTracker::MemoryFile* file = files.at(i);
MemoryFileTracker::Instance::print_report_on(file, stream, scale);
}
}
const GrowableArrayCHeap<MemoryFileTracker::MemoryFile*, mtNMT>& MemoryFileTracker::Instance::files() {
return _tracker->files();
};
void MemoryFileTracker::summary_snapshot(VirtualMemorySnapshot* snapshot) const {
iterate_summary([&](MemTag tag, const VirtualMemory* current) {
VirtualMemory* snap = snapshot->by_tag(tag);
// Only account the committed memory.
snap->commit_memory(current->committed());
});
}
void MemoryFileTracker::Instance::summary_snapshot(VirtualMemorySnapshot* snapshot) {
_tracker->summary_snapshot(snapshot);
}