/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "tools/trace_to_text/trace_to_profile.h"
|
|
#include <cxxabi.h>
|
#include <inttypes.h>
|
|
#include <algorithm>
|
#include <map>
|
#include <set>
|
#include <vector>
|
|
#include "tools/trace_to_text/utils.h"
|
|
#include "perfetto/base/file_utils.h"
|
#include "perfetto/base/logging.h"
|
#include "perfetto/base/temp_file.h"
|
|
#include "perfetto/trace/profiling/profile_packet.pb.h"
|
#include "perfetto/trace/trace.pb.h"
|
#include "perfetto/trace/trace_packet.pb.h"
|
|
#include "third_party/pprof/profile.pb.h"
|
|
namespace perfetto {
|
namespace trace_to_text {
|
|
namespace {
|
|
constexpr const char* kDefaultTmp = "/tmp";
|
|
void MaybeDemangle(std::string* name) {
|
int ignored;
|
char* data = abi::__cxa_demangle(name->c_str(), nullptr, nullptr, &ignored);
|
if (data) {
|
*name = data;
|
free(data);
|
}
|
}
|
|
std::string GetTemp() {
|
const char* tmp = getenv("TMPDIR");
|
if (tmp == nullptr)
|
tmp = kDefaultTmp;
|
return tmp;
|
}
|
|
using ::perfetto::protos::ProfilePacket;
|
|
using GLine = ::perftools::profiles::Line;
|
using GMapping = ::perftools::profiles::Mapping;
|
using GLocation = ::perftools::profiles::Location;
|
using GProfile = ::perftools::profiles::Profile;
|
using GValueType = ::perftools::profiles::ValueType;
|
using GFunction = ::perftools::profiles::Function;
|
using GSample = ::perftools::profiles::Sample;
|
|
std::string ToHex(const std::string& build_id) {
|
std::string hex_build_id(2 * build_id.size() + 1, ' ');
|
for (size_t i = 0; i < build_id.size(); ++i)
|
snprintf(&(hex_build_id[2 * i]), 3, "%02hhx", build_id[i]);
|
// Remove the trailing nullbyte.
|
hex_build_id.resize(2 * build_id.size());
|
return hex_build_id;
|
}
|
|
enum Strings : int64_t {
|
kEmpty = 0,
|
kObjects,
|
kAllocObjects,
|
kCount,
|
kSpace,
|
kAllocSpace,
|
kBytes
|
};
|
|
void DumpProfilePacket(std::vector<ProfilePacket>& packet_fragments,
|
const std::string& file_prefix) {
|
std::map<uint64_t, std::string> string_lookup;
|
// A profile packet can be split into multiple fragments. We need to iterate
|
// over all of them to reconstruct the original packet.
|
for (const ProfilePacket& packet : packet_fragments) {
|
for (const ProfilePacket::InternedString& interned_string :
|
packet.strings())
|
string_lookup.emplace(interned_string.id(), interned_string.str());
|
}
|
|
std::map<uint64_t, const std::vector<uint64_t>> callstack_lookup;
|
for (const ProfilePacket& packet : packet_fragments) {
|
for (const ProfilePacket::Callstack& callstack : packet.callstacks()) {
|
std::vector<uint64_t> frame_ids(
|
static_cast<size_t>(callstack.frame_ids().size()));
|
std::reverse_copy(callstack.frame_ids().cbegin(),
|
callstack.frame_ids().cend(), frame_ids.begin());
|
callstack_lookup.emplace(callstack.id(), std::move(frame_ids));
|
}
|
}
|
|
std::map<std::string, uint64_t> string_table;
|
string_table[""] = kEmpty;
|
string_table["objects"] = kObjects;
|
string_table["alloc_objects"] = kAllocObjects;
|
string_table["count"] = kCount;
|
string_table["space"] = kSpace;
|
string_table["alloc_space"] = kAllocSpace;
|
string_table["bytes"] = kBytes;
|
|
GProfile profile;
|
GValueType* value_type = profile.add_sample_type();
|
value_type->set_type(kObjects);
|
value_type->set_unit(kCount);
|
|
value_type = profile.add_sample_type();
|
value_type->set_type(kAllocObjects);
|
value_type->set_unit(kCount);
|
|
value_type = profile.add_sample_type();
|
value_type->set_type(kAllocSpace);
|
value_type->set_unit(kBytes);
|
|
// The last value is the default one selected.
|
value_type = profile.add_sample_type();
|
value_type->set_type(kSpace);
|
value_type->set_unit(kBytes);
|
|
for (const ProfilePacket& packet : packet_fragments) {
|
for (const ProfilePacket::Mapping& mapping : packet.mappings()) {
|
GMapping* gmapping = profile.add_mapping();
|
gmapping->set_id(mapping.id());
|
gmapping->set_memory_start(mapping.start());
|
gmapping->set_memory_limit(mapping.end());
|
gmapping->set_file_offset(mapping.offset());
|
std::string filename;
|
for (uint64_t str_id : mapping.path_string_ids()) {
|
auto it = string_lookup.find(str_id);
|
if (it == string_lookup.end()) {
|
PERFETTO_ELOG("Mapping %" PRIu64
|
" referring to invalid string_id %" PRIu64 ".",
|
static_cast<uint64_t>(mapping.id()), str_id);
|
continue;
|
}
|
|
filename += "/" + it->second;
|
}
|
|
decltype(string_table)::iterator it;
|
std::tie(it, std::ignore) =
|
string_table.emplace(filename, string_table.size());
|
gmapping->set_filename(static_cast<int64_t>(it->second));
|
|
auto str_it = string_lookup.find(mapping.build_id());
|
if (str_it != string_lookup.end()) {
|
const std::string& build_id = str_it->second;
|
std::tie(it, std::ignore) =
|
string_table.emplace(ToHex(build_id), string_table.size());
|
gmapping->set_build_id(static_cast<int64_t>(it->second));
|
}
|
}
|
}
|
|
std::set<uint64_t> functions_to_dump;
|
for (const ProfilePacket& packet : packet_fragments) {
|
for (const ProfilePacket::Frame& frame : packet.frames()) {
|
GLocation* glocation = profile.add_location();
|
glocation->set_id(frame.id());
|
glocation->set_mapping_id(frame.mapping_id());
|
// TODO(fmayer): This is probably incorrect. Probably should be abs pc.
|
glocation->set_address(frame.rel_pc());
|
GLine* gline = glocation->add_line();
|
gline->set_function_id(frame.function_name_id());
|
functions_to_dump.emplace(frame.function_name_id());
|
}
|
}
|
|
for (uint64_t function_name_id : functions_to_dump) {
|
auto str_it = string_lookup.find(function_name_id);
|
if (str_it == string_lookup.end()) {
|
PERFETTO_ELOG("Function referring to invalid string id %" PRIu64,
|
function_name_id);
|
continue;
|
}
|
decltype(string_table)::iterator it;
|
std::string function_name = str_it->second;
|
// This assumes both the device that captured the trace and the host
|
// machine use the same mangling scheme. This is a reasonable
|
// assumption as the Itanium ABI is the de-facto standard for mangling.
|
MaybeDemangle(&function_name);
|
std::tie(it, std::ignore) =
|
string_table.emplace(std::move(function_name), string_table.size());
|
GFunction* gfunction = profile.add_function();
|
gfunction->set_id(function_name_id);
|
gfunction->set_name(static_cast<int64_t>(it->second));
|
}
|
|
// We keep the interning table as string -> uint64_t for fast and easy
|
// lookup. When dumping, we need to turn it into a uint64_t -> string
|
// table so we get it sorted by key order.
|
std::map<uint64_t, std::string> inverted_string_table;
|
for (const auto& p : string_table)
|
inverted_string_table[p.second] = p.first;
|
for (const auto& p : inverted_string_table)
|
profile.add_string_table(p.second);
|
|
std::map<uint64_t, std::vector<const ProfilePacket::ProcessHeapSamples*>>
|
heap_samples;
|
for (const ProfilePacket& packet : packet_fragments) {
|
for (const ProfilePacket::ProcessHeapSamples& samples :
|
packet.process_dumps()) {
|
heap_samples[samples.pid()].emplace_back(&samples);
|
}
|
}
|
for (const auto& p : heap_samples) {
|
GProfile cur_profile = profile;
|
uint64_t pid = p.first;
|
for (const ProfilePacket::ProcessHeapSamples* samples : p.second) {
|
if (samples->rejected_concurrent()) {
|
PERFETTO_ELOG("WARNING: The profile for %" PRIu64
|
" was rejected due to a concurrent profile.",
|
pid);
|
}
|
if (samples->buffer_overran()) {
|
PERFETTO_ELOG("WARNING: The profile for %" PRIu64
|
" ended early due to a buffer overrun.",
|
pid);
|
}
|
if (samples->buffer_corrupted()) {
|
PERFETTO_ELOG("WARNING: The profile for %" PRIu64
|
" ended early due to a buffer corruption."
|
" THIS IS ALWAYS A BUG IN HEAPPROFD OR"
|
" CLIENT MEMORY CORRUPTION.",
|
pid);
|
}
|
|
for (const ProfilePacket::HeapSample& sample : samples->samples()) {
|
GSample* gsample = cur_profile.add_sample();
|
auto it = callstack_lookup.find(sample.callstack_id());
|
if (it == callstack_lookup.end()) {
|
PERFETTO_ELOG("Callstack referring to invalid callstack id %" PRIu64,
|
static_cast<uint64_t>(sample.callstack_id()));
|
continue;
|
}
|
for (uint64_t frame_id : it->second)
|
gsample->add_location_id(frame_id);
|
gsample->add_value(
|
static_cast<int64_t>(sample.alloc_count() - sample.free_count()));
|
gsample->add_value(static_cast<int64_t>(sample.alloc_count()));
|
gsample->add_value(static_cast<int64_t>(sample.self_allocated()));
|
gsample->add_value(static_cast<int64_t>(sample.self_allocated() -
|
sample.self_freed()));
|
}
|
}
|
std::string filename = file_prefix + std::to_string(pid) + ".pb";
|
base::ScopedFile fd(base::OpenFile(filename, O_CREAT | O_WRONLY, 0700));
|
if (!fd)
|
PERFETTO_FATAL("Failed to open %s", filename.c_str());
|
std::string serialized = cur_profile.SerializeAsString();
|
PERFETTO_CHECK(base::WriteAll(*fd, serialized.c_str(), serialized.size()) ==
|
static_cast<ssize_t>(serialized.size()));
|
}
|
}
|
|
} // namespace
|
|
int TraceToProfile(std::istream* input, std::ostream* output) {
|
std::string temp_dir = GetTemp() + "/heap_profile-XXXXXXX";
|
size_t itr = 0;
|
PERFETTO_CHECK(mkdtemp(&temp_dir[0]));
|
std::vector<ProfilePacket> rolling_profile_packets;
|
ForEachPacketInTrace(input, [&temp_dir, &itr, &rolling_profile_packets](
|
const protos::TracePacket& packet) {
|
if (!packet.has_profile_packet())
|
return;
|
rolling_profile_packets.emplace_back(packet.profile_packet());
|
if (!packet.profile_packet().continued()) {
|
for (size_t i = 1; i < rolling_profile_packets.size(); ++i) {
|
// Ensure we are not missing a chunk.
|
PERFETTO_CHECK(rolling_profile_packets[i - 1].index() + 1 ==
|
rolling_profile_packets[i].index());
|
}
|
DumpProfilePacket(rolling_profile_packets,
|
temp_dir + "/heap_dump." + std::to_string(++itr) + ".");
|
rolling_profile_packets.clear();
|
}
|
});
|
|
if (!rolling_profile_packets.empty()) {
|
*output << "WARNING: Truncated heap dump. Not generating profile."
|
<< std::endl;
|
}
|
|
*output << "Wrote profiles to " << temp_dir << std::endl;
|
|
return 0;
|
}
|
|
} // namespace trace_to_text
|
} // namespace perfetto
|
