include/llvm/ProfileData/SampleProfReader.h

   1 //===- SampleProfReader.h - 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 contains definitions needed for reading sample profiles.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #ifndef LLVM_PROFILEDATA_SAMPLEPROFREADER_H
  14 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H
  15
  16 #include "llvm/ADT/DenseMap.h"
  17 #include "llvm/IR/DiagnosticInfo.h"
  18 #include "llvm/IR/Function.h"
  19 #include "llvm/IR/LLVMContext.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/Twine.h"
  23 #include "llvm/ProfileData/SampleProf.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/ErrorOr.h"
  27 #include "llvm/Support/MemoryBuffer.h"
  28 #include "llvm/Support/raw_ostream.h"
  29
  30 namespace llvm {
  31
  32 namespace sampleprof {
  33
  34 /// \brief Sample-based profile reader.
  35 ///
  36 /// Each profile contains sample counts for all the functions
  37 /// executed. Inside each function, statements are annotated with the
  38 /// collected samples on all the instructions associated with that
  39 /// statement.
  40 ///
  41 /// For this to produce meaningful data, the program needs to be
  42 /// compiled with some debug information (at minimum, line numbers:
  43 /// -gline-tables-only). Otherwise, it will be impossible to match IR
  44 /// instructions to the line numbers collected by the profiler.
  45 ///
  46 /// From the profile file, we are interested in collecting the
  47 /// following information:
  48 ///
  49 /// * A list of functions included in the profile (mangled names).
  50 ///
  51 /// * For each function F:
  52 ///   1. The total number of samples collected in F.
  53 ///
  54 ///   2. The samples collected at each line in F. To provide some
  55 ///      protection against source code shuffling, line numbers should
  56 ///      be relative to the start of the function.
  57 ///
  58 /// The reader supports two file formats: text and binary. The text format
  59 /// is useful for debugging and testing, while the binary format is more
  60 /// compact. They can both be used interchangeably.
  61 class SampleProfileReader {
  62 public:
  63   SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
  64       : Profiles(0), Ctx(C), Buffer(std::move(B)) {}
  65
  66   virtual ~SampleProfileReader() {}
  67
  68   /// \brief Read and validate the file header.
  69   virtual std::error_code readHeader() = 0;
  70
  71   /// \brief Read sample profiles from the associated file.
  72   virtual std::error_code read() = 0;
  73
  74   /// \brief Print the profile for \p FName on stream \p OS.
  75   void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs());
  76
  77   /// \brief Print all the profiles on stream \p OS.
  78   void dump(raw_ostream &OS = dbgs());
  79
  80   /// \brief Return the samples collected for function \p F.
  81   FunctionSamples *getSamplesFor(const Function &F) {
  82     return &Profiles[F.getName()];
  83   }
  84
  85   /// \brief Return all the profiles.
  86   StringMap<FunctionSamples> &getProfiles() { return Profiles; }
  87
  88   /// \brief Report a parse error message.
  89   void reportParseError(int64_t LineNumber, Twine Msg) const {
  90     Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
  91                                              LineNumber, Msg));
  92   }
  93
  94   /// \brief Create a sample profile reader appropriate to the file format.
  95   static std::error_code create(StringRef Filename,
  96                                 std::unique_ptr<SampleProfileReader> &Reader,
  97                                 LLVMContext &C);
  98
  99 protected:
 100   /// \brief Map every function to its associated profile.
 101   ///
 102   /// The profile of every function executed at runtime is collected
 103   /// in the structure FunctionSamples. This maps function objects
 104   /// to their corresponding profiles.
 105   StringMap<FunctionSamples> Profiles;
 106
 107   /// \brief LLVM context used to emit diagnostics.
 108   LLVMContext &Ctx;
 109
 110   /// \brief Memory buffer holding the profile file.
 111   std::unique_ptr<MemoryBuffer> Buffer;
 112 };
 113
 114 class SampleProfileReaderText : public SampleProfileReader {
 115 public:
 116   SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
 117       : SampleProfileReader(std::move(B), C) {}
 118
 119   /// \brief Read and validate the file header.
 120   std::error_code readHeader() override { return sampleprof_error::success; }
 121
 122   /// \brief Read sample profiles from the associated file.
 123   std::error_code read() override;
 124 };
 125
 126 class SampleProfileReaderBinary : public SampleProfileReader {
 127 public:
 128   SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
 129       : SampleProfileReader(std::move(B), C), Data(nullptr), End(nullptr) {}
 130
 131   /// \brief Read and validate the file header.
 132   std::error_code readHeader() override;
 133
 134   /// \brief Read sample profiles from the associated file.
 135   std::error_code read() override;
 136
 137   /// \brief Return true if \p Buffer is in the format supported by this class.
 138   static bool hasFormat(const MemoryBuffer &Buffer);
 139
 140 protected:
 141   /// \brief Read a numeric value of type T from the profile.
 142   ///
 143   /// If an error occurs during decoding, a diagnostic message is emitted and
 144   /// EC is set.
 145   ///
 146   /// \returns the read value.
 147   template <typename T> ErrorOr<T> readNumber();
 148
 149   /// \brief Read a string from the profile.
 150   ///
 151   /// If an error occurs during decoding, a diagnostic message is emitted and
 152   /// EC is set.
 153   ///
 154   /// \returns the read value.
 155   ErrorOr<StringRef> readString();
 156
 157   /// \brief Return true if we've reached the end of file.
 158   bool at_eof() const { return Data >= End; }
 159
 160   /// \brief Points to the current location in the buffer.
 161   const uint8_t *Data;
 162
 163   /// \brief Points to the end of the buffer.
 164   const uint8_t *End;
 165 };
 166
 167 } // End namespace sampleprof
 168
 169 } // End namespace llvm
 170
 171 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H