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 #include "sqllite_prepar_cache_data.h"
16 #include "sph_data.pb.h"
17
18 namespace SysTuning {
19 namespace TraceStreamer {
20 enum class SphQueryType : uint32_t {
21 CPU_DATA = 0,
22 CPU_STATE_DATA = 1,
23 CPU_FREQ_DATA = 2,
24 CPU_FREQ_LIMIT_DATA = 3,
25 CLOCK_DATA = 4,
26 IRQ_DATA = 5,
27 PROCESS_DATA = 6,
28 PROCESS_MEM_DATA = 7,
29 PROCESS_STARTUP_DATA = 8,
30 PROCESS_SO_INIT_DATA = 9,
31 HI_SYS_EVENT_DATA = 10,
32 LOG_DATA = 11,
33 VIRTUAL_MEM_DATA = 12,
34 ENERGY_SYSTEM_DATA = 13,
35 ENERGY_STATE_DATA = 14,
36 ENERGY_ANOMAL_DATA = 15,
37 FRAME_EXPECTED_DATA = 16,
38 FRAME_ACTUAL_DATA = 17,
39 FRAME_ANIMATION_DATA = 18,
40 FRAME_DYNAMIC_DATA = 19,
41 FRAME_SPACING_DATA = 20,
42 PROCESS_EXPECTED_DATA = 26,
43 PROCESS_ACTUAL_DATA = 27,
44 PROCESS_DELIVER_INPUT_EVENT_DATA = 28,
45 THREAD_DATA = 30,
46 FUNC_DATA = 31,
47 ENERGY_POWER_DATA = 47,
48 FILE_SYSTEM_DATA = 48,
49 DISK_IO_DATA = 49,
50 FILE_SYS_VM = 50,
51 VM_TRACKER_SMAPS_DATA = 81,
52 VM_TRACKER_DMA_DATA = 82,
53 VM_TRACKER_GPU_MEMORY_DATA = 83,
54 VM_TRACKER_GPU_DATA = 84,
55 VM_TRACKER_GPU_RESOURCE_DATA = 85,
56 VM_TRACKER_GPU_TATAL_DATA = 86,
57 VM_TRACKER_GPU_WINDOW_DATA = 87,
58 VM_TRACKER_GPU_SHM_DATA = 88,
59 VM_TRACKER_GPU_PURGEABLE_DATA = 89,
60 ABILITY_MEMORY_USED_DATA = 90,
61 CPU_ABILITY_USER_DATA = 91,
62 CPU_ABILITY_SYSTEM_DATA = 92,
63 CPU_ABILITY_MONITOR_DATA = 93,
64 ABILITY_BYTES_READ_DATA = 94,
65 ABILITY_BYTES_WRITTEN_DATA = 95,
66 ABILITY_READ_OPS_DATA = 96,
67 ABILITY_WRITTEN_OPS_DATA = 97,
68 ABILITY_BYTES_IN_TRACE_DATA = 98,
69 ABILITY_BUTES_OUT_TRACE_DATA = 99,
70 ABILITY_PACKET_IN_TRACE_DATA = 100,
71 ABILITY_PACKETS_OUT_TRACE_DATA = 101,
72 ABILITY_PURGEABLE_DAT = 151,
73 ABILITY_GPU_MEMMORY_DATA = 152,
74 ABILITY_DMA_DATA = 153,
75 HEAP_TIME_LINE_DATA = 160,
76 HEAP_SNAPSHOT_DATA = 161,
77 CPU_PROFILER_DATA = 162,
78 HIPERF_CPU_DATA = 200,
79 HIPERF_PROCESS_DATA = 201,
80 HIPERF_THREAD_DATA = 202,
81 HIPERF_CALL_CHART = 203,
82 HIPERF_CALL_STACK = 204,
83 NATIVE_MEMORY_CHART_CACHE_NORMAL = 206,
84 NATIVE_MEMORY_CHART_CACHE_STATISTIC = 207,
85 };
86
Sqlite3ColumnInt(sqlite3_stmt * stmt,uint8_t curCol)87 static inline int32_t Sqlite3ColumnInt(sqlite3_stmt *stmt, uint8_t curCol)
88 {
89 if (sqlite3_column_type(stmt, curCol) == SQLITE_NULL) {
90 return -1;
91 }
92 return sqlite3_column_int(stmt, curCol);
93 }
94
Sqlite3ColumnInt64(sqlite3_stmt * stmt,uint8_t curCol)95 static inline int64_t Sqlite3ColumnInt64(sqlite3_stmt *stmt, uint8_t curCol)
96 {
97 if (sqlite3_column_type(stmt, curCol) == SQLITE_NULL) {
98 return -1;
99 }
100 return sqlite3_column_int64(stmt, curCol);
101 }
102
Sqlite3ColumnText(sqlite3_stmt * stmt,uint8_t curCol)103 static inline std::string Sqlite3ColumnText(sqlite3_stmt *stmt, uint8_t curCol)
104 {
105 const char *textPtr = reinterpret_cast<const char *>(sqlite3_column_text(stmt, curCol));
106 if (textPtr != nullptr) {
107 return std::string(textPtr);
108 }
109 return "";
110 }
111
SqllitePreparCacheData()112 SqllitePreparCacheData::SqllitePreparCacheData()
113 {
114 FillSphQueryFuncMapPartOne();
115 FillSphQueryFuncMapPartTow();
116 FillSphQueryFuncMapPartThree();
117 FillSphQueryFuncMapPartFour();
118 FillSphQueryFuncMapPartFive();
119 }
120
FillSphQueryFuncMapPartOne()121 void SqllitePreparCacheData::FillSphQueryFuncMapPartOne()
122 {
123 sphQueryFuncMap_ = {
124 {static_cast<uint32_t>(SphQueryType::CPU_DATA),
125 std::bind(&SqllitePreparCacheData::FillAndSendCpuDataProto, this, std::placeholders::_1, std::placeholders::_2,
126 std::placeholders::_3)},
127 {static_cast<uint32_t>(SphQueryType::CPU_STATE_DATA),
128 std::bind(&SqllitePreparCacheData::FillAndSendCpuStateDataProto, this, std::placeholders::_1,
129 std::placeholders::_2, std::placeholders::_3)},
130 {static_cast<uint32_t>(SphQueryType::CPU_FREQ_DATA),
131 std::bind(&SqllitePreparCacheData::FillAndSendCpuFreqDataProto, this, std::placeholders::_1,
132 std::placeholders::_2, std::placeholders::_3)},
133 {static_cast<uint32_t>(SphQueryType::CPU_FREQ_LIMIT_DATA),
134 std::bind(&SqllitePreparCacheData::FillAndSendCpuFreqLimitDataProto, this, std::placeholders::_1,
135 std::placeholders::_2, std::placeholders::_3)},
136 {static_cast<uint32_t>(SphQueryType::CLOCK_DATA),
137 std::bind(&SqllitePreparCacheData::FillAndSendClockDataDataProto, this, std::placeholders::_1,
138 std::placeholders::_2, std::placeholders::_3)},
139 {static_cast<uint32_t>(SphQueryType::IRQ_DATA),
140 std::bind(&SqllitePreparCacheData::FillAndSendIrqDataProto, this, std::placeholders::_1, std::placeholders::_2,
141 std::placeholders::_3)},
142 {static_cast<uint32_t>(SphQueryType::PROCESS_DATA),
143 std::bind(&SqllitePreparCacheData::FillAndSendProcessDataProto, this, std::placeholders::_1,
144 std::placeholders::_2, std::placeholders::_3)},
145 {static_cast<uint32_t>(SphQueryType::PROCESS_MEM_DATA),
146 std::bind(&SqllitePreparCacheData::FillAndSendProcessMemDataProto, this, std::placeholders::_1,
147 std::placeholders::_2, std::placeholders::_3)},
148 {static_cast<uint32_t>(SphQueryType::PROCESS_STARTUP_DATA),
149 std::bind(&SqllitePreparCacheData::FillAndSendProcessStartupDataProto, this, std::placeholders::_1,
150 std::placeholders::_2, std::placeholders::_3)},
151 };
152 }
153
FillSphQueryFuncMapPartTow()154 void SqllitePreparCacheData::FillSphQueryFuncMapPartTow()
155 {
156 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::PROCESS_SO_INIT_DATA),
157 std::bind(&SqllitePreparCacheData::FillAndSendProcessSoInitDataProto, this,
158 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
159 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HI_SYS_EVENT_DATA),
160 std::bind(&SqllitePreparCacheData::FillAndSendHiSysEventDataProto, this,
161 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
162 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::LOG_DATA),
163 std::bind(&SqllitePreparCacheData::FillAndSendLogDataProto, this, std::placeholders::_1,
164 std::placeholders::_2, std::placeholders::_3));
165 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VIRTUAL_MEM_DATA),
166 std::bind(&SqllitePreparCacheData::FillAndSendVirtualMemDataProto, this,
167 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
168 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ENERGY_SYSTEM_DATA),
169 std::bind(&SqllitePreparCacheData::FillAndSendEnergyDataProto, this, std::placeholders::_1,
170 std::placeholders::_2, std::placeholders::_3));
171 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ENERGY_STATE_DATA),
172 std::bind(&SqllitePreparCacheData::FillAndSendEnergyDataProto, this, std::placeholders::_1,
173 std::placeholders::_2, std::placeholders::_3));
174 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ENERGY_ANOMAL_DATA),
175 std::bind(&SqllitePreparCacheData::FillAndSendEnergyDataProto, this, std::placeholders::_1,
176 std::placeholders::_2, std::placeholders::_3));
177 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FRAME_EXPECTED_DATA),
178 std::bind(&SqllitePreparCacheData::FillAndSendFrameDataProto, this, std::placeholders::_1,
179 std::placeholders::_2, std::placeholders::_3));
180 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FRAME_ACTUAL_DATA),
181 std::bind(&SqllitePreparCacheData::FillAndSendFrameDataProto, this, std::placeholders::_1,
182 std::placeholders::_2, std::placeholders::_3));
183 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FRAME_ANIMATION_DATA),
184 std::bind(&SqllitePreparCacheData::FillAndSendFrameAnimationDataProto, this,
185 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
186 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FRAME_DYNAMIC_DATA),
187 std::bind(&SqllitePreparCacheData::FillAndSendFrameDynamicDataProto, this,
188 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
189 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FRAME_SPACING_DATA),
190 std::bind(&SqllitePreparCacheData::FillAndSendFrameSpacingDataProto, this,
191 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
192 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::PROCESS_EXPECTED_DATA),
193 std::bind(&SqllitePreparCacheData::FillAndSendProcessJanksFramesDataProto, this,
194 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
195 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::PROCESS_ACTUAL_DATA),
196 std::bind(&SqllitePreparCacheData::FillAndSendProcessJanksActualDataProto, this,
197 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
198 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::PROCESS_DELIVER_INPUT_EVENT_DATA),
199 std::bind(&SqllitePreparCacheData::FillAndSendProcessInputEventDataProto, this,
200 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
201 }
202
FillSphQueryFuncMapPartThree()203 void SqllitePreparCacheData::FillSphQueryFuncMapPartThree()
204 {
205 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::THREAD_DATA),
206 std::bind(&SqllitePreparCacheData::FillAndSendProcessThreadDataProto, this,
207 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
208 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FUNC_DATA),
209 std::bind(&SqllitePreparCacheData::FillAndSendProcessFuncDataProto, this,
210 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
211 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ENERGY_POWER_DATA),
212 std::bind(&SqllitePreparCacheData::FillAndSendEnergyDataProto, this, std::placeholders::_1,
213 std::placeholders::_2, std::placeholders::_3));
214 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FILE_SYSTEM_DATA),
215 std::bind(&SqllitePreparCacheData::FillAndSendEbpfDataProto, this, std::placeholders::_1,
216 std::placeholders::_2, std::placeholders::_3));
217 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::DISK_IO_DATA),
218 std::bind(&SqllitePreparCacheData::FillAndSendEbpfDataProto, this, std::placeholders::_1,
219 std::placeholders::_2, std::placeholders::_3));
220 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::FILE_SYS_VM),
221 std::bind(&SqllitePreparCacheData::FillAndSendEbpfDataProto, this, std::placeholders::_1,
222 std::placeholders::_2, std::placeholders::_3));
223 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_SMAPS_DATA),
224 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
225 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
226 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_DMA_DATA),
227 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
228 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
229 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_MEMORY_DATA),
230 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
231 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
232 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_DATA),
233 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
234 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
235 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_RESOURCE_DATA),
236 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
237 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
238 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_TATAL_DATA),
239 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
240 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
241 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_WINDOW_DATA),
242 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
243 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
244 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_SHM_DATA),
245 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
246 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
247 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::VM_TRACKER_GPU_PURGEABLE_DATA),
248 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
249 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
250 }
251
FillSphQueryFuncMapPartFour()252 void SqllitePreparCacheData::FillSphQueryFuncMapPartFour()
253 {
254 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_MEMORY_USED_DATA),
255 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
256 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
257 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::CPU_ABILITY_USER_DATA),
258 std::bind(&SqllitePreparCacheData::FillAndSendCpuAbilityDataProto, this,
259 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
260 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::CPU_ABILITY_SYSTEM_DATA),
261 std::bind(&SqllitePreparCacheData::FillAndSendCpuAbilityDataProto, this,
262 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
263 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::CPU_ABILITY_MONITOR_DATA),
264 std::bind(&SqllitePreparCacheData::FillAndSendCpuAbilityDataProto, this,
265 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
266 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_BYTES_READ_DATA),
267 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
268 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
269 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_BYTES_WRITTEN_DATA),
270 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
271 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
272 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_READ_OPS_DATA),
273 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
274 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
275 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_WRITTEN_OPS_DATA),
276 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
277 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
278 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_BYTES_IN_TRACE_DATA),
279 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
280 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
281 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_BUTES_OUT_TRACE_DATA),
282 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
283 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
284 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_PACKET_IN_TRACE_DATA),
285 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
286 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
287 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_PACKETS_OUT_TRACE_DATA),
288 std::bind(&SqllitePreparCacheData::FillAndSendAbilityDataProto, this,
289 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
290 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_PURGEABLE_DAT),
291 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
292 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
293 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_GPU_MEMMORY_DATA),
294 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
295 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
296 }
297
FillSphQueryFuncMapPartFive()298 void SqllitePreparCacheData::FillSphQueryFuncMapPartFive()
299 {
300 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::ABILITY_DMA_DATA),
301 std::bind(&SqllitePreparCacheData::FillAndSendTrackerDataProto, this,
302 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
303 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HEAP_TIME_LINE_DATA),
304 std::bind(&SqllitePreparCacheData::FillAndSendHeapFilesDataProto, this,
305 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
306 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HEAP_SNAPSHOT_DATA),
307 std::bind(&SqllitePreparCacheData::FillAndSendHeapFilesDataProto, this,
308 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
309 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::CPU_PROFILER_DATA),
310 std::bind(&SqllitePreparCacheData::FillAndSendCpuProfilerDataProto, this,
311 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
312 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_CPU_DATA),
313 std::bind(&SqllitePreparCacheData::FillAndSendHiperfDataProto, this, std::placeholders::_1,
314 std::placeholders::_2, std::placeholders::_3));
315 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_PROCESS_DATA),
316 std::bind(&SqllitePreparCacheData::FillAndSendHiperfDataProto, this, std::placeholders::_1,
317 std::placeholders::_2, std::placeholders::_3));
318 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_THREAD_DATA),
319 std::bind(&SqllitePreparCacheData::FillAndSendHiperfDataProto, this, std::placeholders::_1,
320 std::placeholders::_2, std::placeholders::_3));
321 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_THREAD_DATA),
322 std::bind(&SqllitePreparCacheData::FillAndSendHiperfDataProto, this, std::placeholders::_1,
323 std::placeholders::_2, std::placeholders::_3));
324 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_CALL_CHART),
325 std::bind(&SqllitePreparCacheData::FillAndSendHiperfCallChartDataProto, this,
326 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
327 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::HIPERF_CALL_STACK),
328 std::bind(&SqllitePreparCacheData::FillAndSendHiperfCallStackDataProto, this,
329 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
330 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::NATIVE_MEMORY_CHART_CACHE_NORMAL),
331 std::bind(&SqllitePreparCacheData::FillAndSendNativeMemoryNormalProto, this,
332 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
333 sphQueryFuncMap_.emplace(static_cast<uint32_t>(SphQueryType::NATIVE_MEMORY_CHART_CACHE_STATISTIC),
334 std::bind(&SqllitePreparCacheData::FillAndSendNativeMemoryStatisticProto, this,
335 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
336 }
337
338 template <typename T>
SendDBProto(uint32_t type,const int32_t isFinish,T & sphData,SqllitePreparCacheData::TLVResultCallBack tLVResultCallBack)339 static bool SendDBProto(uint32_t type,
340 const int32_t isFinish,
341 T &sphData,
342 SqllitePreparCacheData::TLVResultCallBack tLVResultCallBack)
343 {
344 std::string bufferData;
345 sphData.SerializeToString(&bufferData);
346 tLVResultCallBack(bufferData.data(), bufferData.size(), type, isFinish);
347 sphData.Clear();
348 return true;
349 }
350
FillAndSendCpuDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)351 void SqllitePreparCacheData::FillAndSendCpuDataProto(sqlite3_stmt *stmt,
352 uint32_t type,
353 TLVResultCallBack tLVResultCallBack)
354 {
355 BatchSphData batchSphCpuData;
356 while (sqlite3_step(stmt) == SQLITE_ROW) {
357 auto cpuData = batchSphCpuData.add_values()->mutable_cpu_data();
358 uint8_t curCol = 0;
359 cpuData->set_process_id(Sqlite3ColumnInt(stmt, curCol++));
360 cpuData->set_cpu(Sqlite3ColumnInt(stmt, curCol++));
361 cpuData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
362 cpuData->set_id(Sqlite3ColumnInt(stmt, curCol++));
363 cpuData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
364 cpuData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
365 }
366
367 SendDBProto(type, SEND_FINISH, batchSphCpuData, tLVResultCallBack);
368 }
369
FillAndSendCpuFreqDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)370 void SqllitePreparCacheData::FillAndSendCpuFreqDataProto(sqlite3_stmt *stmt,
371 uint32_t type,
372 TLVResultCallBack tLVResultCallBack)
373 {
374 BatchSphData batchSphCpuFreqData;
375 while (sqlite3_step(stmt) == SQLITE_ROW) {
376 auto cpuFreqFata = batchSphCpuFreqData.add_values()->mutable_cpu_freq_data();
377 uint8_t curCol = 0;
378 cpuFreqFata->set_cpu(Sqlite3ColumnInt(stmt, curCol++));
379 cpuFreqFata->set_value(Sqlite3ColumnInt(stmt, curCol++));
380 cpuFreqFata->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
381 cpuFreqFata->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
382 }
383 SendDBProto(type, SEND_FINISH, batchSphCpuFreqData, tLVResultCallBack);
384 }
385
FillAndSendProcessDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)386 void SqllitePreparCacheData::FillAndSendProcessDataProto(sqlite3_stmt *stmt,
387 uint32_t type,
388 TLVResultCallBack tLVResultCallBack)
389 {
390 BatchSphData batchSphProcessData;
391 while (sqlite3_step(stmt) == SQLITE_ROW) {
392 auto processData = batchSphProcessData.add_values()->mutable_process_data();
393 uint8_t curCol = 0;
394 processData->set_cpu(Sqlite3ColumnInt(stmt, curCol++));
395 processData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
396 processData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
397 }
398 SendDBProto(type, SEND_FINISH, batchSphProcessData, tLVResultCallBack);
399 }
400
FillAndSendCpuFreqLimitDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)401 void SqllitePreparCacheData::FillAndSendCpuFreqLimitDataProto(sqlite3_stmt *stmt,
402 uint32_t type,
403 TLVResultCallBack tLVResultCallBack)
404 {
405 BatchSphData batchSphCpuFreqLimitData;
406 while (sqlite3_step(stmt) == SQLITE_ROW) {
407 auto cpuFreqLimitData = batchSphCpuFreqLimitData.add_values()->mutable_cpu_freq_limit_data();
408 uint8_t curCol = 0;
409 cpuFreqLimitData->set_max(Sqlite3ColumnInt(stmt, curCol++));
410 cpuFreqLimitData->set_min(Sqlite3ColumnInt(stmt, curCol++));
411 cpuFreqLimitData->set_value(Sqlite3ColumnInt(stmt, curCol++));
412 cpuFreqLimitData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
413 cpuFreqLimitData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
414 }
415 SendDBProto(type, SEND_FINISH, batchSphCpuFreqLimitData, tLVResultCallBack);
416 }
417
FillAndSendCpuStateDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)418 void SqllitePreparCacheData::FillAndSendCpuStateDataProto(sqlite3_stmt *stmt,
419 uint32_t type,
420 TLVResultCallBack tLVResultCallBack)
421 {
422 BatchSphData batchSphCpuStateData;
423 while (sqlite3_step(stmt) == SQLITE_ROW) {
424 auto cpuStateData = batchSphCpuStateData.add_values()->mutable_cpu_state_data();
425 uint8_t curCol = 0;
426 cpuStateData->set_value(Sqlite3ColumnInt(stmt, curCol++));
427 cpuStateData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
428 cpuStateData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
429 }
430 SendDBProto(type, SEND_FINISH, batchSphCpuStateData, tLVResultCallBack);
431 }
432
FillAndSendProcessMemDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)433 void SqllitePreparCacheData::FillAndSendProcessMemDataProto(sqlite3_stmt *stmt,
434 uint32_t type,
435 TLVResultCallBack tLVResultCallBack)
436 {
437 BatchSphData batchSphProcessMemData;
438 while (sqlite3_step(stmt) == SQLITE_ROW) {
439 auto processMemData = batchSphProcessMemData.add_values()->mutable_process_mem_data();
440 uint8_t curCol = 0;
441 processMemData->set_track_id(Sqlite3ColumnInt(stmt, curCol++));
442 processMemData->set_value(Sqlite3ColumnInt64(stmt, curCol++));
443 processMemData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
444 processMemData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
445 }
446 SendDBProto(type, SEND_FINISH, batchSphProcessMemData, tLVResultCallBack);
447 }
448
FillAndSendProcessSoInitDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)449 void SqllitePreparCacheData::FillAndSendProcessSoInitDataProto(sqlite3_stmt *stmt,
450 uint32_t type,
451 TLVResultCallBack tLVResultCallBack)
452 {
453 BatchSphData batchSphProcessSoInitData;
454 while (sqlite3_step(stmt) == SQLITE_ROW) {
455 auto processSoInitData = batchSphProcessSoInitData.add_values()->mutable_process_soinit_data();
456 uint8_t curCol = 0;
457 processSoInitData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
458 processSoInitData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
459 processSoInitData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
460 processSoInitData->set_itid(Sqlite3ColumnInt(stmt, curCol++));
461 processSoInitData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
462 processSoInitData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
463 processSoInitData->set_id(Sqlite3ColumnInt(stmt, curCol++));
464 }
465 SendDBProto(type, SEND_FINISH, batchSphProcessSoInitData, tLVResultCallBack);
466 }
467
FillAndSendProcessStartupDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)468 void SqllitePreparCacheData::FillAndSendProcessStartupDataProto(sqlite3_stmt *stmt,
469 uint32_t type,
470 TLVResultCallBack tLVResultCallBack)
471 {
472 BatchSphData batchSphProcessStartupData;
473 while (sqlite3_step(stmt) == SQLITE_ROW) {
474 auto processStartupDataData = batchSphProcessStartupData.add_values()->mutable_process_startup_data();
475 uint8_t curCol = 0;
476 processStartupDataData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
477 processStartupDataData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
478 processStartupDataData->set_itid(Sqlite3ColumnInt(stmt, curCol++));
479 processStartupDataData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
480 processStartupDataData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
481 processStartupDataData->set_start_name(Sqlite3ColumnInt(stmt, curCol++));
482 }
483 SendDBProto(type, SEND_FINISH, batchSphProcessStartupData, tLVResultCallBack);
484 }
485
FillAndSendClockDataDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)486 void SqllitePreparCacheData::FillAndSendClockDataDataProto(sqlite3_stmt *stmt,
487 uint32_t type,
488 TLVResultCallBack tLVResultCallBack)
489 {
490 BatchSphData batchSphClockDataData;
491 while (sqlite3_step(stmt) == SQLITE_ROW) {
492 auto clockDataData = batchSphClockDataData.add_values()->mutable_clock_data();
493 uint8_t curCol = 0;
494 clockDataData->set_filter_id(Sqlite3ColumnInt(stmt, curCol++));
495 clockDataData->set_value(Sqlite3ColumnInt(stmt, curCol++));
496 clockDataData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
497 }
498 SendDBProto(type, SEND_FINISH, batchSphClockDataData, tLVResultCallBack);
499 }
500
FillAndSendIrqDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)501 void SqllitePreparCacheData::FillAndSendIrqDataProto(sqlite3_stmt *stmt,
502 uint32_t type,
503 TLVResultCallBack tLVResultCallBack)
504 {
505 BatchSphData batchSphIrqData;
506 while (sqlite3_step(stmt) == SQLITE_ROW) {
507 auto IrqData = batchSphIrqData.add_values()->mutable_irq_data();
508 uint8_t curCol = 0;
509 IrqData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
510 IrqData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
511 IrqData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
512 IrqData->set_arg_set_id(Sqlite3ColumnInt(stmt, curCol++));
513 IrqData->set_id(Sqlite3ColumnInt(stmt, curCol++));
514 }
515 SendDBProto(type, SEND_FINISH, batchSphIrqData, tLVResultCallBack);
516 }
517
FillAndSendHiSysEventDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)518 void SqllitePreparCacheData::FillAndSendHiSysEventDataProto(sqlite3_stmt *stmt,
519 uint32_t type,
520 TLVResultCallBack tLVResultCallBack)
521 {
522 BatchSphData batchHiSysEventData;
523 while (sqlite3_step(stmt) == SQLITE_ROW) {
524 auto HiSysEventData = batchHiSysEventData.add_values()->mutable_hi_sys_event_data();
525 uint8_t curCol = 0;
526 HiSysEventData->set_id(Sqlite3ColumnInt(stmt, curCol++));
527 HiSysEventData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
528 HiSysEventData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
529 HiSysEventData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
530 HiSysEventData->set_uid(Sqlite3ColumnInt(stmt, curCol++));
531 HiSysEventData->set_seq(Sqlite3ColumnText(stmt, curCol++));
532 HiSysEventData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
533 HiSysEventData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
534 }
535 SendDBProto(type, SEND_FINISH, batchHiSysEventData, tLVResultCallBack);
536 }
537
FillAndSendLogDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)538 void SqllitePreparCacheData::FillAndSendLogDataProto(sqlite3_stmt *stmt,
539 uint32_t type,
540 TLVResultCallBack tLVResultCallBack)
541 {
542 BatchSphData batchLogData;
543 while (sqlite3_step(stmt) == SQLITE_ROW) {
544 auto logData = batchLogData.add_values()->mutable_log_data();
545 uint8_t curCol = 0;
546 logData->set_id(Sqlite3ColumnInt(stmt, curCol++));
547 logData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
548 logData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
549 logData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
550 logData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
551 logData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
552 }
553 SendDBProto(type, SEND_FINISH, batchLogData, tLVResultCallBack);
554 }
555
FillAndSendVirtualMemDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)556 void SqllitePreparCacheData::FillAndSendVirtualMemDataProto(sqlite3_stmt *stmt,
557 uint32_t type,
558 TLVResultCallBack tLVResultCallBack)
559 {
560 BatchSphData batchVirtualMemData;
561 while (sqlite3_step(stmt) == SQLITE_ROW) {
562 auto virtualMemData = batchVirtualMemData.add_values()->mutable_virtual_mem_data();
563 uint8_t curCol = 0;
564 virtualMemData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
565 virtualMemData->set_filter_id(Sqlite3ColumnInt(stmt, curCol++));
566 virtualMemData->set_value(Sqlite3ColumnInt64(stmt, curCol++));
567 virtualMemData->set_duration(Sqlite3ColumnInt(stmt, curCol++));
568 virtualMemData->set_max_value(Sqlite3ColumnInt64(stmt, curCol++));
569 virtualMemData->set_delta(Sqlite3ColumnInt(stmt, curCol++));
570 }
571 SendDBProto(type, SEND_FINISH, batchVirtualMemData, tLVResultCallBack);
572 }
573
FillAndSendFrameDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)574 void SqllitePreparCacheData::FillAndSendFrameDataProto(sqlite3_stmt *stmt,
575 uint32_t type,
576 TLVResultCallBack tLVResultCallBack)
577 {
578 BatchSphData batchFrameData;
579 while (sqlite3_step(stmt) == SQLITE_ROW) {
580 auto frameData = batchFrameData.add_values()->mutable_frame_data();
581 uint8_t curCol = 0;
582 frameData->set_id(Sqlite3ColumnInt(stmt, curCol++));
583 frameData->set_frame_type(Sqlite3ColumnText(stmt, curCol++));
584 frameData->set_ipid(Sqlite3ColumnInt(stmt, curCol++));
585 frameData->set_name(Sqlite3ColumnInt(stmt, curCol++));
586 frameData->set_app_dur(Sqlite3ColumnInt64(stmt, curCol++));
587 frameData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
588 frameData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
589 frameData->set_type(Sqlite3ColumnText(stmt, curCol++));
590 frameData->set_jank_tag(Sqlite3ColumnInt(stmt, curCol++));
591 frameData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
592 frameData->set_cmdline(Sqlite3ColumnText(stmt, curCol++));
593 frameData->set_rs_ts(Sqlite3ColumnInt64(stmt, curCol++));
594 frameData->set_rs_vsync(Sqlite3ColumnInt(stmt, curCol++));
595 frameData->set_rs_dur(Sqlite3ColumnInt64(stmt, curCol++));
596 frameData->set_rs_ipid(Sqlite3ColumnInt(stmt, curCol++));
597 frameData->set_rs_pid(Sqlite3ColumnInt(stmt, curCol++));
598 frameData->set_rs_name(Sqlite3ColumnInt(stmt, curCol++));
599 }
600 SendDBProto(type, SEND_FINISH, batchFrameData, tLVResultCallBack);
601 }
602
FillAndSendFrameAnimationDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)603 void SqllitePreparCacheData::FillAndSendFrameAnimationDataProto(sqlite3_stmt *stmt,
604 uint32_t type,
605 TLVResultCallBack tLVResultCallBack)
606 {
607 BatchSphData batchFrameAnimationData;
608 while (sqlite3_step(stmt) == SQLITE_ROW) {
609 auto frameAnimationData = batchFrameAnimationData.add_values()->mutable_frame_animation_data();
610 uint8_t curCol = 0;
611 frameAnimationData->set_animation_id(Sqlite3ColumnInt(stmt, curCol++));
612 frameAnimationData->set_status(Sqlite3ColumnInt(stmt, curCol++));
613 frameAnimationData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
614 frameAnimationData->set_end_ts(Sqlite3ColumnInt64(stmt, curCol++));
615 frameAnimationData->set_name(Sqlite3ColumnText(stmt, curCol++));
616 }
617 SendDBProto(type, SEND_FINISH, batchFrameAnimationData, tLVResultCallBack);
618 }
619
FillAndSendFrameDynamicDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)620 void SqllitePreparCacheData::FillAndSendFrameDynamicDataProto(sqlite3_stmt *stmt,
621 uint32_t type,
622 TLVResultCallBack tLVResultCallBack)
623 {
624 BatchSphData batchFrameDynamicData;
625 while (sqlite3_step(stmt) == SQLITE_ROW) {
626 auto frameDynamicData = batchFrameDynamicData.add_values()->mutable_frame_dynamic_data();
627 uint8_t curCol = 0;
628 frameDynamicData->set_id(Sqlite3ColumnInt(stmt, curCol++));
629 frameDynamicData->set_x(Sqlite3ColumnText(stmt, curCol++));
630 frameDynamicData->set_y(Sqlite3ColumnText(stmt, curCol++));
631 frameDynamicData->set_width(Sqlite3ColumnText(stmt, curCol++));
632 frameDynamicData->set_height(Sqlite3ColumnText(stmt, curCol++));
633 frameDynamicData->set_alpha(Sqlite3ColumnText(stmt, curCol++));
634 frameDynamicData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
635 frameDynamicData->set_app_name(Sqlite3ColumnText(stmt, curCol++));
636 }
637 SendDBProto(type, SEND_FINISH, batchFrameDynamicData, tLVResultCallBack);
638 }
639
FillAndSendFrameSpacingDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)640 void SqllitePreparCacheData::FillAndSendFrameSpacingDataProto(sqlite3_stmt *stmt,
641 uint32_t type,
642 TLVResultCallBack tLVResultCallBack)
643 {
644 BatchSphData batchFrameSpacingData;
645 while (sqlite3_step(stmt) == SQLITE_ROW) {
646 auto frameSpacingData = batchFrameSpacingData.add_values()->mutable_frame_spacing_data();
647 uint8_t curCol = 0;
648 frameSpacingData->set_id(Sqlite3ColumnInt(stmt, curCol++));
649 frameSpacingData->set_x(Sqlite3ColumnText(stmt, curCol++));
650 frameSpacingData->set_y(Sqlite3ColumnText(stmt, curCol++));
651 frameSpacingData->set_current_frame_width(Sqlite3ColumnText(stmt, curCol++));
652 frameSpacingData->set_current_frame_height(Sqlite3ColumnText(stmt, curCol++));
653 frameSpacingData->set_current_ts(Sqlite3ColumnInt64(stmt, curCol++));
654 frameSpacingData->set_name_id(Sqlite3ColumnText(stmt, curCol++));
655 }
656 SendDBProto(type, SEND_FINISH, batchFrameSpacingData, tLVResultCallBack);
657 }
658
FillAndSendTrackerDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)659 void SqllitePreparCacheData::FillAndSendTrackerDataProto(sqlite3_stmt *stmt,
660 uint32_t type,
661 TLVResultCallBack tLVResultCallBack)
662 {
663 BatchSphData batchTrackerData;
664 while (sqlite3_step(stmt) == SQLITE_ROW) {
665 auto trackerData = batchTrackerData.add_values()->mutable_tracker_data();
666 uint8_t curCol = 0;
667 trackerData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
668 trackerData->set_value(Sqlite3ColumnInt64(stmt, curCol++));
669 }
670 SendDBProto(type, SEND_FINISH, batchTrackerData, tLVResultCallBack);
671 }
672
FillAndSendAbilityDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)673 void SqllitePreparCacheData::FillAndSendAbilityDataProto(sqlite3_stmt *stmt,
674 uint32_t type,
675 TLVResultCallBack tLVResultCallBack)
676 {
677 BatchSphData batchAbilityData;
678 while (sqlite3_step(stmt) == SQLITE_ROW) {
679 auto abilityData = batchAbilityData.add_values()->mutable_ability_data();
680 uint8_t curCol = 0;
681 abilityData->set_value(Sqlite3ColumnInt64(stmt, curCol++));
682 abilityData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
683 abilityData->set_dur(Sqlite3ColumnInt(stmt, curCol++));
684 }
685 SendDBProto(type, SEND_FINISH, batchAbilityData, tLVResultCallBack);
686 }
687
FillAndSendEnergyDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)688 void SqllitePreparCacheData::FillAndSendEnergyDataProto(sqlite3_stmt *stmt,
689 uint32_t type,
690 TLVResultCallBack tLVResultCallBack)
691 {
692 BatchSphData batchEnergyData;
693 while (sqlite3_step(stmt) == SQLITE_ROW) {
694 auto energyData = batchEnergyData.add_values()->mutable_energy_data();
695 uint8_t curCol = 0;
696 energyData->set_id(Sqlite3ColumnInt(stmt, curCol++));
697 energyData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
698 energyData->set_event_name(Sqlite3ColumnText(stmt, curCol++));
699 energyData->set_app_key(Sqlite3ColumnText(stmt, curCol++));
700 energyData->set_event_value(Sqlite3ColumnText(stmt, curCol++));
701 }
702 SendDBProto(type, SEND_FINISH, batchEnergyData, tLVResultCallBack);
703 }
704
FillAndSendEbpfDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)705 void SqllitePreparCacheData::FillAndSendEbpfDataProto(sqlite3_stmt *stmt,
706 uint32_t type,
707 TLVResultCallBack tLVResultCallBack)
708 {
709 BatchSphData batchEbpfData;
710 while (sqlite3_step(stmt) == SQLITE_ROW) {
711 auto ebpfData = batchEbpfData.add_values()->mutable_ebpf_data();
712 uint8_t curCol = 0;
713 ebpfData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
714 ebpfData->set_end_ns(Sqlite3ColumnInt64(stmt, curCol++));
715 ebpfData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
716 ebpfData->set_size(Sqlite3ColumnInt64(stmt, curCol++));
717 }
718 SendDBProto(type, SEND_FINISH, batchEbpfData, tLVResultCallBack);
719 }
720
FillAndSendProcessThreadDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)721 void SqllitePreparCacheData::FillAndSendProcessThreadDataProto(sqlite3_stmt *stmt,
722 uint32_t type,
723 TLVResultCallBack tLVResultCallBack)
724 {
725 BatchSphData batchProcessThreadData;
726 while (sqlite3_step(stmt) == SQLITE_ROW) {
727 auto processThreadData = batchProcessThreadData.add_values()->mutable_process_thread_data();
728 uint8_t curCol = 0;
729 processThreadData->set_cpu(Sqlite3ColumnInt(stmt, curCol++));
730 processThreadData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
731 processThreadData->set_id(Sqlite3ColumnInt64(stmt, curCol++));
732 processThreadData->set_tid(Sqlite3ColumnInt64(stmt, curCol++));
733 processThreadData->set_state(Sqlite3ColumnText(stmt, curCol++));
734 processThreadData->set_pid(Sqlite3ColumnInt64(stmt, curCol++));
735 processThreadData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
736 processThreadData->set_arg_set_id(Sqlite3ColumnInt64(stmt, curCol++));
737 }
738 SendDBProto(type, SEND_FINISH, batchProcessThreadData, tLVResultCallBack);
739 }
740
FillAndSendProcessFuncDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)741 void SqllitePreparCacheData::FillAndSendProcessFuncDataProto(sqlite3_stmt *stmt,
742 uint32_t type,
743 TLVResultCallBack tLVResultCallBack)
744 {
745 BatchSphData batchProcessFuncData;
746 while (sqlite3_step(stmt) == SQLITE_ROW) {
747 auto processFuncData = batchProcessFuncData.add_values()->mutable_process_func_data();
748 uint8_t curCol = 0;
749 processFuncData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
750 processFuncData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
751 processFuncData->set_argsetid(Sqlite3ColumnInt64(stmt, curCol++));
752 processFuncData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
753 processFuncData->set_id(Sqlite3ColumnInt64(stmt, curCol++));
754 processFuncData->set_itid(Sqlite3ColumnInt(stmt, curCol++));
755 processFuncData->set_ipid(Sqlite3ColumnInt(stmt, curCol++));
756 }
757 SendDBProto(type, SEND_FINISH, batchProcessFuncData, tLVResultCallBack);
758 }
759
FillAndSendHiperfDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)760 void SqllitePreparCacheData::FillAndSendHiperfDataProto(sqlite3_stmt *stmt,
761 uint32_t type,
762 TLVResultCallBack tLVResultCallBack)
763 {
764 BatchSphData batchHiperfData;
765 while (sqlite3_step(stmt) == SQLITE_ROW) {
766 auto hiperfData = batchHiperfData.add_values()->mutable_hiperf_data();
767 uint8_t curCol = 0;
768 hiperfData->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
769 hiperfData->set_event_count(Sqlite3ColumnInt64(stmt, curCol++));
770 hiperfData->set_sample_count(Sqlite3ColumnInt64(stmt, curCol++));
771 hiperfData->set_event_type_id(Sqlite3ColumnInt(stmt, curCol++));
772 hiperfData->set_callchain_id(Sqlite3ColumnInt(stmt, curCol++));
773 }
774 SendDBProto(type, SEND_FINISH, batchHiperfData, tLVResultCallBack);
775 }
776
FillAndSendHiperfCallChartDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)777 void SqllitePreparCacheData::FillAndSendHiperfCallChartDataProto(sqlite3_stmt *stmt,
778 uint32_t type,
779 TLVResultCallBack tLVResultCallBack)
780 {
781 BatchSphData batchHiperfCallChartData;
782 while (sqlite3_step(stmt) == SQLITE_ROW) {
783 auto hiperfCallChartData = batchHiperfCallChartData.add_values()->mutable_hiperf_call_chart_data();
784 uint8_t curCol = 0;
785 hiperfCallChartData->set_callchain_id(Sqlite3ColumnInt64(stmt, curCol++));
786 hiperfCallChartData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
787 hiperfCallChartData->set_event_count(Sqlite3ColumnInt64(stmt, curCol++));
788 hiperfCallChartData->set_thread_id(Sqlite3ColumnInt64(stmt, curCol++));
789 hiperfCallChartData->set_cpu_id(Sqlite3ColumnInt64(stmt, curCol++));
790 hiperfCallChartData->set_event_type_id(Sqlite3ColumnInt64(stmt, curCol++));
791 }
792 SendDBProto(type, SEND_FINISH, batchHiperfCallChartData, tLVResultCallBack);
793 }
794
FillAndSendHiperfCallStackDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)795 void SqllitePreparCacheData::FillAndSendHiperfCallStackDataProto(sqlite3_stmt *stmt,
796 uint32_t type,
797 TLVResultCallBack tLVResultCallBack)
798 {
799 BatchSphData batchHiperfCallStackData;
800 while (sqlite3_step(stmt) == SQLITE_ROW) {
801 auto hiperfCallStackData = batchHiperfCallStackData.add_values()->mutable_hiperf_call_stack_data();
802 uint8_t curCol = 0;
803 hiperfCallStackData->set_callchain_id(Sqlite3ColumnInt64(stmt, curCol++));
804 hiperfCallStackData->set_file_id(Sqlite3ColumnInt64(stmt, curCol++));
805 hiperfCallStackData->set_depth(Sqlite3ColumnInt64(stmt, curCol++));
806 hiperfCallStackData->set_symbol_id(Sqlite3ColumnInt64(stmt, curCol++));
807 hiperfCallStackData->set_name(Sqlite3ColumnInt64(stmt, curCol++));
808 }
809 SendDBProto(type, SEND_FINISH, batchHiperfCallStackData, tLVResultCallBack);
810 }
811
FillAndSendProcessJanksFramesDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)812 void SqllitePreparCacheData::FillAndSendProcessJanksFramesDataProto(sqlite3_stmt *stmt,
813 uint32_t type,
814 TLVResultCallBack tLVResultCallBack)
815 {
816 BatchSphData batchProcessJanksFramesData;
817 while (sqlite3_step(stmt) == SQLITE_ROW) {
818 auto processJanksFramesData = batchProcessJanksFramesData.add_values()->mutable_process_janks_frames_data();
819 uint8_t curCol = 0;
820 processJanksFramesData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
821 processJanksFramesData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
822 processJanksFramesData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
823 processJanksFramesData->set_id(Sqlite3ColumnInt(stmt, curCol++));
824 processJanksFramesData->set_name(Sqlite3ColumnInt(stmt, curCol++));
825 processJanksFramesData->set_type(Sqlite3ColumnInt(stmt, curCol++));
826 processJanksFramesData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
827 }
828 SendDBProto(type, SEND_FINISH, batchProcessJanksFramesData, tLVResultCallBack);
829 }
830
FillAndSendProcessJanksActualDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)831 void SqllitePreparCacheData::FillAndSendProcessJanksActualDataProto(sqlite3_stmt *stmt,
832 uint32_t type,
833 TLVResultCallBack tLVResultCallBack)
834 {
835 BatchSphData batchProcessJanksActualData;
836 while (sqlite3_step(stmt) == SQLITE_ROW) {
837 auto processJanksActualData = batchProcessJanksActualData.add_values()->mutable_process_janks_actual_data();
838 uint8_t curCol = 0;
839 processJanksActualData->set_ts(Sqlite3ColumnInt64(stmt, curCol++));
840 processJanksActualData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
841 processJanksActualData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
842 processJanksActualData->set_id(Sqlite3ColumnInt(stmt, curCol++));
843 processJanksActualData->set_name(Sqlite3ColumnInt(stmt, curCol++));
844 processJanksActualData->set_type(Sqlite3ColumnInt(stmt, curCol++));
845 processJanksActualData->set_jank_tag(Sqlite3ColumnInt(stmt, curCol++));
846 processJanksActualData->set_dst_slice(Sqlite3ColumnInt(stmt, curCol++));
847 processJanksActualData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
848 }
849 SendDBProto(type, SEND_FINISH, batchProcessJanksActualData, tLVResultCallBack);
850 }
851
FillAndSendProcessInputEventDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)852 void SqllitePreparCacheData::FillAndSendProcessInputEventDataProto(sqlite3_stmt *stmt,
853 uint32_t type,
854 TLVResultCallBack tLVResultCallBack)
855 {
856 BatchSphData batchProcessInputEventData;
857 while (sqlite3_step(stmt) == SQLITE_ROW) {
858 auto processInputEventData = batchProcessInputEventData.add_values()->mutable_process_input_event_data();
859 uint8_t curCol = 0;
860 processInputEventData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
861 processInputEventData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
862 processInputEventData->set_argsetid(Sqlite3ColumnInt64(stmt, curCol++));
863 processInputEventData->set_tid(Sqlite3ColumnInt(stmt, curCol++));
864 processInputEventData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
865 processInputEventData->set_is_main_thread(Sqlite3ColumnInt(stmt, curCol++));
866 processInputEventData->set_track_id(Sqlite3ColumnInt(stmt, curCol++));
867 processInputEventData->set_parent_id(Sqlite3ColumnInt(stmt, curCol++));
868 processInputEventData->set_id(Sqlite3ColumnInt(stmt, curCol++));
869 processInputEventData->set_cookie(Sqlite3ColumnInt(stmt, curCol++));
870 processInputEventData->set_depth(Sqlite3ColumnInt(stmt, curCol++));
871 }
872 SendDBProto(type, SEND_FINISH, batchProcessInputEventData, tLVResultCallBack);
873 }
874
FillAndSendHeapFilesDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)875 void SqllitePreparCacheData::FillAndSendHeapFilesDataProto(sqlite3_stmt *stmt,
876 uint32_t type,
877 TLVResultCallBack tLVResultCallBack)
878 {
879 BatchSphData batchHeapFilesData;
880 while (sqlite3_step(stmt) == SQLITE_ROW) {
881 auto heapFilesData = batchHeapFilesData.add_values()->mutable_heap_files_data();
882 uint8_t curCol = 0;
883 heapFilesData->set_id(Sqlite3ColumnInt64(stmt, curCol++));
884 heapFilesData->set_name(Sqlite3ColumnText(stmt, curCol++));
885 heapFilesData->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
886 heapFilesData->set_end_ts(Sqlite3ColumnInt64(stmt, curCol++));
887 heapFilesData->set_size(Sqlite3ColumnInt64(stmt, curCol++));
888 heapFilesData->set_pid(Sqlite3ColumnInt(stmt, curCol++));
889 }
890 SendDBProto(type, SEND_FINISH, batchHeapFilesData, tLVResultCallBack);
891 }
892
FillAndSendCpuProfilerDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)893 void SqllitePreparCacheData::FillAndSendCpuProfilerDataProto(sqlite3_stmt *stmt,
894 uint32_t type,
895 TLVResultCallBack tLVResultCallBack)
896 {
897 BatchSphData batchCpuProfilerData;
898 while (sqlite3_step(stmt) == SQLITE_ROW) {
899 auto cpuProfilerData = batchCpuProfilerData.add_values()->mutable_cpu_profiler_data();
900 uint8_t curCol = 0;
901 cpuProfilerData->set_id(Sqlite3ColumnInt64(stmt, curCol++));
902 cpuProfilerData->set_function_id(Sqlite3ColumnInt64(stmt, curCol++));
903 cpuProfilerData->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
904 cpuProfilerData->set_end_time(Sqlite3ColumnInt64(stmt, curCol++));
905 cpuProfilerData->set_dur(Sqlite3ColumnInt64(stmt, curCol++));
906 cpuProfilerData->set_name_id(Sqlite3ColumnInt64(stmt, curCol++));
907 cpuProfilerData->set_url_id(Sqlite3ColumnInt64(stmt, curCol++));
908 cpuProfilerData->set_line(Sqlite3ColumnInt64(stmt, curCol++));
909 cpuProfilerData->set_column(Sqlite3ColumnInt64(stmt, curCol++));
910 cpuProfilerData->set_hit_count(Sqlite3ColumnInt64(stmt, curCol++));
911 cpuProfilerData->set_children_string(Sqlite3ColumnInt64(stmt, curCol++));
912 cpuProfilerData->set_parent_id(Sqlite3ColumnInt64(stmt, curCol++));
913 }
914 SendDBProto(type, SEND_FINISH, batchCpuProfilerData, tLVResultCallBack);
915 }
916
FillAndSendNativeMemoryNormalProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)917 void SqllitePreparCacheData::FillAndSendNativeMemoryNormalProto(sqlite3_stmt *stmt,
918 uint32_t type,
919 TLVResultCallBack tLVResultCallBack)
920 {
921 BatchSphData batchNativeMemoryNormal;
922 while (sqlite3_step(stmt) == SQLITE_ROW) {
923 auto nativeMemoryNormal = batchNativeMemoryNormal.add_values()->mutable_native_memory_normal();
924 uint8_t curCol = 0;
925 nativeMemoryNormal->set_start_time(Sqlite3ColumnInt64(stmt, curCol++));
926 nativeMemoryNormal->set_heap_size(Sqlite3ColumnInt64(stmt, curCol++));
927 nativeMemoryNormal->set_event_type(Sqlite3ColumnInt64(stmt, curCol++));
928 nativeMemoryNormal->set_ipid(Sqlite3ColumnInt64(stmt, curCol++));
929 }
930 SendDBProto(type, SEND_FINISH, batchNativeMemoryNormal, tLVResultCallBack);
931 }
932
FillAndSendNativeMemoryStatisticProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)933 void SqllitePreparCacheData::FillAndSendNativeMemoryStatisticProto(sqlite3_stmt *stmt,
934 uint32_t type,
935 TLVResultCallBack tLVResultCallBack)
936 {
937 BatchSphData batchNativeMemoryStatistic;
938 while (sqlite3_step(stmt) == SQLITE_ROW) {
939 auto nativeMemoryStatistic = batchNativeMemoryStatistic.add_values()->mutable_native_memory_statistic();
940 uint8_t curCol = 0;
941 nativeMemoryStatistic->set_callchain_id(Sqlite3ColumnInt64(stmt, curCol++));
942 nativeMemoryStatistic->set_start_ts(Sqlite3ColumnInt64(stmt, curCol++));
943 nativeMemoryStatistic->set_apply_count(Sqlite3ColumnInt64(stmt, curCol++));
944 nativeMemoryStatistic->set_apply_size(Sqlite3ColumnInt64(stmt, curCol++));
945 nativeMemoryStatistic->set_release_count(Sqlite3ColumnInt64(stmt, curCol++));
946 nativeMemoryStatistic->set_release_size(Sqlite3ColumnInt64(stmt, curCol++));
947 nativeMemoryStatistic->set_ipid(Sqlite3ColumnInt64(stmt, curCol++));
948 nativeMemoryStatistic->set_type(Sqlite3ColumnInt64(stmt, curCol++));
949 }
950 SendDBProto(type, SEND_FINISH, batchNativeMemoryStatistic, tLVResultCallBack);
951 }
952
FillAndSendCpuAbilityDataProto(sqlite3_stmt * stmt,uint32_t type,TLVResultCallBack tLVResultCallBack)953 void SqllitePreparCacheData::FillAndSendCpuAbilityDataProto(sqlite3_stmt *stmt,
954 uint32_t type,
955 TLVResultCallBack tLVResultCallBack)
956 {
957 BatchSphData batchCpuAbility;
958 while (sqlite3_step(stmt) == SQLITE_ROW) {
959 auto cpuAbility = batchCpuAbility.add_values()->mutable_cpu_ability_data();
960 uint8_t curCol = 0;
961 cpuAbility->set_value(Sqlite3ColumnText(stmt, curCol++));
962 cpuAbility->set_start_ns(Sqlite3ColumnInt64(stmt, curCol++));
963 cpuAbility->set_dur(Sqlite3ColumnInt(stmt, curCol++));
964 }
965 SendDBProto(type, SEND_FINISH, batchCpuAbility, tLVResultCallBack);
966 }
967 } // namespace TraceStreamer
968 } // namespace SysTuning
969