1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SIMPLE_PERF_RECORD_FILE_H_
#define SIMPLE_PERF_RECORD_FILE_H_
#include <stdio.h>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <android-base/macros.h>
#include "event_attr.h"
#include "perf_event.h"
#include "record.h"
#include "record_file_format.h"
// RecordFileWriter writes to a perf record file, like perf.data.
class RecordFileWriter {
public:
static std::unique_ptr<RecordFileWriter> CreateInstance(const std::string& filename);
~RecordFileWriter();
bool WriteAttrSection(const std::vector<EventAttrWithId>& attr_ids);
bool WriteRecord(const Record& record);
bool SortDataSection();
bool WriteFeatureHeader(size_t feature_count);
bool WriteBuildIdFeature(const std::vector<BuildIdRecord>& build_id_records);
bool WriteFeatureString(int feature, const std::string& s);
bool WriteCmdlineFeature(const std::vector<std::string>& cmdline);
bool WriteBranchStackFeature();
// Normally, Close() should be called after writing. But if something
// wrong happens and we need to finish in advance, the destructor
// will take care of calling Close().
bool Close();
private:
RecordFileWriter(const std::string& filename, FILE* fp);
void GetHitModulesInBuffer(const char* p, const char* end,
std::vector<std::string>* hit_kernel_modules,
std::vector<std::string>* hit_user_files);
bool WriteFileHeader();
bool WriteData(const void* buf, size_t len);
bool Write(const void* buf, size_t len);
std::unique_ptr<Record> ReadRecordFromFile(FILE* fp, std::vector<char>& buf);
bool WriteRecordToFile(FILE* fp, std::unique_ptr<Record> r);
bool SeekFileEnd(uint64_t* file_end);
bool WriteFeatureBegin(uint64_t* start_offset);
bool WriteFeatureEnd(int feature, uint64_t start_offset);
const std::string filename_;
FILE* record_fp_;
perf_event_attr event_attr_;
uint64_t attr_section_offset_;
uint64_t attr_section_size_;
uint64_t data_section_offset_;
uint64_t data_section_size_;
std::vector<int> features_;
int feature_count_;
int current_feature_index_;
DISALLOW_COPY_AND_ASSIGN(RecordFileWriter);
};
// RecordFileReader read contents from a perf record file, like perf.data.
class RecordFileReader {
public:
static std::unique_ptr<RecordFileReader> CreateInstance(const std::string& filename);
~RecordFileReader();
const PerfFileFormat::FileHeader& FileHeader() const {
return header_;
}
std::vector<EventAttrWithId> AttrSection() const {
std::vector<EventAttrWithId> result(file_attrs_.size());
for (size_t i = 0; i < file_attrs_.size(); ++i) {
result[i].attr = &file_attrs_[i].attr;
result[i].ids = event_ids_for_file_attrs_[i];
}
return result;
}
const std::map<int, PerfFileFormat::SectionDesc>& FeatureSectionDescriptors() const {
return feature_section_descriptors_;
}
bool HasFeature(int feature) const {
return feature_section_descriptors_.find(feature) != feature_section_descriptors_.end();
}
bool ReadFeatureSection(int feature, std::vector<char>* data);
// There are two ways to read records in data section: one is by calling
// ReadDataSection(), and [callback] is called for each Record. the other
// is by calling ReadRecord() in a loop.
// If sorted is true, sort records before passing them to callback function.
bool ReadDataSection(const std::function<bool(std::unique_ptr<Record>)>& callback,
bool sorted = true);
// Read next record. If read successfully, set [record] and return true.
// If there is no more records, set [record] to nullptr and return true.
// Otherwise return false.
bool ReadRecord(std::unique_ptr<Record>& record, bool sorted = true);
size_t GetAttrIndexOfRecord(const SampleRecord& record);
std::vector<std::string> ReadCmdlineFeature();
std::vector<BuildIdRecord> ReadBuildIdFeature();
std::string ReadFeatureString(int feature);
bool Close();
// For testing only.
std::vector<std::unique_ptr<Record>> DataSection();
private:
RecordFileReader(const std::string& filename, FILE* fp);
bool ReadHeader();
bool ReadAttrSection();
bool ReadIdsForAttr(const PerfFileFormat::FileAttr& attr, std::vector<uint64_t>* ids);
bool ReadFeatureSectionDescriptors();
std::unique_ptr<Record> ReadRecord(uint64_t* nbytes_read);
bool Read(void* buf, size_t len);
void ProcessEventIdRecord(const EventIdRecord& r);
const std::string filename_;
FILE* record_fp_;
PerfFileFormat::FileHeader header_;
std::vector<PerfFileFormat::FileAttr> file_attrs_;
std::vector<std::vector<uint64_t>> event_ids_for_file_attrs_;
std::unordered_map<uint64_t, size_t> event_id_to_attr_map_;
std::map<int, PerfFileFormat::SectionDesc> feature_section_descriptors_;
size_t event_id_pos_in_sample_records_;
size_t event_id_reverse_pos_in_non_sample_records_;
std::unique_ptr<RecordCache> record_cache_;
uint64_t read_record_size_;
DISALLOW_COPY_AND_ASSIGN(RecordFileReader);
};
#endif // SIMPLE_PERF_RECORD_FILE_H_
|
