RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity
09aff20364
llvm-mirror/unittests/ProfileData/SampleProfTest.cpp
Sergej Jaskiewicz 0975a7654a [llvm] [unittests] Remove temporary files after they're not needed 
Some LLVM unit tests forget to clean up temporary files and
directories. Introduce RAII classes for cleaning them up.

Refactor the tests to use those classes.

Differential Revision: https://reviews.llvm.org/D83228
2020-09-02 00:34:44 +03:00

533 lines
20 KiB
C++
Raw Blame History

//===- unittest/ProfileData/SampleProfTest.cpp ------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/ProfileData/SampleProf.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/ProfileData/SampleProfReader.h"
#include "llvm/ProfileData/SampleProfWriter.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Testing/Support/SupportHelpers.h"
#include "gtest/gtest.h"
#include <string>
#include <vector>
using namespace llvm;
using namespace sampleprof;
using llvm::unittest::TempFile;
static ::testing::AssertionResult NoError(std::error_code EC) {
if (!EC)
return ::testing::AssertionSuccess();
return ::testing::AssertionFailure() << "error " << EC.value() << ": "
<< EC.message();
}
namespace {
struct SampleProfTest : ::testing::Test {
LLVMContext Context;
std::unique_ptr<SampleProfileWriter> Writer;
std::unique_ptr<SampleProfileReader> Reader;
SampleProfTest() : Writer(), Reader() {}
void createWriter(SampleProfileFormat Format, StringRef Profile) {
std::error_code EC;
std::unique_ptr<raw_ostream> OS(
new raw_fd_ostream(Profile, EC, sys::fs::OF_None));
auto WriterOrErr = SampleProfileWriter::create(OS, Format);
ASSERT_TRUE(NoError(WriterOrErr.getError()));
Writer = std::move(WriterOrErr.get());
}
void readProfile(const Module &M, StringRef Profile,
StringRef RemapFile = "") {
auto ReaderOrErr = SampleProfileReader::create(
std::string(Profile), Context, std::string(RemapFile));
ASSERT_TRUE(NoError(ReaderOrErr.getError()));
Reader = std::move(ReaderOrErr.get());
Reader->collectFuncsFrom(M);
}
TempFile createRemapFile() {
return TempFile("remapfile", "", R"(
# Types 'int' and 'long' are equivalent
type i l
# Function names 'foo' and 'faux' are equivalent
name 3foo 4faux
)",
/*Unique*/ true);
}
// Verify profile summary is consistent in the roundtrip to and from
// Metadata. \p AddPartialField is to choose whether the Metadata
// contains the IsPartialProfile field which is optional.
void verifyProfileSummary(ProfileSummary &Summary, Module &M,
const bool AddPartialField,
const bool AddPartialProfileRatioField) {
LLVMContext &Context = M.getContext();
const bool IsPartialProfile = Summary.isPartialProfile();
const double PartialProfileRatio = Summary.getPartialProfileRatio();
auto VerifySummary = [IsPartialProfile, PartialProfileRatio](
ProfileSummary &Summary) mutable {
ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
ASSERT_EQ(138211u, Summary.getTotalCount());
ASSERT_EQ(10u, Summary.getNumCounts());
ASSERT_EQ(4u, Summary.getNumFunctions());
ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
ASSERT_EQ(60351u, Summary.getMaxCount());
ASSERT_EQ(IsPartialProfile, Summary.isPartialProfile());
ASSERT_EQ(PartialProfileRatio, Summary.getPartialProfileRatio());
uint32_t Cutoff = 800000;
auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
return PE.Cutoff == Cutoff;
};
std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
auto EightyPerc = find_if(Details, Predicate);
Cutoff = 900000;
auto NinetyPerc = find_if(Details, Predicate);
Cutoff = 950000;
auto NinetyFivePerc = find_if(Details, Predicate);
Cutoff = 990000;
auto NinetyNinePerc = find_if(Details, Predicate);
ASSERT_EQ(60000u, EightyPerc->MinCount);
ASSERT_EQ(12557u, NinetyPerc->MinCount);
ASSERT_EQ(12557u, NinetyFivePerc->MinCount);
ASSERT_EQ(600u, NinetyNinePerc->MinCount);
};
VerifySummary(Summary);
// Test that conversion of summary to and from Metadata works.
Metadata *MD =
Summary.getMD(Context, AddPartialField, AddPartialProfileRatioField);
ASSERT_TRUE(MD);
ProfileSummary *PS = ProfileSummary::getFromMD(MD);
ASSERT_TRUE(PS);
VerifySummary(*PS);
delete PS;
// Test that summary can be attached to and read back from module.
M.eraseNamedMetadata(M.getOrInsertModuleFlagsMetadata());
M.setProfileSummary(MD, ProfileSummary::PSK_Sample);
MD = M.getProfileSummary(/* IsCS */ false);
ASSERT_TRUE(MD);
PS = ProfileSummary::getFromMD(MD);
ASSERT_TRUE(PS);
VerifySummary(*PS);
delete PS;
}
void testRoundTrip(SampleProfileFormat Format, bool Remap, bool UseMD5) {
TempFile ProfileFile("profile", "", "", /*Unique*/ true);
createWriter(Format, ProfileFile.path());
if (Format == SampleProfileFormat::SPF_Ext_Binary && UseMD5)
static_cast<SampleProfileWriterExtBinary *>(Writer.get())->setUseMD5();
StringRef FooName("_Z3fooi");
FunctionSamples FooSamples;
FooSamples.setName(FooName);
FooSamples.addTotalSamples(7711);
FooSamples.addHeadSamples(610);
FooSamples.addBodySamples(1, 0, 610);
FooSamples.addBodySamples(2, 0, 600);
FooSamples.addBodySamples(4, 0, 60000);
FooSamples.addBodySamples(8, 0, 60351);
FooSamples.addBodySamples(10, 0, 605);
// Add inline instance with name "_Z3gooi".
StringRef GooName("_Z3gooi");
auto &GooSamples =
FooSamples.functionSamplesAt(LineLocation(7, 0))[GooName.str()];
GooSamples.setName(GooName);
GooSamples.addTotalSamples(502);
GooSamples.addBodySamples(3, 0, 502);
// Add inline instance with name "_Z3hooi".
StringRef HooName("_Z3hooi");
auto &HooSamples =
GooSamples.functionSamplesAt(LineLocation(9, 0))[HooName.str()];
HooSamples.setName(HooName);
HooSamples.addTotalSamples(317);
HooSamples.addBodySamples(4, 0, 317);
StringRef BarName("_Z3bari");
FunctionSamples BarSamples;
BarSamples.setName(BarName);
BarSamples.addTotalSamples(20301);
BarSamples.addHeadSamples(1437);
BarSamples.addBodySamples(1, 0, 1437);
// Test how reader/writer handles unmangled names.
StringRef MconstructName("_M_construct<char *>");
StringRef StringviewName("string_view<std::allocator<char> >");
BarSamples.addCalledTargetSamples(1, 0, MconstructName, 1000);
BarSamples.addCalledTargetSamples(1, 0, StringviewName, 437);
StringRef BazName("_Z3bazi");
FunctionSamples BazSamples;
BazSamples.setName(BazName);
BazSamples.addTotalSamples(12557);
BazSamples.addHeadSamples(1257);
BazSamples.addBodySamples(1, 0, 12557);
StringRef BooName("_Z3booi");
FunctionSamples BooSamples;
BooSamples.setName(BooName);
BooSamples.addTotalSamples(1232);
BooSamples.addHeadSamples(1);
BooSamples.addBodySamples(1, 0, 1232);
StringMap<FunctionSamples> Profiles;
Profiles[FooName] = std::move(FooSamples);
Profiles[BarName] = std::move(BarSamples);
Profiles[BazName] = std::move(BazSamples);
Profiles[BooName] = std::move(BooSamples);
Module M("my_module", Context);
FunctionType *fn_type =
FunctionType::get(Type::getVoidTy(Context), {}, false);
TempFile RemapFile(createRemapFile());
if (Remap) {
FooName = "_Z4fauxi";
BarName = "_Z3barl";
GooName = "_Z3gool";
HooName = "_Z3hool";
}
M.getOrInsertFunction(FooName, fn_type);
M.getOrInsertFunction(BarName, fn_type);
M.getOrInsertFunction(BooName, fn_type);
ProfileSymbolList List;
if (Format == SampleProfileFormat::SPF_Ext_Binary) {
List.add("zoo", true);
List.add("moo", true);
}
Writer->setProfileSymbolList(&List);
std::error_code EC;
EC = Writer->write(Profiles);
ASSERT_TRUE(NoError(EC));
Writer->getOutputStream().flush();
readProfile(M, ProfileFile.path(), RemapFile.path());
EC = Reader->read();
ASSERT_TRUE(NoError(EC));
if (Format == SampleProfileFormat::SPF_Ext_Binary) {
std::unique_ptr<ProfileSymbolList> ReaderList =
Reader->getProfileSymbolList();
ReaderList->contains("zoo");
ReaderList->contains("moo");
}
FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
ASSERT_TRUE(ReadFooSamples != nullptr);
if (!UseMD5) {
ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
}
ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
// Try to find a FunctionSamples with GooName at given callsites containing
// inline instance for GooName. Test the correct FunctionSamples can be
// found with Remapper support.
const FunctionSamples *ReadGooSamples =
ReadFooSamples->findFunctionSamplesAt(LineLocation(7, 0), GooName,
Reader->getRemapper());
ASSERT_TRUE(ReadGooSamples != nullptr);
ASSERT_EQ(502u, ReadGooSamples->getTotalSamples());
// Try to find a FunctionSamples with GooName at given callsites containing
// no inline instance for GooName. Test no FunctionSamples will be
// found with Remapper support.
const FunctionSamples *ReadGooSamplesAgain =
ReadFooSamples->findFunctionSamplesAt(LineLocation(9, 0), GooName,
Reader->getRemapper());
ASSERT_TRUE(ReadGooSamplesAgain == nullptr);
// The inline instance of Hoo is inside of the inline instance of Goo.
// Try to find a FunctionSamples with HooName at given callsites containing
// inline instance for HooName. Test the correct FunctionSamples can be
// found with Remapper support.
const FunctionSamples *ReadHooSamples =
ReadGooSamples->findFunctionSamplesAt(LineLocation(9, 0), HooName,
Reader->getRemapper());
ASSERT_TRUE(ReadHooSamples != nullptr);
ASSERT_EQ(317u, ReadHooSamples->getTotalSamples());
FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
ASSERT_TRUE(ReadBarSamples != nullptr);
if (!UseMD5) {
ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
}
ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
ErrorOr<SampleRecord::CallTargetMap> CTMap =
ReadBarSamples->findCallTargetMapAt(1, 0);
ASSERT_FALSE(CTMap.getError());
// Because _Z3bazi is not defined in module M, expect _Z3bazi's profile
// is not loaded when the profile is ExtBinary or Compact format because
// these formats support loading function profiles on demand.
FunctionSamples *ReadBazSamples = Reader->getSamplesFor(BazName);
if (Format == SampleProfileFormat::SPF_Ext_Binary ||
Format == SampleProfileFormat::SPF_Compact_Binary) {
ASSERT_TRUE(ReadBazSamples == nullptr);
ASSERT_EQ(3u, Reader->getProfiles().size());
} else {
ASSERT_TRUE(ReadBazSamples != nullptr);
ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
ASSERT_EQ(4u, Reader->getProfiles().size());
}
FunctionSamples *ReadBooSamples = Reader->getSamplesFor(BooName);
ASSERT_TRUE(ReadBooSamples != nullptr);
ASSERT_EQ(1232u, ReadBooSamples->getTotalSamples());
std::string MconstructGUID;
StringRef MconstructRep =
getRepInFormat(MconstructName, UseMD5, MconstructGUID);
std::string StringviewGUID;
StringRef StringviewRep =
getRepInFormat(StringviewName, UseMD5, StringviewGUID);
ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
ProfileSummary &Summary = Reader->getSummary();
Summary.setPartialProfile(true);
verifyProfileSummary(Summary, M, true, false);
Summary.setPartialProfile(false);
verifyProfileSummary(Summary, M, true, false);
verifyProfileSummary(Summary, M, false, false);
Summary.setPartialProfile(true);
Summary.setPartialProfileRatio(0.5);
verifyProfileSummary(Summary, M, true, true);
}
void addFunctionSamples(StringMap<FunctionSamples> *Smap, const char *Fname,
uint64_t TotalSamples, uint64_t HeadSamples) {
StringRef Name(Fname);
FunctionSamples FcnSamples;
FcnSamples.setName(Name);
FcnSamples.addTotalSamples(TotalSamples);
FcnSamples.addHeadSamples(HeadSamples);
FcnSamples.addBodySamples(1, 0, HeadSamples);
(*Smap)[Name] = FcnSamples;
}
StringMap<FunctionSamples> setupFcnSamplesForElisionTest(StringRef Policy) {
StringMap<FunctionSamples> Smap;
addFunctionSamples(&Smap, "foo", uint64_t(20301), uint64_t(1437));
if (Policy == "" || Policy == "all")
return Smap;
addFunctionSamples(&Smap, "foo.bar", uint64_t(20303), uint64_t(1439));
if (Policy == "selected")
return Smap;
addFunctionSamples(&Smap, "foo.llvm.2465", uint64_t(20305), uint64_t(1441));
return Smap;
}
void createFunctionWithSampleProfileElisionPolicy(Module *M,
const char *Fname,
StringRef Policy) {
FunctionType *FnType =
FunctionType::get(Type::getVoidTy(Context), {}, false);
auto Inserted = M->getOrInsertFunction(Fname, FnType);
auto Fcn = cast<Function>(Inserted.getCallee());
if (Policy != "")
Fcn->addFnAttr("sample-profile-suffix-elision-policy", Policy);
}
void setupModuleForElisionTest(Module *M, StringRef Policy) {
createFunctionWithSampleProfileElisionPolicy(M, "foo", Policy);
createFunctionWithSampleProfileElisionPolicy(M, "foo.bar", Policy);
createFunctionWithSampleProfileElisionPolicy(M, "foo.llvm.2465", Policy);
}
void testSuffixElisionPolicy(SampleProfileFormat Format, StringRef Policy,
const StringMap<uint64_t> &Expected) {
TempFile ProfileFile("profile", "", "", /*Unique*/ true);
Module M("my_module", Context);
setupModuleForElisionTest(&M, Policy);
StringMap<FunctionSamples> ProfMap = setupFcnSamplesForElisionTest(Policy);
// write profile
createWriter(Format, ProfileFile.path());
std::error_code EC;
EC = Writer->write(ProfMap);
ASSERT_TRUE(NoError(EC));
Writer->getOutputStream().flush();
// read profile
readProfile(M, ProfileFile.path());
EC = Reader->read();
ASSERT_TRUE(NoError(EC));
for (auto I = Expected.begin(); I != Expected.end(); ++I) {
uint64_t Esamples = uint64_t(-1);
FunctionSamples *Samples = Reader->getSamplesFor(I->getKey());
if (Samples != nullptr)
Esamples = Samples->getTotalSamples();
ASSERT_EQ(I->getValue(), Esamples);
}
}
};
TEST_F(SampleProfTest, roundtrip_text_profile) {
testRoundTrip(SampleProfileFormat::SPF_Text, false, false);
}
TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Binary, false, false);
}
TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false, true);
}
TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, false);
}
TEST_F(SampleProfTest, roundtrip_md5_ext_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, true);
}
TEST_F(SampleProfTest, remap_text_profile) {
testRoundTrip(SampleProfileFormat::SPF_Text, true, false);
}
TEST_F(SampleProfTest, remap_raw_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Binary, true, false);
}
TEST_F(SampleProfTest, remap_ext_binary_profile) {
testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, true, false);
}
TEST_F(SampleProfTest, sample_overflow_saturation) {
const uint64_t Max = std::numeric_limits<uint64_t>::max();
sampleprof_error Result;
FunctionSamples FooSamples;
Result = FooSamples.addTotalSamples(1);
ASSERT_EQ(Result, sampleprof_error::success);
Result = FooSamples.addHeadSamples(1);
ASSERT_EQ(Result, sampleprof_error::success);
Result = FooSamples.addBodySamples(10, 0, 1);
ASSERT_EQ(Result, sampleprof_error::success);
Result = FooSamples.addTotalSamples(Max);
ASSERT_EQ(Result, sampleprof_error::counter_overflow);
ASSERT_EQ(FooSamples.getTotalSamples(), Max);
Result = FooSamples.addHeadSamples(Max);
ASSERT_EQ(Result, sampleprof_error::counter_overflow);
ASSERT_EQ(FooSamples.getHeadSamples(), Max);
Result = FooSamples.addBodySamples(10, 0, Max);
ASSERT_EQ(Result, sampleprof_error::counter_overflow);
ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
ASSERT_FALSE(BodySamples.getError());
ASSERT_EQ(BodySamples.get(), Max);
}
TEST_F(SampleProfTest, default_suffix_elision_text) {
// Default suffix elision policy: strip everything after first dot.
// This implies that all suffix variants will map to "foo", so
// we don't expect to see any entries for them in the sample
// profile.
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(-1);
Expected["foo.llvm.2465"] = uint64_t(-1);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "", Expected);
}
TEST_F(SampleProfTest, default_suffix_elision_compact_binary) {
// Default suffix elision policy: strip everything after first dot.
// This implies that all suffix variants will map to "foo", so
// we don't expect to see any entries for them in the sample
// profile.
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(-1);
Expected["foo.llvm.2465"] = uint64_t(-1);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "",
Expected);
}
TEST_F(SampleProfTest, selected_suffix_elision_text) {
// Profile is created and searched using the "selected"
// suffix elision policy: we only strip a .XXX suffix if
// it matches a pattern known to be generated by the compiler
// (e.g. ".llvm.<digits>").
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(20303);
Expected["foo.llvm.2465"] = uint64_t(-1);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "selected", Expected);
}
TEST_F(SampleProfTest, selected_suffix_elision_compact_binary) {
// Profile is created and searched using the "selected"
// suffix elision policy: we only strip a .XXX suffix if
// it matches a pattern known to be generated by the compiler
// (e.g. ".llvm.<digits>").
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(20303);
Expected["foo.llvm.2465"] = uint64_t(-1);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "selected",
Expected);
}
TEST_F(SampleProfTest, none_suffix_elision_text) {
// Profile is created and searched using the "none"
// suffix elision policy: no stripping of suffixes at all.
// Here we expect to see all variants in the profile.
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(20303);
Expected["foo.llvm.2465"] = uint64_t(20305);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "none", Expected);
}
TEST_F(SampleProfTest, none_suffix_elision_compact_binary) {
// Profile is created and searched using the "none"
// suffix elision policy: no stripping of suffixes at all.
// Here we expect to see all variants in the profile.
StringMap<uint64_t> Expected;
Expected["foo"] = uint64_t(20301);
Expected["foo.bar"] = uint64_t(20303);
Expected["foo.llvm.2465"] = uint64_t(20305);
testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "none",
Expected);
}
} // end anonymous namespace
Reference in New Issue View Git Blame Copy Permalink