LCOV - code coverage report
Current view: top level - include/llvm/ProfileData - SampleProfWriter.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 7 7 100.0 %
Date: 2018-10-14 09:39:32 Functions: 2 3 66.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- SampleProfWriter.h - Write LLVM sample profile data ------*- 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             : // This file contains definitions needed for writing sample profiles.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : #ifndef LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
      14             : #define LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
      15             : 
      16             : #include "llvm/ADT/MapVector.h"
      17             : #include "llvm/ADT/StringMap.h"
      18             : #include "llvm/ADT/StringRef.h"
      19             : #include "llvm/IR/ProfileSummary.h"
      20             : #include "llvm/ProfileData/SampleProf.h"
      21             : #include "llvm/Support/ErrorOr.h"
      22             : #include "llvm/Support/raw_ostream.h"
      23             : #include <algorithm>
      24             : #include <cstdint>
      25             : #include <memory>
      26             : #include <set>
      27             : #include <system_error>
      28             : 
      29             : namespace llvm {
      30             : namespace sampleprof {
      31             : 
      32             : /// Sample-based profile writer. Base class.
      33             : class SampleProfileWriter {
      34             : public:
      35          22 :   virtual ~SampleProfileWriter() = default;
      36             : 
      37             :   /// Write sample profiles in \p S.
      38             :   ///
      39             :   /// \returns status code of the file update operation.
      40             :   virtual std::error_code write(const FunctionSamples &S) = 0;
      41             : 
      42             :   /// Write all the sample profiles in the given map of samples.
      43             :   ///
      44             :   /// \returns status code of the file update operation.
      45             :   virtual std::error_code write(const StringMap<FunctionSamples> &ProfileMap);
      46             : 
      47             :   raw_ostream &getOutputStream() { return *OutputStream; }
      48             : 
      49             :   /// Profile writer factory.
      50             :   ///
      51             :   /// Create a new file writer based on the value of \p Format.
      52             :   static ErrorOr<std::unique_ptr<SampleProfileWriter>>
      53             :   create(StringRef Filename, SampleProfileFormat Format);
      54             : 
      55             :   /// Create a new stream writer based on the value of \p Format.
      56             :   /// For testing.
      57             :   static ErrorOr<std::unique_ptr<SampleProfileWriter>>
      58             :   create(std::unique_ptr<raw_ostream> &OS, SampleProfileFormat Format);
      59             : 
      60             : protected:
      61             :   SampleProfileWriter(std::unique_ptr<raw_ostream> &OS)
      62          21 :       : OutputStream(std::move(OS)) {}
      63             : 
      64             :   /// Write a file header for the profile file.
      65             :   virtual std::error_code
      66             :   writeHeader(const StringMap<FunctionSamples> &ProfileMap) = 0;
      67             : 
      68             :   /// Output stream where to emit the profile to.
      69             :   std::unique_ptr<raw_ostream> OutputStream;
      70             : 
      71             :   /// Profile summary.
      72             :   std::unique_ptr<ProfileSummary> Summary;
      73             : 
      74             :   /// Compute summary for this profile.
      75             :   void computeSummary(const StringMap<FunctionSamples> &ProfileMap);
      76             : };
      77             : 
      78             : /// Sample-based profile writer (text format).
      79             : class SampleProfileWriterText : public SampleProfileWriter {
      80             : public:
      81             :   std::error_code write(const FunctionSamples &S) override;
      82             : 
      83             : protected:
      84             :   SampleProfileWriterText(std::unique_ptr<raw_ostream> &OS)
      85          26 :       : SampleProfileWriter(OS), Indent(0) {}
      86             : 
      87             :   std::error_code
      88          13 :   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override {
      89          13 :     return sampleprof_error::success;
      90             :   }
      91             : 
      92             : private:
      93             :   /// Indent level to use when writing.
      94             :   ///
      95             :   /// This is used when printing inlined callees.
      96             :   unsigned Indent;
      97             : 
      98             :   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
      99             :   SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
     100             :                               SampleProfileFormat Format);
     101             : };
     102             : 
     103             : /// Sample-based profile writer (binary format).
     104             : class SampleProfileWriterBinary : public SampleProfileWriter {
     105             : public:
     106             :   virtual std::error_code write(const FunctionSamples &S) override;
     107             :   SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
     108          16 :       : SampleProfileWriter(OS) {}
     109             : 
     110             : protected:
     111             :   virtual std::error_code writeNameTable() = 0;
     112             :   virtual std::error_code writeMagicIdent() = 0;
     113             :   virtual std::error_code
     114             :   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
     115             :   std::error_code writeSummary();
     116             :   std::error_code writeNameIdx(StringRef FName);
     117             :   std::error_code writeBody(const FunctionSamples &S);
     118             :   inline void stablizeNameTable(std::set<StringRef> &V);
     119             : 
     120             :   MapVector<StringRef, uint32_t> NameTable;
     121             : 
     122             : private:
     123             :   void addName(StringRef FName);
     124             :   void addNames(const FunctionSamples &S);
     125             : 
     126             :   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
     127             :   SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
     128             :                               SampleProfileFormat Format);
     129             : };
     130             : 
     131             : class SampleProfileWriterRawBinary : public SampleProfileWriterBinary {
     132           8 :   using SampleProfileWriterBinary::SampleProfileWriterBinary;
     133             : 
     134             : protected:
     135             :   virtual std::error_code writeNameTable() override;
     136             :   virtual std::error_code writeMagicIdent() override;
     137             : };
     138             : 
     139             : // CompactBinary is a compact format of binary profile which both reduces
     140             : // the profile size and the load time needed when compiling. It has two
     141             : // major difference with Binary format.
     142             : // 1. It represents all the strings in name table using md5 hash.
     143             : // 2. It saves a function offset table which maps function name index to
     144             : // the offset of its function profile to the start of the binary profile,
     145             : // so by using the function offset table, for those function profiles which
     146             : // will not be needed when compiling a module, the profile reader does't
     147             : // have to read them and it saves compile time if the profile size is huge.
     148             : // The layout of the compact format is shown as follows:
     149             : //
     150             : //    Part1: Profile header, the same as binary format, containing magic
     151             : //           number, version, summary, name table...
     152             : //    Part2: Function Offset Table Offset, which saves the position of
     153             : //           Part4.
     154             : //    Part3: Function profile collection
     155             : //             function1 profile start
     156             : //                 ....
     157             : //             function2 profile start
     158             : //                 ....
     159             : //             function3 profile start
     160             : //                 ....
     161             : //                ......
     162             : //    Part4: Function Offset Table
     163             : //             function1 name index --> function1 profile start
     164             : //             function2 name index --> function2 profile start
     165             : //             function3 name index --> function3 profile start
     166             : //
     167             : // We need Part2 because profile reader can use it to find out and read
     168             : // function offset table without reading Part3 first.
     169             : class SampleProfileWriterCompactBinary : public SampleProfileWriterBinary {
     170             :   using SampleProfileWriterBinary::SampleProfileWriterBinary;
     171             : 
     172             : public:
     173             :   virtual std::error_code write(const FunctionSamples &S) override;
     174             :   virtual std::error_code
     175             :   write(const StringMap<FunctionSamples> &ProfileMap) override;
     176             : 
     177             : protected:
     178             :   /// The table mapping from function name to the offset of its FunctionSample
     179             :   /// towards profile start.
     180             :   MapVector<StringRef, uint64_t> FuncOffsetTable;
     181             :   /// The offset of the slot to be filled with the offset of FuncOffsetTable
     182             :   /// towards profile start.
     183             :   uint64_t TableOffset;
     184             :   virtual std::error_code writeNameTable() override;
     185             :   virtual std::error_code writeMagicIdent() override;
     186             :   virtual std::error_code
     187             :   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
     188             :   std::error_code writeFuncOffsetTable();
     189             : };
     190             : 
     191             : } // end namespace sampleprof
     192             : } // end namespace llvm
     193             : 
     194             : #endif // LLVM_PROFILEDATA_SAMPLEPROFWRITER_H

Generated by: LCOV version 1.13