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
|
/*
* 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_SAMPLE_TREE_H_
#define SIMPLE_PERF_SAMPLE_TREE_H_
#include <limits.h>
#include <functional>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include "dso.h"
struct ProcessEntry {
int pid;
std::string comm;
};
struct MapEntry {
int pid; // pid = -1 for kernel map entries.
uint64_t start_addr;
uint64_t len;
uint64_t pgoff;
uint64_t time; // Map creation time.
DsoEntry* dso;
};
struct SampleEntry {
int tid;
uint64_t ip;
uint64_t time;
uint64_t period;
uint64_t sample_count;
const ProcessEntry* process;
const MapEntry* map;
const SymbolEntry* symbol;
};
typedef std::function<int(const SampleEntry&, const SampleEntry&)> compare_sample_func_t;
class SampleTree {
public:
SampleTree(compare_sample_func_t sample_compare_function)
: sample_comparator_(sample_compare_function),
sample_tree_(sample_comparator_),
sorted_sample_comparator_(sample_compare_function),
sorted_sample_tree_(sorted_sample_comparator_),
total_samples_(0),
total_period_(0) {
unknown_dso_.path = "unknown";
unknown_symbol_ = {
.name = "unknown", .addr = 0, .len = ULLONG_MAX,
};
}
void AddProcess(int pid, const std::string& comm);
void AddKernelMap(uint64_t start_addr, uint64_t len, uint64_t pgoff, uint64_t time,
const std::string& filename);
void AddUserMap(int pid, uint64_t start_addr, uint64_t len, uint64_t pgoff, uint64_t time,
const std::string& filename);
void AddSample(int pid, int tid, uint64_t ip, uint64_t time, uint64_t period);
void VisitAllSamples(std::function<void(const SampleEntry&)> callback);
uint64_t TotalSamples() const {
return total_samples_;
}
uint64_t TotalPeriod() const {
return total_period_;
}
private:
void RemoveOverlappedUserMap(const MapEntry* map);
const ProcessEntry* FindProcessEntryOrNew(int pid);
const MapEntry* FindMapEntryOrNew(int pid, uint64_t ip);
const MapEntry* FindUnknownMapEntryOrNew(int pid);
DsoEntry* FindKernelDsoOrNew(const std::string& filename);
DsoEntry* FindUserDsoOrNew(const std::string& filename);
const SymbolEntry* FindSymbolEntry(uint64_t ip, const MapEntry* map_entry);
struct MapComparator {
bool operator()(const MapEntry* map1, const MapEntry* map2);
};
struct SampleComparator {
bool operator()(const SampleEntry& sample1, const SampleEntry& sample2) {
return compare_function(sample1, sample2) < 0;
}
SampleComparator(compare_sample_func_t compare_function) : compare_function(compare_function) {
}
compare_sample_func_t compare_function;
};
struct SortedSampleComparator {
bool operator()(const SampleEntry& sample1, const SampleEntry& sample2) {
if (sample1.period != sample2.period) {
return sample1.period > sample2.period;
}
return compare_function(sample1, sample2) < 0;
}
SortedSampleComparator(compare_sample_func_t compare_function)
: compare_function(compare_function) {
}
compare_sample_func_t compare_function;
};
std::unordered_map<int, std::unique_ptr<ProcessEntry>> process_tree_;
std::set<MapEntry*, MapComparator> kernel_map_tree_;
std::set<MapEntry*, MapComparator> user_map_tree_;
std::unordered_map<int, MapEntry*> unknown_maps_;
std::vector<std::unique_ptr<MapEntry>> map_storage_;
std::unique_ptr<DsoEntry> kernel_dso_;
std::unordered_map<std::string, std::unique_ptr<DsoEntry>> module_dso_tree_;
std::unordered_map<std::string, std::unique_ptr<DsoEntry>> user_dso_tree_;
DsoEntry unknown_dso_;
SymbolEntry unknown_symbol_;
SampleComparator sample_comparator_;
std::set<SampleEntry, SampleComparator> sample_tree_;
SortedSampleComparator sorted_sample_comparator_;
std::set<SampleEntry, SortedSampleComparator> sorted_sample_tree_;
uint64_t total_samples_;
uint64_t total_period_;
};
#endif // SIMPLE_PERF_SAMPLE_TREE_H_
|
