1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
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 SysTuning {
33 namespace TraceStreamer {
CpuDetailParser(TraceDataCache * dataCache,const TraceStreamerFilters * ctx)34 CpuDetailParser::CpuDetailParser(TraceDataCache *dataCache, const TraceStreamerFilters *ctx)
35 : streamFilters_(ctx), traceDataCache_(dataCache), printEventParser_(dataCache, ctx)
36 {
37 standAloneCpuEventList_.resize(CPU_CORE_MAX);
38 printEventParser_.SetTraceType(TRACE_FILETYPE_RAW_TRACE);
39 printEventParser_.SetTraceClockId(clock_);
40 eventToFunctionMap_ = {
41 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
42 std::bind(&CpuDetailParser::TaskRenameEvent, this, std::placeholders::_1)},
43 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
44 std::bind(&CpuDetailParser::TaskNewtaskEvent, this, std::placeholders::_1)},
45 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
46 std::bind(&CpuDetailParser::SchedSwitchEvent, this, std::placeholders::_1)},
47 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
48 std::bind(&CpuDetailParser::SchedBlockReasonEvent, this, std::placeholders::_1)},
49 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
50 std::bind(&CpuDetailParser::SchedWakeupEvent, this, std::placeholders::_1)},
51 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
52 std::bind(&CpuDetailParser::SchedWakingEvent, this, std::placeholders::_1)},
53 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
54 std::bind(&CpuDetailParser::SchedWakeupNewEvent, this, std::placeholders::_1)},
55 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
56 std::bind(&CpuDetailParser::ProcessExitEvent, this, std::placeholders::_1)},
57 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
58 std::bind(&CpuDetailParser::IpiHandlerEntryEvent, this, std::placeholders::_1)},
59 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
60 std::bind(&CpuDetailParser::IpiHandlerExitEvent, this, std::placeholders::_1)},
61 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_FREE),
62 std::bind(&CpuDetailParser::ProcessFreeEvent, this, std::placeholders::_1)},
63 {config_.eventNameMap_.at(TRACE_EVENT_SUSPEND_RESUME),
64 std::bind(&CpuDetailParser::SuspendResumeEvent, this, std::placeholders::_1)},
65 {config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
66 std::bind(&CpuDetailParser::ParseTracingMarkWriteOrPrintEvent, this, std::placeholders::_1)},
67 };
68 InterruptEventInitialization();
69 ClockEventInitialization();
70 CpuEventInitialization();
71 LockEventInitialization();
72 BinderEventInitialization();
73 StackEventsInitialization();
74 VoltageEventInitialization();
75 }
76
InterruptEventInitialization()77 void CpuDetailParser::InterruptEventInitialization()
78 {
79 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
80 std::bind(&CpuDetailParser::IrqHandlerEntryEvent, this, std::placeholders::_1));
81 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
82 std::bind(&CpuDetailParser::IrqHandlerExitEvent, this, std::placeholders::_1));
83 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
84 std::bind(&CpuDetailParser::SoftIrqRaiseEvent, this, std::placeholders::_1));
85 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
86 std::bind(&CpuDetailParser::SoftIrqEntryEvent, this, std::placeholders::_1));
87 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
88 std::bind(&CpuDetailParser::SoftIrqExitEvent, this, std::placeholders::_1));
89 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT),
90 std::bind(&CpuDetailParser::DmaFenceInitEvent, this, std::placeholders::_1));
91 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY),
92 std::bind(&CpuDetailParser::DmaFenceDestroyEvent, this, std::placeholders::_1));
93 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE),
94 std::bind(&CpuDetailParser::DmaFenceEnableEvent, this, std::placeholders::_1));
95 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED),
96 std::bind(&CpuDetailParser::DmaFenceSignaledEvent, this, std::placeholders::_1));
97 }
ClockEventInitialization()98 void CpuDetailParser::ClockEventInitialization()
99 {
100 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
101 std::bind(&CpuDetailParser::SetRateEvent, this, std::placeholders::_1));
102 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
103 std::bind(&CpuDetailParser::ClockEnableEvent, this, std::placeholders::_1));
104 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
105 std::bind(&CpuDetailParser::ClockDisableEvent, this, std::placeholders::_1));
106 }
CpuEventInitialization()107 void CpuDetailParser::CpuEventInitialization()
108 {
109 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
110 std::bind(&CpuDetailParser::CpuIdleEvent, this, std::placeholders::_1));
111 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
112 std::bind(&CpuDetailParser::CpuFrequencyEvent, this, std::placeholders::_1));
113 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
114 std::bind(&CpuDetailParser::CpuFrequencyLimitsEvent, this, std::placeholders::_1));
115 }
LockEventInitialization()116 void CpuDetailParser::LockEventInitialization()
117 {
118 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCK),
119 std::bind(&CpuDetailParser::BinderTractionLockEvent, this, std::placeholders::_1));
120 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCKED),
121 std::bind(&CpuDetailParser::BinderTractionLockedEvent, this, std::placeholders::_1));
122 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK),
123 std::bind(&CpuDetailParser::BinderTractionUnLockEvent, this, std::placeholders::_1));
124 }
BinderEventInitialization()125 void CpuDetailParser::BinderEventInitialization()
126 {
127 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
128 std::bind(&CpuDetailParser::BinderTractionEvent, this, std::placeholders::_1));
129 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
130 std::bind(&CpuDetailParser::BinderTractionReceivedEvent, this, std::placeholders::_1));
131 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
132 std::bind(&CpuDetailParser::BinderTractionAllocBufEvent, this, std::placeholders::_1));
133 }
StackEventsInitialization()134 void CpuDetailParser::StackEventsInitialization()
135 {
136 eventToFunctionMap_.emplace(
137 config_.eventNameMap_.at(TRACE_EVENT_PRINT),
138 std::bind(&CpuDetailParser::ParseTracingMarkWriteOrPrintEvent, this, std::placeholders::_1));
139 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
140 std::bind(&CpuDetailParser::WorkqueueExecuteStartEvent, this, std::placeholders::_1));
141 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
142 std::bind(&CpuDetailParser::WorkqueueExecuteEndEvent, this, std::placeholders::_1));
143 }
VoltageEventInitialization()144 void CpuDetailParser::VoltageEventInitialization()
145 {
146 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
147 std::bind(&CpuDetailParser::RegulatorSetVoltageEvent, this, std::placeholders::_1));
148 eventToFunctionMap_.emplace(
149 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
150 std::bind(&CpuDetailParser::RegulatorSetVoltageCompleteEvent, this, std::placeholders::_1));
151 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
152 std::bind(&CpuDetailParser::RegulatorDisableEvent, this, std::placeholders::_1));
153 eventToFunctionMap_.emplace(
154 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
155 std::bind(&CpuDetailParser::RegulatorDisableCompleteEvent, this, std::placeholders::_1));
156 }
EventAppend(std::shared_ptr<RawTraceEventInfo> event)157 void CpuDetailParser::EventAppend(std::shared_ptr<RawTraceEventInfo> event)
158 {
159 if (event->cpuId >= standAloneCpuEventList_.size()) {
160 TS_LOGW("cpuId: %u is invailed", event->cpuId);
161 return;
162 }
163 standAloneCpuEventList_[event->cpuId].emplace(std::move(event));
164 curRawTraceEventNum_++;
165 }
ResizeStandAloneCpuEventList(uint32_t cpuNum)166 void CpuDetailParser::ResizeStandAloneCpuEventList(uint32_t cpuNum)
167 {
168 cpuCoreMax_ = cpuNum;
169 standAloneCpuEventList_.resize(cpuNum);
170 }
SortStandAloneCpuEventList(bool isFinished)171 bool CpuDetailParser::SortStandAloneCpuEventList(bool isFinished)
172 {
173 while (curRawTraceEventNum_ > 0) {
174 uint32_t minTimeCpuId = INVALID_UINT32;
175 uint64_t curMinTs = INVALID_UINT64;
176 // select a min time from one of the cpu caches
177 for (int curCpuId = 0; curCpuId < cpuCoreMax_; curCpuId++) {
178 if (!isFinished && standAloneCpuEventList_[curCpuId].empty()) {
179 return true;
180 } else if (standAloneCpuEventList_[curCpuId].empty()) {
181 continue;
182 }
183 uint64_t ts = standAloneCpuEventList_[curCpuId].front()->msgPtr->timestamp();
184 if (ts < curMinTs) {
185 curMinTs = ts;
186 minTimeCpuId = curCpuId;
187 }
188 }
189 if (INVALID_UINT32 == minTimeCpuId) {
190 break;
191 }
192 rawTraceEventList_.emplace_back(std::move(standAloneCpuEventList_[minTimeCpuId].front()));
193 standAloneCpuEventList_[minTimeCpuId].pop();
194 curRawTraceEventNum_--;
195 if (!isFinished && standAloneCpuEventList_[minTimeCpuId].empty()) {
196 break;
197 }
198 }
199 return true;
200 }
UpdateCpuOverwrite(FtraceCpuDetailMsg & cpuDetail)201 void CpuDetailParser::UpdateCpuOverwrite(FtraceCpuDetailMsg &cpuDetail)
202 {
203 if (cpuDetail.overwrite()) {
204 if (!lastOverwrite_) {
205 lastOverwrite_ = cpuDetail.overwrite();
206 }
207 if (lastOverwrite_ != cpuDetail.overwrite()) {
208 TS_LOGW("lost events:%" PRIu64 "", cpuDetail.overwrite() - lastOverwrite_);
209 lastOverwrite_ = cpuDetail.overwrite();
210 }
211 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST);
212 }
213 }
FilterAllEvents(FtraceCpuDetailMsg & cpuDetail,bool isFinished)214 bool CpuDetailParser::FilterAllEvents(FtraceCpuDetailMsg &cpuDetail, bool isFinished)
215 {
216 UpdateCpuOverwrite(cpuDetail);
217 SortStandAloneCpuEventList(isFinished);
218 TS_CHECK_TRUE_RET(!rawTraceEventList_.empty(), true);
219 traceDataCache_->UpdateTraceTime(rawTraceEventList_.front()->msgPtr->timestamp());
220 traceDataCache_->UpdateTraceTime(rawTraceEventList_.back()->msgPtr->timestamp());
221 for (size_t i = 0; i < rawTraceEventList_.size(); i++) {
222 eventPid_ = rawTraceEventList_[i]->msgPtr->tgid();
223 if (eventPid_ != INVALID_INT32) {
224 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventPid_, eventPid_);
225 }
226 DealEvent(*rawTraceEventList_[i].get());
227 rawTraceEventList_[i].reset();
228 }
229 TS_LOGI("deal rawTraceEventList_.size=%zu", rawTraceEventList_.size());
230 rawTraceEventList_.clear();
231 cpuDetail.Clear();
232 return true;
233 }
Clear()234 void CpuDetailParser::Clear()
235 {
236 cpuCoreMax_ = CPU_CORE_MAX;
237 const_cast<TraceStreamerFilters *>(streamFilters_)->FilterClear();
238 streamFilters_->sysEventMemMeasureFilter_->Clear();
239 streamFilters_->sysEventVMemMeasureFilter_->Clear();
240 printEventParser_.Finish();
241 }
FinishCpuDetailParser()242 void CpuDetailParser::FinishCpuDetailParser()
243 {
244 streamFilters_->cpuFilter_->Finish();
245 traceDataCache_->dataDict_.Finish();
246 traceDataCache_->UpdataZeroThreadInfo();
247 if (traceDataCache_->AppStartTraceEnabled()) {
248 streamFilters_->appStartupFilter_->FilterAllAPPStartupData();
249 }
250 Clear();
251 traceDataCache_->GetThreadStateData()->SortAllRowByTs();
252 }
DealEvent(const RawTraceEventInfo & event)253 void CpuDetailParser::DealEvent(const RawTraceEventInfo &event)
254 {
255 eventTid_ = event.msgPtr->common_fields().pid();
256 if (eventTid_ != INVALID_INT32) {
257 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
258 }
259 if (eventTid_ != INVALID_INT32 && eventPid_ != INVALID_INT32) {
260 streamFilters_->processFilter_->GetOrCreateThreadWithPid(eventTid_, eventPid_);
261 }
262 const auto &eventName = FtraceEventProcessor::GetInstance().GetEventNameById(event.eventId);
263 auto iter = eventToFunctionMap_.find(eventName);
264 if (iter != eventToFunctionMap_.end()) {
265 iter->second(event);
266 } else {
267 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED);
268 }
269 }
SchedSwitchEvent(const RawTraceEventInfo & event)270 bool CpuDetailParser::SchedSwitchEvent(const RawTraceEventInfo &event)
271 {
272 auto schedSwitchMsg = event.msgPtr->sched_switch_format();
273 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED);
274
275 auto schedSwitchPrevState = schedSwitchMsg.prev_state();
276 auto nextInternalTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(
277 event.msgPtr->timestamp(), schedSwitchMsg.next_pid(), schedSwitchMsg.next_comm());
278 auto uprevtid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(
279 event.msgPtr->timestamp(), schedSwitchMsg.prev_pid(), schedSwitchMsg.prev_comm());
280
281 streamFilters_->cpuFilter_->InsertSwitchEvent(event.msgPtr->timestamp(), event.cpuId, uprevtid,
282 schedSwitchMsg.prev_prio(), schedSwitchPrevState, nextInternalTid,
283 schedSwitchMsg.next_prio(), INVALID_DATAINDEX);
284 return true;
285 }
SchedBlockReasonEvent(const RawTraceEventInfo & event)286 bool CpuDetailParser::SchedBlockReasonEvent(const RawTraceEventInfo &event)
287 {
288 auto reasonMsg = event.msgPtr->sched_blocked_reason_format();
289 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_RECEIVED);
290 std::string callerStr;
291 if (reasonMsg.caller_str().empty()) {
292 callerStr = "0x" + SysTuning::base::number(reasonMsg.caller(), SysTuning::base::INTEGER_RADIX_TYPE_HEX);
293 } else {
294 callerStr = reasonMsg.caller_str();
295 }
296 auto caller = traceDataCache_->GetDataIndex(std::string_view(callerStr));
297 auto itid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), reasonMsg.pid());
298 if (streamFilters_->cpuFilter_->InsertBlockedReasonEvent(event.cpuId, itid, reasonMsg.io_wait(), caller,
299 INVALID_UINT32)) {
300 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_RECEIVED);
301 } else {
302 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_NOTMATCH);
303 }
304 return true;
305 }
SchedWakeupEvent(const RawTraceEventInfo & event) const306 bool CpuDetailParser::SchedWakeupEvent(const RawTraceEventInfo &event) const
307 {
308 auto wakeupMsg = event.msgPtr->sched_wakeup_format();
309 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
310 auto instants = traceDataCache_->GetInstantsData();
311
312 InternalTid internalTid =
313 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeupMsg.pid());
314 InternalTid wakeupFromPid =
315 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
316 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakeupIndex_, internalTid, wakeupFromPid);
317 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid);
318 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKEUP, wakeupMsg.target_cpu(),
319 internalTid);
320 return true;
321 }
SchedWakingEvent(const RawTraceEventInfo & event) const322 bool CpuDetailParser::SchedWakingEvent(const RawTraceEventInfo &event) const
323 {
324 auto wakeingMsg = event.msgPtr->sched_waking_format();
325 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
326 auto instants = traceDataCache_->GetInstantsData();
327 auto internalTid =
328 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeingMsg.pid());
329 auto wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
330 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid, true);
331 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakingIndex_, internalTid, wakeupFromPid);
332 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKING, wakeingMsg.target_cpu(),
333 wakeupFromPid);
334 return true;
335 }
SchedWakeupNewEvent(const RawTraceEventInfo & event) const336 bool CpuDetailParser::SchedWakeupNewEvent(const RawTraceEventInfo &event) const
337 {
338 auto wakeupNewMsg = event.msgPtr->sched_wakeup_new_format();
339 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP_NEW, STAT_EVENT_RECEIVED);
340 auto instants = traceDataCache_->GetInstantsData();
341 auto internalTid =
342 streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), wakeupNewMsg.pid());
343 auto wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(event.msgPtr->timestamp(), eventTid_);
344 instants->AppendInstantEventData(event.msgPtr->timestamp(), schedWakeupNewIndex_, internalTid, wakeupFromPid);
345 streamFilters_->cpuFilter_->InsertWakeupEvent(event.msgPtr->timestamp(), internalTid);
346 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_SCHED_WAKEUP, wakeupNewMsg.target_cpu(),
347 internalTid);
348 return true;
349 }
ProcessExitEvent(const RawTraceEventInfo & event) const350 bool CpuDetailParser::ProcessExitEvent(const RawTraceEventInfo &event) const
351 {
352 auto procExitMsg = event.msgPtr->sched_process_exit_format();
353 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_RECEIVED);
354 uint32_t pidValue = procExitMsg.pid();
355 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
356 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), pidValue,
357 procExitMsg.comm());
358 if (streamFilters_->cpuFilter_->InsertProcessExitEvent(event.msgPtr->timestamp(), event.cpuId, iTid)) {
359 return true;
360 } else {
361 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_NOTMATCH);
362 return false;
363 }
364 }
ProcessFreeEvent(const RawTraceEventInfo & event) const365 bool CpuDetailParser::ProcessFreeEvent(const RawTraceEventInfo &event) const
366 {
367 auto procFreeMsg = event.msgPtr->sched_process_exit_format();
368 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_RECEIVED);
369 uint32_t pidValue = procFreeMsg.pid();
370 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
371 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), pidValue,
372 procFreeMsg.comm());
373 if (streamFilters_->cpuFilter_->InsertProcessFreeEvent(event.msgPtr->timestamp(), iTid)) {
374 return true;
375 } else {
376 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_FREE, STAT_EVENT_NOTMATCH);
377 return false;
378 }
379 }
BinderTractionEvent(const RawTraceEventInfo & event) const380 bool CpuDetailParser::BinderTractionEvent(const RawTraceEventInfo &event) const
381 {
382 auto transactionMsg = event.msgPtr->binder_transaction_format();
383 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_RECEIVED);
384 int32_t destNode = transactionMsg.target_node();
385 int32_t destTgid = transactionMsg.to_proc();
386 int32_t destTid = transactionMsg.to_thread();
387 int32_t transactionId = transactionMsg.debug_id();
388 bool isReply = transactionMsg.reply() == 1;
389 uint32_t flags = transactionMsg.flags();
390 TS_LOGD("destNode:%d, destTgid:%d, destTid:%d, transactionId:%d, isReply:%d flags:%d, code:%d", destNode, destTgid,
391 destTid, transactionId, isReply, flags, transactionMsg.code());
392 streamFilters_->binderFilter_->SendTraction(event.msgPtr->timestamp(), eventTid_, transactionId, destNode, destTgid,
393 destTid, isReply, flags, transactionMsg.code());
394 return true;
395 }
BinderTractionAllocBufEvent(const RawTraceEventInfo & event) const396 bool CpuDetailParser::BinderTractionAllocBufEvent(const RawTraceEventInfo &event) const
397 {
398 auto allocBufMsg = event.msgPtr->binder_transaction_alloc_buf_format();
399 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_RECEIVED);
400 streamFilters_->binderFilter_->TransactionAllocBuf(event.msgPtr->timestamp(), eventTid_, allocBufMsg.data_size(),
401 allocBufMsg.offsets_size());
402 TS_LOGD("dataSize:%" PRIu64 ", offsetSize:%" PRIu64 "", allocBufMsg.data_size(), allocBufMsg.offsets_size());
403 return true;
404 }
BinderTractionReceivedEvent(const RawTraceEventInfo & event) const405 bool CpuDetailParser::BinderTractionReceivedEvent(const RawTraceEventInfo &event) const
406 {
407 auto recvedMsg = event.msgPtr->binder_transaction_received_format();
408 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_RECEIVED);
409 int32_t transactionId = recvedMsg.debug_id();
410 streamFilters_->binderFilter_->ReceiveTraction(event.msgPtr->timestamp(), eventTid_, transactionId);
411 TS_LOGD("transactionId:%d", transactionId);
412 return true;
413 }
BinderTractionLockEvent(const RawTraceEventInfo & event) const414 bool CpuDetailParser::BinderTractionLockEvent(const RawTraceEventInfo &event) const
415 {
416 auto lockMsg = event.msgPtr->binder_lock_format();
417 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCK, STAT_EVENT_RECEIVED);
418 streamFilters_->binderFilter_->TractionLock(event.msgPtr->timestamp(), eventTid_, lockMsg.tag());
419 TS_LOGD("tag:%s", lockMsg.tag().c_str());
420 return true;
421 }
BinderTractionLockedEvent(const RawTraceEventInfo & event) const422 bool CpuDetailParser::BinderTractionLockedEvent(const RawTraceEventInfo &event) const
423 {
424 auto lockedMsg = event.msgPtr->binder_locked_format();
425 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, STAT_EVENT_RECEIVED);
426 streamFilters_->binderFilter_->TractionLocked(event.msgPtr->timestamp(), eventTid_, lockedMsg.tag());
427 return true;
428 }
BinderTractionUnLockEvent(const RawTraceEventInfo & event) const429 bool CpuDetailParser::BinderTractionUnLockEvent(const RawTraceEventInfo &event) const
430 {
431 auto unlockMsg = event.msgPtr->binder_unlock_format();
432 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, STAT_EVENT_RECEIVED);
433 streamFilters_->binderFilter_->TractionUnlock(event.msgPtr->timestamp(), eventTid_, unlockMsg.tag());
434 return true;
435 }
TaskRenameEvent(const RawTraceEventInfo & event) const436 bool CpuDetailParser::TaskRenameEvent(const RawTraceEventInfo &event) const
437 {
438 auto renameMsg = event.msgPtr->task_rename_format();
439 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED);
440 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(event.msgPtr->timestamp(), renameMsg.pid(),
441 renameMsg.newcomm());
442 return true;
443 }
TaskNewtaskEvent(const RawTraceEventInfo & event) const444 bool CpuDetailParser::TaskNewtaskEvent(const RawTraceEventInfo &event) const
445 {
446 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
447 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_NOTSUPPORTED);
448 return true;
449 }
ParseTracingMarkWriteOrPrintEvent(const RawTraceEventInfo & event)450 bool CpuDetailParser::ParseTracingMarkWriteOrPrintEvent(const RawTraceEventInfo &event)
451 {
452 auto printMsg = event.msgPtr->print_format();
453 BytraceLine line;
454 line.tgid = eventPid_;
455 line.pid = eventTid_;
456 line.ts = event.msgPtr->timestamp();
457 printEventParser_.ParsePrintEvent(event.msgPtr->comm(), line.ts, eventTid_, printMsg.buf(), line);
458 return true;
459 }
CpuIdleEvent(const RawTraceEventInfo & event) const460 bool CpuDetailParser::CpuIdleEvent(const RawTraceEventInfo &event) const
461 {
462 auto idleMsg = event.msgPtr->cpu_idle_format();
463 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
464 std::optional<uint32_t> eventCpu = idleMsg.cpu_id();
465 std::optional<uint64_t> newState = idleMsg.state();
466 if (!eventCpu.has_value()) {
467 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
468 TS_LOGW("Convert event cpu Failed");
469 return false;
470 }
471 if (!newState.has_value()) {
472 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
473 TS_LOGW("Convert event state Failed");
474 return false;
475 }
476
477 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpu.value(), cpuIdleIndex_,
478 event.msgPtr->timestamp(),
479 config_.GetStateValue(newState.value()));
480
481 // Add cpu_idle event to raw_data_table
482 traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_CPU_IDLE, eventCpu.value(), 0);
483 return true;
484 }
CpuFrequencyEvent(const RawTraceEventInfo & event) const485 bool CpuDetailParser::CpuFrequencyEvent(const RawTraceEventInfo &event) const
486 {
487 auto frequencyMsg = event.msgPtr->cpu_frequency_format();
488 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
489 std::optional<uint64_t> newState = frequencyMsg.state();
490 std::optional<uint32_t> eventCpu = frequencyMsg.cpu_id();
491
492 if (!newState.has_value()) {
493 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
494 TS_LOGW("Convert event state Failed");
495 return false;
496 }
497 if (!eventCpu.has_value()) {
498 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
499 TS_LOGW("Convert event cpu Failed");
500 return false;
501 }
502
503 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpu.value(), cpuFrequencyIndex_,
504 event.msgPtr->timestamp(), newState.value());
505 return true;
506 }
CpuFrequencyLimitsEvent(const RawTraceEventInfo & event) const507 bool CpuDetailParser::CpuFrequencyLimitsEvent(const RawTraceEventInfo &event) const
508 {
509 auto limitsMsg = event.msgPtr->cpu_frequency_limits_format();
510 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
511 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, limitsMsg.cpu_id(),
512 cpuFrequencyLimitMaxIndex_, event.msgPtr->timestamp(),
513 limitsMsg.max_freq());
514 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, limitsMsg.cpu_id(),
515 cpuFrequencyLimitMinIndex_, event.msgPtr->timestamp(),
516 limitsMsg.min_freq());
517 return true;
518 }
SuspendResumeEvent(const RawTraceEventInfo & event) const519 bool CpuDetailParser::SuspendResumeEvent(const RawTraceEventInfo &event) const
520 {
521 auto resumeMsg = event.msgPtr->suspend_resume_format();
522 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_RECEIVED);
523 int32_t val = resumeMsg.val();
524 uint32_t start = resumeMsg.start();
525 std::string action = resumeMsg.action();
526 Unused(val);
527 Unused(start);
528 Unused(action);
529 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SUSPEND_RESUME, STAT_EVENT_NOTSUPPORTED);
530 return true;
531 }
WorkqueueExecuteStartEvent(const RawTraceEventInfo & event) const532 bool CpuDetailParser::WorkqueueExecuteStartEvent(const RawTraceEventInfo &event) const
533 {
534 auto executeStartMsg = event.msgPtr->workqueue_execute_start_format();
535 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_RECEIVED);
536 auto funcNameIndex = traceDataCache_->GetSymbolsData()->GetFunc(executeStartMsg.function());
537 size_t result = INVALID_UINT32;
538 if (funcNameIndex == INVALID_UINT64) {
539 std::string addrStr = "0x" + base::number(executeStartMsg.function(), base::INTEGER_RADIX_TYPE_HEX);
540 auto addStrIndex = traceDataCache_->GetDataIndex(addrStr);
541 result = streamFilters_->sliceFilter_->BeginSlice(event.msgPtr->comm(), event.msgPtr->timestamp(), eventPid_,
542 eventPid_, workQueueIndex_, addStrIndex);
543 } else {
544 result = streamFilters_->sliceFilter_->BeginSlice(event.msgPtr->comm(), event.msgPtr->timestamp(), eventPid_,
545 eventPid_, workQueueIndex_, funcNameIndex);
546 }
547
548 traceDataCache_->GetInternalSlicesData()->AppendDistributeInfo();
549 if (result == INVALID_UINT32) {
550 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_DATA_LOST);
551 }
552 return true;
553 }
WorkqueueExecuteEndEvent(const RawTraceEventInfo & event) const554 bool CpuDetailParser::WorkqueueExecuteEndEvent(const RawTraceEventInfo &event) const
555 {
556 auto executeEndMsg = event.msgPtr->workqueue_execute_end_format();
557 if (!streamFilters_->sliceFilter_->EndSlice(event.msgPtr->timestamp(), eventPid_, eventPid_, workQueueIndex_)) {
558 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_NOTMATCH);
559 return false;
560 }
561 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
562 return true;
563 }
IrqHandlerEntryEvent(const RawTraceEventInfo & event) const564 bool CpuDetailParser::IrqHandlerEntryEvent(const RawTraceEventInfo &event) const
565 {
566 auto irqEntryMsg = event.msgPtr->irq_handler_entry_format();
567 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_RECEIVED);
568 // The tostdstring() here cannot use temporary variables, which will cause occasional garbled characters under wasm
569 streamFilters_->irqFilter_->IrqHandlerEntry(event.msgPtr->timestamp(), event.cpuId,
570 traceDataCache_->GetDataIndex(irqEntryMsg.name()));
571 return true;
572 }
IrqHandlerExitEvent(const RawTraceEventInfo & event) const573 bool CpuDetailParser::IrqHandlerExitEvent(const RawTraceEventInfo &event) const
574 {
575 auto irqExitMsg = event.msgPtr->irq_handler_exit_format();
576 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED);
577 streamFilters_->irqFilter_->IrqHandlerExit(event.msgPtr->timestamp(), event.cpuId, irqExitMsg.irq(),
578 static_cast<uint32_t>(irqExitMsg.ret()));
579 return true;
580 }
IpiHandlerEntryEvent(const RawTraceEventInfo & event) const581 bool CpuDetailParser::IpiHandlerEntryEvent(const RawTraceEventInfo &event) const
582 {
583 auto ipiEntryMsg = event.msgPtr->ipi_entry_format();
584 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_ENTRY, STAT_EVENT_RECEIVED);
585 streamFilters_->irqFilter_->IpiHandlerEntry(event.msgPtr->timestamp(), event.cpuId,
586 traceDataCache_->GetDataIndex(ipiEntryMsg.reason()));
587 return true;
588 }
IpiHandlerExitEvent(const RawTraceEventInfo & event) const589 bool CpuDetailParser::IpiHandlerExitEvent(const RawTraceEventInfo &event) const
590 {
591 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_EXIT, STAT_EVENT_RECEIVED);
592 streamFilters_->irqFilter_->IpiHandlerExit(event.msgPtr->timestamp(), event.cpuId);
593 return true;
594 }
SoftIrqEntryEvent(const RawTraceEventInfo & event) const595 bool CpuDetailParser::SoftIrqEntryEvent(const RawTraceEventInfo &event) const
596 {
597 auto softIrqEntryMsg = event.msgPtr->softirq_entry_format();
598 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_RECEIVED);
599 streamFilters_->irqFilter_->SoftIrqEntry(event.msgPtr->timestamp(), event.cpuId,
600 static_cast<uint32_t>(softIrqEntryMsg.vec()));
601 return true;
602 }
SoftIrqRaiseEvent(const RawTraceEventInfo & event) const603 bool CpuDetailParser::SoftIrqRaiseEvent(const RawTraceEventInfo &event) const
604 {
605 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_RECEIVED);
606 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_NOTSUPPORTED);
607 return true;
608 }
SoftIrqExitEvent(const RawTraceEventInfo & event) const609 bool CpuDetailParser::SoftIrqExitEvent(const RawTraceEventInfo &event) const
610 {
611 auto softIrqExitMsg = event.msgPtr->softirq_exit_format();
612 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_RECEIVED);
613 streamFilters_->irqFilter_->SoftIrqExit(event.msgPtr->timestamp(), event.cpuId,
614 static_cast<uint32_t>(softIrqExitMsg.vec()));
615 return true;
616 }
DmaFenceInitEvent(const RawTraceEventInfo & event) const617 bool CpuDetailParser::DmaFenceInitEvent(const RawTraceEventInfo &event) const
618 {
619 auto dmaFenceInitMsg = event.msgPtr->dma_fence_init_format();
620 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_INIT, STAT_EVENT_RECEIVED);
621 std::string timelineStr = dmaFenceInitMsg.timeline();
622 if (timelineStr.empty()) {
623 return false;
624 }
625 DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(),
626 0,
627 dmaFenceInitIndex_,
628 traceDataCache_->GetDataIndex(dmaFenceInitMsg.driver()),
629 traceDataCache_->GetDataIndex(timelineStr),
630 dmaFenceInitMsg.context(),
631 dmaFenceInitMsg.seqno()};
632 streamFilters_->sliceFilter_->DmaFence(dmaFenceRow);
633 return true;
634 }
DmaFenceDestroyEvent(const RawTraceEventInfo & event) const635 bool CpuDetailParser::DmaFenceDestroyEvent(const RawTraceEventInfo &event) const
636 {
637 auto dmaFenceDestroyMsg = event.msgPtr->dma_fence_destroy_format();
638 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_DESTROY, STAT_EVENT_RECEIVED);
639 std::string timelineStr = dmaFenceDestroyMsg.timeline();
640 if (timelineStr.empty()) {
641 return false;
642 }
643 DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(),
644 0,
645 dmaFenceDestroyIndex_,
646 traceDataCache_->GetDataIndex(dmaFenceDestroyMsg.driver()),
647 traceDataCache_->GetDataIndex(timelineStr),
648 dmaFenceDestroyMsg.context(),
649 dmaFenceDestroyMsg.seqno()};
650 streamFilters_->sliceFilter_->DmaFence(dmaFenceRow);
651 return true;
652 }
DmaFenceEnableEvent(const RawTraceEventInfo & event) const653 bool CpuDetailParser::DmaFenceEnableEvent(const RawTraceEventInfo &event) const
654 {
655 auto dmaFenceEnableMsg = event.msgPtr->dma_fence_enable_signal_format();
656 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_ENABLE, STAT_EVENT_RECEIVED);
657 std::string timelineStr = dmaFenceEnableMsg.timeline();
658 if (timelineStr.empty()) {
659 return false;
660 }
661 DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(),
662 0,
663 dmaFenceEnableIndex_,
664 traceDataCache_->GetDataIndex(dmaFenceEnableMsg.driver()),
665 traceDataCache_->GetDataIndex(timelineStr),
666 dmaFenceEnableMsg.context(),
667 dmaFenceEnableMsg.seqno()};
668 streamFilters_->sliceFilter_->DmaFence(dmaFenceRow);
669 return true;
670 }
DmaFenceSignaledEvent(const RawTraceEventInfo & event) const671 bool CpuDetailParser::DmaFenceSignaledEvent(const RawTraceEventInfo &event) const
672 {
673 auto dmaFenceSignaledMsg = event.msgPtr->dma_fence_signaled_format();
674 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_SIGNALED, STAT_EVENT_RECEIVED);
675 std::string timelineStr = dmaFenceSignaledMsg.timeline();
676 if (timelineStr.empty()) {
677 return false;
678 }
679 DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(),
680 0,
681 dmaFenceSignaledIndex_,
682 traceDataCache_->GetDataIndex(dmaFenceSignaledMsg.driver()),
683 traceDataCache_->GetDataIndex(timelineStr),
684 dmaFenceSignaledMsg.context(),
685 dmaFenceSignaledMsg.seqno()};
686 streamFilters_->sliceFilter_->DmaFence(dmaFenceRow);
687 return true;
688 }
SetRateEvent(const RawTraceEventInfo & event) const689 bool CpuDetailParser::SetRateEvent(const RawTraceEventInfo &event) const
690 {
691 auto clockSetRateMsg = event.msgPtr->clock_set_rate_format();
692 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockSetRateMsg.name());
693 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, clockSetRateMsg.cpu_id(),
694 nameIndex, event.msgPtr->timestamp(), clockSetRateMsg.state());
695 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
696 return true;
697 }
ClockEnableEvent(const RawTraceEventInfo & event) const698 bool CpuDetailParser::ClockEnableEvent(const RawTraceEventInfo &event) const
699 {
700 auto clockEnableMsg = event.msgPtr->clock_enable_format();
701 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockEnableMsg.name());
702 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_ENABLE, clockEnableMsg.cpu_id(),
703 nameIndex, event.msgPtr->timestamp(), clockEnableMsg.state());
704 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
705 return true;
706 }
ClockDisableEvent(const RawTraceEventInfo & event) const707 bool CpuDetailParser::ClockDisableEvent(const RawTraceEventInfo &event) const
708 {
709 auto clockDisableMsg = event.msgPtr->clock_disable_format();
710 DataIndex nameIndex = traceDataCache_->GetDataIndex(clockDisableMsg.name());
711 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, clockDisableMsg.cpu_id(),
712 nameIndex, event.msgPtr->timestamp(), clockDisableMsg.state());
713 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
714 return true;
715 }
RegulatorSetVoltageEvent(const RawTraceEventInfo & event) const716 bool CpuDetailParser::RegulatorSetVoltageEvent(const RawTraceEventInfo &event) const
717 {
718 Unused(event);
719 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_NOTSUPPORTED);
720 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_RECEIVED);
721 return true;
722 }
RegulatorSetVoltageCompleteEvent(const RawTraceEventInfo & event) const723 bool CpuDetailParser::RegulatorSetVoltageCompleteEvent(const RawTraceEventInfo &event) const
724 {
725 Unused(event);
726 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE,
727 STAT_EVENT_NOTSUPPORTED);
728 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, STAT_EVENT_RECEIVED);
729 return true;
730 }
RegulatorDisableEvent(const RawTraceEventInfo & event) const731 bool CpuDetailParser::RegulatorDisableEvent(const RawTraceEventInfo &event) const
732 {
733 Unused(event);
734 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_NOTSUPPORTED);
735 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_RECEIVED);
736 return true;
737 }
RegulatorDisableCompleteEvent(const RawTraceEventInfo & event) const738 bool CpuDetailParser::RegulatorDisableCompleteEvent(const RawTraceEventInfo &event) const
739 {
740 Unused(event);
741 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_NOTSUPPORTED);
742 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_RECEIVED);
743 return true;
744 }
745 } // namespace TraceStreamer
746 } // namespace SysTuning
747