472 lines
19 KiB
C++
472 lines
19 KiB
C++
//===- xray-account.h - XRay Function Call Accounting ---------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements basic function call accounting from an XRay trace.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <numeric>
|
|
#include <system_error>
|
|
#include <utility>
|
|
|
|
#include "xray-account.h"
|
|
#include "xray-registry.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
#include "llvm/XRay/InstrumentationMap.h"
|
|
#include "llvm/XRay/Trace.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::xray;
|
|
|
|
static cl::SubCommand Account("account", "Function call accounting");
|
|
static cl::opt<std::string> AccountInput(cl::Positional,
|
|
cl::desc("<xray log file>"),
|
|
cl::Required, cl::sub(Account));
|
|
static cl::opt<bool>
|
|
AccountKeepGoing("keep-going", cl::desc("Keep going on errors encountered"),
|
|
cl::sub(Account), cl::init(false));
|
|
static cl::alias AccountKeepGoing2("k", cl::aliasopt(AccountKeepGoing),
|
|
cl::desc("Alias for -keep_going"),
|
|
cl::sub(Account));
|
|
static cl::opt<bool> AccountDeduceSiblingCalls(
|
|
"deduce-sibling-calls",
|
|
cl::desc("Deduce sibling calls when unrolling function call stacks"),
|
|
cl::sub(Account), cl::init(false));
|
|
static cl::alias
|
|
AccountDeduceSiblingCalls2("d", cl::aliasopt(AccountDeduceSiblingCalls),
|
|
cl::desc("Alias for -deduce_sibling_calls"),
|
|
cl::sub(Account));
|
|
static cl::opt<std::string>
|
|
AccountOutput("output", cl::value_desc("output file"), cl::init("-"),
|
|
cl::desc("output file; use '-' for stdout"),
|
|
cl::sub(Account));
|
|
static cl::alias AccountOutput2("o", cl::aliasopt(AccountOutput),
|
|
cl::desc("Alias for -output"),
|
|
cl::sub(Account));
|
|
enum class AccountOutputFormats { TEXT, CSV };
|
|
static cl::opt<AccountOutputFormats>
|
|
AccountOutputFormat("format", cl::desc("output format"),
|
|
cl::values(clEnumValN(AccountOutputFormats::TEXT,
|
|
"text", "report stats in text"),
|
|
clEnumValN(AccountOutputFormats::CSV, "csv",
|
|
"report stats in csv")),
|
|
cl::sub(Account));
|
|
static cl::alias AccountOutputFormat2("f", cl::desc("Alias of -format"),
|
|
cl::aliasopt(AccountOutputFormat),
|
|
cl::sub(Account));
|
|
|
|
enum class SortField {
|
|
FUNCID,
|
|
COUNT,
|
|
MIN,
|
|
MED,
|
|
PCT90,
|
|
PCT99,
|
|
MAX,
|
|
SUM,
|
|
FUNC,
|
|
};
|
|
|
|
static cl::opt<SortField> AccountSortOutput(
|
|
"sort", cl::desc("sort output by this field"), cl::value_desc("field"),
|
|
cl::sub(Account), cl::init(SortField::FUNCID),
|
|
cl::values(clEnumValN(SortField::FUNCID, "funcid", "function id"),
|
|
clEnumValN(SortField::COUNT, "count", "funciton call counts"),
|
|
clEnumValN(SortField::MIN, "min", "minimum function durations"),
|
|
clEnumValN(SortField::MED, "med", "median function durations"),
|
|
clEnumValN(SortField::PCT90, "90p", "90th percentile durations"),
|
|
clEnumValN(SortField::PCT99, "99p", "99th percentile durations"),
|
|
clEnumValN(SortField::MAX, "max", "maximum function durations"),
|
|
clEnumValN(SortField::SUM, "sum", "sum of call durations"),
|
|
clEnumValN(SortField::FUNC, "func", "function names")));
|
|
static cl::alias AccountSortOutput2("s", cl::aliasopt(AccountSortOutput),
|
|
cl::desc("Alias for -sort"),
|
|
cl::sub(Account));
|
|
|
|
enum class SortDirection {
|
|
ASCENDING,
|
|
DESCENDING,
|
|
};
|
|
static cl::opt<SortDirection> AccountSortOrder(
|
|
"sortorder", cl::desc("sort ordering"), cl::init(SortDirection::ASCENDING),
|
|
cl::values(clEnumValN(SortDirection::ASCENDING, "asc", "ascending"),
|
|
clEnumValN(SortDirection::DESCENDING, "dsc", "descending")),
|
|
cl::sub(Account));
|
|
static cl::alias AccountSortOrder2("r", cl::aliasopt(AccountSortOrder),
|
|
cl::desc("Alias for -sortorder"),
|
|
cl::sub(Account));
|
|
|
|
static cl::opt<int> AccountTop("top", cl::desc("only show the top N results"),
|
|
cl::value_desc("N"), cl::sub(Account),
|
|
cl::init(-1));
|
|
static cl::alias AccountTop2("p", cl::desc("Alias for -top"),
|
|
cl::aliasopt(AccountTop), cl::sub(Account));
|
|
|
|
static cl::opt<std::string>
|
|
AccountInstrMap("instr_map",
|
|
cl::desc("binary with the instrumentation map, or "
|
|
"a separate instrumentation map"),
|
|
cl::value_desc("binary with xray_instr_map"),
|
|
cl::sub(Account), cl::init(""));
|
|
static cl::alias AccountInstrMap2("m", cl::aliasopt(AccountInstrMap),
|
|
cl::desc("Alias for -instr_map"),
|
|
cl::sub(Account));
|
|
|
|
namespace {
|
|
|
|
template <class T, class U> void setMinMax(std::pair<T, T> &MM, U &&V) {
|
|
if (MM.first == 0 || MM.second == 0)
|
|
MM = std::make_pair(std::forward<U>(V), std::forward<U>(V));
|
|
else
|
|
MM = std::make_pair(std::min(MM.first, V), std::max(MM.second, V));
|
|
}
|
|
|
|
template <class T> T diff(T L, T R) { return std::max(L, R) - std::min(L, R); }
|
|
|
|
} // namespace
|
|
|
|
bool LatencyAccountant::accountRecord(const XRayRecord &Record) {
|
|
setMinMax(PerThreadMinMaxTSC[Record.TId], Record.TSC);
|
|
setMinMax(PerCPUMinMaxTSC[Record.CPU], Record.TSC);
|
|
|
|
if (CurrentMaxTSC == 0)
|
|
CurrentMaxTSC = Record.TSC;
|
|
|
|
if (Record.TSC < CurrentMaxTSC)
|
|
return false;
|
|
|
|
auto &ThreadStack = PerThreadFunctionStack[Record.TId];
|
|
switch (Record.Type) {
|
|
case RecordTypes::ENTER: {
|
|
// Function Enter
|
|
ThreadStack.emplace_back(Record.FuncId, Record.TSC);
|
|
break;
|
|
}
|
|
case RecordTypes::EXIT: {
|
|
// Function Exit
|
|
if (ThreadStack.back().first == Record.FuncId) {
|
|
const auto &Top = ThreadStack.back();
|
|
recordLatency(Top.first, diff(Top.second, Record.TSC));
|
|
ThreadStack.pop_back();
|
|
break;
|
|
}
|
|
|
|
if (!DeduceSiblingCalls)
|
|
return false;
|
|
|
|
// Look for the parent up the stack.
|
|
auto Parent =
|
|
std::find_if(ThreadStack.rbegin(), ThreadStack.rend(),
|
|
[&](const std::pair<const int32_t, uint64_t> &E) {
|
|
return E.first == Record.FuncId;
|
|
});
|
|
if (Parent == ThreadStack.rend())
|
|
return false;
|
|
|
|
// Account time for this apparently sibling call exit up the stack.
|
|
// Considering the following case:
|
|
//
|
|
// f()
|
|
// g()
|
|
// h()
|
|
//
|
|
// We might only ever see the following entries:
|
|
//
|
|
// -> f()
|
|
// -> g()
|
|
// -> h()
|
|
// <- h()
|
|
// <- f()
|
|
//
|
|
// Now we don't see the exit to g() because some older version of the XRay
|
|
// runtime wasn't instrumenting tail exits. If we don't deduce tail calls,
|
|
// we may potentially never account time for g() -- and this code would have
|
|
// already bailed out, because `<- f()` doesn't match the current "top" of
|
|
// stack where we're waiting for the exit to `g()` instead. This is not
|
|
// ideal and brittle -- so instead we provide a potentially inaccurate
|
|
// accounting of g() instead, computing it from the exit of f().
|
|
//
|
|
// While it might be better that we account the time between `-> g()` and
|
|
// `-> h()` as the proper accounting of time for g() here, this introduces
|
|
// complexity to do correctly (need to backtrack, etc.).
|
|
//
|
|
// FIXME: Potentially implement the more complex deduction algorithm?
|
|
auto I = std::next(Parent).base();
|
|
for (auto &E : make_range(I, ThreadStack.end())) {
|
|
recordLatency(E.first, diff(E.second, Record.TSC));
|
|
}
|
|
ThreadStack.erase(I, ThreadStack.end());
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
namespace {
|
|
|
|
// We consolidate the data into a struct which we can output in various forms.
|
|
struct ResultRow {
|
|
uint64_t Count;
|
|
double Min;
|
|
double Median;
|
|
double Pct90;
|
|
double Pct99;
|
|
double Max;
|
|
double Sum;
|
|
std::string DebugInfo;
|
|
std::string Function;
|
|
};
|
|
|
|
ResultRow getStats(std::vector<uint64_t> &Timings) {
|
|
assert(!Timings.empty());
|
|
ResultRow R;
|
|
R.Sum = std::accumulate(Timings.begin(), Timings.end(), 0.0);
|
|
auto MinMax = std::minmax_element(Timings.begin(), Timings.end());
|
|
R.Min = *MinMax.first;
|
|
R.Max = *MinMax.second;
|
|
auto MedianOff = Timings.size() / 2;
|
|
std::nth_element(Timings.begin(), Timings.begin() + MedianOff, Timings.end());
|
|
R.Median = Timings[MedianOff];
|
|
auto Pct90Off = std::floor(Timings.size() * 0.9);
|
|
std::nth_element(Timings.begin(), Timings.begin() + Pct90Off, Timings.end());
|
|
R.Pct90 = Timings[Pct90Off];
|
|
auto Pct99Off = std::floor(Timings.size() * 0.99);
|
|
std::nth_element(Timings.begin(), Timings.begin() + Pct90Off, Timings.end());
|
|
R.Pct99 = Timings[Pct99Off];
|
|
R.Count = Timings.size();
|
|
return R;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
template <class F>
|
|
void LatencyAccountant::exportStats(const XRayFileHeader &Header, F Fn) const {
|
|
using TupleType = std::tuple<int32_t, uint64_t, ResultRow>;
|
|
std::vector<TupleType> Results;
|
|
Results.reserve(FunctionLatencies.size());
|
|
for (auto FT : FunctionLatencies) {
|
|
const auto &FuncId = FT.first;
|
|
auto &Timings = FT.second;
|
|
Results.emplace_back(FuncId, Timings.size(), getStats(Timings));
|
|
auto &Row = std::get<2>(Results.back());
|
|
if (Header.CycleFrequency) {
|
|
double CycleFrequency = Header.CycleFrequency;
|
|
Row.Min /= CycleFrequency;
|
|
Row.Median /= CycleFrequency;
|
|
Row.Pct90 /= CycleFrequency;
|
|
Row.Pct99 /= CycleFrequency;
|
|
Row.Max /= CycleFrequency;
|
|
Row.Sum /= CycleFrequency;
|
|
}
|
|
|
|
Row.Function = FuncIdHelper.SymbolOrNumber(FuncId);
|
|
Row.DebugInfo = FuncIdHelper.FileLineAndColumn(FuncId);
|
|
}
|
|
|
|
// Sort the data according to user-provided flags.
|
|
switch (AccountSortOutput) {
|
|
case SortField::FUNCID:
|
|
std::sort(Results.begin(), Results.end(),
|
|
[](const TupleType &L, const TupleType &R) {
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return std::get<0>(L) < std::get<0>(R);
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return std::get<0>(L) > std::get<0>(R);
|
|
llvm_unreachable("Unknown sort direction");
|
|
});
|
|
break;
|
|
case SortField::COUNT:
|
|
std::sort(Results.begin(), Results.end(),
|
|
[](const TupleType &L, const TupleType &R) {
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return std::get<1>(L) < std::get<1>(R);
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return std::get<1>(L) > std::get<1>(R);
|
|
llvm_unreachable("Unknown sort direction");
|
|
});
|
|
break;
|
|
default:
|
|
// Here we need to look into the ResultRow for the rest of the data that
|
|
// we want to sort by.
|
|
std::sort(Results.begin(), Results.end(),
|
|
[&](const TupleType &L, const TupleType &R) {
|
|
auto &LR = std::get<2>(L);
|
|
auto &RR = std::get<2>(R);
|
|
switch (AccountSortOutput) {
|
|
case SortField::COUNT:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Count < RR.Count;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Count > RR.Count;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::MIN:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Min < RR.Min;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Min > RR.Min;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::MED:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Median < RR.Median;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Median > RR.Median;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::PCT90:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Pct90 < RR.Pct90;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Pct90 > RR.Pct90;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::PCT99:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Pct99 < RR.Pct99;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Pct99 > RR.Pct99;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::MAX:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Max < RR.Max;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Max > RR.Max;
|
|
llvm_unreachable("Unknown sort direction");
|
|
case SortField::SUM:
|
|
if (AccountSortOrder == SortDirection::ASCENDING)
|
|
return LR.Sum < RR.Sum;
|
|
if (AccountSortOrder == SortDirection::DESCENDING)
|
|
return LR.Sum > RR.Sum;
|
|
llvm_unreachable("Unknown sort direction");
|
|
default:
|
|
llvm_unreachable("Unsupported sort order");
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
|
|
if (AccountTop > 0)
|
|
Results.erase(Results.begin() + AccountTop.getValue(), Results.end());
|
|
|
|
for (const auto &R : Results)
|
|
Fn(std::get<0>(R), std::get<1>(R), std::get<2>(R));
|
|
}
|
|
|
|
void LatencyAccountant::exportStatsAsText(raw_ostream &OS,
|
|
const XRayFileHeader &Header) const {
|
|
OS << "Functions with latencies: " << FunctionLatencies.size() << "\n";
|
|
|
|
// We spend some effort to make the text output more readable, so we do the
|
|
// following formatting decisions for each of the fields:
|
|
//
|
|
// - funcid: 32-bit, but we can determine the largest number and be
|
|
// between
|
|
// a minimum of 5 characters, up to 9 characters, right aligned.
|
|
// - count: 64-bit, but we can determine the largest number and be
|
|
// between
|
|
// a minimum of 5 characters, up to 9 characters, right aligned.
|
|
// - min, median, 90pct, 99pct, max: double precision, but we want to keep
|
|
// the values in seconds, with microsecond precision (0.000'001), so we
|
|
// have at most 6 significant digits, with the whole number part to be
|
|
// at
|
|
// least 1 character. For readability we'll right-align, with full 9
|
|
// characters each.
|
|
// - debug info, function name: we format this as a concatenation of the
|
|
// debug info and the function name.
|
|
//
|
|
static constexpr char StatsHeaderFormat[] =
|
|
"{0,+9} {1,+10} [{2,+9}, {3,+9}, {4,+9}, {5,+9}, {6,+9}] {7,+9}";
|
|
static constexpr char StatsFormat[] =
|
|
R"({0,+9} {1,+10} [{2,+9:f6}, {3,+9:f6}, {4,+9:f6}, {5,+9:f6}, {6,+9:f6}] {7,+9:f6})";
|
|
OS << llvm::formatv(StatsHeaderFormat, "funcid", "count", "min", "med", "90p",
|
|
"99p", "max", "sum")
|
|
<< llvm::formatv(" {0,-12}\n", "function");
|
|
exportStats(Header, [&](int32_t FuncId, size_t Count, const ResultRow &Row) {
|
|
OS << llvm::formatv(StatsFormat, FuncId, Count, Row.Min, Row.Median,
|
|
Row.Pct90, Row.Pct99, Row.Max, Row.Sum)
|
|
<< " " << Row.DebugInfo << ": " << Row.Function << "\n";
|
|
});
|
|
}
|
|
|
|
void LatencyAccountant::exportStatsAsCSV(raw_ostream &OS,
|
|
const XRayFileHeader &Header) const {
|
|
OS << "funcid,count,min,median,90%ile,99%ile,max,sum,debug,function\n";
|
|
exportStats(Header, [&](int32_t FuncId, size_t Count, const ResultRow &Row) {
|
|
OS << FuncId << ',' << Count << ',' << Row.Min << ',' << Row.Median << ','
|
|
<< Row.Pct90 << ',' << Row.Pct99 << ',' << Row.Max << "," << Row.Sum
|
|
<< ",\"" << Row.DebugInfo << "\",\"" << Row.Function << "\"\n";
|
|
});
|
|
}
|
|
|
|
using namespace llvm::xray;
|
|
|
|
static CommandRegistration Unused(&Account, []() -> Error {
|
|
InstrumentationMap Map;
|
|
if (!AccountInstrMap.empty()) {
|
|
auto InstrumentationMapOrError = loadInstrumentationMap(AccountInstrMap);
|
|
if (!InstrumentationMapOrError)
|
|
return joinErrors(make_error<StringError>(
|
|
Twine("Cannot open instrumentation map '") +
|
|
AccountInstrMap + "'",
|
|
std::make_error_code(std::errc::invalid_argument)),
|
|
InstrumentationMapOrError.takeError());
|
|
Map = std::move(*InstrumentationMapOrError);
|
|
}
|
|
|
|
std::error_code EC;
|
|
raw_fd_ostream OS(AccountOutput, EC, sys::fs::OpenFlags::F_Text);
|
|
if (EC)
|
|
return make_error<StringError>(
|
|
Twine("Cannot open file '") + AccountOutput + "' for writing.", EC);
|
|
|
|
const auto &FunctionAddresses = Map.getFunctionAddresses();
|
|
symbolize::LLVMSymbolizer::Options Opts(
|
|
symbolize::FunctionNameKind::LinkageName, true, true, false, "");
|
|
symbolize::LLVMSymbolizer Symbolizer(Opts);
|
|
llvm::xray::FuncIdConversionHelper FuncIdHelper(AccountInstrMap, Symbolizer,
|
|
FunctionAddresses);
|
|
xray::LatencyAccountant FCA(FuncIdHelper, AccountDeduceSiblingCalls);
|
|
auto TraceOrErr = loadTraceFile(AccountInput);
|
|
if (!TraceOrErr)
|
|
return joinErrors(
|
|
make_error<StringError>(
|
|
Twine("Failed loading input file '") + AccountInput + "'",
|
|
std::make_error_code(std::errc::executable_format_error)),
|
|
TraceOrErr.takeError());
|
|
|
|
auto &T = *TraceOrErr;
|
|
for (const auto &Record : T) {
|
|
if (FCA.accountRecord(Record))
|
|
continue;
|
|
for (const auto &ThreadStack : FCA.getPerThreadFunctionStack()) {
|
|
errs() << "Thread ID: " << ThreadStack.first << "\n";
|
|
auto Level = ThreadStack.second.size();
|
|
for (const auto &Entry : llvm::reverse(ThreadStack.second))
|
|
errs() << "#" << Level-- << "\t"
|
|
<< FuncIdHelper.SymbolOrNumber(Entry.first) << '\n';
|
|
}
|
|
if (!AccountKeepGoing)
|
|
return make_error<StringError>(
|
|
Twine("Failed accounting function calls in file '") + AccountInput +
|
|
"'.",
|
|
std::make_error_code(std::errc::executable_format_error));
|
|
}
|
|
switch (AccountOutputFormat) {
|
|
case AccountOutputFormats::TEXT:
|
|
FCA.exportStatsAsText(OS, T.getFileHeader());
|
|
break;
|
|
case AccountOutputFormats::CSV:
|
|
FCA.exportStatsAsCSV(OS, T.getFileHeader());
|
|
break;
|
|
}
|
|
|
|
return Error::success();
|
|
});
|