1 //===- llvm/unittests/tools/llvm-profdata/OutputSizeLimitTest.cpp ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/ProfileData/SampleProfReader.h"
10 #include "llvm/ProfileData/SampleProfWriter.h"
11 #include "llvm/Support/FileSystem.h"
12 #include "llvm/Support/VirtualFileSystem.h"
13 #include "llvm/Testing/Support/Error.h"
14 #include "gtest/gtest.h"
15
16 using namespace llvm;
17 using llvm::unittest::TempFile;
18
19 std::string Input1 = R"(main:184019:0
20 4: 534
21 4.2: 534
22 5: 1075
23 5.1: 1075
24 6: 2080
25 7: 534
26 9: 2064 _Z3bari:1471 _Z3fooi:631
27 10: inline1:1000
28 1: 1000
29 10: inline2:2000
30 1: 2000
31 _Z3bari:20301:1437
32 1: 1437
33 _Z3fooi:7711:610
34 1: 610)";
35
36 const char EmptyProfile[18] = "\xff\xe5\xd0\xb1\xf4\xc9\x94\xa8\x53\x67";
37
38 /// sys::fs and SampleProf mix Error and error_code, making an adapter class
39 /// to keep code elegant.
40 template <typename T> class ExpectedErrorOr : public Expected<T> {
41 public:
ExpectedErrorOr(T && Obj)42 ExpectedErrorOr(T &&Obj) : Expected<T>(Obj) {}
43
ExpectedErrorOr(std::error_code EC)44 ExpectedErrorOr(std::error_code EC) : Expected<T>(errorCodeToError(EC)) {}
45
ExpectedErrorOr(Error && E)46 ExpectedErrorOr(Error &&E) : Expected<T>(std::move(E)) {}
47
48 template <typename U>
ExpectedErrorOr(ErrorOr<U> && E)49 ExpectedErrorOr(ErrorOr<U> &&E)
50 : Expected<T>(errorCodeToError(E.getError())) {}
51
52 template <typename U>
ExpectedErrorOr(Expected<U> && E)53 ExpectedErrorOr(Expected<U> &&E) : Expected<T>(E.takeError()) {}
54 };
55
56 #define DEF_VAR_RETURN_IF_ERROR(Var, Value) \
57 auto Var##OrErr = Value; \
58 if (!Var##OrErr) \
59 return Var##OrErr; \
60 auto Var = std::move(Var##OrErr.get())
61
62 #define VAR_RETURN_IF_ERROR(Var, Value) \
63 Var##OrErr = Value; \
64 if (!Var##OrErr) \
65 return Var##OrErr; \
66 Var = std::move(Var##OrErr.get())
67
68 #define RETURN_IF_ERROR(Value) \
69 if (auto E = Value) \
70 return std::move(E)
71
72 /// The main testing routine. After rewriting profiles with size limit, check
73 /// the following:
74 /// 1. The file size of the new profile is within the size limit.
75 /// 2. The new profile is a subset of the old profile, and the content of every
76 /// sample in the new profile is unchanged.
77 /// Note that even though by default samples with fewest total count are dropped
78 /// first, this is not a requirement. Samples can be dropped by any order.
RunTest(StringRef Input,size_t SizeLimit,SampleProfileFormat Format,bool Compress=false)79 static ExpectedErrorOr<void *> RunTest(StringRef Input, size_t SizeLimit,
80 SampleProfileFormat Format,
81 bool Compress = false) {
82 // Read Input profile.
83 auto FS = vfs::getRealFileSystem();
84 LLVMContext Context;
85 auto InputBuffer = MemoryBuffer::getMemBuffer(Input);
86 DEF_VAR_RETURN_IF_ERROR(
87 Reader, SampleProfileReader::create(InputBuffer, Context, *FS));
88 RETURN_IF_ERROR(Reader->read());
89 SampleProfileMap OldProfiles = Reader->getProfiles();
90
91 // Rewrite it to a temp file with size limit.
92 TempFile Temp("profile", "afdo", "", true);
93 bool isEmpty = false;
94 {
95 DEF_VAR_RETURN_IF_ERROR(Writer,
96 SampleProfileWriter::create(Temp.path(), Format));
97 if (Compress)
98 Writer->setToCompressAllSections();
99 std::error_code EC = Writer->writeWithSizeLimit(OldProfiles, SizeLimit);
100 // too_large means no sample could be written because SizeLimit is too
101 // small. Otherwise any other error code indicates unexpected failure.
102 if (EC == sampleprof_error::too_large)
103 isEmpty = true;
104 else if (EC)
105 return EC;
106 }
107
108 // Read the temp file to get new profiles. Use the default empty profile if
109 // temp file was not written because size limit is too small.
110 SampleProfileMap NewProfiles;
111 InputBuffer = MemoryBuffer::getMemBuffer(StringRef(EmptyProfile, 17));
112 DEF_VAR_RETURN_IF_ERROR(
113 NewReader, SampleProfileReader::create(InputBuffer, Context, *FS));
114 if (!isEmpty) {
115 VAR_RETURN_IF_ERROR(NewReader, SampleProfileReader::create(
116 Temp.path().str(), Context, *FS));
117 RETURN_IF_ERROR(NewReader->read());
118 NewProfiles = NewReader->getProfiles();
119 }
120
121 // Check temp file is actually within size limit.
122 uint64_t FileSize;
123 RETURN_IF_ERROR(sys::fs::file_size(Temp.path(), FileSize));
124 EXPECT_LE(FileSize, SizeLimit);
125
126 // For every sample in the new profile, confirm it is in the old profile and
127 // unchanged.
128 for (auto Sample : NewProfiles) {
129 auto FindResult = OldProfiles.find(Sample.second.getContext());
130 EXPECT_NE(FindResult, OldProfiles.end());
131 if (FindResult != OldProfiles.end()) {
132 EXPECT_EQ(Sample.second.getHeadSamples(),
133 FindResult->second.getHeadSamples());
134 EXPECT_EQ(Sample.second, FindResult->second);
135 }
136 }
137 return nullptr;
138 }
139
TEST(TestOutputSizeLimit,TestOutputSizeLimitExtBinary)140 TEST(TestOutputSizeLimit, TestOutputSizeLimitExtBinary) {
141 for (size_t OutputSizeLimit : {490, 489, 488, 475, 474, 459, 400})
142 ASSERT_THAT_EXPECTED(
143 RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Ext_Binary),
144 Succeeded());
145 }
146
TEST(TestOutputSizeLimit,TestOutputSizeLimitBinary)147 TEST(TestOutputSizeLimit, TestOutputSizeLimitBinary) {
148 for (size_t OutputSizeLimit : {250, 249, 248, 237, 236, 223, 200})
149 ASSERT_THAT_EXPECTED(
150 RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Binary),
151 Succeeded());
152 }
153
TEST(TestOutputSizeLimit,TestOutputSizeLimitText)154 TEST(TestOutputSizeLimit, TestOutputSizeLimitText) {
155 for (size_t OutputSizeLimit :
156 {229, 228, 227, 213, 212, 211, 189, 188, 187, 186, 150})
157 ASSERT_THAT_EXPECTED(
158 RunTest(Input1, OutputSizeLimit, llvm::sampleprof::SPF_Text),
159 Succeeded());
160 }
161
162 #if LLVM_ENABLE_ZLIB
TEST(TestOutputSizeLimit,TestOutputSizeLimitExtBinaryCompressed)163 TEST(TestOutputSizeLimit, TestOutputSizeLimitExtBinaryCompressed) {
164 for (size_t OutputSizeLimit :
165 {507, 506, 505, 494, 493, 492, 483, 482, 481, 480})
166 ASSERT_THAT_EXPECTED(RunTest(Input1, OutputSizeLimit,
167 llvm::sampleprof::SPF_Ext_Binary, true),
168 Succeeded());
169 }
170 #endif
171