LLVM  3.7.0
SampleProfReader.cpp
Go to the documentation of this file.
1 //===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
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 // This file implements the class that reads LLVM sample profiles. It
11 // supports two file formats: text and binary. The textual representation
12 // is useful for debugging and testing purposes. The binary representation
13 // is more compact, resulting in smaller file sizes. However, they can
14 // both be used interchangeably.
15 //
16 // NOTE: If you are making changes to the file format, please remember
17 // to document them in the Clang documentation at
18 // tools/clang/docs/UsersManual.rst.
19 //
20 // Text format
21 // -----------
22 //
23 // Sample profiles are written as ASCII text. The file is divided into
24 // sections, which correspond to each of the functions executed at runtime.
25 // Each section has the following format
26 //
27 // function1:total_samples:total_head_samples
28 // offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ]
29 // offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ]
30 // ...
31 // offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ]
32 //
33 // The file may contain blank lines between sections and within a
34 // section. However, the spacing within a single line is fixed. Additional
35 // spaces will result in an error while reading the file.
36 //
37 // Function names must be mangled in order for the profile loader to
38 // match them in the current translation unit. The two numbers in the
39 // function header specify how many total samples were accumulated in the
40 // function (first number), and the total number of samples accumulated
41 // in the prologue of the function (second number). This head sample
42 // count provides an indicator of how frequently the function is invoked.
43 //
44 // Each sampled line may contain several items. Some are optional (marked
45 // below):
46 //
47 // a. Source line offset. This number represents the line number
48 // in the function where the sample was collected. The line number is
49 // always relative to the line where symbol of the function is
50 // defined. So, if the function has its header at line 280, the offset
51 // 13 is at line 293 in the file.
52 //
53 // Note that this offset should never be a negative number. This could
54 // happen in cases like macros. The debug machinery will register the
55 // line number at the point of macro expansion. So, if the macro was
56 // expanded in a line before the start of the function, the profile
57 // converter should emit a 0 as the offset (this means that the optimizers
58 // will not be able to associate a meaningful weight to the instructions
59 // in the macro).
60 //
61 // b. [OPTIONAL] Discriminator. This is used if the sampled program
62 // was compiled with DWARF discriminator support
63 // (http://wiki.dwarfstd.org/index.php?title=Path_Discriminators).
64 // DWARF discriminators are unsigned integer values that allow the
65 // compiler to distinguish between multiple execution paths on the
66 // same source line location.
67 //
68 // For example, consider the line of code ``if (cond) foo(); else bar();``.
69 // If the predicate ``cond`` is true 80% of the time, then the edge
70 // into function ``foo`` should be considered to be taken most of the
71 // time. But both calls to ``foo`` and ``bar`` are at the same source
72 // line, so a sample count at that line is not sufficient. The
73 // compiler needs to know which part of that line is taken more
74 // frequently.
75 //
76 // This is what discriminators provide. In this case, the calls to
77 // ``foo`` and ``bar`` will be at the same line, but will have
78 // different discriminator values. This allows the compiler to correctly
79 // set edge weights into ``foo`` and ``bar``.
80 //
81 // c. Number of samples. This is an integer quantity representing the
82 // number of samples collected by the profiler at this source
83 // location.
84 //
85 // d. [OPTIONAL] Potential call targets and samples. If present, this
86 // line contains a call instruction. This models both direct and
87 // number of samples. For example,
88 //
89 // 130: 7 foo:3 bar:2 baz:7
90 //
91 // The above means that at relative line offset 130 there is a call
92 // instruction that calls one of ``foo()``, ``bar()`` and ``baz()``,
93 // with ``baz()`` being the relatively more frequently called target.
94 //
95 //===----------------------------------------------------------------------===//
96 
98 #include "llvm/Support/Debug.h"
99 #include "llvm/Support/ErrorOr.h"
100 #include "llvm/Support/LEB128.h"
103 #include "llvm/Support/Regex.h"
104 
105 using namespace llvm::sampleprof;
106 using namespace llvm;
107 
108 /// \brief Print the samples collected for a function on stream \p OS.
109 ///
110 /// \param OS Stream to emit the output to.
112  OS << TotalSamples << ", " << TotalHeadSamples << ", " << BodySamples.size()
113  << " sampled lines\n";
114  for (const auto &SI : BodySamples) {
115  LineLocation Loc = SI.first;
116  const SampleRecord &Sample = SI.second;
117  OS << "\tline offset: " << Loc.LineOffset
118  << ", discriminator: " << Loc.Discriminator
119  << ", number of samples: " << Sample.getSamples();
120  if (Sample.hasCalls()) {
121  OS << ", calls:";
122  for (const auto &I : Sample.getCallTargets())
123  OS << " " << I.first() << ":" << I.second;
124  }
125  OS << "\n";
126  }
127  OS << "\n";
128 }
129 
130 /// \brief Dump the function profile for \p FName.
131 ///
132 /// \param FName Name of the function to print.
133 /// \param OS Stream to emit the output to.
135  raw_ostream &OS) {
136  OS << "Function: " << FName << ": ";
137  Profiles[FName].print(OS);
138 }
139 
140 /// \brief Dump all the function profiles found on stream \p OS.
142  for (const auto &I : Profiles)
143  dumpFunctionProfile(I.getKey(), OS);
144 }
145 
146 /// \brief Load samples from a text file.
147 ///
148 /// See the documentation at the top of the file for an explanation of
149 /// the expected format.
150 ///
151 /// \returns true if the file was loaded successfully, false otherwise.
152 std::error_code SampleProfileReaderText::read() {
153  line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
154 
155  // Read the profile of each function. Since each function may be
156  // mentioned more than once, and we are collecting flat profiles,
157  // accumulate samples as we parse them.
158  Regex HeadRE("^([^0-9].*):([0-9]+):([0-9]+)$");
159  Regex LineSampleRE("^([0-9]+)\\.?([0-9]+)?: ([0-9]+)(.*)$");
160  Regex CallSampleRE(" +([^0-9 ][^ ]*):([0-9]+)");
161  while (!LineIt.is_at_eof()) {
162  // Read the header of each function.
163  //
164  // Note that for function identifiers we are actually expecting
165  // mangled names, but we may not always get them. This happens when
166  // the compiler decides not to emit the function (e.g., it was inlined
167  // and removed). In this case, the binary will not have the linkage
168  // name for the function, so the profiler will emit the function's
169  // unmangled name, which may contain characters like ':' and '>' in its
170  // name (member functions, templates, etc).
171  //
172  // The only requirement we place on the identifier, then, is that it
173  // should not begin with a number.
175  if (!HeadRE.match(*LineIt, &Matches)) {
176  reportParseError(LineIt.line_number(),
177  "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
179  }
180  assert(Matches.size() == 4);
181  StringRef FName = Matches[1];
182  unsigned NumSamples, NumHeadSamples;
183  Matches[2].getAsInteger(10, NumSamples);
184  Matches[3].getAsInteger(10, NumHeadSamples);
185  Profiles[FName] = FunctionSamples();
186  FunctionSamples &FProfile = Profiles[FName];
187  FProfile.addTotalSamples(NumSamples);
188  FProfile.addHeadSamples(NumHeadSamples);
189  ++LineIt;
190 
191  // Now read the body. The body of the function ends when we reach
192  // EOF or when we see the start of the next function.
193  while (!LineIt.is_at_eof() && isdigit((*LineIt)[0])) {
194  if (!LineSampleRE.match(*LineIt, &Matches)) {
195  reportParseError(
196  LineIt.line_number(),
197  "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " + *LineIt);
199  }
200  assert(Matches.size() == 5);
201  unsigned LineOffset, NumSamples, Discriminator = 0;
202  Matches[1].getAsInteger(10, LineOffset);
203  if (Matches[2] != "")
204  Matches[2].getAsInteger(10, Discriminator);
205  Matches[3].getAsInteger(10, NumSamples);
206 
207  // If there are function calls in this line, generate a call sample
208  // entry for each call.
209  std::string CallsLine(Matches[4]);
210  while (CallsLine != "") {
211  SmallVector<StringRef, 3> CallSample;
212  if (!CallSampleRE.match(CallsLine, &CallSample)) {
213  reportParseError(LineIt.line_number(),
214  "Expected 'mangled_name:NUM', found " + CallsLine);
216  }
217  StringRef CalledFunction = CallSample[1];
218  unsigned CalledFunctionSamples;
219  CallSample[2].getAsInteger(10, CalledFunctionSamples);
220  FProfile.addCalledTargetSamples(LineOffset, Discriminator,
221  CalledFunction, CalledFunctionSamples);
222  CallsLine = CallSampleRE.sub("", CallsLine);
223  }
224 
225  FProfile.addBodySamples(LineOffset, Discriminator, NumSamples);
226  ++LineIt;
227  }
228  }
229 
231 }
232 
234  unsigned NumBytesRead = 0;
235  std::error_code EC;
236  uint64_t Val = decodeULEB128(Data, &NumBytesRead);
237 
238  if (Val > std::numeric_limits<T>::max())
240  else if (Data + NumBytesRead > End)
242  else
244 
245  if (EC) {
246  reportParseError(0, EC.message());
247  return EC;
248  }
249 
250  Data += NumBytesRead;
251  return static_cast<T>(Val);
252 }
253 
255  std::error_code EC;
256  StringRef Str(reinterpret_cast<const char *>(Data));
257  if (Data + Str.size() + 1 > End) {
259  reportParseError(0, EC.message());
260  return EC;
261  }
262 
263  Data += Str.size() + 1;
264  return Str;
265 }
266 
268  while (!at_eof()) {
269  auto FName(readString());
270  if (std::error_code EC = FName.getError())
271  return EC;
272 
273  Profiles[*FName] = FunctionSamples();
274  FunctionSamples &FProfile = Profiles[*FName];
275 
276  auto Val = readNumber<unsigned>();
277  if (std::error_code EC = Val.getError())
278  return EC;
279  FProfile.addTotalSamples(*Val);
280 
281  Val = readNumber<unsigned>();
282  if (std::error_code EC = Val.getError())
283  return EC;
284  FProfile.addHeadSamples(*Val);
285 
286  // Read the samples in the body.
287  auto NumRecords = readNumber<unsigned>();
288  if (std::error_code EC = NumRecords.getError())
289  return EC;
290  for (unsigned I = 0; I < *NumRecords; ++I) {
291  auto LineOffset = readNumber<uint64_t>();
292  if (std::error_code EC = LineOffset.getError())
293  return EC;
294 
295  auto Discriminator = readNumber<uint64_t>();
296  if (std::error_code EC = Discriminator.getError())
297  return EC;
298 
299  auto NumSamples = readNumber<uint64_t>();
300  if (std::error_code EC = NumSamples.getError())
301  return EC;
302 
303  auto NumCalls = readNumber<unsigned>();
304  if (std::error_code EC = NumCalls.getError())
305  return EC;
306 
307  for (unsigned J = 0; J < *NumCalls; ++J) {
308  auto CalledFunction(readString());
309  if (std::error_code EC = CalledFunction.getError())
310  return EC;
311 
312  auto CalledFunctionSamples = readNumber<uint64_t>();
313  if (std::error_code EC = CalledFunctionSamples.getError())
314  return EC;
315 
316  FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
317  *CalledFunction,
318  *CalledFunctionSamples);
319  }
320 
321  FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
322  }
323  }
324 
326 }
327 
329  Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
330  End = Data + Buffer->getBufferSize();
331 
332  // Read and check the magic identifier.
333  auto Magic = readNumber<uint64_t>();
334  if (std::error_code EC = Magic.getError())
335  return EC;
336  else if (*Magic != SPMagic())
338 
339  // Read the version number.
340  auto Version = readNumber<uint64_t>();
341  if (std::error_code EC = Version.getError())
342  return EC;
343  else if (*Version != SPVersion())
345 
347 }
348 
350  const uint8_t *Data =
351  reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
352  uint64_t Magic = decodeULEB128(Data);
353  return Magic == SPMagic();
354 }
355 
356 /// \brief Prepare a memory buffer for the contents of \p Filename.
357 ///
358 /// \returns an error code indicating the status of the buffer.
360 setupMemoryBuffer(std::string Filename) {
361  auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
362  if (std::error_code EC = BufferOrErr.getError())
363  return EC;
364  auto Buffer = std::move(BufferOrErr.get());
365 
366  // Sanity check the file.
367  if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
369 
370  return std::move(Buffer);
371 }
372 
373 /// \brief Create a sample profile reader based on the format of the input file.
374 ///
375 /// \param Filename The file to open.
376 ///
377 /// \param Reader The reader to instantiate according to \p Filename's format.
378 ///
379 /// \param C The LLVM context to use to emit diagnostics.
380 ///
381 /// \returns an error code indicating the status of the created reader.
384  auto BufferOrError = setupMemoryBuffer(Filename);
385  if (std::error_code EC = BufferOrError.getError())
386  return EC;
387 
388  auto Buffer = std::move(BufferOrError.get());
389  std::unique_ptr<SampleProfileReader> Reader;
391  Reader.reset(new SampleProfileReaderBinary(std::move(Buffer), C));
392  else
393  Reader.reset(new SampleProfileReaderText(std::move(Buffer), C));
394 
395  if (std::error_code EC = Reader->readHeader())
396  return EC;
397 
398  return std::move(Reader);
399 }
Represents either an error or a value T.
Definition: ErrorOr.h:82
void addBodySamples(int LineOffset, unsigned Discriminator, unsigned Num)
Definition: SampleProf.h:173
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
const char * getBufferStart() const
Definition: MemoryBuffer.h:50
int64_t line_number() const
Return the current line number. May return any number at EOF.
Definition: LineIterator.h:56
std::error_code read() override
Read sample profiles from the associated file.
void print(raw_ostream &OS=dbgs())
Print the samples collected for a function on stream OS.
std::error_code readHeader() override
Read and validate the file header.
void addTotalSamples(unsigned Num)
Definition: SampleProf.h:171
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:32
const CallTargetMap & getCallTargets() const
Definition: SampleProf.h:146
Representation of the samples collected for a function.
Definition: SampleProf.h:167
static ErrorOr< std::unique_ptr< MemoryBuffer > > setupMemoryBuffer(std::string Filename)
Prepare a memory buffer for the contents of Filename.
Representation of a single sample record.
Definition: SampleProf.h:113
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
void addHeadSamples(unsigned Num)
Definition: SampleProf.h:172
static ErrorOr< std::unique_ptr< SampleProfileReader > > create(StringRef Filename, LLVMContext &C)
Create a sample profile reader appropriate to the file format.
static uint64_t SPVersion()
Definition: SampleProf.h:60
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:80
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
ErrorOr< T > readNumber()
Read a numeric value of type T from the profile.
ErrorOr< StringRef > readString()
Read a string from the profile.
std::string sub(StringRef Repl, StringRef String, std::string *Error=nullptr)
sub - Return the result of replacing the first match of the regex in String with the Repl string...
Definition: Regex.cpp:98
void dumpFunctionProfile(StringRef FName, raw_ostream &OS=dbgs())
Print the profile for FName on stream OS.
static const char *const Magic
Definition: Archive.cpp:26
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, int64_t FileSize=-1)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:37
bool hasCalls() const
Return true if this sample record contains function calls.
Definition: SampleProf.h:143
static uint64_t SPMagic()
Definition: SampleProf.h:53
Represents the relative location of an instruction.
Definition: SampleProf.h:71
#define I(x, y, z)
Definition: MD5.cpp:54
unsigned getSamples() const
Definition: SampleProf.h:145
Provides ErrorOr<T> smart pointer.
bool is_at_eof() const
Return true if we've reached EOF or are an "end" iterator.
Definition: LineIterator.h:50
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr)
matches - Match the regex against a given String.
Definition: Regex.cpp:59
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
void dump(raw_ostream &OS=dbgs())
Print all the profiles on stream OS.
std::error_code read() override
Read sample profiles from the associated file.
void addCalledTargetSamples(int LineOffset, unsigned Discriminator, std::string FName, unsigned Num)
Definition: SampleProf.h:183