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
|
/*
* 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 "perf_event.h"
#include "record.h"
#include "record_file_format.h"
struct AttrWithId {
const perf_event_attr* attr;
std::vector<uint64_t> ids;
};
// 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<AttrWithId>& attr_ids);
bool WriteData(const void* buf, size_t len);
bool WriteData(const std::vector<char>& data) {
return WriteData(data.data(), data.size());
}
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 Write(const void* buf, size_t len);
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_;
}
const std::vector<PerfFileFormat::FileAttr>& AttrSection() const {
return file_attrs_;
}
const std::map<int, PerfFileFormat::SectionDesc>& FeatureSectionDescriptors() const {
return feature_section_descriptors_;
}
bool ReadIdsForAttr(const PerfFileFormat::FileAttr& attr, std::vector<uint64_t>* ids);
// If sorted is true, sort records before passing them to callback function.
bool ReadDataSection(std::function<bool(std::unique_ptr<Record>)> callback, bool sorted = true);
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 ReadFeatureSectionDescriptors();
bool ReadFeatureSection(int feature, std::vector<char>* data);
std::unique_ptr<Record> ReadRecord();
const std::string filename_;
FILE* record_fp_;
PerfFileFormat::FileHeader header_;
std::vector<PerfFileFormat::FileAttr> file_attrs_;
std::unordered_map<uint64_t, perf_event_attr*> 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_;
DISALLOW_COPY_AND_ASSIGN(RecordFileReader);
};
#endif // SIMPLE_PERF_RECORD_FILE_H_
|
