LCOV - code coverage report
Current view: top level - include/llvm/ProfileData - SampleProfWriter.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 12 12 100.0 %
Date: 2018-06-17 00:07:59 Functions: 5 9 55.6 %
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          38 :   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             :   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          19 :       : 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          11 : 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          22 :       : SampleProfileWriter(OS), Indent(0) {}
      86             : 
      87             :   std::error_code
      88          11 :   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override {
      89          11 :     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           8 : class SampleProfileWriterBinary : public SampleProfileWriter {
     105             : public:
     106             :   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             :   std::error_code writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
     114             :   std::error_code writeSummary();
     115             :   std::error_code writeNameIdx(StringRef FName);
     116             :   std::error_code writeBody(const FunctionSamples &S);
     117             :   inline void stablizeNameTable(std::set<StringRef> &V);
     118             : 
     119             :   MapVector<StringRef, uint32_t> NameTable;
     120             : 
     121             : private:
     122             :   void addName(StringRef FName);
     123             :   void addNames(const FunctionSamples &S);
     124             : 
     125             :   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
     126             :   SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
     127             :                               SampleProfileFormat Format);
     128             : };
     129             : 
     130          14 : class SampleProfileWriterRawBinary : public SampleProfileWriterBinary {
     131           7 :   using SampleProfileWriterBinary::SampleProfileWriterBinary;
     132             : 
     133             : protected:
     134             :   virtual std::error_code writeNameTable() override;
     135             :   virtual std::error_code writeMagicIdent() override;
     136             : };
     137             : 
     138           2 : class SampleProfileWriterCompactBinary : public SampleProfileWriterBinary {
     139           1 :   using SampleProfileWriterBinary::SampleProfileWriterBinary;
     140             : 
     141             : protected:
     142             :   virtual std::error_code writeNameTable() override;
     143             :   virtual std::error_code writeMagicIdent() override;
     144             : };
     145             : 
     146             : } // end namespace sampleprof
     147             : } // end namespace llvm
     148             : 
     149             : #endif // LLVM_PROFILEDATA_SAMPLEPROFWRITER_H

Generated by: LCOV version 1.13