//===-- xray-graph.cpp: XRay Function Call Graph Renderer -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Generate a DOT file to represent the function call graph encountered in // the trace. // //===----------------------------------------------------------------------===// #include "xray-graph.h" #include "xray-registry.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/XRay/InstrumentationMap.h" #include "llvm/XRay/Trace.h" #include <cmath> usingnamespacellvm; usingnamespacellvm::xray; // Setup llvm-xray graph subcommand and its options. static cl::SubCommand GraphC("graph", "Generate function-call graph"); static cl::opt<std::string> GraphInput(cl::Positional, cl::desc("<xray log file>"), cl::Required, cl::sub(GraphC)); static cl::opt<bool> GraphKeepGoing("keep-going", cl::desc("Keep going on errors encountered"), cl::sub(GraphC), cl::init(false)); static cl::alias GraphKeepGoing2("k", cl::aliasopt(GraphKeepGoing), cl::desc("Alias for -keep-going")); static cl::opt<std::string> GraphOutput("output", cl::value_desc("Output file"), cl::init("-"), cl::desc("output file; use '-' for stdout"), cl::sub(GraphC)); static cl::alias GraphOutput2("o", cl::aliasopt(GraphOutput), cl::desc("Alias for -output")); static cl::opt<std::string> GraphInstrMap("instr_map", cl::desc("binary with the instrumrntation map, or " "a separate instrumentation map"), cl::value_desc("binary with xray_instr_map"), cl::sub(GraphC), cl::init("")); static cl::alias GraphInstrMap2("m", cl::aliasopt(GraphInstrMap), cl::desc("alias for -instr_map")); static cl::opt<bool> GraphDeduceSiblingCalls( "deduce-sibling-calls", cl::desc("Deduce sibling calls when unrolling function call stacks"), cl::sub(GraphC), cl::init(false)); static cl::alias GraphDeduceSiblingCalls2("d", cl::aliasopt(GraphDeduceSiblingCalls), cl::desc("Alias for -deduce-sibling-calls")); static cl::opt<GraphRenderer::StatType> GraphEdgeLabel("edge-label", cl::desc("Output graphs with edges labeled with this field"), cl::value_desc("field"), cl::sub(GraphC), cl::init(GraphRenderer::StatType::NONE), cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none", "Do not label Edges"), clEnumValN(GraphRenderer::StatType::COUNT, "count", "function call counts"), clEnumValN(GraphRenderer::StatType::MIN, "min", "minimum function durations"), clEnumValN(GraphRenderer::StatType::MED, "med", "median function durations"), clEnumValN(GraphRenderer::StatType::PCT90, "90p", "90th percentile durations"), clEnumValN(GraphRenderer::StatType::PCT99, "99p", "99th percentile durations"), clEnumValN(GraphRenderer::StatType::MAX, "max", "maximum function durations"), clEnumValN(GraphRenderer::StatType::SUM, "sum", "sum of call durations"))); static cl::alias GraphEdgeLabel2("e", cl::aliasopt(GraphEdgeLabel), cl::desc("Alias for -edge-label")); static cl::opt<GraphRenderer::StatType> GraphVertexLabel( "vertex-label", cl::desc("Output graphs with vertices labeled with this field"), cl::value_desc("field"), cl::sub(GraphC), cl::init(GraphRenderer::StatType::NONE), cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none", "Do not label Vertices"), clEnumValN(GraphRenderer::StatType::COUNT, "count", "function call counts"), clEnumValN(GraphRenderer::StatType::MIN, "min", "minimum function durations"), clEnumValN(GraphRenderer::StatType::MED, "med", "median function durations"), clEnumValN(GraphRenderer::StatType::PCT90, "90p", "90th percentile durations"), clEnumValN(GraphRenderer::StatType::PCT99, "99p", "99th percentile durations"), clEnumValN(GraphRenderer::StatType::MAX, "max", "maximum function durations"), clEnumValN(GraphRenderer::StatType::SUM, "sum", "sum of call durations"))); static cl::alias GraphVertexLabel2("v", cl::aliasopt(GraphVertexLabel), cl::desc("Alias for -edge-label")); static cl::opt<GraphRenderer::StatType> GraphEdgeColorType( "color-edges", cl::desc("Output graphs with edge colors determined by this field"), cl::value_desc("field"), cl::sub(GraphC), cl::init(GraphRenderer::StatType::NONE), cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none", "Do not color Edges"), clEnumValN(GraphRenderer::StatType::COUNT, "count", "function call counts"), clEnumValN(GraphRenderer::StatType::MIN, "min", "minimum function durations"), clEnumValN(GraphRenderer::StatType::MED, "med", "median function durations"), clEnumValN(GraphRenderer::StatType::PCT90, "90p", "90th percentile durations"), clEnumValN(GraphRenderer::StatType::PCT99, "99p", "99th percentile durations"), clEnumValN(GraphRenderer::StatType::MAX, "max", "maximum function durations"), clEnumValN(GraphRenderer::StatType::SUM, "sum", "sum of call durations"))); static cl::alias GraphEdgeColorType2("c", cl::aliasopt(GraphEdgeColorType), cl::desc("Alias for -color-edges")); static cl::opt<GraphRenderer::StatType> GraphVertexColorType( "color-vertices", cl::desc("Output graphs with vertex colors determined by this field"), cl::value_desc("field"), cl::sub(GraphC), cl::init(GraphRenderer::StatType::NONE), cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none", "Do not color vertices"), clEnumValN(GraphRenderer::StatType::COUNT, "count", "function call counts"), clEnumValN(GraphRenderer::StatType::MIN, "min", "minimum function durations"), clEnumValN(GraphRenderer::StatType::MED, "med", "median function durations"), clEnumValN(GraphRenderer::StatType::PCT90, "90p", "90th percentile durations"), clEnumValN(GraphRenderer::StatType::PCT99, "99p", "99th percentile durations"), clEnumValN(GraphRenderer::StatType::MAX, "max", "maximum function durations"), clEnumValN(GraphRenderer::StatType::SUM, "sum", "sum of call durations"))); static cl::alias GraphVertexColorType2("b", cl::aliasopt(GraphVertexColorType), cl::desc("Alias for -edge-label")); template <class T> T diff(T L, T R) { … } // Updates the statistics for a GraphRenderer::TimeStat static void updateStat(GraphRenderer::TimeStat &S, int64_t L) { … } // Labels in a DOT graph must be legal XML strings so it's necessary to escape // certain characters. static std::string escapeString(StringRef Label) { … } // Evaluates an XRay record and performs accounting on it. // // If the record is an ENTER record it pushes the FuncID and TSC onto a // structure representing the call stack for that function. // If the record is an EXIT record it checks computes computes the ammount of // time the function took to complete and then stores that information in an // edge of the graph. If there is no matching ENTER record the function tries // to recover by assuming that there were EXIT records which were missed, for // example caused by tail call elimination and if the option is enabled then // then tries to recover from this. // // This function will also error if the records are out of order, as the trace // is expected to be sorted. // // The graph generated has an immaginary root for functions called by no-one at // FuncId 0. // // FIXME: Refactor this and account subcommand to reduce code duplication. Error GraphRenderer::accountRecord(const XRayRecord &Record) { … } template <typename U> void GraphRenderer::getStats(U begin, U end, GraphRenderer::TimeStat &S) { … } void GraphRenderer::updateMaxStats(const GraphRenderer::TimeStat &S, GraphRenderer::TimeStat &M) { … } void GraphRenderer::calculateEdgeStatistics() { … } void GraphRenderer::calculateVertexStatistics() { … } // A Helper function for normalizeStatistics which normalises a single // TimeStat element. static void normalizeTimeStat(GraphRenderer::TimeStat &S, double CycleFrequency) { … } // Normalises the statistics in the graph for a given TSC frequency. void GraphRenderer::normalizeStatistics(double CycleFrequency) { … } // Returns a string containing the value of statistic field T std::string GraphRenderer::TimeStat::getString(GraphRenderer::StatType T) const { … } // Returns the quotient between the property T of this and another TimeStat as // a double double GraphRenderer::TimeStat::getDouble(StatType T) const { … } // Outputs a DOT format version of the Graph embedded in the GraphRenderer // object on OS. It does this in the expected way by itterating // through all edges then vertices and then outputting them and their // annotations. // // FIXME: output more information, better presented. void GraphRenderer::exportGraphAsDOT(raw_ostream &OS, StatType ET, StatType EC, StatType VT, StatType VC) { … } Expected<GraphRenderer> GraphRenderer::Factory::getGraphRenderer() { … } // Here we register and implement the llvm-xray graph subcommand. // The bulk of this code reads in the options, opens the required files, uses // those files to create a context for analysing the xray trace, then there is a // short loop which actually analyses the trace, generates the graph and then // outputs it as a DOT. // // FIXME: include additional filtering and annalysis passes to provide more // specific useful information. static CommandRegistration Unused(&GraphC, []() -> Error { … });
Codebase Browser
llvm