1 //===- unittest/ProfileData/SampleProfTest.cpp ------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ProfileData/SampleProf.h"
11 #include "llvm/ADT/StringMap.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/IR/LLVMContext.h"
14 #include "llvm/IR/Metadata.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/ProfileData/SampleProfReader.h"
17 #include "llvm/ProfileData/SampleProfWriter.h"
18 #include "llvm/Support/Casting.h"
19 #include "llvm/Support/ErrorOr.h"
20 #include "llvm/Support/MemoryBuffer.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include "gtest/gtest.h"
23 #include <string>
24 #include <vector>
25 
26 using namespace llvm;
27 using namespace sampleprof;
28 
29 static ::testing::AssertionResult NoError(std::error_code EC) {
30   if (!EC)
31     return ::testing::AssertionSuccess();
32   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
33                                        << EC.message();
34 }
35 
36 namespace {
37 
38 struct SampleProfTest : ::testing::Test {
39   std::string Data;
40   LLVMContext Context;
41   std::unique_ptr<raw_ostream> OS;
42   std::unique_ptr<SampleProfileWriter> Writer;
43   std::unique_ptr<SampleProfileReader> Reader;
44 
45   SampleProfTest()
46       : Data(), OS(new raw_string_ostream(Data)), Writer(), Reader() {}
47 
48   void createWriter(SampleProfileFormat Format) {
49     auto WriterOrErr = SampleProfileWriter::create(OS, Format);
50     ASSERT_TRUE(NoError(WriterOrErr.getError()));
51     Writer = std::move(WriterOrErr.get());
52   }
53 
54   void readProfile(std::unique_ptr<MemoryBuffer> &Profile) {
55     auto ReaderOrErr = SampleProfileReader::create(Profile, Context);
56     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
57     Reader = std::move(ReaderOrErr.get());
58   }
59 
60   void testRoundTrip(SampleProfileFormat Format) {
61     createWriter(Format);
62 
63     StringRef FooName("_Z3fooi");
64     FunctionSamples FooSamples;
65     FooSamples.setName(FooName);
66     FooSamples.addTotalSamples(7711);
67     FooSamples.addHeadSamples(610);
68     FooSamples.addBodySamples(1, 0, 610);
69     FooSamples.addBodySamples(2, 0, 600);
70     FooSamples.addBodySamples(4, 0, 60000);
71     FooSamples.addBodySamples(8, 0, 60351);
72     FooSamples.addBodySamples(10, 0, 605);
73 
74     StringRef BarName("_Z3bari");
75     FunctionSamples BarSamples;
76     BarSamples.setName(BarName);
77     BarSamples.addTotalSamples(20301);
78     BarSamples.addHeadSamples(1437);
79     BarSamples.addBodySamples(1, 0, 1437);
80 
81     StringMap<FunctionSamples> Profiles;
82     Profiles[FooName] = std::move(FooSamples);
83     Profiles[BarName] = std::move(BarSamples);
84 
85     std::error_code EC;
86     EC = Writer->write(Profiles);
87     ASSERT_TRUE(NoError(EC));
88 
89     Writer->getOutputStream().flush();
90 
91     auto Profile = MemoryBuffer::getMemBufferCopy(Data);
92     readProfile(Profile);
93 
94     EC = Reader->read();
95     ASSERT_TRUE(NoError(EC));
96 
97     StringMap<FunctionSamples> &ReadProfiles = Reader->getProfiles();
98     ASSERT_EQ(2u, ReadProfiles.size());
99 
100     FunctionSamples &ReadFooSamples = ReadProfiles[FooName];
101     ASSERT_EQ(7711u, ReadFooSamples.getTotalSamples());
102     ASSERT_EQ(610u, ReadFooSamples.getHeadSamples());
103 
104     FunctionSamples &ReadBarSamples = ReadProfiles[BarName];
105     ASSERT_EQ(20301u, ReadBarSamples.getTotalSamples());
106     ASSERT_EQ(1437u, ReadBarSamples.getHeadSamples());
107 
108     auto VerifySummary = [](ProfileSummary &Summary) mutable {
109       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
110       ASSERT_EQ(123603u, Summary.getTotalCount());
111       ASSERT_EQ(6u, Summary.getNumCounts());
112       ASSERT_EQ(2u, Summary.getNumFunctions());
113       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
114       ASSERT_EQ(60351u, Summary.getMaxCount());
115 
116       uint32_t Cutoff = 800000;
117       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
118         return PE.Cutoff == Cutoff;
119       };
120       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
121       auto EightyPerc = find_if(Details, Predicate);
122       Cutoff = 900000;
123       auto NinetyPerc = find_if(Details, Predicate);
124       Cutoff = 950000;
125       auto NinetyFivePerc = find_if(Details, Predicate);
126       Cutoff = 990000;
127       auto NinetyNinePerc = find_if(Details, Predicate);
128       ASSERT_EQ(60000u, EightyPerc->MinCount);
129       ASSERT_EQ(60000u, NinetyPerc->MinCount);
130       ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
131       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
132     };
133 
134     ProfileSummary &Summary = Reader->getSummary();
135     VerifySummary(Summary);
136 
137     // Test that conversion of summary to and from Metadata works.
138     Metadata *MD = Summary.getMD(Context);
139     ASSERT_TRUE(MD);
140     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
141     ASSERT_TRUE(PS);
142     VerifySummary(*PS);
143     delete PS;
144 
145     // Test that summary can be attached to and read back from module.
146     Module M("my_module", Context);
147     M.setProfileSummary(MD);
148     MD = M.getProfileSummary();
149     ASSERT_TRUE(MD);
150     PS = ProfileSummary::getFromMD(MD);
151     ASSERT_TRUE(PS);
152     VerifySummary(*PS);
153     delete PS;
154   }
155 };
156 
157 TEST_F(SampleProfTest, roundtrip_text_profile) {
158   testRoundTrip(SampleProfileFormat::SPF_Text);
159 }
160 
161 TEST_F(SampleProfTest, roundtrip_binary_profile) {
162   testRoundTrip(SampleProfileFormat::SPF_Binary);
163 }
164 
165 TEST_F(SampleProfTest, sample_overflow_saturation) {
166   const uint64_t Max = std::numeric_limits<uint64_t>::max();
167   sampleprof_error Result;
168 
169   StringRef FooName("_Z3fooi");
170   FunctionSamples FooSamples;
171   Result = FooSamples.addTotalSamples(1);
172   ASSERT_EQ(Result, sampleprof_error::success);
173 
174   Result = FooSamples.addHeadSamples(1);
175   ASSERT_EQ(Result, sampleprof_error::success);
176 
177   Result = FooSamples.addBodySamples(10, 0, 1);
178   ASSERT_EQ(Result, sampleprof_error::success);
179 
180   Result = FooSamples.addTotalSamples(Max);
181   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
182   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
183 
184   Result = FooSamples.addHeadSamples(Max);
185   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
186   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
187 
188   Result = FooSamples.addBodySamples(10, 0, Max);
189   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
190   ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
191   ASSERT_FALSE(BodySamples.getError());
192   ASSERT_EQ(BodySamples.get(), Max);
193 }
194 
195 } // end anonymous namespace
196