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
|
