2014-02-18 07:22:49 +08:00
|
|
|
//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2014-02-18 07:22:49 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// llvm-profdata merges .profdata files.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-11-19 01:10:24 +08:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2015-12-16 01:37:09 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2014-02-18 07:22:49 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2015-01-14 19:23:27 +08:00
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2014-03-22 01:24:48 +08:00
|
|
|
#include "llvm/ProfileData/InstrProfReader.h"
|
2014-03-22 01:46:22 +08:00
|
|
|
#include "llvm/ProfileData/InstrProfWriter.h"
|
2016-02-05 07:34:31 +08:00
|
|
|
#include "llvm/ProfileData/ProfileCommon.h"
|
2014-11-01 08:56:55 +08:00
|
|
|
#include "llvm/ProfileData/SampleProfReader.h"
|
|
|
|
#include "llvm/ProfileData/SampleProfWriter.h"
|
2014-02-18 07:22:49 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2015-12-16 01:37:09 +08:00
|
|
|
#include "llvm/Support/Errc.h"
|
2014-04-30 07:26:49 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2014-03-24 04:43:50 +08:00
|
|
|
#include "llvm/Support/Format.h"
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2018-04-14 02:26:06 +08:00
|
|
|
#include "llvm/Support/InitLLVM.h"
|
2014-02-18 07:22:49 +08:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2015-03-24 02:07:13 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2020-06-21 21:30:39 +08:00
|
|
|
#include "llvm/Support/ThreadPool.h"
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
#include "llvm/Support/Threading.h"
|
2019-02-21 15:42:31 +08:00
|
|
|
#include "llvm/Support/WithColor.h"
|
2014-02-18 07:22:49 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2015-12-16 01:37:09 +08:00
|
|
|
#include <algorithm>
|
2014-02-18 07:22:49 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2018-06-12 06:40:43 +08:00
|
|
|
enum ProfileFormat {
|
|
|
|
PF_None = 0,
|
|
|
|
PF_Text,
|
|
|
|
PF_Compact_Binary,
|
2019-08-24 03:05:30 +08:00
|
|
|
PF_Ext_Binary,
|
2018-06-12 06:40:43 +08:00
|
|
|
PF_GCC,
|
2018-06-12 13:53:49 +08:00
|
|
|
PF_Binary
|
2018-06-12 06:40:43 +08:00
|
|
|
};
|
2015-11-24 04:47:38 +08:00
|
|
|
|
2018-04-18 22:42:33 +08:00
|
|
|
static void warn(Twine Message, std::string Whence = "",
|
2017-11-18 05:18:32 +08:00
|
|
|
std::string Hint = "") {
|
2018-04-18 22:42:33 +08:00
|
|
|
WithColor::warning();
|
2014-03-22 01:24:48 +08:00
|
|
|
if (!Whence.empty())
|
|
|
|
errs() << Whence << ": ";
|
|
|
|
errs() << Message << "\n";
|
2015-11-13 11:47:58 +08:00
|
|
|
if (!Hint.empty())
|
2018-04-18 22:42:33 +08:00
|
|
|
WithColor::note() << Hint << "\n";
|
2017-11-18 05:18:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void exitWithError(Twine Message, std::string Whence = "",
|
|
|
|
std::string Hint = "") {
|
2018-04-18 22:42:33 +08:00
|
|
|
WithColor::error();
|
|
|
|
if (!Whence.empty())
|
|
|
|
errs() << Whence << ": ";
|
|
|
|
errs() << Message << "\n";
|
|
|
|
if (!Hint.empty())
|
|
|
|
WithColor::note() << Hint << "\n";
|
2014-03-13 06:00:57 +08:00
|
|
|
::exit(1);
|
2014-02-18 07:22:49 +08:00
|
|
|
}
|
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
static void exitWithError(Error E, StringRef Whence = "") {
|
|
|
|
if (E.isA<InstrProfError>()) {
|
|
|
|
handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
|
|
|
|
instrprof_error instrError = IPE.get();
|
|
|
|
StringRef Hint = "";
|
|
|
|
if (instrError == instrprof_error::unrecognized_format) {
|
2020-01-20 20:52:12 +08:00
|
|
|
// Hint for common error of forgetting --sample for sample profiles.
|
|
|
|
Hint = "Perhaps you forgot to use the --sample option?";
|
2016-05-19 11:54:45 +08:00
|
|
|
}
|
2020-01-29 03:23:46 +08:00
|
|
|
exitWithError(IPE.message(), std::string(Whence), std::string(Hint));
|
2016-05-19 11:54:45 +08:00
|
|
|
});
|
2015-11-13 11:47:58 +08:00
|
|
|
}
|
2016-05-19 11:54:45 +08:00
|
|
|
|
2020-01-29 03:23:46 +08:00
|
|
|
exitWithError(toString(std::move(E)), std::string(Whence));
|
2016-05-19 11:54:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
|
2020-01-29 03:23:46 +08:00
|
|
|
exitWithError(EC.message(), std::string(Whence));
|
2015-11-13 11:47:58 +08:00
|
|
|
}
|
|
|
|
|
2015-06-16 08:43:04 +08:00
|
|
|
namespace {
|
2015-12-15 04:37:15 +08:00
|
|
|
enum ProfileKinds { instr, sample };
|
2019-09-04 06:23:16 +08:00
|
|
|
enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
|
|
|
|
}
|
|
|
|
|
|
|
|
static void warnOrExitGivenError(FailureMode FailMode, std::error_code EC,
|
|
|
|
StringRef Whence = "") {
|
|
|
|
if (FailMode == failIfAnyAreInvalid)
|
|
|
|
exitWithErrorCode(EC, Whence);
|
|
|
|
else
|
2020-01-29 03:23:46 +08:00
|
|
|
warn(EC.message(), std::string(Whence));
|
2015-06-16 08:43:04 +08:00
|
|
|
}
|
2014-02-18 07:22:49 +08:00
|
|
|
|
2016-05-19 11:54:45 +08:00
|
|
|
static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
|
2015-11-18 06:08:53 +08:00
|
|
|
StringRef WhenceFunction = "",
|
2015-12-15 04:37:15 +08:00
|
|
|
bool ShowHint = true) {
|
2015-11-18 06:08:53 +08:00
|
|
|
if (!WhenceFile.empty())
|
|
|
|
errs() << WhenceFile << ": ";
|
|
|
|
if (!WhenceFunction.empty())
|
|
|
|
errs() << WhenceFunction << ": ";
|
2016-05-19 11:54:45 +08:00
|
|
|
|
|
|
|
auto IPE = instrprof_error::success;
|
|
|
|
E = handleErrors(std::move(E),
|
|
|
|
[&IPE](std::unique_ptr<InstrProfError> E) -> Error {
|
|
|
|
IPE = E->get();
|
|
|
|
return Error(std::move(E));
|
|
|
|
});
|
|
|
|
errs() << toString(std::move(E)) << "\n";
|
2015-11-18 06:08:53 +08:00
|
|
|
|
|
|
|
if (ShowHint) {
|
|
|
|
StringRef Hint = "";
|
2016-05-19 11:54:45 +08:00
|
|
|
if (IPE != instrprof_error::success) {
|
|
|
|
switch (IPE) {
|
2015-11-18 07:37:09 +08:00
|
|
|
case instrprof_error::hash_mismatch:
|
|
|
|
case instrprof_error::count_mismatch:
|
|
|
|
case instrprof_error::value_site_count_mismatch:
|
2015-12-15 04:37:15 +08:00
|
|
|
Hint = "Make sure that all profile data to be merged is generated "
|
2015-11-18 06:08:53 +08:00
|
|
|
"from the same binary.";
|
2015-11-18 07:37:09 +08:00
|
|
|
break;
|
2015-11-18 08:52:45 +08:00
|
|
|
default:
|
|
|
|
break;
|
2015-11-18 06:08:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Hint.empty())
|
|
|
|
errs() << Hint << "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-14 04:22:02 +08:00
|
|
|
namespace {
|
|
|
|
/// A remapper from original symbol names to new symbol names based on a file
|
|
|
|
/// containing a list of mappings from old name to new name.
|
|
|
|
class SymbolRemapper {
|
|
|
|
std::unique_ptr<MemoryBuffer> File;
|
|
|
|
DenseMap<StringRef, StringRef> RemappingTable;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/// Build a SymbolRemapper from a file containing a list of old/new symbols.
|
|
|
|
static std::unique_ptr<SymbolRemapper> create(StringRef InputFile) {
|
|
|
|
auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
|
|
|
|
if (!BufOrError)
|
|
|
|
exitWithErrorCode(BufOrError.getError(), InputFile);
|
|
|
|
|
2019-08-15 23:54:37 +08:00
|
|
|
auto Remapper = std::make_unique<SymbolRemapper>();
|
2018-09-14 04:22:02 +08:00
|
|
|
Remapper->File = std::move(BufOrError.get());
|
|
|
|
|
|
|
|
for (line_iterator LineIt(*Remapper->File, /*SkipBlanks=*/true, '#');
|
|
|
|
!LineIt.is_at_eof(); ++LineIt) {
|
|
|
|
std::pair<StringRef, StringRef> Parts = LineIt->split(' ');
|
|
|
|
if (Parts.first.empty() || Parts.second.empty() ||
|
|
|
|
Parts.second.count(' ')) {
|
|
|
|
exitWithError("unexpected line in remapping file",
|
|
|
|
(InputFile + ":" + Twine(LineIt.line_number())).str(),
|
|
|
|
"expected 'old_symbol new_symbol'");
|
|
|
|
}
|
|
|
|
Remapper->RemappingTable.insert(Parts);
|
|
|
|
}
|
|
|
|
return Remapper;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Attempt to map the given old symbol into a new symbol.
|
|
|
|
///
|
|
|
|
/// \return The new symbol, or \p Name if no such symbol was found.
|
|
|
|
StringRef operator()(StringRef Name) {
|
|
|
|
StringRef New = RemappingTable.lookup(Name);
|
|
|
|
return New.empty() ? Name : New;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-12-16 01:37:09 +08:00
|
|
|
struct WeightedFile {
|
2016-07-21 06:24:52 +08:00
|
|
|
std::string Filename;
|
2015-12-16 01:37:09 +08:00
|
|
|
uint64_t Weight;
|
|
|
|
};
|
|
|
|
typedef SmallVector<WeightedFile, 5> WeightedFileVector;
|
|
|
|
|
2016-07-19 09:17:20 +08:00
|
|
|
/// Keep track of merged data and reported errors.
|
|
|
|
struct WriterContext {
|
|
|
|
std::mutex Lock;
|
|
|
|
InstrProfWriter Writer;
|
2019-09-04 06:23:16 +08:00
|
|
|
std::vector<std::pair<Error, std::string>> Errors;
|
2016-07-19 09:17:20 +08:00
|
|
|
std::mutex &ErrLock;
|
|
|
|
SmallSet<instrprof_error, 4> &WriterErrorCodes;
|
|
|
|
|
|
|
|
WriterContext(bool IsSparse, std::mutex &ErrLock,
|
|
|
|
SmallSet<instrprof_error, 4> &WriterErrorCodes)
|
2019-09-04 06:23:16 +08:00
|
|
|
: Lock(), Writer(IsSparse), Errors(), ErrLock(ErrLock),
|
|
|
|
WriterErrorCodes(WriterErrorCodes) {}
|
2016-07-19 09:17:20 +08:00
|
|
|
};
|
|
|
|
|
2019-05-01 05:19:12 +08:00
|
|
|
/// Computer the overlap b/w profile BaseFilename and TestFileName,
|
|
|
|
/// and store the program level result to Overlap.
|
|
|
|
static void overlapInput(const std::string &BaseFilename,
|
|
|
|
const std::string &TestFilename, WriterContext *WC,
|
|
|
|
OverlapStats &Overlap,
|
|
|
|
const OverlapFuncFilters &FuncFilter,
|
|
|
|
raw_fd_ostream &OS, bool IsCS) {
|
|
|
|
auto ReaderOrErr = InstrProfReader::create(TestFilename);
|
|
|
|
if (Error E = ReaderOrErr.takeError()) {
|
|
|
|
// Skip the empty profiles by returning sliently.
|
|
|
|
instrprof_error IPE = InstrProfError::take(std::move(E));
|
|
|
|
if (IPE != instrprof_error::empty_raw_profile)
|
2019-09-04 06:23:16 +08:00
|
|
|
WC->Errors.emplace_back(make_error<InstrProfError>(IPE), TestFilename);
|
2019-05-01 05:19:12 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Reader = std::move(ReaderOrErr.get());
|
|
|
|
for (auto &I : *Reader) {
|
|
|
|
OverlapStats FuncOverlap(OverlapStats::FunctionLevel);
|
|
|
|
FuncOverlap.setFuncInfo(I.Name, I.Hash);
|
|
|
|
|
|
|
|
WC->Writer.overlapRecord(std::move(I), Overlap, FuncOverlap, FuncFilter);
|
|
|
|
FuncOverlap.dump(OS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-19 09:17:20 +08:00
|
|
|
/// Load an input into a writer context.
|
2018-09-14 04:22:02 +08:00
|
|
|
static void loadInput(const WeightedFile &Input, SymbolRemapper *Remapper,
|
|
|
|
WriterContext *WC) {
|
2016-07-19 09:17:20 +08:00
|
|
|
std::unique_lock<std::mutex> CtxGuard{WC->Lock};
|
|
|
|
|
2017-11-17 10:58:23 +08:00
|
|
|
// Copy the filename, because llvm::ThreadPool copied the input "const
|
|
|
|
// WeightedFile &" by value, making a reference to the filename within it
|
|
|
|
// invalid outside of this packaged task.
|
2019-09-04 06:23:16 +08:00
|
|
|
std::string Filename = Input.Filename;
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
auto ReaderOrErr = InstrProfReader::create(Input.Filename);
|
2016-10-20 06:51:17 +08:00
|
|
|
if (Error E = ReaderOrErr.takeError()) {
|
|
|
|
// Skip the empty profiles by returning sliently.
|
|
|
|
instrprof_error IPE = InstrProfError::take(std::move(E));
|
|
|
|
if (IPE != instrprof_error::empty_raw_profile)
|
2019-09-04 06:23:16 +08:00
|
|
|
WC->Errors.emplace_back(make_error<InstrProfError>(IPE), Filename);
|
2016-07-19 09:17:20 +08:00
|
|
|
return;
|
2016-10-20 06:51:17 +08:00
|
|
|
}
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
auto Reader = std::move(ReaderOrErr.get());
|
|
|
|
bool IsIRProfile = Reader->isIRLevelProfile();
|
2019-03-01 03:55:07 +08:00
|
|
|
bool HasCSIRProfile = Reader->hasCSIRLevelProfile();
|
|
|
|
if (WC->Writer.setIsIRLevelProfile(IsIRProfile, HasCSIRProfile)) {
|
2019-09-04 06:23:16 +08:00
|
|
|
WC->Errors.emplace_back(
|
|
|
|
make_error<StringError>(
|
|
|
|
"Merge IR generated profile with Clang generated profile.",
|
|
|
|
std::error_code()),
|
|
|
|
Filename);
|
2016-07-19 09:17:20 +08:00
|
|
|
return;
|
|
|
|
}
|
2020-07-23 05:58:42 +08:00
|
|
|
WC->Writer.setInstrEntryBBEnabled(Reader->instrEntryBBEnabled());
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
for (auto &I : *Reader) {
|
2018-09-14 04:22:02 +08:00
|
|
|
if (Remapper)
|
|
|
|
I.Name = (*Remapper)(I.Name);
|
2016-10-20 07:31:59 +08:00
|
|
|
const StringRef FuncName = I.Name;
|
2017-07-10 11:04:59 +08:00
|
|
|
bool Reported = false;
|
|
|
|
WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
|
|
|
|
if (Reported) {
|
|
|
|
consumeError(std::move(E));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Reported = true;
|
2016-07-19 09:17:20 +08:00
|
|
|
// Only show hint the first time an error occurs.
|
|
|
|
instrprof_error IPE = InstrProfError::take(std::move(E));
|
|
|
|
std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
|
|
|
|
bool firstTime = WC->WriterErrorCodes.insert(IPE).second;
|
|
|
|
handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
|
2016-10-20 07:31:59 +08:00
|
|
|
FuncName, firstTime);
|
2017-07-10 11:04:59 +08:00
|
|
|
});
|
2016-07-19 09:17:20 +08:00
|
|
|
}
|
2019-09-04 06:23:16 +08:00
|
|
|
if (Reader->hasError())
|
|
|
|
if (Error E = Reader->getError())
|
|
|
|
WC->Errors.emplace_back(std::move(E), Filename);
|
2016-07-19 09:17:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Merge the \p Src writer context into \p Dst.
|
|
|
|
static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
|
2019-09-04 06:23:16 +08:00
|
|
|
for (auto &ErrorPair : Src->Errors)
|
|
|
|
Dst->Errors.push_back(std::move(ErrorPair));
|
|
|
|
Src->Errors.clear();
|
2017-11-17 10:58:23 +08:00
|
|
|
|
2017-07-10 11:04:59 +08:00
|
|
|
Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) {
|
2019-09-04 06:23:16 +08:00
|
|
|
instrprof_error IPE = InstrProfError::take(std::move(E));
|
|
|
|
std::unique_lock<std::mutex> ErrGuard{Dst->ErrLock};
|
|
|
|
bool firstTime = Dst->WriterErrorCodes.insert(IPE).second;
|
|
|
|
if (firstTime)
|
|
|
|
warn(toString(make_error<InstrProfError>(IPE)));
|
2017-07-10 11:04:59 +08:00
|
|
|
});
|
2016-07-19 09:17:20 +08:00
|
|
|
}
|
|
|
|
|
2020-07-10 07:12:43 +08:00
|
|
|
static void writeInstrProfile(StringRef OutputFilename,
|
|
|
|
ProfileFormat OutputFormat,
|
|
|
|
InstrProfWriter &Writer) {
|
|
|
|
std::error_code EC;
|
|
|
|
raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::OF_None);
|
|
|
|
if (EC)
|
|
|
|
exitWithErrorCode(EC, OutputFilename);
|
|
|
|
|
|
|
|
if (OutputFormat == PF_Text) {
|
|
|
|
if (Error E = Writer.writeText(Output))
|
|
|
|
exitWithError(std::move(E));
|
|
|
|
} else {
|
|
|
|
Writer.write(Output);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-16 01:37:09 +08:00
|
|
|
static void mergeInstrProfile(const WeightedFileVector &Inputs,
|
2018-09-14 04:22:02 +08:00
|
|
|
SymbolRemapper *Remapper,
|
2015-11-24 04:47:38 +08:00
|
|
|
StringRef OutputFilename,
|
2016-07-19 09:17:20 +08:00
|
|
|
ProfileFormat OutputFormat, bool OutputSparse,
|
2019-09-04 06:23:16 +08:00
|
|
|
unsigned NumThreads, FailureMode FailMode) {
|
2014-04-19 05:48:40 +08:00
|
|
|
if (OutputFilename.compare("-") == 0)
|
|
|
|
exitWithError("Cannot write indexed profdata format to stdout.");
|
2014-02-18 07:22:49 +08:00
|
|
|
|
2018-06-12 13:53:49 +08:00
|
|
|
if (OutputFormat != PF_Binary && OutputFormat != PF_Compact_Binary &&
|
2019-08-24 03:05:30 +08:00
|
|
|
OutputFormat != PF_Ext_Binary && OutputFormat != PF_Text)
|
2015-11-24 04:47:38 +08:00
|
|
|
exitWithError("Unknown format is specified.");
|
|
|
|
|
2016-07-19 09:17:20 +08:00
|
|
|
std::mutex ErrorLock;
|
2016-05-19 11:54:45 +08:00
|
|
|
SmallSet<instrprof_error, 4> WriterErrorCodes;
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
// If NumThreads is not specified, auto-detect a good default.
|
|
|
|
if (NumThreads == 0)
|
[Support] On Windows, ensure hardware_concurrency() extends to all CPU sockets and all NUMA groups
The goal of this patch is to maximize CPU utilization on multi-socket or high core count systems, so that parallel computations such as LLD/ThinLTO can use all hardware threads in the system. Before this patch, on Windows, a maximum of 64 hardware threads could be used at most, in some cases dispatched only on one CPU socket.
== Background ==
Windows doesn't have a flat cpu_set_t like Linux. Instead, it projects hardware CPUs (or NUMA nodes) to applications through a concept of "processor groups". A "processor" is the smallest unit of execution on a CPU, that is, an hyper-thread if SMT is active; a core otherwise. There's a limit of 32-bit processors on older 32-bit versions of Windows, which later was raised to 64-processors with 64-bit versions of Windows. This limit comes from the affinity mask, which historically is represented by the sizeof(void*). Consequently, the concept of "processor groups" was introduced for dealing with systems with more than 64 hyper-threads.
By default, the Windows OS assigns only one "processor group" to each starting application, in a round-robin manner. If the application wants to use more processors, it needs to programmatically enable it, by assigning threads to other "processor groups". This also means that affinity cannot cross "processor group" boundaries; one can only specify a "preferred" group on start-up, but the application is free to allocate more groups if it wants to.
This creates a peculiar situation, where newer CPUs like the AMD EPYC 7702P (64-cores, 128-hyperthreads) are projected by the OS as two (2) "processor groups". This means that by default, an application can only use half of the cores. This situation could only get worse in the years to come, as dies with more cores will appear on the market.
== The problem ==
The heavyweight_hardware_concurrency() API was introduced so that only *one hardware thread per core* was used. Once that API returns, that original intention is lost, only the number of threads is retained. Consider a situation, on Windows, where the system has 2 CPU sockets, 18 cores each, each core having 2 hyper-threads, for a total of 72 hyper-threads. Both heavyweight_hardware_concurrency() and hardware_concurrency() currently return 36, because on Windows they are simply wrappers over std::thread::hardware_concurrency() -- which can only return processors from the current "processor group".
== The changes in this patch ==
To solve this situation, we capture (and retain) the initial intention until the point of usage, through a new ThreadPoolStrategy class. The number of threads to use is deferred as late as possible, until the moment where the std::threads are created (ThreadPool in the case of ThinLTO).
When using hardware_concurrency(), setting ThreadCount to 0 now means to use all the possible hardware CPU (SMT) threads. Providing a ThreadCount above to the maximum number of threads will have no effect, the maximum will be used instead.
The heavyweight_hardware_concurrency() is similar to hardware_concurrency(), except that only one thread per hardware *core* will be used.
When LLVM_ENABLE_THREADS is OFF, the threading APIs will always return 1, to ensure any caller loops will be exercised at least once.
Differential Revision: https://reviews.llvm.org/D71775
2020-02-14 11:49:57 +08:00
|
|
|
NumThreads = std::min(hardware_concurrency().compute_thread_count(),
|
|
|
|
unsigned((Inputs.size() + 1) / 2));
|
|
|
|
// FIXME: There's a bug here, where setting NumThreads = Inputs.size() fails
|
|
|
|
// the merge_empty_profile.test because the InstrProfWriter.ProfileKind isn't
|
|
|
|
// merged, thus the emitted file ends up with a PF_Unknown kind.
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
// Initialize the writer contexts.
|
|
|
|
SmallVector<std::unique_ptr<WriterContext>, 4> Contexts;
|
|
|
|
for (unsigned I = 0; I < NumThreads; ++I)
|
2019-08-15 23:54:37 +08:00
|
|
|
Contexts.emplace_back(std::make_unique<WriterContext>(
|
2016-07-19 09:17:20 +08:00
|
|
|
OutputSparse, ErrorLock, WriterErrorCodes));
|
|
|
|
|
|
|
|
if (NumThreads == 1) {
|
|
|
|
for (const auto &Input : Inputs)
|
2018-09-14 04:22:02 +08:00
|
|
|
loadInput(Input, Remapper, Contexts[0].get());
|
2016-07-19 09:17:20 +08:00
|
|
|
} else {
|
[Support] On Windows, ensure hardware_concurrency() extends to all CPU sockets and all NUMA groups
The goal of this patch is to maximize CPU utilization on multi-socket or high core count systems, so that parallel computations such as LLD/ThinLTO can use all hardware threads in the system. Before this patch, on Windows, a maximum of 64 hardware threads could be used at most, in some cases dispatched only on one CPU socket.
== Background ==
Windows doesn't have a flat cpu_set_t like Linux. Instead, it projects hardware CPUs (or NUMA nodes) to applications through a concept of "processor groups". A "processor" is the smallest unit of execution on a CPU, that is, an hyper-thread if SMT is active; a core otherwise. There's a limit of 32-bit processors on older 32-bit versions of Windows, which later was raised to 64-processors with 64-bit versions of Windows. This limit comes from the affinity mask, which historically is represented by the sizeof(void*). Consequently, the concept of "processor groups" was introduced for dealing with systems with more than 64 hyper-threads.
By default, the Windows OS assigns only one "processor group" to each starting application, in a round-robin manner. If the application wants to use more processors, it needs to programmatically enable it, by assigning threads to other "processor groups". This also means that affinity cannot cross "processor group" boundaries; one can only specify a "preferred" group on start-up, but the application is free to allocate more groups if it wants to.
This creates a peculiar situation, where newer CPUs like the AMD EPYC 7702P (64-cores, 128-hyperthreads) are projected by the OS as two (2) "processor groups". This means that by default, an application can only use half of the cores. This situation could only get worse in the years to come, as dies with more cores will appear on the market.
== The problem ==
The heavyweight_hardware_concurrency() API was introduced so that only *one hardware thread per core* was used. Once that API returns, that original intention is lost, only the number of threads is retained. Consider a situation, on Windows, where the system has 2 CPU sockets, 18 cores each, each core having 2 hyper-threads, for a total of 72 hyper-threads. Both heavyweight_hardware_concurrency() and hardware_concurrency() currently return 36, because on Windows they are simply wrappers over std::thread::hardware_concurrency() -- which can only return processors from the current "processor group".
== The changes in this patch ==
To solve this situation, we capture (and retain) the initial intention until the point of usage, through a new ThreadPoolStrategy class. The number of threads to use is deferred as late as possible, until the moment where the std::threads are created (ThreadPool in the case of ThinLTO).
When using hardware_concurrency(), setting ThreadCount to 0 now means to use all the possible hardware CPU (SMT) threads. Providing a ThreadCount above to the maximum number of threads will have no effect, the maximum will be used instead.
The heavyweight_hardware_concurrency() is similar to hardware_concurrency(), except that only one thread per hardware *core* will be used.
When LLVM_ENABLE_THREADS is OFF, the threading APIs will always return 1, to ensure any caller loops will be exercised at least once.
Differential Revision: https://reviews.llvm.org/D71775
2020-02-14 11:49:57 +08:00
|
|
|
ThreadPool Pool(hardware_concurrency(NumThreads));
|
2016-07-19 09:17:20 +08:00
|
|
|
|
|
|
|
// Load the inputs in parallel (N/NumThreads serial steps).
|
|
|
|
unsigned Ctx = 0;
|
|
|
|
for (const auto &Input : Inputs) {
|
2018-09-14 04:22:02 +08:00
|
|
|
Pool.async(loadInput, Input, Remapper, Contexts[Ctx].get());
|
2016-07-19 09:17:20 +08:00
|
|
|
Ctx = (Ctx + 1) % NumThreads;
|
2015-11-18 06:08:53 +08:00
|
|
|
}
|
2016-07-19 09:17:20 +08:00
|
|
|
Pool.wait();
|
|
|
|
|
|
|
|
// Merge the writer contexts together (~ lg(NumThreads) serial steps).
|
|
|
|
unsigned Mid = Contexts.size() / 2;
|
|
|
|
unsigned End = Contexts.size();
|
|
|
|
assert(Mid > 0 && "Expected more than one context");
|
|
|
|
do {
|
|
|
|
for (unsigned I = 0; I < Mid; ++I)
|
|
|
|
Pool.async(mergeWriterContexts, Contexts[I].get(),
|
|
|
|
Contexts[I + Mid].get());
|
|
|
|
Pool.wait();
|
|
|
|
if (End & 1) {
|
|
|
|
Pool.async(mergeWriterContexts, Contexts[0].get(),
|
|
|
|
Contexts[End - 1].get());
|
|
|
|
Pool.wait();
|
|
|
|
}
|
|
|
|
End = Mid;
|
|
|
|
Mid /= 2;
|
|
|
|
} while (Mid > 0);
|
2014-03-13 06:00:57 +08:00
|
|
|
}
|
2016-07-19 09:17:20 +08:00
|
|
|
|
2019-09-04 06:23:16 +08:00
|
|
|
// Handle deferred errors encountered during merging. If the number of errors
|
|
|
|
// is equal to the number of inputs the merge failed.
|
|
|
|
unsigned NumErrors = 0;
|
2017-11-18 05:18:32 +08:00
|
|
|
for (std::unique_ptr<WriterContext> &WC : Contexts) {
|
2019-09-04 06:23:16 +08:00
|
|
|
for (auto &ErrorPair : WC->Errors) {
|
|
|
|
++NumErrors;
|
|
|
|
warn(toString(std::move(ErrorPair.first)), ErrorPair.second);
|
|
|
|
}
|
2017-11-18 05:18:32 +08:00
|
|
|
}
|
2019-09-04 06:23:16 +08:00
|
|
|
if (NumErrors == Inputs.size() ||
|
|
|
|
(NumErrors > 0 && FailMode == failIfAnyAreInvalid))
|
|
|
|
exitWithError("No profiles could be merged.");
|
2017-11-18 05:18:32 +08:00
|
|
|
|
2020-07-10 07:12:43 +08:00
|
|
|
writeInstrProfile(OutputFilename, OutputFormat, Contexts[0]->Writer);
|
2014-02-18 07:22:49 +08:00
|
|
|
}
|
2014-03-19 10:20:46 +08:00
|
|
|
|
Supplement instr profile with sample profile.
PGO profile is usually more precise than sample profile. However, PGO profile
needs to be collected from loadtest and loadtest may not be representative
enough to the production workload. Sample profile collected from production
can be used as a supplement -- for functions cold in loadtest but warm/hot
in production, we can scale up the related function in PGO profile if the
function is warm or hot in sample profile.
The implementation contains changes in compiler side and llvm-profdata side.
Given an instr profile and a sample profile, for a function cold in PGO
profile but warm/hot in sample profile, llvm-profdata will either mark
all the counters in the profile to be -1 or scale up the max count in the
function to be above hot threshold, depending on the zero counter ratio in
the profile. The assumption is if there are too many counters being zero
in the function profile, the profile is more likely to cause harm than good,
then llvm-profdata will mark all the counters to be -1 indicating the
function is hot but the profile is unaccountable. In compiler side, if a
function profile with all -1 counters is seen, the function entry count will
be set to be above hot threshold but its internal profile will be dropped.
In the long run, it may be useful to let compiler support using PGO profile
and sample profile at the same time, but that requires more careful design
and more substantial changes to make two profiles work seamlessly. The patch
here serves as a simple intermediate solution.
Differential Revision: https://reviews.llvm.org/D81981
2020-07-09 06:19:44 +08:00
|
|
|
/// The profile entry for a function in instrumentation profile.
|
|
|
|
struct InstrProfileEntry {
|
|
|
|
uint64_t MaxCount = 0;
|
|
|
|
float ZeroCounterRatio = 0.0;
|
|
|
|
InstrProfRecord *ProfRecord;
|
|
|
|
InstrProfileEntry(InstrProfRecord *Record);
|
|
|
|
InstrProfileEntry() = default;
|
|
|
|
};
|
|
|
|
|
|
|
|
InstrProfileEntry::InstrProfileEntry(InstrProfRecord *Record) {
|
|
|
|
ProfRecord = Record;
|
|
|
|
uint64_t CntNum = Record->Counts.size();
|
|
|
|
uint64_t ZeroCntNum = 0;
|
|
|
|
for (size_t I = 0; I < CntNum; ++I) {
|
|
|
|
MaxCount = std::max(MaxCount, Record->Counts[I]);
|
|
|
|
ZeroCntNum += !Record->Counts[I];
|
|
|
|
}
|
|
|
|
ZeroCounterRatio = (float)ZeroCntNum / CntNum;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Either set all the counters in the instr profile entry \p IFE to -1
|
|
|
|
/// in order to drop the profile or scale up the counters in \p IFP to
|
|
|
|
/// be above hot threshold. We use the ratio of zero counters in the
|
|
|
|
/// profile of a function to decide the profile is helpful or harmful
|
|
|
|
/// for performance, and to choose whether to scale up or drop it.
|
|
|
|
static void updateInstrProfileEntry(InstrProfileEntry &IFE,
|
|
|
|
uint64_t HotInstrThreshold,
|
|
|
|
float ZeroCounterThreshold) {
|
|
|
|
InstrProfRecord *ProfRecord = IFE.ProfRecord;
|
|
|
|
if (!IFE.MaxCount || IFE.ZeroCounterRatio > ZeroCounterThreshold) {
|
|
|
|
// If all or most of the counters of the function are zero, the
|
|
|
|
// profile is unaccountable and shuld be dropped. Reset all the
|
|
|
|
// counters to be -1 and PGO profile-use will drop the profile.
|
|
|
|
// All counters being -1 also implies that the function is hot so
|
|
|
|
// PGO profile-use will also set the entry count metadata to be
|
|
|
|
// above hot threshold.
|
|
|
|
for (size_t I = 0; I < ProfRecord->Counts.size(); ++I)
|
|
|
|
ProfRecord->Counts[I] = -1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scale up the MaxCount to be multiple times above hot threshold.
|
|
|
|
const unsigned MultiplyFactor = 3;
|
|
|
|
uint64_t Numerator = HotInstrThreshold * MultiplyFactor;
|
|
|
|
uint64_t Denominator = IFE.MaxCount;
|
|
|
|
ProfRecord->scale(Numerator, Denominator, [&](instrprof_error E) {
|
|
|
|
warn(toString(make_error<InstrProfError>(E)));
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint64_t ColdPercentileIdx = 15;
|
|
|
|
const uint64_t HotPercentileIdx = 11;
|
|
|
|
|
|
|
|
/// Adjust the instr profile in \p WC based on the sample profile in
|
|
|
|
/// \p Reader.
|
|
|
|
static void
|
|
|
|
adjustInstrProfile(std::unique_ptr<WriterContext> &WC,
|
|
|
|
std::unique_ptr<sampleprof::SampleProfileReader> &Reader,
|
|
|
|
unsigned SupplMinSizeThreshold, float ZeroCounterThreshold,
|
|
|
|
unsigned InstrProfColdThreshold) {
|
|
|
|
// Function to its entry in instr profile.
|
|
|
|
StringMap<InstrProfileEntry> InstrProfileMap;
|
|
|
|
InstrProfSummaryBuilder IPBuilder(ProfileSummaryBuilder::DefaultCutoffs);
|
|
|
|
for (auto &PD : WC->Writer.getProfileData()) {
|
|
|
|
// Populate IPBuilder.
|
|
|
|
for (const auto &PDV : PD.getValue()) {
|
|
|
|
InstrProfRecord Record = PDV.second;
|
|
|
|
IPBuilder.addRecord(Record);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If a function has multiple entries in instr profile, skip it.
|
|
|
|
if (PD.getValue().size() != 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Initialize InstrProfileMap.
|
|
|
|
InstrProfRecord *R = &PD.getValue().begin()->second;
|
|
|
|
InstrProfileMap[PD.getKey()] = InstrProfileEntry(R);
|
|
|
|
}
|
|
|
|
|
|
|
|
ProfileSummary InstrPS = *IPBuilder.getSummary();
|
|
|
|
ProfileSummary SamplePS = Reader->getSummary();
|
|
|
|
|
|
|
|
// Compute cold thresholds for instr profile and sample profile.
|
|
|
|
uint64_t ColdSampleThreshold =
|
|
|
|
ProfileSummaryBuilder::getEntryForPercentile(
|
|
|
|
SamplePS.getDetailedSummary(),
|
|
|
|
ProfileSummaryBuilder::DefaultCutoffs[ColdPercentileIdx])
|
|
|
|
.MinCount;
|
|
|
|
uint64_t HotInstrThreshold =
|
|
|
|
ProfileSummaryBuilder::getEntryForPercentile(
|
|
|
|
InstrPS.getDetailedSummary(),
|
|
|
|
ProfileSummaryBuilder::DefaultCutoffs[HotPercentileIdx])
|
|
|
|
.MinCount;
|
|
|
|
uint64_t ColdInstrThreshold =
|
|
|
|
InstrProfColdThreshold
|
|
|
|
? InstrProfColdThreshold
|
|
|
|
: ProfileSummaryBuilder::getEntryForPercentile(
|
|
|
|
InstrPS.getDetailedSummary(),
|
|
|
|
ProfileSummaryBuilder::DefaultCutoffs[ColdPercentileIdx])
|
|
|
|
.MinCount;
|
|
|
|
|
|
|
|
// Find hot/warm functions in sample profile which is cold in instr profile
|
|
|
|
// and adjust the profiles of those functions in the instr profile.
|
|
|
|
for (const auto &PD : Reader->getProfiles()) {
|
|
|
|
StringRef FName = PD.getKey();
|
|
|
|
const sampleprof::FunctionSamples &FS = PD.getValue();
|
|
|
|
auto It = InstrProfileMap.find(FName);
|
|
|
|
if (FS.getHeadSamples() > ColdSampleThreshold &&
|
|
|
|
It != InstrProfileMap.end() &&
|
|
|
|
It->second.MaxCount <= ColdInstrThreshold &&
|
|
|
|
FS.getBodySamples().size() >= SupplMinSizeThreshold) {
|
|
|
|
updateInstrProfileEntry(It->second, HotInstrThreshold,
|
|
|
|
ZeroCounterThreshold);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// The main function to supplement instr profile with sample profile.
|
|
|
|
/// \Inputs contains the instr profile. \p SampleFilename specifies the
|
|
|
|
/// sample profile. \p OutputFilename specifies the output profile name.
|
|
|
|
/// \p OutputFormat specifies the output profile format. \p OutputSparse
|
|
|
|
/// specifies whether to generate sparse profile. \p SupplMinSizeThreshold
|
|
|
|
/// specifies the minimal size for the functions whose profile will be
|
|
|
|
/// adjusted. \p ZeroCounterThreshold is the threshold to check whether
|
|
|
|
/// a function contains too many zero counters and whether its profile
|
|
|
|
/// should be dropped. \p InstrProfColdThreshold is the user specified
|
|
|
|
/// cold threshold which will override the cold threshold got from the
|
|
|
|
/// instr profile summary.
|
|
|
|
static void supplementInstrProfile(
|
|
|
|
const WeightedFileVector &Inputs, StringRef SampleFilename,
|
|
|
|
StringRef OutputFilename, ProfileFormat OutputFormat, bool OutputSparse,
|
|
|
|
unsigned SupplMinSizeThreshold, float ZeroCounterThreshold,
|
|
|
|
unsigned InstrProfColdThreshold) {
|
|
|
|
if (OutputFilename.compare("-") == 0)
|
|
|
|
exitWithError("Cannot write indexed profdata format to stdout.");
|
|
|
|
if (Inputs.size() != 1)
|
|
|
|
exitWithError("Expect one input to be an instr profile.");
|
|
|
|
if (Inputs[0].Weight != 1)
|
|
|
|
exitWithError("Expect instr profile doesn't have weight.");
|
|
|
|
|
|
|
|
StringRef InstrFilename = Inputs[0].Filename;
|
|
|
|
|
|
|
|
// Read sample profile.
|
|
|
|
LLVMContext Context;
|
|
|
|
auto ReaderOrErr =
|
|
|
|
sampleprof::SampleProfileReader::create(SampleFilename.str(), Context);
|
|
|
|
if (std::error_code EC = ReaderOrErr.getError())
|
|
|
|
exitWithErrorCode(EC, SampleFilename);
|
|
|
|
auto Reader = std::move(ReaderOrErr.get());
|
|
|
|
if (std::error_code EC = Reader->read())
|
|
|
|
exitWithErrorCode(EC, SampleFilename);
|
|
|
|
|
|
|
|
// Read instr profile.
|
|
|
|
std::mutex ErrorLock;
|
|
|
|
SmallSet<instrprof_error, 4> WriterErrorCodes;
|
|
|
|
auto WC = std::make_unique<WriterContext>(OutputSparse, ErrorLock,
|
|
|
|
WriterErrorCodes);
|
|
|
|
loadInput(Inputs[0], nullptr, WC.get());
|
|
|
|
if (WC->Errors.size() > 0)
|
|
|
|
exitWithError(std::move(WC->Errors[0].first), InstrFilename);
|
|
|
|
|
|
|
|
adjustInstrProfile(WC, Reader, SupplMinSizeThreshold, ZeroCounterThreshold,
|
|
|
|
InstrProfColdThreshold);
|
|
|
|
writeInstrProfile(OutputFilename, OutputFormat, WC->Writer);
|
|
|
|
}
|
|
|
|
|
2018-09-14 04:22:02 +08:00
|
|
|
/// Make a copy of the given function samples with all symbol names remapped
|
|
|
|
/// by the provided symbol remapper.
|
|
|
|
static sampleprof::FunctionSamples
|
|
|
|
remapSamples(const sampleprof::FunctionSamples &Samples,
|
|
|
|
SymbolRemapper &Remapper, sampleprof_error &Error) {
|
|
|
|
sampleprof::FunctionSamples Result;
|
|
|
|
Result.setName(Remapper(Samples.getName()));
|
|
|
|
Result.addTotalSamples(Samples.getTotalSamples());
|
|
|
|
Result.addHeadSamples(Samples.getHeadSamples());
|
|
|
|
for (const auto &BodySample : Samples.getBodySamples()) {
|
|
|
|
Result.addBodySamples(BodySample.first.LineOffset,
|
|
|
|
BodySample.first.Discriminator,
|
|
|
|
BodySample.second.getSamples());
|
|
|
|
for (const auto &Target : BodySample.second.getCallTargets()) {
|
|
|
|
Result.addCalledTargetSamples(BodySample.first.LineOffset,
|
|
|
|
BodySample.first.Discriminator,
|
|
|
|
Remapper(Target.first()), Target.second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto &CallsiteSamples : Samples.getCallsiteSamples()) {
|
|
|
|
sampleprof::FunctionSamplesMap &Target =
|
|
|
|
Result.functionSamplesAt(CallsiteSamples.first);
|
|
|
|
for (const auto &Callsite : CallsiteSamples.second) {
|
|
|
|
sampleprof::FunctionSamples Remapped =
|
|
|
|
remapSamples(Callsite.second, Remapper, Error);
|
2020-01-29 03:23:46 +08:00
|
|
|
MergeResult(Error,
|
|
|
|
Target[std::string(Remapped.getName())].merge(Remapped));
|
2018-09-14 04:22:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2015-11-24 04:47:38 +08:00
|
|
|
static sampleprof::SampleProfileFormat FormatMap[] = {
|
2019-08-24 03:05:30 +08:00
|
|
|
sampleprof::SPF_None,
|
|
|
|
sampleprof::SPF_Text,
|
|
|
|
sampleprof::SPF_Compact_Binary,
|
|
|
|
sampleprof::SPF_Ext_Binary,
|
|
|
|
sampleprof::SPF_GCC,
|
|
|
|
sampleprof::SPF_Binary};
|
2015-11-24 04:47:38 +08:00
|
|
|
|
2019-08-31 10:27:26 +08:00
|
|
|
static std::unique_ptr<MemoryBuffer>
|
|
|
|
getInputFileBuf(const StringRef &InputFile) {
|
|
|
|
if (InputFile == "")
|
|
|
|
return {};
|
|
|
|
|
|
|
|
auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
|
|
|
|
if (!BufOrError)
|
|
|
|
exitWithErrorCode(BufOrError.getError(), InputFile);
|
|
|
|
|
|
|
|
return std::move(*BufOrError);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void populateProfileSymbolList(MemoryBuffer *Buffer,
|
|
|
|
sampleprof::ProfileSymbolList &PSL) {
|
|
|
|
if (!Buffer)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallVector<StringRef, 32> SymbolVec;
|
|
|
|
StringRef Data = Buffer->getBuffer();
|
|
|
|
Data.split(SymbolVec, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
|
|
|
|
|
|
|
|
for (StringRef symbol : SymbolVec)
|
|
|
|
PSL.add(symbol);
|
|
|
|
}
|
|
|
|
|
2019-10-08 00:12:37 +08:00
|
|
|
static void handleExtBinaryWriter(sampleprof::SampleProfileWriter &Writer,
|
|
|
|
ProfileFormat OutputFormat,
|
|
|
|
MemoryBuffer *Buffer,
|
|
|
|
sampleprof::ProfileSymbolList &WriterList,
|
2020-04-04 02:57:36 +08:00
|
|
|
bool CompressAllSections, bool UseMD5,
|
2020-05-13 05:48:22 +08:00
|
|
|
bool GenPartialProfile) {
|
2019-10-08 00:12:37 +08:00
|
|
|
populateProfileSymbolList(Buffer, WriterList);
|
|
|
|
if (WriterList.size() > 0 && OutputFormat != PF_Ext_Binary)
|
|
|
|
warn("Profile Symbol list is not empty but the output format is not "
|
|
|
|
"ExtBinary format. The list will be lost in the output. ");
|
|
|
|
|
|
|
|
Writer.setProfileSymbolList(&WriterList);
|
|
|
|
|
|
|
|
if (CompressAllSections) {
|
2020-03-04 05:19:32 +08:00
|
|
|
if (OutputFormat != PF_Ext_Binary)
|
2019-10-08 00:12:37 +08:00
|
|
|
warn("-compress-all-section is ignored. Specify -extbinary to enable it");
|
2020-03-04 05:19:32 +08:00
|
|
|
else
|
|
|
|
Writer.setToCompressAllSections();
|
|
|
|
}
|
|
|
|
if (UseMD5) {
|
|
|
|
if (OutputFormat != PF_Ext_Binary)
|
|
|
|
warn("-use-md5 is ignored. Specify -extbinary to enable it");
|
|
|
|
else
|
|
|
|
Writer.setUseMD5();
|
2019-10-08 00:12:37 +08:00
|
|
|
}
|
2020-05-13 05:48:22 +08:00
|
|
|
if (GenPartialProfile) {
|
2020-04-04 02:57:36 +08:00
|
|
|
if (OutputFormat != PF_Ext_Binary)
|
2020-05-13 05:48:22 +08:00
|
|
|
warn("-gen-partial-profile is ignored. Specify -extbinary to enable it");
|
2020-04-04 02:57:36 +08:00
|
|
|
else
|
|
|
|
Writer.setPartialProfile();
|
|
|
|
}
|
2019-10-08 00:12:37 +08:00
|
|
|
}
|
|
|
|
|
2020-03-04 05:19:32 +08:00
|
|
|
static void
|
|
|
|
mergeSampleProfile(const WeightedFileVector &Inputs, SymbolRemapper *Remapper,
|
|
|
|
StringRef OutputFilename, ProfileFormat OutputFormat,
|
|
|
|
StringRef ProfileSymbolListFile, bool CompressAllSections,
|
2020-05-13 05:48:22 +08:00
|
|
|
bool UseMD5, bool GenPartialProfile, FailureMode FailMode) {
|
2014-11-01 08:56:55 +08:00
|
|
|
using namespace sampleprof;
|
|
|
|
StringMap<FunctionSamples> ProfileMap;
|
2015-10-09 03:40:37 +08:00
|
|
|
SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
|
2016-04-15 05:59:01 +08:00
|
|
|
LLVMContext Context;
|
2019-08-31 10:27:26 +08:00
|
|
|
sampleprof::ProfileSymbolList WriterList;
|
2020-12-17 04:54:50 +08:00
|
|
|
Optional<bool> ProfileIsProbeBased;
|
2015-12-16 01:37:09 +08:00
|
|
|
for (const auto &Input : Inputs) {
|
2016-04-15 05:59:01 +08:00
|
|
|
auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context);
|
2019-09-04 06:23:16 +08:00
|
|
|
if (std::error_code EC = ReaderOrErr.getError()) {
|
|
|
|
warnOrExitGivenError(FailMode, EC, Input.Filename);
|
|
|
|
continue;
|
|
|
|
}
|
2014-11-01 08:56:55 +08:00
|
|
|
|
2015-10-09 03:40:37 +08:00
|
|
|
// We need to keep the readers around until after all the files are
|
|
|
|
// read so that we do not lose the function names stored in each
|
|
|
|
// reader's memory. The function names are needed to write out the
|
|
|
|
// merged profile map.
|
|
|
|
Readers.push_back(std::move(ReaderOrErr.get()));
|
|
|
|
const auto Reader = Readers.back().get();
|
2019-09-04 06:23:16 +08:00
|
|
|
if (std::error_code EC = Reader->read()) {
|
|
|
|
warnOrExitGivenError(FailMode, EC, Input.Filename);
|
|
|
|
Readers.pop_back();
|
|
|
|
continue;
|
|
|
|
}
|
2014-11-01 08:56:55 +08:00
|
|
|
|
|
|
|
StringMap<FunctionSamples> &Profiles = Reader->getProfiles();
|
2020-12-17 04:54:50 +08:00
|
|
|
if (ProfileIsProbeBased &&
|
|
|
|
ProfileIsProbeBased != FunctionSamples::ProfileIsProbeBased)
|
|
|
|
exitWithError(
|
|
|
|
"cannot merge probe-based profile with non-probe-based profile");
|
|
|
|
ProfileIsProbeBased = FunctionSamples::ProfileIsProbeBased;
|
2014-11-01 08:56:55 +08:00
|
|
|
for (StringMap<FunctionSamples>::iterator I = Profiles.begin(),
|
|
|
|
E = Profiles.end();
|
|
|
|
I != E; ++I) {
|
2018-09-14 04:22:02 +08:00
|
|
|
sampleprof_error Result = sampleprof_error::success;
|
|
|
|
FunctionSamples Remapped =
|
|
|
|
Remapper ? remapSamples(I->second, *Remapper, Result)
|
|
|
|
: FunctionSamples();
|
|
|
|
FunctionSamples &Samples = Remapper ? Remapped : I->second;
|
|
|
|
StringRef FName = Samples.getName();
|
|
|
|
MergeResult(Result, ProfileMap[FName].merge(Samples, Input.Weight));
|
2015-12-17 05:45:43 +08:00
|
|
|
if (Result != sampleprof_error::success) {
|
|
|
|
std::error_code EC = make_error_code(Result);
|
2016-05-19 11:54:45 +08:00
|
|
|
handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName);
|
2015-12-17 05:45:43 +08:00
|
|
|
}
|
2014-11-01 08:56:55 +08:00
|
|
|
}
|
2019-08-31 10:27:26 +08:00
|
|
|
|
|
|
|
std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
|
|
|
|
Reader->getProfileSymbolList();
|
|
|
|
if (ReaderList)
|
|
|
|
WriterList.merge(*ReaderList);
|
2014-11-01 08:56:55 +08:00
|
|
|
}
|
2019-07-09 05:03:12 +08:00
|
|
|
auto WriterOrErr =
|
|
|
|
SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
|
|
|
|
if (std::error_code EC = WriterOrErr.getError())
|
|
|
|
exitWithErrorCode(EC, OutputFilename);
|
|
|
|
|
2019-10-08 00:12:37 +08:00
|
|
|
auto Writer = std::move(WriterOrErr.get());
|
2019-08-31 10:27:26 +08:00
|
|
|
// WriterList will have StringRef refering to string in Buffer.
|
|
|
|
// Make sure Buffer lives as long as WriterList.
|
|
|
|
auto Buffer = getInputFileBuf(ProfileSymbolListFile);
|
2019-10-08 00:12:37 +08:00
|
|
|
handleExtBinaryWriter(*Writer, OutputFormat, Buffer.get(), WriterList,
|
2020-05-13 05:48:22 +08:00
|
|
|
CompressAllSections, UseMD5, GenPartialProfile);
|
2014-11-01 08:56:55 +08:00
|
|
|
Writer->write(ProfileMap);
|
|
|
|
}
|
|
|
|
|
2015-12-16 01:37:09 +08:00
|
|
|
static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
|
2016-06-07 07:43:56 +08:00
|
|
|
StringRef WeightStr, FileName;
|
|
|
|
std::tie(WeightStr, FileName) = WeightedFilename.split(',');
|
2015-12-16 01:37:09 +08:00
|
|
|
|
|
|
|
uint64_t Weight;
|
|
|
|
if (WeightStr.getAsInteger(10, Weight) || Weight < 1)
|
|
|
|
exitWithError("Input weight must be a positive integer.");
|
|
|
|
|
2020-01-29 03:23:46 +08:00
|
|
|
return {std::string(FileName), Weight};
|
2015-12-16 01:37:09 +08:00
|
|
|
}
|
|
|
|
|
2016-07-21 06:24:52 +08:00
|
|
|
static void addWeightedInput(WeightedFileVector &WNI, const WeightedFile &WF) {
|
|
|
|
StringRef Filename = WF.Filename;
|
|
|
|
uint64_t Weight = WF.Weight;
|
2016-07-22 20:39:55 +08:00
|
|
|
|
|
|
|
// If it's STDIN just pass it on.
|
|
|
|
if (Filename == "-") {
|
2020-01-29 03:23:46 +08:00
|
|
|
WNI.push_back({std::string(Filename), Weight});
|
2016-07-22 20:39:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-07-21 06:24:52 +08:00
|
|
|
llvm::sys::fs::file_status Status;
|
|
|
|
llvm::sys::fs::status(Filename, Status);
|
|
|
|
if (!llvm::sys::fs::exists(Status))
|
|
|
|
exitWithErrorCode(make_error_code(errc::no_such_file_or_directory),
|
|
|
|
Filename);
|
|
|
|
// If it's a source file, collect it.
|
|
|
|
if (llvm::sys::fs::is_regular_file(Status)) {
|
2020-01-29 03:23:46 +08:00
|
|
|
WNI.push_back({std::string(Filename), Weight});
|
2016-07-21 06:24:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (llvm::sys::fs::is_directory(Status)) {
|
|
|
|
std::error_code EC;
|
|
|
|
for (llvm::sys::fs::recursive_directory_iterator F(Filename, EC), E;
|
|
|
|
F != E && !EC; F.increment(EC)) {
|
|
|
|
if (llvm::sys::fs::is_regular_file(F->path())) {
|
|
|
|
addWeightedInput(WNI, {F->path(), Weight});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (EC)
|
|
|
|
exitWithErrorCode(EC, Filename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-08 06:47:31 +08:00
|
|
|
static void parseInputFilenamesFile(MemoryBuffer *Buffer,
|
|
|
|
WeightedFileVector &WFV) {
|
|
|
|
if (!Buffer)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallVector<StringRef, 8> Entries;
|
|
|
|
StringRef Data = Buffer->getBuffer();
|
|
|
|
Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
|
|
|
|
for (const StringRef &FileWeightEntry : Entries) {
|
|
|
|
StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r");
|
|
|
|
// Skip comments.
|
|
|
|
if (SanitizedEntry.startswith("#"))
|
|
|
|
continue;
|
|
|
|
// If there's no comma, it's an unweighted profile.
|
|
|
|
else if (SanitizedEntry.find(',') == StringRef::npos)
|
2020-01-29 03:23:46 +08:00
|
|
|
addWeightedInput(WFV, {std::string(SanitizedEntry), 1});
|
2016-06-08 06:47:31 +08:00
|
|
|
else
|
2016-07-21 06:24:52 +08:00
|
|
|
addWeightedInput(WFV, parseWeightedFile(SanitizedEntry));
|
2016-06-08 06:47:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-16 01:37:09 +08:00
|
|
|
static int merge_main(int argc, const char *argv[]) {
|
|
|
|
cl::list<std::string> InputFilenames(cl::Positional,
|
|
|
|
cl::desc("<filename...>"));
|
|
|
|
cl::list<std::string> WeightedInputFilenames("weighted-input",
|
|
|
|
cl::desc("<weight>,<filename>"));
|
2016-06-08 06:47:31 +08:00
|
|
|
cl::opt<std::string> InputFilenamesFile(
|
|
|
|
"input-files", cl::init(""),
|
|
|
|
cl::desc("Path to file containing newline-separated "
|
|
|
|
"[<weight>,]<filename> entries"));
|
|
|
|
cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
|
|
|
|
cl::aliasopt(InputFilenamesFile));
|
|
|
|
cl::opt<bool> DumpInputFileList(
|
|
|
|
"dump-input-file-list", cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Dump the list of input files and their weights, then exit"));
|
2018-09-14 04:22:02 +08:00
|
|
|
cl::opt<std::string> RemappingFile("remapping-file", cl::value_desc("file"),
|
|
|
|
cl::desc("Symbol remapping file"));
|
|
|
|
cl::alias RemappingFileA("r", cl::desc("Alias for --remapping-file"),
|
|
|
|
cl::aliasopt(RemappingFile));
|
2014-03-22 01:29:44 +08:00
|
|
|
cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::init("-"), cl::Required,
|
2014-03-22 01:29:44 +08:00
|
|
|
cl::desc("Output file"));
|
|
|
|
cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
|
|
|
|
cl::aliasopt(OutputFilename));
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::opt<ProfileKinds> ProfileKind(
|
|
|
|
cl::desc("Profile kind:"), cl::init(instr),
|
|
|
|
cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
|
2016-10-09 03:41:06 +08:00
|
|
|
clEnumVal(sample, "Sample profile")));
|
2015-11-24 04:47:38 +08:00
|
|
|
cl::opt<ProfileFormat> OutputFormat(
|
2018-06-12 13:53:49 +08:00
|
|
|
cl::desc("Format of output profile"), cl::init(PF_Binary),
|
2019-08-24 03:05:30 +08:00
|
|
|
cl::values(
|
|
|
|
clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
|
|
|
|
clEnumValN(PF_Compact_Binary, "compbinary",
|
|
|
|
"Compact binary encoding"),
|
|
|
|
clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding"),
|
|
|
|
clEnumValN(PF_Text, "text", "Text encoding"),
|
|
|
|
clEnumValN(PF_GCC, "gcc",
|
|
|
|
"GCC encoding (only meaningful for -sample)")));
|
2019-09-04 06:23:16 +08:00
|
|
|
cl::opt<FailureMode> FailureMode(
|
|
|
|
"failure-mode", cl::init(failIfAnyAreInvalid), cl::desc("Failure mode:"),
|
|
|
|
cl::values(clEnumValN(failIfAnyAreInvalid, "any",
|
|
|
|
"Fail if any profile is invalid."),
|
|
|
|
clEnumValN(failIfAllAreInvalid, "all",
|
|
|
|
"Fail only if all profiles are invalid.")));
|
2016-01-30 06:54:45 +08:00
|
|
|
cl::opt<bool> OutputSparse("sparse", cl::init(false),
|
|
|
|
cl::desc("Generate a sparse profile (only meaningful for -instr)"));
|
2016-07-19 09:17:20 +08:00
|
|
|
cl::opt<unsigned> NumThreads(
|
|
|
|
"num-threads", cl::init(0),
|
|
|
|
cl::desc("Number of merge threads to use (default: autodetect)"));
|
|
|
|
cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
|
|
|
|
cl::aliasopt(NumThreads));
|
2019-08-31 10:27:26 +08:00
|
|
|
cl::opt<std::string> ProfileSymbolListFile(
|
|
|
|
"prof-sym-list", cl::init(""),
|
|
|
|
cl::desc("Path to file containing the list of function symbols "
|
|
|
|
"used to populate profile symbol list"));
|
2019-10-08 00:12:37 +08:00
|
|
|
cl::opt<bool> CompressAllSections(
|
|
|
|
"compress-all-sections", cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Compress all sections when writing the profile (only "
|
|
|
|
"meaningful for -extbinary)"));
|
2020-03-04 05:19:32 +08:00
|
|
|
cl::opt<bool> UseMD5(
|
|
|
|
"use-md5", cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Choose to use MD5 to represent string in name table (only "
|
|
|
|
"meaningful for -extbinary)"));
|
2020-05-13 05:48:22 +08:00
|
|
|
cl::opt<bool> GenPartialProfile(
|
|
|
|
"gen-partial-profile", cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Generate a partial profile (only meaningful for -extbinary)"));
|
Supplement instr profile with sample profile.
PGO profile is usually more precise than sample profile. However, PGO profile
needs to be collected from loadtest and loadtest may not be representative
enough to the production workload. Sample profile collected from production
can be used as a supplement -- for functions cold in loadtest but warm/hot
in production, we can scale up the related function in PGO profile if the
function is warm or hot in sample profile.
The implementation contains changes in compiler side and llvm-profdata side.
Given an instr profile and a sample profile, for a function cold in PGO
profile but warm/hot in sample profile, llvm-profdata will either mark
all the counters in the profile to be -1 or scale up the max count in the
function to be above hot threshold, depending on the zero counter ratio in
the profile. The assumption is if there are too many counters being zero
in the function profile, the profile is more likely to cause harm than good,
then llvm-profdata will mark all the counters to be -1 indicating the
function is hot but the profile is unaccountable. In compiler side, if a
function profile with all -1 counters is seen, the function entry count will
be set to be above hot threshold but its internal profile will be dropped.
In the long run, it may be useful to let compiler support using PGO profile
and sample profile at the same time, but that requires more careful design
and more substantial changes to make two profiles work seamlessly. The patch
here serves as a simple intermediate solution.
Differential Revision: https://reviews.llvm.org/D81981
2020-07-09 06:19:44 +08:00
|
|
|
cl::opt<std::string> SupplInstrWithSample(
|
|
|
|
"supplement-instr-with-sample", cl::init(""), cl::Hidden,
|
|
|
|
cl::desc("Supplement an instr profile with sample profile, to correct "
|
|
|
|
"the profile unrepresentativeness issue. The sample "
|
|
|
|
"profile is the input of the flag. Output will be in instr "
|
|
|
|
"format (The flag only works with -instr)"));
|
|
|
|
cl::opt<float> ZeroCounterThreshold(
|
|
|
|
"zero-counter-threshold", cl::init(0.7), cl::Hidden,
|
|
|
|
cl::desc("For the function which is cold in instr profile but hot in "
|
|
|
|
"sample profile, if the ratio of the number of zero counters "
|
|
|
|
"divided by the the total number of counters is above the "
|
|
|
|
"threshold, the profile of the function will be regarded as "
|
|
|
|
"being harmful for performance and will be dropped. "));
|
|
|
|
cl::opt<unsigned> SupplMinSizeThreshold(
|
|
|
|
"suppl-min-size-threshold", cl::init(10), cl::Hidden,
|
|
|
|
cl::desc("If the size of a function is smaller than the threshold, "
|
|
|
|
"assume it can be inlined by PGO early inliner and it won't "
|
|
|
|
"be adjusted based on sample profile. "));
|
|
|
|
cl::opt<unsigned> InstrProfColdThreshold(
|
|
|
|
"instr-prof-cold-threshold", cl::init(0), cl::Hidden,
|
|
|
|
cl::desc("User specified cold threshold for instr profile which will "
|
|
|
|
"override the cold threshold got from profile summary. "));
|
2016-01-30 06:54:45 +08:00
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
|
|
|
|
|
2016-06-07 07:43:56 +08:00
|
|
|
WeightedFileVector WeightedInputs;
|
|
|
|
for (StringRef Filename : InputFilenames)
|
2020-01-29 03:23:46 +08:00
|
|
|
addWeightedInput(WeightedInputs, {std::string(Filename), 1});
|
2016-06-07 07:43:56 +08:00
|
|
|
for (StringRef WeightedFilename : WeightedInputFilenames)
|
2016-07-21 06:24:52 +08:00
|
|
|
addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename));
|
2016-06-08 06:47:31 +08:00
|
|
|
|
|
|
|
// Make sure that the file buffer stays alive for the duration of the
|
|
|
|
// weighted input vector's lifetime.
|
2019-08-31 10:27:26 +08:00
|
|
|
auto Buffer = getInputFileBuf(InputFilenamesFile);
|
2016-06-08 06:47:31 +08:00
|
|
|
parseInputFilenamesFile(Buffer.get(), WeightedInputs);
|
|
|
|
|
|
|
|
if (WeightedInputs.empty())
|
|
|
|
exitWithError("No input files specified. See " +
|
|
|
|
sys::path::filename(argv[0]) + " -help");
|
|
|
|
|
|
|
|
if (DumpInputFileList) {
|
|
|
|
for (auto &WF : WeightedInputs)
|
|
|
|
outs() << WF.Weight << "," << WF.Filename << "\n";
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-04 08:36:28 +08:00
|
|
|
|
2018-09-14 04:22:02 +08:00
|
|
|
std::unique_ptr<SymbolRemapper> Remapper;
|
|
|
|
if (!RemappingFile.empty())
|
|
|
|
Remapper = SymbolRemapper::create(RemappingFile);
|
|
|
|
|
Supplement instr profile with sample profile.
PGO profile is usually more precise than sample profile. However, PGO profile
needs to be collected from loadtest and loadtest may not be representative
enough to the production workload. Sample profile collected from production
can be used as a supplement -- for functions cold in loadtest but warm/hot
in production, we can scale up the related function in PGO profile if the
function is warm or hot in sample profile.
The implementation contains changes in compiler side and llvm-profdata side.
Given an instr profile and a sample profile, for a function cold in PGO
profile but warm/hot in sample profile, llvm-profdata will either mark
all the counters in the profile to be -1 or scale up the max count in the
function to be above hot threshold, depending on the zero counter ratio in
the profile. The assumption is if there are too many counters being zero
in the function profile, the profile is more likely to cause harm than good,
then llvm-profdata will mark all the counters to be -1 indicating the
function is hot but the profile is unaccountable. In compiler side, if a
function profile with all -1 counters is seen, the function entry count will
be set to be above hot threshold but its internal profile will be dropped.
In the long run, it may be useful to let compiler support using PGO profile
and sample profile at the same time, but that requires more careful design
and more substantial changes to make two profiles work seamlessly. The patch
here serves as a simple intermediate solution.
Differential Revision: https://reviews.llvm.org/D81981
2020-07-09 06:19:44 +08:00
|
|
|
if (!SupplInstrWithSample.empty()) {
|
|
|
|
if (ProfileKind != instr)
|
|
|
|
exitWithError(
|
|
|
|
"-supplement-instr-with-sample can only work with -instr. ");
|
|
|
|
|
|
|
|
supplementInstrProfile(WeightedInputs, SupplInstrWithSample, OutputFilename,
|
|
|
|
OutputFormat, OutputSparse, SupplMinSizeThreshold,
|
|
|
|
ZeroCounterThreshold, InstrProfColdThreshold);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
if (ProfileKind == instr)
|
2018-09-14 04:22:02 +08:00
|
|
|
mergeInstrProfile(WeightedInputs, Remapper.get(), OutputFilename,
|
2019-09-04 06:23:16 +08:00
|
|
|
OutputFormat, OutputSparse, NumThreads, FailureMode);
|
2014-11-01 08:56:55 +08:00
|
|
|
else
|
2018-09-14 04:22:02 +08:00
|
|
|
mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
|
2019-10-08 00:12:37 +08:00
|
|
|
OutputFormat, ProfileSymbolListFile, CompressAllSections,
|
2020-05-13 05:48:22 +08:00
|
|
|
UseMD5, GenPartialProfile, FailureMode);
|
2014-11-01 08:56:55 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-03-22 01:29:44 +08:00
|
|
|
|
2019-05-01 05:19:12 +08:00
|
|
|
/// Computer the overlap b/w profile BaseFilename and profile TestFilename.
|
|
|
|
static void overlapInstrProfile(const std::string &BaseFilename,
|
|
|
|
const std::string &TestFilename,
|
|
|
|
const OverlapFuncFilters &FuncFilter,
|
|
|
|
raw_fd_ostream &OS, bool IsCS) {
|
|
|
|
std::mutex ErrorLock;
|
|
|
|
SmallSet<instrprof_error, 4> WriterErrorCodes;
|
|
|
|
WriterContext Context(false, ErrorLock, WriterErrorCodes);
|
|
|
|
WeightedFile WeightedInput{BaseFilename, 1};
|
|
|
|
OverlapStats Overlap;
|
2019-10-02 02:06:50 +08:00
|
|
|
Error E = Overlap.accumulateCounts(BaseFilename, TestFilename, IsCS);
|
2019-05-01 05:19:12 +08:00
|
|
|
if (E)
|
|
|
|
exitWithError(std::move(E), "Error in getting profile count sums");
|
|
|
|
if (Overlap.Base.CountSum < 1.0f) {
|
|
|
|
OS << "Sum of edge counts for profile " << BaseFilename << " is 0.\n";
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
if (Overlap.Test.CountSum < 1.0f) {
|
|
|
|
OS << "Sum of edge counts for profile " << TestFilename << " is 0.\n";
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
loadInput(WeightedInput, nullptr, &Context);
|
|
|
|
overlapInput(BaseFilename, TestFilename, &Context, Overlap, FuncFilter, OS,
|
|
|
|
IsCS);
|
|
|
|
Overlap.dump(OS);
|
|
|
|
}
|
|
|
|
|
2020-08-09 08:49:33 +08:00
|
|
|
namespace {
|
|
|
|
struct SampleOverlapStats {
|
|
|
|
StringRef BaseName;
|
|
|
|
StringRef TestName;
|
|
|
|
// Number of overlap units
|
|
|
|
uint64_t OverlapCount;
|
|
|
|
// Total samples of overlap units
|
|
|
|
uint64_t OverlapSample;
|
|
|
|
// Number of and total samples of units that only present in base or test
|
|
|
|
// profile
|
|
|
|
uint64_t BaseUniqueCount;
|
|
|
|
uint64_t BaseUniqueSample;
|
|
|
|
uint64_t TestUniqueCount;
|
|
|
|
uint64_t TestUniqueSample;
|
|
|
|
// Number of units and total samples in base or test profile
|
|
|
|
uint64_t BaseCount;
|
|
|
|
uint64_t BaseSample;
|
|
|
|
uint64_t TestCount;
|
|
|
|
uint64_t TestSample;
|
|
|
|
// Number of and total samples of units that present in at least one profile
|
|
|
|
uint64_t UnionCount;
|
|
|
|
uint64_t UnionSample;
|
|
|
|
// Weighted similarity
|
|
|
|
double Similarity;
|
|
|
|
// For SampleOverlapStats instances representing functions, weights of the
|
|
|
|
// function in base and test profiles
|
|
|
|
double BaseWeight;
|
|
|
|
double TestWeight;
|
|
|
|
|
|
|
|
SampleOverlapStats()
|
|
|
|
: OverlapCount(0), OverlapSample(0), BaseUniqueCount(0),
|
|
|
|
BaseUniqueSample(0), TestUniqueCount(0), TestUniqueSample(0),
|
|
|
|
BaseCount(0), BaseSample(0), TestCount(0), TestSample(0), UnionCount(0),
|
|
|
|
UnionSample(0), Similarity(0.0), BaseWeight(0.0), TestWeight(0.0) {}
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct FuncSampleStats {
|
|
|
|
uint64_t SampleSum;
|
|
|
|
uint64_t MaxSample;
|
|
|
|
uint64_t HotBlockCount;
|
|
|
|
FuncSampleStats() : SampleSum(0), MaxSample(0), HotBlockCount(0) {}
|
|
|
|
FuncSampleStats(uint64_t SampleSum, uint64_t MaxSample,
|
|
|
|
uint64_t HotBlockCount)
|
|
|
|
: SampleSum(SampleSum), MaxSample(MaxSample),
|
|
|
|
HotBlockCount(HotBlockCount) {}
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
enum MatchStatus { MS_Match, MS_FirstUnique, MS_SecondUnique, MS_None };
|
|
|
|
|
|
|
|
// Class for updating merging steps for two sorted maps. The class should be
|
|
|
|
// instantiated with a map iterator type.
|
|
|
|
template <class T> class MatchStep {
|
|
|
|
public:
|
|
|
|
MatchStep() = delete;
|
|
|
|
|
|
|
|
MatchStep(T FirstIter, T FirstEnd, T SecondIter, T SecondEnd)
|
|
|
|
: FirstIter(FirstIter), FirstEnd(FirstEnd), SecondIter(SecondIter),
|
|
|
|
SecondEnd(SecondEnd), Status(MS_None) {}
|
|
|
|
|
|
|
|
bool areBothFinished() const {
|
|
|
|
return (FirstIter == FirstEnd && SecondIter == SecondEnd);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isFirstFinished() const { return FirstIter == FirstEnd; }
|
|
|
|
|
|
|
|
bool isSecondFinished() const { return SecondIter == SecondEnd; }
|
|
|
|
|
|
|
|
/// Advance one step based on the previous match status unless the previous
|
|
|
|
/// status is MS_None. Then update Status based on the comparison between two
|
|
|
|
/// container iterators at the current step. If the previous status is
|
|
|
|
/// MS_None, it means two iterators are at the beginning and no comparison has
|
|
|
|
/// been made, so we simply update Status without advancing the iterators.
|
|
|
|
void updateOneStep();
|
|
|
|
|
|
|
|
T getFirstIter() const { return FirstIter; }
|
|
|
|
|
|
|
|
T getSecondIter() const { return SecondIter; }
|
|
|
|
|
|
|
|
MatchStatus getMatchStatus() const { return Status; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Current iterator and end iterator of the first container.
|
|
|
|
T FirstIter;
|
|
|
|
T FirstEnd;
|
|
|
|
// Current iterator and end iterator of the second container.
|
|
|
|
T SecondIter;
|
|
|
|
T SecondEnd;
|
|
|
|
// Match status of the current step.
|
|
|
|
MatchStatus Status;
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
template <class T> void MatchStep<T>::updateOneStep() {
|
|
|
|
switch (Status) {
|
|
|
|
case MS_Match:
|
|
|
|
++FirstIter;
|
|
|
|
++SecondIter;
|
|
|
|
break;
|
|
|
|
case MS_FirstUnique:
|
|
|
|
++FirstIter;
|
|
|
|
break;
|
|
|
|
case MS_SecondUnique:
|
|
|
|
++SecondIter;
|
|
|
|
break;
|
|
|
|
case MS_None:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update Status according to iterators at the current step.
|
|
|
|
if (areBothFinished())
|
|
|
|
return;
|
|
|
|
if (FirstIter != FirstEnd &&
|
|
|
|
(SecondIter == SecondEnd || FirstIter->first < SecondIter->first))
|
|
|
|
Status = MS_FirstUnique;
|
|
|
|
else if (SecondIter != SecondEnd &&
|
|
|
|
(FirstIter == FirstEnd || SecondIter->first < FirstIter->first))
|
|
|
|
Status = MS_SecondUnique;
|
|
|
|
else
|
|
|
|
Status = MS_Match;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the sum of line/block samples, the max line/block sample, and the
|
|
|
|
// number of line/block samples above the given threshold in a function
|
|
|
|
// including its inlinees.
|
|
|
|
static void getFuncSampleStats(const sampleprof::FunctionSamples &Func,
|
|
|
|
FuncSampleStats &FuncStats,
|
|
|
|
uint64_t HotThreshold) {
|
|
|
|
for (const auto &L : Func.getBodySamples()) {
|
|
|
|
uint64_t Sample = L.second.getSamples();
|
|
|
|
FuncStats.SampleSum += Sample;
|
|
|
|
FuncStats.MaxSample = std::max(FuncStats.MaxSample, Sample);
|
|
|
|
if (Sample >= HotThreshold)
|
|
|
|
++FuncStats.HotBlockCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto &C : Func.getCallsiteSamples()) {
|
|
|
|
for (const auto &F : C.second)
|
|
|
|
getFuncSampleStats(F.second, FuncStats, HotThreshold);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Predicate that determines if a function is hot with a given threshold. We
|
|
|
|
/// keep it separate from its callsites for possible extension in the future.
|
|
|
|
static bool isFunctionHot(const FuncSampleStats &FuncStats,
|
|
|
|
uint64_t HotThreshold) {
|
|
|
|
// We intentionally compare the maximum sample count in a function with the
|
|
|
|
// HotThreshold to get an approximate determination on hot functions.
|
|
|
|
return (FuncStats.MaxSample >= HotThreshold);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
class SampleOverlapAggregator {
|
|
|
|
public:
|
|
|
|
SampleOverlapAggregator(const std::string &BaseFilename,
|
|
|
|
const std::string &TestFilename,
|
|
|
|
double LowSimilarityThreshold, double Epsilon,
|
|
|
|
const OverlapFuncFilters &FuncFilter)
|
|
|
|
: BaseFilename(BaseFilename), TestFilename(TestFilename),
|
|
|
|
LowSimilarityThreshold(LowSimilarityThreshold), Epsilon(Epsilon),
|
|
|
|
FuncFilter(FuncFilter) {}
|
|
|
|
|
|
|
|
/// Detect 0-sample input profile and report to output stream. This interface
|
|
|
|
/// should be called after loadProfiles().
|
|
|
|
bool detectZeroSampleProfile(raw_fd_ostream &OS) const;
|
|
|
|
|
|
|
|
/// Write out function-level similarity statistics for functions specified by
|
|
|
|
/// options --function, --value-cutoff, and --similarity-cutoff.
|
|
|
|
void dumpFuncSimilarity(raw_fd_ostream &OS) const;
|
|
|
|
|
|
|
|
/// Write out program-level similarity and overlap statistics.
|
|
|
|
void dumpProgramSummary(raw_fd_ostream &OS) const;
|
|
|
|
|
|
|
|
/// Write out hot-function and hot-block statistics for base_profile,
|
|
|
|
/// test_profile, and their overlap. For both cases, the overlap HO is
|
|
|
|
/// calculated as follows:
|
|
|
|
/// Given the number of functions (or blocks) that are hot in both profiles
|
|
|
|
/// HCommon and the number of functions (or blocks) that are hot in at
|
|
|
|
/// least one profile HUnion, HO = HCommon / HUnion.
|
|
|
|
void dumpHotFuncAndBlockOverlap(raw_fd_ostream &OS) const;
|
|
|
|
|
|
|
|
/// This function tries matching functions in base and test profiles. For each
|
|
|
|
/// pair of matched functions, it aggregates the function-level
|
|
|
|
/// similarity into a profile-level similarity. It also dump function-level
|
|
|
|
/// similarity information of functions specified by --function,
|
|
|
|
/// --value-cutoff, and --similarity-cutoff options. The program-level
|
|
|
|
/// similarity PS is computed as follows:
|
|
|
|
/// Given function-level similarity FS(A) for all function A, the
|
|
|
|
/// weight of function A in base profile WB(A), and the weight of function
|
|
|
|
/// A in test profile WT(A), compute PS(base_profile, test_profile) =
|
|
|
|
/// sum_A(FS(A) * avg(WB(A), WT(A))) ranging in [0.0f to 1.0f] with 0.0
|
|
|
|
/// meaning no-overlap.
|
|
|
|
void computeSampleProfileOverlap(raw_fd_ostream &OS);
|
|
|
|
|
|
|
|
/// Initialize ProfOverlap with the sum of samples in base and test
|
|
|
|
/// profiles. This function also computes and keeps the sum of samples and
|
|
|
|
/// max sample counts of each function in BaseStats and TestStats for later
|
|
|
|
/// use to avoid re-computations.
|
|
|
|
void initializeSampleProfileOverlap();
|
|
|
|
|
|
|
|
/// Load profiles specified by BaseFilename and TestFilename.
|
|
|
|
std::error_code loadProfiles();
|
|
|
|
|
|
|
|
private:
|
|
|
|
SampleOverlapStats ProfOverlap;
|
|
|
|
SampleOverlapStats HotFuncOverlap;
|
|
|
|
SampleOverlapStats HotBlockOverlap;
|
|
|
|
std::string BaseFilename;
|
|
|
|
std::string TestFilename;
|
|
|
|
std::unique_ptr<sampleprof::SampleProfileReader> BaseReader;
|
|
|
|
std::unique_ptr<sampleprof::SampleProfileReader> TestReader;
|
|
|
|
// BaseStats and TestStats hold FuncSampleStats for each function, with
|
|
|
|
// function name as the key.
|
|
|
|
StringMap<FuncSampleStats> BaseStats;
|
|
|
|
StringMap<FuncSampleStats> TestStats;
|
|
|
|
// Low similarity threshold in floating point number
|
|
|
|
double LowSimilarityThreshold;
|
|
|
|
// Block samples above BaseHotThreshold or TestHotThreshold are considered hot
|
|
|
|
// for tracking hot blocks.
|
|
|
|
uint64_t BaseHotThreshold;
|
|
|
|
uint64_t TestHotThreshold;
|
|
|
|
// A small threshold used to round the results of floating point accumulations
|
|
|
|
// to resolve imprecision.
|
|
|
|
const double Epsilon;
|
|
|
|
std::multimap<double, SampleOverlapStats, std::greater<double>>
|
|
|
|
FuncSimilarityDump;
|
|
|
|
// FuncFilter carries specifications in options --value-cutoff and
|
|
|
|
// --function.
|
|
|
|
OverlapFuncFilters FuncFilter;
|
|
|
|
// Column offsets for printing the function-level details table.
|
|
|
|
static const unsigned int TestWeightCol = 15;
|
|
|
|
static const unsigned int SimilarityCol = 30;
|
|
|
|
static const unsigned int OverlapCol = 43;
|
|
|
|
static const unsigned int BaseUniqueCol = 53;
|
|
|
|
static const unsigned int TestUniqueCol = 67;
|
|
|
|
static const unsigned int BaseSampleCol = 81;
|
|
|
|
static const unsigned int TestSampleCol = 96;
|
|
|
|
static const unsigned int FuncNameCol = 111;
|
|
|
|
|
|
|
|
/// Return a similarity of two line/block sample counters in the same
|
|
|
|
/// function in base and test profiles. The line/block-similarity BS(i) is
|
|
|
|
/// computed as follows:
|
|
|
|
/// For an offsets i, given the sample count at i in base profile BB(i),
|
|
|
|
/// the sample count at i in test profile BT(i), the sum of sample counts
|
|
|
|
/// in this function in base profile SB, and the sum of sample counts in
|
|
|
|
/// this function in test profile ST, compute BS(i) = 1.0 - fabs(BB(i)/SB -
|
|
|
|
/// BT(i)/ST), ranging in [0.0f to 1.0f] with 0.0 meaning no-overlap.
|
|
|
|
double computeBlockSimilarity(uint64_t BaseSample, uint64_t TestSample,
|
|
|
|
const SampleOverlapStats &FuncOverlap) const;
|
|
|
|
|
|
|
|
void updateHotBlockOverlap(uint64_t BaseSample, uint64_t TestSample,
|
|
|
|
uint64_t HotBlockCount);
|
|
|
|
|
|
|
|
void getHotFunctions(const StringMap<FuncSampleStats> &ProfStats,
|
|
|
|
StringMap<FuncSampleStats> &HotFunc,
|
|
|
|
uint64_t HotThreshold) const;
|
|
|
|
|
|
|
|
void computeHotFuncOverlap();
|
|
|
|
|
|
|
|
/// This function updates statistics in FuncOverlap, HotBlockOverlap, and
|
|
|
|
/// Difference for two sample units in a matched function according to the
|
|
|
|
/// given match status.
|
|
|
|
void updateOverlapStatsForFunction(uint64_t BaseSample, uint64_t TestSample,
|
|
|
|
uint64_t HotBlockCount,
|
|
|
|
SampleOverlapStats &FuncOverlap,
|
|
|
|
double &Difference, MatchStatus Status);
|
|
|
|
|
|
|
|
/// This function updates statistics in FuncOverlap, HotBlockOverlap, and
|
|
|
|
/// Difference for unmatched callees that only present in one profile in a
|
|
|
|
/// matched caller function.
|
|
|
|
void updateForUnmatchedCallee(const sampleprof::FunctionSamples &Func,
|
|
|
|
SampleOverlapStats &FuncOverlap,
|
|
|
|
double &Difference, MatchStatus Status);
|
|
|
|
|
|
|
|
/// This function updates sample overlap statistics of an overlap function in
|
|
|
|
/// base and test profile. It also calculates a function-internal similarity
|
|
|
|
/// FIS as follows:
|
|
|
|
/// For offsets i that have samples in at least one profile in this
|
|
|
|
/// function A, given BS(i) returned by computeBlockSimilarity(), compute
|
|
|
|
/// FIS(A) = (2.0 - sum_i(1.0 - BS(i))) / 2, ranging in [0.0f to 1.0f] with
|
|
|
|
/// 0.0 meaning no overlap.
|
|
|
|
double computeSampleFunctionInternalOverlap(
|
|
|
|
const sampleprof::FunctionSamples &BaseFunc,
|
|
|
|
const sampleprof::FunctionSamples &TestFunc,
|
|
|
|
SampleOverlapStats &FuncOverlap);
|
|
|
|
|
|
|
|
/// Function-level similarity (FS) is a weighted value over function internal
|
|
|
|
/// similarity (FIS). This function computes a function's FS from its FIS by
|
|
|
|
/// applying the weight.
|
|
|
|
double weightForFuncSimilarity(double FuncSimilarity, uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample) const;
|
|
|
|
|
|
|
|
/// The function-level similarity FS(A) for a function A is computed as
|
|
|
|
/// follows:
|
|
|
|
/// Compute a function-internal similarity FIS(A) by
|
|
|
|
/// computeSampleFunctionInternalOverlap(). Then, with the weight of
|
|
|
|
/// function A in base profile WB(A), and the weight of function A in test
|
|
|
|
/// profile WT(A), compute FS(A) = FIS(A) * (1.0 - fabs(WB(A) - WT(A)))
|
|
|
|
/// ranging in [0.0f to 1.0f] with 0.0 meaning no overlap.
|
|
|
|
double
|
|
|
|
computeSampleFunctionOverlap(const sampleprof::FunctionSamples *BaseFunc,
|
|
|
|
const sampleprof::FunctionSamples *TestFunc,
|
|
|
|
SampleOverlapStats *FuncOverlap,
|
|
|
|
uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample);
|
|
|
|
|
|
|
|
/// Profile-level similarity (PS) is a weighted aggregate over function-level
|
|
|
|
/// similarities (FS). This method weights the FS value by the function
|
|
|
|
/// weights in the base and test profiles for the aggregation.
|
|
|
|
double weightByImportance(double FuncSimilarity, uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample) const;
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
bool SampleOverlapAggregator::detectZeroSampleProfile(
|
|
|
|
raw_fd_ostream &OS) const {
|
|
|
|
bool HaveZeroSample = false;
|
|
|
|
if (ProfOverlap.BaseSample == 0) {
|
|
|
|
OS << "Sum of sample counts for profile " << BaseFilename << " is 0.\n";
|
|
|
|
HaveZeroSample = true;
|
|
|
|
}
|
|
|
|
if (ProfOverlap.TestSample == 0) {
|
|
|
|
OS << "Sum of sample counts for profile " << TestFilename << " is 0.\n";
|
|
|
|
HaveZeroSample = true;
|
|
|
|
}
|
|
|
|
return HaveZeroSample;
|
|
|
|
}
|
|
|
|
|
|
|
|
double SampleOverlapAggregator::computeBlockSimilarity(
|
|
|
|
uint64_t BaseSample, uint64_t TestSample,
|
|
|
|
const SampleOverlapStats &FuncOverlap) const {
|
|
|
|
double BaseFrac = 0.0;
|
|
|
|
double TestFrac = 0.0;
|
|
|
|
if (FuncOverlap.BaseSample > 0)
|
|
|
|
BaseFrac = static_cast<double>(BaseSample) / FuncOverlap.BaseSample;
|
|
|
|
if (FuncOverlap.TestSample > 0)
|
|
|
|
TestFrac = static_cast<double>(TestSample) / FuncOverlap.TestSample;
|
|
|
|
return 1.0 - std::fabs(BaseFrac - TestFrac);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::updateHotBlockOverlap(uint64_t BaseSample,
|
|
|
|
uint64_t TestSample,
|
|
|
|
uint64_t HotBlockCount) {
|
|
|
|
bool IsBaseHot = (BaseSample >= BaseHotThreshold);
|
|
|
|
bool IsTestHot = (TestSample >= TestHotThreshold);
|
|
|
|
if (!IsBaseHot && !IsTestHot)
|
|
|
|
return;
|
|
|
|
|
|
|
|
HotBlockOverlap.UnionCount += HotBlockCount;
|
|
|
|
if (IsBaseHot)
|
|
|
|
HotBlockOverlap.BaseCount += HotBlockCount;
|
|
|
|
if (IsTestHot)
|
|
|
|
HotBlockOverlap.TestCount += HotBlockCount;
|
|
|
|
if (IsBaseHot && IsTestHot)
|
|
|
|
HotBlockOverlap.OverlapCount += HotBlockCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::getHotFunctions(
|
|
|
|
const StringMap<FuncSampleStats> &ProfStats,
|
|
|
|
StringMap<FuncSampleStats> &HotFunc, uint64_t HotThreshold) const {
|
|
|
|
for (const auto &F : ProfStats) {
|
|
|
|
if (isFunctionHot(F.second, HotThreshold))
|
|
|
|
HotFunc.try_emplace(F.first(), F.second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::computeHotFuncOverlap() {
|
|
|
|
StringMap<FuncSampleStats> BaseHotFunc;
|
|
|
|
getHotFunctions(BaseStats, BaseHotFunc, BaseHotThreshold);
|
|
|
|
HotFuncOverlap.BaseCount = BaseHotFunc.size();
|
|
|
|
|
|
|
|
StringMap<FuncSampleStats> TestHotFunc;
|
|
|
|
getHotFunctions(TestStats, TestHotFunc, TestHotThreshold);
|
|
|
|
HotFuncOverlap.TestCount = TestHotFunc.size();
|
|
|
|
HotFuncOverlap.UnionCount = HotFuncOverlap.TestCount;
|
|
|
|
|
|
|
|
for (const auto &F : BaseHotFunc) {
|
|
|
|
if (TestHotFunc.count(F.first()))
|
|
|
|
++HotFuncOverlap.OverlapCount;
|
|
|
|
else
|
|
|
|
++HotFuncOverlap.UnionCount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::updateOverlapStatsForFunction(
|
|
|
|
uint64_t BaseSample, uint64_t TestSample, uint64_t HotBlockCount,
|
|
|
|
SampleOverlapStats &FuncOverlap, double &Difference, MatchStatus Status) {
|
|
|
|
assert(Status != MS_None &&
|
|
|
|
"Match status should be updated before updating overlap statistics");
|
|
|
|
if (Status == MS_FirstUnique) {
|
|
|
|
TestSample = 0;
|
|
|
|
FuncOverlap.BaseUniqueSample += BaseSample;
|
|
|
|
} else if (Status == MS_SecondUnique) {
|
|
|
|
BaseSample = 0;
|
|
|
|
FuncOverlap.TestUniqueSample += TestSample;
|
|
|
|
} else {
|
|
|
|
++FuncOverlap.OverlapCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
FuncOverlap.UnionSample += std::max(BaseSample, TestSample);
|
|
|
|
FuncOverlap.OverlapSample += std::min(BaseSample, TestSample);
|
|
|
|
Difference +=
|
|
|
|
1.0 - computeBlockSimilarity(BaseSample, TestSample, FuncOverlap);
|
|
|
|
updateHotBlockOverlap(BaseSample, TestSample, HotBlockCount);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::updateForUnmatchedCallee(
|
|
|
|
const sampleprof::FunctionSamples &Func, SampleOverlapStats &FuncOverlap,
|
|
|
|
double &Difference, MatchStatus Status) {
|
|
|
|
assert((Status == MS_FirstUnique || Status == MS_SecondUnique) &&
|
|
|
|
"Status must be either of the two unmatched cases");
|
|
|
|
FuncSampleStats FuncStats;
|
|
|
|
if (Status == MS_FirstUnique) {
|
|
|
|
getFuncSampleStats(Func, FuncStats, BaseHotThreshold);
|
|
|
|
updateOverlapStatsForFunction(FuncStats.SampleSum, 0,
|
|
|
|
FuncStats.HotBlockCount, FuncOverlap,
|
|
|
|
Difference, Status);
|
|
|
|
} else {
|
|
|
|
getFuncSampleStats(Func, FuncStats, TestHotThreshold);
|
|
|
|
updateOverlapStatsForFunction(0, FuncStats.SampleSum,
|
|
|
|
FuncStats.HotBlockCount, FuncOverlap,
|
|
|
|
Difference, Status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
double SampleOverlapAggregator::computeSampleFunctionInternalOverlap(
|
|
|
|
const sampleprof::FunctionSamples &BaseFunc,
|
|
|
|
const sampleprof::FunctionSamples &TestFunc,
|
|
|
|
SampleOverlapStats &FuncOverlap) {
|
|
|
|
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
double Difference = 0;
|
|
|
|
|
|
|
|
// Accumulate Difference for regular line/block samples in the function.
|
|
|
|
// We match them through sort-merge join algorithm because
|
|
|
|
// FunctionSamples::getBodySamples() returns a map of sample counters ordered
|
|
|
|
// by their offsets.
|
|
|
|
MatchStep<BodySampleMap::const_iterator> BlockIterStep(
|
|
|
|
BaseFunc.getBodySamples().cbegin(), BaseFunc.getBodySamples().cend(),
|
|
|
|
TestFunc.getBodySamples().cbegin(), TestFunc.getBodySamples().cend());
|
|
|
|
BlockIterStep.updateOneStep();
|
|
|
|
while (!BlockIterStep.areBothFinished()) {
|
|
|
|
uint64_t BaseSample =
|
|
|
|
BlockIterStep.isFirstFinished()
|
|
|
|
? 0
|
|
|
|
: BlockIterStep.getFirstIter()->second.getSamples();
|
|
|
|
uint64_t TestSample =
|
|
|
|
BlockIterStep.isSecondFinished()
|
|
|
|
? 0
|
|
|
|
: BlockIterStep.getSecondIter()->second.getSamples();
|
|
|
|
updateOverlapStatsForFunction(BaseSample, TestSample, 1, FuncOverlap,
|
|
|
|
Difference, BlockIterStep.getMatchStatus());
|
|
|
|
|
|
|
|
BlockIterStep.updateOneStep();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Accumulate Difference for callsite lines in the function. We match
|
|
|
|
// them through sort-merge algorithm because
|
|
|
|
// FunctionSamples::getCallsiteSamples() returns a map of callsite records
|
|
|
|
// ordered by their offsets.
|
|
|
|
MatchStep<CallsiteSampleMap::const_iterator> CallsiteIterStep(
|
|
|
|
BaseFunc.getCallsiteSamples().cbegin(),
|
|
|
|
BaseFunc.getCallsiteSamples().cend(),
|
|
|
|
TestFunc.getCallsiteSamples().cbegin(),
|
|
|
|
TestFunc.getCallsiteSamples().cend());
|
|
|
|
CallsiteIterStep.updateOneStep();
|
|
|
|
while (!CallsiteIterStep.areBothFinished()) {
|
|
|
|
MatchStatus CallsiteStepStatus = CallsiteIterStep.getMatchStatus();
|
|
|
|
assert(CallsiteStepStatus != MS_None &&
|
|
|
|
"Match status should be updated before entering loop body");
|
|
|
|
|
|
|
|
if (CallsiteStepStatus != MS_Match) {
|
|
|
|
auto Callsite = (CallsiteStepStatus == MS_FirstUnique)
|
|
|
|
? CallsiteIterStep.getFirstIter()
|
|
|
|
: CallsiteIterStep.getSecondIter();
|
|
|
|
for (const auto &F : Callsite->second)
|
|
|
|
updateForUnmatchedCallee(F.second, FuncOverlap, Difference,
|
|
|
|
CallsiteStepStatus);
|
|
|
|
} else {
|
|
|
|
// There may be multiple inlinees at the same offset, so we need to try
|
|
|
|
// matching all of them. This match is implemented through sort-merge
|
|
|
|
// algorithm because callsite records at the same offset are ordered by
|
|
|
|
// function names.
|
|
|
|
MatchStep<FunctionSamplesMap::const_iterator> CalleeIterStep(
|
|
|
|
CallsiteIterStep.getFirstIter()->second.cbegin(),
|
|
|
|
CallsiteIterStep.getFirstIter()->second.cend(),
|
|
|
|
CallsiteIterStep.getSecondIter()->second.cbegin(),
|
|
|
|
CallsiteIterStep.getSecondIter()->second.cend());
|
|
|
|
CalleeIterStep.updateOneStep();
|
|
|
|
while (!CalleeIterStep.areBothFinished()) {
|
|
|
|
MatchStatus CalleeStepStatus = CalleeIterStep.getMatchStatus();
|
|
|
|
if (CalleeStepStatus != MS_Match) {
|
|
|
|
auto Callee = (CalleeStepStatus == MS_FirstUnique)
|
|
|
|
? CalleeIterStep.getFirstIter()
|
|
|
|
: CalleeIterStep.getSecondIter();
|
|
|
|
updateForUnmatchedCallee(Callee->second, FuncOverlap, Difference,
|
|
|
|
CalleeStepStatus);
|
|
|
|
} else {
|
|
|
|
// An inlined function can contain other inlinees inside, so compute
|
|
|
|
// the Difference recursively.
|
|
|
|
Difference += 2.0 - 2 * computeSampleFunctionInternalOverlap(
|
|
|
|
CalleeIterStep.getFirstIter()->second,
|
|
|
|
CalleeIterStep.getSecondIter()->second,
|
|
|
|
FuncOverlap);
|
|
|
|
}
|
|
|
|
CalleeIterStep.updateOneStep();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CallsiteIterStep.updateOneStep();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Difference reflects the total differences of line/block samples in this
|
|
|
|
// function and ranges in [0.0f to 2.0f]. Take (2.0 - Difference) / 2 to
|
|
|
|
// reflect the similarity between function profiles in [0.0f to 1.0f].
|
|
|
|
return (2.0 - Difference) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
double SampleOverlapAggregator::weightForFuncSimilarity(
|
|
|
|
double FuncInternalSimilarity, uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample) const {
|
|
|
|
// Compute the weight as the distance between the function weights in two
|
|
|
|
// profiles.
|
|
|
|
double BaseFrac = 0.0;
|
|
|
|
double TestFrac = 0.0;
|
|
|
|
assert(ProfOverlap.BaseSample > 0 &&
|
|
|
|
"Total samples in base profile should be greater than 0");
|
|
|
|
BaseFrac = static_cast<double>(BaseFuncSample) / ProfOverlap.BaseSample;
|
|
|
|
assert(ProfOverlap.TestSample > 0 &&
|
|
|
|
"Total samples in test profile should be greater than 0");
|
|
|
|
TestFrac = static_cast<double>(TestFuncSample) / ProfOverlap.TestSample;
|
|
|
|
double WeightDistance = std::fabs(BaseFrac - TestFrac);
|
|
|
|
|
|
|
|
// Take WeightDistance into the similarity.
|
|
|
|
return FuncInternalSimilarity * (1 - WeightDistance);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
SampleOverlapAggregator::weightByImportance(double FuncSimilarity,
|
|
|
|
uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample) const {
|
|
|
|
|
|
|
|
double BaseFrac = 0.0;
|
|
|
|
double TestFrac = 0.0;
|
|
|
|
assert(ProfOverlap.BaseSample > 0 &&
|
|
|
|
"Total samples in base profile should be greater than 0");
|
|
|
|
BaseFrac = static_cast<double>(BaseFuncSample) / ProfOverlap.BaseSample / 2.0;
|
|
|
|
assert(ProfOverlap.TestSample > 0 &&
|
|
|
|
"Total samples in test profile should be greater than 0");
|
|
|
|
TestFrac = static_cast<double>(TestFuncSample) / ProfOverlap.TestSample / 2.0;
|
|
|
|
return FuncSimilarity * (BaseFrac + TestFrac);
|
|
|
|
}
|
|
|
|
|
|
|
|
double SampleOverlapAggregator::computeSampleFunctionOverlap(
|
|
|
|
const sampleprof::FunctionSamples *BaseFunc,
|
|
|
|
const sampleprof::FunctionSamples *TestFunc,
|
|
|
|
SampleOverlapStats *FuncOverlap, uint64_t BaseFuncSample,
|
|
|
|
uint64_t TestFuncSample) {
|
|
|
|
// Default function internal similarity before weighted, meaning two functions
|
|
|
|
// has no overlap.
|
|
|
|
const double DefaultFuncInternalSimilarity = 0;
|
|
|
|
double FuncSimilarity;
|
|
|
|
double FuncInternalSimilarity;
|
|
|
|
|
|
|
|
// If BaseFunc or TestFunc is nullptr, it means the functions do not overlap.
|
|
|
|
// In this case, we use DefaultFuncInternalSimilarity as the function internal
|
|
|
|
// similarity.
|
|
|
|
if (!BaseFunc || !TestFunc) {
|
|
|
|
FuncInternalSimilarity = DefaultFuncInternalSimilarity;
|
|
|
|
} else {
|
|
|
|
assert(FuncOverlap != nullptr &&
|
|
|
|
"FuncOverlap should be provided in this case");
|
|
|
|
FuncInternalSimilarity = computeSampleFunctionInternalOverlap(
|
|
|
|
*BaseFunc, *TestFunc, *FuncOverlap);
|
|
|
|
// Now, FuncInternalSimilarity may be a little less than 0 due to
|
|
|
|
// imprecision of floating point accumulations. Make it zero if the
|
|
|
|
// difference is below Epsilon.
|
|
|
|
FuncInternalSimilarity = (std::fabs(FuncInternalSimilarity - 0) < Epsilon)
|
|
|
|
? 0
|
|
|
|
: FuncInternalSimilarity;
|
|
|
|
}
|
|
|
|
FuncSimilarity = weightForFuncSimilarity(FuncInternalSimilarity,
|
|
|
|
BaseFuncSample, TestFuncSample);
|
|
|
|
return FuncSimilarity;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::computeSampleProfileOverlap(raw_fd_ostream &OS) {
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
StringMap<const FunctionSamples *> BaseFuncProf;
|
|
|
|
const auto &BaseProfiles = BaseReader->getProfiles();
|
|
|
|
for (const auto &BaseFunc : BaseProfiles) {
|
2020-09-21 07:50:08 +08:00
|
|
|
BaseFuncProf.try_emplace(BaseFunc.second.getName(), &(BaseFunc.second));
|
2020-08-09 08:49:33 +08:00
|
|
|
}
|
|
|
|
ProfOverlap.UnionCount = BaseFuncProf.size();
|
|
|
|
|
|
|
|
const auto &TestProfiles = TestReader->getProfiles();
|
|
|
|
for (const auto &TestFunc : TestProfiles) {
|
|
|
|
SampleOverlapStats FuncOverlap;
|
2020-09-21 07:50:08 +08:00
|
|
|
FuncOverlap.TestName = TestFunc.second.getName();
|
2020-08-09 08:49:33 +08:00
|
|
|
assert(TestStats.count(FuncOverlap.TestName) &&
|
|
|
|
"TestStats should have records for all functions in test profile "
|
|
|
|
"except inlinees");
|
|
|
|
FuncOverlap.TestSample = TestStats[FuncOverlap.TestName].SampleSum;
|
|
|
|
|
|
|
|
const auto Match = BaseFuncProf.find(FuncOverlap.TestName);
|
|
|
|
if (Match == BaseFuncProf.end()) {
|
|
|
|
const FuncSampleStats &FuncStats = TestStats[FuncOverlap.TestName];
|
|
|
|
++ProfOverlap.TestUniqueCount;
|
|
|
|
ProfOverlap.TestUniqueSample += FuncStats.SampleSum;
|
|
|
|
FuncOverlap.TestUniqueSample = FuncStats.SampleSum;
|
|
|
|
|
|
|
|
updateHotBlockOverlap(0, FuncStats.SampleSum, FuncStats.HotBlockCount);
|
|
|
|
|
|
|
|
double FuncSimilarity = computeSampleFunctionOverlap(
|
|
|
|
nullptr, nullptr, nullptr, 0, FuncStats.SampleSum);
|
|
|
|
ProfOverlap.Similarity +=
|
|
|
|
weightByImportance(FuncSimilarity, 0, FuncStats.SampleSum);
|
|
|
|
|
|
|
|
++ProfOverlap.UnionCount;
|
|
|
|
ProfOverlap.UnionSample += FuncStats.SampleSum;
|
|
|
|
} else {
|
|
|
|
++ProfOverlap.OverlapCount;
|
|
|
|
|
|
|
|
// Two functions match with each other. Compute function-level overlap and
|
|
|
|
// aggregate them into profile-level overlap.
|
2020-09-21 07:50:08 +08:00
|
|
|
FuncOverlap.BaseName = Match->second->getName();
|
2020-08-09 08:49:33 +08:00
|
|
|
assert(BaseStats.count(FuncOverlap.BaseName) &&
|
|
|
|
"BaseStats should have records for all functions in base profile "
|
|
|
|
"except inlinees");
|
|
|
|
FuncOverlap.BaseSample = BaseStats[FuncOverlap.BaseName].SampleSum;
|
|
|
|
|
|
|
|
FuncOverlap.Similarity = computeSampleFunctionOverlap(
|
|
|
|
Match->second, &TestFunc.second, &FuncOverlap, FuncOverlap.BaseSample,
|
|
|
|
FuncOverlap.TestSample);
|
|
|
|
ProfOverlap.Similarity +=
|
|
|
|
weightByImportance(FuncOverlap.Similarity, FuncOverlap.BaseSample,
|
|
|
|
FuncOverlap.TestSample);
|
|
|
|
ProfOverlap.OverlapSample += FuncOverlap.OverlapSample;
|
|
|
|
ProfOverlap.UnionSample += FuncOverlap.UnionSample;
|
|
|
|
|
|
|
|
// Accumulate the percentage of base unique and test unique samples into
|
|
|
|
// ProfOverlap.
|
|
|
|
ProfOverlap.BaseUniqueSample += FuncOverlap.BaseUniqueSample;
|
|
|
|
ProfOverlap.TestUniqueSample += FuncOverlap.TestUniqueSample;
|
|
|
|
|
|
|
|
// Remove matched base functions for later reporting functions not found
|
|
|
|
// in test profile.
|
|
|
|
BaseFuncProf.erase(Match);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print function-level similarity information if specified by options.
|
|
|
|
assert(TestStats.count(FuncOverlap.TestName) &&
|
|
|
|
"TestStats should have records for all functions in test profile "
|
|
|
|
"except inlinees");
|
|
|
|
if (TestStats[FuncOverlap.TestName].MaxSample >= FuncFilter.ValueCutoff ||
|
|
|
|
(Match != BaseFuncProf.end() &&
|
|
|
|
FuncOverlap.Similarity < LowSimilarityThreshold) ||
|
|
|
|
(Match != BaseFuncProf.end() && !FuncFilter.NameFilter.empty() &&
|
|
|
|
FuncOverlap.BaseName.find(FuncFilter.NameFilter) !=
|
|
|
|
FuncOverlap.BaseName.npos)) {
|
|
|
|
assert(ProfOverlap.BaseSample > 0 &&
|
|
|
|
"Total samples in base profile should be greater than 0");
|
|
|
|
FuncOverlap.BaseWeight =
|
|
|
|
static_cast<double>(FuncOverlap.BaseSample) / ProfOverlap.BaseSample;
|
|
|
|
assert(ProfOverlap.TestSample > 0 &&
|
|
|
|
"Total samples in test profile should be greater than 0");
|
|
|
|
FuncOverlap.TestWeight =
|
|
|
|
static_cast<double>(FuncOverlap.TestSample) / ProfOverlap.TestSample;
|
|
|
|
FuncSimilarityDump.emplace(FuncOverlap.BaseWeight, FuncOverlap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Traverse through functions in base profile but not in test profile.
|
|
|
|
for (const auto &F : BaseFuncProf) {
|
2020-09-21 07:50:08 +08:00
|
|
|
assert(BaseStats.count(F.second->getName()) &&
|
2020-08-09 08:49:33 +08:00
|
|
|
"BaseStats should have records for all functions in base profile "
|
|
|
|
"except inlinees");
|
2020-09-21 07:50:08 +08:00
|
|
|
const FuncSampleStats &FuncStats = BaseStats[F.second->getName()];
|
2020-08-09 08:49:33 +08:00
|
|
|
++ProfOverlap.BaseUniqueCount;
|
|
|
|
ProfOverlap.BaseUniqueSample += FuncStats.SampleSum;
|
|
|
|
|
|
|
|
updateHotBlockOverlap(FuncStats.SampleSum, 0, FuncStats.HotBlockCount);
|
|
|
|
|
|
|
|
double FuncSimilarity = computeSampleFunctionOverlap(
|
|
|
|
nullptr, nullptr, nullptr, FuncStats.SampleSum, 0);
|
|
|
|
ProfOverlap.Similarity +=
|
|
|
|
weightByImportance(FuncSimilarity, FuncStats.SampleSum, 0);
|
|
|
|
|
|
|
|
ProfOverlap.UnionSample += FuncStats.SampleSum;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, ProfSimilarity may be a little greater than 1 due to imprecision
|
|
|
|
// of floating point accumulations. Make it 1.0 if the difference is below
|
|
|
|
// Epsilon.
|
|
|
|
ProfOverlap.Similarity = (std::fabs(ProfOverlap.Similarity - 1) < Epsilon)
|
|
|
|
? 1
|
|
|
|
: ProfOverlap.Similarity;
|
|
|
|
|
|
|
|
computeHotFuncOverlap();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::initializeSampleProfileOverlap() {
|
|
|
|
const auto &BaseProf = BaseReader->getProfiles();
|
|
|
|
for (const auto &I : BaseProf) {
|
|
|
|
++ProfOverlap.BaseCount;
|
|
|
|
FuncSampleStats FuncStats;
|
|
|
|
getFuncSampleStats(I.second, FuncStats, BaseHotThreshold);
|
|
|
|
ProfOverlap.BaseSample += FuncStats.SampleSum;
|
2020-09-21 07:50:08 +08:00
|
|
|
BaseStats.try_emplace(I.second.getName(), FuncStats);
|
2020-08-09 08:49:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const auto &TestProf = TestReader->getProfiles();
|
|
|
|
for (const auto &I : TestProf) {
|
|
|
|
++ProfOverlap.TestCount;
|
|
|
|
FuncSampleStats FuncStats;
|
|
|
|
getFuncSampleStats(I.second, FuncStats, TestHotThreshold);
|
|
|
|
ProfOverlap.TestSample += FuncStats.SampleSum;
|
2020-09-21 07:50:08 +08:00
|
|
|
TestStats.try_emplace(I.second.getName(), FuncStats);
|
2020-08-09 08:49:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ProfOverlap.BaseName = StringRef(BaseFilename);
|
|
|
|
ProfOverlap.TestName = StringRef(TestFilename);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::dumpFuncSimilarity(raw_fd_ostream &OS) const {
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
if (FuncSimilarityDump.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
formatted_raw_ostream FOS(OS);
|
|
|
|
FOS << "Function-level details:\n";
|
|
|
|
FOS << "Base weight";
|
|
|
|
FOS.PadToColumn(TestWeightCol);
|
|
|
|
FOS << "Test weight";
|
|
|
|
FOS.PadToColumn(SimilarityCol);
|
|
|
|
FOS << "Similarity";
|
|
|
|
FOS.PadToColumn(OverlapCol);
|
|
|
|
FOS << "Overlap";
|
|
|
|
FOS.PadToColumn(BaseUniqueCol);
|
|
|
|
FOS << "Base unique";
|
|
|
|
FOS.PadToColumn(TestUniqueCol);
|
|
|
|
FOS << "Test unique";
|
|
|
|
FOS.PadToColumn(BaseSampleCol);
|
|
|
|
FOS << "Base samples";
|
|
|
|
FOS.PadToColumn(TestSampleCol);
|
|
|
|
FOS << "Test samples";
|
|
|
|
FOS.PadToColumn(FuncNameCol);
|
|
|
|
FOS << "Function name\n";
|
|
|
|
for (const auto &F : FuncSimilarityDump) {
|
|
|
|
double OverlapPercent =
|
|
|
|
F.second.UnionSample > 0
|
|
|
|
? static_cast<double>(F.second.OverlapSample) / F.second.UnionSample
|
|
|
|
: 0;
|
|
|
|
double BaseUniquePercent =
|
|
|
|
F.second.BaseSample > 0
|
|
|
|
? static_cast<double>(F.second.BaseUniqueSample) /
|
|
|
|
F.second.BaseSample
|
|
|
|
: 0;
|
|
|
|
double TestUniquePercent =
|
|
|
|
F.second.TestSample > 0
|
|
|
|
? static_cast<double>(F.second.TestUniqueSample) /
|
|
|
|
F.second.TestSample
|
|
|
|
: 0;
|
|
|
|
|
|
|
|
FOS << format("%.2f%%", F.second.BaseWeight * 100);
|
|
|
|
FOS.PadToColumn(TestWeightCol);
|
|
|
|
FOS << format("%.2f%%", F.second.TestWeight * 100);
|
|
|
|
FOS.PadToColumn(SimilarityCol);
|
|
|
|
FOS << format("%.2f%%", F.second.Similarity * 100);
|
|
|
|
FOS.PadToColumn(OverlapCol);
|
|
|
|
FOS << format("%.2f%%", OverlapPercent * 100);
|
|
|
|
FOS.PadToColumn(BaseUniqueCol);
|
|
|
|
FOS << format("%.2f%%", BaseUniquePercent * 100);
|
|
|
|
FOS.PadToColumn(TestUniqueCol);
|
|
|
|
FOS << format("%.2f%%", TestUniquePercent * 100);
|
|
|
|
FOS.PadToColumn(BaseSampleCol);
|
|
|
|
FOS << F.second.BaseSample;
|
|
|
|
FOS.PadToColumn(TestSampleCol);
|
|
|
|
FOS << F.second.TestSample;
|
|
|
|
FOS.PadToColumn(FuncNameCol);
|
|
|
|
FOS << F.second.TestName << "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::dumpProgramSummary(raw_fd_ostream &OS) const {
|
|
|
|
OS << "Profile overlap infomation for base_profile: " << ProfOverlap.BaseName
|
|
|
|
<< " and test_profile: " << ProfOverlap.TestName << "\nProgram level:\n";
|
|
|
|
|
|
|
|
OS << " Whole program profile similarity: "
|
|
|
|
<< format("%.3f%%", ProfOverlap.Similarity * 100) << "\n";
|
|
|
|
|
|
|
|
assert(ProfOverlap.UnionSample > 0 &&
|
|
|
|
"Total samples in two profile should be greater than 0");
|
|
|
|
double OverlapPercent =
|
|
|
|
static_cast<double>(ProfOverlap.OverlapSample) / ProfOverlap.UnionSample;
|
|
|
|
assert(ProfOverlap.BaseSample > 0 &&
|
|
|
|
"Total samples in base profile should be greater than 0");
|
|
|
|
double BaseUniquePercent = static_cast<double>(ProfOverlap.BaseUniqueSample) /
|
|
|
|
ProfOverlap.BaseSample;
|
|
|
|
assert(ProfOverlap.TestSample > 0 &&
|
|
|
|
"Total samples in test profile should be greater than 0");
|
|
|
|
double TestUniquePercent = static_cast<double>(ProfOverlap.TestUniqueSample) /
|
|
|
|
ProfOverlap.TestSample;
|
|
|
|
|
|
|
|
OS << " Whole program sample overlap: "
|
|
|
|
<< format("%.3f%%", OverlapPercent * 100) << "\n";
|
|
|
|
OS << " percentage of samples unique in base profile: "
|
|
|
|
<< format("%.3f%%", BaseUniquePercent * 100) << "\n";
|
|
|
|
OS << " percentage of samples unique in test profile: "
|
|
|
|
<< format("%.3f%%", TestUniquePercent * 100) << "\n";
|
|
|
|
OS << " total samples in base profile: " << ProfOverlap.BaseSample << "\n"
|
|
|
|
<< " total samples in test profile: " << ProfOverlap.TestSample << "\n";
|
|
|
|
|
|
|
|
assert(ProfOverlap.UnionCount > 0 &&
|
|
|
|
"There should be at least one function in two input profiles");
|
|
|
|
double FuncOverlapPercent =
|
|
|
|
static_cast<double>(ProfOverlap.OverlapCount) / ProfOverlap.UnionCount;
|
|
|
|
OS << " Function overlap: " << format("%.3f%%", FuncOverlapPercent * 100)
|
|
|
|
<< "\n";
|
|
|
|
OS << " overlap functions: " << ProfOverlap.OverlapCount << "\n";
|
|
|
|
OS << " functions unique in base profile: " << ProfOverlap.BaseUniqueCount
|
|
|
|
<< "\n";
|
|
|
|
OS << " functions unique in test profile: " << ProfOverlap.TestUniqueCount
|
|
|
|
<< "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
void SampleOverlapAggregator::dumpHotFuncAndBlockOverlap(
|
|
|
|
raw_fd_ostream &OS) const {
|
|
|
|
assert(HotFuncOverlap.UnionCount > 0 &&
|
|
|
|
"There should be at least one hot function in two input profiles");
|
|
|
|
OS << " Hot-function overlap: "
|
|
|
|
<< format("%.3f%%", static_cast<double>(HotFuncOverlap.OverlapCount) /
|
|
|
|
HotFuncOverlap.UnionCount * 100)
|
|
|
|
<< "\n";
|
|
|
|
OS << " overlap hot functions: " << HotFuncOverlap.OverlapCount << "\n";
|
|
|
|
OS << " hot functions unique in base profile: "
|
|
|
|
<< HotFuncOverlap.BaseCount - HotFuncOverlap.OverlapCount << "\n";
|
|
|
|
OS << " hot functions unique in test profile: "
|
|
|
|
<< HotFuncOverlap.TestCount - HotFuncOverlap.OverlapCount << "\n";
|
|
|
|
|
|
|
|
assert(HotBlockOverlap.UnionCount > 0 &&
|
|
|
|
"There should be at least one hot block in two input profiles");
|
|
|
|
OS << " Hot-block overlap: "
|
|
|
|
<< format("%.3f%%", static_cast<double>(HotBlockOverlap.OverlapCount) /
|
|
|
|
HotBlockOverlap.UnionCount * 100)
|
|
|
|
<< "\n";
|
|
|
|
OS << " overlap hot blocks: " << HotBlockOverlap.OverlapCount << "\n";
|
|
|
|
OS << " hot blocks unique in base profile: "
|
|
|
|
<< HotBlockOverlap.BaseCount - HotBlockOverlap.OverlapCount << "\n";
|
|
|
|
OS << " hot blocks unique in test profile: "
|
|
|
|
<< HotBlockOverlap.TestCount - HotBlockOverlap.OverlapCount << "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::error_code SampleOverlapAggregator::loadProfiles() {
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
LLVMContext Context;
|
|
|
|
auto BaseReaderOrErr = SampleProfileReader::create(BaseFilename, Context);
|
|
|
|
if (std::error_code EC = BaseReaderOrErr.getError())
|
|
|
|
exitWithErrorCode(EC, BaseFilename);
|
|
|
|
|
|
|
|
auto TestReaderOrErr = SampleProfileReader::create(TestFilename, Context);
|
|
|
|
if (std::error_code EC = TestReaderOrErr.getError())
|
|
|
|
exitWithErrorCode(EC, TestFilename);
|
|
|
|
|
|
|
|
BaseReader = std::move(BaseReaderOrErr.get());
|
|
|
|
TestReader = std::move(TestReaderOrErr.get());
|
|
|
|
|
|
|
|
if (std::error_code EC = BaseReader->read())
|
|
|
|
exitWithErrorCode(EC, BaseFilename);
|
|
|
|
if (std::error_code EC = TestReader->read())
|
|
|
|
exitWithErrorCode(EC, TestFilename);
|
2020-12-17 04:54:50 +08:00
|
|
|
if (BaseReader->profileIsProbeBased() != TestReader->profileIsProbeBased())
|
|
|
|
exitWithError(
|
|
|
|
"cannot compare probe-based profile with non-probe-based profile");
|
2020-08-09 08:49:33 +08:00
|
|
|
|
|
|
|
// Load BaseHotThreshold and TestHotThreshold as 99-percentile threshold in
|
|
|
|
// profile summary.
|
|
|
|
const uint64_t HotCutoff = 990000;
|
|
|
|
ProfileSummary &BasePS = BaseReader->getSummary();
|
|
|
|
for (const auto &SummaryEntry : BasePS.getDetailedSummary()) {
|
|
|
|
if (SummaryEntry.Cutoff == HotCutoff) {
|
|
|
|
BaseHotThreshold = SummaryEntry.MinCount;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ProfileSummary &TestPS = TestReader->getSummary();
|
|
|
|
for (const auto &SummaryEntry : TestPS.getDetailedSummary()) {
|
|
|
|
if (SummaryEntry.Cutoff == HotCutoff) {
|
|
|
|
TestHotThreshold = SummaryEntry.MinCount;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return std::error_code();
|
|
|
|
}
|
|
|
|
|
|
|
|
void overlapSampleProfile(const std::string &BaseFilename,
|
|
|
|
const std::string &TestFilename,
|
|
|
|
const OverlapFuncFilters &FuncFilter,
|
|
|
|
uint64_t SimilarityCutoff, raw_fd_ostream &OS) {
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
// We use 0.000005 to initialize OverlapAggr.Epsilon because the final metrics
|
|
|
|
// report 2--3 places after decimal point in percentage numbers.
|
|
|
|
SampleOverlapAggregator OverlapAggr(
|
|
|
|
BaseFilename, TestFilename,
|
|
|
|
static_cast<double>(SimilarityCutoff) / 1000000, 0.000005, FuncFilter);
|
|
|
|
if (std::error_code EC = OverlapAggr.loadProfiles())
|
|
|
|
exitWithErrorCode(EC);
|
|
|
|
|
|
|
|
OverlapAggr.initializeSampleProfileOverlap();
|
|
|
|
if (OverlapAggr.detectZeroSampleProfile(OS))
|
|
|
|
return;
|
|
|
|
|
|
|
|
OverlapAggr.computeSampleProfileOverlap(OS);
|
|
|
|
|
|
|
|
OverlapAggr.dumpProgramSummary(OS);
|
|
|
|
OverlapAggr.dumpHotFuncAndBlockOverlap(OS);
|
|
|
|
OverlapAggr.dumpFuncSimilarity(OS);
|
|
|
|
}
|
|
|
|
|
2019-05-01 05:19:12 +08:00
|
|
|
static int overlap_main(int argc, const char *argv[]) {
|
|
|
|
cl::opt<std::string> BaseFilename(cl::Positional, cl::Required,
|
|
|
|
cl::desc("<base profile file>"));
|
|
|
|
cl::opt<std::string> TestFilename(cl::Positional, cl::Required,
|
|
|
|
cl::desc("<test profile file>"));
|
|
|
|
cl::opt<std::string> Output("output", cl::value_desc("output"), cl::init("-"),
|
|
|
|
cl::desc("Output file"));
|
|
|
|
cl::alias OutputA("o", cl::desc("Alias for --output"), cl::aliasopt(Output));
|
|
|
|
cl::opt<bool> IsCS("cs", cl::init(false),
|
|
|
|
cl::desc("For context sensitive counts"));
|
|
|
|
cl::opt<unsigned long long> ValueCutoff(
|
|
|
|
"value-cutoff", cl::init(-1),
|
|
|
|
cl::desc(
|
|
|
|
"Function level overlap information for every function in test "
|
|
|
|
"profile with max count value greater then the parameter value"));
|
|
|
|
cl::opt<std::string> FuncNameFilter(
|
|
|
|
"function",
|
|
|
|
cl::desc("Function level overlap information for matching functions"));
|
2020-08-09 08:49:33 +08:00
|
|
|
cl::opt<unsigned long long> SimilarityCutoff(
|
|
|
|
"similarity-cutoff", cl::init(0),
|
|
|
|
cl::desc(
|
|
|
|
"For sample profiles, list function names for overlapped functions "
|
|
|
|
"with similarities below the cutoff (percentage times 10000)."));
|
|
|
|
cl::opt<ProfileKinds> ProfileKind(
|
|
|
|
cl::desc("Profile kind:"), cl::init(instr),
|
|
|
|
cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
|
|
|
|
clEnumVal(sample, "Sample profile")));
|
2019-05-01 05:19:12 +08:00
|
|
|
cl::ParseCommandLineOptions(argc, argv, "LLVM profile data overlap tool\n");
|
|
|
|
|
|
|
|
std::error_code EC;
|
2019-08-05 13:43:48 +08:00
|
|
|
raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_Text);
|
2019-05-01 05:19:12 +08:00
|
|
|
if (EC)
|
|
|
|
exitWithErrorCode(EC, Output);
|
|
|
|
|
2020-08-09 08:49:33 +08:00
|
|
|
if (ProfileKind == instr)
|
|
|
|
overlapInstrProfile(BaseFilename, TestFilename,
|
|
|
|
OverlapFuncFilters{ValueCutoff, FuncNameFilter}, OS,
|
|
|
|
IsCS);
|
|
|
|
else
|
|
|
|
overlapSampleProfile(BaseFilename, TestFilename,
|
|
|
|
OverlapFuncFilters{ValueCutoff, FuncNameFilter},
|
|
|
|
SimilarityCutoff, OS);
|
2019-05-01 05:19:12 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-10 03:03:57 +08:00
|
|
|
typedef struct ValueSitesStats {
|
|
|
|
ValueSitesStats()
|
|
|
|
: TotalNumValueSites(0), TotalNumValueSitesWithValueProfile(0),
|
|
|
|
TotalNumValues(0) {}
|
|
|
|
uint64_t TotalNumValueSites;
|
|
|
|
uint64_t TotalNumValueSitesWithValueProfile;
|
|
|
|
uint64_t TotalNumValues;
|
|
|
|
std::vector<unsigned> ValueSitesHistogram;
|
|
|
|
} ValueSitesStats;
|
|
|
|
|
|
|
|
static void traverseAllValueSites(const InstrProfRecord &Func, uint32_t VK,
|
|
|
|
ValueSitesStats &Stats, raw_fd_ostream &OS,
|
2017-03-17 05:15:48 +08:00
|
|
|
InstrProfSymtab *Symtab) {
|
2017-03-10 03:03:57 +08:00
|
|
|
uint32_t NS = Func.getNumValueSites(VK);
|
|
|
|
Stats.TotalNumValueSites += NS;
|
|
|
|
for (size_t I = 0; I < NS; ++I) {
|
|
|
|
uint32_t NV = Func.getNumValueDataForSite(VK, I);
|
|
|
|
std::unique_ptr<InstrProfValueData[]> VD = Func.getValueForSite(VK, I);
|
|
|
|
Stats.TotalNumValues += NV;
|
|
|
|
if (NV) {
|
|
|
|
Stats.TotalNumValueSitesWithValueProfile++;
|
|
|
|
if (NV > Stats.ValueSitesHistogram.size())
|
|
|
|
Stats.ValueSitesHistogram.resize(NV, 0);
|
|
|
|
Stats.ValueSitesHistogram[NV - 1]++;
|
|
|
|
}
|
2019-01-09 06:41:48 +08:00
|
|
|
|
|
|
|
uint64_t SiteSum = 0;
|
|
|
|
for (uint32_t V = 0; V < NV; V++)
|
|
|
|
SiteSum += VD[V].Count;
|
|
|
|
if (SiteSum == 0)
|
|
|
|
SiteSum = 1;
|
|
|
|
|
2017-03-10 03:03:57 +08:00
|
|
|
for (uint32_t V = 0; V < NV; V++) {
|
2019-01-09 06:41:48 +08:00
|
|
|
OS << "\t[ " << format("%2u", I) << ", ";
|
2017-03-17 05:15:48 +08:00
|
|
|
if (Symtab == nullptr)
|
2019-02-06 02:09:28 +08:00
|
|
|
OS << format("%4" PRIu64, VD[V].Value);
|
2017-03-17 05:15:48 +08:00
|
|
|
else
|
|
|
|
OS << Symtab->getFuncName(VD[V].Value);
|
2019-01-09 06:41:48 +08:00
|
|
|
OS << ", " << format("%10" PRId64, VD[V].Count) << " ] ("
|
|
|
|
<< format("%.2f%%", (VD[V].Count * 100.0 / SiteSum)) << ")\n";
|
2017-03-10 03:03:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void showValueSitesStats(raw_fd_ostream &OS, uint32_t VK,
|
|
|
|
ValueSitesStats &Stats) {
|
|
|
|
OS << " Total number of sites: " << Stats.TotalNumValueSites << "\n";
|
|
|
|
OS << " Total number of sites with values: "
|
|
|
|
<< Stats.TotalNumValueSitesWithValueProfile << "\n";
|
|
|
|
OS << " Total number of profiled values: " << Stats.TotalNumValues << "\n";
|
|
|
|
|
|
|
|
OS << " Value sites histogram:\n\tNumTargets, SiteCount\n";
|
|
|
|
for (unsigned I = 0; I < Stats.ValueSitesHistogram.size(); I++) {
|
|
|
|
if (Stats.ValueSitesHistogram[I] > 0)
|
|
|
|
OS << "\t" << I + 1 << ", " << Stats.ValueSitesHistogram[I] << "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-18 04:41:14 +08:00
|
|
|
static int showInstrProfile(const std::string &Filename, bool ShowCounts,
|
2017-07-12 04:30:43 +08:00
|
|
|
uint32_t TopN, bool ShowIndirectCallTargets,
|
|
|
|
bool ShowMemOPSizes, bool ShowDetailedSummary,
|
2016-01-14 05:44:36 +08:00
|
|
|
std::vector<uint32_t> DetailedSummaryCutoffs,
|
2019-03-01 03:55:07 +08:00
|
|
|
bool ShowAllFunctions, bool ShowCS,
|
|
|
|
uint64_t ValueCutoff, bool OnlyListBelow,
|
|
|
|
const std::string &ShowFunction, bool TextFormat,
|
|
|
|
raw_fd_ostream &OS) {
|
2014-11-03 08:51:45 +08:00
|
|
|
auto ReaderOrErr = InstrProfReader::create(Filename);
|
2016-06-18 04:41:14 +08:00
|
|
|
std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
|
|
|
|
if (ShowDetailedSummary && Cutoffs.empty()) {
|
2016-01-14 05:44:36 +08:00
|
|
|
Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
|
|
|
|
}
|
2016-06-18 04:41:14 +08:00
|
|
|
InstrProfSummaryBuilder Builder(std::move(Cutoffs));
|
2016-05-19 11:54:45 +08:00
|
|
|
if (Error E = ReaderOrErr.takeError())
|
|
|
|
exitWithError(std::move(E), Filename);
|
2014-03-22 01:29:44 +08:00
|
|
|
|
2014-11-03 08:51:45 +08:00
|
|
|
auto Reader = std::move(ReaderOrErr.get());
|
2016-02-11 01:18:30 +08:00
|
|
|
bool IsIRInstr = Reader->isIRLevelProfile();
|
2016-01-14 05:44:36 +08:00
|
|
|
size_t ShownFunctions = 0;
|
2019-01-09 06:41:48 +08:00
|
|
|
size_t BelowCutoffFunctions = 0;
|
2017-03-10 03:03:57 +08:00
|
|
|
int NumVPKind = IPVK_Last - IPVK_First + 1;
|
|
|
|
std::vector<ValueSitesStats> VPStats(NumVPKind);
|
2017-07-12 04:30:43 +08:00
|
|
|
|
|
|
|
auto MinCmp = [](const std::pair<std::string, uint64_t> &v1,
|
|
|
|
const std::pair<std::string, uint64_t> &v2) {
|
|
|
|
return v1.second > v2.second;
|
|
|
|
};
|
|
|
|
|
|
|
|
std::priority_queue<std::pair<std::string, uint64_t>,
|
|
|
|
std::vector<std::pair<std::string, uint64_t>>,
|
|
|
|
decltype(MinCmp)>
|
|
|
|
HottestFuncs(MinCmp);
|
|
|
|
|
2019-01-09 06:41:48 +08:00
|
|
|
if (!TextFormat && OnlyListBelow) {
|
|
|
|
OS << "The list of functions with the maximum counter less than "
|
|
|
|
<< ValueCutoff << ":\n";
|
|
|
|
}
|
|
|
|
|
2018-08-24 09:34:45 +08:00
|
|
|
// Add marker so that IR-level instrumentation round-trips properly.
|
|
|
|
if (TextFormat && IsIRInstr)
|
|
|
|
OS << ":ir\n";
|
|
|
|
|
2014-03-22 01:29:44 +08:00
|
|
|
for (const auto &Func : *Reader) {
|
2019-03-01 03:55:07 +08:00
|
|
|
if (Reader->isIRLevelProfile()) {
|
|
|
|
bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
|
|
|
|
if (FuncIsCS != ShowCS)
|
|
|
|
continue;
|
|
|
|
}
|
2014-11-01 08:56:55 +08:00
|
|
|
bool Show =
|
|
|
|
ShowAllFunctions || (!ShowFunction.empty() &&
|
|
|
|
Func.Name.find(ShowFunction) != Func.Name.npos);
|
2014-03-22 01:29:44 +08:00
|
|
|
|
2018-08-24 09:34:45 +08:00
|
|
|
bool doTextFormatDump = (Show && TextFormat);
|
2015-11-24 04:47:38 +08:00
|
|
|
|
|
|
|
if (doTextFormatDump) {
|
2015-12-20 14:22:13 +08:00
|
|
|
InstrProfSymtab &Symtab = Reader->getSymtab();
|
2017-07-07 03:00:12 +08:00
|
|
|
InstrProfWriter::writeRecordInText(Func.Name, Func.Hash, Func, Symtab,
|
|
|
|
OS);
|
2015-11-24 04:47:38 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-04-25 10:45:33 +08:00
|
|
|
assert(Func.Counts.size() > 0 && "function missing entry counter");
|
2016-05-20 05:07:12 +08:00
|
|
|
Builder.addRecord(Func);
|
2015-11-24 04:47:38 +08:00
|
|
|
|
2019-01-09 06:41:48 +08:00
|
|
|
uint64_t FuncMax = 0;
|
|
|
|
uint64_t FuncSum = 0;
|
|
|
|
for (size_t I = 0, E = Func.Counts.size(); I < E; ++I) {
|
Supplement instr profile with sample profile.
PGO profile is usually more precise than sample profile. However, PGO profile
needs to be collected from loadtest and loadtest may not be representative
enough to the production workload. Sample profile collected from production
can be used as a supplement -- for functions cold in loadtest but warm/hot
in production, we can scale up the related function in PGO profile if the
function is warm or hot in sample profile.
The implementation contains changes in compiler side and llvm-profdata side.
Given an instr profile and a sample profile, for a function cold in PGO
profile but warm/hot in sample profile, llvm-profdata will either mark
all the counters in the profile to be -1 or scale up the max count in the
function to be above hot threshold, depending on the zero counter ratio in
the profile. The assumption is if there are too many counters being zero
in the function profile, the profile is more likely to cause harm than good,
then llvm-profdata will mark all the counters to be -1 indicating the
function is hot but the profile is unaccountable. In compiler side, if a
function profile with all -1 counters is seen, the function entry count will
be set to be above hot threshold but its internal profile will be dropped.
In the long run, it may be useful to let compiler support using PGO profile
and sample profile at the same time, but that requires more careful design
and more substantial changes to make two profiles work seamlessly. The patch
here serves as a simple intermediate solution.
Differential Revision: https://reviews.llvm.org/D81981
2020-07-09 06:19:44 +08:00
|
|
|
if (Func.Counts[I] == (uint64_t)-1)
|
|
|
|
continue;
|
2019-01-09 06:41:48 +08:00
|
|
|
FuncMax = std::max(FuncMax, Func.Counts[I]);
|
|
|
|
FuncSum += Func.Counts[I];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FuncMax < ValueCutoff) {
|
|
|
|
++BelowCutoffFunctions;
|
|
|
|
if (OnlyListBelow) {
|
|
|
|
OS << " " << Func.Name << ": (Max = " << FuncMax
|
|
|
|
<< " Sum = " << FuncSum << ")\n";
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
} else if (OnlyListBelow)
|
|
|
|
continue;
|
2019-01-09 06:37:12 +08:00
|
|
|
|
2019-01-09 06:41:48 +08:00
|
|
|
if (TopN) {
|
2017-07-12 04:30:43 +08:00
|
|
|
if (HottestFuncs.size() == TopN) {
|
|
|
|
if (HottestFuncs.top().second < FuncMax) {
|
|
|
|
HottestFuncs.pop();
|
|
|
|
HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
|
|
|
|
}
|
|
|
|
|
2014-03-22 01:29:44 +08:00
|
|
|
if (Show) {
|
|
|
|
if (!ShownFunctions)
|
|
|
|
OS << "Counters:\n";
|
2015-11-24 04:47:38 +08:00
|
|
|
|
2014-03-22 01:29:44 +08:00
|
|
|
++ShownFunctions;
|
|
|
|
|
|
|
|
OS << " " << Func.Name << ":\n"
|
2014-03-24 04:43:50 +08:00
|
|
|
<< " Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
|
2016-02-11 01:18:30 +08:00
|
|
|
<< " Counters: " << Func.Counts.size() << "\n";
|
|
|
|
if (!IsIRInstr)
|
|
|
|
OS << " Function count: " << Func.Counts[0] << "\n";
|
2015-11-24 04:47:38 +08:00
|
|
|
|
2015-09-30 06:13:58 +08:00
|
|
|
if (ShowIndirectCallTargets)
|
2015-11-02 13:08:23 +08:00
|
|
|
OS << " Indirect Call Site Count: "
|
|
|
|
<< Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";
|
2014-03-22 01:29:44 +08:00
|
|
|
|
2017-03-17 05:15:48 +08:00
|
|
|
uint32_t NumMemOPCalls = Func.getNumValueSites(IPVK_MemOPSize);
|
|
|
|
if (ShowMemOPSizes && NumMemOPCalls > 0)
|
|
|
|
OS << " Number of Memory Intrinsics Calls: " << NumMemOPCalls
|
|
|
|
<< "\n";
|
|
|
|
|
2015-11-24 04:47:38 +08:00
|
|
|
if (ShowCounts) {
|
|
|
|
OS << " Block counts: [";
|
2016-02-11 01:18:30 +08:00
|
|
|
size_t Start = (IsIRInstr ? 0 : 1);
|
|
|
|
for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
|
|
|
|
OS << (I == Start ? "" : ", ") << Func.Counts[I];
|
2015-11-24 04:47:38 +08:00
|
|
|
}
|
|
|
|
OS << "]\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ShowIndirectCallTargets) {
|
2017-03-10 03:03:57 +08:00
|
|
|
OS << " Indirect Target Results:\n";
|
|
|
|
traverseAllValueSites(Func, IPVK_IndirectCallTarget,
|
|
|
|
VPStats[IPVK_IndirectCallTarget], OS,
|
2017-03-17 05:15:48 +08:00
|
|
|
&(Reader->getSymtab()));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ShowMemOPSizes && NumMemOPCalls > 0) {
|
2017-05-25 01:55:25 +08:00
|
|
|
OS << " Memory Intrinsic Size Results:\n";
|
2017-03-17 05:15:48 +08:00
|
|
|
traverseAllValueSites(Func, IPVK_MemOPSize, VPStats[IPVK_MemOPSize], OS,
|
|
|
|
nullptr);
|
2015-09-30 06:13:58 +08:00
|
|
|
}
|
|
|
|
}
|
2014-03-22 01:29:44 +08:00
|
|
|
}
|
2014-03-24 04:55:53 +08:00
|
|
|
if (Reader->hasError())
|
2016-05-19 11:54:45 +08:00
|
|
|
exitWithError(Reader->getError(), Filename);
|
2014-03-22 01:29:44 +08:00
|
|
|
|
2018-08-24 09:34:45 +08:00
|
|
|
if (TextFormat)
|
2015-11-24 04:47:38 +08:00
|
|
|
return 0;
|
2016-05-20 05:53:28 +08:00
|
|
|
std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
|
2020-07-23 05:58:42 +08:00
|
|
|
bool IsIR = Reader->isIRLevelProfile();
|
|
|
|
OS << "Instrumentation level: " << (IsIR ? "IR" : "Front-end");
|
|
|
|
if (IsIR)
|
|
|
|
OS << " entry_first = " << Reader->instrEntryBBEnabled();
|
|
|
|
OS << "\n";
|
2014-03-22 01:29:44 +08:00
|
|
|
if (ShowAllFunctions || !ShowFunction.empty())
|
|
|
|
OS << "Functions shown: " << ShownFunctions << "\n";
|
2016-05-20 05:07:12 +08:00
|
|
|
OS << "Total functions: " << PS->getNumFunctions() << "\n";
|
2019-01-09 06:41:48 +08:00
|
|
|
if (ValueCutoff > 0) {
|
|
|
|
OS << "Number of functions with maximum count (< " << ValueCutoff
|
|
|
|
<< "): " << BelowCutoffFunctions << "\n";
|
|
|
|
OS << "Number of functions with maximum count (>= " << ValueCutoff
|
|
|
|
<< "): " << PS->getNumFunctions() - BelowCutoffFunctions << "\n";
|
|
|
|
}
|
2016-05-20 05:07:12 +08:00
|
|
|
OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
|
2016-05-20 05:53:28 +08:00
|
|
|
OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
|
2017-03-17 05:15:48 +08:00
|
|
|
|
2017-07-12 04:30:43 +08:00
|
|
|
if (TopN) {
|
|
|
|
std::vector<std::pair<std::string, uint64_t>> SortedHottestFuncs;
|
|
|
|
while (!HottestFuncs.empty()) {
|
|
|
|
SortedHottestFuncs.emplace_back(HottestFuncs.top());
|
|
|
|
HottestFuncs.pop();
|
|
|
|
}
|
|
|
|
OS << "Top " << TopN
|
|
|
|
<< " functions with the largest internal block counts: \n";
|
|
|
|
for (auto &hotfunc : llvm::reverse(SortedHottestFuncs))
|
|
|
|
OS << " " << hotfunc.first << ", max count = " << hotfunc.second << "\n";
|
|
|
|
}
|
|
|
|
|
2016-05-24 00:36:11 +08:00
|
|
|
if (ShownFunctions && ShowIndirectCallTargets) {
|
2017-03-10 03:03:57 +08:00
|
|
|
OS << "Statistics for indirect call sites profile:\n";
|
|
|
|
showValueSitesStats(OS, IPVK_IndirectCallTarget,
|
|
|
|
VPStats[IPVK_IndirectCallTarget]);
|
2016-05-24 00:36:11 +08:00
|
|
|
}
|
2016-01-14 05:44:36 +08:00
|
|
|
|
2017-03-17 05:15:48 +08:00
|
|
|
if (ShownFunctions && ShowMemOPSizes) {
|
|
|
|
OS << "Statistics for memory intrinsic calls sizes profile:\n";
|
|
|
|
showValueSitesStats(OS, IPVK_MemOPSize, VPStats[IPVK_MemOPSize]);
|
|
|
|
}
|
|
|
|
|
2016-01-14 05:44:36 +08:00
|
|
|
if (ShowDetailedSummary) {
|
2016-05-20 05:53:28 +08:00
|
|
|
OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
|
2016-05-20 05:07:12 +08:00
|
|
|
OS << "Total count: " << PS->getTotalCount() << "\n";
|
2020-05-02 23:34:10 +08:00
|
|
|
PS->printDetailedSummary(OS);
|
2016-01-14 05:44:36 +08:00
|
|
|
}
|
2014-03-22 01:29:44 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-09-22 01:23:55 +08:00
|
|
|
static void showSectionInfo(sampleprof::SampleProfileReader *Reader,
|
|
|
|
raw_fd_ostream &OS) {
|
|
|
|
if (!Reader->dumpSectionInfo(OS)) {
|
|
|
|
WithColor::warning() << "-show-sec-info-only is only supported for "
|
|
|
|
<< "sample profile in extbinary format and is "
|
|
|
|
<< "ignored for other formats.\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 06:17:03 +08:00
|
|
|
namespace {
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
struct HotFuncInfo {
|
|
|
|
StringRef FuncName;
|
|
|
|
uint64_t TotalCount;
|
|
|
|
double TotalCountPercent;
|
|
|
|
uint64_t MaxCount;
|
|
|
|
uint64_t EntryCount;
|
|
|
|
|
|
|
|
HotFuncInfo()
|
|
|
|
: FuncName(), TotalCount(0), TotalCountPercent(0.0f), MaxCount(0),
|
|
|
|
EntryCount(0) {}
|
|
|
|
|
|
|
|
HotFuncInfo(StringRef FN, uint64_t TS, double TSP, uint64_t MS, uint64_t ES)
|
|
|
|
: FuncName(FN), TotalCount(TS), TotalCountPercent(TSP), MaxCount(MS),
|
|
|
|
EntryCount(ES) {}
|
|
|
|
};
|
2020-06-25 06:17:03 +08:00
|
|
|
} // namespace
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
|
|
|
|
// Print out detailed information about hot functions in PrintValues vector.
|
|
|
|
// Users specify titles and offset of every columns through ColumnTitle and
|
|
|
|
// ColumnOffset. The size of ColumnTitle and ColumnOffset need to be the same
|
|
|
|
// and at least 4. Besides, users can optionally give a HotFuncMetric string to
|
|
|
|
// print out or let it be an empty string.
|
|
|
|
static void dumpHotFunctionList(const std::vector<std::string> &ColumnTitle,
|
|
|
|
const std::vector<int> &ColumnOffset,
|
|
|
|
const std::vector<HotFuncInfo> &PrintValues,
|
|
|
|
uint64_t HotFuncCount, uint64_t TotalFuncCount,
|
|
|
|
uint64_t HotProfCount, uint64_t TotalProfCount,
|
|
|
|
const std::string &HotFuncMetric,
|
|
|
|
raw_fd_ostream &OS) {
|
2020-08-09 08:49:33 +08:00
|
|
|
assert(ColumnOffset.size() == ColumnTitle.size() &&
|
|
|
|
"ColumnOffset and ColumnTitle should have the same size");
|
|
|
|
assert(ColumnTitle.size() >= 4 &&
|
|
|
|
"ColumnTitle should have at least 4 elements");
|
|
|
|
assert(TotalFuncCount > 0 &&
|
|
|
|
"There should be at least one function in the profile");
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
double TotalProfPercent = 0;
|
|
|
|
if (TotalProfCount > 0)
|
2020-08-09 08:49:33 +08:00
|
|
|
TotalProfPercent = static_cast<double>(HotProfCount) / TotalProfCount * 100;
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
|
|
|
|
formatted_raw_ostream FOS(OS);
|
|
|
|
FOS << HotFuncCount << " out of " << TotalFuncCount
|
|
|
|
<< " functions with profile ("
|
2020-08-09 08:49:33 +08:00
|
|
|
<< format("%.2f%%",
|
|
|
|
(static_cast<double>(HotFuncCount) / TotalFuncCount * 100))
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
<< ") are considered hot functions";
|
|
|
|
if (!HotFuncMetric.empty())
|
|
|
|
FOS << " (" << HotFuncMetric << ")";
|
|
|
|
FOS << ".\n";
|
|
|
|
FOS << HotProfCount << " out of " << TotalProfCount << " profile counts ("
|
|
|
|
<< format("%.2f%%", TotalProfPercent) << ") are from hot functions.\n";
|
|
|
|
|
|
|
|
for (size_t I = 0; I < ColumnTitle.size(); ++I) {
|
|
|
|
FOS.PadToColumn(ColumnOffset[I]);
|
|
|
|
FOS << ColumnTitle[I];
|
|
|
|
}
|
|
|
|
FOS << "\n";
|
|
|
|
|
2020-06-25 06:17:03 +08:00
|
|
|
for (const HotFuncInfo &R : PrintValues) {
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
FOS.PadToColumn(ColumnOffset[0]);
|
|
|
|
FOS << R.TotalCount << " (" << format("%.2f%%", R.TotalCountPercent) << ")";
|
|
|
|
FOS.PadToColumn(ColumnOffset[1]);
|
|
|
|
FOS << R.MaxCount;
|
|
|
|
FOS.PadToColumn(ColumnOffset[2]);
|
|
|
|
FOS << R.EntryCount;
|
|
|
|
FOS.PadToColumn(ColumnOffset[3]);
|
|
|
|
FOS << R.FuncName << "\n";
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
showHotFunctionList(const StringMap<sampleprof::FunctionSamples> &Profiles,
|
|
|
|
ProfileSummary &PS, raw_fd_ostream &OS) {
|
|
|
|
using namespace sampleprof;
|
|
|
|
|
|
|
|
const uint32_t HotFuncCutoff = 990000;
|
|
|
|
auto &SummaryVector = PS.getDetailedSummary();
|
|
|
|
uint64_t MinCountThreshold = 0;
|
2020-06-25 06:17:03 +08:00
|
|
|
for (const ProfileSummaryEntry &SummaryEntry : SummaryVector) {
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
if (SummaryEntry.Cutoff == HotFuncCutoff) {
|
|
|
|
MinCountThreshold = SummaryEntry.MinCount;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Traverse all functions in the profile and keep only hot functions.
|
|
|
|
// The following loop also calculates the sum of total samples of all
|
|
|
|
// functions.
|
|
|
|
std::multimap<uint64_t, std::pair<const FunctionSamples *, const uint64_t>,
|
|
|
|
std::greater<uint64_t>>
|
|
|
|
HotFunc;
|
|
|
|
uint64_t ProfileTotalSample = 0;
|
|
|
|
uint64_t HotFuncSample = 0;
|
|
|
|
uint64_t HotFuncCount = 0;
|
2020-08-09 08:49:33 +08:00
|
|
|
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
for (const auto &I : Profiles) {
|
2020-08-09 08:49:33 +08:00
|
|
|
FuncSampleStats FuncStats;
|
2020-06-25 06:17:03 +08:00
|
|
|
const FunctionSamples &FuncProf = I.second;
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
ProfileTotalSample += FuncProf.getTotalSamples();
|
2020-08-09 08:49:33 +08:00
|
|
|
getFuncSampleStats(FuncProf, FuncStats, MinCountThreshold);
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
|
2020-08-09 08:49:33 +08:00
|
|
|
if (isFunctionHot(FuncStats, MinCountThreshold)) {
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
HotFunc.emplace(FuncProf.getTotalSamples(),
|
2020-08-09 08:49:33 +08:00
|
|
|
std::make_pair(&(I.second), FuncStats.MaxSample));
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
HotFuncSample += FuncProf.getTotalSamples();
|
|
|
|
++HotFuncCount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> ColumnTitle{"Total sample (%)", "Max sample",
|
|
|
|
"Entry sample", "Function name"};
|
|
|
|
std::vector<int> ColumnOffset{0, 24, 42, 58};
|
|
|
|
std::string Metric =
|
|
|
|
std::string("max sample >= ") + std::to_string(MinCountThreshold);
|
|
|
|
std::vector<HotFuncInfo> PrintValues;
|
|
|
|
for (const auto &FuncPair : HotFunc) {
|
2020-06-25 06:17:03 +08:00
|
|
|
const FunctionSamples &Func = *FuncPair.second.first;
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
double TotalSamplePercent =
|
|
|
|
(ProfileTotalSample > 0)
|
2020-06-25 06:17:03 +08:00
|
|
|
? (Func.getTotalSamples() * 100.0) / ProfileTotalSample
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
: 0;
|
2020-09-21 07:50:08 +08:00
|
|
|
PrintValues.emplace_back(
|
|
|
|
HotFuncInfo(Func.getName(), Func.getTotalSamples(), TotalSamplePercent,
|
|
|
|
FuncPair.second.second, Func.getEntrySamples()));
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
}
|
|
|
|
dumpHotFunctionList(ColumnTitle, ColumnOffset, PrintValues, HotFuncCount,
|
|
|
|
Profiles.size(), HotFuncSample, ProfileTotalSample,
|
|
|
|
Metric, OS);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-18 04:41:14 +08:00
|
|
|
static int showSampleProfile(const std::string &Filename, bool ShowCounts,
|
2020-05-02 23:34:10 +08:00
|
|
|
bool ShowAllFunctions, bool ShowDetailedSummary,
|
2016-06-18 04:41:14 +08:00
|
|
|
const std::string &ShowFunction,
|
2019-09-22 01:23:55 +08:00
|
|
|
bool ShowProfileSymbolList,
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
bool ShowSectionInfoOnly, bool ShowHotFuncList,
|
|
|
|
raw_fd_ostream &OS) {
|
2014-11-01 08:56:55 +08:00
|
|
|
using namespace sampleprof;
|
2016-04-15 05:59:01 +08:00
|
|
|
LLVMContext Context;
|
|
|
|
auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
|
2014-11-03 08:51:45 +08:00
|
|
|
if (std::error_code EC = ReaderOrErr.getError())
|
2015-11-13 11:47:58 +08:00
|
|
|
exitWithErrorCode(EC, Filename);
|
2014-11-01 08:56:55 +08:00
|
|
|
|
2014-11-03 08:51:45 +08:00
|
|
|
auto Reader = std::move(ReaderOrErr.get());
|
2019-09-22 01:23:55 +08:00
|
|
|
|
|
|
|
if (ShowSectionInfoOnly) {
|
|
|
|
showSectionInfo(Reader.get(), OS);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-17 08:17:21 +08:00
|
|
|
if (std::error_code EC = Reader->read())
|
2015-11-13 11:47:58 +08:00
|
|
|
exitWithErrorCode(EC, Filename);
|
2015-09-17 08:17:21 +08:00
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
if (ShowAllFunctions || ShowFunction.empty())
|
|
|
|
Reader->dump(OS);
|
|
|
|
else
|
|
|
|
Reader->dumpFunctionProfile(ShowFunction, OS);
|
|
|
|
|
2019-08-31 10:27:26 +08:00
|
|
|
if (ShowProfileSymbolList) {
|
|
|
|
std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
|
|
|
|
Reader->getProfileSymbolList();
|
|
|
|
ReaderList->dump(OS);
|
|
|
|
}
|
|
|
|
|
2020-05-02 23:34:10 +08:00
|
|
|
if (ShowDetailedSummary) {
|
|
|
|
auto &PS = Reader->getSummary();
|
|
|
|
PS.printSummary(OS);
|
|
|
|
PS.printDetailedSummary(OS);
|
|
|
|
}
|
|
|
|
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
if (ShowHotFuncList)
|
|
|
|
showHotFunctionList(Reader->getProfiles(), Reader->getSummary(), OS);
|
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-10 00:23:46 +08:00
|
|
|
static int show_main(int argc, const char *argv[]) {
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::opt<std::string> Filename(cl::Positional, cl::Required,
|
|
|
|
cl::desc("<profdata-file>"));
|
|
|
|
|
|
|
|
cl::opt<bool> ShowCounts("counts", cl::init(false),
|
|
|
|
cl::desc("Show counter values for shown functions"));
|
2015-11-24 04:47:38 +08:00
|
|
|
cl::opt<bool> TextFormat(
|
|
|
|
"text", cl::init(false),
|
|
|
|
cl::desc("Show instr profile data in text dump format"));
|
2015-09-30 06:13:58 +08:00
|
|
|
cl::opt<bool> ShowIndirectCallTargets(
|
|
|
|
"ic-targets", cl::init(false),
|
|
|
|
cl::desc("Show indirect call site target values for shown functions"));
|
2017-03-17 05:15:48 +08:00
|
|
|
cl::opt<bool> ShowMemOPSizes(
|
|
|
|
"memop-sizes", cl::init(false),
|
|
|
|
cl::desc("Show the profiled sizes of the memory intrinsic calls "
|
|
|
|
"for shown functions"));
|
2016-01-14 05:44:36 +08:00
|
|
|
cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
|
|
|
|
cl::desc("Show detailed profile summary"));
|
|
|
|
cl::list<uint32_t> DetailedSummaryCutoffs(
|
|
|
|
cl::CommaSeparated, "detailed-summary-cutoffs",
|
|
|
|
cl::desc(
|
|
|
|
"Cutoff percentages (times 10000) for generating detailed summary"),
|
|
|
|
cl::value_desc("800000,901000,999999"));
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
cl::opt<bool> ShowHotFuncList(
|
|
|
|
"hot-func-list", cl::init(false),
|
|
|
|
cl::desc("Show profile summary of a list of hot functions"));
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
|
|
|
|
cl::desc("Details for every function"));
|
2019-03-01 03:55:07 +08:00
|
|
|
cl::opt<bool> ShowCS("showcs", cl::init(false),
|
|
|
|
cl::desc("Show context sensitive counts"));
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::opt<std::string> ShowFunction("function",
|
|
|
|
cl::desc("Details for matching functions"));
|
|
|
|
|
|
|
|
cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
|
|
|
|
cl::init("-"), cl::desc("Output file"));
|
|
|
|
cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
|
|
|
|
cl::aliasopt(OutputFilename));
|
|
|
|
cl::opt<ProfileKinds> ProfileKind(
|
|
|
|
cl::desc("Profile kind:"), cl::init(instr),
|
|
|
|
cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
|
2016-10-09 03:41:06 +08:00
|
|
|
clEnumVal(sample, "Sample profile")));
|
2017-07-12 04:30:43 +08:00
|
|
|
cl::opt<uint32_t> TopNFunctions(
|
|
|
|
"topn", cl::init(0),
|
|
|
|
cl::desc("Show the list of functions with the largest internal counts"));
|
2019-01-09 06:41:48 +08:00
|
|
|
cl::opt<uint32_t> ValueCutoff(
|
|
|
|
"value-cutoff", cl::init(0),
|
|
|
|
cl::desc("Set the count value cutoff. Functions with the maximum count "
|
|
|
|
"less than this value will not be printed out. (Default is 0)"));
|
|
|
|
cl::opt<bool> OnlyListBelow(
|
|
|
|
"list-below-cutoff", cl::init(false),
|
|
|
|
cl::desc("Only output names of functions whose max count values are "
|
|
|
|
"below the cutoff value"));
|
2019-08-31 10:27:26 +08:00
|
|
|
cl::opt<bool> ShowProfileSymbolList(
|
|
|
|
"show-prof-sym-list", cl::init(false),
|
|
|
|
cl::desc("Show profile symbol list if it exists in the profile. "));
|
2019-09-22 01:23:55 +08:00
|
|
|
cl::opt<bool> ShowSectionInfoOnly(
|
|
|
|
"show-sec-info-only", cl::init(false),
|
|
|
|
cl::desc("Show the information of each section in the sample profile. "
|
|
|
|
"The flag is only usable when the sample profile is in "
|
|
|
|
"extbinary format"));
|
2019-08-31 10:27:26 +08:00
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
|
|
|
|
|
|
|
|
if (OutputFilename.empty())
|
|
|
|
OutputFilename = "-";
|
|
|
|
|
2019-07-09 05:03:12 +08:00
|
|
|
if (!Filename.compare(OutputFilename)) {
|
|
|
|
errs() << sys::path::filename(argv[0])
|
|
|
|
<< ": Input file name cannot be the same as the output file name!\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-11-01 08:56:55 +08:00
|
|
|
std::error_code EC;
|
2019-08-05 13:43:48 +08:00
|
|
|
raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_Text);
|
2014-11-01 08:56:55 +08:00
|
|
|
if (EC)
|
2015-11-24 04:47:38 +08:00
|
|
|
exitWithErrorCode(EC, OutputFilename);
|
2014-11-01 08:56:55 +08:00
|
|
|
|
|
|
|
if (ShowAllFunctions && !ShowFunction.empty())
|
2018-04-18 22:42:33 +08:00
|
|
|
WithColor::warning() << "-function argument ignored: showing all functions\n";
|
2014-11-01 08:56:55 +08:00
|
|
|
|
|
|
|
if (ProfileKind == instr)
|
2017-07-12 04:30:43 +08:00
|
|
|
return showInstrProfile(Filename, ShowCounts, TopNFunctions,
|
|
|
|
ShowIndirectCallTargets, ShowMemOPSizes,
|
|
|
|
ShowDetailedSummary, DetailedSummaryCutoffs,
|
2019-03-01 03:55:07 +08:00
|
|
|
ShowAllFunctions, ShowCS, ValueCutoff,
|
|
|
|
OnlyListBelow, ShowFunction, TextFormat, OS);
|
2014-11-01 08:56:55 +08:00
|
|
|
else
|
|
|
|
return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
|
2020-05-02 23:34:10 +08:00
|
|
|
ShowDetailedSummary, ShowFunction,
|
Add --hot-func-list to llvm-profdata show for sample profiles
Summary:
Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.
Test Plan:
Reviewers: wenlei, hoyFB
Reviewed By: wenlei, hoyFB
Subscribers: hoyFB, wenlei, weihe, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D82355
2020-06-25 03:43:27 +08:00
|
|
|
ShowProfileSymbolList, ShowSectionInfoOnly,
|
|
|
|
ShowHotFuncList, OS);
|
2014-11-01 08:56:55 +08:00
|
|
|
}
|
|
|
|
|
2014-03-19 10:20:46 +08:00
|
|
|
int main(int argc, const char *argv[]) {
|
2018-04-14 02:26:06 +08:00
|
|
|
InitLLVM X(argc, argv);
|
2014-03-19 10:20:46 +08:00
|
|
|
|
|
|
|
StringRef ProgName(sys::path::filename(argv[0]));
|
|
|
|
if (argc > 1) {
|
2014-04-25 12:24:47 +08:00
|
|
|
int (*func)(int, const char *[]) = nullptr;
|
2014-03-19 10:20:46 +08:00
|
|
|
|
|
|
|
if (strcmp(argv[1], "merge") == 0)
|
|
|
|
func = merge_main;
|
2014-03-22 01:29:44 +08:00
|
|
|
else if (strcmp(argv[1], "show") == 0)
|
|
|
|
func = show_main;
|
2019-05-01 05:19:12 +08:00
|
|
|
else if (strcmp(argv[1], "overlap") == 0)
|
|
|
|
func = overlap_main;
|
2014-03-19 10:20:46 +08:00
|
|
|
|
|
|
|
if (func) {
|
|
|
|
std::string Invocation(ProgName.str() + " " + argv[1]);
|
|
|
|
argv[1] = Invocation.c_str();
|
|
|
|
return func(argc - 1, argv + 1);
|
|
|
|
}
|
|
|
|
|
2015-12-15 04:37:15 +08:00
|
|
|
if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
|
2014-03-19 10:20:46 +08:00
|
|
|
strcmp(argv[1], "--help") == 0) {
|
|
|
|
|
|
|
|
errs() << "OVERVIEW: LLVM profile data tools\n\n"
|
|
|
|
<< "USAGE: " << ProgName << " <command> [args...]\n"
|
|
|
|
<< "USAGE: " << ProgName << " <command> -help\n\n"
|
2016-08-04 07:10:51 +08:00
|
|
|
<< "See each individual command --help for more details.\n"
|
2019-05-01 05:19:12 +08:00
|
|
|
<< "Available commands: merge, show, overlap\n";
|
2014-03-19 10:20:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argc < 2)
|
|
|
|
errs() << ProgName << ": No command specified!\n";
|
|
|
|
else
|
|
|
|
errs() << ProgName << ": Unknown command!\n";
|
|
|
|
|
2019-05-01 05:19:12 +08:00
|
|
|
errs() << "USAGE: " << ProgName << " <merge|show|overlap> [args...]\n";
|
2014-03-19 10:20:46 +08:00
|
|
|
return 1;
|
|
|
|
}
|