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
16 #include "cpu_detail_parser.h"
17 #include <cinttypes>
18 #include <string_view>
19 #include "app_start_filter.h"
20 #include "binder_filter.h"
21 #include "common_types.h"
22 #include "cpu_filter.h"
23 #include "irq_filter.h"
24 #include "measure_filter.h"
25 #include "process_filter.h"
26 #include "slice_filter.h"
27 #include "stat_filter.h"
28 #include "system_event_measure_filter.h"
29 #include "ftrace_event_processor.h"
30 #include "string_to_numerical.h"
31
32 namespace {
33 constexpr uint64_t FILTER_MAX_SIZE = 3000000;
34 }
35 namespace SysTuning {
36 namespace TraceStreamer {
CpuDetailParser(TraceDataCache * dataCache,const TraceStreamerFilters * ctx)37 CpuDetailParser::CpuDetailParser(TraceDataCache* dataCache, const TraceStreamerFilters* ctx)
38 : streamFilters_(ctx), traceDataCache_(dataCache), printEventParser_(dataCache, ctx)
39 {
40 printEventParser_.SetTraceType(TRACE_FILETYPE_RAW_TRACE);
41 printEventParser_.SetTraceClockId(clock_);
42 eventToFunctionMap_ = {
43 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
44 std::bind(&CpuDetailParser::TaskRenameEvent, this, std::placeholders::_1)},
45 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
46 std::bind(&CpuDetailParser::TaskNewtaskEvent, this, std::placeholders::_1)},
47 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
48 std::bind(&CpuDetailParser::SchedSwitchEvent, this, std::placeholders::_1)},
49 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
50 std::bind(&CpuDetailParser::SchedBlockReasonEvent, this, std::placeholders::_1)},
51 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
52 std::bind(&CpuDetailParser::SchedWakeupEvent, this, std::placeholders::_1)},
53 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
54 std::bind(&CpuDetailParser::SchedWakingEvent, this, std::placeholders::_1)},
55 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
56 std::bind(&CpuDetailParser::SchedWakeupNewEvent, this, std::placeholders::_1)},
57 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
58 std::bind(&CpuDetailParser::ProcessExitEvent, this, std::placeholders::_1)},
59 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
60 std::bind(&CpuDetailParser::IpiHandlerEntryEvent, this, std::placeholders::_1)},
61 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
62 std::bind(&CpuDetailParser::IpiHandlerExitEvent, this, std::placeholders::_1)},
63 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_FREE),
64 std::bind(&CpuDetailParser::ProcessFreeEvent, this, std::placeholders::_1)},
65 {config_.eventNameMap_.at(TRACE_EVENT_SUSPEND_RESUME),
66 std::bind(&CpuDetailParser::SuspendResumeEvent, this, std::placeholders::_1)},
67 {config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
68 std::bind(&CpuDetailParser::ParseTracingMarkWriteOrPrintEvent, this, std::placeholders::_1)},
69 };
70 InterruptEventInitialization();
71 ClockEventInitialization();
72 CpuEventInitialization();
73 LockEventInitialization();
74 BinderEventInitialization();
75 StackEventsInitialization();
76 VoltageEventInitialization();
77 }
78
InterruptEventInitialization()79 void CpuDetailParser::InterruptEventInitialization()
80 {
81 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
82 std::bind(&CpuDetailParser::IrqHandlerEntryEvent, this, std::placeholders::_1));
83 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
84 std::bind(&CpuDetailParser::IrqHandlerExitEvent, this, std::placeholders::_1));
85 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
86 std::bind(&CpuDetailParser::SoftIrqRaiseEvent, this, std::placeholders::_1));
87 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
88 std::bind(&CpuDetailParser::SoftIrqEntryEvent, this, std::placeholders::_1));
89 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
90 std::bind(&CpuDetailParser::SoftIrqExitEvent, this, std::placeholders::_1));
91 }
ClockEventInitialization()92 void CpuDetailParser::ClockEventInitialization()
93 {
94 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
95 std::bind(&CpuDetailParser::SetRateEvent, this, std::placeholders::_1));
96 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
97 std::bind(&CpuDetailParser::ClockEnableEvent, this, std::placeholders::_1));
98 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
99 std::bind(&CpuDetailParser::ClockDisableEvent, this, std::placeholders::_1));
100 }
CpuEventInitialization()101 void CpuDetailParser::CpuEventInitialization()
102 {
103 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
104 std::bind(&CpuDetailParser::CpuIdleEvent, this, std::placeholders::_1));
105 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
106 std::bind(&CpuDetailParser::CpuFrequencyEvent, this, std::placeholders::_1));
107 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
108 std::bind(&CpuDetailParser::CpuFrequencyLimitsEvent, this, std::placeholders::_1));
109 }
LockEventInitialization()110 void CpuDetailParser::LockEventInitialization()
111 {
112 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCK),
113 std::bind(&CpuDetailParser::BinderTractionLockEvent, this, std::placeholders::_1));
114 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCKED),
115 std::bind(&CpuDetailParser::BinderTractionLockedEvent, this, std::placeholders::_1));
116 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK),
117 std::bind(&CpuDetailParser::BinderTractionUnLockEvent, this, std::placeholders::_1));
118 }
BinderEventInitialization()119 void CpuDetailParser::BinderEventInitialization()
120 {
121 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
122 std::bind(&CpuDetailParser::BinderTractionEvent, this, std::placeholders::_1));
123 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
124 std::bind(&CpuDetailParser::BinderTractionReceivedEvent, this, std::placeholders::_1));
125 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
126 std::bind(&CpuDetailParser::BinderTractionAllocBufEvent, this, std::placeholders::_1));
127 }
StackEventsInitialization()128 void CpuDetailParser::StackEventsInitialization()
129 {
130 eventToFunctionMap_.emplace(
131 config_.eventNameMap_.at(TRACE_EVENT_PRINT),
132 std::bind(&CpuDetailParser::ParseTracingMarkWriteOrPrintEvent, this, std::placeholders::_1));
133 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
134 std::bind(&CpuDetailParser::WorkqueueExecuteStartEvent, this, std::placeholders::_1));
135 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
136 std::bind(&CpuDetailParser::WorkqueueExecuteEndEvent, this, std::placeholders::_1));
137 }
VoltageEventInitialization()138 void CpuDetailParser::VoltageEventInitialization()
139 {
140 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
141 std::bind(&CpuDetailParser::RegulatorSetVoltageEvent, this, std::placeholders::_1));
142 eventToFunctionMap_.emplace(
143 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
144 std::bind(&CpuDetailParser::RegulatorSetVoltageCompleteEvent, this, std::placeholders::_1));
145 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
146 std::bind(&CpuDetailParser::RegulatorDisableEvent, this, std::placeholders::_1));
147 eventToFunctionMap_.emplace(
148 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
149 std::bind(&CpuDetailParser::RegulatorDisableCompleteEvent, this, std::placeholders::_1));
150 }
151
EventAppend(std::unique_ptr<RawTraceEventInfo> event)152 void CpuDetailParser::EventAppend(std::unique_ptr<RawTraceEventInfo> event)
153 {
154 rawTraceEventList_.emplace_back(std::move(event));
155 }
FilterAllEvents(FtraceCpuDetailMsg & cpuDetail,bool isFinished)156 bool CpuDetailParser::FilterAllEvents(FtraceCpuDetailMsg& cpuDetail, bool isFinished)
157 {
158 if (cpuDetail.overwrite()) {
159 if (!lastOverwrite_) {
160 lastOverwrite_ = cpuDetail.overwrite();
161 }
162 if (lastOverwrite_ != cpuDetail.overwrite()) {
163 TS_LOGW("lost events:%" PRIu64 "", cpuDetail.overwrite() - lastOverwrite_);
164 lastOverwrite_ = cpuDetail.overwrite();
165 }
166 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST);
167 }
168 if (!isFinished && rawTraceEventList_.size() < FILTER_MAX_SIZE) {
169 return false;
170 }
171 auto cmp = [](const std::unique_ptr<RawTraceEventInfo>& a, const std::unique_ptr<RawTraceEventInfo>& b) {
172 return a->msgPtr->timestamp() < b->msgPtr->timestamp();
173 };
174 std::stable_sort(rawTraceEventList_.begin(), rawTraceEventList_.end(), cmp);
175 if (rawTraceEventList_.empty()) {
176 return false;
177 }
178 traceDataCache_->UpdateTraceTime(rawTraceEventList_.front()->msgPtr->timestamp());
179 traceDataCache_->UpdateTraceTime(rawTraceEventList_.back()->msgPtr->timestamp());
180 for (size_t i = 0; i < rawTraceEventList_.size(); i++) {
181 eventPid_ = rawTraceEventList_[i]->msgPtr->tgid();
182 if (eventPid_ != INVALID_INT32) {
183 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventPid_, eventPid_);
184 }
185 DealEvent(*rawTraceEventList_[i].get());
186 }
187 TS_LOGI("event_size=%d, rawTraceEventList_.size=%zu", cpuDetail.event().size(), rawTraceEventList_.size());
188 rawTraceEventList_.clear();
189 cpuDetail.Clear();
190 TS_CHECK_TRUE_RET(isFinished, true);
191 streamFilters_->cpuFilter_->Finish();
192 traceDataCache_->dataDict_.Finish();
193 traceDataCache_->UpdataZeroThreadInfo();
194 if (traceDataCache_->AppStartTraceEnabled()) {
195 streamFilters_->appStartupFilter_->FilterAllAPPStartupData();
196 }
197 Clear();
198 return true;
199 }
Clear()200 void CpuDetailParser::Clear()
201 {
202 const_cast<TraceStreamerFilters*>(streamFilters_)->FilterClear();
203 streamFilters_->sysEventMemMeasureFilter_->Clear();
204 streamFilters_->sysEventVMemMeasureFilter_->Clear();
205 printEventParser_.Finish();
206 }
DealEvent(const RawTraceEventInfo & event)207 void CpuDetailParser::DealEvent(const RawTraceEventInfo& event)
208 {
209 eventTid_ = event.msgPtr->common_fields().pid();
210 if (eventTid_ != INVALID_INT32) {
211 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
212 }
213 if (eventTid_ != INVALID_INT32 && eventPid_ != INVALID_INT32) {
214 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventTid_, eventPid_);
215 }
216 const auto& eventName = FtraceEventProcessor::GetInstance().GetEventNameById(event.eventId);
217 auto iter = eventToFunctionMap_.find(eventName);
218 if (iter != eventToFunctionMap_.end()) {
219 iter->second(event);
220 } else {
221 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED);
222 }
223 }
SchedSwitchEvent(const RawTraceEventInfo & event)224 bool CpuDetailParser::SchedSwitchEvent(const RawTraceEventInfo& event)
225 {
226 auto schedSwitchMsg = event.msgPtr->sched_switch_format();
227 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED);
228
229 auto schedSwitchPrevState = schedSwitchMsg.prev_state();
230 auto nextInternalTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(
231 event.msgPtr->timestamp(), schedSwitchMsg.next_pid(), schedSwitchMsg.next_comm());
232 auto uprevtid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(
233 event.msgPtr->timestamp(), schedSwitchMsg.prev_pid(), schedSwitchMsg.prev_comm());
234
235 streamFilters_->cpuFilter_->InsertSwitchEvent(
236 event.msgPtr->timestamp(), event.cpuId, uprevtid, static_cast<uint64_t>(schedSwitchMsg.prev_prio()),
237 schedSwitchPrevState, nextInternalTid, static_cast<uint64_t>(schedSwitchMsg.next_prio()), INVALID_DATAINDEX);
238 return true;
239 }
SchedBlockReasonEvent(const RawTraceEventInfo & event)240 bool CpuDetailParser::SchedBlockReasonEvent(const RawTraceEventInfo& event)
241 {
242 auto reasonMsg = event.msgPtr->sched_blocked_reason_format();
243 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_RECEIVED);
244 auto caller = traceDataCache_->GetDataIndex(
245 std::string_view("0x" + SysTuning::base::number(reasonMsg.caller(), SysTuning::base::INTEGER_RADIX_TYPE_HEX)));
246 auto itid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), reasonMsg.pid());
247 if (!streamFilters_->cpuFilter_->InsertBlockedReasonEvent(event.msgPtr->timestamp(), event.cpuId, itid,
248 reasonMsg.io_wait(), caller, INVALID_UINT32)) {
249 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_NOTMATCH);
250 }
251 return true;
252 }
SchedWakeupEvent(const RawTraceEventInfo & event) const253 bool CpuDetailParser::SchedWakeupEvent(const RawTraceEventInfo& event) const
254 {
255 auto wakeupMsg = event.msgPtr->sched_wakeup_format();
256 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
257 auto instants = traceDataCache_->GetInstantsData();
258
259 InternalTid internalTid =
260 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeupMsg.pid());
261 InternalTid wakeupFromPid =
262 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
263 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakeupIndex_, internalTid, wakeupFromPid);
264 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid);
265 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKEUP, wakeupMsg.target_cpu(),
266 internalTid);
267 return true;
268 }
SchedWakingEvent(const RawTraceEventInfo & event) const269 bool CpuDetailParser::SchedWakingEvent(const RawTraceEventInfo& event) const
270 {
271 auto wakeingMsg = event.msgPtr->sched_waking_format();
272 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
273 auto instants = traceDataCache_->GetInstantsData();
274 auto internalTid =
275 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeingMsg.pid());
276 auto wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
277 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid, true);
278 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakingIndex_, internalTid, wakeupFromPid);
279 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKING, wakeingMsg.target_cpu(),
280 wakeupFromPid);
281 return true;
282 }
SchedWakeupNewEvent(const RawTraceEventInfo & event) const283 bool CpuDetailParser::SchedWakeupNewEvent(const RawTraceEventInfo& event) const
284 {
285 auto wakeupNewMsg = event.msgPtr->sched_wakeup_new_format();
286 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP_NEW, STAT_EVENT_RECEIVED);
287 auto instants = traceDataCache_->GetInstantsData();
288 auto internalTid =
289 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeupNewMsg.pid());
290 auto wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
291 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakeupNewIndex_, internalTid, wakeupFromPid);
292 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid);
293 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKEUP, wakeupNewMsg.target_cpu(),
294 internalTid);
295 return true;
296 }
ProcessExitEvent(const RawTraceEventInfo & event) const297 bool CpuDetailParser::ProcessExitEvent(const RawTraceEventInfo& event) const
298 {
299 auto procExitMsg = event.msgPtr->sched_process_exit_format();
300 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_RECEIVED);
301 uint32_t pidValue = procExitMsg.pid();
302 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
303 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), pidValue,
304 procExitMsg.comm());
305 if (streamFilters_->cpuFilter_->InsertProcessExitEvent(event.msgPtr->timestamp(), event.cpuId, iTid)) {
306 return true;
307 } else {
308 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_NOTMATCH);
309 return false;
310 }
311 }
ProcessFreeEvent(const RawTraceEventInfo & event) const312 bool CpuDetailParser::ProcessFreeEvent(const RawTraceEventInfo& event) const
313 {
314 auto procFreeMsg = event.msgPtr->sched_process_exit_format();
315 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_RECEIVED);
316 uint32_t pidValue = procFreeMsg.pid();
317 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
318 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), pidValue,
319 procFreeMsg.comm());
320 if (streamFilters_->cpuFilter_->InsertProcessFreeEvent(event.msgPtr->timestamp(), iTid)) {
321 return true;
322 } else {
323 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_NOTMATCH);
324 return false;
325 }
326 }
BinderTractionEvent(const RawTraceEventInfo & event) const327 bool CpuDetailParser::BinderTractionEvent(const RawTraceEventInfo& event) const
328 {
329 auto transactionMsg = event.msgPtr->binder_transaction_format();
330 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_RECEIVED);
331 int32_t destNode = transactionMsg.target_node();
332 int32_t destTgid = transactionMsg.to_proc();
333 int32_t destTid = transactionMsg.to_thread();
334 int32_t transactionId = transactionMsg.debug_id();
335 bool isReply = transactionMsg.reply() == 1;
336 uint32_t flags = transactionMsg.flags();
337 TS_LOGD("destNode:%d, destTgid:%d, destTid:%d, transactionId:%d, isReply:%d flags:%d, code:%d", destNode, destTgid,
338 destTid, transactionId, isReply, flags, transactionMsg.code());
339 streamFilters_->binderFilter_->SendTraction(event.msgPtr->timestamp(), eventTid_, transactionId, destNode, destTgid,
340 destTid, isReply, flags, transactionMsg.code());
341 return true;
342 }
BinderTractionAllocBufEvent(const RawTraceEventInfo & event) const343 bool CpuDetailParser::BinderTractionAllocBufEvent(const RawTraceEventInfo& event) const
344 {
345 auto allocBufMsg = event.msgPtr->binder_transaction_alloc_buf_format();
346 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_RECEIVED);
347 streamFilters_->binderFilter_->TransactionAllocBuf(event.msgPtr->timestamp(), eventTid_, allocBufMsg.data_size(),
348 allocBufMsg.offsets_size());
349 TS_LOGD("dataSize:%" PRIu64 ", offsetSize:%" PRIu64 "", allocBufMsg.data_size(), allocBufMsg.offsets_size());
350 return true;
351 }
BinderTractionReceivedEvent(const RawTraceEventInfo & event) const352 bool CpuDetailParser::BinderTractionReceivedEvent(const RawTraceEventInfo& event) const
353 {
354 auto recvedMsg = event.msgPtr->binder_transaction_received_format();
355 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_RECEIVED);
356 int32_t transactionId = recvedMsg.debug_id();
357 streamFilters_->binderFilter_->ReceiveTraction(event.msgPtr->timestamp(), eventTid_, transactionId);
358 TS_LOGD("transactionId:%d", transactionId);
359 return true;
360 }
BinderTractionLockEvent(const RawTraceEventInfo & event) const361 bool CpuDetailParser::BinderTractionLockEvent(const RawTraceEventInfo& event) const
362 {
363 auto lockMsg = event.msgPtr->binder_lock_format();
364 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCK, STAT_EVENT_RECEIVED);
365 streamFilters_->binderFilter_->TractionLock(event.msgPtr->timestamp(), eventTid_, lockMsg.tag());
366 TS_LOGD("tag:%s", lockMsg.tag().c_str());
367 return true;
368 }
BinderTractionLockedEvent(const RawTraceEventInfo & event) const369 bool CpuDetailParser::BinderTractionLockedEvent(const RawTraceEventInfo& event) const
370 {
371 auto lockedMsg = event.msgPtr->binder_locked_format();
372 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, STAT_EVENT_RECEIVED);
373 streamFilters_->binderFilter_->TractionLocked(event.msgPtr->timestamp(), eventTid_, lockedMsg.tag());
374 return true;
375 }
BinderTractionUnLockEvent(const RawTraceEventInfo & event) const376 bool CpuDetailParser::BinderTractionUnLockEvent(const RawTraceEventInfo& event) const
377 {
378 auto unlockMsg = event.msgPtr->binder_unlock_format();
379 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, STAT_EVENT_RECEIVED);
380 streamFilters_->binderFilter_->TractionUnlock(event.msgPtr->timestamp(), eventTid_, unlockMsg.tag());
381 return true;
382 }
TaskRenameEvent(const RawTraceEventInfo & event) const383 bool CpuDetailParser::TaskRenameEvent(const RawTraceEventInfo& event) const
384 {
385 auto renameMsg = event.msgPtr->task_rename_format();
386 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED);
387 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), renameMsg.pid(),
388 renameMsg.newcomm());
389 return true;
390 }
TaskNewtaskEvent(const RawTraceEventInfo & event) const391 bool CpuDetailParser::TaskNewtaskEvent(const RawTraceEventInfo& event) const
392 {
393 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
394 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_NOTSUPPORTED);
395 return true;
396 }
ParseTracingMarkWriteOrPrintEvent(const RawTraceEventInfo & event)397 bool CpuDetailParser::ParseTracingMarkWriteOrPrintEvent(const RawTraceEventInfo& event)
398 {
399 auto printMsg = event.msgPtr->print_format();
400 BytraceLine line;
401 line.tgid = eventPid_;
402 line.pid = eventTid_;
403 line.ts = event.msgPtr->timestamp();
404 printEventParser_.ParsePrintEvent(event.msgPtr->comm(), line.ts, eventTid_, printMsg.buf(), line);
405 return true;
406 }
CpuIdleEvent(const RawTraceEventInfo & event) const407 bool CpuDetailParser::CpuIdleEvent(const RawTraceEventInfo& event) const
408 {
409 auto idleMsg = event.msgPtr->cpu_idle_format();
410 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
411 std::optional<uint32_t> eventCpu = idleMsg.cpu_id();
412 std::optional<uint64_t> newState = idleMsg.state();
413 if (!eventCpu.has_value()) {
414 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
415 TS_LOGW("Convert event cpu Failed");
416 return false;
417 }
418 if (!newState.has_value()) {
419 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
420 TS_LOGW("Convert event state Failed");
421 return false;
422 }
423
424 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpu.value(), cpuIdleIndex_, event.msgPtr->timestamp(),
425 config_.GetStateValue(newState.value()));
426
427 // Add cpu_idle event to raw_data_table
428 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_CPU_IDLE, eventCpu.value(), 0);
429 return true;
430 }
CpuFrequencyEvent(const RawTraceEventInfo & event) const431 bool CpuDetailParser::CpuFrequencyEvent(const RawTraceEventInfo& event) const
432 {
433 auto frequencyMsg = event.msgPtr->cpu_frequency_format();
434 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
435 std::optional<uint64_t> newState = frequencyMsg.state();
436 std::optional<uint32_t> eventCpu = frequencyMsg.cpu_id();
437
438 if (!newState.has_value()) {
439 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
440 TS_LOGW("Convert event state Failed");
441 return false;
442 }
443 if (!eventCpu.has_value()) {
444 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
445 TS_LOGW("Convert event cpu Failed");
446 return false;
447 }
448
449 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpu.value(), cpuFrequencyIndex_,
450 event.msgPtr->timestamp(), newState.value());
451 return true;
452 }
CpuFrequencyLimitsEvent(const RawTraceEventInfo & event) const453 bool CpuDetailParser::CpuFrequencyLimitsEvent(const RawTraceEventInfo& event) const
454 {
455 auto limitsMsg = event.msgPtr->cpu_frequency_limits_format();
456 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
457 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(limitsMsg.cpu_id(), cpuFrequencyLimitMaxIndex_,
458 event.msgPtr->timestamp(), limitsMsg.max_freq());
459 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(limitsMsg.cpu_id(), cpuFrequencyLimitMinIndex_,
460 event.msgPtr->timestamp(), limitsMsg.min_freq());
461 return true;
462 }
SuspendResumeEvent(const RawTraceEventInfo & event) const463 bool CpuDetailParser::SuspendResumeEvent(const RawTraceEventInfo& event) const
464 {
465 auto resumeMsg = event.msgPtr->suspend_resume_format();
466 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_RECEIVED);
467 int32_t val = resumeMsg.val();
468 uint32_t start = resumeMsg.start();
469 std::string action = resumeMsg.action();
470 Unused(val);
471 Unused(start);
472 Unused(action);
473 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_NOTSUPPORTED);
474 return true;
475 }
WorkqueueExecuteStartEvent(const RawTraceEventInfo & event) const476 bool CpuDetailParser::WorkqueueExecuteStartEvent(const RawTraceEventInfo& event) const
477 {
478 auto executeStartMsg = event.msgPtr->workqueue_execute_start_format();
479 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_RECEIVED);
480 auto funcNameIndex = traceDataCache_->GetSymbolsData()->GetFunc(executeStartMsg.function());
481 size_t result = INVALID_UINT32;
482 if (funcNameIndex == INVALID_UINT64) {
483 std::string addrStr = "0x" + base::number(executeStartMsg.function(), base::INTEGER_RADIX_TYPE_HEX);
484 auto addStrIndex = traceDataCache_->GetDataIndex(addrStr);
485 result = streamFilters_->sliceFilter_->BeginSlice(event.msgPtr->comm(), event.msgPtr->timestamp(), eventPid_,
486 eventPid_, workQueueIndex_, addStrIndex);
487 } else {
488 result = streamFilters_->sliceFilter_->BeginSlice(event.msgPtr->comm(), event.msgPtr->timestamp(), eventPid_,
489 eventPid_, workQueueIndex_, funcNameIndex);
490 }
491
492 traceDataCache_->GetInternalSlicesData()->AppendDistributeInfo();
493 if (result == INVALID_UINT32) {
494 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_DATA_LOST);
495 }
496 return true;
497 }
WorkqueueExecuteEndEvent(const RawTraceEventInfo & event) const498 bool CpuDetailParser::WorkqueueExecuteEndEvent(const RawTraceEventInfo& event) const
499 {
500 auto executeEndMsg = event.msgPtr->workqueue_execute_end_format();
501 if (!streamFilters_->sliceFilter_->EndSlice(event.msgPtr->timestamp(), eventPid_, eventPid_, workQueueIndex_)) {
502 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_NOTMATCH);
503 return false;
504 }
505 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
506 return true;
507 }
IrqHandlerEntryEvent(const RawTraceEventInfo & event) const508 bool CpuDetailParser::IrqHandlerEntryEvent(const RawTraceEventInfo& event) const
509 {
510 auto irqEntryMsg = event.msgPtr->irq_handler_entry_format();
511 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_RECEIVED);
512 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
513 streamFilters_->irqFilter_->IrqHandlerEntry(event.msgPtr->timestamp(), event.cpuId,
514 traceDataCache_->GetDataIndex(irqEntryMsg.name()));
515 return true;
516 }
IrqHandlerExitEvent(const RawTraceEventInfo & event) const517 bool CpuDetailParser::IrqHandlerExitEvent(const RawTraceEventInfo& event) const
518 {
519 auto irqExitMsg = event.msgPtr->irq_handler_exit_format();
520 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED);
521 streamFilters_->irqFilter_->IrqHandlerExit(event.msgPtr->timestamp(), event.cpuId, irqExitMsg.irq(),
522 static_cast<uint32_t>(irqExitMsg.ret()));
523 return true;
524 }
IpiHandlerEntryEvent(const RawTraceEventInfo & event) const525 bool CpuDetailParser::IpiHandlerEntryEvent(const RawTraceEventInfo& event) const
526 {
527 auto ipiEntryMsg = event.msgPtr->ipi_entry_format();
528 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_ENTRY, STAT_EVENT_RECEIVED);
529 streamFilters_->irqFilter_->IpiHandlerEntry(event.msgPtr->timestamp(), event.cpuId,
530 traceDataCache_->GetDataIndex(ipiEntryMsg.reason()));
531 return true;
532 }
IpiHandlerExitEvent(const RawTraceEventInfo & event) const533 bool CpuDetailParser::IpiHandlerExitEvent(const RawTraceEventInfo& event) const
534 {
535 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_EXIT, STAT_EVENT_RECEIVED);
536 streamFilters_->irqFilter_->IpiHandlerExit(event.msgPtr->timestamp(), event.cpuId);
537 return true;
538 }
SoftIrqEntryEvent(const RawTraceEventInfo & event) const539 bool CpuDetailParser::SoftIrqEntryEvent(const RawTraceEventInfo& event) const
540 {
541 auto softIrqEntryMsg = event.msgPtr->softirq_entry_format();
542 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_RECEIVED);
543 streamFilters_->irqFilter_->SoftIrqEntry(event.msgPtr->timestamp(), event.cpuId,
544 static_cast<uint32_t>(softIrqEntryMsg.vec()));
545 return true;
546 }
SoftIrqRaiseEvent(const RawTraceEventInfo & event) const547 bool CpuDetailParser::SoftIrqRaiseEvent(const RawTraceEventInfo& event) const
548 {
549 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_RECEIVED);
550 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_NOTSUPPORTED);
551 return true;
552 }
SoftIrqExitEvent(const RawTraceEventInfo & event) const553 bool CpuDetailParser::SoftIrqExitEvent(const RawTraceEventInfo& event) const
554 {
555 auto softIrqExitMsg = event.msgPtr->softirq_exit_format();
556 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_RECEIVED);
557 streamFilters_->irqFilter_->SoftIrqExit(event.msgPtr->timestamp(), event.cpuId,
558 static_cast<uint32_t>(softIrqExitMsg.vec()));
559 return true;
560 }
SetRateEvent(const RawTraceEventInfo & event) const561 bool CpuDetailParser::SetRateEvent(const RawTraceEventInfo& event) const
562 {
563 auto clockSetRateMsg = event.msgPtr->clock_set_rate_format();
564 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockSetRateMsg.name());
565 streamFilters_->clockRateFilter_->AppendNewMeasureData(clockSetRateMsg.cpu_id(), nameIndex,
566 event.msgPtr->timestamp(), clockSetRateMsg.state());
567 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
568 return true;
569 }
ClockEnableEvent(const RawTraceEventInfo & event) const570 bool CpuDetailParser::ClockEnableEvent(const RawTraceEventInfo& event) const
571 {
572 auto clockEnableMsg = event.msgPtr->clock_enable_format();
573 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockEnableMsg.name());
574 streamFilters_->clockEnableFilter_->AppendNewMeasureData(clockEnableMsg.cpu_id(), nameIndex,
575 event.msgPtr->timestamp(), clockEnableMsg.state());
576 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
577 return true;
578 }
ClockDisableEvent(const RawTraceEventInfo & event) const579 bool CpuDetailParser::ClockDisableEvent(const RawTraceEventInfo& event) const
580 {
581 auto clockDisableMsg = event.msgPtr->clock_disable_format();
582 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockDisableMsg.name());
583 streamFilters_->clockDisableFilter_->AppendNewMeasureData(clockDisableMsg.cpu_id(), nameIndex,
584 event.msgPtr->timestamp(), clockDisableMsg.state());
585 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
586 return true;
587 }
RegulatorSetVoltageEvent(const RawTraceEventInfo & event) const588 bool CpuDetailParser::RegulatorSetVoltageEvent(const RawTraceEventInfo& event) const
589 {
590 Unused(event);
591 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_NOTSUPPORTED);
592 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_RECEIVED);
593 return true;
594 }
RegulatorSetVoltageCompleteEvent(const RawTraceEventInfo & event) const595 bool CpuDetailParser::RegulatorSetVoltageCompleteEvent(const RawTraceEventInfo& event) const
596 {
597 Unused(event);
598 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE,
599 STAT_EVENT_NOTSUPPORTED);
600 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, STAT_EVENT_RECEIVED);
601 return true;
602 }
RegulatorDisableEvent(const RawTraceEventInfo & event) const603 bool CpuDetailParser::RegulatorDisableEvent(const RawTraceEventInfo& event) const
604 {
605 Unused(event);
606 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_NOTSUPPORTED);
607 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_RECEIVED);
608 return true;
609 }
RegulatorDisableCompleteEvent(const RawTraceEventInfo & event) const610 bool CpuDetailParser::RegulatorDisableCompleteEvent(const RawTraceEventInfo& event) const
611 {
612 Unused(event);
613 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_NOTSUPPORTED);
614 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_RECEIVED);
615 return true;
616 }
617 } // namespace TraceStreamer
618 } // namespace SysTuning
619