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 "bytrace_event_parser.h"
17 #include "app_start_filter.h"
18 #include "binder_filter.h"
19 #include "cpu_filter.h"
20 #include "filter_filter.h"
21 #include "irq_filter.h"
22 #include "measure_filter.h"
23 #include "parting_string.h"
24 #include "process_filter.h"
25 #include "slice_filter.h"
26 #include "stat_filter.h"
27 #include "string_to_numerical.h"
28 #include "thread_state_flag.h"
29 #include "ts_common.h"
30 namespace SysTuning {
31 namespace TraceStreamer {
32 namespace {
GetFunctionName(const std::string_view & text,const std::string_view & delimiter)33 std::string GetFunctionName(const std::string_view& text, const std::string_view& delimiter)
34 {
35 std::string str("");
36 if (delimiter.empty()) {
37 return str;
38 }
39
40 std::size_t foundIndex = text.find(delimiter);
41 if (foundIndex != std::string::npos) {
42 std::size_t funIndex = foundIndex + delimiter.size();
43 str = std::string(text.substr(funIndex, text.size() - funIndex));
44 }
45 return str;
46 }
47 } // namespace
48
BytraceEventParser(TraceDataCache * dataCache,const TraceStreamerFilters * filter)49 BytraceEventParser::BytraceEventParser(TraceDataCache* dataCache, const TraceStreamerFilters* filter)
50 : EventParserBase(dataCache, filter), printEventParser_(traceDataCache_, streamFilters_)
51 {
52 printEventParser_.SetTraceType(TRACE_FILETYPE_BY_TRACE);
53 eventToFunctionMap_ = {
54 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
55 bind(&BytraceEventParser::TaskRenameEvent, this, std::placeholders::_1, std::placeholders::_2)},
56 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
57 bind(&BytraceEventParser::TaskNewtaskEvent, this, std::placeholders::_1, std::placeholders::_2)},
58 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
59 bind(&BytraceEventParser::SchedSwitchEvent, this, std::placeholders::_1, std::placeholders::_2)},
60 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
61 bind(&BytraceEventParser::BlockedReason, this, std::placeholders::_1, std::placeholders::_2)},
62 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
63 bind(&BytraceEventParser::SchedWakeupEvent, this, std::placeholders::_1, std::placeholders::_2)},
64 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
65 bind(&BytraceEventParser::SchedWakingEvent, this, std::placeholders::_1, std::placeholders::_2)},
66 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
67 bind(&BytraceEventParser::SchedWakeupEvent, this, std::placeholders::_1, std::placeholders::_2)},
68 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
69 bind(&BytraceEventParser::ProcessExitEvent, this, std::placeholders::_1, std::placeholders::_2)},
70 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
71 bind(&BytraceEventParser::IpiEntryEvent, this, std::placeholders::_1, std::placeholders::_2)},
72 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
73 bind(&BytraceEventParser::IpiExitEvent, this, std::placeholders::_1, std::placeholders::_2)},
74 };
75 InterruptEventInitialization();
76 ClockEventInitialization();
77 CpuEventInitialization();
78 RegulatorEventInitialization();
79 BinderEventInitialization();
80 StackEventsInitialization();
81 }
82
InterruptEventInitialization()83 void BytraceEventParser::InterruptEventInitialization()
84 {
85 // Interrupt and soft interrupt event initialization
86 eventToFunctionMap_.emplace(
87 config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
88 bind(&BytraceEventParser::IrqHandlerEntryEvent, this, std::placeholders::_1, std::placeholders::_2));
89 eventToFunctionMap_.emplace(
90 config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
91 bind(&BytraceEventParser::IrqHandlerExitEvent, this, std::placeholders::_1, std::placeholders::_2));
92 eventToFunctionMap_.emplace(
93 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
94 bind(&BytraceEventParser::SoftIrqRaiseEvent, this, std::placeholders::_1, std::placeholders::_2));
95 eventToFunctionMap_.emplace(
96 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
97 bind(&BytraceEventParser::SoftIrqEntryEvent, this, std::placeholders::_1, std::placeholders::_2));
98 eventToFunctionMap_.emplace(
99 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
100 bind(&BytraceEventParser::SoftIrqExitEvent, this, std::placeholders::_1, std::placeholders::_2));
101 }
102
ClockEventInitialization()103 void BytraceEventParser::ClockEventInitialization()
104 {
105 // Clock event initialization
106 eventToFunctionMap_.emplace(
107 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
108 bind(&BytraceEventParser::SetRateEvent, this, std::placeholders::_1, std::placeholders::_2));
109 eventToFunctionMap_.emplace(
110 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
111 bind(&BytraceEventParser::ClockEnableEvent, this, std::placeholders::_1, std::placeholders::_2));
112 eventToFunctionMap_.emplace(
113 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
114 bind(&BytraceEventParser::ClockDisableEvent, this, std::placeholders::_1, std::placeholders::_2));
115 }
116
CpuEventInitialization()117 void BytraceEventParser::CpuEventInitialization()
118 {
119 eventToFunctionMap_.emplace(
120 config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
121 bind(&BytraceEventParser::CpuIdleEvent, this, std::placeholders::_1, std::placeholders::_2));
122 eventToFunctionMap_.emplace(
123 config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
124 bind(&BytraceEventParser::CpuFrequencyEvent, this, std::placeholders::_1, std::placeholders::_2));
125 eventToFunctionMap_.emplace(
126 config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
127 bind(&BytraceEventParser::CpuFrequencyLimitsEvent, this, std::placeholders::_1, std::placeholders::_2));
128 }
129
RegulatorEventInitialization()130 void BytraceEventParser::RegulatorEventInitialization()
131 {
132 // Initialize regulator related events
133 eventToFunctionMap_.emplace(
134 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
135 bind(&BytraceEventParser::RegulatorSetVoltageEvent, this, std::placeholders::_1, std::placeholders::_2));
136 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
137 bind(&BytraceEventParser::RegulatorSetVoltageCompleteEvent, this, std::placeholders::_1,
138 std::placeholders::_2));
139 eventToFunctionMap_.emplace(
140 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
141 bind(&BytraceEventParser::RegulatorDisableEvent, this, std::placeholders::_1, std::placeholders::_2));
142 eventToFunctionMap_.emplace(
143 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
144 bind(&BytraceEventParser::RegulatorDisableCompleteEvent, this, std::placeholders::_1, std::placeholders::_2));
145 }
146
BinderEventInitialization()147 void BytraceEventParser::BinderEventInitialization()
148 {
149 // Binder event initialization
150 eventToFunctionMap_.emplace(
151 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
152 bind(&BytraceEventParser::BinderTransaction, this, std::placeholders::_1, std::placeholders::_2));
153 eventToFunctionMap_.emplace(
154 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
155 bind(&BytraceEventParser::BinderTransactionReceived, this, std::placeholders::_1, std::placeholders::_2));
156 eventToFunctionMap_.emplace(
157 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
158 bind(&BytraceEventParser::BinderTransactionAllocBufEvent, this, std::placeholders::_1, std::placeholders::_2));
159 }
160
StackEventsInitialization()161 void BytraceEventParser::StackEventsInitialization()
162 {
163 // Call stack Events
164 eventToFunctionMap_.emplace(
165 config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
166 bind(&BytraceEventParser::TracingMarkWriteOrPrintEvent, this, std::placeholders::_1, std::placeholders::_2));
167 eventToFunctionMap_.emplace(
168 config_.eventNameMap_.at(TRACE_EVENT_PRINT),
169 bind(&BytraceEventParser::TracingMarkWriteOrPrintEvent, this, std::placeholders::_1, std::placeholders::_2));
170 eventToFunctionMap_.emplace(
171 config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
172 bind(&BytraceEventParser::WorkqueueExecuteStartEvent, this, std::placeholders::_1, std::placeholders::_2));
173 eventToFunctionMap_.emplace(
174 config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
175 bind(&BytraceEventParser::WorkqueueExecuteEndEvent, this, std::placeholders::_1, std::placeholders::_2));
176 }
177
SchedSwitchEvent(const ArgsMap & args,const BytraceLine & line) const178 bool BytraceEventParser::SchedSwitchEvent(const ArgsMap& args, const BytraceLine& line) const
179 {
180 if (args.empty() || args.size() < MIN_SCHED_SWITCH_ARGS_COUNT) {
181 TS_LOGW("Failed to parse sched_switch event, no args or args size < 6, argsStr=%s.", line.argsStr.data());
182 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
183 return false;
184 }
185 auto prevCommStr = std::string_view(args.at("prev_comm"));
186 auto nextCommStr = std::string_view(args.at("next_comm"));
187 auto prevPrioValue = base::StrToInt<int32_t>(args.at("prev_prio"));
188 auto nextPrioValue = base::StrToInt<int32_t>(args.at("next_prio"));
189 auto prevPidValue = base::StrToInt<uint32_t>(args.at("prev_pid"));
190 auto nextPidValue = base::StrToInt<uint32_t>(args.at("next_pid"));
191 DataIndex nextInfo = INVALID_DATAINDEX;
192 auto nextInfoIt = args.find("next_info");
193 if (nextInfoIt != args.end()) {
194 nextInfo = traceDataCache_->GetDataIndex(std::string_view(args.at("next_info")));
195 }
196 if (!(prevPidValue.has_value() && prevPrioValue.has_value() && nextPidValue.has_value() &&
197 nextPrioValue.has_value())) {
198 TS_LOGD("Failed to parse sched_switch event");
199 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
200 return false;
201 }
202 auto prevStateStr = args.at("prev_state");
203 auto threadState = ThreadStateFlag(prevStateStr.c_str());
204 uint64_t prevState = threadState.State();
205 if (threadState.IsInvalid()) {
206 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
207 }
208 uint32_t nextInternalTid = 0;
209 uint32_t uprevtid = 0;
210 nextInternalTid =
211 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, nextPidValue.value(), nextCommStr);
212
213 if (!prevCommStr.empty()) {
214 uprevtid =
215 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, prevPidValue.value(), prevCommStr);
216 } else {
217 uprevtid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, prevPidValue.value());
218 }
219 streamFilters_->cpuFilter_->InsertSwitchEvent(
220 line.ts, line.cpu, uprevtid, static_cast<uint64_t>(prevPrioValue.value()), prevState, nextInternalTid,
221 static_cast<uint64_t>(nextPrioValue.value()), nextInfo);
222 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED);
223 return true;
224 }
BlockedReason(const ArgsMap & args,const BytraceLine & line) const225 bool BytraceEventParser::BlockedReason(const ArgsMap& args, const BytraceLine& line) const
226 {
227 if (args.empty() || args.size() < MIN_BLOCKED_REASON_ARGS_COUNT) {
228 TS_LOGD("Failed to parse blocked_reason event, no args or args size < %d", MIN_BLOCKED_REASON_ARGS_COUNT);
229 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_DATA_INVALID);
230 return false;
231 }
232 auto tid = base::StrToInt<int32_t>(args.at("pid"));
233 auto iowaitIt = args.find("iowait");
234 if (iowaitIt == args.end()) {
235 iowaitIt = args.find("io_wait");
236 }
237 auto iowait = base::StrToInt<int32_t>(iowaitIt->second);
238 uint32_t delayValue = INVALID_UINT32;
239 if (args.find("delay") != args.end()) {
240 auto delay = base::StrToInt<int32_t>(args.at("delay"));
241 delayValue = delay.has_value() ? delay.value() : INVALID_UINT32;
242 }
243 auto caller = traceDataCache_->GetDataIndex(std::string_view(args.at("caller")));
244 if (!(tid.has_value() && iowait.has_value())) {
245 TS_LOGD("Failed to parse blocked_reason event");
246 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_DATA_INVALID);
247 return false;
248 }
249 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, tid.value());
250
251 if (streamFilters_->cpuFilter_->InsertBlockedReasonEvent(line.ts, line.cpu, iTid, iowait.value(), caller,
252 delayValue)) {
253 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_RECEIVED);
254 } else {
255 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_NOTMATCH);
256 }
257 return true;
258 }
259
TaskRenameEvent(const ArgsMap & args,const BytraceLine & line) const260 bool BytraceEventParser::TaskRenameEvent(const ArgsMap& args, const BytraceLine& line) const
261 {
262 if (args.empty() || args.size() < MIN_TASK_RENAME_ARGS_COUNT) {
263 TS_LOGD("Failed to parse task_rename event, no args or args size < 2");
264 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_RENAME, STAT_EVENT_DATA_INVALID);
265 return false;
266 }
267 auto prevCommStr = std::string_view(args.at("newcomm"));
268 auto pidValue = base::StrToInt<uint32_t>(args.at("pid"));
269 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, pidValue.value(), prevCommStr);
270 return true;
271 }
272
TaskNewtaskEvent(const ArgsMap & args,const BytraceLine & line) const273 bool BytraceEventParser::TaskNewtaskEvent(const ArgsMap& args, const BytraceLine& line) const
274 {
275 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
276 // the clone flag from txt trace from kernel original is HEX, but when it is converted from proto
277 // based trace, it will be OCT number, it is not stable, so we decide to ignore it
278 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_NOTSUPPORTED);
279 return true;
280 }
281
TracingMarkWriteOrPrintEvent(const ArgsMap & args,const BytraceLine & line)282 bool BytraceEventParser::TracingMarkWriteOrPrintEvent(const ArgsMap& args, const BytraceLine& line)
283 {
284 Unused(args);
285 return printEventParser_.ParsePrintEvent(line.task, line.ts, line.pid, line.argsStr.c_str(), line);
286 }
287 // prefer to use waking, unless no waking, can use wakeup
SchedWakeupEvent(const ArgsMap & args,const BytraceLine & line) const288 bool BytraceEventParser::SchedWakeupEvent(const ArgsMap& args, const BytraceLine& line) const
289 {
290 if (args.size() < MIN_SCHED_WAKEUP_ARGS_COUNT) {
291 TS_LOGD("Failed to parse SchedWakeupEvent event, no args or args size < 2");
292 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID);
293 return false;
294 }
295 std::optional<uint32_t> wakePidValue = base::StrToInt<uint32_t>(args.at("pid"));
296 if (!wakePidValue.has_value()) {
297 TS_LOGD("Failed to convert wake_pid");
298 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID);
299 return false;
300 }
301 auto instants = traceDataCache_->GetInstantsData();
302 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, wakePidValue.value_or(0));
303 streamFilters_->cpuFilter_->InsertWakeupEvent(line.ts, internalTid);
304
305 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, line.pid);
306
307 instants->AppendInstantEventData(line.ts, schedWakeupName_, internalTid, wakeupFromPid);
308 std::optional<uint32_t> targetCpu = base::StrToInt<uint32_t>(args.at("target_cpu"));
309 if (targetCpu.has_value()) {
310 traceDataCache_->GetRawData()->AppendRawData(line.ts, RAW_SCHED_WAKEUP, targetCpu.value(), wakeupFromPid);
311 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
312 }
313 return true;
314 }
315
SchedWakingEvent(const ArgsMap & args,const BytraceLine & line) const316 bool BytraceEventParser::SchedWakingEvent(const ArgsMap& args, const BytraceLine& line) const
317 {
318 if (args.empty() || args.size() < MIN_SCHED_WAKING_ARGS_COUNT) {
319 TS_LOGD("Failed to parse sched_waking event, no args or args size < 4");
320 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_DATA_INVALID);
321 return false;
322 }
323 std::optional<uint32_t> wakePidValue = base::StrToInt<uint32_t>(args.at("pid"));
324 if (!wakePidValue.has_value()) {
325 TS_LOGD("Failed to convert wake_pid");
326 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_DATA_INVALID);
327 return false;
328 }
329 auto instants = traceDataCache_->GetInstantsData();
330 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, wakePidValue.value());
331 DataIndex wakeByPidStrIndex = traceDataCache_->GetDataIndex(line.task);
332 InternalTid internalTidWakeup =
333 streamFilters_->processFilter_->UpdateOrCreateThreadWithNameIndex(line.ts, line.pid, wakeByPidStrIndex);
334 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, line.pid);
335 streamFilters_->cpuFilter_->InsertWakeupEvent(line.ts, internalTid, true);
336 instants->AppendInstantEventData(line.ts, schedWakingName_, internalTid, wakeupFromPid);
337 std::optional<uint32_t> targetCpu = base::StrToInt<uint32_t>(args.at("target_cpu"));
338 if (targetCpu.has_value()) {
339 traceDataCache_->GetRawData()->AppendRawData(line.ts, RAW_SCHED_WAKING, targetCpu.value(), internalTidWakeup);
340 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
341 }
342
343 return true;
344 }
345
CpuIdleEvent(const ArgsMap & args,const BytraceLine & line) const346 bool BytraceEventParser::CpuIdleEvent(const ArgsMap& args, const BytraceLine& line) const
347 {
348 if (args.empty() || args.size() < MIN_CPU_IDLE_ARGS_COUNT) {
349 TS_LOGD("Failed to parse cpu_idle event, no args or args size < 2");
350 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
351 return false;
352 }
353 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
354 std::optional<int64_t> newStateValue = base::StrToInt<int64_t>(args.at("state"));
355 if (!eventCpuValue.has_value()) {
356 TS_LOGD("Failed to convert event cpu");
357 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
358 return false;
359 }
360 if (!newStateValue.has_value()) {
361 TS_LOGD("Failed to convert state");
362 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
363 return false;
364 }
365 // Add cpu_idle event to raw_data_table
366 auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
367 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuidleNameIndex, line.ts,
368 config_.GetStateValue(newStateValue.value()));
369 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
370 return true;
371 }
372
CpuFrequencyEvent(const ArgsMap & args,const BytraceLine & line) const373 bool BytraceEventParser::CpuFrequencyEvent(const ArgsMap& args, const BytraceLine& line) const
374 {
375 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
376 if (args.empty() || args.size() < MIN_CPU_FREQUENCY_ARGS_COUNT) {
377 TS_LOGD("Failed to parse cpu_frequency event, no args or args size < 2");
378 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
379 return false;
380 }
381 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
382 std::optional<int64_t> newStateValue = base::StrToInt<int64_t>(args.at("state"));
383
384 if (!newStateValue.has_value()) {
385 TS_LOGD("Failed to convert state");
386 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
387 return false;
388 }
389 if (!eventCpuValue.has_value()) {
390 TS_LOGD("Failed to convert event cpu");
391 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
392 return false;
393 }
394
395 auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
396 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuidleNameIndex, line.ts,
397 newStateValue.value());
398 return true;
399 }
CpuFrequencyLimitsEvent(const ArgsMap & args,const BytraceLine & line) const400 bool BytraceEventParser::CpuFrequencyLimitsEvent(const ArgsMap& args, const BytraceLine& line) const
401 {
402 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
403 if (args.empty() || args.size() < MIN_CPU_FREQUENCY_ARGS_COUNT) {
404 TS_LOGD("Failed to parse cpu_frequency event, no args or args size < 2");
405 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
406 return false;
407 }
408 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
409
410 auto minIt = args.find("min");
411 if (minIt == args.end()) {
412 minIt = args.find("min_freq");
413 }
414 auto maxIt = args.find("max");
415 if (maxIt == args.end()) {
416 maxIt = args.find("max_freq");
417 }
418 std::optional<int64_t> minValue = base::StrToInt<int64_t>(minIt->second);
419 std::optional<int64_t> maxValue = base::StrToInt<int64_t>(maxIt->second);
420
421 if (!minValue.has_value()) {
422 TS_LOGD("Failed to get frequency minValue");
423 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
424 return false;
425 }
426 if (!maxValue.has_value()) {
427 TS_LOGD("Failed to get frequency maxValue");
428 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
429 return false;
430 }
431 if (!eventCpuValue.has_value()) {
432 TS_LOGD("Failed to get frequency cpu");
433 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
434 return false;
435 }
436
437 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyLimitMaxNameId, line.ts,
438 maxValue.value());
439 streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyLimitMinNameId, line.ts,
440 minValue.value());
441 return true;
442 }
443
WorkqueueExecuteStartEvent(const ArgsMap & args,const BytraceLine & line) const444 bool BytraceEventParser::WorkqueueExecuteStartEvent(const ArgsMap& args, const BytraceLine& line) const
445 {
446 Unused(args);
447 auto splitStr = GetFunctionName(line.argsStr, "function ");
448 auto splitStrIndex = traceDataCache_->GetDataIndex(splitStr);
449 size_t result =
450 streamFilters_->sliceFilter_->BeginSlice(line.task, line.ts, line.pid, 0, workQueueId_, splitStrIndex);
451 traceDataCache_->GetInternalSlicesData()->AppendDistributeInfo();
452 if (result != INVALID_UINT32) {
453 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_RECEIVED);
454 return true;
455 } else {
456 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_DATA_LOST);
457 return false;
458 }
459 }
460
WorkqueueExecuteEndEvent(const ArgsMap & args,const BytraceLine & line) const461 bool BytraceEventParser::WorkqueueExecuteEndEvent(const ArgsMap& args, const BytraceLine& line) const
462 {
463 Unused(args);
464 if (streamFilters_->sliceFilter_->EndSlice(line.ts, line.pid, 0, workQueueId_)) {
465 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
466 return true;
467 } else {
468 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_NOTMATCH);
469 return false;
470 }
471 }
472
ProcessExitEvent(const ArgsMap & args,const BytraceLine & line) const473 bool BytraceEventParser::ProcessExitEvent(const ArgsMap& args, const BytraceLine& line) const
474 {
475 if (args.empty() || args.size() < MIN_PROCESS_EXIT_ARGS_COUNT) {
476 TS_LOGD("Failed to parse process_exit event, no args or args size < 2");
477 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_DATA_INVALID);
478 return false;
479 }
480 auto comm = std::string_view(args.at("comm"));
481 auto pid = base::StrToInt<uint32_t>(args.at("pid"));
482 if (!pid.has_value()) {
483 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_DATA_INVALID);
484 return false;
485 }
486 auto itid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, pid.value(), comm);
487 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_RECEIVED);
488 if (streamFilters_->cpuFilter_->InsertProcessExitEvent(line.ts, line.cpu, itid)) {
489 return true;
490 } else {
491 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_NOTMATCH);
492 return false;
493 }
494 }
495
SetRateEvent(const ArgsMap & args,const BytraceLine & line) const496 bool BytraceEventParser::SetRateEvent(const ArgsMap& args, const BytraceLine& line) const
497 {
498 if (args.empty() || args.size() < MIN_CLOCK_SET_RATE_ARGS_COUNT) {
499 TS_LOGD("Failed to parse clock_set_rate event, no args or args size < 3");
500 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_DATA_INVALID);
501 return false;
502 }
503 auto name = std::string_view(args.at("name"));
504 auto state = base::StrToInt<int64_t>(args.at("state"));
505 uint64_t cpu = 0;
506 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
507 streamFilters_->clockRateFilter_->AppendNewMeasureData(cpu, nameIndex, line.ts, state.value());
508 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
509 return true;
510 }
511
ClockEnableEvent(const ArgsMap & args,const BytraceLine & line) const512 bool BytraceEventParser::ClockEnableEvent(const ArgsMap& args, const BytraceLine& line) const
513 {
514 if (args.empty() || args.size() < MIN_CLOCK_ENABLE_ARGS_COUNT) {
515 TS_LOGD("Failed to parse clock_enable event, no args or args size < 3");
516 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_DATA_INVALID);
517 return false;
518 }
519 auto name = std::string_view(args.at("name"));
520 auto state = base::StrToInt<int64_t>(args.at("state"));
521 auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
522 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
523 streamFilters_->clockEnableFilter_->AppendNewMeasureData(cpuId.value(), nameIndex, line.ts, state.value());
524 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
525 return true;
526 }
ClockDisableEvent(const ArgsMap & args,const BytraceLine & line) const527 bool BytraceEventParser::ClockDisableEvent(const ArgsMap& args, const BytraceLine& line) const
528 {
529 if (args.empty() || args.size() < MIN_CLOCK_DISABLE_ARGS_COUNT) {
530 TS_LOGD("Failed to parse clock_disable event, no args or args size < 3");
531 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_DATA_INVALID);
532 return false;
533 }
534 auto name = std::string_view(args.at("name"));
535 auto state = base::StrToInt<int64_t>(args.at("state"));
536 auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
537 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
538 streamFilters_->clockDisableFilter_->AppendNewMeasureData(cpuId.value(), nameIndex, line.ts, state.value());
539 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
540 return true;
541 }
542
RegulatorSetVoltageEvent(const ArgsMap & args,const BytraceLine & line) const543 bool BytraceEventParser::RegulatorSetVoltageEvent(const ArgsMap& args, const BytraceLine& line) const
544 {
545 Unused(args);
546 Unused(line);
547 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_RECEIVED);
548 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_NOTSUPPORTED);
549 return true;
550 }
RegulatorSetVoltageCompleteEvent(const ArgsMap & args,const BytraceLine & line) const551 bool BytraceEventParser::RegulatorSetVoltageCompleteEvent(const ArgsMap& args, const BytraceLine& line) const
552 {
553 Unused(args);
554 Unused(line);
555 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, STAT_EVENT_RECEIVED);
556 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE,
557 STAT_EVENT_NOTSUPPORTED);
558 return true;
559 }
RegulatorDisableEvent(const ArgsMap & args,const BytraceLine & line) const560 bool BytraceEventParser::RegulatorDisableEvent(const ArgsMap& args, const BytraceLine& line) const
561 {
562 Unused(args);
563 Unused(line);
564 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_RECEIVED);
565 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_NOTSUPPORTED);
566 return true;
567 }
RegulatorDisableCompleteEvent(const ArgsMap & args,const BytraceLine & line) const568 bool BytraceEventParser::RegulatorDisableCompleteEvent(const ArgsMap& args, const BytraceLine& line) const
569 {
570 Unused(args);
571 Unused(line);
572 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_RECEIVED);
573 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_NOTSUPPORTED);
574 return true;
575 }
576
IpiEntryEvent(const ArgsMap & args,const BytraceLine & line) const577 bool BytraceEventParser::IpiEntryEvent(const ArgsMap& args, const BytraceLine& line) const
578 {
579 Unused(args);
580 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_ENTRY, STAT_EVENT_RECEIVED);
581 streamFilters_->irqFilter_->IpiHandlerEntry(line.ts, line.cpu, traceDataCache_->GetDataIndex(line.argsStr));
582 return true;
583 }
IpiExitEvent(const ArgsMap & args,const BytraceLine & line) const584 bool BytraceEventParser::IpiExitEvent(const ArgsMap& args, const BytraceLine& line) const
585 {
586 Unused(args);
587 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_EXIT, STAT_EVENT_RECEIVED);
588 streamFilters_->irqFilter_->IpiHandlerExit(line.ts, line.cpu);
589 return true;
590 }
IrqHandlerEntryEvent(const ArgsMap & args,const BytraceLine & line) const591 bool BytraceEventParser::IrqHandlerEntryEvent(const ArgsMap& args, const BytraceLine& line) const
592 {
593 if (args.empty() || args.size() < MIN_IRQ_HANDLER_ENTRY_ARGS_COUNT) {
594 TS_LOGD("Failed to parse irq_handler_entry event, no args or args size < 2");
595 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_DATA_INVALID);
596 return false;
597 }
598 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_RECEIVED);
599 auto name = std::string_view(args.at("name"));
600 streamFilters_->irqFilter_->IrqHandlerEntry(line.ts, line.cpu, traceDataCache_->GetDataIndex(name));
601 return true;
602 }
IrqHandlerExitEvent(const ArgsMap & args,const BytraceLine & line) const603 bool BytraceEventParser::IrqHandlerExitEvent(const ArgsMap& args, const BytraceLine& line) const
604 {
605 if (args.empty() || args.size() < MIN_IRQ_HANDLER_EXIT_ARGS_COUNT) {
606 TS_LOGD("Failed to parse irq_handler_exit event, no args or args size < 2");
607 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_DATA_INVALID);
608 return false;
609 }
610 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED);
611 uint32_t ret = (args.at("ret") == "handled") ? 1 : 0;
612 auto irq = base::StrToInt<uint32_t>(args.at("irq"));
613 streamFilters_->irqFilter_->IrqHandlerExit(line.ts, line.cpu, irq.value(), ret);
614 return true;
615 }
SoftIrqRaiseEvent(const ArgsMap & args,const BytraceLine & line) const616 bool BytraceEventParser::SoftIrqRaiseEvent(const ArgsMap& args, const BytraceLine& line) const
617 {
618 Unused(args);
619 Unused(line);
620 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_RECEIVED);
621 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_NOTSUPPORTED);
622 return true;
623 }
SoftIrqEntryEvent(const ArgsMap & args,const BytraceLine & line) const624 bool BytraceEventParser::SoftIrqEntryEvent(const ArgsMap& args, const BytraceLine& line) const
625 {
626 if (args.empty() || args.size() < MIN_SOFTIRQ_ENTRY_ARGS_COUNT) {
627 TS_LOGD("Failed to parse softirq_entry event, no args or args size < 2");
628 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_DATA_INVALID);
629 return false;
630 }
631 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_RECEIVED);
632 auto vec = base::StrToInt<uint32_t>(args.at("vec"));
633 streamFilters_->irqFilter_->SoftIrqEntry(line.ts, line.cpu, vec.value());
634 return true;
635 }
SoftIrqExitEvent(const ArgsMap & args,const BytraceLine & line) const636 bool BytraceEventParser::SoftIrqExitEvent(const ArgsMap& args, const BytraceLine& line) const
637 {
638 if (args.empty() || args.size() < MIN_SOFTIRQ_EXIT_ARGS_COUNT) {
639 TS_LOGD("Failed to parse softirq_exit event, no args or args size < 2");
640 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_INVALID);
641 return false;
642 }
643 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_RECEIVED);
644 auto vec = base::StrToInt<uint32_t>(args.at("vec"));
645 streamFilters_->irqFilter_->SoftIrqExit(line.ts, line.cpu, vec.value());
646 return true;
647 }
648
BinderTransaction(const ArgsMap & args,const BytraceLine & line) const649 bool BytraceEventParser::BinderTransaction(const ArgsMap& args, const BytraceLine& line) const
650 {
651 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_ARGS_COUNT) {
652 TS_LOGD("Failed to parse binder_transaction event, no args or args size < 7");
653 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_DATA_INVALID);
654 return false;
655 }
656 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_RECEIVED);
657 auto transactionId = base::StrToInt<int64_t>(args.at("transaction"));
658 auto destNode = base::StrToInt<uint32_t>(args.at("dest_node"));
659 auto destProc = base::StrToInt<uint32_t>(args.at("dest_proc"));
660 auto destThread = base::StrToInt<uint32_t>(args.at("dest_thread"));
661 auto isReply = base::StrToInt<uint32_t>(args.at("reply"));
662 auto flags = base::StrToInt<uint32_t>(args.at("flags"), base::INTEGER_RADIX_TYPE_HEX);
663 auto codeStr = base::StrToInt<uint32_t>(args.at("code"), base::INTEGER_RADIX_TYPE_HEX);
664 TS_LOGD("ts:%lu, pid:%u, destNode:%u, destTgid:%u, destTid:%u, transactionId:%lu, isReply:%u flags:%u, code:%u",
665 line.ts, line.pid, destNode.value(), destProc.value(), destThread.value(), transactionId.value(),
666 isReply.value(), flags.value(), codeStr.value());
667 streamFilters_->binderFilter_->SendTraction(line.ts, line.pid, transactionId.value(), destNode.value(),
668 destProc.value(), destThread.value(), isReply.value(), flags.value(),
669 codeStr.value());
670 if (traceDataCache_->BinderRunnableTraceEnabled() && transactionId.has_value() && flags.has_value() &&
671 !streamFilters_->binderFilter_->IsAsync(flags.value())) {
672 streamFilters_->cpuFilter_->InsertRunnableBinderEvent(transactionId.value(),
673 streamFilters_->processFilter_->GetInternalTid(line.pid));
674 }
675 return true;
676 }
BinderTransactionReceived(const ArgsMap & args,const BytraceLine & line) const677 bool BytraceEventParser::BinderTransactionReceived(const ArgsMap& args, const BytraceLine& line) const
678 {
679 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_RECEIVED_ARGS_COUNT) {
680 TS_LOGD("Failed to parse binder_transaction_received event, no args or args size < 1");
681 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_DATA_INVALID);
682 return false;
683 }
684 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_RECEIVED);
685 auto transactionId = base::StrToInt<int64_t>(args.at("transaction"));
686 streamFilters_->binderFilter_->ReceiveTraction(line.ts, line.pid, transactionId.value());
687 if (traceDataCache_->BinderRunnableTraceEnabled() && transactionId.has_value()) {
688 streamFilters_->cpuFilter_->InsertRunnableBinderRecvEvent(
689 transactionId.value(), streamFilters_->processFilter_->GetInternalTid(line.pid));
690 }
691 TS_LOGD("ts:%lu, pid:%u, transactionId:%lu", line.ts, line.pid, transactionId.value());
692 return true;
693 }
BinderTransactionAllocBufEvent(const ArgsMap & args,const BytraceLine & line) const694 bool BytraceEventParser::BinderTransactionAllocBufEvent(const ArgsMap& args, const BytraceLine& line) const
695 {
696 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_ALLOC_BUF_ARGS_COUNT) {
697 TS_LOGD("Failed to parse binder_transaction_alloc_buf event, no args or args size < 3");
698 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_DATA_INVALID);
699 return false;
700 }
701 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_RECEIVED);
702 auto dataSize = base::StrToInt<uint64_t>(args.at("data_size"));
703 auto offsetsSize = base::StrToInt<uint64_t>(args.at("offsets_size"));
704 streamFilters_->binderFilter_->TransactionAllocBuf(line.ts, line.pid, dataSize.value(), offsetsSize.value());
705 TS_LOGD("dataSize:%lu, offsetSize:%lu", dataSize.value(), offsetsSize.value());
706 return true;
707 }
ParseDataItem(const BytraceLine & line)708 void BytraceEventParser::ParseDataItem(const BytraceLine& line)
709 {
710 eventList_.push_back(std::make_unique<EventInfo>(line.ts, std::move(line)));
711 return;
712 }
GetDataSegArgs(BytraceLine & bufLine,ArgsMap & args,uint32_t & tgid) const713 void BytraceEventParser::GetDataSegArgs(BytraceLine& bufLine, ArgsMap& args, uint32_t& tgid) const
714 {
715 if (bufLine.tGidStr.size() && bufLine.tGidStr.at(0) != '-') {
716 tgid = base::StrToInt<uint32_t>(bufLine.tGidStr).value_or(0);
717 } else {
718 tgid = 0;
719 }
720 bufLine.tgid = tgid;
721
722 for (base::PartingString ss(bufLine.argsStr, ' '); ss.Next();) {
723 std::string key;
724 std::string value;
725 if (!(std::string(ss.GetCur()).find("=") != std::string::npos)) {
726 key = "name";
727 value = ss.GetCur();
728 args.emplace(std::move(key), std::move(value));
729 continue;
730 }
731 for (base::PartingString inner(ss.GetCur(), '='); inner.Next();) {
732 if (key.empty()) {
733 key = inner.GetCur();
734 } else {
735 value = inner.GetCur();
736 }
737 }
738 args.emplace(std::move(key), std::move(value));
739 }
740 }
FilterAllEventsTemp()741 void BytraceEventParser::FilterAllEventsTemp()
742 {
743 size_t maxBuffSize = 1000 * 1000;
744 size_t maxQueue = 2;
745 if (eventList_.size() < maxBuffSize * maxQueue) {
746 return;
747 }
748 auto cmp = [](const std::unique_ptr<EventInfo>& a, const std::unique_ptr<EventInfo>& b) {
749 return a->eventTimestamp < b->eventTimestamp;
750 };
751 std::stable_sort(eventList_.begin(), eventList_.end(), cmp);
752 auto endOfList = eventList_.begin() + maxBuffSize;
753 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
754 EventInfo* event = itor->get();
755 BeginFilterEvents(event);
756 itor->reset();
757 }
758 eventList_.erase(eventList_.begin(), endOfList);
759 }
760
FilterAllEvents()761 void BytraceEventParser::FilterAllEvents()
762 {
763 auto cmp = [](const std::unique_ptr<EventInfo>& a, const std::unique_ptr<EventInfo>& b) {
764 return a->eventTimestamp < b->eventTimestamp;
765 };
766 std::stable_sort(eventList_.begin(), eventList_.end(), cmp);
767 size_t maxBuffSize = 1000 * 1000;
768 while (eventList_.size()) {
769 int32_t size = std::min(maxBuffSize, eventList_.size());
770 auto endOfList = eventList_.begin() + size;
771 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
772 EventInfo* event = itor->get();
773 BeginFilterEvents(event);
774 itor->reset();
775 }
776 eventList_.erase(eventList_.begin(), endOfList);
777 }
778 eventList_.clear();
779 streamFilters_->cpuFilter_->Finish();
780 traceDataCache_->dataDict_.Finish();
781 traceDataCache_->UpdataZeroThreadInfo();
782 if (traceDataCache_->AppStartTraceEnabled()) {
783 streamFilters_->appStartupFilter_->FilterAllAPPStartupData();
784 }
785 traceDataCache_->GetThreadStateData()->SortAllRowByTs();
786 }
787
BeginFilterEvents(EventInfo * event)788 void BytraceEventParser::BeginFilterEvents(EventInfo* event)
789 {
790 auto it = eventToFunctionMap_.find(event->line.eventName);
791 if (it != eventToFunctionMap_.end()) {
792 uint32_t tgid;
793 ArgsMap args;
794 GetDataSegArgs(event->line, args, tgid);
795 if (tgid) {
796 streamFilters_->processFilter_->UpdateOrCreateThreadWithPidAndName(event->line.pid, tgid, event->line.task);
797 } else {
798 // When tgid is zero, only use tid create thread
799 streamFilters_->processFilter_->GetOrCreateThreadWithPid(event->line.pid, tgid);
800 }
801 if (it->second(args, event->line)) {
802 traceDataCache_->UpdateTraceTime(event->line.ts);
803 }
804 } else {
805 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED);
806 TS_LOGD("UnRecognizable event name:%s", event->line.eventName.c_str());
807 }
808 }
809
Clear()810 void BytraceEventParser::Clear()
811 {
812 const_cast<TraceStreamerFilters*>(streamFilters_)->FilterClear();
813 printEventParser_.Finish();
814 }
815 } // namespace TraceStreamer
816 } // namespace SysTuning
817