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
|
/*
* 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_EVENT_SELECTION_SET_H_
#define SIMPLE_PERF_EVENT_SELECTION_SET_H_
#include <functional>
#include <map>
#include <set>
#include <unordered_map>
#include <vector>
#include <android-base/macros.h>
#include "event_attr.h"
#include "event_fd.h"
#include "event_type.h"
#include "perf_event.h"
#include "record.h"
constexpr double DEFAULT_PERIOD_TO_DETECT_CPU_HOTPLUG_EVENTS_IN_SEC = 0.5;
struct CounterInfo {
pid_t tid;
int cpu;
PerfCounter counter;
};
struct CountersInfo {
uint32_t group_id;
std::string event_name;
std::string event_modifier;
std::vector<CounterInfo> counters;
};
class IOEventLoop;
// EventSelectionSet helps to monitor events. It is used in following steps:
// 1. Create an EventSelectionSet, and add event types to monitor by calling
// AddEventType() or AddEventGroup().
// 2. Define how to monitor events by calling SetEnableOnExec(), SampleIdAll(),
// SetSampleFreq(), etc.
// 3. Start monitoring by calling OpenEventFilesForCpus() or
// OpenEventFilesForThreadsOnCpus(). If SetEnableOnExec() has been called
// in step 2, monitor will be delayed until the monitored thread calls
// exec().
// 4. Read counters by calling ReadCounters(), or read mapped event records
// by calling MmapEventFiles(), PrepareToReadMmapEventData() and
// FinishReadMmapEventData().
// 5. Stop monitoring automatically in the destructor of EventSelectionSet by
// closing perf event files.
class EventSelectionSet {
public:
EventSelectionSet(bool for_stat_cmd)
: for_stat_cmd_(for_stat_cmd), mmap_pages_(0), loop_(nullptr) {}
bool empty() const { return groups_.empty(); }
bool AddEventType(const std::string& event_name);
bool AddEventGroup(const std::vector<std::string>& event_names);
std::vector<const EventType*> GetTracepointEvents() const;
std::vector<EventAttrWithId> GetEventAttrWithId() const;
void SetEnableOnExec(bool enable);
bool GetEnableOnExec();
void SampleIdAll();
void SetSampleFreq(uint64_t sample_freq);
void SetSamplePeriod(uint64_t sample_period);
void UseDefaultSampleFreq();
bool SetBranchSampling(uint64_t branch_sample_type);
void EnableFpCallChainSampling();
bool EnableDwarfCallChainSampling(uint32_t dump_stack_size);
void SetInherit(bool enable);
void SetLowWatermark();
bool NeedKernelSymbol() const;
void AddMonitoredProcesses(const std::set<pid_t>& processes) {
processes_.insert(processes.begin(), processes.end());
}
void AddMonitoredThreads(const std::set<pid_t>& threads) {
threads_.insert(threads.begin(), threads.end());
}
const std::set<pid_t>& GetMonitoredProcesses() const { return processes_; }
const std::set<pid_t>& GetMonitoredThreads() const { return threads_; }
bool HasMonitoredTarget() const {
return !processes_.empty() || !threads_.empty();
}
bool OpenEventFiles(const std::vector<int>& on_cpus);
bool ReadCounters(std::vector<CountersInfo>* counters);
bool MmapEventFiles(size_t min_mmap_pages, size_t max_mmap_pages);
bool PrepareToReadMmapEventData(IOEventLoop& loop,
const std::function<bool(Record*)>& callback);
bool FinishReadMmapEventData();
// If monitored_cpus is empty, monitor all cpus.
bool HandleCpuHotplugEvents(
IOEventLoop& loop, const std::vector<int>& monitored_cpus,
double check_interval_in_sec =
DEFAULT_PERIOD_TO_DETECT_CPU_HOTPLUG_EVENTS_IN_SEC);
private:
struct EventSelection {
EventTypeAndModifier event_type_modifier;
perf_event_attr event_attr;
std::vector<std::unique_ptr<EventFd>> event_fds;
// counters for event files closed for cpu hotplug events
std::vector<CounterInfo> hotplugged_counters;
};
typedef std::vector<EventSelection> EventSelectionGroup;
bool BuildAndCheckEventSelection(const std::string& event_name,
EventSelection* selection);
void UnionSampleType();
bool OpenEventFilesOnGroup(EventSelectionGroup& group, pid_t tid, int cpu,
std::string* failed_event_type);
bool MmapEventFiles(size_t mmap_pages, bool report_error);
bool ReadMmapEventDataForFd(EventFd* event_fd);
bool DetectCpuHotplugEvents();
bool HandleCpuOnlineEvent(int cpu);
bool HandleCpuOfflineEvent(int cpu);
bool CreateMappedBufferForCpu(int cpu);
const bool for_stat_cmd_;
std::vector<EventSelectionGroup> groups_;
std::set<pid_t> processes_;
std::set<pid_t> threads_;
size_t mmap_pages_;
IOEventLoop* loop_;
std::function<bool(Record*)> record_callback_;
std::set<int> monitored_cpus_;
std::vector<int> online_cpus_;
DISALLOW_COPY_AND_ASSIGN(EventSelectionSet);
};
bool IsBranchSamplingSupported();
bool IsDwarfCallChainSamplingSupported();
#endif // SIMPLE_PERF_EVENT_SELECTION_SET_H_
|
