1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "htrace_event_parser.h"
16 #include <string>
17 #include "binder_filter.h"
18 #include "binder.pb.h"
19 #include "clock_filter.h"
20 #include "cpu_filter.h"
21 #include "irq_filter.h"
22 #include "irq.pb.h"
23 #include "log.h"
24 #include "measure_filter.h"
25 #include "process_filter.h"
26 #include "slice_filter.h"
27 #include "stat_filter.h"
28 #include "symbols_filter.h"
29 #include "system_event_measure_filter.h"
30 #include "thread_state.h"
31 namespace SysTuning {
32 namespace TraceStreamer {
HtraceEventParser(TraceDataCache * dataCache,const TraceStreamerFilters * filter)33 HtraceEventParser::HtraceEventParser(TraceDataCache* dataCache, const TraceStreamerFilters* filter)
34 : EventParserBase(dataCache, filter),
35 workQueueId_(dataCache->dataDict_.GetStringIndex("workqueue")),
36 printEventParser_(traceDataCache_, streamFilters_)
37 {
38 eventToFunctionMap_ = {{config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
39 std::bind(&HtraceEventParser::BinderTractionEvent, this, std::placeholders::_1)},
40 {config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
41 std::bind(&HtraceEventParser::BinderTractionReceivedEvent, this, std::placeholders::_1)},
42 {config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
43 std::bind(&HtraceEventParser::BinderTractionAllocBufEvent, this, std::placeholders::_1)},
44 {config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCK),
45 std::bind(&HtraceEventParser::BinderTractionLockEvent, this, std::placeholders::_1)},
46 {config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCKED),
47 std::bind(&HtraceEventParser::BinderTractionLockedEvent, this, std::placeholders::_1)},
48 {config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK),
49 std::bind(&HtraceEventParser::BinderTractionUnLockEvent, this, std::placeholders::_1)},
50 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
51 std::bind(&HtraceEventParser::SchedSwitchEvent, this, std::placeholders::_1)},
52 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
53 std::bind(&HtraceEventParser::TaskRenameEvent, this, std::placeholders::_1)},
54 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
55 std::bind(&HtraceEventParser::TaskNewtaskEvent, this, std::placeholders::_1)},
56 {config_.eventNameMap_.at(TRACE_EVENT_PRINT),
57 std::bind(&HtraceEventParser::ParsePrintEvent, this, std::placeholders::_1)},
58 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
59 std::bind(&HtraceEventParser::SchedWakeupEvent, this, std::placeholders::_1)},
60 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
61 std::bind(&HtraceEventParser::SchedWakeupNewEvent, this, std::placeholders::_1)},
62 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
63 std::bind(&HtraceEventParser::ProcessExitEvent, this, std::placeholders::_1)},
64 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_FREE),
65 std::bind(&HtraceEventParser::ProcessFreeEvent, this, std::placeholders::_1)},
66 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
67 std::bind(&HtraceEventParser::SchedWakingEvent, this, std::placeholders::_1)},
68 {config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
69 std::bind(&HtraceEventParser::CpuIdleEvent, this, std::placeholders::_1)},
70 {config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
71 std::bind(&HtraceEventParser::CpuFrequencyEvent, this, std::placeholders::_1)},
72 {config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
73 std::bind(&HtraceEventParser::CpuFrequencyLimitsEvent, this, std::placeholders::_1)},
74 {config_.eventNameMap_.at(TRACE_EVENT_SUSPEND_RESUME),
75 std::bind(&HtraceEventParser::SuspendResumeEvent, this, std::placeholders::_1)},
76 {config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
77 std::bind(&HtraceEventParser::WorkqueueExecuteStartEvent, this, std::placeholders::_1)},
78 {config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
79 std::bind(&HtraceEventParser::WorkqueueExecuteEndEvent, this, std::placeholders::_1)},
80 {config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
81 std::bind(&HtraceEventParser::ClockSetRateEvent, this, std::placeholders::_1)},
82 {config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
83 std::bind(&HtraceEventParser::ClockEnableEvent, this, std::placeholders::_1)},
84 {config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
85 std::bind(&HtraceEventParser::ClockDisableEvent, this, std::placeholders::_1)},
86 {config_.eventNameMap_.at(TRACE_EVENT_CLK_SET_RATE),
87 std::bind(&HtraceEventParser::ClkSetRateEvent, this, std::placeholders::_1)},
88 {config_.eventNameMap_.at(TRACE_EVENT_CLK_ENABLE),
89 std::bind(&HtraceEventParser::ClkEnableEvent, this, std::placeholders::_1)},
90 {config_.eventNameMap_.at(TRACE_EVENT_CLK_DISABLE),
91 std::bind(&HtraceEventParser::ClkDisableEvent, this, std::placeholders::_1)},
92 {config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
93 std::bind(&HtraceEventParser::IrqHandlerEntryEvent, this, std::placeholders::_1)},
94 {config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
95 std::bind(&HtraceEventParser::IrqHandlerExitEvent, this, std::placeholders::_1)},
96 {config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
97 std::bind(&HtraceEventParser::SoftIrqEntryEvent, this, std::placeholders::_1)},
98 {config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
99 std::bind(&HtraceEventParser::SoftIrqRaiseEvent, this, std::placeholders::_1)},
100 {config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
101 std::bind(&HtraceEventParser::SoftIrqExitEvent, this, std::placeholders::_1)},
102 {config_.eventNameMap_.at(TRACE_EVENT_SYS_ENTRY),
103 std::bind(&HtraceEventParser::SysEnterEvent, this, std::placeholders::_1)},
104 {config_.eventNameMap_.at(TRACE_EVENT_SYS_EXIT),
105 std::bind(&HtraceEventParser::SysExitEvent, this, std::placeholders::_1)},
106 {config_.eventNameMap_.at(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE),
107 std::bind(&HtraceEventParser::OomScoreAdjUpdate, this, std::placeholders::_1)}};
108 }
109
~HtraceEventParser()110 HtraceEventParser::~HtraceEventParser()
111 {
112 TS_LOGI("thread count:%u", static_cast<unsigned int>(tids_.size()));
113 TS_LOGI("process count:%u", static_cast<unsigned int>(pids_.size()));
114 TS_LOGI("ftrace ts MIN:%llu, MAX:%llu", static_cast<unsigned long long>(ftraceStartTime_),
115 static_cast<unsigned long long>(ftraceEndTime_));
116 }
ParseDataItem(const FtraceCpuDetailMsg * cpuDetail,BuiltinClocks clock)117 void HtraceEventParser::ParseDataItem(const FtraceCpuDetailMsg* cpuDetail, BuiltinClocks clock)
118 {
119 eventCpu_ = cpuDetail->cpu();
120 auto events = cpuDetail->event();
121 if (!events.size()) {
122 return;
123 }
124 if (cpuDetail->overwrite()) {
125 if (!lastOverwrite_) {
126 lastOverwrite_ = cpuDetail->overwrite();
127 }
128 if (lastOverwrite_ != cpuDetail->overwrite()) {
129 TS_LOGW("lost events:%lu", cpuDetail->overwrite() - lastOverwrite_);
130 lastOverwrite_ = cpuDetail->overwrite();
131 }
132 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST);
133 }
134 // parser cpu event
135 for (auto i = 0; i < events.size(); i++) {
136 auto event = cpuDetail->event(i);
137 eventTimestamp_ = event.timestamp();
138 comm_ = event.comm();
139 ftraceStartTime_ = std::min(ftraceStartTime_, eventTimestamp_);
140 ftraceEndTime_ = std::max(ftraceEndTime_, eventTimestamp_);
141 eventTimestamp_ = streamFilters_->clockFilter_->ToPrimaryTraceTime(clock, eventTimestamp_);
142 traceDataCache_->UpdateTraceTime(eventTimestamp_);
143 if (event.tgid() != INVALID_INT32) {
144 eventPid_ = event.tgid();
145 if (!pids_.count(eventPid_)) {
146 pids_.insert(eventPid_);
147 }
148 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventPid_, eventPid_);
149 }
150 if (event.common_fields().pid() != INVALID_INT32) {
151 eventTid_ = event.common_fields().pid();
152 if (!tids_.count(eventTid_)) {
153 tids_.insert(eventTid_);
154 }
155 streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventTid_);
156 }
157 if (eventTid_ != INVALID_INT32 && eventPid_ != INVALID_INT32) {
158 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventTid_, eventPid_);
159 }
160 // remember all event
161 eventList_.push_back(std::move(
162 std::make_unique<EventInfo>(comm_, eventTimestamp_, eventCpu_, eventPid_, eventTid_, std::move(event))));
163 // push all events in queue and finally release it, the data may not be released
164 // this may limit the max size of data, so we parser data periodicity
165 FilterAllEventsTemp();
166 }
167 }
DealEvent(const FtraceEvent & event)168 void HtraceEventParser::DealEvent(const FtraceEvent& event)
169 {
170 streamFilters_->processFilter_->UpdateOrCreateThreadWithPidAndName(event.common_fields().pid(), event.tgid(),
171 event.comm());
172 if (event.has_sched_switch_format()) {
173 InvokeFunc(TRACE_EVENT_SCHED_SWITCH, event.sched_switch_format());
174 } else if (event.has_task_rename_format()) {
175 InvokeFunc(TRACE_EVENT_TASK_RENAME, event.task_rename_format());
176 } else if (event.has_task_newtask_format()) {
177 InvokeFunc(TRACE_EVENT_TASK_NEWTASK, event.task_newtask_format());
178 } else if (event.has_sched_wakeup_format()) {
179 InvokeFunc(TRACE_EVENT_SCHED_WAKEUP, event.sched_wakeup_format());
180 } else if (event.has_sched_wakeup_new_format()) {
181 InvokeFunc(TRACE_EVENT_SCHED_WAKEUP, event.sched_wakeup_new_format());
182 } else if (event.has_sched_process_exit_format()) {
183 InvokeFunc(TRACE_EVENT_PROCESS_EXIT, event.sched_process_exit_format());
184 } else if (event.has_sched_process_free_format()) {
185 InvokeFunc(TRACE_EVENT_PROCESS_FREE, event.sched_process_free_format());
186 } else if (event.has_sched_waking_format()) {
187 InvokeFunc(TRACE_EVENT_SCHED_WAKING, event.sched_waking_format());
188 } else if (event.has_cpu_idle_format()) {
189 InvokeFunc(TRACE_EVENT_CPU_IDLE, event.cpu_idle_format());
190 } else if (event.has_cpu_frequency_format()) {
191 InvokeFunc(TRACE_EVENT_CPU_FREQUENCY, event.cpu_frequency_format());
192 } else if (event.has_cpu_frequency_limits_format()) {
193 InvokeFunc(TRACE_EVENT_CPU_FREQUENCY_LIMITS, event.cpu_frequency_limits_format());
194 } else if (event.has_print_format()) {
195 InvokeFunc(TRACE_EVENT_PRINT, event.print_format());
196 } else if (event.has_suspend_resume_format()) {
197 InvokeFunc(TRACE_EVENT_SUSPEND_RESUME, event.suspend_resume_format());
198 } else if (event.has_workqueue_execute_start_format()) {
199 InvokeFunc(TRACE_EVENT_WORKQUEUE_EXECUTE_START, event.workqueue_execute_start_format());
200 } else if (event.has_workqueue_execute_end_format()) {
201 InvokeFunc(TRACE_EVENT_WORKQUEUE_EXECUTE_END, event.workqueue_execute_end_format());
202 } else if (event.has_clock_disable_format()) {
203 InvokeFunc(TRACE_EVENT_CLOCK_DISABLE, event.clock_disable_format());
204 } else if (event.has_clock_enable_format()) {
205 InvokeFunc(TRACE_EVENT_CLOCK_ENABLE, event.clock_enable_format());
206 } else if (event.has_clock_set_rate_format()) {
207 InvokeFunc(TRACE_EVENT_CLOCK_SET_RATE, event.clock_set_rate_format());
208 } else if (event.has_clk_disable_format()) {
209 InvokeFunc(TRACE_EVENT_CLK_DISABLE, event.clk_disable_format());
210 } else if (event.has_clk_enable_format()) {
211 InvokeFunc(TRACE_EVENT_CLK_ENABLE, event.clk_enable_format());
212 } else if (event.has_clk_set_rate_format()) {
213 InvokeFunc(TRACE_EVENT_CLK_SET_RATE, event.clk_set_rate_format());
214 } else if (event.has_sys_enter_format()) {
215 InvokeFunc(TRACE_EVENT_SYS_ENTRY, event.sys_enter_format());
216 } else if (event.has_sys_exit_format()) {
217 InvokeFunc(TRACE_EVENT_SYS_EXIT, event.sys_exit_format());
218 } else if (event.has_binder_transaction_format()) {
219 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION, event.binder_transaction_format());
220 } else if (event.has_binder_transaction_received_format()) {
221 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, event.binder_transaction_received_format());
222 } else if (event.has_binder_transaction_alloc_buf_format()) {
223 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, event.binder_transaction_alloc_buf_format());
224 } else if (event.has_binder_lock_format()) {
225 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION_LOCK, event.binder_lock_format());
226 } else if (event.has_binder_unlock_format()) {
227 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, event.binder_unlock_format());
228 } else if (event.has_binder_locked_format()) {
229 InvokeFunc(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, event.binder_locked_format());
230 } else if (event.has_irq_handler_entry_format()) {
231 InvokeFunc(TRACE_EVENT_IRQ_HANDLER_ENTRY, event.irq_handler_entry_format());
232 } else if (event.has_irq_handler_exit_format()) {
233 InvokeFunc(TRACE_EVENT_IRQ_HANDLER_EXIT, event.irq_handler_exit_format());
234 } else if (event.has_softirq_entry_format()) {
235 InvokeFunc(TRACE_EVENT_SOFTIRQ_ENTRY, event.softirq_entry_format());
236 } else if (event.has_softirq_exit_format()) {
237 InvokeFunc(TRACE_EVENT_SOFTIRQ_EXIT, event.softirq_exit_format());
238 } else if (event.has_oom_score_adj_update_format()) {
239 InvokeFunc(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE, event.oom_score_adj_update_format());
240 } else if (event.has_signal_generate_format()) {
241 InvokeFunc(TRACE_EVENT_SIGNAL_GENERATE, event.signal_generate_format());
242 } else if (event.has_signal_deliver_format()) {
243 InvokeFunc(TRACE_EVENT_SIGNAL_DELIVER, event.signal_deliver_format());
244 } else {
245 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED);
246 TS_LOGD("has_rpc_socket_shutdown_format\n");
247 }
248 }
BinderTractionAllocBufEvent(const MessageLite & event) const249 bool HtraceEventParser::BinderTractionAllocBufEvent(const MessageLite& event) const
250 {
251 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_RECEIVED);
252 const auto msg = static_cast<const BinderTransactionAllocBufFormat&>(event);
253 uint64_t dataSize = msg.data_size();
254 uint64_t offsetsSize = msg.offsets_size();
255 streamFilters_->binderFilter_->TransactionAllocBuf(eventTimestamp_, eventTid_, dataSize, offsetsSize);
256 TS_LOGD("dataSize:%lu, offsetSize:%lu", dataSize, offsetsSize);
257 return true;
258 }
BinderTractionEvent(const MessageLite & event) const259 bool HtraceEventParser::BinderTractionEvent(const MessageLite& event) const
260 {
261 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_RECEIVED);
262 const auto msg = static_cast<const BinderTransactionFormat&>(event);
263 int32_t destNode = msg.target_node();
264 int32_t destTgid = msg.to_proc();
265 int32_t destTid = msg.to_thread();
266 int32_t transactionId = msg.debug_id();
267 bool isReply = msg.reply() == 1;
268 uint32_t flags = msg.flags();
269 TS_LOGD("destNode:%d, destTgid:%d, destTid:%d, transactionId:%d, isReply:%d flags:%d, code:%d", destNode, destTgid,
270 destTid, transactionId, isReply, flags, msg.code());
271 streamFilters_->binderFilter_->SendTraction(eventTimestamp_, eventTid_, transactionId, destNode, destTgid, destTid,
272 isReply, flags, msg.code());
273 return true;
274 }
BinderTractionReceivedEvent(const MessageLite & event) const275 bool HtraceEventParser::BinderTractionReceivedEvent(const MessageLite& event) const
276 {
277 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_RECEIVED);
278 const auto msg = static_cast<const BinderTransactionReceivedFormat&>(event);
279 int32_t transactionId = msg.debug_id();
280 streamFilters_->binderFilter_->ReceiveTraction(eventTimestamp_, eventTid_, transactionId);
281 TS_LOGD("transactionId:%d", transactionId);
282 return true;
283 }
BinderTractionLockEvent(const MessageLite & event) const284 bool HtraceEventParser::BinderTractionLockEvent(const MessageLite& event) const
285 {
286 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCK, STAT_EVENT_RECEIVED);
287 const auto msg = static_cast<const BinderLockFormat&>(event);
288 std::string tag = msg.tag();
289 streamFilters_->binderFilter_->TractionLock(eventTimestamp_, eventTid_, tag);
290 TS_LOGD("tag:%s", tag.c_str());
291 return true;
292 }
BinderTractionLockedEvent(const MessageLite & event) const293 bool HtraceEventParser::BinderTractionLockedEvent(const MessageLite& event) const
294 {
295 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, STAT_EVENT_RECEIVED);
296 const auto msg = static_cast<const BinderLockedFormat&>(event);
297 std::string tag = msg.tag();
298 streamFilters_->binderFilter_->TractionLocked(eventTimestamp_, eventTid_, tag);
299 return true;
300 }
BinderTractionUnLockEvent(const MessageLite & event) const301 bool HtraceEventParser::BinderTractionUnLockEvent(const MessageLite& event) const
302 {
303 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, STAT_EVENT_RECEIVED);
304 const auto msg = static_cast<const BinderUnlockFormat&>(event);
305 std::string tag = msg.tag();
306 TS_LOGD("tag:%s", tag.c_str());
307 streamFilters_->binderFilter_->TractionUnlock(eventTimestamp_, eventTid_, tag);
308 return true;
309 }
SchedSwitchEvent(const MessageLite & event)310 bool HtraceEventParser::SchedSwitchEvent(const MessageLite& event)
311 {
312 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED);
313 const auto msg = static_cast<const SchedSwitchFormat&>(event);
314 uint32_t prevPrioValue = msg.prev_prio();
315 uint32_t nextPrioValue = msg.next_prio();
316 uint32_t prevPidValue = msg.prev_pid();
317 uint32_t nextPidValue = msg.next_pid();
318 if (!tids_.count(prevPidValue)) {
319 tids_.insert(prevPidValue);
320 }
321 if (!tids_.count(nextPidValue)) {
322 tids_.insert(nextPidValue);
323 }
324 std::string prevCommStr = msg.prev_comm();
325 std::string nextCommStr = msg.next_comm();
326 auto prevState = msg.prev_state();
327
328 auto nextInternalTid =
329 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(eventTimestamp_, nextPidValue, nextCommStr);
330 auto uprevtid =
331 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(eventTimestamp_, prevPidValue, prevCommStr);
332 streamFilters_->cpuFilter_->InsertSwitchEvent(eventTimestamp_, eventCpu_, uprevtid,
333 static_cast<uint64_t>(prevPrioValue), prevState, nextInternalTid,
334 static_cast<uint64_t>(nextPrioValue));
335 return true;
336 }
ProcessExitEvent(const MessageLite & event) const337 bool HtraceEventParser::ProcessExitEvent(const MessageLite& event) const
338 {
339 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_RECEIVED);
340 const auto msg = static_cast<const SchedProcessExitFormat&>(event);
341 uint32_t pidValue = msg.pid();
342 std::string commStr = msg.comm();
343 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(eventTimestamp_, pidValue, commStr);
344 if (streamFilters_->cpuFilter_->InsertProcessExitEvent(eventTimestamp_, eventCpu_, iTid)) {
345 return true;
346 } else {
347 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_NOTMATCH);
348 return false;
349 }
350 }
ProcessFreeEvent(const MessageLite & event) const351 bool HtraceEventParser::ProcessFreeEvent(const MessageLite& event) const
352 {
353 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_RECEIVED);
354 const auto msg = static_cast<const SchedProcessFreeFormat&>(event);
355 uint32_t pidValue = msg.pid();
356 std::string commStr = msg.comm();
357 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(eventTimestamp_, pidValue, commStr);
358 if (streamFilters_->cpuFilter_->InsertProcessFreeEvent(eventTimestamp_, iTid)) {
359 return true;
360 } else {
361 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_NOTMATCH);
362 return false;
363 }
364 }
TaskRenameEvent(const MessageLite & event) const365 bool HtraceEventParser::TaskRenameEvent(const MessageLite& event) const
366 {
367 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED);
368 const auto msg = static_cast<const TaskRenameFormat&>(event);
369 auto prevCommStr = msg.newcomm();
370 auto pidValue = msg.pid();
371 return true;
372 }
TaskNewtaskEvent(const MessageLite & event) const373 bool HtraceEventParser::TaskNewtaskEvent(const MessageLite& event) const
374 {
375 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
376 // the clone flag from txt trace from kernel original is HEX, but when it is converted from proto
377 // based trace, it will be OCT number, it is not stable, so we decide to ignore it
378 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_NOTSUPPORTED);
379 return true;
380 }
ParsePrintEvent(const MessageLite & event)381 bool HtraceEventParser::ParsePrintEvent(const MessageLite& event)
382 {
383 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PRINT, STAT_EVENT_RECEIVED);
384 const auto msg = static_cast<const PrintFormat&>(event);
385 printEventParser_.ParsePrintEvent(comm_, eventTimestamp_, eventTid_, msg.buf().c_str());
386 if (!tids_.count(eventTid_)) {
387 tids_.insert(eventTid_);
388 }
389 return true;
390 }
SchedWakeupEvent(const MessageLite & event) const391 bool HtraceEventParser::SchedWakeupEvent(const MessageLite& event) const
392 {
393 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
394 const auto msg = static_cast<const SchedWakeupFormat&>(event);
395 auto instants = traceDataCache_->GetInstantsData();
396
397 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, msg.pid());
398 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventTid_);
399 instants->AppendInstantEventData(eventTimestamp_, schedWakeupName_, internalTid, wakeupFromPid);
400 std::optional<uint32_t> targetCpu = msg.target_cpu();
401 if (targetCpu.has_value()) {
402 traceDataCache_->GetRawData()->AppendRawData(0, eventTimestamp_, RAW_SCHED_WAKEUP, targetCpu.value(),
403 internalTid);
404 } else {
405 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID);
406 }
407 return true;
408 }
SchedWakeupNewEvent(const MessageLite & event) const409 bool HtraceEventParser::SchedWakeupNewEvent(const MessageLite& event) const
410 {
411 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP_NEW, STAT_EVENT_RECEIVED);
412 const auto msg = static_cast<const SchedWakeupNewFormat&>(event);
413 auto instants = traceDataCache_->GetInstantsData();
414
415 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, msg.pid());
416 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventTid_);
417 instants->AppendInstantEventData(eventTimestamp_, schedWakeupNewName_, internalTid, wakeupFromPid);
418 std::optional<uint32_t> targetCpu = msg.target_cpu();
419 if (targetCpu.has_value()) {
420 traceDataCache_->GetRawData()->AppendRawData(0, eventTimestamp_, RAW_SCHED_WAKEUP, targetCpu.value(),
421 internalTid);
422 } else {
423 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP_NEW, STAT_EVENT_DATA_INVALID);
424 }
425 return true;
426 }
SchedWakingEvent(const MessageLite & event) const427 bool HtraceEventParser::SchedWakingEvent(const MessageLite& event) const
428 {
429 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
430 const auto msg = static_cast<const SchedWakingFormat&>(event);
431 std::optional<uint32_t> wakePidValue = msg.pid();
432 if (!wakePidValue.has_value()) {
433 TS_LOGD("Failed to convert wake_pid");
434 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_DATA_INVALID);
435 return false;
436 }
437 auto instants = traceDataCache_->GetInstantsData();
438 InternalTid internalTid =
439 streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, wakePidValue.value());
440 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventTid_);
441 instants->AppendInstantEventData(eventTimestamp_, schedWakingName_, internalTid, wakeupFromPid);
442 streamFilters_->cpuFilter_->InsertWakeupEvent(eventTimestamp_, internalTid);
443 std::optional<uint32_t> targetCpu = msg.target_cpu();
444 if (targetCpu.has_value()) {
445 traceDataCache_->GetRawData()->AppendRawData(0, eventTimestamp_, RAW_SCHED_WAKING, targetCpu.value(),
446 wakeupFromPid);
447 }
448 return true;
449 }
CpuIdleEvent(const MessageLite & event) const450 bool HtraceEventParser::CpuIdleEvent(const MessageLite& event) const
451 {
452 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
453 const auto msg = static_cast<const CpuIdleFormat&>(event);
454 std::optional<uint32_t> eventCpuValue = msg.cpu_id();
455 std::optional<uint64_t> newStateValue = msg.state();
456 if (!eventCpuValue.has_value()) {
457 TS_LOGW("Failed to convert event cpu");
458 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
459 return false;
460 }
461 if (!newStateValue.has_value()) {
462 TS_LOGW("Failed to convert state");
463 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
464 return false;
465 }
466
467 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuIdleName_, eventTimestamp_,
468 config_.GetStateValue(newStateValue.value()));
469
470 // Add cpu_idle event to raw_data_table
471 traceDataCache_->GetRawData()->AppendRawData(0, eventTimestamp_, RAW_CPU_IDLE, eventCpuValue.value(), 0);
472 return true;
473 }
CpuFrequencyEvent(const MessageLite & event) const474 bool HtraceEventParser::CpuFrequencyEvent(const MessageLite& event) const
475 {
476 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
477 const auto msg = static_cast<const CpuFrequencyFormat&>(event);
478 std::optional<uint64_t> newStateValue = msg.state();
479 std::optional<uint32_t> eventCpuValue = msg.cpu_id();
480
481 if (!newStateValue.has_value()) {
482 TS_LOGW("Failed to convert state");
483 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
484 return false;
485 }
486 if (!eventCpuValue.has_value()) {
487 TS_LOGW("Failed to convert event cpu");
488 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
489 return false;
490 }
491
492 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyName_, eventTimestamp_,
493 newStateValue.value());
494 return true;
495 }
CpuFrequencyLimitsEvent(const MessageLite & event) const496 bool HtraceEventParser::CpuFrequencyLimitsEvent(const MessageLite& event) const
497 {
498 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
499 const auto msg = static_cast<const CpuFrequencyLimitsFormat&>(event);
500 uint32_t maxFreq = msg.max_freq();
501 uint32_t minFreq = msg.min_freq();
502 uint32_t eventCpuValue = msg.cpu_id();
503 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue, cpuFrequencyLimitMaxNameId, eventTimestamp_,
504 maxFreq);
505 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue, cpuFrequencyLimitMinNameId, eventTimestamp_,
506 minFreq);
507 return true;
508 }
SuspendResumeEvent(const MessageLite & event) const509 bool HtraceEventParser::SuspendResumeEvent(const MessageLite& event) const
510 {
511 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_RECEIVED);
512 const auto msg = static_cast<const SuspendResumeFormat&>(event);
513 int32_t val = msg.val();
514 uint32_t start = msg.start();
515 std::string action = msg.action();
516 UNUSED(val);
517 UNUSED(start);
518 UNUSED(action);
519 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_NOTSUPPORTED);
520 return true;
521 }
WorkqueueExecuteStartEvent(const MessageLite & event) const522 bool HtraceEventParser::WorkqueueExecuteStartEvent(const MessageLite& event) const
523 {
524 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_RECEIVED);
525 const auto msg = static_cast<const WorkqueueExecuteStartFormat&>(event);
526 auto funcNameIndex = streamFilters_->symbolsFilter_->GetFunc(msg.function());
527 size_t result = INVALID_UINT32;
528 if (funcNameIndex == INVALID_UINT64) {
529 std::string addrStr = "0x" + base::number(msg.function(), base::INTEGER_RADIX_TYPE_HEX);
530 auto addStrIndex = traceDataCache_->GetDataIndex(addrStr);
531 result = streamFilters_->sliceFilter_->BeginSlice(comm_, eventTimestamp_, eventPid_, eventPid_,
532 workQueueId_, addStrIndex);
533 } else {
534 result = streamFilters_->sliceFilter_->BeginSlice(comm_, eventTimestamp_, eventPid_, eventPid_,
535 workQueueId_, funcNameIndex);
536 }
537
538 traceDataCache_->GetInternalSlicesData()->AppendDistributeInfo();
539 if (result == INVALID_UINT32) {
540 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TRACING_MARK_WRITE, STAT_EVENT_DATA_LOST);
541 }
542 return true;
543 }
WorkqueueExecuteEndEvent(const MessageLite & event) const544 bool HtraceEventParser::WorkqueueExecuteEndEvent(const MessageLite& event) const
545 {
546 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
547 const auto msg = static_cast<const WorkqueueExecuteEndFormat&>(event);
548 if (streamFilters_->sliceFilter_->EndSlice(eventTimestamp_, eventPid_, eventPid_, workQueueId_)) {
549 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_NOTMATCH);
550 }
551 return true;
552 }
ClockSetRateEvent(const MessageLite & event) const553 bool HtraceEventParser::ClockSetRateEvent(const MessageLite& event) const
554 {
555 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
556 const auto msg = static_cast<const ClockSetRateFormat&>(event);
557 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
558 streamFilters_->clockRateFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, eventTimestamp_, msg.state());
559 return true;
560 }
ClockEnableEvent(const MessageLite & event) const561 bool HtraceEventParser::ClockEnableEvent(const MessageLite& event) const
562 {
563 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
564 const auto msg = static_cast<const ClockEnableFormat&>(event);
565 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
566 streamFilters_->clockEnableFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, eventTimestamp_, msg.state());
567 return true;
568 }
ClockDisableEvent(const MessageLite & event) const569 bool HtraceEventParser::ClockDisableEvent(const MessageLite& event) const
570 {
571 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
572 const auto msg = static_cast<const ClockDisableFormat&>(event);
573 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
574 streamFilters_->clockDisableFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, eventTimestamp_, msg.state());
575 return true;
576 }
ClkSetRateEvent(const MessageLite & event) const577 bool HtraceEventParser::ClkSetRateEvent(const MessageLite& event) const
578 {
579 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_SET_RATE, STAT_EVENT_RECEIVED);
580 const auto msg = static_cast<const ClkSetRateFormat&>(event);
581 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
582 streamFilters_->clkRateFilter_->AppendNewMeasureData(eventCpu_, nameIndex, eventTimestamp_, msg.rate());
583 return true;
584 }
ClkEnableEvent(const MessageLite & event) const585 bool HtraceEventParser::ClkEnableEvent(const MessageLite& event) const
586 {
587 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_ENABLE, STAT_EVENT_RECEIVED);
588 const auto msg = static_cast<const ClkEnableFormat&>(event);
589 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
590 streamFilters_->clkEnableFilter_->AppendNewMeasureData(eventCpu_, nameIndex, eventTimestamp_, 1);
591 return true;
592 }
ClkDisableEvent(const MessageLite & event) const593 bool HtraceEventParser::ClkDisableEvent(const MessageLite& event) const
594 {
595 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_DISABLE, STAT_EVENT_RECEIVED);
596 const auto msg = static_cast<const ClkDisableFormat&>(event);
597 DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name());
598 streamFilters_->clkDisableFilter_->AppendNewMeasureData(eventCpu_, nameIndex, eventTimestamp_, 0);
599 return true;
600 }
601
IrqHandlerEntryEvent(const MessageLite & event) const602 bool HtraceEventParser::IrqHandlerEntryEvent(const MessageLite& event) const
603 {
604 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_RECEIVED);
605 const auto msg = static_cast<const IrqHandlerEntryFormat&>(event);
606 auto name = std::string_view(msg.name());
607 streamFilters_->irqFilter_->IrqHandlerEntry(eventTimestamp_, eventCpu_, traceDataCache_->GetDataIndex(name));
608 return true;
609 }
IrqHandlerExitEvent(const MessageLite & event) const610 bool HtraceEventParser::IrqHandlerExitEvent(const MessageLite& event) const
611 {
612 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED);
613 const auto msg = static_cast<const IrqHandlerExitFormat&>(event);
614 streamFilters_->irqFilter_->IrqHandlerExit(eventTimestamp_, eventCpu_, static_cast<uint32_t>(msg.ret()));
615 return true;
616 }
SoftIrqEntryEvent(const MessageLite & event) const617 bool HtraceEventParser::SoftIrqEntryEvent(const MessageLite& event) const
618 {
619 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_RECEIVED);
620 const auto msg = static_cast<const SoftirqEntryFormat&>(event);
621 streamFilters_->irqFilter_->SoftIrqEntry(eventTimestamp_, eventCpu_, static_cast<uint32_t>(msg.vec()));
622 return true;
623 }
SoftIrqRaiseEvent(const MessageLite & event) const624 bool HtraceEventParser::SoftIrqRaiseEvent(const MessageLite& event) const
625 {
626 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_RECEIVED);
627 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_NOTSUPPORTED);
628 return true;
629 }
SoftIrqExitEvent(const MessageLite & event) const630 bool HtraceEventParser::SoftIrqExitEvent(const MessageLite& event) const
631 {
632 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_RECEIVED);
633 const auto msg = static_cast<const SoftirqExitFormat&>(event);
634 streamFilters_->irqFilter_->SoftIrqExit(eventTimestamp_, eventCpu_, static_cast<uint32_t>(msg.vec()));
635 return true;
636 }
SysEnterEvent(const MessageLite & event) const637 bool HtraceEventParser::SysEnterEvent(const MessageLite& event) const
638 {
639 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SYS_ENTRY, STAT_EVENT_RECEIVED);
640 const auto msg = static_cast<const SysEnterFormat&>(event);
641 auto ipid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventPid_);
642 traceDataCache_->GetSysCallData()->AppendSysCallData(msg.id(), sysEnterName_, ipid, eventTimestamp_, 0);
643 return true;
644 }
SysExitEvent(const MessageLite & event) const645 bool HtraceEventParser::SysExitEvent(const MessageLite& event) const
646 {
647 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SYS_EXIT, STAT_EVENT_RECEIVED);
648 const auto msg = static_cast<const SysExitFormat&>(event);
649 auto ipid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventPid_);
650 traceDataCache_->GetSysCallData()->AppendSysCallData(msg.id(), sysExitName_, ipid, eventTimestamp_, msg.ret());
651 return true;
652 }
653
OomScoreAdjUpdate(const MessageLite & event) const654 bool HtraceEventParser::OomScoreAdjUpdate(const MessageLite& event) const
655 {
656 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE, STAT_EVENT_RECEIVED);
657 const auto msg = static_cast<const OomScoreAdjUpdateFormat&>(event);
658 streamFilters_->processMeasureFilter_->AppendNewMeasureData(msg.pid(), oomScoreAdjName_, eventTimestamp_,
659 msg.oom_score_adj());
660 return true;
661 }
662
SignalGenerateEvent(const MessageLite & event) const663 bool HtraceEventParser::SignalGenerateEvent(const MessageLite& event) const
664 {
665 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BLOCK_BIO_BACKMERGE, STAT_EVENT_RECEIVED);
666 const auto msg = static_cast<const SignalGenerateFormat&>(event);
667 InternalTid internalTid =
668 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(eventTimestamp_, msg.pid(), msg.comm());
669 streamFilters_->threadFilter_->AppendNewMeasureData(internalTid, signalGenerateId_, eventTimestamp_, msg.sig());
670 return true;
671 }
SignalDeleverEvent(const MessageLite & event) const672 bool HtraceEventParser::SignalDeleverEvent(const MessageLite& event) const
673 {
674 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BLOCK_BIO_BACKMERGE, STAT_EVENT_RECEIVED);
675 const auto msg = static_cast<const SignalDeliverFormat&>(event);
676 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(eventTimestamp_, eventPid_);
677 streamFilters_->threadFilter_->AppendNewMeasureData(internalTid, signalDeliverId_, eventTimestamp_, msg.sig());
678 return true;
679 }
InvokeFunc(const SupportedTraceEventType & eventType,const MessageLite & msgBase)680 bool HtraceEventParser::InvokeFunc(const SupportedTraceEventType& eventType, const MessageLite& msgBase)
681 {
682 auto eventName = config_.eventNameMap_.find(eventType);
683 if (eventName == config_.eventNameMap_.end()) {
684 // log warn
685 streamFilters_->statFilter_->IncreaseStat(eventType, STAT_EVENT_NOTSUPPORTED);
686 return false;
687 }
688 auto it = eventToFunctionMap_.find(eventName->second);
689 if (it == eventToFunctionMap_.end()) {
690 // log warn
691 streamFilters_->statFilter_->IncreaseStat(eventType, STAT_EVENT_NOTSUPPORTED);
692 return false;
693 }
694 it->second(msgBase);
695 return true;
696 }
FilterAllEventsTemp()697 void HtraceEventParser::FilterAllEventsTemp()
698 {
699 size_t maxBuffSize = 1000 * 1000;
700 size_t maxQueue = 2;
701 if (eventList_.size() < maxBuffSize * maxQueue) {
702 return;
703 }
704 auto cmp = [](const std::unique_ptr<EventInfo>& a, const std::unique_ptr<EventInfo>& b) {
705 return a->eventTimestamp_ < b->eventTimestamp_;
706 };
707 std::sort(eventList_.begin(), eventList_.end(), cmp);
708
709 auto endOfList = eventList_.begin() + maxBuffSize;
710 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
711 EventInfo* event = itor->get();
712 eventTimestamp_ = event->eventTimestamp_;
713 eventCpu_ = event->eventCpu_;
714 eventPid_ = event->eventPid_;
715 eventTid_ = event->eventTid_;
716 comm_ = event->common_;
717 DealEvent(event->cpuDetail_);
718 itor->reset();
719 }
720 eventList_.erase(eventList_.begin(), endOfList);
721 }
FilterAllEvents()722 void HtraceEventParser::FilterAllEvents()
723 {
724 auto cmp = [](const std::unique_ptr<EventInfo>& a, const std::unique_ptr<EventInfo>& b) {
725 return a->eventTimestamp_ < b->eventTimestamp_;
726 };
727 std::sort(eventList_.begin(), eventList_.end(), cmp);
728 size_t maxBuffSize = 1000 * 1000;
729
730 while (eventList_.size()) {
731 int size = std::min(maxBuffSize, eventList_.size());
732 auto endOfList = eventList_.begin() + size;
733 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
734 EventInfo* event = itor->get();
735 eventTimestamp_ = event->eventTimestamp_;
736 eventCpu_ = event->eventCpu_;
737 eventPid_ = event->eventPid_;
738 eventTid_ = event->eventTid_;
739 comm_ = event->common_;
740 DealEvent(event->cpuDetail_);
741 itor->reset();
742 }
743 eventList_.erase(eventList_.begin(), endOfList);
744 }
745 eventList_.clear();
746 streamFilters_->cpuFilter_->Finish();
747 traceDataCache_->dataDict_.Finish();
748 traceDataCache_->UpdataZeroThreadInfo();
749 }
Clear() const750 void HtraceEventParser::Clear() const
751 {
752 streamFilters_->binderFilter_->Clear();
753 streamFilters_->sliceFilter_->Clear();
754 streamFilters_->cpuFilter_->Clear();
755 streamFilters_->irqFilter_->Clear();
756 streamFilters_->cpuMeasureFilter_->Clear();
757 streamFilters_->threadMeasureFilter_->Clear();
758 streamFilters_->threadFilter_->Clear();
759 streamFilters_->processMeasureFilter_->Clear();
760 streamFilters_->processFilterFilter_->Clear();
761 streamFilters_->symbolsFilter_->Clear();
762 streamFilters_->clockEnableFilter_->Clear();
763 streamFilters_->clockDisableFilter_->Clear();
764 streamFilters_->clkRateFilter_->Clear();
765 streamFilters_->clkDisableFilter_->Clear();
766 streamFilters_->binderFilter_->Clear();
767 streamFilters_->sysEventMemMeasureFilter_->Clear();
768 streamFilters_->sysEventVMemMeasureFilter_->Clear();
769 }
770 } // namespace TraceStreamer
771 } // namespace SysTuning
772