diff --git a/.gitignore b/.gitignore index c5a81c0d9aac78f9d56865ec7b27f2efd84ea85f..2a8966244b44cf5e6a88ade71de4d998844f4ada 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ trace_streamer/prebuilts/emsdk trace_streamer/prebuilts/linux trace_streamer/third_party trace_streamer/compile_commands.json +ts_tmp.perf.data trace_streamer/.cache tmp_* build-* diff --git a/trace_streamer/.gn b/trace_streamer/.gn old mode 100755 new mode 100644 diff --git a/trace_streamer/BUILD.gn b/trace_streamer/BUILD.gn index 6babb6dbdd4c62701bdba4946d24f0a0e35c01f6..22c6002d7fb84d6e98e200d719d098d50dec64e5 100644 --- a/trace_streamer/BUILD.gn +++ b/trace_streamer/BUILD.gn @@ -27,7 +27,7 @@ group("trace_streamer") { } else if (is_sdkdemo) { deps = [ "sdk/demo_sdk:trace_streamer_sdk_builtin" ] } else if (is_sdkdemo_test) { - deps = [ "sdk/test:sdkunittest" ] + deps = [ "sdk/demo_sdk/test:sdkunittest" ] } else if (use_wasm) { deps = [ "src:trace_streamer_builtin" ] } else { diff --git a/trace_streamer/README.md b/trace_streamer/README.md index 9ca966509202bdda42a0d3a7607b713e84ec36be..a94ab67ff3a892268ab634d55a102096555b7390 100644 --- a/trace_streamer/README.md +++ b/trace_streamer/README.md @@ -34,16 +34,83 @@ TraceStreamer可以WebAssembly方式在浏览器中运行，相关接口在wasm extern "C" { /* 初始化wasm，在JS中注册回调函数，并返回一段可复用的内存空间，由JS调用 * - * @ replyFunction: 回调函数 -* @ reqBufferSize: 返回的内存长度 -* return: 返回一段内存地址给JS + * @ replyFunction: 回调函数，返回json格式的数据。 + * @ reqBufferSize: js在wasm中申请的内存大小。 + * @ replyTLVFunction: 回调函数，返回proto格式的sql查询结果。 + * @ ffrtConvertedReply: 回调函数，返回ffrt转换后生成的新trace文件。 + * return: 返回一段内存地址给JS */ -EMSCRIPTEN_KEEPALIVE uint8_t* Initialize(ReplyFunction replyFunction, uint32_t reqBufferSize) +EMSCRIPTEN_KEEPALIVE uint8_t *Initialize(uint32_t reqBufferSize, + ReplyFunction replyFunction, + TLVReplyFunction replyTLVFunction, + ReplyFunction ffrtConvertedReply) + +extern "C" { +/* 初始化wasm，在JS中注册大文件切割或按时间切割文件的回调函数，并返回一段可复用的内存空间，由JS调用 + * + * @ splitFileFunction: 回调函数, 返回大文件切割，或者按时间切割后生成的数据。 + * @ reqBufferSize: js在wasm中申请的内存大小。 + * return: 返回一段内存地址给JS +*/ +EMSCRIPTEN_KEEPALIVE uint8_t *InitializeSplitFile(SplitFileFunction splitFileFunction, uint32_t reqBufferSize) + +/* 通知wasm,按时间切割文件的时间信息已发送，并且通知时间信息大小为dataLen字节 + * + * @ dataLen 切割文件的时间信息长度。 时间数据保存在InitializeSplitFile接口申请的内存中。数据格式:"startTS;endTS;"。 + * return: bool类型。解析切割时间信息成功返回true,否则返回false。 +*/ +EMSCRIPTEN_KEEPALIVE int TraceStreamerSplitFileEx(int dataLen) + +/* 通知wasm,按时间切割的文件信息已发送，并且通知发送的文件信息大小为dataLen字节 + * + * @ dataLen 已经发送的被切割的文件数据长度，数据内容保存在InitializeSplitFile接口申请的内存中。 + * @ isFinish bool类型， 被切割的文件数据发送完成为true, 否则为false。 + * return: 切割成功返回0,否则返回-1。 +*/ +EMSCRIPTEN_KEEPALIVE int TraceStreamerReciveFileEx(int32_t dataLen, int32_t isFinish) + +/* JS在wasm中申请一段内存，用于传输config配置信息。如： ffrt convert开关，animation开关，taskpool开关等 + * + * @ reqBufferSize JS准备申请的内存大小。 + * return: 返回一段内存地址给JS。 +*/ +EMSCRIPTEN_KEEPALIVE uint8_t *InitializeParseConfig(uint32_t reqBufferSize) + +/* JS通知wasm已经发送了config信息，并通知发送的数据大小。 wasm解析config信息。 + * + * @ dataLen JS发送config信息大小， 数据内容保存在InitializeParseConfig接口申请的内存中。 + * return: wasm解析config信息成功返回0，否则返回-1。 +*/ +EMSCRIPTEN_KEEPALIVE int TraceStreamerParserConfigEx(int dataLen) + +/* JS通知wasm已经发送大文件切割的时间信息，并通知发送的数据大小。 wasm解析大文件切割的时间信息。 + * + * @ dataLen JS发送大文件切割时间信息长度。时间信息格式为proto数据的1024头，保存在InitializeSplitFile接口申请的内存中。 + * return: wasm解析大文件切割时间信息成功返回0，否则返回-1。 +*/ +EMSCRIPTEN_KEEPALIVE int TraceStreamerGetLongTraceTimeSnapEx(int dataLen) + +/* JS通知wasm已经发送大文件切割的文件数据，并通知发送的数据大小。 + * + * @ dataLen JS发送大文件切割文件数据大小。 + * @ isFinish JS发送数据是否结束。 + * @ pageNum 准备按照第pageNum个文件的时间范围，切割大文件。 + * return: wasm解析大文件切割时间信息成功返回0，否则返回-1。 +*/ +EMSCRIPTEN_KEEPALIVE int TraceStreamerLongTraceSplitFileEx(int dataLen, int32_t isFinish, uint32_t pageNum) + +/* 导入so重新符号化业务，JS通知wasm申请内存保存导入so的文件名称，并设置导入so重新符号化的回调函数。 + * + * @ parseELFCallback 回调函数 + * @ reqBufferSize 申请的文件大小 + * return: 返回一段内存给JS。 +*/ +EMSCRIPTEN_KEEPALIVE uint8_t *InitFileName(ParseELFFunction parseELFCallback, uint32_t reqBufferSize) /* 更新起始结束时间,由JS调用 * * @ len: 起始和结束时间组成的字符串长度 -* return: 成功返回0。 + * return: 成功返回0。 */ EMSCRIPTEN_KEEPALIVE int UpdateTraceTime(int len) @@ -55,6 +122,12 @@ EMSCRIPTEN_KEEPALIVE int UpdateTraceTime(int len) */ EMSCRIPTEN_KEEPALIVE uint8_t* TraceStreamerSetThirdPartyDataDealer(SendDataCallBack sendDataCallBack, uint32_t reqBufferSize) +/* 设置TraceStreamer可以打印的日志级别，由JS调用 + * + * @ level: 允许打印日志的最低级别。 +*/ +EMSCRIPTEN_KEEPALIVE void TraceStreamerSetLogLevel(uint32_t level) + /* TraceStreamer的数据解析接口，由JS调用 * * @ dataLen: 需要解析的数据源长度 @@ -62,13 +135,26 @@ EMSCRIPTEN_KEEPALIVE uint8_t* TraceStreamerSetThirdPartyDataDealer(SendDataCallB */ EMSCRIPTEN_KEEPALIVE int TraceStreamerParseDataEx(int dataLen, bool isFinish) +/* 导入so重新符号化业务的下载so文件接口，由JS调用 + * + * @ totalLen: 传输的文件总长度。 + * @ fileNameLen: 传输的文件名长度。 + * @ dataLen: 当前调用传输的文件数据长度。 + * @ finish: 当前文件是否传输结束。 + * return: wasm下载并保存该文件成功返回0，失败返回-1 +*/ +EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerDownloadELFEx(int32_t totalLen, + int32_t fileNameLen, + int32_t dataLen, + int32_t finish) + /* TraceStreamer停止解析数据，由JS调用 * * return: 成功返回0，失败返回-1 */ EMSCRIPTEN_KEEPALIVE int TraceStreamerParseDataOver() -/* 数据库操作接口，由JS调用 +/* 数据库操作接口，由JS调用，返回json格式的sql查询结果。 * * @ sqlLen: 需要执行的操作类sql语句长度 * return: 成功返回0，失败返回-1 @@ -94,6 +180,19 @@ EMSCRIPTEN_KEEPALIVE int TraceStreamerSqlQueryEx(int sqlLen) */ EMSCRIPTEN_KEEPALIVE int TraceStreamerCancel() +/*执行查询类sql语句，由JS调用。返回proto格式的sql查询结果。 + * +* @ sqlLen: 需要执行的查询类sql语句长度 +* return: 成功返回0，失败返回-1 +*/ +EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerSqlQueryToProtoCallback(int32_t sqlLen) +/*执行metrics数据查询 + * +* @ sqlLen: 需要执行的查询类sql语句长度 +* return: 成功返回0，失败返回-1 +*/ +EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerSqlMetricsQuery(int32_t sqlLen) + /*发送数据给第三方wasm解析，由TraceStreamer调用 * * @ pluginData: 第三方插件的数据源 @@ -103,6 +202,13 @@ EMSCRIPTEN_KEEPALIVE int TraceStreamerCancel() */ int TraceStreamerPluginOutSendData(const char* pluginData, int len, const std::string componentName) +/*返回解析数据库 + * + * @ fun: 回调函数，负责返回解析生成的数据库。 + * return: 成功返回0 +*/ +EMSCRIPTEN_KEEPALIVE int32_t WasmExportDatabase(ExportDBCallback fun) + /* 初始化配置接口，由JS调用 * * @ dataLen: 配置字符串的长度 diff --git a/trace_streamer/build/protoc_w.py b/trace_streamer/build/protoc_w.py index de4cfdcdb1ca9b81ef1858d06ecf4e8bfdc6fcea..3dd7b13a4a1de30832f345213cb58bad9f5ace55 100755 --- a/trace_streamer/build/protoc_w.py +++ b/trace_streamer/build/protoc_w.py @@ -49,7 +49,7 @@ PARAMS_ALL = f"{PARAMS_SRC}" if not sys.argv[4].startswith("--plugin"): if os.path.isfile(OPT_PLUGIN_PROTOREADER_PATH): - cmd = [PROTOC, OPT_PLUGIN_PROTOREADER, f"{PLUGINOUT}:{sys.argv[5]}", *PARAMS_ALL.split()] + cmd=[PROTOC, OPT_PLUGIN_PROTOREADER, f"{PLUGINOUT}:{sys.argv[5]}", *PARAMS_ALL.split()] print("执行参数：--------------- ", cmd, " --------------------------") subprocess.run(cmd) subprocess.run([PROTOC, *PARAMS_ALL.split()]) diff --git a/trace_streamer/doc/des_tables.md b/trace_streamer/doc/des_tables.md index 1dc29b4eb1f40cc66a1b44abe99dff8378941917..fa1e90f3074a8cc056974e4ae524e4249965db93 100755 --- a/trace_streamer/doc/des_tables.md +++ b/trace_streamer/doc/des_tables.md @@ -37,6 +37,7 @@ TraceStreamer可以将trace数据源转化为易于理解和使用的数据库 | frame_slice | 记录RS(RenderService)和应用的帧渲染| | gpu_slice | 记录RS的帧对应的gpu渲染时长| | hidump | 记录FPS（Frame Per Second）数据| +| hisys_all_event | 记录了所有HiSysEvent事件相关的原始数据 | | hisys_event_measure | 记录了HiSysEvent事件相关数据，目前HiSysEvent事件包括了异常事件，IDE事件，器件状态事件 | | instant | 记录Sched_waking, sched_wakeup事件， 用作ThreadState表的上下文使用 | | irq | 记录中断相关事件| @@ -68,7 +69,7 @@ TraceStreamer可以将trace数据源转化为易于理解和使用的数据库 | paged_memory_sample | 记录内存操作相关方法调用，及调用栈数据| | perf_callchain | 记录Hiperf采样数据的调用栈信息| | perf_files | 记录Hiperf工具采集到的函数符号表和文件名| -| perf_report | 记录Hiperf工具采集数据时的配置信息。包括|抓取的事件类型，抓取数据的命令， 抓数据时指定的进程名称| +| perf_report | 记录Hiperf工具采集数据时的配置信息。包括抓取的事件类型，抓取数据的命令， 抓数据时指定的进程名称| | perf_sample | 记录Hiperf工具的采样信息| | perf_thread | 记录Hiperf工具采集到的进程和线程数据| | process | 记录所有的进程信息| @@ -79,6 +80,9 @@ TraceStreamer可以将trace数据源转化为易于理解和使用的数据库 | smaps | 记录进程的内存消耗的相关信息采样| | stat | 此结果用来统计数据解析中各类数据的数据条数，数据和合法性，数据的匹配程度（begin-end），数据的损失等，查看此结构对应的表，可对数据源有基本的了解| | static_initalize | 记录了so初始化相关数据| +| memory_cpu | 记录了cpu内存数据 | +| memory_profile | 记录了sys/kernel/debug/mali0/ctx/$(pidof xxx)/mem_profile节点相关数据| +| memory_rs_image | 记录了hidumper抓取的界面的内存大小相关数据| | symbols | 记录系统调用名称和其函数指针的对应关系，trace中用addr来映射function_name来节省存储空间| | syscall | 记录用户空间函数与内核空间函数相互调用记录| | sys_event_filter | 记录所有的filter| @@ -110,6 +114,7 @@ TraceStreamer可以将trace数据源转化为易于理解和使用的数据库 |frame_slice | - |ftrace-plugin |帧渲染数据 | |gpu_slice | - |ftrace-plugin |gpu渲染时长 | |hidump | - |hidump-plugin |FPS数据 | +|hisys_all_event | - |hisysevent-plugin |JSON数据源 | |hisys_event_measure | - |hisysevent-plugin |JSON数据源 | |instant | - |ftrace-plugin |waking和wakeup事件 | |irq | - |ftrace-plugin |记录中断事件 | @@ -127,6 +132,9 @@ TraceStreamer可以将trace数据源转化为易于理解和使用的数据库 |js_heap_trace_node | - |arkts-plugin | js内存数据 | |app_startup | - |ftrace-plugin | 应用启动数据 | |static_initalize | - |ftrace-plugin | so初始化数据 | +|memory_cpu | - |hidumper-plugin | cpu内存数据 | +|memory_profile | - |hidumper-plugin |/sys/kernel/debug/mali0/ctx/$(pidof xxx)/mem_profile节点相关数据| +| memory_rs_image | - |hidumper-plugin |hidumper抓取的界面内存大小数据| |live_process | - |process-plugin |Monitor数据 | |network | - |network-plugin |Monitor数据 | |diskio | - |diskio-plugin |Monitor数据 | @@ -271,7 +279,6 @@ js_heap_sample:记录timeline的时间轴信息 | Columns Name | SQL TYPE | |---- |---- | |id |INT | -|flag |INT | |app_name |INT | |app_key |INT | #### 表描述 @@ -293,6 +300,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录方法的参数集合。 #### 字段详细描述 +- id: 唯一标识 - key：键 - datatype：数据类型 - value：取值 @@ -319,6 +327,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录IO操作相关方法调用，及调用栈数据。 #### 字段详细描述 +- id: 唯一标识 - callchain_id：调用栈的唯一标识。与ebpf_callstack表中Callchain_id字段关联 - type：事件类型其取值为枚举类型（DATA_READ，DATA_WRITE，METADATA_READ，- METADATA_WRITE，PAGE_IN，PAGE_OUT） - ipid：TS内部进程号 @@ -350,18 +359,23 @@ js_heap_sample:记录timeline的时间轴信息 |spanId |TEXT | |parentSpanId |TEXT | |flag |TEXT | -|args |TEXT | #### 表描述 记录调用堆栈和异步调用信息，其中depth,stack_id和parent_stack_id仅在非异步的调用中有效。当cookid不为空时，为异步调用，此时callid为进程唯一号，否则为线程唯一号。 #### 字段详细描述 +- id: 唯一标识 +- ts: 数据事件上报时间戳 - dur：调用时长 - callid：调用者的ID，比如针对线程表里面的id +- cat: 表示当前栈帧属于哪个业务(binder/workqueue/null) - name：调用名称 -- depth：调用深度 +- depth：调用深度 +- cookie: 异步调用的cookie值 - parent_id：父调用的id -- spanId：分布式调用关联关系 +- argsetid: 调用的参数列表，关联args表的id字段 +- chainId:分布式数据中的chainId,id相同则表示为同一个分布式的调用栈 +- spanId：分布式调用关联关系，当前帧的id +- parentSpanId: 分布式调用关联关系，当前帧的parent的SpanId，对应当前表的spandId - flag：C表示分布式调用发送方，S表示接受方 -- args：分布式调用函数参数 ### clk_event_filter表 #### 表结构 @@ -374,8 +388,10 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录时钟信息。 #### 字段详细描述 -- Type：时钟事件类型 -- Name：时钟事件名称 +- id: 与measure表的filterId字段关联 +- type：时钟事件类型 +- name：时钟事件名称 +- cpu: cpu编号 ### clock_event_filter表 #### 表结构 @@ -384,25 +400,28 @@ js_heap_sample:记录timeline的时间轴信息 |id |INT | |type |TEXT | |name |TEXT | -|cpu |INT | +|cpu |INT | #### 表描述 此结构用来维护时钟事件，cpu与唯一的ID做关联。 #### 主要字段描述 +- id: 与measure表的filterId字段关联 - Type：时钟事件类型 - Name：时钟事件名称 +- cpu: cpu编号 ### cpu_measure_filter表 #### 表结构 | Columns Name | SQL TYPE | |---- |---- | |id |INT | -|type |TEXT | |name |TEXT | |cpu |INT | #### 表描述 将cpu号作为key1，cpu的频率，空闲等状态作为key2，唯一确定一个filter_id。 #### 主要字段描述 -- Id(filterid), cpu：事件名称，cpu号 +- id: 与measure表的filterId字段关联 +- name: 事件名(cpu_idle/cpu_frequency/cpu_frequency_limits_max/cpu_frequency_limits_min) +- cpu：cpu号 ### cpu_usage表 #### 表结构 @@ -415,8 +434,10 @@ js_heap_sample:记录timeline的时间轴信息 |system_load |REAL | |process_num |INT | #### 表描述 -记录了与CPU使用率相关的数据。 +记录了/proc/pid/stat与CPU使用率相关的数据。 #### 主要字段描述 +- ts: 数据上报时间 +- dur: 持续时间 - total_load：总负荷 - user_load：用户负载 - system_load：系统负载 @@ -444,6 +465,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 此表记录了一个数据类型ID和数据描述的映射。 #### 主要字段描述 +- id: 唯一标识 - typeId:：数据类型id - Desc：数据类型描述 @@ -464,9 +486,16 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了与磁盘读写相关的数据。 #### 主要字段描述 -- rd_sectors_kb：读数据的速度 -- wr_sectors_kb：写入数据的速度 - ts：时间戳 +- dur: 持续时间 +- rd: 当前时间段的读取量 +- wr: 当前时间段的写入量 +- rd_speed:当前时间段的读取速度 +- wr_speed:当前时间段的写入速度 +- rd_count:读取的数据总量 +- wr_count:写入的数据总量 +- rd_sectors_speed：读数据的平均速度 +- wr_sectors_speed：写入数据的平均速度 ### ebpf_callstack表 #### 表结构 @@ -481,6 +510,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了与磁盘读写相关的数据。 #### 主要字段描述 +- id: 唯一标识 - callchain_id：调用栈的唯一标识 - depth：调用栈深度。取值为零时表示栈顶 - ip：调用栈ip @@ -512,7 +542,8 @@ js_heap_sample:记录timeline的时间轴信息 #### 主要字段描述 - callchain_id：调用栈信息ID与file_system_callstack表中call_chain_id字段相关联 - type：对应文件操作open，close，read，write -- ipid：线程所属的进程ID +- ipid：样本所属的内部进程ID，关联process表id +- itid: 样本所属的内部线程ID，关联thread表id - start_ts：开始时间 - end_ts：结束时间 - dur：耗时 @@ -536,6 +567,8 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 此表记录了设备的帧率信息，fps。 #### 相关字段描述 +- id: 唯一标识 +- ts: 数据上报时间戳 - fps：帧率值 ### hisys_event_measure表 @@ -552,7 +585,8 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录所有的system event事件的相关数据，及其相关表的映射信息。 #### 相关字段描述 -- serial：每条数据过来携带唯一一条id作为标识 +- serial：每条数据过来携带唯一一条id作为标识 +- ts: 数据上报时间戳 - name_id：存放事件对应的ID，与data_dict表相关联可以取出对应的字段 - key_id：存放事件包含的字段的ID，与表app_name的id字段相关联，找到app_name表的 id字段对应行的app_key字段与表data_dict表相关联取出对应的字段 - type：存放事件所包含的字段的值所属的类型为int型还是string（0为int，1为string） @@ -593,21 +627,21 @@ js_heap_sample:记录timeline的时间轴信息 |cookie |INT | |parent_id |INT | |argsetid |INT | -|chainId |TEXT | -|spanId |TEXT | -|parentSpanId |TEXT | |flag |TEXT | -|args |TEXT | #### 表描述 记录中断相关事件。 #### 相关字段描述 +- id: 唯一标识 +- ts: 数据上报时间戳 - dur：调用中断时长 - callid：调用中断者的ID，比如针对线程表里面的id -- cat：调用栈数据类型（取值范围：irq，softirq...） +- cat：调用栈数据类型（取值范围：irq，softirq, ipi） - name：调用中断的名称 - depth：中断调用的深度 +- cookie: 异步调用的cookie值 - parent_id：父调用中断的id -- spanId：分布式调用中断关联关系 +- argsetid: 跟arg_view中的argset关联，保存irq的名字以及值（irq=5 name=IPI） +- flag: 1表示硬中断 ### js_config表 @@ -706,7 +740,7 @@ js_heap_sample:记录timeline的时间轴信息 | file_name | TEXT | | start_time | INT | | end_time | INT | -| pid | INT | +| self_size | INT | #### 表描述 记录了js内存数据的文件名称和时间。 #### 相关字段描述 @@ -714,7 +748,7 @@ js_heap_sample:记录timeline的时间轴信息 - file_name：文件名称 - start_time：数据抓取的起始时间 - end_time：数据抓取的终止时间 -- pid：进程号 +- self_size: 当前snapshot中所有node的size之和 ### js_heap_info表 #### 表结构 @@ -912,8 +946,11 @@ js_heap_sample:记录timeline的时间轴信息 |disk_writes |INT | |disk_reads |INT | #### 表描述 -记录了一些实时的进程中执行的一些数据（Monitor）。 +记录了一些实时的进程中（/proc/$PID/status、/proc/$PID/stat、/proc/stat）执行的一些数据（Monitor）。 #### 主要字段描述 +- ts: 数据上报时间戳 +- dur: 事件持续时间 +- cpu_time: /proc/$PID/stat 中的cpu时间 - process_id：进程id - process_name：进程名 - parent_process_id：父进程的id @@ -940,13 +977,14 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录日志信息。 #### 关键字段描述 -- Seq：日志序号，保证日志解析的准确性 -- Ts：打印日志时间 -- Pid：日志的进程号 -- Tid：日志的线程号 -- Level：日志级别 -- Tag：日志标签 -- Context：日志内容 +- seq：日志序号，保证日志解析的准确性 +- ts：打印日志时间 +- pid：日志的进程号 +- tid：日志的线程号 +- level：日志级别 +- tag：日志标签 +- context：日志内容 +- origints：log中自带的时间 ### measure表 #### 表结构 @@ -978,7 +1016,10 @@ js_heap_sample:记录timeline的时间轴信息 记录一个递增的filterid队列，所有其他的filter类型在获取过程中，均从此数据列表中获取下一个可用的filter_id并做记录。 #### 字段详细描述 过滤分类（type），过滤名称（key2），数据ID(key1)。 -数据ID在process_measure_filter, sys_event_filter中作为id。 +id: 唯一的filterId,与process_measure_filter, sys_event_filter中的id关联。 +type：各种类型（cpu_measure_filter，clk_rate_filter，process_measure_filter...） +name: type的子类型。 +source_arg_set_id: 同一个source_arg_set_id代表一组数据，一般取得是itid或者cpu编号。 ### meta表 #### 表结构 @@ -1013,17 +1054,21 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录native_hook抓取的某个进程的堆内存，内存映射相关数据。 #### 关键字段描述 +- id: 唯一标识 - callChainId：唯一标识一条native_hook数据 +- ipid：所属的进程内部id, 关联process表中的id +- itid：所属的线程内部id, 关联thread表中的id - event_type：事件类型取值范围（AllocEvent,FreeEvent,MmapEvent, MunmapEvent） - sub_type_id：子事件类型(只有sub_type字段为MmapEvent时，该字段才会有值) - start_ts：申请内存开始时间 - end_ts：释放内存时间 -- Dur：申请内存活跃时间 -- Addr：申请内存地址 -- mem_size：申请或释放内存大小 -- all_mem_size：从采集数据开始到当前时刻，申请并活跃的内存总量。 event_type为AllocEvent或者FreeEvent时，表示活跃的堆内存总量。当event_type为MmapEvent或者MunmapEvent时，表示活跃的映射内存总量 +- dur：申请内存活跃时间 +- addr：申请内存地址 +- heap_size: 申请的内存大小 +- all_heap_size：从采集数据开始到当前时刻，申请并活跃的内存总量。 event_type为AllocEvent或者FreeEvent时，表示活跃的堆内存总量。当event_type为MmapEvent或者MunmapEvent时，表示活跃的映射内存总量 - current_size_dur：表示当前活跃内存总量的持续时间 -- last_lib_id：函数调用栈他最后一个函数所属的文件路径，除了文件名中带musl和libc++ +- last_lib_id：函数调用栈最后一个函数所属的文件路径，除了文件名中带musl和libc++ +- last_symbol_id: 函数调用栈最后一个函数名，lib除了文件名中带musl和libc++ ### native_hook_frame表 #### 表结构 @@ -1032,17 +1077,24 @@ js_heap_sample:记录timeline的时间轴信息 |id |INT | |callchain_id |INT | |depth |INT | +|ip |INT | |symbol_id |INT | |file_id |INT | |offset |INT | |symbol_offset |INT | +|vaddr |INT | #### 表描述 记录了内存的申请和释放的堆栈。 #### 相关字段描述 +- id: 唯一标识 - callchain_id：标识一组调用堆栈 - depth：调用栈深度 -- symbol_id：函数名 -- file_id：函数所属文件 +- ip: 函数ip +- symbol_id：函数名id,对应data_dict中id +- file_id：函数所属文件id，对应data_dict中id +- offset: 取自Frame message的offset字段 +- symbol_offset: 取自Frame message的symbol_offset字段 +- vaddr: 一般取值为offset + symbol_offset ### native_hook_statistic表 #### 表结构 @@ -1053,6 +1105,7 @@ js_heap_sample:记录timeline的时间轴信息 |ipid |INT | |ts |INT | |type |INT | +|sube_type_id |INT | |apply_count |INT | |release_count |INT | |apply_size |INT | @@ -1060,15 +1113,19 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录了内存申请/释放的统计信息。 -#### 关键字段描述 +#### 关键字段描述 +- id: 唯一标识 - callchain_id：内存分配的回调链id - ipid：进程id - ts：统计数据上报时间 - type：事件类型，0代表malloc事件，1代表mmap事件 +- sub_type_id：事件子类型，关联data_dict表id - apply_count：当前调用栈内存分配总次数 - release_count：当前调用栈内存释放总次数 - apply_size：当前调用栈累计分配总大小 - release_size：当前调用栈累计释放总大小 +- last_lib_id：函数调用栈最后一个函数所属的文件路径，除了文件名中带musl和libc++ +- last_symbol_id: 函数调用栈最后一个函数名，lib除了文件名中带musl和libc++ ### network表 #### 表结构 @@ -1088,10 +1145,17 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了网络数据传输相关的信息。 #### 主要字段描述 -- tv_sec：时间，秒为单位 -- tv_nsec：时间，纳秒为单位 -- tx_bytes：网络数据的写入量 -- rx_bytes：网络数据的读取量 +- ts:事件上报时间 +- dur: 持续时间 +- tx: 网络数据的写入次数 +- rx: 网络数据的读取次数 +- tx_speed: 网络数据的写入次数/s +- rx_speed: 网络数据的读取次数/s +- packet_in：网络数据申请的数据包个数 +- packet_in_sec： 网络数据申请的数据包个数/s +- packet_out: 网络数据发送的数据包个数 +- packet_out_sec：网络数据发送的数据包个数/s +- net_type:网络类型，wifi/蜂窝 ### paged_memory_sample表 #### 表结构 @@ -1110,14 +1174,16 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了网络数据传输相关的信息。 #### 主要字段描述 +- id: 唯一标识 - callchain_id： 取值相同的一组数据，表示一个完整的调用栈 - type：事件类型 - ipid：TS内部进程号 - start_ts：开始时间 - end_ts：结束时间 - dur：持续时间 -- size：操作页数 -- itid：TS内部线程号 +- size：操作页数，1页=4kb +- addr: 内存地址 +- itid：内部线程号 ### perf_callchain表 #### 表结构 @@ -1126,6 +1192,7 @@ js_heap_sample:记录timeline的时间轴信息 |id |INT | |callchain_id |INT | |depth |INT | +|ip |INT | |vaddr_in_file |INT | |file_id |INT | |symbol_id |INT | @@ -1133,8 +1200,10 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了Hiperf采样数据的调用栈信息。 #### 主要字段描述 +- id: 唯一标识 - callchain_id：标识一组调用堆栈 - depth：调用栈深度 +- ip: 函数ip - vaddr_in_file：函数在文件中的虚拟地址 - file_id：与PerfFiles中的file_id字段相关联 - symbol_id：与PerfFiles中的symbol_id相关联 @@ -1152,6 +1221,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录Hiperf工具采集到的函数符号表和文件名。 #### 主要字段描述 +- id: 唯一标识 - file_id：文件编号 - serial_id：一个文件中可能有多个函数，serial_id表示函数的编号 - symbol：函数名 @@ -1167,6 +1237,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录Hiperf工具采集数据时的配置信息。包括：抓取的事件类型，抓取数据的命令， 抓数据时指定的进程名称。 #### 主要字段描述 +- id: 唯一标识 - report_type：数据类型。取值只有三种类型：config_name（事件类型）, workload（抓取的进程名）, cmdline（抓取命令） - report_value：对应类型的取值 @@ -1186,6 +1257,8 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录Hiperf工具的采样信息。 #### 主要字段描述 +- id: 唯一标识 +- callchain_id：关联perf_callchain表callchain_id - timestamp：未进行时钟源同步的时间戳 - thread_id：线程号 - event_count：采样统计 @@ -1205,6 +1278,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录Hiperf工具采集到的进程和线程数据。 #### 主要字段描述 +- id: 唯一标识 - thread_id：线程号 - process_id：进程号 - thread_name：线程名 @@ -1215,43 +1289,26 @@ js_heap_sample:记录timeline的时间轴信息 |---- |---- | |id |INT | |ipid |INT | -|type |TEXT | |pid |INT | |name |TEXT | |start_ts |INT | |switch_count |INT | |thread_count |INT | |slice_count |INT | -|mem_count |INT | +|mem_count |INT | #### 表描述 记录了进程相关数据。 #### 关键字段描述 - id：进程在数据库重新重新定义的id，从0开始序列增长 - ipid：TS内部进程id -- type：固定取值：process - pid：进程的真实id - name：进程名字 - start_ts：开始时间 - switch_count：统计内部有多少个线程有切换 - thread_count：统计其线程个数 -- slice_count：进程内有多个线程有slice数据 +- slice_count：进程内有多少个线程有slice数据 - mem_count：进程是否有内存数据 -### process_filter表 -#### 表结构 -| Columns Name | SQL TYPE | -|---- |---- | -|id |INT | -|type |TEXT | -|name |TEXT | -|ipid |INT | -#### 表描述 -将进程ID作为key1，进程的内存，界面刷新，屏幕亮度等信息作为key2，唯一确定一个filter_id, filter_id同时被记录在filter表中。 -#### 主要字段描述 -- id：进程id -- type：固定取值：process_filter -- name：进程名 -- ipid：该进程表中的id与process表中的id相关联 ### process_measure表 #### 表结构 @@ -1264,23 +1321,24 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 保存进程的内存，堆栈值等所有计量值信息。 #### 字段详细描述 +- type: 固定为measure - ts：事件时间 +- dur: 持续时间 - value：数值 -- filter_id：对应process_measure_filter表中的ID +- filter_id：对应process_measure_filter表中的id ### process_measure_filter表 #### 表结构 | Columns Name | SQL TYPE | |---- |---- | |id |INT | -|type |TEXT | |name |TEXT | |ipid |INT | #### 表描述 将进程ID作为key1，进程的内存，界面刷新，屏幕亮度等信息作为key2，唯一确定一个filter_id, filter_id同时被记录在measure_filter表中。 #### 字段详细描述 -- type：固定取值：process_measure_filter -- name：cpu状态名 +- id: 与measure表的filterId字段相关联 +- name：key名 - ipid：进程内部编号 ### raw表 @@ -1288,7 +1346,6 @@ js_heap_sample:记录timeline的时间轴信息 | Columns Name | SQL TYPE | |---- |---- | |id |INT | -|type |TEXT | |ts |INT | |name |TEXT | |cpu |INT | @@ -1296,34 +1353,39 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了系统中的waking、wakup、cpu_idel、cpu_frequency数据。 #### 相关字段描述 -- type：固定字段（raw） +- id: 唯一标识 +- ts：事件时间 - name：调度名称（取值：cpu_idle，sched_wakeup，sched_waking） - cpu：事件发生在哪个CPU -- itid：时间对应哪个utid +- itid：时间对应哪个itid,对应thread表中id ### sched_slice表 #### 表结构 | Columns Name | SQL TYPE | |---- |---- | |id |INT | -|type |TEXT | |ts |INT | |dur |INT | |ts_end |INT | |cpu |INT | |itid |INT | +|ipid |INT | |end_state |TEXT | |priority |INT | +|argset_id |INT | #### 表描述 此数据结构主要作为ThreadState的上下文使用，这张表是sched_switch事件的原始记录。 #### 主要字段描述 -- ts：事件发生事件 -- type：固定字段（sched_slice） +- id: 唯一标识 +- ts：事件发生时间 - dur：状态持续时长 - ts_end：状态结束时长 - cpu：事件发生在哪个cpu -- itid：事件对应哪个utid +- itid：进程内部编号 +- ipid：进程内部编号 - end_state：线程的终结状态 +- priority: 线程优先级 +- argset_id：线程状态参数，对应arg_view中arg_set ### smaps表 #### 表结构 @@ -1340,11 +1402,17 @@ js_heap_sample:记录timeline的时间轴信息 |virtaul_size |INT | |reside |REAL | |protection_id |INT | -|path_id |INT | -#### 表描述 -记录进程的内存消耗的相关信息采样。 +|shared_clean |INT | +|shared_dirty |INT | +|private_clean |INT | +|private_dirty |INT | +|swap |INT | +|swap_pss |INT | +|type |INT | +#### 表描述 +记录进程的内存消耗的相关信息采样,读取/proc/${pid}/smaps节点。 #### 主要字段描述 -- id：状态持续时长 +- id: 唯一标识 - timestamp：事件发生事件 - start_addr：内存段地址的起始位置 - end_addr：内存段地址的结束位置 @@ -1356,6 +1424,14 @@ js_heap_sample:记录timeline的时间轴信息 - reside：实际分配的内存大小与虚拟内存空间的大小的比 - protection_id：内存段的权限id与表data_dict的id字段相关联 - path_id：如果区域是从文件映射的，则这是文件的名称对应的id序号与表data_dict的id字段相关联 +- shared_clean:smaps节点中Shared_clean +- shared_dirty:smaps节点中Shared_dirty +- private_clean:smaps节点中Private_clean +- private_dirty:samps节点中Private_dirty +- swap： smap节点中Swap +- swap_pss:smap节点中SwapPss +- type : 根据type分类信息 + ### stat表 #### 表结构 @@ -1385,8 +1461,9 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 此表记录了被调用函数与其地址的映射关系。 #### 相关字段描述 +- id: 唯一标识 - funcname：系统调用名称 -- adr：系统调用地址 +- addr：系统调用地址 ### syscall表 #### 表结构 @@ -1416,6 +1493,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录所有的filter。 #### 相关字段描述 +- id: 与measure表的filterid字段关联 - type：文件类型 - name：文件名 @@ -1430,7 +1508,9 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录系统内存与系统虚拟内存。 #### 相关字段描述 +- type: 固定为measure - ts：事件时间 +- dur: 持续时间 - value：数值 - filter_id：对应filter表中的ID @@ -1451,7 +1531,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 记录了线程相关数据。 #### 字段详细描述 -- id：线程在数据库重新重新定义的id，从0开始序列增长 +- id: 唯一标识 - itid：TS内部线程id - type：固定字段（thread） - tid：线程号 @@ -1491,10 +1571,11 @@ js_heap_sample:记录timeline的时间轴信息 |tid |INT | |pid |INT | |state |TEXT | +|argset_id |INT | #### 表描述 记录了线程状态相关的数据。 -#### 字段详细描述 -- id：线程状态在数据库中的id，从0开始序列增长 +#### 字段详细描述 +- id: 唯一标识 - ts：该线程状态的起始时间 - dur：该线程状态的持续时间 - cpu：该线程在哪个cpu上执行（针对running状态的线程） @@ -1502,6 +1583,8 @@ js_heap_sample:记录timeline的时间轴信息 - tid：线程号 - pid：进程号 - state：线程实际的的状态值 +- argset_id：线程状态参数，对应arg_view中arg_set + ``` 'R', Runnable状态 "S", interruptible sleep @@ -1567,17 +1650,23 @@ js_heap_sample:记录timeline的时间轴信息 |src |TEXT | |dst |INT | |type |INT | +|type_desc |TEXT | |flag |INT | |depth |INT | |frame_no |INT| #### 表描述 应用的实际渲染帧和期望渲染帧的开始时间，持续时长，以及RenderService和App之间的关联关系。 #### 关键字段描述 +- ts: 数据上报时间戳 +- vsync: 一个id值，用于标识一组渲染帧的期望和实际数据。 +- ipid：所属的进程内部id, 关联process表中的id +- itid：所属的线程id, 关联thread表中的id - callstack_id：该帧数据对应着callstack表的调用栈所在的行数 - dur：该帧渲染时长（当数据不完整时，改行数据为空） - src：该帧是被哪一帧（该表中对应的行数）触发的，有多个值时，用逗号分割 - dst：该帧对应的渲染帧是哪一行 - type: 0 说明该行数据是实际渲染帧， 1 说明该行数据是期望渲染帧 +- type_desc: 当type值为0时，该字段为actural; 当type值为1时，该字段为expect; - flag: 空时，为不完整的数据；0 表示实际渲染帧不卡帧， 1 表示实际渲染帧卡帧(expectEndTime < actualEndTime为异常)， 2 表示数据不需要绘制（没有frameNum信息），3 表示rs进程与app进程起止异常(|expRsStartTime - expUiEndTime| < 1ms 正常，否则异常。这里使用期待帧的时间差做判断，给实际帧打标签) - depth：预留 - frame_no：预留 @@ -1630,7 +1719,7 @@ js_heap_sample:记录timeline的时间轴信息 |allocation_itid |INT | |execute_itid |INT | |return_itid |INT | -|execute_id |INT | +|task_id |INT | |priority |INT | |execute_state |INT | |return_state |INT | @@ -1638,13 +1727,14 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录了任务池相关数据，与callstack表关联。 #### 关键字段描述 +- id: 唯一标识 - allocation_task_row：与callstack表id号相关联 - execute_task_row：与callstack表id号相关联 - return_task_row：与callstack表id号相关联 - allocation_itid：任务分发的itid - execute_itid：任务执行的itid - return_itid：任务返回的itid -- execute_id：任务执行id +- task_id：任务执行id - priority：任务分发独有的，优先级{HIGH : 0，MEDIUM : 1，LOW : 2} - execute_state：任务执行独有的执行状态{NOT_FOUND : 0，WAITING : 1，RUNNING : 2，CANCELED : 3} - return_state：任务返回独有的任务返回状态[IsCanceled DeserializeFailed Successful Unsuccessful] @@ -1663,11 +1753,12 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录动效的响应时延和完成时延等信息。 #### 关键字段描述 +- id: 唯一标识 - input_time：输入时间点 - start_point：开始时间点 - end_point：结束时间点 -- frame_info：动效帧信息，格式：`实际帧个数:实际帧帧率` -- name: 当前动效名，eg：`H:APP_LIST_FLING, com.taobao.taobao` +- frame_info：动效帧信息，格式：`实际帧个数:实际帧帧率` +- name: 当前动效名，eg：`H:APP_LIST_FLING, com.taobao.taobao` ### dynamic_frame表 #### 表结构 @@ -1684,6 +1775,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录动效帧的坐标、分辨率、结束时间等信息。 #### 关键字段描述 +- id: 唯一标识 - x：坐标x - y：坐标y - width：宽 @@ -1703,6 +1795,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录设备分辨率和帧率等信息。 #### 关键字段描述 +- id: 唯一标识 - physical_width：设备宽 - physical_height：设备高 - physical_frame_rate：设备帧率 @@ -1733,22 +1826,29 @@ js_heap_sample:记录timeline的时间轴信息 |recording |INT | |stream_all |INT | #### 表描述 -该表记录设备屏幕亮度，蓝牙，位置，wifi，音乐，媒体等信息。 +该表记录设备屏幕亮度，蓝牙，位置，wifi，音乐，媒体等信息。该表目前暂未被使用。 #### 关键字段描述 +- id: 唯一标识 - brightness：屏幕亮度 - bt_state：蓝牙状态 - location：位置信息 - wifi：无线网络状态 +- stream_default: 取自AudioVolumeInfo message的stream_default字段。 - voice_call：语音通话 - music：音乐播放 +- stream_ring: 取自AudioVolumeInfo message的stream_ring字段。 - media：多媒体 - voice_assistant：语音助手 - system：系统 - alarm：闹钟 - notification：消息通知 - bt_sco：蓝牙语音 +- enforced_audible: 取自AudioVolumeInfo message的enforced_audible字段 +- stream_dtmf: 取自AudioVolumeInfo message的stream_dtmf字段 +- stream_tts: 取自AudioVolumeInfo message的stream_tts字段 - accessibility：访问权限 - recording：录音 +- stream_all: 取自AudioVolumeInfo message的stream_all字段 ### trace_config表 #### 表结构 @@ -1761,6 +1861,7 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录trace数据源，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 #### 关键字段描述 +- id: 唯一标识 - trace_source：事件源 - key：事件需要关注的信息名 - value：事件需要关注的信息名对应的信息值 @@ -1783,16 +1884,20 @@ js_heap_sample:记录timeline的时间轴信息 |purged |INT | |flag |INT | #### 表描述 -该表记录trace数据源，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 +该表记录trace数据源/proc/purgeable_ashmem_trigger，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 #### 关键字段描述 +- id: 唯一标识 - ts：时间戳 - ipid：内部进程号 +- adj: purgeable_ashmem_trigger中adj - fd：共享内存文件描述符 - ashmem_name_id：共享内存名 - size：共享内存大小 - pss：PSS内存大小 - ashmem_id：共享内存ID +- time： purgeable_ashmem_trigger中time - ref_count：引用计数 +- purged: purgeable_ashmem_trigger中purged - flag：去重标记，0表示正常，1表示进程内部重复数据，2表示进程间重复数据 ### memory_dma表 @@ -1811,13 +1916,16 @@ js_heap_sample:记录timeline的时间轴信息 |exp_name_id |INT | |flag |INT | #### 表描述 -该表记录trace数据源，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 +该表记录trace数据源取/proc/process_dmabuf_info节点，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 #### 关键字段描述 +- id: 唯一标识 - ts：时间戳 - ipid：内部进程号 - fd：dma内存文件描述符 - size：dma内存大小 +- ino: process_dmabuf_info中ino列 - exp_pid：申请者的进程号 +- exp_task_comm_id：申请者的的线程名，对应data_dict的id - buf_name_id：dma内存名 - exp_name_id：申请者进程名 - flag：去重标记，0表示正常，1表示进程内部重复数据，2表示进程间重复数据 @@ -1835,8 +1943,9 @@ js_heap_sample:记录timeline的时间轴信息 |itid |INT | |used_gpu_size |INT | #### 表描述 -该表记录trace数据源，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 +该表记录trace数据源读取/proc/gpu_memory节点 #### 关键字段描述 +- id: 唯一标识 - ts：时间戳 - gpu_name_id：gpu内存名称 - all_gpu_size：进程占用gpu总大小 @@ -1859,15 +1968,17 @@ js_heap_sample:记录timeline的时间轴信息 |count |INT | |purgeable_size|INT | #### 表描述 -该表记录trace数据源，proto的事件-plugin与其process_name（目前只有HisysEvent事件在用）。 +该表记录trace数据源/sys/kernel/debug/mali0/ctx/$(pidof xxx)_0/mem_profile #### 关键字段描述 +- id: 唯一标识 - ts：时间戳 - window_name_id：窗口名 - window_id：窗口id - module_name_id：模块名 - category_name_id：目录名 -- size：内存大小 +- size：内存大小 bytes - count：内存申请个数 +- purgeable_size： 取Total memory对应的字节大小 ### static_initalize表 #### 表结构 @@ -1884,10 +1995,99 @@ js_heap_sample:记录timeline的时间轴信息 #### 表描述 该表记录了so初始化相关数据。 #### 关键字段描述 +- id: 唯一标识 - ipid：内部进程号 - tid：内部线程号 - call_id：调用者的ID，对应线程表里面的itid - start_time：阶段开始时间 - end_time：阶段结束时间 - so_name：so文件名称 -- depth：泳道图的深度 \ No newline at end of file +- depth：泳道图的深度 +### memory_cpu表 +#### 表结构 +| Columns Name | SQL TYPE | +|---- |---- | +|id |INT | +|ts |INT | +|total_size |INT | +#### 表描述 +该表记录了hidumper抓取的cpu的内存大小的相关数据。 +#### 关键字段描述 +- id: 唯一标识 +- ts：数据上报时间戳 +- total_size：hidumper取到的cpu内存大小 + +### memory_profile表 +#### 表结构 +| Columns Name | SQL TYPE | +|---- |---- | +|id |INT | +|ts |INT | +|channel_id |INT | +|total_size |INT | +#### 表描述 +该表记录了读取/sys/kernel/debug/mali0/ctx/$(pidof xxx)_0/mem_profile节点相关数据。 +#### 关键字段描述 +- id: 唯一标识 +- ts：数据上报时间戳 +- channel_id: 取Channel对应的名称,对应data_dict的id +- total_size：取Total memory对应的字节大小 + +### memory_rs_image表 +#### 表结构 +| Columns Name | SQL TYPE | +|---- |---- | +|id |INT | +|ts |INT | +|ipid |INT | +|mem_size |INT | +|type_id |INT | +|surface_name_id|INT | + +#### 表描述 +该表记录了hidumper抓取的界面的内存大小的相关数据。 +#### 关键字段描述 +- id: 唯一标识 +- ts：数据上报时间戳 +- ipid：内部进程号 +- mem_size: 取hidumper的size列 +- type_id：取hidumper的type列,对于data_dict表中的id +- surface_name_id: 取hidumper的surfaceName列 +### hisys_all_event表 +#### 表结构 +| Columns Name | SQL TYPE | +|---- |---- | +|id |INT | +|domain_id |INT | +|event_name_id |INT | +|ts |INT | +|type |INT | +|time_zone |TEXT | +|pid |INT | +|tid |INT | +|uid |INT | +|level |TEXT | +|tag |TEXT | +|event_id |INT | +|seq |INT | +|info |TEXT | +|contents |TEXT | + +#### 表描述 +该表记录所有hisysevent采集到的原始数据。 +#### 关键字段描述 +- id: 唯一标识一条该表数据 +- domain_id: 对应原始数据中的domain_字段在data_dict表中的索引。 +- event_name_id: 对应原始数据中name_字段在data_dict表中的索引。 +- ts: 对应原始数据中time_(ms)字段转化成ns +- type: 对应原始数据中type_字段 +- time_zone: 对应原始数据中tz_字段 +- pid: 进程号，对应原始数据中的pid_ +- tid: 线程号, 对应原始数据中tid_ +- uid: 对应原始数据中uid_ +- level: 对应原始数据中level_ +- tag: 对应原始数据中tag_ +- event_id: 对应原始数据id_ +- seq: 对应原始数据中seq_ +- info: 对应原数据中info_字段 +- contents: 取源数据中除了以上字段外的其他字段，组成新的json数据。 \ No newline at end of file diff --git a/trace_streamer/figures/db_hisys_event.png b/trace_streamer/figures/db_hisys_event.png index 215265182de684f1b4a31fd7158309f8c7532053..5d2fb43e681e6cfdd1ec5d08f81d21c36c9bc088 100755 Binary files a/trace_streamer/figures/db_hisys_event.png and b/trace_streamer/figures/db_hisys_event.png differ diff --git a/trace_streamer/figures/db_native_memory.png b/trace_streamer/figures/db_native_memory.png index 7cb32fd4250fcda94ad9aa86157d02628e776e28..c0733454d252c57121f2986af0ab8c0f7189c8b5 100644 Binary files a/trace_streamer/figures/db_native_memory.png and b/trace_streamer/figures/db_native_memory.png differ diff --git a/trace_streamer/figures/dump_and_mem.png b/trace_streamer/figures/dump_and_mem.png index ab9d01a8107c957e53cce9b66ff5a1d8e200064c..5d66800f663a7dcc66538363b794e42afe816340 100644 Binary files a/trace_streamer/figures/dump_and_mem.png and b/trace_streamer/figures/dump_and_mem.png differ diff --git a/trace_streamer/pare_third_party.sh b/trace_streamer/pare_third_party.sh index 4fa45c3c1d206121be282588176664f60712930d..74bea958df5310215fb72fc0e8035ebb513f6c73 100755 --- a/trace_streamer/pare_third_party.sh +++ b/trace_streamer/pare_third_party.sh @@ -132,8 +132,6 @@ if [ ! -f "hiperf/BUILD.gn" ];then if [ -d "developtools_hiperf" ];then mv developtools_hiperf hiperf $cp ../prebuilts/patch_hiperf/BUILD.gn ../third_party/hiperf/BUILD.gn - $cp ../prebuilts/patch_hiperf/file_ex.h hiperf/include/nonlinux/linux - $cp ../prebuilts/patch_hiperf/unique_fd.h hiperf/include/nonlinux/linux $sed -i "/FRIEND_TEST/s/^\(.*\)$/\/\/\1/g" hiperf/include/virtual_thread.h $sed -i "s/HIPERF_DEBUG/ALWAYSTRUE/g" hiperf/include/virtual_thread.h $sed -i "/#include \"report_json_file.h\"/s/^\(.*\)$/\/\/\1/g" hiperf/include/report.h @@ -168,12 +166,11 @@ if [ ! -f "bounds_checking_function/BUILD.gn" ];then $cp ../prebuilts/patch_bounds_checking_function/bounds_checking_functionbuild.gn bounds_checking_function/BUILD.gn fi -if [ ! -f "commonlibrary/c_utils/base/include/nocopyable.h" ];then +if [ ! -d "commonlibrary" ];then rm -rf commonlibrary git clone --depth=1 git@gitee.com:openharmony/commonlibrary_c_utils.git if [ -d "commonlibrary_c_utils" ];then - mkdir -p commonlibrary/c_utils/base/include - $cp commonlibrary_c_utils/base/include/nocopyable.h commonlibrary/c_utils/base/include + mv commonlibrary_c_utils commonlibrary rm -rf commonlibrary_c_utils fi fi diff --git a/trace_streamer/prebuilts/patch_hiperf/BUILD.gn b/trace_streamer/prebuilts/patch_hiperf/BUILD.gn index 4fbceafead74ad974204455ee8d52b61dae9f718..4fcf8600e011ccf93b8be1b014821e4914871b05 100644 --- a/trace_streamer/prebuilts/patch_hiperf/BUILD.gn +++ b/trace_streamer/prebuilts/patch_hiperf/BUILD.gn @@ -13,87 +13,66 @@ import("//build/ohos.gni") import("../../build/ts.gni") -ohos_source_set("elf") { - subsystem_name = "developtools" - part_name = "smartperf_host" - configs -= [ trace_cfg_path ] - configs += [ "../../gn:hiperf_trace_cfg" ] - cflags = [ "-D is_mingw=${is_mingw}" ] - sources = [ "src/utilities.cpp" ] - include_dirs = [ - "include", - "${SRC}/base", - "include/nonlinux/linux", - "include/nonlinux", - "${THIRD_PARTY}/bounds_checking_function/include", +config("hiperf_config") { + cflags = [ + "-D ALWAYSTRUE", + "-D is_mingw=${is_mingw}", ] - public_deps = [ "${THIRD_PARTY}/zlib:libz" ] } -ohos_source_set("hiperf_src") { - configs -= [ trace_cfg_path ] - configs += [ "../../gn:hiperf_trace_cfg" ] - subsystem_name = "developtools" - part_name = "smartperf_host" - cflags = [ "-D ALWAYSTRUE" ] - if (is_mingw) { - cflags += [ "-includeMingW64Fix.h" ] - } - sources = [ - "./src/callstack.cpp", - "./src/callstack.h", - "./src/dwarf_encoding.cpp", - "./src/dwarf_encoding.h", - "./src/hashlist.h", - "./src/option.cpp", - "./src/perf_event_record.cpp", - "./src/perf_file_format.cpp", - "./src/perf_file_reader.cpp", - "./src/register.cpp", - "./src/register.h", - "./src/report.cpp", - "./src/subcommand.cpp", - "./src/symbols_file.cpp", - "./src/unique_stack_table.cpp", - "./src/virtual_runtime.cpp", - "./src/virtual_thread.cpp", - "include/symbols_file.h", - ] +config("hiperf_public_config") { include_dirs = [ "linux", - "../", - "./", - "../../src/base", "include", - "../../src/include", - "../../src/", - "../../src/trace_streamer", "include/nonlinux", "include/nonlinux/linux", + "${SRC}/", + "${SRC}/base", + "${SRC}/include", + "${SRC}/trace_streamer", "${THIRD_PARTY}/bounds_checking_function/include", - ] - include_dirs += [ "${THIRD_PARTY}/perf_include/libbpf", - "${THIRD_PARTY}/libunwind/include", - "${THIRD_PARTY}/libunwind/src", - "${THIRD_PARTY}/libunwind/include/tdep-x86_64", - ] - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/cutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxlog", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include", + "${COMMON_LIBRARY}/base/include", ] + if (is_mingw) { + cflags = [ "-includeMingW64Fix.h" ] + } } -group("hiperf_platform_common") { - deps = [ - ":elf", - ":hiperf_src", - "${THIRD_PARTY}/protobuf:protobuf_lite_static", - "${THIRD_PARTY}/protobuf:protobuf_static", - "//third_party/perf_include/hiviewdfx:hiviewdfx", +ohos_source_set("hiperf_src") { + subsystem_name = "thirdparty" + part_name = "hiperf" + sources = [ + "src/callstack.cpp", + "src/dwarf_encoding.cpp", + "src/option.cpp", + "src/perf_event_record.cpp", + "src/perf_file_format.cpp", + "src/perf_file_reader.cpp", + "src/register.cpp", + "src/report.cpp", + "src/subcommand.cpp", + "src/symbols_file.cpp", + "src/unique_stack_table.cpp", + "src/utilities.cpp", + "src/virtual_runtime.cpp", + "src/virtual_thread.cpp", + ] + configs -= [ trace_cfg_path ] + configs += [ "../../gn:hiperf_trace_cfg" ] + configs += [ ":hiperf_config" ] + public_configs = [ ":hiperf_public_config" ] + public_deps = [ + "${THIRD_PARTY}/zlib:libz", + "//third_party/perf_include/hiviewdfx:libfaultloggerd", ] + if (!use_wasm && !is_win && !is_mingw && !is_mac && !is_test) { + if (!is_independent_compile) { + if (target_cpu == "arm64") { + public_deps += [ "//third_party/libunwind:unwind_source_arm64_opt" ] + } else { + public_deps += [ "//third_party/libunwind:unwind_source_${target_cpu}" ] + } + } else { + public_deps += [ "${THIRD_PARTY}/libunwind:libunwind" ] + } + } } diff --git a/trace_streamer/prebuilts/patch_hiperf/hiviewdfx_BUILD.gn b/trace_streamer/prebuilts/patch_hiperf/hiviewdfx_BUILD.gn index ca28797f0e308a236864ae274f41d43ea33f33c6..7e9651695b6d30241792d197fa8ae48d7d80fae5 100644 --- a/trace_streamer/prebuilts/patch_hiperf/hiviewdfx_BUILD.gn +++ b/trace_streamer/prebuilts/patch_hiperf/hiviewdfx_BUILD.gn @@ -12,55 +12,48 @@ # limitations under the License. import("//build/ohos.gni") import("//build/ts.gni") -ohos_source_set("hiviewdfx_source") { - configs -= [ trace_cfg_path ] - configs += [ "${TS_DIR}/gn:hiperf_trace_cfg" ] - subsystem_name = "developtools" - part_name = "smartperf_host" - cflags = [ "-D ALWAYSTRUE" ] - cflags += [ "-D DFX_NO_PRINT_LOG" ] - cflags += [ "-D is_host" ] +config("faultloggerd_config") { + cflags = [ + "-D ALWAYSTRUE", + "-D DFX_NO_PRINT_LOG", + "-D is_host", + ] if (!is_independent_compile) { configs = [ "${TS_DIR}/gn:ts_config" ] } - include_dirs = [ "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include" ] - include_dirs += [ "${THIRD_PARTY}/bounds_checking_function/include" ] - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxlog", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - ] - sources = [ "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil/dfx_util.cpp" ] - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - ] - - include_dirs += [ "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include" ] - include_dirs += [ +} +config("faultloggerd_public_config") { + include_dirs = [ + "faultloggerd/common/dfxlog", + "faultloggerd/common/dfxutil", + "faultloggerd/interfaces/common", + "faultloggerd/interfaces/nonlinux", + "faultloggerd/interfaces/innerkits/unwinder/include", "${THIRD_PARTY}/hiperf/include", "${THIRD_PARTY}/hiperf/include/nonlinux", "${THIRD_PARTY}/hiperf/include/nonlinux/linux", + "${THIRD_PARTY}/bounds_checking_function/include", + "${COMMON_LIBRARY}/base/include", ] if (is_mingw) { - cflags += [ "-includeMingW64Fix.h" ] include_dirs += [ "${THIRD_PARTY}/libunwind/include/mingw" ] } - sources += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_elf.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_elf_parser.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_map.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_maps.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_memory.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_mmap.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/dfx_symbols.cpp", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/unwinder_config.cpp", - ] } - -group("hiviewdfx") { - deps = [ - ":hiviewdfx_source", - "${THIRD_PARTY}/bounds_checking_function:libsec_static", +ohos_source_set("libfaultloggerd") { + sources = [ + "faultloggerd/common/dfxutil/dfx_util.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_elf.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_elf_parser.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_map.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_maps.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_memory.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_mmap.cpp", + "faultloggerd/interfaces/innerkits/unwinder/dfx_symbols.cpp", + "faultloggerd/interfaces/innerkits/unwinder/unwinder_config.cpp", ] + configs += [ ":faultloggerd_config" ] + public_configs = [ ":faultloggerd_public_config" ] + public_deps = [ "${THIRD_PARTY}/bounds_checking_function:libsec_static" ] + part_name = "faultloggerd" + subsystem_name = "thirdparty" } diff --git a/trace_streamer/prebuilts/patch_hiperf/unique_fd.h b/trace_streamer/prebuilts/patch_hiperf/unique_fd.h deleted file mode 100644 index d4ad5640937165b95aba2ad32eadde1a0c1609b5..0000000000000000000000000000000000000000 --- a/trace_streamer/prebuilts/patch_hiperf/unique_fd.h +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef UNIQUE_FD_H -#define UNIQUE_FD_H - -#include - -namespace OHOS { -class DefaultDeleter { -public: - static void Close(int fd) - { - if (fd >= 0) { - close(fd); - } - } -}; - -template -class UniqueFdAddDeletor; -template -bool operator==(const int &lhs, const UniqueFdAddDeletor &rhs); -template -bool operator!=(const int &lhs, const UniqueFdAddDeletor &rhs); -template -bool operator>=(const int &lhs, const UniqueFdAddDeletor &rhs); -template -bool operator>(const int &lhs, const UniqueFdAddDeletor &rhs); -template -bool operator<=(const int &lhs, const UniqueFdAddDeletor &rhs); -template -bool operator<(const int &lhs, const UniqueFdAddDeletor &rhs); - -template -class UniqueFdAddDeletor final { - friend bool operator==(const int &lhs, const UniqueFdAddDeletor &rhs); - - friend bool operator!=(const int &lhs, const UniqueFdAddDeletor &rhs); - - friend bool operator>=(const int &lhs, const UniqueFdAddDeletor &rhs); - - friend bool operator>(const int &lhs, const UniqueFdAddDeletor &rhs); - - friend bool operator<=(const int &lhs, const UniqueFdAddDeletor &rhs); - // clang-format off - friend bool operator< (const int& lhs, const UniqueFdAddDeletor& rhs); - // clang-format on -public: - explicit UniqueFdAddDeletor(const int &value) : fd_(value) {} - UniqueFdAddDeletor() : fd_(-1) {} - ~UniqueFdAddDeletor() - { - Reset(-1); - } - - // get fd out - int Release() - { - int tmp = fd_; - fd_ = -1; - return tmp; - } - - // this is dangerous, when you use it , you should know it, donot operator on the ret - operator int() const - { - return Get(); - } // NOLINT - // this is dangerous, when you use it , you should know it, donot operator on the ret - int Get() const - { - return fd_; - } - - // we need move fd from one to another - UniqueFdAddDeletor(UniqueFdAddDeletor &&rhs) - { - int rhsfd = rhs.Release(); - fd_ = rhsfd; - } - - UniqueFdAddDeletor &operator=(UniqueFdAddDeletor &&rhs) - { - int rhsfd = rhs.Release(); - Reset(rhsfd); - return *this; - } - - bool operator==(const int &rhs) const - { - return fd_ == rhs; - } - - bool operator!=(const int &rhs) const - { - return !(fd_ == rhs); - } - bool operator>=(const int &rhs) const - { - return fd_ >= rhs; - } - - bool operator>(const int &rhs) const - { - return fd_ > rhs; - } - - bool operator<=(const int &rhs) const - { - return fd_ <= rhs; - } - - bool operator<(const int &rhs) const - { - return fd_ < rhs; - } - -private: - int fd_ = -1; - - void Reset(int newValue) - { - if (fd_ >= 0) { - Deleter::Close(fd_); - } - fd_ = newValue; - } - - // disallow copy ctor and copy assign - UniqueFdAddDeletor(const UniqueFdAddDeletor &rhs) = delete; - UniqueFdAddDeletor &operator=(const UniqueFdAddDeletor &rhs) = delete; -}; - -template -bool operator==(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return lhs == uniqueFd.fd_; -} - -template -bool operator!=(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return !(lhs == uniqueFd.fd_); -} - -template -bool operator>=(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return lhs >= uniqueFd.fd_; -} - -template -bool operator>(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return lhs > uniqueFd.fd_; -} - -template -bool operator<=(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return lhs <= uniqueFd.fd_; -} - -template -bool operator<(const int &lhs, const UniqueFdAddDeletor &uniqueFd) -{ - return lhs < uniqueFd.fd_; -} - -using UniqueFd = UniqueFdAddDeletor; -} // namespace OHOS -#endif diff --git a/trace_streamer/prebuilts/patch_libunwind/libunwindbuild.gn b/trace_streamer/prebuilts/patch_libunwind/libunwindbuild.gn index 5228ee192b54adfb755d7cfb6e3025c429e15286..2d9d555a6a4ae69b3067f47e0b7d1e09e3342c06 100644 --- a/trace_streamer/prebuilts/patch_libunwind/libunwindbuild.gn +++ b/trace_streamer/prebuilts/patch_libunwind/libunwindbuild.gn @@ -13,225 +13,221 @@ import("//build/ohos.gni") common_source = [ - "src/dwarf/Gexpr.c", - "src/dwarf/Gfde.c", - "src/dwarf/Gfind_proc_info-lsb.c", - "src/dwarf/Gfind_unwind_table.c", - "src/dwarf/global.c", - "src/dwarf/Gparser.c", - "src/dwarf/Gpe.c", - "src/dwarf/Lexpr.c", - "src/dwarf/Lfde.c", - "src/dwarf/Lfind_proc_info-lsb.c", - "src/dwarf/Lfind_unwind_table.c", - "src/dwarf/Lparser.c", - "src/dwarf/Lpe.c", - "src/mi/backtrace.c", - "src/mi/dyn-cancel.c", - "src/mi/dyn-info-list.c", - "src/mi/dyn-register.c", - "src/mi/flush_cache.c", - "src/mi/Gdestroy_addr_space.c", - "src/mi/Gdyn-extract.c", - "src/mi/Gdyn-remote.c", - "src/mi/Gfind_dynamic_proc_info.c", - "src/mi/Gget_accessors.c", - "src/mi/Gget_fpreg.c", - "src/mi/Gget_proc_info_by_ip.c", - "src/mi/Gget_proc_name.c", - "src/mi/Gget_reg.c", - "src/mi/Gput_dynamic_unwind_info.c", - "src/mi/Gset_cache_size.c", - "src/mi/Gset_caching_policy.c", - "src/mi/Gset_fpreg.c", - "src/mi/Gset_reg.c", - "src/mi/init.c", - "src/mi/Ldestroy_addr_space.c", - "src/mi/Ldyn-extract.c", - "src/mi/Lfind_dynamic_proc_info.c", - "src/mi/Lget_fpreg.c", - "src/mi/Lget_proc_info_by_ip.c", - "src/mi/Lget_proc_name.c", - "src/mi/Lget_reg.c", - "src/mi/Lput_dynamic_unwind_info.c", - "src/mi/Lset_cache_size.c", - "src/mi/Lset_caching_policy.c", - "src/mi/Lset_fpreg.c", - "src/mi/Lset_reg.c", - "src/mi/mempool.c", - "src/mi/strerror.c", - "src/os-linux.c", - "src/ohos-config.c", - "src/ptrace/_UPT_access_fpreg.c", - "src/ptrace/_UPT_access_mem.c", - "src/ptrace/_UPT_access_reg.c", - "src/ptrace/_UPT_accessors.c", - "src/ptrace/_UPT_create.c", - "src/ptrace/_UPT_destroy.c", - "src/ptrace/_UPT_find_proc_info.c", - "src/ptrace/_UPT_get_dyn_info_list_addr.c", - "src/ptrace/_UPT_get_proc_name.c", - "src/ptrace/_UPT_put_unwind_info.c", - "src/ptrace/_UPT_reg_offset.c", - "src/ptrace/_UPT_resume.c", - "src/mi/maps.c", + "libunwind/src/dwarf/Gexpr.c", + "libunwind/src/dwarf/Gfde.c", + "libunwind/src/dwarf/Gfind_proc_info-lsb.c", + "libunwind/src/dwarf/Gfind_unwind_table.c", + "libunwind/src/dwarf/global.c", + "libunwind/src/dwarf/Gparser.c", + "libunwind/src/dwarf/Gpe.c", + "libunwind/src/dwarf/Lexpr.c", + "libunwind/src/dwarf/Lfde.c", + "libunwind/src/dwarf/Lfind_proc_info-lsb.c", + "libunwind/src/dwarf/Lfind_unwind_table.c", + "libunwind/src/dwarf/Lparser.c", + "libunwind/src/dwarf/Lpe.c", + "libunwind/src/mi/backtrace.c", + "libunwind/src/mi/dyn-cancel.c", + "libunwind/src/mi/dyn-info-list.c", + "libunwind/src/mi/dyn-register.c", + "libunwind/src/mi/flush_cache.c", + "libunwind/src/mi/Gdestroy_addr_space.c", + "libunwind/src/mi/Gdyn-extract.c", + "libunwind/src/mi/Gdyn-remote.c", + "libunwind/src/mi/Gfind_dynamic_proc_info.c", + "libunwind/src/mi/Gget_accessors.c", + "libunwind/src/mi/Gget_fpreg.c", + "libunwind/src/mi/Gget_proc_info_by_ip.c", + "libunwind/src/mi/Gget_proc_name.c", + "libunwind/src/mi/Gget_reg.c", + "libunwind/src/mi/Gput_dynamic_unwind_info.c", + "libunwind/src/mi/Gset_cache_size.c", + "libunwind/src/mi/Gset_caching_policy.c", + "libunwind/src/mi/Gset_fpreg.c", + "libunwind/src/mi/Gset_reg.c", + "libunwind/src/mi/init.c", + "libunwind/src/mi/Ldestroy_addr_space.c", + "libunwind/src/mi/Ldyn-extract.c", + "libunwind/src/mi/Lfind_dynamic_proc_info.c", + "libunwind/src/mi/Lget_fpreg.c", + "libunwind/src/mi/Lget_proc_info_by_ip.c", + "libunwind/src/mi/Lget_proc_name.c", + "libunwind/src/mi/Lget_reg.c", + "libunwind/src/mi/Lput_dynamic_unwind_info.c", + "libunwind/src/mi/Lset_cache_size.c", + "libunwind/src/mi/Lset_caching_policy.c", + "libunwind/src/mi/Lset_fpreg.c", + "libunwind/src/mi/Lset_reg.c", + "libunwind/src/mi/mempool.c", + "libunwind/src/mi/strerror.c", + "libunwind/src/os-linux.c", + "libunwind/src/ptrace/_UPT_access_fpreg.c", + "libunwind/src/ptrace/_UPT_access_mem.c", + "libunwind/src/ptrace/_UPT_access_reg.c", + "libunwind/src/ptrace/_UPT_accessors.c", + "libunwind/src/ptrace/_UPT_create.c", + "libunwind/src/ptrace/_UPT_destroy.c", + "libunwind/src/ptrace/_UPT_find_proc_info.c", + "libunwind/src/ptrace/_UPT_get_proc_name.c", + "libunwind/src/ptrace/_UPT_put_unwind_info.c", + "libunwind/src/ptrace/_UPT_reg_offset.c", + "libunwind/src/ptrace/_UPT_resume.c", ] # as libc++ is static linked with libunwind.a # we remove the Gstep.c for duplicated symbol violation if (target_cpu == "arm") { arm_source = [ - "src/arm/Gapply_reg_state.c", - "src/arm/Gcreate_addr_space.c", - "src/arm/Gex_tables.c", - "src/arm/Gget_proc_info.c", - "src/arm/Gget_save_loc.c", - "src/arm/Gglobal.c", - "src/arm/Ginit.c", - "src/arm/Ginit_local.c", - "src/arm/Ginit_remote.c", - "src/arm/Gos-linux.c", - "src/arm/Greg_states_iterate.c", - "src/arm/Gregs.c", - "src/arm/Gresume.c", - "src/arm/Gstash_frame.c", - "src/arm/Gstep.c", - "src/arm/Gtrace.c", - "src/arm/Lcreate_addr_space.c", - "src/arm/Lex_tables.c", - "src/arm/Lget_proc_info.c", - "src/arm/Lget_save_loc.c", - "src/arm/Lglobal.c", - "src/arm/Linit.c", - "src/arm/Linit_local.c", - "src/arm/Linit_remote.c", - "src/arm/Los-linux.c", - "src/arm/Lregs.c", - "src/arm/Lresume.c", - "src/arm/Lstash_frame.c", - "src/arm/Lstep.c", - "src/arm/Ltrace.c", - "src/arm/gen-offsets.c", - "src/arm/getcontext.S", - "src/arm/is_fpreg.c", - "src/arm/regname.c", - "src/arm/siglongjmp.S", - "src/elf32.c", + "libunwind/src/arm/Gapply_reg_state.c", + "libunwind/src/arm/Gcreate_addr_space.c", + "libunwind/src/arm/Gex_tables.c", + "libunwind/src/arm/Gget_proc_info.c", + "libunwind/src/arm/Gget_save_loc.c", + "libunwind/src/arm/Gglobal.c", + "libunwind/src/arm/Ginit.c", + "libunwind/src/arm/Ginit_local.c", + "libunwind/src/arm/Ginit_remote.c", + "libunwind/src/arm/Gos-linux.c", + "libunwind/src/arm/Greg_states_iterate.c", + "libunwind/src/arm/Gregs.c", + "libunwind/src/arm/Gresume.c", + "libunwind/src/arm/Gstash_frame.c", + "libunwind/src/arm/Gstep.c", + "libunwind/src/arm/Gtrace.c", + "libunwind/src/arm/Lcreate_addr_space.c", + "libunwind/src/arm/Lex_tables.c", + "libunwind/src/arm/Lget_proc_info.c", + "libunwind/src/arm/Lget_save_loc.c", + "libunwind/src/arm/Lglobal.c", + "libunwind/src/arm/Linit.c", + "libunwind/src/arm/Linit_local.c", + "libunwind/src/arm/Linit_remote.c", + "libunwind/src/arm/Los-linux.c", + "libunwind/src/arm/Lregs.c", + "libunwind/src/arm/Lresume.c", + "libunwind/src/arm/Lstash_frame.c", + "libunwind/src/arm/Lstep.c", + "libunwind/src/arm/Ltrace.c", + "libunwind/src/arm/getcontext.S", + "libunwind/src/arm/is_fpreg.c", + "libunwind/src/arm/regname.c", + "libunwind/src/arm/siglongjmp.S", + "libunwind/src/elf32.c", ] } if (target_cpu == "arm64") { arm64_source = [ - "src/aarch64/Gcreate_addr_space.c", - "src/aarch64/Gget_proc_info.c", - "src/aarch64/Gget_save_loc.c", - "src/aarch64/Gglobal.c", - "src/aarch64/Ginit.c", - "src/aarch64/Ginit_local.c", - "src/aarch64/Ginit_remote.c", - "src/aarch64/Gis_signal_frame.c", - "src/aarch64/Gregs.c", - "src/aarch64/Gresume.c", - "src/aarch64/Gstash_frame.c", - "src/aarch64/Gstep.c", - "src/aarch64/Gtrace.c", - "src/aarch64/Lcreate_addr_space.c", - "src/aarch64/Lget_proc_info.c", - "src/aarch64/Lget_save_loc.c", - "src/aarch64/Lglobal.c", - "src/aarch64/Linit.c", - "src/aarch64/Linit_local.c", - "src/aarch64/Linit_remote.c", - "src/aarch64/Lis_signal_frame.c", - "src/aarch64/Lregs.c", - "src/aarch64/Lresume.c", - "src/aarch64/Lstash_frame.c", - "src/aarch64/Lstep.c", - "src/aarch64/Ltrace.c", - "src/aarch64/getcontext.S", - "src/aarch64/is_fpreg.c", - "src/aarch64/regname.c", - "src/elf64.c", + "libunwind/src/aarch64/Gcreate_addr_space.c", + "libunwind/src/aarch64/Gget_proc_info.c", + "libunwind/src/aarch64/Gget_save_loc.c", + "libunwind/src/aarch64/Gglobal.c", + "libunwind/src/aarch64/Ginit.c", + "libunwind/src/aarch64/Ginit_local.c", + "libunwind/src/aarch64/Ginit_remote.c", + "libunwind/src/aarch64/Gis_signal_frame.c", + "libunwind/src/aarch64/Gregs.c", + "libunwind/src/aarch64/Gresume.c", + "libunwind/src/aarch64/Gstash_frame.c", + "libunwind/src/aarch64/Gstep.c", + "libunwind/src/aarch64/Gtrace.c", + "libunwind/src/aarch64/Lcreate_addr_space.c", + "libunwind/src/aarch64/Lget_proc_info.c", + "libunwind/src/aarch64/Lget_save_loc.c", + "libunwind/src/aarch64/Lglobal.c", + "libunwind/src/aarch64/Linit.c", + "libunwind/src/aarch64/Linit_local.c", + "libunwind/src/aarch64/Linit_remote.c", + "libunwind/src/aarch64/Lis_signal_frame.c", + "libunwind/src/aarch64/Lregs.c", + "libunwind/src/aarch64/Lresume.c", + "libunwind/src/aarch64/Lstash_frame.c", + "libunwind/src/aarch64/Lstep.c", + "libunwind/src/aarch64/Ltrace.c", + "libunwind/src/aarch64/getcontext.S", + "libunwind/src/aarch64/is_fpreg.c", + "libunwind/src/aarch64/regname.c", + "libunwind/src/elf64.c", ] } if (target_cpu == "x64") { x64_source = [ - "src/elf64.c", - "src/x86_64/Gcreate_addr_space.c", - "src/x86_64/Gget_proc_info.c", - "src/x86_64/Gget_save_loc.c", - "src/x86_64/Gglobal.c", - "src/x86_64/Ginit.c", - "src/x86_64/Ginit_local.c", - "src/x86_64/Ginit_remote.c", - "src/x86_64/Gos-linux.c", - "src/x86_64/Gregs.c", - "src/x86_64/Gresume.c", - "src/x86_64/Gstash_frame.c", - "src/x86_64/Gstep.c", - "src/x86_64/Gtrace.c", - "src/x86_64/Lcreate_addr_space.c", - "src/x86_64/Lget_proc_info.c", - "src/x86_64/Lget_save_loc.c", - "src/x86_64/Lglobal.c", - "src/x86_64/Linit.c", - "src/x86_64/Linit_local.c", - "src/x86_64/Linit_remote.c", - "src/x86_64/Los-linux.c", - "src/x86_64/Lregs.c", - "src/x86_64/Lresume.c", - "src/x86_64/Lstash_frame.c", - "src/x86_64/Lstep.c", - "src/x86_64/Ltrace.c", - "src/x86_64/getcontext.S", - "src/x86_64/is_fpreg.c", - "src/x86_64/regname.c", - "src/x86_64/setcontext.S", + "libunwind/src/elf64.c", + "libunwind/src/x86_64/Gcreate_addr_space.c", + "libunwind/src/x86_64/Gget_proc_info.c", + "libunwind/src/x86_64/Gget_save_loc.c", + "libunwind/src/x86_64/Gglobal.c", + "libunwind/src/x86_64/Ginit.c", + "libunwind/src/x86_64/Ginit_local.c", + "libunwind/src/x86_64/Ginit_remote.c", + "libunwind/src/x86_64/Gos-linux.c", + "libunwind/src/x86_64/Gregs.c", + "libunwind/src/x86_64/Gresume.c", + "libunwind/src/x86_64/Gstash_frame.c", + "libunwind/src/x86_64/Gstep.c", + "libunwind/src/x86_64/Gtrace.c", + "libunwind/src/x86_64/Lcreate_addr_space.c", + "libunwind/src/x86_64/Lget_proc_info.c", + "libunwind/src/x86_64/Lget_save_loc.c", + "libunwind/src/x86_64/Lglobal.c", + "libunwind/src/x86_64/Linit.c", + "libunwind/src/x86_64/Linit_local.c", + "libunwind/src/x86_64/Linit_remote.c", + "libunwind/src/x86_64/Los-linux.c", + "libunwind/src/x86_64/Lregs.c", + "libunwind/src/x86_64/Lresume.c", + "libunwind/src/x86_64/Lstash_frame.c", + "libunwind/src/x86_64/Lstep.c", + "libunwind/src/x86_64/Ltrace.c", + "libunwind/src/x86_64/getcontext.S", + "libunwind/src/x86_64/is_fpreg.c", + "libunwind/src/x86_64/regname.c", + "libunwind/src/x86_64/setcontext.S", ] } remove_sources = [] ptrace_sources = [ - "src/ptrace/_UPT_access_fpreg.c", - "src/ptrace/_UPT_access_mem.c", - "src/ptrace/_UPT_access_reg.c", - "src/ptrace/_UPT_accessors.c", - "src/ptrace/_UPT_create.c", - "src/ptrace/_UPT_destroy.c", - "src/ptrace/_UPT_find_proc_info.c", - "src/ptrace/_UPT_get_dyn_info_list_addr.c", - "src/ptrace/_UPT_get_proc_name.c", - "src/ptrace/_UPT_put_unwind_info.c", - "src/ptrace/_UPT_reg_offset.c", - "src/ptrace/_UPT_resume.c", + "libunwind/src/ptrace/_UPT_access_fpreg.c", + "libunwind/src/ptrace/_UPT_access_mem.c", + "libunwind/src/ptrace/_UPT_access_reg.c", + "libunwind/src/ptrace/_UPT_accessors.c", + "libunwind/src/ptrace/_UPT_create.c", + "libunwind/src/ptrace/_UPT_destroy.c", + "libunwind/src/ptrace/_UPT_find_proc_info.c", + "libunwind/src/ptrace/_UPT_get_dyn_info_list_addr.c", + "libunwind/src/ptrace/_UPT_get_proc_name.c", + "libunwind/src/ptrace/_UPT_put_unwind_info.c", + "libunwind/src/ptrace/_UPT_reg_offset.c", + "libunwind/src/ptrace/_UPT_resume.c", ] libunwind_la_SOURCES_local_nounwind = [ - "src/mi/backtrace.c", - "src/mi/dyn-cancel.c", - "src/mi/dyn-info-list.c", - "src/mi/dyn-register.c", - "src/mi/Ldyn-extract.c", - "src/mi/Lfind_dynamic_proc_info.c", - "src/mi/Lget_proc_info_by_ip.c", - "src/mi/Lget_proc_name.c", - "src/mi/Lput_dynamic_unwind_info.c", - "src/mi/Ldestroy_addr_space.c", - "src/mi/Lget_reg.c", - "src/mi/Lset_reg.c", - "src/mi/Lget_fpreg.c", - "src/mi/Lset_fpreg.c", - "src/mi/Lset_caching_policy.c", - "src/mi/Lset_cache_size.c", + "libunwind/src/mi/backtrace.c", + "libunwind/src/mi/dyn-cancel.c", + "libunwind/src/mi/dyn-info-list.c", + "libunwind/src/mi/dyn-register.c", + "libunwind/src/mi/Ldyn-extract.c", + "libunwind/src/mi/Lfind_dynamic_proc_info.c", + "libunwind/src/mi/Lget_proc_info_by_ip.c", + "libunwind/src/mi/Lget_proc_name.c", + "libunwind/src/mi/Lput_dynamic_unwind_info.c", + "libunwind/src/mi/Ldestroy_addr_space.c", + "libunwind/src/mi/Lget_reg.c", + "libunwind/src/mi/Lset_reg.c", + "libunwind/src/mi/Lget_fpreg.c", + "libunwind/src/mi/Lset_fpreg.c", + "libunwind/src/mi/Lset_caching_policy.c", + "libunwind/src/mi/Lset_cache_size.c", ] libunwind_dwarf_local_la_SOURCES = [ - "src/dwarf/Lexpr.c", - "src/dwarf/Lfde.c", - "src/dwarf/Lparser.c", - "src/dwarf/Lpe.c", - "src/dwarf/Lfind_proc_info-lsb.c", - "src/dwarf/Lfind_unwind_table.c", + "libunwind/src/dwarf/Lexpr.c", + "libunwind/src/dwarf/Lfde.c", + "libunwind/src/dwarf/Lparser.c", + "libunwind/src/dwarf/Lpe.c", + "libunwind/src/dwarf/Lfind_proc_info-lsb.c", + "libunwind/src/dwarf/Lfind_unwind_table.c", ] # remove local file @@ -240,13 +236,13 @@ remove_sources += libunwind_dwarf_local_la_SOURCES remove_sources += ptrace_sources if (is_mingw) { - common_source += [ "src/mingw/pal-single-threaded.c" ] + common_source += [ "libunwind/src/mingw/pal-single-threaded.c" ] } config("unwind_config_public") { include_dirs = [ - "src", - "include", + "libunwind/src", + "libunwind/include", ] cflags = [ @@ -261,6 +257,7 @@ config("unwind_config_public") { "-Wno-unused-variable", "-Wno-unused-result", "-Wno-tautological-constant-out-of-range-compare", + "-Wno-bitfield-constant-conversion", ] if (use_wasm) { cflags += [ "-Wno-incompatible-pointer-types" ] @@ -278,7 +275,7 @@ config("unwind_config_public") { } if (target_cpu == "arm") { - include_dirs += [ "include/tdep-arm" ] + include_dirs += [ "libunwind/include/tdep-arm" ] cflags += [ "-Wno-inline-asm", "-Wno-shift-count-overflow", @@ -286,10 +283,10 @@ config("unwind_config_public") { "-Wno-unused-function", ] } else if (target_cpu == "arm64") { - include_dirs += [ "include/tdep-aarch64" ] + include_dirs += [ "libunwind/include/tdep-aarch64" ] cflags += [ "-Wno-incompatible-pointer-types" ] } else if (target_cpu == "x64") { - include_dirs += [ "include/tdep-x86_64" ] + include_dirs += [ "libunwind/include/tdep-x86_64" ] } } config("unwind_config_remote") { @@ -354,8 +351,8 @@ if (target_cpu == "arm") { # no jump lib arm_source -= [ - "src/arm/getcontext.S", - "src/arm/siglongjmp.S", + "libunwind/src/arm/getcontext.S", + "libunwind/src/arm/siglongjmp.S", ] sources += arm_source sources -= remove_sources @@ -372,8 +369,7 @@ if (target_cpu == "arm64") { ":unwind_config_arm64", ] sources = common_source - - arm64_source -= [ "src/aarch64/getcontext.S" ] + arm64_source -= [ "libunwind/src/aarch64/getcontext.S" ] sources += arm64_source sources -= remove_sources @@ -393,8 +389,8 @@ if (target_cpu == "x86") { # no jump lib x64_source -= [ - "src/x86_64/getcontext.S", - "src/x86_64/setcontext.S", + "libunwind/src/x86_64/getcontext.S", + "libunwind/src/x86_64/setcontext.S", ] sources += x64_source sources -= remove_sources @@ -417,18 +413,9 @@ ohos_source_set("unwind_source") { sources += x64_source public_configs = [ ":unwind_config_x64" ] } - - sources += [ "src/os-ohos.c" ] } -if (defined(ohos_lite)) { - source_set("libunwind") { - deps = [ ":unwind_source" ] - public_configs = [ ":unwind_config_public" ] - } -} else { - source_set("libunwind") { - deps = [ ":unwind_source" ] - public_configs = [ ":unwind_config_public" ] - } +source_set("libunwind") { + deps = [ ":unwind_source" ] + public_configs = [ ":unwind_config_public" ] } diff --git a/trace_streamer/sdk/demo_sdk/BUILD.gn b/trace_streamer/sdk/demo_sdk/BUILD.gn index 7278cc971df2ea11d78b5fb595ae026a84eff4b5..9c4e5bd0068f2801c967e3c7d5ade67efc4b40c3 100644 --- a/trace_streamer/sdk/demo_sdk/BUILD.gn +++ b/trace_streamer/sdk/demo_sdk/BUILD.gn @@ -107,12 +107,6 @@ ohos_source_set("trace_streamer_sdk") { "${THIRD_PARTY}/json/single_include/nlohmann", "${THIRD_PARTY}/bounds_checking_function/include", ] - if (!use_wasm) { - include_dirs += [ - "${THIRD_PARTY}/libunwind/include", - "${THIRD_PARTY}/libunwind/src", - ] - } deps = [ "${SRC}/base:base", "${THIRD_PARTY}/bounds_checking_function:libsec_static", diff --git a/trace_streamer/sdk/demo_sdk/test/BUILD.gn b/trace_streamer/sdk/demo_sdk/test/BUILD.gn index 06192a8e5a5e82a32f5f848591d7e0d8307f28a9..d92e5841910d2e3add98edd1095bef16c633e768 100644 --- a/trace_streamer/sdk/demo_sdk/test/BUILD.gn +++ b/trace_streamer/sdk/demo_sdk/test/BUILD.gn @@ -27,7 +27,7 @@ if (target == "sdkdemotest") { "../:trace_streamer_sdk", ] include_dirs = [ - "../base", + "${SRC}/base", "../sdk", "..", "../trace_streamer", diff --git a/trace_streamer/sdk/demo_sdk/test/unittest/sdk_api_test.cpp b/trace_streamer/sdk/demo_sdk/test/unittest/sdk_api_test.cpp index f94e8fe8534ca11b2d3dec5de88941e047d75315..b87aa683a610c742ba800db4cab3365e84bcbf61 100644 --- a/trace_streamer/sdk/demo_sdk/test/unittest/sdk_api_test.cpp +++ b/trace_streamer/sdk/demo_sdk/test/unittest/sdk_api_test.cpp @@ -35,7 +35,7 @@ public: public: TraceStreamerSelector stream_ = {}; - RpcServer *rpcServer = new RpcServer(); + DemoRpcServer *rpcServer = new DemoRpcServer(); }; std::string g_resultTest; @@ -62,25 +62,25 @@ HWTEST_F(SDKApiTest, SetTableName, TestSize.Level1) SetRpcServer(rpcServer); auto ret = SDKSetTableName("first_table", "second_table", "third_table", "fouth_table"); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from first_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_TRUE(ret); EXPECT_EQ(g_resultTest.find("ok"), 0); std::string sqlQueryCounterObj("select * from second_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySlice("select * from third_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySliceObj("select * from fouth_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -94,24 +94,24 @@ HWTEST_F(SDKApiTest, DefaultTableName, TestSize.Level1) { TS_LOGI("test1-2"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySlice("select * from slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -127,24 +127,24 @@ HWTEST_F(SDKApiTest, NullTableName, TestSize.Level1) SetRpcServer(rpcServer); auto ret = SDKSetTableName(" ", " ", " ", " "); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQuerySlice("select * from slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); } @@ -160,24 +160,24 @@ HWTEST_F(SDKApiTest, NullAndManuallyCounterTableName, TestSize.Level1) SetRpcServer(rpcServer); auto ret = SDKSetTableName("first_table", "second_table", " ", " "); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from first_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQueryCounterObj("select * from second_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySlice("select * from slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); } @@ -193,24 +193,24 @@ HWTEST_F(SDKApiTest, NullAndManuallySliceTableName, TestSize.Level1) SetRpcServer(rpcServer); auto ret = SDKSetTableName(" ", " ", "first_table", "second_table"); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); std::string sqlQuerySlice("select * from first_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); std::string sqlQuerySliceObj("select * from second_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -224,14 +224,14 @@ HWTEST_F(SDKApiTest, CurrentDataForCounterObjectWithDefaultTableName, TestSize.L { TS_LOGI("test1-6"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounterObject(1, "counter_1"); EXPECT_EQ(0, ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -245,15 +245,15 @@ HWTEST_F(SDKApiTest, CurrentDataForCounterObjectWithManuallyTableName, TestSize. { TS_LOGI("test1-7"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", "second_table", " ", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", "second_table", " ", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounterObject(1, "counter_1"); EXPECT_EQ(0, ret); std::string sqlQueryCounterObj("select * from second_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -267,14 +267,14 @@ HWTEST_F(SDKApiTest, WrongDataForCounterObjectWithDefaultTableName, TestSize.Lev { TS_LOGI("test1-8"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounterObject(INVALID_INT32, "counter_1"); EXPECT_EQ(0, ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -288,15 +288,15 @@ HWTEST_F(SDKApiTest, WrongDataForCounterObjectWithManuallyTableName, TestSize.Le { TS_LOGI("test1-9"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", "second_table", " ", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", "second_table", " ", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounterObject(INVALID_INT32, "counter_1"); EXPECT_EQ(0, ret); std::string sqlQueryCounterObj("select * from second_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -310,15 +310,15 @@ HWTEST_F(SDKApiTest, WrongDataForCounterObject, TestSize.Level1) { TS_LOGI("test1-10"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", "second_table", " ", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", "second_table", " ", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounterObject(INVALID_INT32, " "); EXPECT_EQ(0, ret); std::string sqlQueryCounterObj("select * from gpu_counter_object;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); } @@ -332,14 +332,14 @@ HWTEST_F(SDKApiTest, CurrentDataForCounterWithDefaultTableName, TestSize.Level1) { TS_LOGI("test1-11"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounter(1, 100, 100); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -353,15 +353,15 @@ HWTEST_F(SDKApiTest, CurrentDataForCounterWithManuallyTableName, TestSize.Level1 { TS_LOGI("test1-12"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName("first_table", " ", " ", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName("first_table", " ", " ", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounter(1, 100, 100); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from first_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -375,14 +375,14 @@ HWTEST_F(SDKApiTest, WrongDataForCounterWithDefaultTableName, TestSize.Level1) { TS_LOGI("test1-13"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounter(INVALID_INT32, 100, 100); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -396,15 +396,15 @@ HWTEST_F(SDKApiTest, WrongDataForCounterWithManuallyTableName, TestSize.Level1) { TS_LOGI("test1-14"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName("first_table", " ", " ", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName("first_table", " ", " ", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounter(INVALID_INT32, 100, 100); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from first_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -418,14 +418,14 @@ HWTEST_F(SDKApiTest, CounterWithWrongData, TestSize.Level1) { TS_LOGI("test1-15"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendCounter(INVALID_INT32, INVALID_UINT64, INVALID_INT32); EXPECT_EQ(0, ret); std::string sqlQueryCounter("select * from counter_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -439,14 +439,14 @@ HWTEST_F(SDKApiTest, CurrentDataForSliceObjectWithDefaultTableName, TestSize.Lev { TS_LOGI("test1-16"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSliceObject(1, "slice_1"); EXPECT_EQ(0, ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -460,15 +460,15 @@ HWTEST_F(SDKApiTest, CurrentDataForSliceObjectWithManuallyTableName, TestSize.Le { TS_LOGI("test1-17"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", " ", " ", "fourth_table"); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table"); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSliceObject(1, "slice_1"); EXPECT_EQ(0, ret); std::string sqlQuerySliceObj("select * from fourth_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -482,14 +482,14 @@ HWTEST_F(SDKApiTest, WrongDataForSliceObjectWithDefaultTableName, TestSize.Level { TS_LOGI("test1-18"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSliceObject(1, "slice_1"); EXPECT_EQ(0, ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -503,15 +503,15 @@ HWTEST_F(SDKApiTest, WrongDataForSliceObjectWithManuallyTableName, TestSize.Leve { TS_LOGI("test1-19"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", " ", " ", "fourth_table"); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table"); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSliceObject(INVALID_INT32, "slice_1"); EXPECT_EQ(0, ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); } @@ -525,15 +525,15 @@ HWTEST_F(SDKApiTest, WrongDataForSliceObject, TestSize.Level1) { TS_LOGI("test1-20"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", " ", " ", "fourth_table"); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table"); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSliceObject(INVALID_INT32, " "); EXPECT_EQ(0, ret); std::string sqlQuerySliceObj("select * from slice_object_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res); EXPECT_EQ(g_resultTest.find("ok"), string::npos); EXPECT_FALSE(ret); } @@ -547,14 +547,14 @@ HWTEST_F(SDKApiTest, CurrentDataForSliceWithDefaultTableName, TestSize.Level1) { TS_LOGI("test1-21"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSlice(1, 100, 100, 100); EXPECT_EQ(0, ret); std::string sqlQuerySlice("select * from Slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -568,15 +568,15 @@ HWTEST_F(SDKApiTest, CurrentDataForSliceWithManuallyTableName, TestSize.Level1) { TS_LOGI("test1-22"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", " ", "third_table", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", " ", "third_table", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSlice(1, 100, 100, 100); EXPECT_EQ(0, ret); std::string sqlQuerySlice("select * from third_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -590,14 +590,14 @@ HWTEST_F(SDKApiTest, WrongDataForSliceWithDefaultTableName, TestSize.Level1) { TS_LOGI("test1-23"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSlice(INVALID_INT32, 100, 100, 100); EXPECT_EQ(0, ret); std::string sqlQuerySlice("select * from Slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -611,15 +611,15 @@ HWTEST_F(SDKApiTest, WrongDataForSliceWithManuallyTableName, TestSize.Level1) { TS_LOGI("test1-24"); SetRpcServer(rpcServer); - auto ret = SDKSetTableName(" ", " ", "third_table", " "); - ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = SDK_SetTableName(" ", " ", "third_table", " "); + ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSlice(INVALID_INT32, 100, 100, 100); EXPECT_EQ(0, ret); std::string sqlQuerySlice("select * from third_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } @@ -633,14 +633,14 @@ HWTEST_F(SDKApiTest, SliceWithWrongData, TestSize.Level1) { TS_LOGI("test1-25"); SetRpcServer(rpcServer); - auto ret = rpcServer->ts_->sdkDataParser_->GetJsonConfig(QueryResultCallback); + auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback); EXPECT_EQ(0, ret); - ret = rpcServer->ts_->sdkDataParser_->CreateTableByJson(); + ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson(); EXPECT_EQ(0, ret); ret = SDKAppendSlice(INVALID_INT32, INVALID_UINT64, INVALID_UINT64, INVALID_INT32); EXPECT_EQ(0, ret); std::string sqlQuerySlice("select * from slice_table;"); - ret = rpcServer->SqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); + ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res); EXPECT_EQ(g_resultTest.find("ok"), 0); EXPECT_TRUE(ret); } diff --git a/trace_streamer/sdk/demo_sdk/ts.gni b/trace_streamer/sdk/demo_sdk/ts.gni index 4ca0cd25e53fae1e0eac4583c0028aea7cef3b91..4c69fad04a9cc8ab92efbb6947ef11e80d5470e8 100644 --- a/trace_streamer/sdk/demo_sdk/ts.gni +++ b/trace_streamer/sdk/demo_sdk/ts.gni @@ -11,7 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. OHOS_PROTO_DIR = "" - +THIRD_PARTY = "//third_party" +SRC = "//src" if (target_os == "linux" || target_os == "macx" || target_os == "windows") { OHOS_FTRACE_PROTO_DIR = "//src/multi_platform" OHOS_MEMORY_PROTO_DIR = "//src/multi_platform" diff --git a/trace_streamer/src/BUILD.gn b/trace_streamer/src/BUILD.gn index 455d78792ab9ccd7591e2a415cbc85ef99caf666..c63d5a454e83d08b1e3a4723ffee27353b350b7d 100644 --- a/trace_streamer/src/BUILD.gn +++ b/trace_streamer/src/BUILD.gn @@ -80,9 +80,6 @@ config("trace_streamer_cfg") { "${THIRD_PARTY}/elfutils/libelf", ] } - if (is_mingw) { - cflags = [ "-includeMingW64Fix.h" ] - } } ohos_source_set("trace_streamer_source") { @@ -112,7 +109,7 @@ ohos_source_set("trace_streamer_source") { "table:table", "trace_data:trace_data", "//third_party/bounds_checking_function:libsec_static", - "//third_party/perf_include/hiviewdfx:hiviewdfx", + "//third_party/perf_include/hiviewdfx:libfaultloggerd", ] public_configs = [ ":trace_streamer_cfg" ] public_deps = [] diff --git a/trace_streamer/src/base/file.cpp b/trace_streamer/src/base/file.cpp index 338506437d0b95bf932bb7191f43b78a7fa83d31..fe4c4ff13d969fe767452f10bbe17e4ec2515c35 100644 --- a/trace_streamer/src/base/file.cpp +++ b/trace_streamer/src/base/file.cpp @@ -75,5 +75,23 @@ std::string GetExecutionDirectoryPath() std::string str(currPath); return str.substr(0, str.find_last_of('/')); } +#ifdef is_linux +std::vector GetFilesNameFromDir(const std::string &path) +{ + std::vector soFiles; + + std::filesystem::path dirPath(path); + // 检查文件是否存在 + if (!std::filesystem::exists(dirPath)) { + std::cout << "!std::filesystem::exists(dirPath)" << std::endl; + return soFiles; + } + // 遍历目录 + for (const auto &entry : std::filesystem::directory_iterator(dirPath)) { + soFiles.emplace_back(entry.path().string()); + } + return soFiles; +} +#endif } // namespace base } // namespace SysTuning diff --git a/trace_streamer/src/base/file.h b/trace_streamer/src/base/file.h index 04c5d01b38be1039b2731cab0f2120b36858b38a..931fc18e41b2c9d612bcbd2b37ed75c43338aa66 100644 --- a/trace_streamer/src/base/file.h +++ b/trace_streamer/src/base/file.h @@ -16,8 +16,11 @@ #ifndef INCLUDE_TUNING_BASE_FILE_UTILS_H #define INCLUDE_TUNING_BASE_FILE_UTILS_H +#ifdef is_linux +#include +#endif #include - +#include namespace SysTuning { namespace base { #define TS_PERMISSION_RW 0600 @@ -39,6 +42,9 @@ ssize_t Read(int32_t fd, uint8_t *dst, size_t dstSize); int32_t OpenFile(const std::string &path, int32_t flags, uint32_t mode = K_FILE_MODE_INVALID); std::string GetExecutionDirectoryPath(); +#ifdef is_linux +std::vector GetFilesNameFromDir(const std::string &fileDir); +#endif } // namespace base } // namespace SysTuning #endif // INCLUDE_TUNING_BASE_FILE_UTILS_H_ diff --git a/trace_streamer/src/cfg/trace_streamer_config.cpp b/trace_streamer/src/cfg/trace_streamer_config.cpp index ef3ba27e17eecb00f9a9c94aa15b89a9c51fc761..f1718c6ab4a535990cf1dfaef62d2ab104426c21 100644 --- a/trace_streamer/src/cfg/trace_streamer_config.cpp +++ b/trace_streamer/src/cfg/trace_streamer_config.cpp @@ -99,7 +99,7 @@ void TraceStreamerConfig::PrintInfo() const printf("\n"); } -inline void TraceStreamerConfig::InitBinderEventNameMap() +void TraceStreamerConfig::InitBinderEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION, TRACE_ACTION_BINDER_TRANSACTION); eventNameMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, TRACE_ACTION_BINDER_TRANSACTION_RECEIVED); @@ -108,7 +108,7 @@ inline void TraceStreamerConfig::InitBinderEventNameMap() eventNameMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, TRACE_ACTION_BINDER_TRANSACTION_LOCKED); eventNameMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, TRACE_ACTION_BINDER_TRANSACTION_UNLOCK); } -inline void TraceStreamerConfig::InitSchedEventNameMap() +void TraceStreamerConfig::InitSchedEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_SCHED_SWITCH, TRACE_ACTION_SCHED_SWITCH); eventNameMap_.emplace(TRACE_EVENT_SCHED_BLOCKED_REASON, TRACE_ACTION_SCHED_BLOCKED_REASON); @@ -116,7 +116,7 @@ inline void TraceStreamerConfig::InitSchedEventNameMap() eventNameMap_.emplace(TRACE_EVENT_SCHED_WAKING, TRACE_ACTION_SCHED_WAKING); eventNameMap_.emplace(TRACE_EVENT_SCHED_WAKEUP_NEW, TRACE_ACTION_SCHED_WAKEUP_NEW); } -inline void TraceStreamerConfig::InitClkEventNameMap() +void TraceStreamerConfig::InitClkEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_CLOCK_SET_RATE, TRACE_ACTION_CLOCK_SET_RATE); eventNameMap_.emplace(TRACE_EVENT_CLOCK_ENABLE, TRACE_ACTION_CLOCK_ENABLE); @@ -126,14 +126,14 @@ inline void TraceStreamerConfig::InitClkEventNameMap() eventNameMap_.emplace(TRACE_EVENT_CLK_DISABLE, TRACE_ACTION_CLK_DISABLE); eventNameMap_.emplace(TRACE_EVENT_CLOCK_SYNC, TRACE_ACTION_CLOCK_SYNC); } -inline void TraceStreamerConfig::InitCpuEventNameMap() +void TraceStreamerConfig::InitCpuEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_CPU_IDLE, TRACE_ACTION_CPU_IDLE); eventNameMap_.emplace(TRACE_EVENT_CPU_FREQUENCY, TRACE_ACTION_CPU_FREQUENCY); eventNameMap_.emplace(TRACE_EVENT_CPU_FREQUENCY_LIMITS, TRACE_ACTION_CPU_FREQUENCY_LIMITS); eventNameMap_.emplace(TRACE_CPU_USAGE, TRACE_ACTION_CPU_USAGE); } -inline void TraceStreamerConfig::InitInterruptEventNameMap() +void TraceStreamerConfig::InitInterruptEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_IPI_ENTRY, TRACE_ACTION_IPI_ENTRY); eventNameMap_.emplace(TRACE_EVENT_IPI_EXIT, TRACE_ACTION_IPI_EXIT); @@ -142,8 +142,13 @@ inline void TraceStreamerConfig::InitInterruptEventNameMap() eventNameMap_.emplace(TRACE_EVENT_SOFTIRQ_RAISE, TRACE_ACTION_SOFTIRQ_RAISE); eventNameMap_.emplace(TRACE_EVENT_SOFTIRQ_ENTRY, TRACE_ACTION_SOFTIRQ_ENTRY); eventNameMap_.emplace(TRACE_EVENT_SOFTIRQ_EXIT, TRACE_ACTION_SOFTIRQ_EXIT); + eventNameMap_.emplace(TRACE_EVENT_DMA_FENCE_INIT, TRACE_ACTION_DMA_FENCE_INIT); + eventNameMap_.emplace(TRACE_EVENT_DMA_FENCE_DESTROY, TRACE_ACTION_DMA_FENCE_DESTROY); + eventNameMap_.emplace(TRACE_EVENT_DMA_FENCE_ENABLE, TRACE_ACTION_DMA_FENCE_ENABLE); + eventNameMap_.emplace(TRACE_EVENT_DMA_FENCE_SIGNALED, TRACE_ACTION_DMA_FENCE_SIGNALED); + eventNameMap_.emplace(TRACE_EVENT_DMA_FENCE, TRACE_ACTION_DMA_FENCE); } -inline void TraceStreamerConfig::InitMemoryEventNameMap() +void TraceStreamerConfig::InitMemoryEventNameMap() { eventNameMap_.emplace(TRACE_MEMORY, TRACE_ACTION_MEMORY); eventNameMap_.emplace(TRACE_SYS_MEMORY, TRACE_ACTION_SYS_MEMORY); @@ -154,7 +159,7 @@ inline void TraceStreamerConfig::InitMemoryEventNameMap() eventNameMap_.emplace(TRACE_JS_MEMORY, TRACE_ACTION_JS_MEMORY); eventNameMap_.emplace(TRACE_SYS_VIRTUAL_MEMORY, TRACE_ACTION_SYS_VIRTUAL_MEMORY); } -inline void TraceStreamerConfig::InitBlockEventNameMap() +void TraceStreamerConfig::InitBlockEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_BLOCK_BIO_BACKMERGE, TRACE_ACTION_BLOCK_BIO_BACKMERGE); eventNameMap_.emplace(TRACE_EVENT_BLOCK_BIO_BOUNCE, TRACE_ACTION_BLOCK_BIO_BOUNCE); @@ -170,14 +175,14 @@ inline void TraceStreamerConfig::InitBlockEventNameMap() eventNameMap_.emplace(TRACE_EVENT_BLOCK_RQ_REMAP, TRACE_ACTION_BLOCK_RQ_REMAP); eventNameMap_.emplace(TRACE_EVENT_BLOCK_RQ_ISSUE, TRACE_ACTION_BLOCK_RQ_ISSUE); } -inline void TraceStreamerConfig::InitRegulatorEventNameMap() +void TraceStreamerConfig::InitRegulatorEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_REGULATOR_SET_VOLTAGE, TRACE_ACTION_REGULATOR_SET_VOLTAGE); eventNameMap_.emplace(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, TRACE_ACTION_REGULATOR_SET_VOLTAGE_COMPLETE); eventNameMap_.emplace(TRACE_EVENT_REGULATOR_DISABLE, TRACE_ACTION_REGULATOR_DISABLE); eventNameMap_.emplace(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, TRACE_ACTION_REGULATOR_DISABLE_COMPLETE); } -inline void TraceStreamerConfig::InitOtherEventNameMap() +void TraceStreamerConfig::InitOtherEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_FFRT, TRACE_ACTION_FFRT); eventNameMap_.emplace(TRACE_EVENT_PRINT, TRACE_ACTION_PRINT); @@ -208,14 +213,14 @@ inline void TraceStreamerConfig::InitOtherEventNameMap() eventNameMap_.emplace(TRACE_ON_DO_COMPOSITION, TRACE_ACTION_ON_DO_COMPOSITION); eventNameMap_.emplace(TRACE_FRAMEQUEUE, TRACE_ACTION_FRAMEQUEUE); } -inline void TraceStreamerConfig::InitEbpfEventNameMap() +void TraceStreamerConfig::InitEbpfEventNameMap() { eventNameMap_.emplace(TRACE_EVENT_EBPF, TRACE_ACTION_EBPF); eventNameMap_.emplace(TRACE_EVENT_EBPF_FILE_SYSTEM, TRACE_ACTION_EBPF_FILE_SYSTEM); eventNameMap_.emplace(TRACE_EVENT_EBPF_PAGED_MEMORY, TRACE_ACTION_EBPF_PAGED_MEMORY); eventNameMap_.emplace(TRACE_EVENT_EBPF_BIO_LATENCY, TRACE_ACTION_EBPF_BIO_LATENCY); } -inline void TraceStreamerConfig::InitHookEventNameMap() +void TraceStreamerConfig::InitHookEventNameMap() { eventNameMap_.emplace(TRACE_NATIVE_HOOK_MALLOC, TRACE_ACTION_NATIVE_HOOK_MALLOC); eventNameMap_.emplace(TRACE_NATIVE_HOOK_FREE, TRACE_ACTION_NATIVE_HOOK_FREE); @@ -280,7 +285,7 @@ void TraceStreamerConfig::InitSysMemMap() {SysMeminfoType::PMEM_INACTIVE_PURG, SYS_MEMINFO_INACTIVE_PURG_DESC}, {SysMeminfoType::PMEM_PINED_PURG, SYS_MEMINFO_PINED_PURG_DESC}}; } -inline void TraceStreamerConfig::InitNrZoneEventSysVmemMap() +void TraceStreamerConfig::InitNrZoneEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_ZONE_ACTIVE_ANON, SYS_VMEMINFO_NR_ZONE_ACTIVE_ANON_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_ZONE_ACTIVE_FILE, SYS_VMEMINFO_NR_ZONE_ACTIVE_FILE_DESC); @@ -292,7 +297,7 @@ inline void TraceStreamerConfig::InitNrZoneEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_ZONE_WRITE_PENDING, SYS_VMEMINFO_NR_ZONE_WRITE_PENDING_DESC); } -inline void TraceStreamerConfig::InitNrDirtierEventSysVmemMap() +void TraceStreamerConfig::InitNrDirtierEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_DIRTY, SYS_VMEMINFO_NR_DIRTY_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_DIRTY_THRESHOLD, SYS_VMEMINFO_NR_DIRTY_THRESHOLD_DESC); @@ -300,7 +305,7 @@ inline void TraceStreamerConfig::InitNrDirtierEventSysVmemMap() SYS_VMEMINFO_NR_DIRTY_BACKGROUND_THRESHOLD_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_DIRTIED, SYS_VMEMINFO_NR_DIRTIED_DESC); } -inline void TraceStreamerConfig::InitNrOtherEventSysVmemMap() +void TraceStreamerConfig::InitNrOtherEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_FREE_PAGES, SYS_VMEMINFO_NR_FREE_PAGES_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_ALLOC_BATCH, SYS_VMEMINFO_NR_ALLOC_BATCH_DESC); @@ -351,7 +356,7 @@ inline void TraceStreamerConfig::InitNrOtherEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_NR_UNRECLAIMABLE_PAGES, SYS_VMEMINFO_NR_UNRECLAIMABLE_PAGES_DESC); } -inline void TraceStreamerConfig::InitPgscanEventSysVmemMap() +void TraceStreamerConfig::InitPgscanEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSCAN_KSWAPD_DMA, SYS_VMEMINFO_PGSCAN_KSWAPD_DMA_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSCAN_KSWAPD_NORMAL, @@ -368,7 +373,7 @@ inline void TraceStreamerConfig::InitPgscanEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSCAN_DIRECT, SYS_VMEMINFO_PGSCAN_DIRECT_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSCAN_KSWAPD, SYS_VMEMINFO_PGSCAN_KSWAPD_DESC); } -inline void TraceStreamerConfig::InitPgstealEventSysVmemMap() +void TraceStreamerConfig::InitPgstealEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSTEAL_KSWAPD_DMA, SYS_VMEMINFO_PGSTEAL_KSWAPD_DMA_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSTEAL_KSWAPD_NORMAL, @@ -383,7 +388,7 @@ inline void TraceStreamerConfig::InitPgstealEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSTEAL_DIRECT, SYS_VMEMINFO_PGSTEAL_DIRECT_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSTEAL_KSWAPD, SYS_VMEMINFO_PGSTEAL_KSWAPD_DESC); } -inline void TraceStreamerConfig::InitCompactEventSysVmemMap() +void TraceStreamerConfig::InitCompactEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_COMPACT_MIGRATE_SCANNED, SYS_VMEMINFO_COMPACT_MIGRATE_SCANNED_DESC); @@ -399,7 +404,7 @@ inline void TraceStreamerConfig::InitCompactEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_COMPACT_DAEMON_MIGRATE_SCANNED, SYS_VMEMINFO_COMPACT_DAEMON_MIGRATE_SCANNED_DESC); } -inline void TraceStreamerConfig::InitUnevictableEventSysVmemMap() +void TraceStreamerConfig::InitUnevictableEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_UNEVICTABLE_PGS_CULLED, SYS_VMEMINFO_UNEVICTABLE_PGS_CULLED_DESC); @@ -416,14 +421,14 @@ inline void TraceStreamerConfig::InitUnevictableEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_UNEVICTABLE_PGS_STRANDED, SYS_VMEMINFO_UNEVICTABLE_PGS_STRANDED_DESC); } -inline void TraceStreamerConfig::InitPgreFillEventSysVmemMap() +void TraceStreamerConfig::InitPgreFillEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGREFILL_DMA, SYS_VMEMINFO_PGREFILL_DMA_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGREFILL_NORMAL, SYS_VMEMINFO_PGREFILL_NORMAL_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGREFILL_MOVABLE, SYS_VMEMINFO_PGREFILL_MOVABLE_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGREFILL, SYS_VMEMINFO_PGREFILL_DESC); } -inline void TraceStreamerConfig::InitWorkingSetEventSysVmemMap() +void TraceStreamerConfig::InitWorkingSetEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_WORKINGSET_REFAULT, SYS_VMEMINFO_WORKINGSET_REFAULT_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_WORKINGSET_ACTIVATE, SYS_VMEMINFO_WORKINGSET_ACTIVATE_DESC); @@ -431,7 +436,7 @@ inline void TraceStreamerConfig::InitWorkingSetEventSysVmemMap() SYS_VMEMINFO_WORKINGSET_NODERECLAIM_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_WORKINGSET_RESTORE, SYS_VMEMINFO_WORKINGSET_RESTORE_DESC); } -inline void TraceStreamerConfig::InitPgEventSysVmemMap() +void TraceStreamerConfig::InitPgEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGPGIN, SYS_VMEMINFO_PGPGIN_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGPGOUT, SYS_VMEMINFO_PGPGOUT_DESC); @@ -454,7 +459,7 @@ inline void TraceStreamerConfig::InitPgEventSysVmemMap() sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSKIP_MOVABLE, SYS_VMEMINFO_PGSKIP_MOVABLE_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PGSKIP_NORMAL, SYS_VMEMINFO_PGSKIP_NORMAL_DESC); } -inline void TraceStreamerConfig::InitOtherEventSysVmemMap() +void TraceStreamerConfig::InitOtherEventSysVmemMap() { sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_UNSPECIFIED, SYS_VMEMINFO_UNSPECIFIED_DESC); sysVirtualMemNameMap_.emplace(SysVMeminfoType::VMEMINFO_PSWPIN, SYS_VMEMINFO_PSWPIN_DESC); @@ -491,131 +496,6 @@ void TraceStreamerConfig::InitSysVmemMap() InitOtherEventSysVmemMap(); } #endif -inline void TraceStreamerConfig::InitBinderEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_LOCK, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_LOCKED, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitSchedEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SCHED_SWITCH, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SCHED_BLOCKED_REASON, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SCHED_WAKEUP, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SCHED_WAKING, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SCHED_WAKEUP_NEW, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitClkEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLOCK_SET_RATE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLOCK_ENABLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLOCK_DISABLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLK_SET_RATE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLK_ENABLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLK_DISABLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CLOCK_SYNC, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitCpuEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CPU_IDLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CPU_FREQUENCY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_CPU_FREQUENCY_LIMITS, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_CPU_USAGE, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitInterruptEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_IPI_ENTRY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_IPI_EXIT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_IRQ_HANDLER_ENTRY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_IRQ_HANDLER_EXIT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SOFTIRQ_RAISE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SOFTIRQ_ENTRY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SOFTIRQ_EXIT, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitMemoryEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_MEMORY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_SYS_MEMORY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_ASHMEM, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_DMAMEM, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_GPU_PROCESS_MEM, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_GPU_WINDOW_MEM, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_JS_MEMORY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_SYS_VIRTUAL_MEMORY, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitBlockEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_BACKMERGE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_BOUNCE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_COMPLETE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_FRONTMERGE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_QUEUE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_BIO_REMAP, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_DIRTY_BUFFER, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_GETRQ, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_PLUG, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_RQ_COMPLETE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_RQ_INSERT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_RQ_REMAP, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_BLOCK_RQ_ISSUE, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitRegulatorEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_REGULATOR_SET_VOLTAGE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_REGULATOR_DISABLE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitOtherEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_FFRT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_PRINT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_TRACING_MARK_WRITE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_TASK_RENAME, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_TASK_NEWTASK, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SUSPEND_RESUME, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_WORKQUEUE_EXECUTE_START, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_WORKQUEUE_EXECUTE_END, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SYS_ENTRY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SYS_EXIT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_PROCESS_EXIT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_PROCESS_FREE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SIGNAL_GENERATE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_SIGNAL_DELIVER, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_OTHER, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_DISKIO, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_PROCESS, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NETWORK, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_PERF, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_HILOG, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_HIDUMP_FPS, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_HISYSEVENT, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_SMAPS, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_WINDOW_MANAGER_SERVICE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_VSYNC, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_ON_DO_COMPOSITION, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_FRAMEQUEUE, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitEbpfEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_EBPF, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_EBPF_FILE_SYSTEM, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_EBPF_PAGED_MEMORY, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_EVENT_EBPF_BIO_LATENCY, statSeverityDescMap_); -} -inline void TraceStreamerConfig::InitHookEventSecurityMap() -{ - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_MALLOC, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_FREE, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_MMAP, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_MUNMAP, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_RECORD_STATISTICS, statSeverityDescMap_); - eventParserStatSeverityDescMap_.emplace(TRACE_NATIVE_HOOK_MEMTAG, statSeverityDescMap_); -} void TraceStreamerConfig::InitSecurityMap() { statSeverityDescMap_ = { @@ -623,17 +503,9 @@ void TraceStreamerConfig::InitSecurityMap() {STAT_EVENT_NOTMATCH, STAT_SEVERITY_LEVEL_INFO}, {STAT_EVENT_NOTSUPPORTED, STAT_SEVERITY_LEVEL_WARN}, {STAT_EVENT_DATA_INVALID, STAT_SEVERITY_LEVEL_ERROR}, }; - InitBinderEventSecurityMap(); - InitSchedEventSecurityMap(); - InitClkEventSecurityMap(); - InitCpuEventSecurityMap(); - InitInterruptEventSecurityMap(); - InitMemoryEventSecurityMap(); - InitBlockEventSecurityMap(); - InitRegulatorEventSecurityMap(); - InitOtherEventSecurityMap(); - InitEbpfEventSecurityMap(); - InitHookEventSecurityMap(); + for (int i = 0; i < TRACE_EVENT_MAX; i++) { + eventParserStatSeverityDescMap_.emplace(static_cast(i), statSeverityDescMap_); + } } } // namespace TraceCfg } // namespace SysTuning diff --git a/trace_streamer/src/cfg/trace_streamer_config.h b/trace_streamer/src/cfg/trace_streamer_config.h index f1b065d68f41cc6b81f5d2d469bcad21e3468a91..7b4c28bd2ca8b5bdd7fe78de3604fbc58faa1f0c 100644 --- a/trace_streamer/src/cfg/trace_streamer_config.h +++ b/trace_streamer/src/cfg/trace_streamer_config.h @@ -116,6 +116,11 @@ enum SupportedTraceEventType { TRACE_GPU_PROCESS_MEM, TRACE_GPU_WINDOW_MEM, TRACE_WINDOW_MANAGER_SERVICE, + TRACE_EVENT_DMA_FENCE_INIT, + TRACE_EVENT_DMA_FENCE_DESTROY, + TRACE_EVENT_DMA_FENCE_ENABLE, + TRACE_EVENT_DMA_FENCE_SIGNALED, + TRACE_EVENT_DMA_FENCE, TRACE_EVENT_OTHER, TRACE_EVENT_MAX }; @@ -223,19 +228,7 @@ private: void InitPgEventSysVmemMap(); void InitOtherEventSysVmemMap(); #endif - void InitSecurityMap(); - void InitBinderEventSecurityMap(); - void InitSchedEventSecurityMap(); - void InitClkEventSecurityMap(); - void InitCpuEventSecurityMap(); - void InitInterruptEventSecurityMap(); - void InitMemoryEventSecurityMap(); - void InitBlockEventSecurityMap(); - void InitRegulatorEventSecurityMap(); - void InitOtherEventSecurityMap(); - void InitEbpfEventSecurityMap(); - void InitHookEventSecurityMap(); // all supported events should be defined here, these str can be find in text-based trace const std::string TRACE_ACTION_BINDER_TRANSACTION = "binder_transaction"; const std::string TRACE_ACTION_BINDER_TRANSACTION_RECEIVED = "binder_transaction_received"; @@ -306,6 +299,11 @@ private: const std::string TRACE_ACTION_BLOCK_RQ_INSERT = "trace_block_rq_insert"; const std::string TRACE_ACTION_BLOCK_RQ_REMAP = "trace_block_rq_remap"; const std::string TRACE_ACTION_BLOCK_RQ_ISSUE = "trace_block_rq_issue"; + const std::string TRACE_ACTION_DMA_FENCE_INIT = "dma_fence_init"; + const std::string TRACE_ACTION_DMA_FENCE_DESTROY = "dma_fence_destroy"; + const std::string TRACE_ACTION_DMA_FENCE_ENABLE = "dma_fence_enable_signal"; + const std::string TRACE_ACTION_DMA_FENCE_SIGNALED = "dma_fence_signaled"; + const std::string TRACE_ACTION_DMA_FENCE = "dma_fence"; const std::string TRACE_ACTION_FFRT = "trace_ffrt"; const std::string TRACE_ACTION_SYS_MEMORY = "sys_memory"; diff --git a/trace_streamer/src/filter/binder_filter.cpp b/trace_streamer/src/filter/binder_filter.cpp index 03c19a12eb43ae888e597130847d95f3661447c4..a7cf6a7c1d7966e1ffe837c9ce8e3bbea89cc29a 100644 --- a/trace_streamer/src/filter/binder_filter.cpp +++ b/trace_streamer/src/filter/binder_filter.cpp @@ -125,9 +125,12 @@ void BinderFilter::ReceiveTraction(int64_t ts, uint32_t pid, uint64_t transactio args.AppendArg(destThreadNameId_, BASE_DATA_TYPE_STRING, threadName); if (IsValidUint32(static_cast(replySliceid))) { args.AppendArg(destSliceId_, BASE_DATA_TYPE_INT, replySliceid); + } else { + TS_LOGD("ReceiveTraction, replySliceid value is INVALID!"); + return; } // Add dest args - uint64_t transSliceId = INVALID_UINT64; + uint64_t transSliceId = INVALID_UINT32; uint32_t argSetId = INVALID_UINT32; std::tie(transSliceId, argSetId) = streamFilters_->sliceFilter_->AddArgs(transNeedReply_[transactionId], binderCatalogId_, transSliceId_, args); @@ -136,6 +139,9 @@ void BinderFilter::ReceiveTraction(int64_t ts, uint32_t pid, uint64_t transactio ArgsSet replyDestInserter; if (IsValidUint32(transSliceId)) { replyDestInserter.AppendArg(destSliceId_, BASE_DATA_TYPE_INT, transSliceId); + } else { + TS_LOGD("ReceiveTraction, transSliceId value is INVALID!"); + return; } std::tie(transSliceId, argSetId) = streamFilters_->sliceFilter_->AddArgs(pid, binderCatalogId_, replyId_, replyDestInserter); diff --git a/trace_streamer/src/filter/hook_filter/BUILD.gn b/trace_streamer/src/filter/hook_filter/BUILD.gn index f3b05bc70525a8c9c876cff8687ecc61ab0af4bd..8af3276601b07041de589fb294e96291f5eb2010 100644 --- a/trace_streamer/src/filter/hook_filter/BUILD.gn +++ b/trace_streamer/src/filter/hook_filter/BUILD.gn @@ -15,7 +15,10 @@ import("//build/ohos.gni") import("../../../build/ts.gni") config("native_hook_filter_cfg") { - include_dirs = [ "." ] + include_dirs = [ + ".", + "${COMMON_LIBRARY}/base/include", + ] } ohos_static_library("native_hook_filter") { diff --git a/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp b/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp index 237a95a25ee0af97f2da910316923da75717a573..283a6f6831ab968231b0fa212813eba7ed2aac4b 100644 --- a/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp +++ b/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp @@ -403,7 +403,7 @@ void NativeHookFilter::ParseMmapEvent(uint64_t timeStamp, const ProtoReader::Byt DataIndex subType = INVALID_UINT64; auto mMapAddr = mMapEventReader.addr(); auto mMapSize = mMapEventReader.size(); - if (mMapEventReader.has_type()) { + if (mMapEventReader.has_type() && !mMapEventReader.type().ToStdString().empty()) { subType = traceDataCache_->dataDict_.GetStringIndex(mMapEventReader.type().ToStdString()); // Establish a mapping of addr and size to the mmap tag index. addrToMmapTag_[mMapAddr] = subType; // update addr to MemMapSubType @@ -1196,7 +1196,7 @@ void NativeHookFilter::UpdateFilePathIdAndStValueToSymAddrMap(T *firstSymbolAddr } } -bool NativeHookFilter::NativeHookReloadElfSymbolTable(const std::vector> &symbolsFiles) +void NativeHookFilter::NativeHookReloadElfSymbolTable(const std::vector> &symbolsFiles) { auto nativeHookFrame = traceDataCache_->GetNativeHookFrameData(); auto size = nativeHookFrame->Size(); @@ -1227,7 +1227,6 @@ bool NativeHookFilter::NativeHookReloadElfSymbolTable(const std::vector &nativeHookMetaData); void ParseTagEvent(const ProtoReader::BytesView &bytesView); void FinishParseNativeHookData(); - bool NativeHookReloadElfSymbolTable(const std::vector> &symbolsFiles); + void NativeHookReloadElfSymbolTable(const std::vector> &symbolsFiles); CommHookData &GetCommHookData(); ProfilerPluginData *GetHookPluginData(); void SerializeHookCommDataToString(); diff --git a/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.cpp b/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.cpp index a2fe90caba7b8110bb3e702e35740bb7eb65e0ba..a7431a1772200e940e3a75b728b3573632ee8680 100644 --- a/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.cpp +++ b/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.cpp @@ -152,40 +152,5 @@ std::shared_ptr OfflineSymbolizationFilter::OfflineSymbolizationByIp( ipidToIpToFrameInfo_.Insert(ipid, ip, frameInfo); return frameInfo; } -DataIndex OfflineSymbolizationFilter::OfflineSymbolizationByVaddr(uint64_t symVaddr, DataIndex filePathIndex) -{ - auto &symbolTable = filePathIdToImportSymbolTableMap_.at(filePathIndex); - // pase sym_table to Elf32_Sym or Elf64_Sym array decided by sym_entry_size. - auto symEntLen = symbolTable->symEntSize; - auto startValueToSymAddrMap = filePathIdAndStValueToSymAddr_.Find(filePathIndex); - if (!startValueToSymAddrMap) { - return INVALID_DATAINDEX; - } - // Traverse array, st_value <= symVaddr and symVaddr <= st_value + st_size. then you can get st_name - auto end = startValueToSymAddrMap->upper_bound(symVaddr); - auto length = std::distance(startValueToSymAddrMap->begin(), end); - uint32_t symbolStart = INVALID_UINT32; - if (length > 0) { - end--; - if (symEntLen == ELF32_SYM) { - GetSymbolStartMaybeUpdateFrameInfo(reinterpret_cast(end->second), symbolStart, symVaddr, - 0, nullptr); - } else { - GetSymbolStartMaybeUpdateFrameInfo(reinterpret_cast(end->second), symbolStart, symVaddr, - 0, nullptr); - } - } - if (symbolStart == INVALID_UINT32 || symbolStart >= symbolTable->strTable.size()) { - TS_LOGD("symbolStart is : %u invaliable!!!", symbolStart); - return INVALID_DATAINDEX; - } - auto mangle = symbolTable->strTable.c_str() + symbolStart; - auto demangle = base::GetDemangleSymbolIndex(mangle); - auto index = traceDataCache_->GetDataIndex(demangle); - if (demangle != mangle) { - free(demangle); - } - return index; -} } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.h b/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.h index f0083cc04f7413fd128516370b715e77f2801b76..aa73e9ada529729267935f60d9c75ace35ab569c 100644 --- a/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.h +++ b/trace_streamer/src/filter/hook_filter/offline_symbolization_filter.h @@ -63,7 +63,6 @@ public: OfflineSymbolizationFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter); ~OfflineSymbolizationFilter() override = default; std::shared_ptr OfflineSymbolizationByIp(uint64_t ipid, uint64_t ip); - DataIndex OfflineSymbolizationByVaddr(uint64_t symVaddr, DataIndex filePathIndex); protected: enum SYSTEM_ENTRY_VALUE { ELF32_SYM = 16, ELF64_SYM = 24 }; diff --git a/trace_streamer/src/filter/slice_filter.cpp b/trace_streamer/src/filter/slice_filter.cpp index f5cdb909199fcebcb58003fa1f8bafc2f96239ef..00ad01d3a72cc112cc4763d0cf040f7dabc7619e 100644 --- a/trace_streamer/src/filter/slice_filter.cpp +++ b/trace_streamer/src/filter/slice_filter.cpp @@ -22,6 +22,7 @@ #include "measure_filter.h" #include "process_filter.h" #include "stat_filter.h" +#include "string_help.h" #include "string_to_numerical.h" #include "ts_common.h" @@ -161,6 +162,17 @@ void SliceFilter::SoftIrqExit(uint64_t timeStamp, uint32_t cpu, ArgsSet args) return; } +void SliceFilter::DmaFence(DmaFenceRow &dmaFenceRow) +{ + if (dmaFenceEventMap_.find(dmaFenceRow.timeline) == dmaFenceEventMap_.end()) { + dmaFenceEventMap_.emplace(dmaFenceRow.timeline, dmaFenceRow.timeStamp); + } else { + dmaFenceRow.duration = dmaFenceRow.timeStamp - dmaFenceEventMap_.at(dmaFenceRow.timeline); + dmaFenceEventMap_.at(dmaFenceRow.timeline) = dmaFenceRow.timeStamp; + } + traceDataCache_->GetDmaFenceData()->AppendNew(dmaFenceRow); +} + void SliceFilter::RememberSliceData(InternalTid internalTid, std::unordered_map &stackMap, SliceData &slice, @@ -316,7 +328,7 @@ size_t SliceFilter::StartSlice(uint64_t timeStamp, CallStackInternalRow callStackInternalRow = {sliceData.timeStamp, static_cast(sliceData.duration), sliceData.internalTid, sliceData.cat, sliceData.name, 0}; - size_t index = slices->AppendInternalSlice(callStackInternalRow, std::nullopt); + size_t index = slices->AppendInternalSlice(callStackInternalRow, parentId); if (depth >= std::numeric_limits::max()) { return SIZE_MAX; } @@ -432,24 +444,29 @@ uint64_t SliceFilter::StartAsyncSlice(uint64_t timeStamp, int64_t cookie, DataIndex nameIndex) { - Unused(pid); InternalPid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(timeStamp, threadGroupId); - + uint32_t parentId = streamFilters_->processFilter_->UpdateOrCreateThread(timeStamp, pid); auto lastFilterId = asyncEventMap_.Find(internalTid, cookie, nameIndex); auto slices = traceDataCache_->GetInternalSlicesData(); + auto cat = INVALID_UINT64; if (lastFilterId != INVALID_UINT64) { asyncEventDisMatchCount_++; return INVALID_UINT64; } asyncEventSize_++; + std::smatch matchLine; + if (std::regex_match(traceDataCache_->GetDataFromDict(nameIndex), matchLine, categoryReg_)) { + std::string category = matchLine[categoryMatchedIdx_].str(); + cat = traceDataCache_->GetDataIndex(Strip(category)); + } // a pid, cookie and function name determain a callstack asyncEventMap_.Insert(internalTid, cookie, nameIndex, asyncEventSize_); // the IDE need a depth to paint call slice in different position of the canvas, the depth of async call // do not mean the parent-to-child relationship, it is different from no-async call uint8_t depth = 0; - CallStackInternalRow callStackInternalRow = { - timeStamp, static_cast(-1), internalTid, INVALID_UINT64, nameIndex, depth}; - size_t index = slices->AppendInternalAsyncSlice(callStackInternalRow, cookie, std::nullopt); + CallStackInternalRow callStackInternalRow = {timeStamp, static_cast(-1), internalTid, cat, nameIndex, + depth}; + size_t index = slices->AppendInternalAsyncSlice(callStackInternalRow, cookie, parentId); asyncEventFilterMap_.insert(std::make_pair(asyncEventSize_, AsyncEvent{timeStamp, index})); return index; } @@ -489,7 +506,6 @@ void SliceFilter::StartGEvent(uint64_t timeStamp, int64_t cookie, DataIndex nameIndex) { - Unused(pid); InternalPid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(timeStamp, threadGroupId); auto gEventRes = gEventMap_.Find(internalTid, cookie, nameIndex); auto slices = traceDataCache_->GetInternalSlicesData(); @@ -539,6 +555,7 @@ uint64_t SliceFilter::FinishHEvent(uint64_t timeStamp, uint32_t threadGroupId, i streamFilters_->processFilter_->AddThreadSliceNum(internalTid); return lastRow; } + size_t SliceFilter::EndSlice(uint64_t timeStamp, uint32_t pid, uint32_t threadGroupId, @@ -602,6 +619,8 @@ void SliceFilter::Clear() depthHolder_.clear(); sliceRowToArgsSetId_.clear(); argsSet_.clear(); + gEventMap_.Clear(); + gEventFilterMap_.clear(); } } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/filter/slice_filter.h b/trace_streamer/src/filter/slice_filter.h index 83d6b6f2d8ce07de56c67449605539de12fc9a20..2a46bc38e40861683690fc00534716187db510b5 100644 --- a/trace_streamer/src/filter/slice_filter.h +++ b/trace_streamer/src/filter/slice_filter.h @@ -93,6 +93,7 @@ public: void IpiHandlerExit(uint64_t timeStamp, uint32_t cpu); void SoftIrqEntry(uint64_t timeStamp, uint32_t cpu, DataIndex catalog, DataIndex nameIndex); void SoftIrqExit(uint64_t timeStamp, uint32_t cpu, ArgsSet args); + void DmaFence(DmaFenceRow &dmaFenceRow); void Clear(); void UpdateReadySize() { @@ -124,8 +125,8 @@ private: private: // The parameter list is tid, cookid, functionName, asyncCallId. TripleMap asyncEventMap_; - // this is only used to calc the layer of the async event in same time range TripleMap> gEventMap_; + // this is only used to calc the layer of the async event in same time range std::map asyncNoEndingEventMap_ = {}; // irq map, key1 is cpu, key2 struct IrqRecords { @@ -136,6 +137,7 @@ private: std::unordered_map ipiEventMap_ = {}; // irq map, key1 is cpu, key2 std::unordered_map softIrqEventMap_ = {}; + std::unordered_map dmaFenceEventMap_ = {}; std::map asyncEventFilterMap_ = {}; std::map gEventFilterMap_ = {}; std::unordered_map sliceStackMap_ = {}; @@ -157,6 +159,8 @@ private: DataIndex asyncBeginTsId_ = traceDataCache_->GetDataIndex("legacy_unnestable_last_begin_ts"); DataIndex ipiId_ = traceDataCache_->GetDataIndex("IPI"); std::map irqDataLinker_ = {}; + const std::regex categoryReg_ = std::regex(R"((.+)\$\$(.+))"); + const uint64_t categoryMatchedIdx_ = 1; }; } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/main.cpp b/trace_streamer/src/main.cpp index 2153563779581a9c19a050225e9f46f85ad33770..e3708b9704e2c4b1648c2e572287b2fadf8f7b9d 100644 --- a/trace_streamer/src/main.cpp +++ b/trace_streamer/src/main.cpp @@ -362,6 +362,7 @@ struct TraceExportOption { bool closeMutiThread = false; uint8_t parserThreadNum = INVALID_UINT8; bool needClearLongTraceCache = true; + std::string soFilesDir; }; bool CheckFinal(char **argv, TraceExportOption &traceExportOption) { @@ -375,7 +376,6 @@ bool CheckFinal(char **argv, TraceExportOption &traceExportOption) } return true; } - bool CheckArgc(int argc, char **argv, int curArgNum) { if (curArgNum == argc) { @@ -384,6 +384,12 @@ bool CheckArgc(int argc, char **argv, int curArgNum) } return true; } +bool CheckAndSetSoFilesPath(TraceExportOption &traceExportOption, int argc, char **argv, int &index) +{ + TS_CHECK_TRUE_RET(CheckArgc(argc, argv, ++index), false); + traceExportOption.soFilesDir = std::string(argv[index]); + return true; +} bool CheckAndSetLogLevel(int argc, char **argv, int &index) { TS_CHECK_TRUE_RET(CheckArgc(argc, argv, ++index), false); @@ -530,6 +536,10 @@ bool ParseArgs(int argc, char **argv, TraceExportOption &traceExportOption) TS_CHECK_TRUE_RET(CheckAndSetOutputFilePath(traceExportOption, argc, argv, i), false); i++; continue; + } else if (!strcmp(argv[i], "--So_dir")) { + TS_CHECK_TRUE_RET(CheckAndSetSoFilesPath(traceExportOption, argc, argv, i), false); + i++; + continue; } else if (!ParseOtherArgs(argc, argv, traceExportOption, i)) { return false; } @@ -729,6 +739,12 @@ int main(int argc, char **argv) } return 1; } +#ifdef is_linux + if (!traceExportOption.soFilesDir.empty()) { + auto values = GetFilesNameFromDir(traceExportOption.soFilesDir); + ts.ReloadSymbolFiles(traceExportOption.soFilesDir, values); + } +#endif if (traceExportOption.interactiveState) { TS_CHECK_TRUE_RET(EnterInteractiveState(ts), 1); } diff --git a/trace_streamer/src/parser/BUILD.gn b/trace_streamer/src/parser/BUILD.gn index 421a22a3d5cdaf5bd0ef327616de0b9d0f72011f..92f6fcd311c9ea0938d429797ffd19a8299397da 100644 --- a/trace_streamer/src/parser/BUILD.gn +++ b/trace_streamer/src/parser/BUILD.gn @@ -39,20 +39,6 @@ config("parser_base_cfg") { "${THIRD_PARTY}/json/single_include/nlohmann", "${THIRD_PARTY}/profiler/device/plugins/ftrace_plugin/include", ] - include_dirs += [ - "${PERF_DIR}/hiperf/include/nonlinux/linux", - "${PERF_DIR}/hiperf/include/nonlinux", - "${PERF_DIR}/hiperf/include", - "${THIRD_PARTY}/perf_include", - "${THIRD_PARTY}/perf_include/libbpf", - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/cutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxlog", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include", - ] include_dirs += [ "${SRC}/trace_data/trace_stdtype", "${SRC}/trace_data/trace_stdtype/ftrace", diff --git a/trace_streamer/src/parser/ebpf_parser/BUILD.gn b/trace_streamer/src/parser/ebpf_parser/BUILD.gn index 9a1512a2a7a2bc05662bfcc5ae88217ffa0abb59..224d47879ca057e67cda11ef18085f86f6b9ae39 100644 --- a/trace_streamer/src/parser/ebpf_parser/BUILD.gn +++ b/trace_streamer/src/parser/ebpf_parser/BUILD.gn @@ -59,17 +59,6 @@ config("ebpf_parser_cfg") { cflags += [ "-D IS_UT" ] } } - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - "${THIRD_PARTY}/perf_include/linux", - "${THIRD_PARTY}/hiperf/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/hiperf/include/nonlinux/linux", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/hiperf/include/nonlinux/", - "${THIRD_PARTY}/perf_include/libbpf", - ] } ohos_static_library("ebpf_parser") { @@ -87,7 +76,7 @@ ohos_static_library("ebpf_parser") { public_configs = [ ":ebpf_parser_cfg" ] public_deps = [ "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/types/plugins/memory_data:memory_data_reader", - "${PERF_DIR}/hiperf:hiperf_platform_common", + "${PERF_DIR}/hiperf:hiperf_src", ] deps = [ "${THIRD_PARTY}/protobuf:protobuf_lite_static", diff --git a/trace_streamer/src/parser/ebpf_parser/bio_latency_data_parser.cpp b/trace_streamer/src/parser/ebpf_parser/bio_latency_data_parser.cpp index c5d1dcac8acc605dee4eea534dced7cb28b9e67a..5f58ff54958ebb322c0048da5551b88516e4a73d 100644 --- a/trace_streamer/src/parser/ebpf_parser/bio_latency_data_parser.cpp +++ b/trace_streamer/src/parser/ebpf_parser/bio_latency_data_parser.cpp @@ -47,15 +47,12 @@ const uint64_t *BioLatencyDataParser::IPAndCallIdProcessing(const BIOFixedHeader currentCallId_ = callChainId_++; } } else { - currentCallId_ = INVALID_UINT64; + currentCallId_ = INVALID_UINT32; } return userIpsAddr; } void BioLatencyDataParser::ParseBioLatencyEvent() { - if (!reader_->GetBIOSampleMap().size()) { - return; - } for (auto mapItor = reader_->GetBIOSampleMap().begin(); mapItor != reader_->GetBIOSampleMap().end(); mapItor++) { streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_EBPF_BIO_LATENCY, STAT_EVENT_RECEIVED); auto bioFixedHeadrAddr = mapItor->second; diff --git a/trace_streamer/src/parser/ebpf_parser/ebpf_base.cpp b/trace_streamer/src/parser/ebpf_parser/ebpf_base.cpp index 9483f83b9ff75540513041d515ba2625e32445be..5fc741344f05c6fc81e07870afe6ad57857b4636 100644 --- a/trace_streamer/src/parser/ebpf_parser/ebpf_base.cpp +++ b/trace_streamer/src/parser/ebpf_parser/ebpf_base.cpp @@ -215,7 +215,7 @@ void EbpfBase::UpdateFilePathIndexAndStValueToSymAddrMap(T *firstSymbolAddr, con } } } -bool EbpfBase::EBPFReloadElfSymbolTable(const std::vector> &symbolsFiles) +void EbpfBase::EBPFReloadElfSymbolTable(const std::vector> &symbolsFiles) { auto ebpfCallStackDate = traceDataCache_->GetEbpfCallStack(); auto size = ebpfCallStackDate->Size(); @@ -241,7 +241,6 @@ bool EbpfBase::EBPFReloadElfSymbolTable(const std::vector diff --git a/trace_streamer/src/parser/ebpf_parser/ebpf_base.h b/trace_streamer/src/parser/ebpf_parser/ebpf_base.h index 7625cebc803f65b6bf9c7cd226d7cc3321492733..b33463efd04b3001f91c54b42726af725d4dba1c 100644 --- a/trace_streamer/src/parser/ebpf_parser/ebpf_base.h +++ b/trace_streamer/src/parser/ebpf_parser/ebpf_base.h @@ -36,7 +36,7 @@ public: EbpfBase(TraceDataCache *dataCache, const TraceStreamerFilters *ctx); ~EbpfBase(); bool InitEbpfDataParser(EbpfDataReader *reader); - bool EBPFReloadElfSymbolTable(const std::vector> &symbolsFiles); + void EBPFReloadElfSymbolTable(const std::vector> &symbolsFiles); protected: void ParseCallStackData(const uint64_t *userIpsAddr, uint16_t count, uint32_t pid, uint32_t callId); diff --git a/trace_streamer/src/parser/ebpf_parser/file_system_data_parser.cpp b/trace_streamer/src/parser/ebpf_parser/file_system_data_parser.cpp index cd23c3388337328e6a1b6fed01f6edd754b6465c..b03ae0e8ab8f18ea7422c72339d98d9cf52e6ccf 100644 --- a/trace_streamer/src/parser/ebpf_parser/file_system_data_parser.cpp +++ b/trace_streamer/src/parser/ebpf_parser/file_system_data_parser.cpp @@ -47,7 +47,7 @@ void FileSystemDataParser::IpAndCallidFind(const FsFixedHeader *fsFixedHeadrAddr currentCallId_ = callChainId_++; } } else { - currentCallId_ = INVALID_UINT64; + currentCallId_ = INVALID_UINT32; } } @@ -100,9 +100,6 @@ size_t FileSystemDataParser::FileWriteOperation(TracerEventToStrIndexMap &tracer void FileSystemDataParser::ParseFileSystemEvent() { - if (!reader_->GetFileSystemEventMap().size()) { - return; - } auto &tracerEventToStrIndexMap = reader_->GetTracerEventToStrIndexMap(); for (auto mapItor = reader_->GetFileSystemEventMap().begin(); mapItor != reader_->GetFileSystemEventMap().end(); mapItor++) { diff --git a/trace_streamer/src/parser/ebpf_parser/paged_memory_data_parser.cpp b/trace_streamer/src/parser/ebpf_parser/paged_memory_data_parser.cpp index 9298676f473570ae22c33d86b1d7430b1fc47b12..f35d328625bb73ccf94468a7db431c8ad7d50714 100644 --- a/trace_streamer/src/parser/ebpf_parser/paged_memory_data_parser.cpp +++ b/trace_streamer/src/parser/ebpf_parser/paged_memory_data_parser.cpp @@ -65,9 +65,6 @@ int32_t PagedMemoryDataParser::PagingData(const PagedMemoryFixedHeader *pagedMem void PagedMemoryDataParser::ParsePagedMemoryEvent() { - if (!reader_->GetPagedMemoryMap().size()) { - return; - } for (auto mapItor = reader_->GetPagedMemoryMap().begin(); mapItor != reader_->GetPagedMemoryMap().end(); mapItor++) { streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_EBPF_PAGED_MEMORY, STAT_EVENT_RECEIVED); @@ -80,7 +77,7 @@ void PagedMemoryDataParser::ParsePagedMemoryEvent() pagedMemoryFixedHeadrAddr->nips * SINGLE_IP_SIZE); auto ipsHashValue = hashFun_(ipsToStr); auto value = pidAndipsToCallId_.Find(pagedMemoryFixedHeadrAddr->pid, ipsHashValue); - if (value != INVALID_UINT64) { + if (value != INVALID_UINT32) { callIdExistFlag = true; currentCallId_ = value; } else { diff --git a/trace_streamer/src/parser/hiperf_parser/BUILD.gn b/trace_streamer/src/parser/hiperf_parser/BUILD.gn index 48697bff5305a2f02a988c9c5e38fe8da9493b02..03e3ad65cd0d5b50b1d57f1cda428eb57690c41c 100644 --- a/trace_streamer/src/parser/hiperf_parser/BUILD.gn +++ b/trace_streamer/src/parser/hiperf_parser/BUILD.gn @@ -46,7 +46,7 @@ config("hiperf_parser_cfg") { "${THIRD_PARTY}/bounds_checking_function/include", "${THIRD_PARTY}/sqlite/include", "${THIRD_PARTY}/protobuf/src", - "${COMMON_LIBRARY}/c_utils/base/include", + "${COMMON_LIBRARY}/base/include", "${THIRD_PARTY}/googletest/googletest/include", ] include_dirs += [ @@ -60,11 +60,6 @@ config("hiperf_parser_cfg") { "${SRC}/trace_data/trace_stdtype/measure", ] include_dirs += [ - "${THIRD_PARTY}/libunwind/include", - "${THIRD_PARTY}/libunwind/src", - "${PERF_DIR}/hiperf/include", - "${PERF_DIR}/hiperf/include/nonlinux/linux", - "${PERF_DIR}/hiperf/include/nonlinux", "${THIRD_PARTY}/googletest/googletest/include", "${THIRD_PARTY}/perf_include/libbpf", "${THIRD_PARTY}/perf_include/include", @@ -72,25 +67,12 @@ config("hiperf_parser_cfg") { "${THIRD_PARTY}/perf_include/linux", "../hiperf_parser", "../hiperf_parser/include", - "${COMMON_LIBRARY}/c_utils/base/include", + "${COMMON_LIBRARY}/base/include", "${THIRD_PARTY}/sqlite", ] - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/cutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxlog", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include", - ] - include_dirs += [ "${THIRD_PARTY}/libunwind/include" ] if (is_mingw || is_mac) { include_dirs += [ "${THIRD_PARTY}/libbpf/include/uapi" ] } - if (is_mingw) { - cflags = [ "-includeMingW64Fix.h" ] - } } ohos_static_library("hiperf_parser") { @@ -102,9 +84,9 @@ ohos_static_library("hiperf_parser") { "../../filter/perf_filter:hiperf_filter_cfg", ] public_deps = [ - "${PERF_DIR}/hiperf:hiperf_platform_common", + "${PERF_DIR}/hiperf:hiperf_src", "${THIRD_PARTY}/protobuf:protobuf_lite_static", "${THIRD_PARTY}/protobuf:protobuf_static", - "//third_party/perf_include/hiviewdfx:hiviewdfx", + "//third_party/perf_include/hiviewdfx:libfaultloggerd", ] } diff --git a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp index 2489c601e46c0d75bfaaca3464a40c70db711965..b7b515d38c418323d127ee1a7ae691685e66bbcd 100644 --- a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp +++ b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp @@ -16,7 +16,10 @@ #include "clock_filter_ex.h" #include "file.h" #include "perf_data_filter.h" +#include "perf_file_format.h" #include "stat_filter.h" +#include "utilities.h" +#include namespace SysTuning { namespace TraceStreamer { @@ -66,7 +69,7 @@ uint64_t PerfDataParser::DataProcessingLength(const std::deque &dequeBu &PerfDataParser::SplitPerfWaitForFinish}; if (static_cast(splitState_) >= splitFunc.size()) { - TS_LOGE("Invalid split state %d", splitState_); + TS_LOGE("Invalid split state %d", static_cast(splitState_)); perfSplitError_ = true; SplitDataWithdraw(); return size; @@ -407,25 +410,79 @@ PerfDataParser::~PerfDataParser() static_cast(GetPluginEndTime())); } -bool PerfDataParser::PerfReloadSymbolFiles(std::vector &symbolsPaths) +std::tuple PerfDataParser::GetFileIdWithLikelyFilePath(const std::string &inputFilePath) { - if (access(tmpPerfData_.c_str(), F_OK) != 0) { - TS_LOGE("perf file:%s not exist", tmpPerfData_.c_str()); - return false; + auto perfFilesData = traceDataCache_->GetConstPerfFilesData(); + for (auto row = 0; row < perfFilesData.Size(); row++) { + auto filePath = traceDataCache_->GetDataFromDict(perfFilesData.FilePaths()[row]); + if (EndsWith(filePath, inputFilePath)) { + return std::make_tuple(perfFilesData.FileIds()[row], perfFilesData.FilePaths()[row]); + } } - recordDataReader_ = PerfFileReader::Instance(tmpPerfData_); - report_ = std::make_unique(); - report_->virtualRuntime_.SetSymbolsPaths(symbolsPaths); - if (recordDataReader_ == nullptr) { + return std::make_tuple(INVALID_UINT64, INVALID_DATAINDEX); +} + +bool PerfDataParser::ReloadPerfFile(const std::unique_ptr &symbolsFile, + uint64_t &fileId, + DataIndex &filePathIndex) +{ + std::tie(fileId, filePathIndex) = GetFileIdWithLikelyFilePath(symbolsFile->filePath_); + if (fileId == INVALID_UINT64) { return false; } - if (Reload()) { - Finish(); - return true; - } else { + // clean perf file same fileId data + if (!traceDataCache_->GetPerfFilesData()->EraseFileIdSameData(fileId)) { return false; } + // add new symbol Data to PerfFile table + for (auto dfxSymbol : symbolsFile->GetSymbols()) { + auto symbolNameIndex = traceDataCache_->GetDataIndex(dfxSymbol.GetName()); + traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileId, dfxSymbol.index_, symbolNameIndex, + filePathIndex); + } + return true; } + +void PerfDataParser::ReloadPerfCallChain(const std::unique_ptr &symbolsFile, + uint64_t fileId, + DataIndex filePathIndex) +{ + // Associate perf_callchain with perf_file + auto perfCallChainData = traceDataCache_->GetPerfCallChainData(); + + for (auto row = 0; row < perfCallChainData->Size(); row++) { + if (perfCallChainData->FileIds()[row] == fileId) { + // Get the current call stack's pid and tid + if (!callChainIdToThreadInfo_.count(perfCallChainData->CallChainIds()[row])) { + continue; + } + pid_t pid; + pid_t tid; + std::tie(pid, tid) = callChainIdToThreadInfo_.at(perfCallChainData->CallChainIds()[row]); + // Get VirtualThread object + auto &virtualThread = report_->virtualRuntime_.GetThread(pid, tid); + // Get dfxMap object + auto dfxMap = virtualThread.FindMapByAddr(perfCallChainData->Ips()[row]); + auto vaddr = symbolsFile->GetVaddrInSymbols(perfCallChainData->Ips()[row], dfxMap->begin, dfxMap->offset); + auto dfxSymbol = symbolsFile->GetSymbolWithVaddr(vaddr); + auto nameIndex = traceDataCache_->GetDataIndex(dfxSymbol.GetName()); + perfCallChainData->UpdateSymbolRelatedData(row, dfxSymbol.funcVaddr_, dfxSymbol.index_, nameIndex); + } + } +} + +void PerfDataParser::PerfReloadSymbolFiles(const std::vector> &symbolsFiles) +{ + for (const auto &symbolsFile : symbolsFiles) { + uint64_t fileId; + DataIndex filePathIndex; + if (!ReloadPerfFile(symbolsFile, fileId, filePathIndex)) { + continue; + } + ReloadPerfCallChain(symbolsFile, fileId, filePathIndex); + } +} + bool PerfDataParser::LoadPerfData() { // try load the perf data @@ -464,6 +521,7 @@ bool PerfDataParser::Reload() UpdateEventConfigInfo(); UpdateReportWorkloadInfo(); UpdateCmdlineInfo(); + SetHM(); // update perf Files table UpdateSymbolAndFilesData(); @@ -622,6 +680,7 @@ uint32_t PerfDataParser::UpdateCallChainUnCompressed(const std::unique_ptrdata_.tid)}); uint32_t depth = 0; for (auto frame = sample->callFrames_.rbegin(); frame != sample->callFrames_.rend(); ++frame) { uint64_t fileId = INVALID_UINT64; @@ -673,5 +732,22 @@ void PerfDataParser::Finish() } pidAndStackHashToCallChainId_.Clear(); } + +void PerfDataParser::SetHM() +{ + std::string os = recordDataReader_->GetFeatureString(FEATURE::OSRELEASE); + auto isHM = os.find(HMKERNEL) != std::string::npos; + isHM = isHM || os.find("hmkernel") != std::string::npos; + isHM = isHM || os.find("HongMeng") != std::string::npos; + report_->virtualRuntime_.SetHM(isHM); + if (isHM) { + pid_t devhost = -1; + std::string str = recordDataReader_->GetFeatureString(FEATURE::HIPERF_HM_DEVHOST); + if (str != EMPTY_STRING) { + devhost = std::stoi(str); + } + report_->virtualRuntime_.SetDevhostPid(devhost); + } +} } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h index cc422f27fc9bfb65b8756c1e206d0ae172377f55..5b6c28e63e683ccae13c7c03423b0aa6e8d6f982 100644 --- a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h +++ b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h @@ -58,7 +58,7 @@ public: bool isSplitFile, bool isFinish); void Finish(); - bool PerfReloadSymbolFiles(std::vector &symbolsPaths); + void PerfReloadSymbolFiles(const std::vector> &symbolsFiles); const auto &GetPerfSplitResult() { return splitResult_; @@ -91,6 +91,7 @@ public: } private: + void SetHM(); bool Reload(); bool LoadPerfData(); void UpdateEventConfigInfo(); @@ -101,13 +102,15 @@ private: void UpdateClockType(); bool RecordCallBack(std::unique_ptr record); void UpdatePerfSampleData(uint32_t callChainId, std::unique_ptr &sample); + std::tuple GetFileIdWithLikelyFilePath(const std::string &inputFilePath); + bool ReloadPerfFile(const std::unique_ptr &symbolsFile, uint64_t &fileId, DataIndex &filePathIndex); + void ReloadPerfCallChain(const std::unique_ptr &symbolsFile, uint64_t fileId, DataIndex filePathIndex); uint32_t UpdateCallChainUnCompressed(const std::unique_ptr &sample); SplitPerfState DataLengthProcessing(const std::deque &dequeBuffer, perf_event_header &dataHeader, uint64_t size, uint64_t &processedLen, bool &invalid); - bool PerfSplitCallBack(std::unique_ptr record); uint64_t SplitPerfData(const std::deque &dequeBuffer, uint64_t size, uint64_t offset, bool isFinish); uint64_t DataProcessingLength(const std::deque &dequeBuffer, @@ -175,6 +178,7 @@ private: std::map fileDataDictIdToFileId_ = {}; std::hash hashFun_; DoubleMap pidAndStackHashToCallChainId_; + std::unordered_map> callChainIdToThreadInfo_ = {}; const std::string tmpPerfData_ = "ts_tmp.perf.data"; const std::string cpuOffEventName_ = "sched:sched_switch"; const std::string wakingEventName_ = "sched:sched_waking"; diff --git a/trace_streamer/src/parser/pbreader_parser/BUILD.gn b/trace_streamer/src/parser/pbreader_parser/BUILD.gn index 1752d2d939b1e2ffb9fa5f7b1d929d44404ddb2a..cad38ce9f63531443c2893b4bb01843b4cbb0bdc 100644 --- a/trace_streamer/src/parser/pbreader_parser/BUILD.gn +++ b/trace_streamer/src/parser/pbreader_parser/BUILD.gn @@ -74,9 +74,6 @@ ohos_source_set("pbreader_parser_src") { cflags += [ "-D IS_UT" ] } } - if (is_mingw) { - cflags = [ "-includeMingW64Fix.h" ] - } public_configs = [ "../ebpf_parser:ebpf_parser_cfg" ] public_deps = [ "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/services:ts_all_type_cpp" ] @@ -127,17 +124,6 @@ ohos_source_set("pbreader_parser_src") { "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/services:ts_all_type_cpp_standard", "${THIRD_PARTY}/protobuf:protobuf_lite_static", "${THIRD_PARTY}/protobuf:protobuf_static", - "//third_party/perf_include/hiviewdfx:hiviewdfx", + "//third_party/perf_include/hiviewdfx:libfaultloggerd", ] - if (!use_wasm && !is_win && !is_mingw && !is_mac && !is_test) { - if (!is_independent_compile) { - if (target_cpu == "arm64") { - public_deps += [ "//third_party/libunwind:unwind_source_arm64_opt" ] - } else { - public_deps += [ "//third_party/libunwind:unwind_source_${target_cpu}" ] - } - } else { - public_deps += [ "${THIRD_PARTY}/libunwind:libunwind" ] - } - } } diff --git a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp index 2ffb5fcc24ea3cee70f76b141f963c940ba8c112..ad373e46b85350b50a007884a0b5828f96a91a85 100644 --- a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp +++ b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp @@ -30,6 +30,7 @@ #include "ipi.pbreader.h" #include "irq_filter.h" #include "irq.pbreader.h" +#include "dma_fence.pbreader.h" #include "measure_filter.h" #include "oom.pbreader.h" #include "power.pbreader.h" @@ -96,6 +97,14 @@ void HtraceEventParser::InterruptEventInitialization() std::bind(&HtraceEventParser::SoftIrqEntryEvent, this, std::placeholders::_1)); eventToFunctionMap_.emplace(TRACE_EVENT_SOFTIRQ_EXIT, std::bind(&HtraceEventParser::SoftIrqExitEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(TRACE_EVENT_DMA_FENCE_INIT, + std::bind(&HtraceEventParser::DmaFenceInitEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(TRACE_EVENT_DMA_FENCE_DESTROY, + std::bind(&HtraceEventParser::DmaFenceDestroyEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(TRACE_EVENT_DMA_FENCE_ENABLE, + std::bind(&HtraceEventParser::DmaFenceEnableEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(TRACE_EVENT_DMA_FENCE_SIGNALED, + std::bind(&HtraceEventParser::DmaFenceSignaledEvent, this, std::placeholders::_1)); } void HtraceEventParser::ClockEventInitialization() @@ -323,6 +332,17 @@ bool HtraceEventParser::InterruptEventSet(const ProtoReader::FtraceEvent_Reader judgment = BytesViewEventInfo(bytesView, event.softirq_exit_format(), eventInfo, TRACE_EVENT_SOFTIRQ_EXIT); } else if (event.has_softirq_entry_format()) { judgment = BytesViewEventInfo(bytesView, event.softirq_entry_format(), eventInfo, TRACE_EVENT_SOFTIRQ_ENTRY); + } else if (event.has_dma_fence_init_format()) { + judgment = BytesViewEventInfo(bytesView, event.dma_fence_init_format(), eventInfo, TRACE_EVENT_DMA_FENCE_INIT); + } else if (event.has_dma_fence_destroy_format()) { + judgment = + BytesViewEventInfo(bytesView, event.dma_fence_destroy_format(), eventInfo, TRACE_EVENT_DMA_FENCE_DESTROY); + } else if (event.has_dma_fence_enable_signal_format()) { + judgment = BytesViewEventInfo(bytesView, event.dma_fence_enable_signal_format(), eventInfo, + TRACE_EVENT_DMA_FENCE_ENABLE); + } else if (event.has_dma_fence_signaled_format()) { + judgment = + BytesViewEventInfo(bytesView, event.dma_fence_signaled_format(), eventInfo, TRACE_EVENT_DMA_FENCE_SIGNALED); } return judgment; @@ -887,6 +907,62 @@ bool HtraceEventParser::SoftIrqExitEvent(const EventInfo &event) const streamFilters_->irqFilter_->SoftIrqExit(event.timeStamp, event.cpu, static_cast(msg.vec())); return true; } +bool HtraceEventParser::DmaFenceInitEvent(const EventInfo &event) const +{ + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_INIT, STAT_EVENT_RECEIVED); + ProtoReader::DmaFenceInitFormat_Reader msg(event.detail); + DmaFenceRow dmaFenceRow = {event.timeStamp, + 0, + dmaFenceInitName_, + traceDataCache_->GetDataIndex(msg.driver().ToStdString()), + traceDataCache_->GetDataIndex(msg.timeline().ToStdString()), + static_cast(msg.context()), + static_cast(msg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool HtraceEventParser::DmaFenceDestroyEvent(const EventInfo &event) const +{ + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_DESTROY, STAT_EVENT_RECEIVED); + ProtoReader::DmaFenceDestroyFormat_Reader msg(event.detail); + DmaFenceRow dmaFenceRow = {event.timeStamp, + 0, + dmaFenceDestroyName_, + traceDataCache_->GetDataIndex(msg.driver().ToStdString()), + traceDataCache_->GetDataIndex(msg.timeline().ToStdString()), + static_cast(msg.context()), + static_cast(msg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool HtraceEventParser::DmaFenceEnableEvent(const EventInfo &event) const +{ + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_ENABLE, STAT_EVENT_RECEIVED); + ProtoReader::DmaFenceEnableSignalFormat_Reader msg(event.detail); + DmaFenceRow dmaFenceRow = {event.timeStamp, + 0, + dmaFenceEnableName_, + traceDataCache_->GetDataIndex(msg.driver().ToStdString()), + traceDataCache_->GetDataIndex(msg.timeline().ToStdString()), + static_cast(msg.context()), + static_cast(msg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool HtraceEventParser::DmaFenceSignaledEvent(const EventInfo &event) const +{ + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_SIGNALED, STAT_EVENT_RECEIVED); + ProtoReader::DmaFenceSignaledFormat_Reader msg(event.detail); + DmaFenceRow dmaFenceRow = {event.timeStamp, + 0, + dmaFenceSignaledName_, + traceDataCache_->GetDataIndex(msg.driver().ToStdString()), + traceDataCache_->GetDataIndex(msg.timeline().ToStdString()), + static_cast(msg.context()), + static_cast(msg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} bool HtraceEventParser::SysEnterEvent(const EventInfo &event) const { streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SYS_ENTRY, STAT_EVENT_RECEIVED); @@ -908,7 +984,8 @@ bool HtraceEventParser::OomScoreAdjUpdate(const EventInfo &event) const { streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE, STAT_EVENT_RECEIVED); ProtoReader::OomScoreAdjUpdateFormat_Reader msg(event.detail); - streamFilters_->processMeasureFilter_->AppendNewMeasureData(msg.pid(), oomScoreAdjName_, event.timeStamp, + auto ipid = streamFilters_->processFilter_->GetInternalPid(msg.pid()); + streamFilters_->processMeasureFilter_->AppendNewMeasureData(ipid, oomScoreAdjName_, event.timeStamp, msg.oom_score_adj()); return true; } diff --git a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.h b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.h index fee2ec4fc02b7266d9e06a5031627d259927c3c3..6a16997e30579764dac8367c454b7d5fa9380320 100644 --- a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.h +++ b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.h @@ -140,6 +140,10 @@ private: bool SoftIrqEntryEvent(const EventInfo &event) const; bool SoftIrqRaiseEvent(const EventInfo &event) const; bool SoftIrqExitEvent(const EventInfo &event) const; + bool DmaFenceInitEvent(const EventInfo &event) const; + bool DmaFenceDestroyEvent(const EventInfo &event) const; + bool DmaFenceEnableEvent(const EventInfo &event) const; + bool DmaFenceSignaledEvent(const EventInfo &event) const; bool SysEnterEvent(const EventInfo &event) const; bool SysExitEvent(const EventInfo &event) const; bool OomScoreAdjUpdate(const EventInfo &event) const; @@ -163,6 +167,10 @@ private: const DataIndex sysEnterName_ = traceDataCache_->GetDataIndex("sys_enter"); const DataIndex sysExitName_ = traceDataCache_->GetDataIndex("sys_exit"); const DataIndex oomScoreAdjName_ = traceDataCache_->GetDataIndex("oom_score_adj"); + const DataIndex dmaFenceInitName_ = traceDataCache_->GetDataIndex("dma_fence_init"); + const DataIndex dmaFenceDestroyName_ = traceDataCache_->GetDataIndex("dma_fence_destroy"); + const DataIndex dmaFenceEnableName_ = traceDataCache_->GetDataIndex("dma_fence_enable_signal"); + const DataIndex dmaFenceSignaledName_ = traceDataCache_->GetDataIndex("dma_fence_signaled"); TraceStreamerConfig config_{}; std::atomic clock_{TS_CLOCK_BOOTTIME}; std::mutex mutex_; diff --git a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/BUILD.gn b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/BUILD.gn index a9f2279d04e848ec55db4166e4eb9e4e6cc81707..0e512554ee67919c4aa2db6b03d895b69b2f611a 100644 --- a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/BUILD.gn +++ b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/BUILD.gn @@ -29,7 +29,7 @@ ohos_static_library("native_hook_parser") { "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/services:ts_all_type_cpp", "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/types/plugins/ftrace_data/${device_kernel_version}:ftrace_data_reader", "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/types/plugins/native_hook:native_hook_data_reader", - "${PERF_DIR}/hiperf:hiperf_platform_common", + "${PERF_DIR}/hiperf:hiperf_src", ] public_configs = [ ":native_hook_parser_cfg", diff --git a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h index c7fe533aacc5a55f19213dd219d89192a1fbd6d4..e13a90e41e310a740dbdd25438b6200c5e6b34d9 100644 --- a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h +++ b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h @@ -36,9 +36,9 @@ public: void FinishSplitNativeHook(); void FinishParseNativeHookData(); void Finish(); - bool NativeHookReloadElfSymbolTable(const std::vector> &symbolsFile) + void NativeHookReloadElfSymbolTable(const std::vector> &symbolsFile) { - return nativeHookFilter_->NativeHookReloadElfSymbolTable(symbolsFile); + nativeHookFilter_->NativeHookReloadElfSymbolTable(symbolsFile); } void UpdataOfflineSymbolizationMode(bool isOfflineSymbolizationMode) { diff --git a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp index 6f742dfe4858b075c809548593cc82a3d2bd966c..f7badb159a883f68a1a965122c539784fd6d3b4c 100644 --- a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp +++ b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp @@ -196,18 +196,16 @@ PbreaderParser::~PbreaderParser() bool PbreaderParser::ReparseSymbolFilesAndResymbolization(std::string &symbolsPath, std::vector &symbolsPaths) { - std::vector dirs; auto parseStatus = false; - for (auto file : symbolsPaths) { - auto dir = file.substr(0, file.find_last_of("/\\")); - dirs.emplace_back(dir); - } -#ifdef ENABLE_HIPERF - parseStatus = perfDataParser_->PerfReloadSymbolFiles(dirs); -#endif #if defined(ENABLE_HIPERF) || defined(ENABLE_NATIVE_HOOK) || defined(ENABLE_EBPF) ParserFileSO(symbolsPath, symbolsPaths); #endif +#ifdef ENABLE_HIPERF + if (traceDataCache_->GetPerfFilesData()->Size() > 0) { + perfDataParser_->PerfReloadSymbolFiles(symbolsFiles_); + parseStatus = true; + } +#endif #ifdef ENABLE_NATIVE_HOOK if (traceDataCache_->GetNativeHookFrameData()->Size() > 0) { pbreaderNativeHookParser_->NativeHookReloadElfSymbolTable(symbolsFiles_); @@ -302,6 +300,9 @@ void PbreaderParser::WaitForParserEnd() hasGotHeader_ = false; WaitForHPluginParserEnd(); WaitForOtherPluginParserEnd(); +#if defined(ENABLE_HTRACE) && defined(ENABLE_NATIVE_HOOK) && defined(ENABLE_HIPERF) + ParseNapiAsync(); +#endif traceDataCache_->GetDataSourceClockIdData()->Finish(); dataSegArray_.reset(); processedDataLen_ = 0; @@ -1135,5 +1136,148 @@ bool PbreaderParser::InitProfilerTraceFileHeader() pbreaderClockDetailParser_->Parse(pHeader); return true; } + +#if defined(ENABLE_HTRACE) && defined(ENABLE_NATIVE_HOOK) && defined(ENABLE_HIPERF) +void PbreaderParser::ParseNapiAsync() +{ + // 将native memory中存在的traceid取出, 并记录其对应的callstackid + std::unordered_map traceidToCallchainidMap; + GetTraceidInfoFromNativeHook(traceidToCallchainidMap); + + // 从callstack表中获取所有的traceid, 根据其所属的itid将SliceInfo存入对应queue + std::unordered_map> itidToCallstackIdsMap; + GetTraceidInfoFromCallstack(traceidToCallchainidMap, itidToCallstackIdsMap); + + // 筛选出包含NativeAsyncWork::AsyncWorkCallback的函数栈的callchainid, 将其存入callchainIdSet + std::unordered_set callchainIdSet; + GetCallchainIdSetFromHiperf(callchainIdSet); + + DumpDataFromHiperf(traceidToCallchainidMap, callchainIdSet, itidToCallstackIdsMap); +} + +void PbreaderParser::GetTraceidInfoFromNativeHook(std::unordered_map &traceidToCallchainidMap) +{ + auto nativeHook = traceDataCache_->GetConstNativeHookData(); + std::string preWord("napi:"); + for (int i = 0; i < nativeHook.Size(); i++) { + auto subType = nativeHook.SubTypes()[i]; + if (subType == INVALID_UINT64) { + continue; + } + auto subTypeStr = traceDataCache_->GetDataFromDict(subType); + if (!StartWith(subTypeStr, preWord)) { + continue; + } + auto pos = subTypeStr.find(preWord) + preWord.size(); + auto traceidStr = subTypeStr.substr(pos, subTypeStr.find_last_of(':') - pos); + auto traceidIndex = traceDataCache_->GetDataIndex(traceidStr); + traceidToCallchainidMap.emplace(std::move(traceidStr), nativeHook.CallChainIds()[i]); + } +} + +void PbreaderParser::GetTraceidInfoFromCallstack( + const std::unordered_map &traceidToCallchainidMap, + std::unordered_map> &itidToCallstackIdsMap) +{ + auto callStack = traceDataCache_->GetConstInternalSlicesData(); + std::string preWord("traceid:"); + std::string invalidTraceidStr("0x0"); + for (int i = 0; i < callStack.Size(); i++) { + auto name = traceDataCache_->GetDataFromDict(callStack.NamesData()[i]); + if (!StartWith(name, "H:Napi execute, name:") || callStack.DursData()[i] == INVALID_UINT64) { + continue; + } + auto traceidStr = name.substr(name.find(preWord) + preWord.size()); + if (traceidStr == invalidTraceidStr) { + continue; + } + if (traceidToCallchainidMap.find(traceidStr) == traceidToCallchainidMap.end()) { + continue; + } + auto iter = itidToCallstackIdsMap.find(callStack.CallIds()[i]); + if (iter == itidToCallstackIdsMap.end()) { + itidToCallstackIdsMap.emplace(callStack.CallIds()[i], std::queue()); + iter = itidToCallstackIdsMap.find(callStack.CallIds()[i]); + } + iter->second.emplace(callStack.TimeStampData()[i], callStack.TimeStampData()[i] + callStack.DursData()[i], + traceidStr); + } +} + +void PbreaderParser::GetCallchainIdSetFromHiperf(std::unordered_set &callchainIdSet) +{ + auto perfCallChain = traceDataCache_->GetConstPerfCallChainData(); + std::string asyncWork("NativeAsyncWork::AsyncWorkCallback"); + for (int i = 0; i < perfCallChain.Size(); i++) { + auto callchainId = perfCallChain.CallChainIds()[i]; + if (callchainIdSet.find(callchainId) != callchainIdSet.end()) { + continue; + } + auto nameIndex = perfCallChain.Names()[i]; + if (nameIndex == INVALID_UINT64) { + continue; + } + auto name = traceDataCache_->GetDataFromDict(nameIndex); + if (name.find(asyncWork) != std::string::npos) { + callchainIdSet.emplace(perfCallChain.CallChainIds()[i]); + } + } +} + +void PbreaderParser::DumpDataFromHiperf(const std::unordered_map &traceidToCallchainidMap, + const std::unordered_set &callchainIdSet, + std::unordered_map> &itidToCallstackIdsMap) +{ + auto perfThread = traceDataCache_->GetConstPerfThreadData(); + std::unordered_map tidToPidMap; + for (size_t i = 0; i < perfThread.Size(); i++) { + tidToPidMap.emplace(perfThread.Tids()[i], perfThread.Pids()[i]); + } + auto perfSample = traceDataCache_->GetConstPerfSampleData(); + auto callStack = traceDataCache_->GetConstInternalSlicesData(); + for (size_t i = 0; i < perfSample.Size(); i++) { + // callchainid未命中, 即当前栈不包含NativeAsyncWork::AsyncWorkCallback + if (callchainIdSet.find(perfSample.SampleIds()[i]) == callchainIdSet.end()) { + continue; + } + // 根据tid和tsPerfSample查询对应的SliceInfo + auto itid = streamFilters_->processFilter_->GetInternalTid(perfSample.Tids()[i]); + if (itidToCallstackIdsMap.find(itid) == itidToCallstackIdsMap.end()) { + continue; + } + auto tsPerfSample = perfSample.TimestampTraces()[i]; + auto queue = itidToCallstackIdsMap.at(itid); + while (!queue.empty() && queue.front().tsEnd_ < tsPerfSample) { + queue.pop(); + } + if (queue.empty() || tsPerfSample < queue.front().tsBegin_) { + continue; + } + // 根据traceid查询native侧的callchainid + auto iterNative = traceidToCallchainidMap.find(queue.front().traceid_); + if (iterNative == traceidToCallchainidMap.end()) { + continue; + } + // 根据tid查询pid + auto iterPid = tidToPidMap.find(perfSample.Tids()[i]); + if (iterPid == tidToPidMap.end()) { + continue; + } + PerfNapiAsyncRow perfNapiAsyncRow{ + .timeStamp = tsPerfSample, + .traceid = traceDataCache_->GetDataIndex(queue.front().traceid_), + .cpuId = static_cast(perfSample.CpuIds()[i]), + .threadId = perfSample.Tids()[i], + .processId = iterPid->second, + .callerCallchainid = iterNative->second, + .calleeCallchainid = perfSample.SampleIds()[i], + .perfSampleId = i, + .eventCount = perfSample.EventCounts()[i], + .eventTypeId = perfSample.EventTypeIds()[i], + }; + traceDataCache_->GetPerfNapiAsyncData()->AppendNewPerfNapiAsync(perfNapiAsyncRow); + } +} +#endif } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h index f1a3b8319f79307a97ead3cbb9a0566616dabc65..644ab7c131e2b35423b778b09027b62889069592 100644 --- a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h +++ b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h @@ -18,9 +18,12 @@ #include #include #include +#include #include #include #include +#include +#include #include "common_types.h" #include "common_types.pbreader.h" #include "clock_filter_ex.h" @@ -86,6 +89,15 @@ namespace SysTuning { namespace TraceStreamer { using namespace SysTuning::base; using namespace OHOS::Developtools::HiPerf; +#if defined(ENABLE_HTRACE) && defined(ENABLE_NATIVE_HOOK) && defined(ENABLE_HIPERF) +struct SliceInfo { + SliceInfo(uint64_t tsBegin, uint64_t tsEnd, const std::string &traceid) + : tsBegin_(tsBegin), tsEnd_(tsEnd), traceid_(traceid){}; + uint64_t tsBegin_ = INVALID_UINT64; + uint64_t tsEnd_ = INVALID_UINT64; + std::string traceid_; +}; +#endif class PbreaderParser : public ParserBase, public HtracePluginTimeParser { public: PbreaderParser(TraceDataCache *dataCache, const TraceStreamerFilters *filters); @@ -246,6 +258,16 @@ private: const ProtoReader::ProfilerPluginData_Reader &pluginDataZero, bool isSplitFile); bool SpliteDataBySegment(DataIndex pluginNameIndex, PbreaderDataSegment &dataSeg); +#if defined(ENABLE_HTRACE) && defined(ENABLE_NATIVE_HOOK) && defined(ENABLE_HIPERF) + void ParseNapiAsync(); + void GetTraceidInfoFromCallstack(const std::unordered_map &traceidToCallchainidMap, + std::unordered_map> &itidToCallstackIdsMap); + void GetTraceidInfoFromNativeHook(std::unordered_map &traceidToCallchainidMap); + void GetCallchainIdSetFromHiperf(std::unordered_set &callchainIdSet); + void DumpDataFromHiperf(const std::unordered_map &traceidToCallchainidMap, + const std::unordered_set &callchainIdSet, + std::unordered_map> &itidToCallstackIdsMap); +#endif ProfilerTraceFileHeader profilerTraceFileHeader_; uint32_t profilerDataType_ = ProfilerTraceFileHeader::UNKNOW_TYPE; uint64_t profilerDataLength_ = 0; diff --git a/trace_streamer/src/parser/print_event_parser.cpp b/trace_streamer/src/parser/print_event_parser.cpp index e28f533b44812a5dd1b8b60993a8cf7dcff40cfe..6b3f73f69c86bbc030722921cc5dcfc4ccaad164 100644 --- a/trace_streamer/src/parser/print_event_parser.cpp +++ b/trace_streamer/src/parser/print_event_parser.cpp @@ -32,6 +32,8 @@ PrintEventParser::PrintEventParser(TraceDataCache *dataCache, const TraceStreame std::placeholders::_3)}, {rsOnDoCompositionEvent_, bind(&PrintEventParser::RSReciveOnDoComposition, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)}, + {onVsyncEvent_, bind(&PrintEventParser::OnVsyncEvent, this, std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3)}, {marshRwTransactionData_, bind(&PrintEventParser::OnRwTransaction, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)}, {rsMainThreadProcessCmd_, bind(&PrintEventParser::OnMainThreadProcessCmd, this, std::placeholders::_1, @@ -196,7 +198,7 @@ void PrintEventParser::Finish() { eventToFrameFunctionMap_.clear(); frameCallIds_.clear(); - vsyncSliceIds_.clear(); + vsyncSliceMap_.clear(); streamFilters_->animationFilter_->Clear(); streamFilters_->frameFilter_->Clear(); } @@ -253,8 +255,18 @@ ParseResult PrintEventParser::HandlerB(std::string_view pointStr, TracePoint &ou TS_LOGD("point name is empty!"); return PARSE_ERROR; } - // Use ## to differentiate distributed data - if (outPoint.name_.find("##") == std::string::npos) { + // Distributed data: + // <...>-357 (-------) .... 174330.287420: tracing_mark_write: + // B|1298|H:[8b00e96b2,2,1]#C##napi::NativeAsyncWork::QueueWithQos + std::smatch matcheLine; + bool matched = std::regex_match(outPoint.name_, matcheLine, distributeMatcher_); + if (matched) { + size_t index = 0; + outPoint.chainId_ = matcheLine[++index].str(); + outPoint.spanId_ = matcheLine[++index].str(); + outPoint.parentSpanId_ = matcheLine[++index].str(); + outPoint.flag_ = matcheLine[++index].str(); + } else { auto space = outPoint.name_.find(' '); if (space != std::string::npos) { outPoint.funcPrefix_ = outPoint.name_.substr(0, space); @@ -263,20 +275,6 @@ ParseResult PrintEventParser::HandlerB(std::string_view pointStr, TracePoint &ou } else { outPoint.funcPrefixId_ = traceDataCache_->GetDataIndex(outPoint.name_); } - return PARSE_SUCCESS; - } - // Resolve distributed calls - // the normal data mybe like: - // system-1298 ( 1298) [001] ...1 174330.287420: tracing_mark_write: B|1298|H:[8b00e96b2,2,1]#C##decodeFrame" - const std::regex distributeMatcher = std::regex(R"(H:\[([a-z0-9]+),([a-z0-9]+),([a-z0-9]+)\]#([CS]?)##(.*))"); - std::smatch matcheLine; - bool matched = std::regex_match(outPoint.name_, matcheLine, distributeMatcher); - if (matched) { - size_t index = 0; - outPoint.chainId_ = matcheLine[++index].str(); - outPoint.spanId_ = matcheLine[++index].str(); - outPoint.parentSpanId_ = matcheLine[++index].str(); - outPoint.flag_ = matcheLine[++index].str(); } return PARSE_SUCCESS; } @@ -327,7 +325,26 @@ bool PrintEventParser::ReciveVsync(size_t callStackRow, std::string &args, const } } streamFilters_->frameFilter_->BeginVsyncEvent(line, now, expectEnd, vsyncId, callStackRow); - vsyncSliceIds_.push_back(callStackRow); + auto iTid = streamFilters_->processFilter_->GetInternalTid(line.pid); + if (vsyncSliceMap_.count(iTid)) { + vsyncSliceMap_[iTid].push_back(callStackRow); + } else { + vsyncSliceMap_[iTid] = {callStackRow}; + } + return true; +} +bool PrintEventParser::OnVsyncEvent(size_t callStackRow, std::string &args, const BytraceLine &line) +{ + Unused(args); + auto iTid = streamFilters_->processFilter_->GetInternalTid(line.pid); + if (!vsyncSliceMap_.count(iTid)) { + return false; + } + // when there are mutiple nested OnVsyncEvent,only handle the OnvsyncEvent of the next layer under ReceiveVsync + if (vsyncSliceMap_[iTid].size() >= maxVsyncEventSize_) { + return false; + } + vsyncSliceMap_[iTid].push_back(callStackRow); return true; } bool PrintEventParser::RSReciveOnDoComposition(size_t callStackRow, std::string &args, const BytraceLine &line) @@ -351,7 +368,7 @@ bool PrintEventParser::OnRwTransaction(size_t callStackRow, std::string &args, c } bool PrintEventParser::OnMainThreadProcessCmd(size_t callStackRow, std::string &args, const BytraceLine &line) { - std::sregex_iterator it(args.begin(), args.end(), mainProcessCmdPattern); + std::sregex_iterator it(args.begin(), args.end(), mainProcessCmdPattern_); std::sregex_iterator end; std::vector frames; while (it != end) { @@ -378,12 +395,14 @@ void PrintEventParser::HandleFrameSliceEndEvent(uint64_t ts, uint64_t pid, uint6 { // it can be frame or slice auto iTid = streamFilters_->processFilter_->GetInternalTid(tid); - auto pos = std::find(vsyncSliceIds_.begin(), vsyncSliceIds_.end(), callStackRow); - if (pos != vsyncSliceIds_.end()) { - if (!streamFilters_->frameFilter_->EndVsyncEvent(ts, iTid)) { - streamFilters_->statFilter_->IncreaseStat(TRACE_VSYNC, STAT_EVENT_NOTMATCH); + if (vsyncSliceMap_.count(iTid)) { + auto pos = std::find(vsyncSliceMap_[iTid].begin(), vsyncSliceMap_[iTid].end(), callStackRow); + if (pos != vsyncSliceMap_[iTid].end()) { + if (!streamFilters_->frameFilter_->EndVsyncEvent(ts, iTid)) { + streamFilters_->statFilter_->IncreaseStat(TRACE_VSYNC, STAT_EVENT_NOTMATCH); + } + vsyncSliceMap_[iTid].erase(pos); } - vsyncSliceIds_.erase(pos); } return; } diff --git a/trace_streamer/src/parser/print_event_parser.h b/trace_streamer/src/parser/print_event_parser.h index 2bd70edb643204bfcd21795a8d08f165d3c10dc0..6b26d035a2c95b7611864302666c7338d9ea418c 100644 --- a/trace_streamer/src/parser/print_event_parser.h +++ b/trace_streamer/src/parser/print_event_parser.h @@ -79,11 +79,13 @@ private: bool OnRwTransaction(size_t callStackRow, std::string &args, const BytraceLine &line); bool OnMainThreadProcessCmd(size_t callStackRow, std::string &args, const BytraceLine &line); bool OnFrameQueueStart(uint64_t ts, size_t callStackRow, uint64_t pid); + bool OnVsyncEvent(size_t callStackRow, std::string &args, const BytraceLine &line); private: std::map eventToFrameFunctionMap_ = {}; TraceStreamerConfig config_{}; const DataIndex recvievVsync_ = traceDataCache_->GetDataIndex("H:ReceiveVsync"); + const DataIndex onVsyncEvent_ = traceDataCache_->GetDataIndex("H:OnVsyncEvent"); const std::string rsOnDoCompositionStr_ = "H:RSMainThread::DoComposition"; DataIndex rsOnDoCompositionEvent_ = INVALID_DATAINDEX; const std::string onFrameQueeuStartEvent_ = "H:M: Frame queued"; @@ -92,11 +94,13 @@ private: const DataIndex rsMainThreadProcessCmd_ = traceDataCache_->GetDataIndex("H:RSMainThread::ProcessCommandUni"); const std::regex recvVsyncPattern_ = std::regex("(\\w+):(\\w+)"); const std::regex transFlagPattern_ = std::regex("transactionFlag:\\[(\\d+),(\\d+)\\]"); - const std::regex mainProcessCmdPattern = std::regex("\\[(\\d+),(\\d+)\\]"); + const std::regex mainProcessCmdPattern_ = std::regex("\\[(\\d+),(\\d+)\\]"); + const std::regex distributeMatcher_ = std::regex(R"(H:\[([a-z0-9]+),([a-z0-9]+),([a-z0-9]+)\]#([CS]?)##(.*))"); std::vector frameCallIds_ = {}; - std::vector vsyncSliceIds_ = {}; + std::unordered_map> vsyncSliceMap_ = {}; TraceFileType traceType_ = TRACE_FILETYPE_H_TRACE; BuiltinClocks clock_ = TS_CLOCK_BOOTTIME; + const uint32_t maxVsyncEventSize_ = 2; // if convert vsync's now and expectEnd bool convertVsyncTs_ = true; }; diff --git a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp index c66641bcdcdfdc493bede5d899e0cf90a465ed65..1557e9fdeba99ab63baac1012ddb55d0c58cc0f9 100644 --- a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp +++ b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp @@ -98,6 +98,18 @@ void BytraceEventParser::InterruptEventInitialization() eventToFunctionMap_.emplace( config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT), bind(&BytraceEventParser::SoftIrqExitEvent, this, std::placeholders::_1, std::placeholders::_2)); + eventToFunctionMap_.emplace( + config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT), + bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2)); + eventToFunctionMap_.emplace( + config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY), + bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2)); + eventToFunctionMap_.emplace( + config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE), + bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2)); + eventToFunctionMap_.emplace( + config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED), + bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2)); } void BytraceEventParser::ClockEventInitialization() @@ -642,7 +654,28 @@ bool BytraceEventParser::SoftIrqExitEvent(const ArgsMap &args, const BytraceLine streamFilters_->irqFilter_->SoftIrqExit(line.ts, line.cpu, vec.value()); return true; } - +bool BytraceEventParser::DmaFenceEvent(const ArgsMap &args, const BytraceLine &line) const +{ + if (args.empty() || args.size() < MIN_DMA_FENCE_ARGS_COUNT) { + TS_LOGD("Failed to dma fence event,no args or args size <4"); + streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_DMA_FENCE, STAT_EVENT_DATA_INVALID); + return false; + } + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE, STAT_EVENT_RECEIVED); + auto driverStr = std::string_view(args.at("driver")); + auto timelineStr = std::string_view(args.at("timeline")); + auto context = base::StrToInt(args.at("context")); + auto seqno = base::StrToInt(args.at("seqno")); + DmaFenceRow dmaFenceRow = {line.ts, + 0, + traceDataCache_->GetDataIndex(line.eventName), + traceDataCache_->GetDataIndex(driverStr), + traceDataCache_->GetDataIndex(timelineStr), + context.value(), + seqno.value()}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} bool BytraceEventParser::BinderTransaction(const ArgsMap &args, const BytraceLine &line) const { if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_ARGS_COUNT) { diff --git a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.h b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.h index a037d5d54affe60adc3fa3bec1c3c7546c779b1b..9021d221f7c519283dfb7eef5c935bf5fd02ed2d 100644 --- a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.h +++ b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.h @@ -74,6 +74,7 @@ private: bool SoftIrqRaiseEvent(const ArgsMap &args, const BytraceLine &line) const; bool SoftIrqEntryEvent(const ArgsMap &args, const BytraceLine &line) const; bool SoftIrqExitEvent(const ArgsMap &args, const BytraceLine &line) const; + bool DmaFenceEvent(const ArgsMap &args, const BytraceLine &line) const; bool BinderTransaction(const ArgsMap &args, const BytraceLine &line) const; bool BinderTransactionReceived(const ArgsMap &args, const BytraceLine &line) const; bool BinderTransactionAllocBufEvent(const ArgsMap &args, const BytraceLine &line) const; @@ -101,6 +102,7 @@ private: const uint32_t MIN_IRQ_HANDLER_EXIT_ARGS_COUNT = 2; const uint32_t MIN_SOFTIRQ_ENTRY_ARGS_COUNT = 2; const uint32_t MIN_SOFTIRQ_EXIT_ARGS_COUNT = 2; + const uint32_t MIN_DMA_FENCE_ARGS_COUNT = 4; const uint32_t MIN_BINDER_TRANSACTION_ARGS_COUNT = 7; const uint32_t MIN_BINDER_TRANSACTION_RECEIVED_ARGS_COUNT = 1; const uint32_t MIN_BINDER_TRANSACTION_ALLOC_BUF_ARGS_COUNT = 3; diff --git a/trace_streamer/src/parser/rawtrace_parser/BUILD.gn b/trace_streamer/src/parser/rawtrace_parser/BUILD.gn index 35e990dd62096c4f48c79a0d6e76000797fb6f0b..80680752922b0775b799e0388d0f8d948280c6a6 100755 --- a/trace_streamer/src/parser/rawtrace_parser/BUILD.gn +++ b/trace_streamer/src/parser/rawtrace_parser/BUILD.gn @@ -28,11 +28,8 @@ config("rawtrace_parser_comm") { "${THIRD_PARTY}/sqlite/include", "${THIRD_PARTY}/bounds_checking_function/include", "${THIRD_PARTY}/json/single_include/nlohmann", - "${PERF_DIR}/hiperf/include", - "${PERF_DIR}/hiperf/include/nonlinux/linux", - "${PERF_DIR}/hiperf/include/nonlinux", "${PERF_DIR}/profiler/device/plugins/ftrace_plugin/include", - "${COMMON_LIBRARY}/c_utils/base/include", + "${COMMON_LIBRARY}/base/include", ] include_dirs += [ "${SRC}/trace_data/trace_stdtype", @@ -78,9 +75,6 @@ ohos_static_library("rawtrace_parser") { if (!is_independent_compile) { configs = [ "${TS_DIR}/gn:ts_config" ] } - if (is_mingw) { - cflags = [ "-includeMingW64Fix.h" ] - } public_deps = [ "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/services:ts_all_type_cpp_standard", diff --git a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp index 998bed996ca75ec734cc1d5ec8d17ec01081d98f..9c0f3546a6b6521ca64f005bf94f26044c77b3ba 100644 --- a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp +++ b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp @@ -86,6 +86,14 @@ void CpuDetailParser::InterruptEventInitialization() std::bind(&CpuDetailParser::SoftIrqEntryEvent, this, std::placeholders::_1)); eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT), std::bind(&CpuDetailParser::SoftIrqExitEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT), + std::bind(&CpuDetailParser::DmaFenceInitEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY), + std::bind(&CpuDetailParser::DmaFenceDestroyEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE), + std::bind(&CpuDetailParser::DmaFenceEnableEvent, this, std::placeholders::_1)); + eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED), + std::bind(&CpuDetailParser::DmaFenceSignaledEvent, this, std::placeholders::_1)); } void CpuDetailParser::ClockEventInitialization() { @@ -594,6 +602,62 @@ bool CpuDetailParser::SoftIrqExitEvent(const RawTraceEventInfo &event) const static_cast(softIrqExitMsg.vec())); return true; } +bool CpuDetailParser::DmaFenceInitEvent(const RawTraceEventInfo &event) const +{ + auto dmaFenceInitMsg = event.msgPtr->dma_fence_init_format(); + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_INIT, STAT_EVENT_RECEIVED); + DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(), + 0, + dmaFenceInitIndex_, + traceDataCache_->GetDataIndex(dmaFenceInitMsg.driver()), + traceDataCache_->GetDataIndex(dmaFenceInitMsg.timeline()), + static_cast(dmaFenceInitMsg.context()), + static_cast(dmaFenceInitMsg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool CpuDetailParser::DmaFenceDestroyEvent(const RawTraceEventInfo &event) const +{ + auto dmaFenceDestroyMsg = event.msgPtr->dma_fence_destroy_format(); + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_DESTROY, STAT_EVENT_RECEIVED); + DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(), + 0, + dmaFenceDestroyIndex_, + traceDataCache_->GetDataIndex(dmaFenceDestroyMsg.driver()), + traceDataCache_->GetDataIndex(dmaFenceDestroyMsg.timeline()), + static_cast(dmaFenceDestroyMsg.context()), + static_cast(dmaFenceDestroyMsg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool CpuDetailParser::DmaFenceEnableEvent(const RawTraceEventInfo &event) const +{ + auto dmaFenceEnableMsg = event.msgPtr->dma_fence_enable_signal_format(); + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_ENABLE, STAT_EVENT_RECEIVED); + DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(), + 0, + dmaFenceEnableIndex_, + traceDataCache_->GetDataIndex(dmaFenceEnableMsg.driver()), + traceDataCache_->GetDataIndex(dmaFenceEnableMsg.timeline()), + static_cast(dmaFenceEnableMsg.context()), + static_cast(dmaFenceEnableMsg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} +bool CpuDetailParser::DmaFenceSignaledEvent(const RawTraceEventInfo &event) const +{ + auto dmaFenceSignaledMsg = event.msgPtr->dma_fence_signaled_format(); + traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE_SIGNALED, STAT_EVENT_RECEIVED); + DmaFenceRow dmaFenceRow = {event.msgPtr->timestamp(), + 0, + dmaFenceSignaledIndex_, + traceDataCache_->GetDataIndex(dmaFenceSignaledMsg.driver()), + traceDataCache_->GetDataIndex(dmaFenceSignaledMsg.timeline()), + static_cast(dmaFenceSignaledMsg.context()), + static_cast(dmaFenceSignaledMsg.seqno())}; + streamFilters_->sliceFilter_->DmaFence(dmaFenceRow); + return true; +} bool CpuDetailParser::SetRateEvent(const RawTraceEventInfo &event) const { auto clockSetRateMsg = event.msgPtr->clock_set_rate_format(); diff --git a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.h b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.h index 671b99a61432ac56d8a638e0c8c38abbe8910fba..c796826cd22e0c812dc10f00aae95cec0d7a6ca2 100644 --- a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.h +++ b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.h @@ -71,6 +71,10 @@ private: bool SoftIrqEntryEvent(const RawTraceEventInfo &event) const; bool SoftIrqRaiseEvent(const RawTraceEventInfo &event) const; bool SoftIrqExitEvent(const RawTraceEventInfo &event) const; + bool DmaFenceInitEvent(const RawTraceEventInfo &event) const; + bool DmaFenceDestroyEvent(const RawTraceEventInfo &event) const; + bool DmaFenceEnableEvent(const RawTraceEventInfo &event) const; + bool DmaFenceSignaledEvent(const RawTraceEventInfo &event) const; bool SetRateEvent(const RawTraceEventInfo &event) const; bool ClockEnableEvent(const RawTraceEventInfo &event) const; bool ClockDisableEvent(const RawTraceEventInfo &event) const; @@ -115,6 +119,10 @@ private: const DataIndex cpuFrequencyLimitMaxIndex_ = traceDataCache_->GetDataIndex("cpu_frequency_limits_max"); const DataIndex cpuFrequencyLimitMinIndex_ = traceDataCache_->GetDataIndex("cpu_frequency_limits_min"); const DataIndex workQueueIndex_ = traceDataCache_->GetDataIndex("workqueue"); + const DataIndex dmaFenceInitIndex_ = traceDataCache_->GetDataIndex("dma_fence_init"); + const DataIndex dmaFenceDestroyIndex_ = traceDataCache_->GetDataIndex("dma_fence_destroy"); + const DataIndex dmaFenceEnableIndex_ = traceDataCache_->GetDataIndex("dma_fence_enable_signal"); + const DataIndex dmaFenceSignaledIndex_ = traceDataCache_->GetDataIndex("dma_fence_signaled"); }; } // namespace TraceStreamer } // namespace SysTuning diff --git a/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.cpp b/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.cpp index 326586f3709fe42a159e2b16306220abdb7041f3..58e0c9c5f369da1d4eae8c94da061798c4d5b823 100644 --- a/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.cpp +++ b/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.cpp @@ -13,6 +13,9 @@ * limitations under the License. */ #include "ftrace_event_processor.h" +#include "rawtrace_parser/ftrace_field_processor.h" +#include +#include namespace SysTuning { namespace TraceStreamer { @@ -96,6 +99,21 @@ void FtraceEventProcessor::InterruptEventInitialization() eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT), std::bind(&FtraceEventProcessor::SoftirqExit, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); + eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT), + std::bind(&FtraceEventProcessor::DmaFenceInit, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); + + eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY), + std::bind(&FtraceEventProcessor::DmaFenceDestroy, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); + + eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE), + std::bind(&FtraceEventProcessor::DmaFenceEnable, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); + + eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED), + std::bind(&FtraceEventProcessor::DmaFenceSignaled, this, std::placeholders::_1, + std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); } void FtraceEventProcessor::ClockEventInitialization() { @@ -416,7 +434,17 @@ bool FtraceEventProcessor::TracingMarkWriteOrPrintFormat(FtraceEvent &ftraceEven if (format.eventId < HM_EVENT_ID_OFFSET) { printMsg->set_ip(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); } - printMsg->set_buf(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + // size大于60时为适配内核的event，小于则为原始的event + if (format.eventSize > 60) { + auto pid = FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size); + auto name = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size); + auto start = FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size); + auto msg = std::string(start == 0 ? "E" : "B") + std::string("|") + std::to_string(pid) + std::string("|") + + std::string(start == 0 ? "" : name); + printMsg->set_buf(msg); + } else { + printMsg->set_buf(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + } return true; } @@ -551,6 +579,59 @@ bool FtraceEventProcessor::SoftirqExit(FtraceEvent &ftraceEvent, uint8_t data[], softirqExitMsg->set_vec(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); return true; } +bool FtraceEventProcessor::DmaFenceInit(FtraceEvent &ftraceEvent, + uint8_t data[], + size_t size, + const EventFormat &format) +{ + uint8_t index = 0; + auto dmaFenceInitMsg = ftraceEvent.mutable_dma_fence_init_format(); + dmaFenceInitMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceInitMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceInitMsg->set_context(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + dmaFenceInitMsg->set_seqno(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + return true; +} +bool FtraceEventProcessor::DmaFenceDestroy(FtraceEvent &ftraceEvent, + uint8_t data[], + size_t size, + const EventFormat &format) +{ + uint8_t index = 0; + auto dmaFenceDestroyMsg = ftraceEvent.mutable_dma_fence_destroy_format(); + dmaFenceDestroyMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceDestroyMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceDestroyMsg->set_context(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + dmaFenceDestroyMsg->set_seqno(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + return true; +} +bool FtraceEventProcessor::DmaFenceEnable(FtraceEvent &ftraceEvent, + uint8_t data[], + size_t size, + const EventFormat &format) +{ + uint8_t index = 0; + auto dmaFenceEnableMsg = ftraceEvent.mutable_dma_fence_enable_signal_format(); + dmaFenceEnableMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceEnableMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceEnableMsg->set_context(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + dmaFenceEnableMsg->set_seqno(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + return true; +} +bool FtraceEventProcessor::DmaFenceSignaled(FtraceEvent &ftraceEvent, + uint8_t data[], + size_t size, + const EventFormat &format) +{ + uint8_t index = 0; + auto dmaFenceSignaledMsg = ftraceEvent.mutable_dma_fence_signaled_format(); + dmaFenceSignaledMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceSignaledMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size)); + dmaFenceSignaledMsg->set_context( + FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + dmaFenceSignaledMsg->set_seqno(FtraceFieldProcessor::HandleIntField(format.fields, index++, data, size)); + return true; +} bool FtraceEventProcessor::ClockSetRate(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, diff --git a/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.h b/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.h index 5b159d116b7c3ebf21c3a61aefb8a18aebd79b98..9d95feb7fa735aa956a549c820211814ea552e8b 100644 --- a/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.h +++ b/trace_streamer/src/parser/rawtrace_parser/ftrace_event_processor.h @@ -43,6 +43,10 @@ private: bool SoftirqRaise(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); bool SoftirqEntry(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); bool SoftirqExit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); + bool DmaFenceInit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); + bool DmaFenceDestroy(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); + bool DmaFenceEnable(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); + bool DmaFenceSignaled(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); bool SuspendResume(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); bool WorkqueueExecuteStart(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); bool WorkqueueExecuteEnd(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format); diff --git a/trace_streamer/src/rpc/ffrt_converter.cpp b/trace_streamer/src/rpc/ffrt_converter.cpp index c228338d6c9ef47e7897c8db79a277309a91b3bf..6da27f8a5e2c142a5a5a59f04bdb3e6cc3cd7d25 100644 --- a/trace_streamer/src/rpc/ffrt_converter.cpp +++ b/trace_streamer/src/rpc/ffrt_converter.cpp @@ -142,7 +142,8 @@ std::string FfrtConverter::ReplaceSchedSwitchLog(std::string &fakeLog, std::smatch match; auto taskId = GetTaskId(pid, gid); if (mark.find("prev_pid=" + std::to_string(tid)) != std::string::npos) { - if (regex_search(fakeLog, match, indexPattern_)) { + if (regex_search(fakeLog, match, indexPattern_) && fakeLog.find("prev_comm=") != std::string::npos && + fakeLog.find("prev_prio=") != std::string::npos) { auto beginPos = fakeLog.find(match.str()); (void)sprintf_s(result.get(), MAX_LEN, " %s-%s ", taskLabels_[pid][gid].c_str(), taskId.c_str()); fakeLog = result.get() + fakeLog.substr(beginPos); @@ -158,7 +159,8 @@ std::string FfrtConverter::ReplaceSchedSwitchLog(std::string &fakeLog, fakeLog = fakeLog.substr(0, pPidPos) + result.get() + fakeLog.substr(pPrioPos); memset_s(result.get(), MAX_LEN, 0, MAX_LEN); } - } else if (mark.find("next_pid=" + std::to_string(tid)) != std::string::npos) { + } else if (mark.find("next_pid=" + std::to_string(tid)) != std::string::npos && + fakeLog.find("next_comm=") != std::string::npos && fakeLog.find("next_prio=") != std::string::npos) { (void)sprintf_s(result.get(), MAX_LEN, "next_comm=%s ", taskLabels_[pid][gid].c_str()); size_t nCommPos = fakeLog.find("next_comm="); size_t nPidPos = fakeLog.find("next_pid="); @@ -182,12 +184,16 @@ std::string FfrtConverter::ReplaceSchedWakeLog(std::string &fakeLog, (void)sprintf_s(result.get(), MAX_LEN, "comm=%s ", label.c_str()); size_t commPos = fakeLog.find("comm="); size_t pidPos = fakeLog.find("pid="); - fakeLog = fakeLog.substr(0, commPos) + result.get() + fakeLog.substr(pidPos); - memset_s(result.get(), MAX_LEN, 0, MAX_LEN); - (void)sprintf_s(result.get(), MAX_LEN, "pid=%s ", taskId.c_str()); - pidPos = fakeLog.find("pid="); - size_t prioPos = fakeLog.find("prio="); - fakeLog = fakeLog.substr(0, pidPos) + result.get() + fakeLog.substr(prioPos); + if (commPos != std::string::npos && pidPos != std::string::npos) { + fakeLog = fakeLog.substr(0, commPos) + result.get() + fakeLog.substr(pidPos); + memset_s(result.get(), MAX_LEN, 0, MAX_LEN); + (void)sprintf_s(result.get(), MAX_LEN, "pid=%s ", taskId.c_str()); + pidPos = fakeLog.find("pid="); + size_t prioPos = fakeLog.find("prio="); + if (prioPos != std::string::npos) { + fakeLog = fakeLog.substr(0, pidPos) + result.get() + fakeLog.substr(prioPos); + } + } return fakeLog; } @@ -198,7 +204,9 @@ std::string FfrtConverter::ReplaceSchedBlockLog(std::string &fakeLog, const int (void)sprintf_s(result.get(), MAX_LEN, "pid=%s ", taskId.c_str()); size_t pidPos = fakeLog.find("pid"); size_t ioPos = fakeLog.find("iowait="); - fakeLog = fakeLog.substr(0, pidPos) + result.get() + fakeLog.substr(ioPos); + if (pidPos != std::string::npos && ioPos != std::string::npos) { + fakeLog = fakeLog.substr(0, pidPos) + result.get() + fakeLog.substr(ioPos); + } return fakeLog; } std::string FfrtConverter::ReplaceTracingMarkLog(std::string &fakeLog, @@ -235,9 +243,13 @@ std::string FfrtConverter::ConvertWorkerLogToTask(const std::string &mark, } int FfrtConverter::FindIntNumberAfterStr(const size_t index, const string &str) { - auto beginPos = context_[index].find(str) + str.length(); - auto endPos = context_[index].find_first_of(" ", beginPos); - return stoi(context_[index].substr(beginPos, endPos - beginPos)); + auto beginPos = context_[index].find(str); + if (beginPos != std::string::npos) { + beginPos = beginPos + str.length(); + auto endPos = context_[index].find_first_of(" ", beginPos); + return stoi(context_[index].substr(beginPos, endPos - beginPos)); + } + return -1; } std::string FfrtConverter::FindSubStrAfterStr(const size_t index, const string &str) { @@ -250,10 +262,10 @@ void FfrtConverter::ClassifySchedSwitchData(const size_t index, std::unordered_m auto prevTid = FindIntNumberAfterStr(index, "prev_pid="); auto nextTid = FindIntNumberAfterStr(index, "next_pid="); // update sched_switch prev_pid and next_pid corresponding line number - if (traceMap.count(prevTid) == 0) { + if (prevTid != -1 && traceMap.count(prevTid) == 0) { traceMap[prevTid] = std::vector(); } - if (traceMap.count(nextTid) == 0) { + if (nextTid != -1 && traceMap.count(nextTid) == 0) { traceMap[nextTid] = std::vector(); } traceMap[prevTid].push_back(index); @@ -290,12 +302,14 @@ void FfrtConverter::FindFfrtProcessAndClassify(const size_t index, std::unordere std::string res = context_[index].substr(0, endPos); std::string begin = "-"; auto beginPos = res.find_last_of(begin); - beginPos = beginPos + begin.length(); - auto tid = stoi(context_[index].substr(beginPos, endPos - beginPos)); - if (traceMap.find(tid) == traceMap.end()) { - traceMap[tid] = std::vector(); + if (beginPos != std::string::npos) { + beginPos = beginPos + begin.length(); + auto tid = stoi(context_[index].substr(beginPos, endPos - beginPos)); + if (traceMap.find(tid) == traceMap.end()) { + traceMap[tid] = std::vector(); + } + traceMap[tid].push_back(index); } - traceMap[tid].push_back(index); } return; } @@ -394,14 +408,18 @@ void FfrtConverter::ProcessMarkWithSchedSwitch(const int tid, int &prio, const s if (context_[index].find("prev_pid=" + std::to_string(tid) + " ") != std::string::npos) { static std::string beginPprio = "prev_prio="; auto beginPos = context_[index].find(beginPprio); - beginPos = beginPos + beginPprio.length(); - auto endPos = context_[index].find_first_of(" ", beginPos); - prio = stoi(context_[index].substr(beginPos, endPos - beginPos)); + if (beginPos != std::string::npos) { + beginPos = beginPos + beginPprio.length(); + auto endPos = context_[index].find_first_of(" ", beginPos); + prio = stoi(context_[index].substr(beginPos, endPos - beginPos)); + } } else if (context_[index].find("next_pid=" + std::to_string(tid)) != std::string::npos) { static std::string beginNprio = "next_prio="; auto beginPos = context_[index].find(beginNprio); - beginPos = beginPos + beginNprio.length(); - prio = stoi(context_[index].substr(beginPos)); + if (beginPos != std::string::npos) { + beginPos = beginPos + beginNprio.length(); + prio = stoi(context_[index].substr(beginPos)); + } } } } @@ -412,25 +430,33 @@ std::string FfrtConverter::GetLabel(const string &line) if (line.find("H:FFRT::") != std::string::npos) { auto beginPos = line.rfind("["); auto endPos = line.rfind("]"); - label = line.substr(beginPos + 1, endPos - beginPos - 1); + if (beginPos != std::string::npos && endPos != std::string::npos) { + label = line.substr(beginPos + 1, endPos - beginPos - 1); + } } else { static std::string indexHFfrt = "|H:FFRT"; auto beginPos = line.find(indexHFfrt); beginPos = beginPos + indexHFfrt.length(); auto endPos = line.find_first_of("|", beginPos); - label = line.substr(beginPos, endPos - beginPos); + if (endPos != std::string::npos) { + label = line.substr(beginPos, endPos - beginPos); + } } } else { if (line.find("|FFRT::") != std::string::npos) { auto beginPos = line.rfind("["); auto endPos = line.rfind("]"); - label = line.substr(beginPos + 1, endPos - beginPos - 1); + if (beginPos != std::string::npos && endPos != std::string::npos) { + label = line.substr(beginPos + 1, endPos - beginPos - 1); + } } else { static std::string indexFfrt = "|FFRT"; auto beginPos = line.find(indexFfrt); beginPos = beginPos + indexFfrt.length(); auto endPos = line.find_first_of("|", beginPos); - label = line.substr(beginPos, endPos - beginPos); + if (endPos != std::string::npos) { + label = line.substr(beginPos, endPos - beginPos); + } } } return label; diff --git a/trace_streamer/src/rpc/wasm_func.cpp b/trace_streamer/src/rpc/wasm_func.cpp index 0afeca2a616a0fd2f8fccff800022b1612dcf7a2..031d2cddabc3554d1fab63d058f5c4dda37a5384 100644 --- a/trace_streamer/src/rpc/wasm_func.cpp +++ b/trace_streamer/src/rpc/wasm_func.cpp @@ -255,13 +255,6 @@ EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerParseDataOver() } return -1; } -EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerSqlOperate(const uint8_t *sql, int32_t sqlLen) -{ - if (g_wasmTraceStreamer.SqlOperate(sql, sqlLen, nullptr)) { - return 0; - } - return -1; -} EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerSqlOperateEx(int32_t sqlLen) { if (g_wasmTraceStreamer.SqlOperate(g_reqBuf, sqlLen, nullptr)) { diff --git a/trace_streamer/src/rpc/wasm_func.h b/trace_streamer/src/rpc/wasm_func.h index 6fc0fa87f2dbf7569abaa7d5f1342b708996ef3b..b511f4f1d32bbb56d265987fe677b711dd3a1883 100644 --- a/trace_streamer/src/rpc/wasm_func.h +++ b/trace_streamer/src/rpc/wasm_func.h @@ -38,7 +38,6 @@ extern "C" { int32_t TraceStreamerParseData(const uint8_t *data, int32_t dataLen); int32_t TraceStreamerParseDataEx(int32_t dataLen, bool isFinish); int32_t TraceStreamerParseDataOver(); -int32_t TraceStreamerSqlOperate(const uint8_t *sql, int32_t sqlLen); int32_t TraceStreamerSqlOperateEx(int32_t sqlLen); int32_t TraceStreamerReset(); int32_t TraceStreamerSqlQuery(const uint8_t *sql, int32_t sqlLen, uint8_t *out, int32_t outLen); diff --git a/trace_streamer/src/table/ftrace/BUILD.gn b/trace_streamer/src/table/ftrace/BUILD.gn index d43e070386fb3305c85533dae58476ff67424a77..a68a10bc050770a3fd2ef64d98875ce592e8a0e1 100644 --- a/trace_streamer/src/table/ftrace/BUILD.gn +++ b/trace_streamer/src/table/ftrace/BUILD.gn @@ -25,6 +25,7 @@ ohos_source_set("ftrace_tables") { "clock_event_filter_table.cpp", "clock_snapshot_table.cpp", "cpu_measure_filter_table.cpp", + "dma_fence_table.cpp", "dynamic_frame_table.cpp", "filter_table.cpp", "frame_maps_table.cpp", diff --git a/trace_streamer/src/table/ftrace/dma_fence_table.cpp b/trace_streamer/src/table/ftrace/dma_fence_table.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bffbae4054f4c300beca759a92c0d1dd9e42415e --- /dev/null +++ b/trace_streamer/src/table/ftrace/dma_fence_table.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dma_fence_table.h" + +namespace SysTuning { +namespace TraceStreamer { +enum class Index : int32_t { ID = 0, TS, DURS, CAT, DRIVER, TIMELINE, CONTEXT, SEQNO }; +DmaFenceTable::DmaFenceTable(const TraceDataCache *dataCache) : TableBase(dataCache) +{ + tableColumn_.emplace_back(TableBase::ColumnInfo("id", "INTEGER")); + tableColumn_.emplace_back(TableBase::ColumnInfo("ts", "INTEGER")); + tableColumn_.emplace_back(TableBase::ColumnInfo("dur", "INTEGER")); + tableColumn_.emplace_back(TableBase::ColumnInfo("cat", "TEXT")); + tableColumn_.emplace_back(TableBase::ColumnInfo("driver", "TEXT")); + tableColumn_.emplace_back(TableBase::ColumnInfo("timeline", "TEXT")); + tableColumn_.emplace_back(TableBase::ColumnInfo("context", "INTEGER")); + tableColumn_.emplace_back(TableBase::ColumnInfo("seqno", "INTEGER")); + tablePriKey_.push_back("id"); +} + +DmaFenceTable::~DmaFenceTable() {} + +void DmaFenceTable::FilterByConstraint(FilterConstraints &dmaFencefc, + double &dmaFencefilterCost, + size_t dmaFencerowCount, + uint32_t dmaFencecurrenti) +{ + const auto &dmaFencec = dmaFencefc.GetConstraints()[dmaFencecurrenti]; + switch (static_cast(dmaFencec.col)) { + case Index::ID: { + if (CanFilterId(dmaFencec.op, dmaFencerowCount)) { + dmaFencefc.UpdateConstraint(dmaFencecurrenti, true); + dmaFencefilterCost += 1; // id can position by 1 step + } else { + dmaFencefilterCost += dmaFencerowCount; // scan all rows + } + break; + } + default: // other column + dmaFencefilterCost += dmaFencerowCount; // scan all rows + break; + } +} + +std::unique_ptr DmaFenceTable::CreateCursor() +{ + return std::make_unique(dataCache_, this); +} + +DmaFenceTable::Cursor::Cursor(const TraceDataCache *dataCache, TableBase *table) + : TableBase::Cursor(dataCache, table, static_cast(dataCache->GetConstDmaFenceData().Size())), + dmaFenceObj_(dataCache->GetConstDmaFenceData()) +{ +} + +DmaFenceTable::Cursor::~Cursor() {} + +int32_t DmaFenceTable::Cursor::Filter(const FilterConstraints &fc, sqlite3_value **argv) +{ + // reset indexMap_ + indexMap_ = std::make_unique(0, rowCount_); + + if (rowCount_ <= 0) { + return SQLITE_OK; + } + + auto DmaFenceTabCs = fc.GetConstraints(); + for (size_t i = 0; i < DmaFenceTabCs.size(); i++) { + const auto &c = DmaFenceTabCs[i]; + switch (static_cast(c.col)) { + case Index::ID: + FilterId(c.op, argv[i]); + break; + case Index::TS: + FilterTS(c.op, argv[i], dmaFenceObj_.TimelinesData()); + break; + default: + break; + } + } + + auto DmaFenceTabOrderbys = fc.GetOrderBys(); + for (auto i = DmaFenceTabOrderbys.size(); i > 0;) { + i--; + switch (static_cast(DmaFenceTabOrderbys[i].iColumn)) { + case Index::ID: + indexMap_->SortBy(DmaFenceTabOrderbys[i].desc); + break; + default: + break; + } + } + + return SQLITE_OK; +} + +int32_t DmaFenceTable::Cursor::Column(int32_t column) const +{ + switch (static_cast(column)) { + case Index::ID: + sqlite3_result_int64(context_, CurrentRow()); + break; + case Index::TS: + SetTypeColumnInt64(dmaFenceObj_.TimeStampData()[CurrentRow()], INVALID_UINT64); + break; + case Index::DURS: + SetTypeColumnInt64(dmaFenceObj_.DursData()[CurrentRow()], INVALID_UINT64); + break; + case Index::CAT: { + SetTypeColumnText(dmaFenceObj_.CatsData()[CurrentRow()], INVALID_UINT64); + break; + } + case Index::DRIVER: { + SetTypeColumnText(dmaFenceObj_.DriversData()[CurrentRow()], INVALID_UINT64); + break; + } + case Index::TIMELINE: { + SetTypeColumnText(dmaFenceObj_.TimelinesData()[CurrentRow()], INVALID_UINT64); + break; + } + case Index::CONTEXT: { + SetTypeColumnInt32(dmaFenceObj_.ContextsData()[CurrentRow()], INVALID_UINT32); + break; + } + case Index::SEQNO: { + SetTypeColumnInt32(dmaFenceObj_.SeqnosData()[CurrentRow()], INVALID_UINT32); + break; + } + default: + break; + } + return SQLITE_OK; +} + +void DmaFenceTable::GetOrbyes(FilterConstraints &dmaFencefc, EstimatedIndexInfo &dmaFenceei) +{ + auto dmaFenceorderbys = dmaFencefc.GetOrderBys(); + for (auto i = 0; i < dmaFenceorderbys.size(); i++) { + switch (static_cast(dmaFenceorderbys[i].iColumn)) { + case Index::ID: + break; + default: // other columns can be sorted by SQLite + dmaFenceei.isOrdered = false; + break; + } + } +} +} // namespace TraceStreamer +} // namespace SysTuning \ No newline at end of file diff --git a/trace_streamer/src/table/ftrace/include/dma_fence_table.h b/trace_streamer/src/table/ftrace/include/dma_fence_table.h new file mode 100644 index 0000000000000000000000000000000000000000..39bec3482d228ba10448975d55588468f34ba783 --- /dev/null +++ b/trace_streamer/src/table/ftrace/include/dma_fence_table.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TRACE_STREAMER_DMA_FENCE_TABLE_H +#define TRACE_STREAMER_DMA_FENCE_TABLE_H + +#include "table_base.h" +#include "trace_data_cache.h" + +namespace SysTuning { +namespace TraceStreamer { +class DmaFenceTable : public TableBase { +public: + explicit DmaFenceTable(const TraceDataCache *dataCache); + ~DmaFenceTable() override; + std::unique_ptr CreateCursor() override; + +private: + int64_t GetSize() override + { + return dataCache_->GetConstDmaFenceData().Size(); + } + void GetOrbyes(FilterConstraints &dmaFencefc, EstimatedIndexInfo &dmaFenceei) override; + void FilterByConstraint(FilterConstraints &dmaFencefc, + double &dmaFencefilterCost, + size_t dmaFencerowCount, + uint32_t dmaFencecurrenti) override; + class Cursor : public TableBase::Cursor { + public: + explicit Cursor(const TraceDataCache *dataCache, TableBase *table); + ~Cursor() override; + int32_t Filter(const FilterConstraints &fc, sqlite3_value **argv) override; + int32_t Column(int32_t column) const override; + + private: + const DmaFence &dmaFenceObj_; + }; +}; +} // namespace TraceStreamer +} // namespace SysTuning +#endif // TRACE_STREAMER_DMA_FENCE_TABLE_H diff --git a/trace_streamer/src/table/hiperf/BUILD.gn b/trace_streamer/src/table/hiperf/BUILD.gn index 56791a2b06d2393c83e3bb0308f85df33ede4478..73c303dea3d7d20d8a5e1a3a5e0100ab8d24b233 100644 --- a/trace_streamer/src/table/hiperf/BUILD.gn +++ b/trace_streamer/src/table/hiperf/BUILD.gn @@ -20,6 +20,7 @@ ohos_source_set("hiperf_tables") { sources = [ "perf_call_chain_table.cpp", "perf_files_table.cpp", + "perf_napi_async_table.cpp", "perf_report_table.cpp", "perf_sample_table.cpp", "perf_thread_table.cpp", diff --git a/trace_streamer/prebuilts/patch_hiperf/file_ex.h b/trace_streamer/src/table/hiperf/include/perf_napi_async_table.h similarity index 33% rename from trace_streamer/prebuilts/patch_hiperf/file_ex.h rename to trace_streamer/src/table/hiperf/include/perf_napi_async_table.h index 978663d8fcf594b1b10e8a17653cf517da0d702b..5c38d18c4eab5478d2daf4b17fb7527008feed40 100644 --- a/trace_streamer/prebuilts/patch_hiperf/file_ex.h +++ b/trace_streamer/src/table/hiperf/include/perf_napi_async_table.h @@ -13,21 +13,42 @@ * limitations under the License. */ -#ifndef UTILS_BASE_FILE_EX_H -#define UTILS_BASE_FILE_EX_H +#ifndef PERF_NAPI_ASYNC_TABLE_H +#define PERF_NAPI_ASYNC_TABLE_H -#include -#include -namespace OHOS { -bool LoadStringFromFile(const std::string &filePath, std::string &content); -bool SaveStringToFile(const std::string &filePath, const std::string &content, bool truncated = true); -bool LoadStringFromFd(int fd, std::string &content); -bool SaveStringToFd(int fd, const std::string &content); -bool LoadBufferFromFile(const std::string &filePath, std::vector &content); -bool SaveBufferToFile(const std::string &filePath, const std::vector &content, bool truncated = true); -bool FileExists(const std::string &fileName); -bool StringExistsInFile(const std::string &fileName, const std::string &subStr, bool caseSensitive = true); -int CountStrInFile(const std::string &fileName, const std::string &subStr, bool caseSensitive = true); -} // namespace OHOS +#include "table_base.h" +#include "trace_data_cache.h" -#endif +namespace SysTuning { +namespace TraceStreamer { +class PerfNapiAsyncTable : public TableBase { +public: + explicit PerfNapiAsyncTable(const TraceDataCache *dataCache); + ~PerfNapiAsyncTable() override; + std::unique_ptr CreateCursor() override; + +private: + int64_t GetSize() override + { + return dataCache_->GetConstPerfNapiAsyncData().Size(); + } + void GetOrbyes(FilterConstraints &napiAsyncFc, EstimatedIndexInfo &napiAsyncEi) override; + void FilterByConstraint(FilterConstraints &chainfc, + double &chainfilterCost, + size_t chainrowCount, + uint32_t chaincurrenti) override; + + class Cursor : public TableBase::Cursor { + public: + explicit Cursor(const TraceDataCache *dataCache, TableBase *table); + ~Cursor() override; + int32_t Filter(const FilterConstraints &fc, sqlite3_value **argv) override; + int32_t Column(int32_t column) const override; + + private: + const PerfNapiAsync &perfNapiAsyncObj_; + }; +}; +} // namespace TraceStreamer +} // namespace SysTuning +#endif // PERF_NAPI_ASYNC_TABLE_H diff --git a/trace_streamer/src/table/hiperf/perf_napi_async_table.cpp b/trace_streamer/src/table/hiperf/perf_napi_async_table.cpp new file mode 100644 index 0000000000000000000000000000000000000000..09ba3c58cd868ddb9caadce9ceee3e18a162a76f --- /dev/null +++ b/trace_streamer/src/table/hiperf/perf_napi_async_table.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "perf_napi_async_table.h" +#include "ts_common.h" + +namespace SysTuning { +namespace TraceStreamer { +enum class Index : int32_t { + ID = 0, + TS, + TRACEID, + CPU_ID, + THREAD_ID, + PROCESS_ID, + CALLER_CALLCHAINID, + CALLEE_CALLCHAINID, + PERF_SAMPLE_ID, + EVENT_COUNT, + EVENT_TYPE_ID, +}; +PerfNapiAsyncTable::PerfNapiAsyncTable(const TraceDataCache *dataCache) : TableBase(dataCache) +{ + tableColumn_.emplace_back("id", "INTEGER"); + tableColumn_.emplace_back("ts", "INTEGER"); + tableColumn_.emplace_back("traceid", "TEXT"); + tableColumn_.emplace_back("cpu_id", "INTEGER"); + tableColumn_.emplace_back("thread_id", "INTEGER"); + tableColumn_.emplace_back("process_id", "INTEGER"); + tableColumn_.emplace_back("caller_callchainid", "INTEGER"); + tableColumn_.emplace_back("callee_callchainid", "INTEGER"); + tableColumn_.emplace_back("perf_sample_id", "INTEGER"); + tableColumn_.emplace_back("event_count", "INTEGER"); + tableColumn_.emplace_back("event_type_id", "INTEGER"); + tablePriKey_.emplace_back("id"); +} + +PerfNapiAsyncTable::~PerfNapiAsyncTable() {} + +void PerfNapiAsyncTable::FilterByConstraint(FilterConstraints &napiAsyncFc, + double &napiAsyncFilterCost, + size_t napiAsyncRowCount, + uint32_t napiAsyncCurrenti) +{ + // To use the EstimateFilterCost function in the TableBase parent class function to calculate the i-value of each + // for loop + const auto &napiAsyncC = napiAsyncFc.GetConstraints()[napiAsyncCurrenti]; + switch (static_cast(napiAsyncC.col)) { + case Index::ID: { + if (CanFilterId(napiAsyncC.op, napiAsyncRowCount)) { + napiAsyncFc.UpdateConstraint(napiAsyncCurrenti, true); + napiAsyncFilterCost += 1; // id can position by 1 step + } else { + napiAsyncFilterCost += napiAsyncRowCount; // scan all rows + } + break; + } + default: // other column + napiAsyncFilterCost += napiAsyncRowCount; // scan all rows + break; + } +} + +std::unique_ptr PerfNapiAsyncTable::CreateCursor() +{ + return std::make_unique(dataCache_, this); +} + +PerfNapiAsyncTable::Cursor::Cursor(const TraceDataCache *dataCache, TableBase *table) + : TableBase::Cursor(dataCache, table, static_cast(dataCache->GetConstPerfNapiAsyncData().Size())), + perfNapiAsyncObj_(dataCache->GetConstPerfNapiAsyncData()) +{ +} + +PerfNapiAsyncTable::Cursor::~Cursor() {} + +int32_t PerfNapiAsyncTable::Cursor::Filter(const FilterConstraints &fc, sqlite3_value **argv) +{ + // reset indexMap_ + indexMap_ = std::make_unique(0, rowCount_); + + if (rowCount_ <= 0) { + return SQLITE_OK; + } + + auto perfNapiAsyncCs = fc.GetConstraints(); + std::set sId = {static_cast(Index::ID)}; + SwapIndexFront(perfNapiAsyncCs, sId); + for (size_t i = 0; i < perfNapiAsyncCs.size(); i++) { + const auto &c = perfNapiAsyncCs[i]; + switch (static_cast(c.col)) { + case Index::ID: + FilterId(c.op, argv[c.idxInaConstraint]); + break; + case Index::TRACEID: + indexMap_->MixRange(c.op, static_cast(sqlite3_value_int64(argv[c.idxInaConstraint])), + perfNapiAsyncObj_.Traceids()); + break; + case Index::THREAD_ID: + indexMap_->MixRange(c.op, static_cast(sqlite3_value_int64(argv[c.idxInaConstraint])), + perfNapiAsyncObj_.InternalTidsData()); + break; + case Index::CALLER_CALLCHAINID: + indexMap_->MixRange(c.op, static_cast(sqlite3_value_int64(argv[c.idxInaConstraint])), + perfNapiAsyncObj_.CallerCallchainids()); + break; + case Index::CALLEE_CALLCHAINID: + indexMap_->MixRange(c.op, static_cast(sqlite3_value_int64(argv[c.idxInaConstraint])), + perfNapiAsyncObj_.CalleeCallchainids()); + break; + default: + break; + } + } + + auto perfNapiAsyncOrderbys = fc.GetOrderBys(); + for (auto i = perfNapiAsyncOrderbys.size(); i > 0;) { + i--; + switch (static_cast(perfNapiAsyncOrderbys[i].iColumn)) { + case Index::ID: + indexMap_->SortBy(perfNapiAsyncOrderbys[i].desc); + break; + default: + break; + } + } + + return SQLITE_OK; +} + +int32_t PerfNapiAsyncTable::Cursor::Column(int32_t column) const +{ + switch (static_cast(column)) { + case Index::ID: + sqlite3_result_int64(context_, perfNapiAsyncObj_.IdsData()[CurrentRow()]); + break; + case Index::TS: + SetTypeColumnInt64(perfNapiAsyncObj_.TimeStampData()[CurrentRow()], INVALID_UINT64); + break; + case Index::TRACEID: + SetTypeColumnText(perfNapiAsyncObj_.Traceids()[CurrentRow()], INVALID_UINT64); + break; + case Index::CPU_ID: + SetTypeColumnInt64(perfNapiAsyncObj_.CpuIds()[CurrentRow()], INVALID_UINT64); + break; + case Index::THREAD_ID: + SetTypeColumnInt64(perfNapiAsyncObj_.InternalTidsData()[CurrentRow()], INVALID_UINT64); + break; + case Index::PROCESS_ID: + SetTypeColumnInt64(perfNapiAsyncObj_.ProcessIds()[CurrentRow()], INVALID_UINT64); + break; + case Index::CALLER_CALLCHAINID: + SetTypeColumnInt64(perfNapiAsyncObj_.CallerCallchainids()[CurrentRow()], INVALID_UINT64); + break; + case Index::CALLEE_CALLCHAINID: + SetTypeColumnInt64(perfNapiAsyncObj_.CalleeCallchainids()[CurrentRow()], INVALID_UINT64); + break; + case Index::PERF_SAMPLE_ID: + SetTypeColumnInt64(perfNapiAsyncObj_.PerfSampleIds()[CurrentRow()], INVALID_UINT64); + break; + case Index::EVENT_COUNT: + SetTypeColumnInt64(perfNapiAsyncObj_.EventCounts()[CurrentRow()], INVALID_UINT64); + break; + case Index::EVENT_TYPE_ID: + SetTypeColumnInt64(perfNapiAsyncObj_.EventTypeIds()[CurrentRow()], INVALID_UINT64); + break; + default: + TS_LOGF("Unregistered column : %d", column); + break; + } + return SQLITE_OK; +} + +void PerfNapiAsyncTable::GetOrbyes(FilterConstraints &napiAsyncFc, EstimatedIndexInfo &napiAsyncEi) +{ + auto napiAsyncOrderbys = napiAsyncFc.GetOrderBys(); + for (auto i = 0; i < napiAsyncOrderbys.size(); i++) { + switch (static_cast(napiAsyncOrderbys[i].iColumn)) { + case Index::ID: + break; + default: // other columns can be sorted by SQLite + napiAsyncEi.isOrdered = false; + break; + } + } +} +} // namespace TraceStreamer +} // namespace SysTuning diff --git a/trace_streamer/src/trace_data/trace_data_cache.cpp b/trace_streamer/src/trace_data/trace_data_cache.cpp index 7879c1c57b6501f5220133b0e1779c77ffe10cd5..78b8a3b52c35e7918657b64e69da55944c509a1c 100644 --- a/trace_streamer/src/trace_data/trace_data_cache.cpp +++ b/trace_streamer/src/trace_data/trace_data_cache.cpp @@ -36,6 +36,7 @@ #include "datasource_clockid_table.h" #include "device_info_table.h" #include "device_state_table.h" +#include "dma_fence_table.h" #include "disk_io_table.h" #include "dynamic_frame_table.h" #include "ebpf_callstack_table.h" @@ -83,6 +84,7 @@ #include "perf_report_table.h" #include "perf_sample_table.h" #include "perf_thread_table.h" +#include "perf_napi_async_table.h" #include "process_measure_filter_table.h" #include "process_table.h" #include "range_table.h" @@ -151,6 +153,7 @@ void TraceDataCache::InitHiperfDB() TableBase::TableDeclare(*db_, this, "perf_callchain"); TableBase::TableDeclare(*db_, this, "perf_thread"); TableBase::TableDeclare(*db_, this, "perf_files"); + TableBase::TableDeclare(*db_, this, "perf_napi_async"); } void TraceDataCache::InitMeasureDB() { @@ -245,6 +248,7 @@ void TraceDataCache::InitDB() TableBase::TableDeclare(*db_, this, "diskio"); TableBase::TableDeclare(*db_, this, "cpu_usage"); TableBase::TableDeclare(*db_, this, "live_process"); + TableBase::TableDeclare(*db_, this, "dma_fence"); dbInited_ = true; } bool TraceDataCache::AnimationTraceEnabled() const diff --git a/trace_streamer/src/trace_data/trace_data_cache_base.h b/trace_streamer/src/trace_data/trace_data_cache_base.h index 8d16faaf4e01168a7f2340ccc3a57e96dae259c7..b2dde69a80e44f3fcda8024ba637a4c5051171c2 100644 --- a/trace_streamer/src/trace_data/trace_data_cache_base.h +++ b/trace_streamer/src/trace_data/trace_data_cache_base.h @@ -133,6 +133,7 @@ public: PerfThread perfThread_; PerfFiles perfFiles_; PerfReport perfReport_; + PerfNapiAsync perfNapiAsync_; std::deque internalProcessesData_ = {}; std::deque internalThreadsData_ = {}; @@ -169,6 +170,7 @@ public: FrameSlice frameSliceData_; FrameMaps frameMapsData_; GPUSlice gpuSliceData_; + DmaFence dmaFenceData_; TaskPoolInfo taskPoolInfo_; JsHeapFiles jsHeapFilesData_; JsHeapEdges jsHeapEdgesData_; diff --git a/trace_streamer/src/trace_data/trace_data_cache_reader.cpp b/trace_streamer/src/trace_data/trace_data_cache_reader.cpp index cb12c7ad81f150a8f047a92d5461691fe763082c..81d0c1b6e027f27e1941e399faa12c00a86fd9b7 100644 --- a/trace_streamer/src/trace_data/trace_data_cache_reader.cpp +++ b/trace_streamer/src/trace_data/trace_data_cache_reader.cpp @@ -171,6 +171,10 @@ const PerfReport &TraceDataCacheReader::GetConstPerfReportData() const { return perfReport_; } +const PerfNapiAsync &TraceDataCacheReader::GetConstPerfNapiAsyncData() const +{ + return perfNapiAsync_; +} const SysCall &TraceDataCacheReader::GetConstSysCallData() const { return sysCallData_; @@ -320,6 +324,10 @@ const GPUSlice &TraceDataCacheReader::GetConstGPUSliceData() const { return gpuSliceData_; } +const DmaFence &TraceDataCacheReader::GetConstDmaFenceData() const +{ + return dmaFenceData_; +} const AppStartup &TraceDataCacheReader::GetConstAppStartupData() const { return appStartupData_; diff --git a/trace_streamer/src/trace_data/trace_data_cache_reader.h b/trace_streamer/src/trace_data/trace_data_cache_reader.h index 5290b41f9b148067a8b41cce6bf8246b28f84a9b..dacfcc2f59ec08a891c8105e3009ff919bac0fde 100644 --- a/trace_streamer/src/trace_data/trace_data_cache_reader.h +++ b/trace_streamer/src/trace_data/trace_data_cache_reader.h @@ -82,6 +82,7 @@ public: const PerfSample &GetConstPerfSampleData() const; const PerfThread &GetConstPerfThreadData() const; const PerfReport &GetConstPerfReportData() const; + const PerfNapiAsync &GetConstPerfNapiAsyncData() const; const ArgSet &GetConstArgSetData() const; const DataType &GetConstDataTypeData() const; const SysMeasureFilter &GetConstSysMeasureFilterData() const; @@ -104,6 +105,7 @@ public: const FrameSlice &GetConstFrameSliceData() const; const FrameMaps &GetConstFrameMapsData() const; const GPUSlice &GetConstGPUSliceData() const; + const DmaFence &GetConstDmaFenceData() const; const TaskPoolInfo &GetConstTaskPoolData() const; const JsHeapFiles &GetConstJsHeapFilesData() const; const JsHeapEdges &GetConstJsHeapEdgesData() const; diff --git a/trace_streamer/src/trace_data/trace_data_cache_writer.cpp b/trace_streamer/src/trace_data/trace_data_cache_writer.cpp index 261e66521608da467a96dd4fd42efa807eee740b..8439ab5740800e92f436a7b2aa0839de843b25fe 100644 --- a/trace_streamer/src/trace_data/trace_data_cache_writer.cpp +++ b/trace_streamer/src/trace_data/trace_data_cache_writer.cpp @@ -223,6 +223,10 @@ PerfReport *TraceDataCacheWriter::GetPerfReportData() { return &perfReport_; } +PerfNapiAsync *TraceDataCacheWriter::GetPerfNapiAsyncData() +{ + return &perfNapiAsync_; +} ArgSet *TraceDataCacheWriter::GetArgSetData() { return &argSet_; @@ -316,6 +320,10 @@ GPUSlice *TraceDataCacheWriter::GetGPUSliceData() { return &gpuSliceData_; } +DmaFence *TraceDataCacheWriter::GetDmaFenceData() +{ + return &dmaFenceData_; +} TaskPoolInfo *TraceDataCacheWriter::GetTaskPoolData() { return &taskPoolInfo_; @@ -515,6 +523,7 @@ void TraceDataCacheWriter::Clear() gpuProcessMemData_.Clear(); gpuWindowMemData_.Clear(); gpuSliceData_.Clear(); + dmaFenceData_.Clear(); frameMapsData_.Clear(); frameSliceData_.Clear(); } diff --git a/trace_streamer/src/trace_data/trace_data_cache_writer.h b/trace_streamer/src/trace_data/trace_data_cache_writer.h index 8dd2a02a688b4dba0409afdc32fd985eda8f7c3a..d916002e8699b86b3afe843c4e4ccc2492b35cf1 100644 --- a/trace_streamer/src/trace_data/trace_data_cache_writer.h +++ b/trace_streamer/src/trace_data/trace_data_cache_writer.h @@ -66,6 +66,7 @@ public: PerfSample *GetPerfSampleData(); PerfThread *GetPerfThreadData(); PerfReport *GetPerfReportData(); + PerfNapiAsync *GetPerfNapiAsyncData(); ArgSet *GetArgSetData(); DataType *GetDataTypeData(); SysMeasureFilter *GetSysMeasureFilterData(); @@ -88,6 +89,7 @@ public: FrameSlice *GetFrameSliceData(); FrameMaps *GetFrameMapsData(); GPUSlice *GetGPUSliceData(); + DmaFence *GetDmaFenceData(); TaskPoolInfo *GetTaskPoolData(); JsHeapFiles *GetJsHeapFilesData(); JsHeapEdges *GetJsHeapEdgesData(); diff --git a/trace_streamer/src/trace_data/trace_stdtype/base_stdtype.h b/trace_streamer/src/trace_data/trace_stdtype/base_stdtype.h index c1babaa7723fc0b8cc78b58fe72effc272cc2f68..ceaf7480793037d380878afc7e48ac6c1d27fd80 100644 --- a/trace_streamer/src/trace_data/trace_stdtype/base_stdtype.h +++ b/trace_streamer/src/trace_data/trace_stdtype/base_stdtype.h @@ -69,7 +69,7 @@ public: } virtual void ClearExportedData() = 0; template - void EraseElements(T &deq, changedata &... args) + void EraseElements(T &deq, changedata &...args) { deq.erase(deq.begin(), deq.begin() + readySize_); EraseElements(args...); diff --git a/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.cpp b/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.cpp index c8253ab2f461efa7d52714c00064c3783375cd12..aa5a6a06d2c34112907f8ea2533822fafa36ed55 100644 --- a/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.cpp +++ b/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.cpp @@ -180,6 +180,47 @@ const std::deque &GPUSlice::Durs() const { return durs_; } +size_t DmaFence::AppendNew(const DmaFenceRow &dmaFenceRow) +{ + timeStamps_.emplace_back(dmaFenceRow.timeStamp); + durs_.emplace_back(dmaFenceRow.duration); + cats_.emplace_back(dmaFenceRow.eventName); + drivers_.emplace_back(dmaFenceRow.driver); + timelines_.emplace_back(dmaFenceRow.timeline); + contexts_.emplace_back(dmaFenceRow.context); + seqnos_.emplace_back(dmaFenceRow.seqno); + return Size() - 1; +} + +const std::deque &DmaFence::DursData() const +{ + return durs_; +} + +const std::deque &DmaFence::CatsData() const +{ + return cats_; +} + +const std::deque &DmaFence::DriversData() const +{ + return drivers_; +} + +const std::deque &DmaFence::TimelinesData() const +{ + return timelines_; +} + +const std::deque &DmaFence::ContextsData() const +{ + return contexts_; +} + +const std::deque &DmaFence::SeqnosData() const +{ + return seqnos_; +} size_t FrameMaps::AppendNew(FrameSlice *frameSlice, uint64_t src, uint64_t dst) { diff --git a/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.h b/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.h index f19706bd35fcd85244bcf566418e49b8c3ae131c..412b16f45b44b43905f16abc89cda1774166b785 100644 --- a/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.h +++ b/trace_streamer/src/trace_data/trace_stdtype/ftrace/render_service_stdtype.h @@ -106,6 +106,44 @@ private: std::deque frameRows_ = {}; std::deque durs_ = {}; }; +struct DmaFenceRow { + uint64_t timeStamp = INVALID_UINT64; + uint64_t duration = INVALID_UINT64; + DataIndex eventName = INVALID_DATAINDEX; + DataIndex driver = INVALID_DATAINDEX; + DataIndex timeline = INVALID_DATAINDEX; + uint32_t context = INVALID_UINT32; + uint32_t seqno = INVALID_UINT32; +}; + +class DmaFence : public CacheBase { +public: + size_t AppendNew(const DmaFenceRow &dmaFenceRow); + const std::deque &DursData() const; + const std::deque &CatsData() const; + const std::deque &DriversData() const; + const std::deque &TimelinesData() const; + const std::deque &ContextsData() const; + const std::deque &SeqnosData() const; + void Clear() override + { + CacheBase::Clear(); + durs_.clear(); + cats_.clear(); + drivers_.clear(); + timelines_.clear(); + contexts_.clear(); + seqnos_.clear(); + } + +private: + std::deque durs_ = {}; + std::deque cats_ = {}; + std::deque drivers_ = {}; + std::deque timelines_ = {}; + std::deque contexts_ = {}; + std::deque seqnos_ = {}; +}; class FrameMaps : public CacheBase, public BatchCacheBase { public: diff --git a/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.cpp b/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.cpp index 22555340de9161cdfb87807cdcc1cdfe53cd5fbf..022a1e5b5102c605aa6f68038608afe740eea176 100644 --- a/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.cpp +++ b/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.cpp @@ -78,6 +78,14 @@ void PerfCallChain::UpdateSymbolId(size_t index, DataIndex symbolId) symbolIds_[index] = symbolId; } } +void PerfCallChain::UpdateSymbolRelatedData(size_t index, uint64_t vaddrInFile, uint64_t symbolId, DataIndex nameIndex) +{ + if (index < Size()) { + vaddrInFiles_[index] = vaddrInFile; + symbolIds_[index] = symbolId; + names_[index] = nameIndex; + } +} size_t PerfFiles::AppendNewPerfFiles(uint64_t fileIds, uint32_t serial, DataIndex symbols, DataIndex filePath) { ids_.emplace_back(Size()); @@ -105,6 +113,31 @@ const std::deque &PerfFiles::FilePaths() const return filePaths_; } +bool PerfFiles::EraseFileIdSameData(uint64_t fileId) +{ + uint64_t start = INVALID_UINT64; + uint64_t end = INVALID_UINT64; + for (auto row = 0; row < Size(); row++) { + if (fileIds_[row] == fileId) { + if (start == INVALID_UINT64) { + start = row; + end = row; + } else { + end = row; + } + } + } + end++; + if (start <= end && end < Size()) { + ids_.erase(ids_.begin() + start, ids_.begin() + end); + fileIds_.erase(fileIds_.begin() + start, fileIds_.begin() + end); + serials_.erase(serials_.begin() + start, serials_.begin() + end); + symbols_.erase(symbols_.begin() + start, symbols_.begin() + end); + filePaths_.erase(filePaths_.begin() + start, filePaths_.begin() + end); + return true; + } + return false; +} void PerfFiles::Clear() { CacheBase::Clear(); @@ -210,5 +243,63 @@ const std::deque &PerfReport::Values() const { return values_; } +size_t PerfNapiAsync::AppendNewPerfNapiAsync(const PerfNapiAsyncRow &perfNapiAsyncRow) +{ + ids_.emplace_back(Size()); + timeStamps_.emplace_back(perfNapiAsyncRow.timeStamp); + traceids_.emplace_back(perfNapiAsyncRow.traceid); + cpuIds_.emplace_back(perfNapiAsyncRow.cpuId); + internalTids_.emplace_back(perfNapiAsyncRow.threadId); + processIds_.emplace_back(perfNapiAsyncRow.processId); + callerCallchainids_.emplace_back(perfNapiAsyncRow.callerCallchainid); + calleeCallchainids_.emplace_back(perfNapiAsyncRow.calleeCallchainid); + perfSampleIds_.emplace_back(perfNapiAsyncRow.perfSampleId); + eventCounts_.emplace_back(perfNapiAsyncRow.eventCount); + eventTypeIds_.emplace_back(perfNapiAsyncRow.eventTypeId); + return Size() - 1; +} +const std::deque &PerfNapiAsync::Traceids() const +{ + return traceids_; +} +const std::deque &PerfNapiAsync::CpuIds() const +{ + return cpuIds_; +} +const std::deque &PerfNapiAsync::ProcessIds() const +{ + return processIds_; +} +const std::deque &PerfNapiAsync::CallerCallchainids() const +{ + return callerCallchainids_; +} +const std::deque &PerfNapiAsync::CalleeCallchainids() const +{ + return calleeCallchainids_; +} +const std::deque &PerfNapiAsync::PerfSampleIds() const +{ + return perfSampleIds_; +} +const std::deque &PerfNapiAsync::EventCounts() const +{ + return eventCounts_; +} +const std::deque &PerfNapiAsync::EventTypeIds() const +{ + return eventTypeIds_; +} +void PerfNapiAsync::Clear() +{ + CacheBase::Clear(); + traceids_.clear(); + processIds_.clear(); + callerCallchainids_.clear(); + calleeCallchainids_.clear(); + perfSampleIds_.clear(); + eventCounts_.clear(); + eventTypeIds_.clear(); +} } // namespace TraceStdtype } // namespace SysTuning diff --git a/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.h b/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.h index 115506a4711a880b788d04dac8ad5e15bae876f1..0224d6369dc22495bc9406dc4b7d6fc2f1889d73 100644 --- a/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.h +++ b/trace_streamer/src/trace_data/trace_stdtype/hiperf/hiperf_stdtype.h @@ -43,6 +43,7 @@ public: void SetName(uint64_t index, DataIndex name); void UpdateSymbolId(size_t index, DataIndex symbolId); void Clear() override; + void UpdateSymbolRelatedData(size_t index, uint64_t vaddrInFile, uint64_t symbolId, DataIndex nameIndex); private: std::deque callChainIds_ = {}; @@ -62,6 +63,7 @@ public: const std::deque &FilePaths() const; const std::deque &Serials() const; void Clear() override; + bool EraseFileIdSameData(uint64_t fileId); private: std::deque fileIds_ = {}; @@ -125,6 +127,43 @@ private: std::deque types_ = {}; std::deque values_ = {}; }; + +struct PerfNapiAsyncRow { + uint64_t timeStamp = INVALID_UINT64; + DataIndex traceid = INVALID_UINT64; + uint8_t cpuId = INVALID_UINT8; + InternalTid threadId = INVALID_UINT32; + uint32_t processId = INVALID_UINT32; + uint32_t callerCallchainid = INVALID_UINT32; + uint32_t calleeCallchainid = INVALID_UINT32; + uint64_t perfSampleId = INVALID_UINT64; + uint64_t eventCount = 0; + uint64_t eventTypeId = 0; +}; + +class PerfNapiAsync : public CacheBase { +public: + size_t AppendNewPerfNapiAsync(const PerfNapiAsyncRow &perfNapiAsyncRow); + const std::deque &Traceids() const; + const std::deque &CpuIds() const; + const std::deque &ProcessIds() const; + const std::deque &CallerCallchainids() const; + const std::deque &CalleeCallchainids() const; + const std::deque &PerfSampleIds() const; + const std::deque &EventCounts() const; + const std::deque &EventTypeIds() const; + void Clear() override; + +private: + std::deque traceids_ = {}; + std::deque cpuIds_ = {}; + std::deque processIds_ = {}; + std::deque callerCallchainids_ = {}; + std::deque calleeCallchainids_ = {}; + std::deque perfSampleIds_ = {}; + std::deque eventCounts_ = {}; + std::deque eventTypeIds_ = {}; +}; } // namespace TraceStdtype } // namespace SysTuning #endif // HIPERF_STDTYPE_H diff --git a/trace_streamer/test/BUILD.gn b/trace_streamer/test/BUILD.gn index e05211d4ccfaf8e9c5265cd4eae541d9d453da33..74ef66c2b1154454fb20cb9fd925382ac0b7333f 100644 --- a/trace_streamer/test/BUILD.gn +++ b/trace_streamer/test/BUILD.gn @@ -107,35 +107,32 @@ if (is_test) { [ "${EXTEND_SRC}/parser/pbreader_stream_parser:stream_extend_parser" ] } include_dirs = [ - "../src", - "../src/trace_data", - "../src/table", - "../src/table/base", - "../src/filter", - "../src/metrics", - "../src/base", - "../src/rpc", - "../src/metrics", - "../src/include", - "../src/trace_streamer", - "../src/parser/ptreader_parser", - "../src/parser/ptreader_parser/bytrace_parser", - "../src/parser", - "../src/cfg", - "../src/metrics", - "../src/parser/ebpf_parser", - "../src/parser/hiperf_parser", - "../src/parser/hiperf_parser/include", - "../src/proto_reader", - "../src/proto_reader/include", - "../src/table/base/include", + "${SRC}", + "${SRC}/trace_data", + "${SRC}/table", + "${SRC}/table/base", + "${SRC}/filter", + "${SRC}/metrics", + "${SRC}/base", + "${SRC}/rpc", + "${SRC}/metrics", + "${SRC}/include", + "${SRC}/trace_streamer", + "${SRC}/parser/ptreader_parser", + "${SRC}/parser/ptreader_parser/bytrace_parser", + "${SRC}/parser", + "${SRC}/cfg", + "${SRC}/metrics", + "${SRC}/parser/ebpf_parser", + "${SRC}/parser/hiperf_parser", + "${SRC}/parser/hiperf_parser/include", + "${SRC}/proto_reader", + "${SRC}/proto_reader/include", + "${SRC}/table/base/include", "..", "unittest/base", "${THIRD_PARTY}/googletest/googletest/include/gtest", "${THIRD_PARTY}/protobuf/src", - "${PERF_DIR}/hiperf/include", - "${PERF_DIR}/hiperf/include/nonlinux/linux", - "${PERF_DIR}/hiperf/include/nonlinux", "${THIRD_PARTY}/protobuf/src/google/protobuf", "${THIRD_PARTY}/json/single_include/nlohmann", "${THIRD_PARTY}/perf_include/libbpf", @@ -145,25 +142,14 @@ if (is_test) { "${THIRD_PARTY}/sqlite/include", "${THIRD_PARTY}/bounds_checking_function/include", "${THIRD_PARTY}/json/single_include/nlohmann", - "../src/parser/pbreader_parser", - "../src/parser/pbreader_parser/htrace_parser", - "../src/proto_reader", - "../src/proto_reader/include", + "${SRC}/parser/pbreader_parser", + "${SRC}/parser/pbreader_parser/htrace_parser", + "${SRC}/proto_reader", + "${SRC}/proto_reader/include", "${SRC}/metrics", "${SRC}/parser/rawtrace_parser", ] - include_dirs += [ - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/cutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxlog", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/common/dfxutil", - "${THIRD_PARTY}/perf_include/hiviewdfx/hilog/include", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/common", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/nonlinux", - "${THIRD_PARTY}/perf_include/hiviewdfx/faultloggerd/interfaces/innerkits/unwinder/include", - ] - cflags = [ "-Wno-inconsistent-missing-override", "-Dprivate=public", #allow test code access private members diff --git a/trace_streamer/test/resource/Mmap.htrace b/trace_streamer/test/resource/Mmap.htrace old mode 100755 new mode 100644 diff --git a/trace_streamer/test/resource/ebpf_bio.htrace b/trace_streamer/test/resource/ebpf_bio.htrace old mode 100755 new mode 100644 diff --git a/trace_streamer/test/resource/hiprofiler_data_ability.htrace b/trace_streamer/test/resource/hiprofiler_data_ability.htrace old mode 100755 new mode 100644 diff --git a/trace_streamer/test/resource/hiprofiler_data_perf.htrace b/trace_streamer/test/resource/hiprofiler_data_perf.htrace old mode 100755 new mode 100644 diff --git a/trace_streamer/test/resource/htrace_perf_no_profiler_header.bin b/trace_streamer/test/resource/htrace_perf_no_profiler_header.bin old mode 100755 new mode 100644 diff --git a/trace_streamer/test/resource/perfCompressed.data b/trace_streamer/test/resource/perfCompressed.data old mode 100755 new mode 100644