+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__BEGIN_DECLS
+
+constexpr uint64_t BYTRACE_TAG_NEVER = 0; // This tag is never enabled.
+constexpr uint64_t BYTRACE_TAG_ALWAYS = (1ULL << 0); // This tag is always enabled.
+constexpr uint64_t BYTRACE_TAG_OHOS = (1ULL << 30); // OHOS generic tag.
+constexpr uint64_t BYTRACE_TAG_ABILITY_MANAGER = (1ULL << 31); // Ability Manager tag.
+constexpr uint64_t BYTRACE_TAG_ZCAMERA = (1ULL << 32); // Camera module tag.
+constexpr uint64_t BYTRACE_TAG_ZMEDIA = (1ULL << 33); // Media module tag.
+constexpr uint64_t BYTRACE_TAG_ZIMAGE = (1ULL << 34); // Image module tag.
+constexpr uint64_t BYTRACE_TAG_ZAUDIO = (1ULL << 35); // Audio module tag.
+constexpr uint64_t BYTRACE_TAG_DISTRIBUTEDDATA = (1ULL << 36); // Distributeddata manager module tag.
+constexpr uint64_t BYTRACE_TAG_MDFS = (1ULL << 37); // Mobile distributed file system tag.
+constexpr uint64_t BYTRACE_TAG_GRAPHIC_AGP = (1ULL << 38); // Graphic module tag.
+constexpr uint64_t BYTRACE_TAG_ACE = (1ULL << 39); // ACE development framework tag.
+constexpr uint64_t BYTRACE_TAG_NOTIFICATION = (1ULL << 40); // Notification module tag.
+constexpr uint64_t BYTRACE_TAG_APP = (1ULL << 62); // App tag.
+
+constexpr uint64_t BYTRACE_TAG_LAST = BYTRACE_TAG_APP;
+constexpr uint64_t BYTRACE_TAG_NOT_READY = (1ULL << 63); // Reserved for initialization.
+constexpr uint64_t BYTRACE_TAG_VALID_MASK = ((BYTRACE_TAG_LAST - 1) | BYTRACE_TAG_LAST);
+
+#ifndef BYTRACE_TAG
+#define BYTRACE_TAG BYTRACE_TAG_NEVER
+#elif BYTRACE_TAG > BYTRACE_TAG_VALID_MASK
+#error BYTRACE_TAG must be defined to be one of the tags defined in bytrace.h
+#elif BYTRACE_TAG < BYTRACE_TAG_OHOS
+#error BYTRACE_TAG must be defined to be one of the tags defined in bytrace.h
+#endif
+
+#define RELEASE_LEVEL 0X01
+#define DEBUG_LEVEL 0X02
+
+#ifndef TRACE_LEVEL
+#define TRACE_LEVEL RELEASE
+#endif
+
+/**
+ * Update trace label when your process has started.
+ */
+void UpdateTraceLabel();
+
+/**
+ * Track the beginning of a context.
+ */
+void StartTrace(uint64_t label, const std::string& value, float limit = -1);
+void StartTraceDebug(uint64_t label, const std::string& value, float limit = -1);
+/**
+ * Track the end of a context.
+ */
+void FinishTrace(uint64_t label, const std::string& value);
+void FinishTraceDebug(uint64_t label, const std::string& value);
+/**
+ * Track the beginning of an asynchronous event.
+ */
+void StartAsyncTrace(uint64_t label, const std::string& value, int32_t taskId, float limit = -1);
+void StartAsyncTraceDebug(uint64_t label, const std::string& value, int32_t taskId, float limit = -1);
+
+/**
+ * Track the end of an asynchronous event.
+ */
+void FinishAsyncTrace(uint64_t label, const std::string& value, int32_t taskId);
+void FinishAsyncTraceDebug(uint64_t label, const std::string& value, int32_t taskId);
+
+/**
+ * Track the middle of a context. Match the previous function of StartTrace before it.
+ */
+void MiddleTrace(uint64_t label, const std::string& beforeValue, const std::string& afterValue);
+void MiddleTraceDebug(uint64_t label, const std::string& beforeValue, const std::string& afterValue);
+
+/**
+ * Track the 64-bit integer counter value.
+ */
+void CountTrace(uint64_t label, const std::string& name, int64_t count);
+void CountTraceDebug(uint64_t label, const std::string& name, int64_t count);
+
+__END_DECLS
+#ifdef __cplusplus
+}
+#endif
+#endif // DEVELOPTOOLS_INTERFACES_INNERKITS_BYTRACE_INCLUDE_BYTRACE_H
diff --git a/interfaces/kits/js/@ohos.bytrace.d.ts b/interfaces/kits/js/@ohos.bytrace.d.ts
new file mode 100644
index 0000000..8776352
--- /dev/null
+++ b/interfaces/kits/js/@ohos.bytrace.d.ts
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+/**
+ * Provides interfaces to generate {@code ByTrace} logs.
+ *
+ * This class traces the start, end, and value changes of key processes that last for at least 3 ms.
+ *
+ *
Example:
+ * To trace a name verification that is expected to complete within 5 ms:
+ *
{@code
+ * Bytrace.startTrace("checkName", "5");
+ * Bytrace.finishTrace("checkName");
+ * }
+ * To trace the number of layers, which is 3:
+ * {@code
+ * Bytrace.count("curLayer", 3);
+ * }
+ *
+ * Each {@code startTrace} matches one {@code finishTrace}, and they must have the same value.
+ *
+ * @since 1
+ */
+declare namespace bytrace {
+ /**
+ * Updates the trace label when your process has started.
+ */
+ function updateTraceLabel(): void;
+
+ /**
+ * Records a trace with the expected completion time and marks it as the start of a task.
+ *
+ * This method is invoked at the start of a transaction to indicate that a task whose name is specified by
+ * {@code value} has started. The {@link #finishTrace(String)} method using the same {@code value} must be
+ * invoked at the end of the transaction.
+ *
+ * @param value Indicates the operation name.
+ * @param limit Indicates the expected time required for completing the operation, in milliseconds.
+ */
+ function startTrace(value: string, limit: number): void;
+
+ /**
+ * Track the middle of a context. Match the previous function of StartTrace before it.
+ *
+ * @param beforeValue Indicates the matched startTrace vlaue.
+ * @param afterValue Indicates the matched finishTrace value.
+ */
+ function middleTrace(beforeValue: string, afterValue: string): void;
+
+ /**
+ * Records a trace and marks it as the end of a task.
+ *
+ * This method is invoked at the end of a transaction to indicate that a task whose name is specified by
+ * {@code value} has ended. This method must be invoked after the {@link #startTrace(String, float)} or
+ * {@link #startTrace(String)} method is invoked.
+ *
+ * @param value Indicates the operation name. It must be the same as the {@code value} of
+ * {@link #startTrace(String, float)} or {@link #startTrace(String)}.
+ *
+ */
+ function finishTrace(value: string): void;
+
+ /**
+ * Writes a async trace message and mark as start spot. The name and cookie
+ * used to begin an event must be used to end it.
+ *
+ * @param value Message content.
+ * @param taskId Unique identifier for distinguishing simultaneous events.
+ * @param limit It is expected that the operation will be completed within the specified time period.
+ */
+ function startAsyncTrace(value: string, taskId: number, limit: number): void;
+
+ /**
+ * Writes a async trace message and mark as start spot. The name and cookie
+ * used to begin an event must be used to end it.
+ *
+ * @param value Message content.
+ * @param taskId Unique identifier for distinguishing simultaneous events.
+ */
+ function finishAsyncTrace(value: string, taskId: number): void;
+
+ /**
+ * Records a trace for generating a count, such as clock pulse and the number of layers.
+ *
+ * @param name Indicates the operation name.
+ * @param count Indicates the count of the operation.
+ */
+ function countTrace(name: string, count: number): void;
+}
+export default bytrace;
diff --git a/ohos.build b/ohos.build
new file mode 100755
index 0000000..f898d94
--- /dev/null
+++ b/ohos.build
@@ -0,0 +1,26 @@
+{
+ "subsystem": "developtools",
+ "parts": {
+ "bytrace_standard": {
+ "module_list": [
+ "//developtools/bytrace_standard/interfaces/innerkits/native:bytrace_core",
+ "//developtools/bytrace_standard/bin:bytrace_target"
+ ],
+ "inner_kits": [
+ {
+ "type": "so",
+ "name": "//developtools/bytrace_standard/interfaces/innerkits/native:bytrace_core",
+ "header": {
+ "header_files": [
+ "bytrace.h"
+ ],
+ "header_base": "//developtools/bytrace_standard/interfaces/innerkits/native/include"
+ }
+ }
+ ],
+ "test_list": [
+ "//developtools/bytrace_standard/bin/test:moduletest"
+ ]
+ }
+ }
+}
diff --git a/script/bytrace_capture.bat b/script/bytrace_capture.bat
new file mode 100755
index 0000000..ce59ffe
--- /dev/null
+++ b/script/bytrace_capture.bat
@@ -0,0 +1,21 @@
+@rem Copyright (C) 2021 Huawei Device Co., Ltd.
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+
+@echo off
+hdc shell "echo > /sys/kernel/debug/tracing/trace"
+hdc shell "echo 4096 > /d/tracing/saved_cmdlines_size"
+hdc shell "bytrace -t 10 -b 4096 --overwrite ohos zimage zmedia zcamera zaudio ability distributeddatamgr sched freq irq workq rs idle load disk pagecache memreclaim > /data/mynewtrace.ftrace"
+hdc shell "echo > /sys/kernel/debug/tracing/trace"
+hdc shell "sed -i '1,2d' /data/mynewtrace.ftrace"
+hdc pull /data/mynewtrace.ftrace .
+pause
diff --git a/script/bytrace_multi.py b/script/bytrace_multi.py
new file mode 100755
index 0000000..3518fb0
--- /dev/null
+++ b/script/bytrace_multi.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2021 Huawei Device Co., Ltd.
+# 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.
+
+import codecs
+import sys
+import os
+import re
+import time
+
+files = []
+trace_regex = "\s*(.*?)-(\d+?)\s+\(\s*(\d+?)\)\s+\[\d+\]\s+(.*?)\s+(.*?):\s+"
+all_traces_dict = {} # {"deviceName": [(timestamp, line) ...]}
+all_real_time_dict = {}
+default_real_time = 7983849599000 # 2222-12-31 23:59:59
+
+def compare_timestamp(time1, time2):
+ return float(time1) < float(time2)
+
+def read_files(file, devices_name):
+ traces = []
+ with codecs.open(file, 'r', encoding='utf-8') as fp:
+ for line in fp:
+ if line.find("binder_transaction") > -1 \
+ or line.find("tracing_mark_write") > -1:
+ line = line.replace("\n", "")
+ trace_match = re.match(trace_regex, line)
+ if trace_match:
+ traces.append((float(trace_match.group(5)), line))
+ if line.find("realtime_ts") > -1:
+ time_regex = trace_regex + \
+ "tracing_mark_write:\s+trace_event_clock_sync: realtime_ts=(.*)"
+ time_match = re.match(time_regex, line)
+ all_real_time_dict[devices_name] = { \
+ "realtime_ts": int(time_match.group(6)), \
+ "timestamp": float(time_match.group(5))}
+ if (not all_real_time_dict.__contains__(devices_name)) and traces:
+ line = traces[-1][1]
+ trace_match = re.match(trace_regex, line)
+ all_real_time_dict[devices_name] = { \
+ "realtime_ts": default_real_time, \
+ "timestamp": float(trace_match.group(5))}
+ return traces
+
+def handle_option():
+ if len(sys.argv) < 2:
+ print("eg: python bytrace_multi.py file1.ftrace file2.ftrace ...")
+ exit(0)
+ for i in range(len(sys.argv)):
+ if i == 0:
+ continue
+ if sys.argv[i] == "-h" or sys.argv[i] == "--help":
+ print("eg: python bytrace_multi.py file1.ftrace file2.ftrace ...")
+ exit(0)
+ elif not os.path.exists(sys.argv[i]):
+ print("Warning: {} is not found.".format(sys.argv[i]))
+ else:
+ files.append(sys.argv[i])
+
+def change_trace_time(all_trace_list, \
+ base_real_time, \
+ base_time_stamp, \
+ target_device):
+ target_real_time = all_real_time_dict[target_device]["realtime_ts"]
+ target_time_stamp = all_real_time_dict[target_device]["timestamp"]
+ if not target_real_time == default_real_time:
+ diff_real_time = float(target_real_time - base_real_time) / 1000
+ target_time_stamp_ = base_time_stamp + diff_real_time
+ diff_time = target_time_stamp - target_time_stamp_
+ else:
+ # If the file does not have realtime, the difference is 0.5s.
+ diff_real_time = 0.5
+ target_time_stamp_ = base_time_stamp + diff_real_time
+ diff_time = target_time_stamp - target_time_stamp_
+ traces = all_traces_dict[target_device]
+ for mtuple in traces:
+ timestamp = float(mtuple[0])
+ line = mtuple[1]
+ timestamp_ = "{:.6f}".format(timestamp - diff_time)
+ line_ = target_device + \
+ line.replace("{:.6f}".format(timestamp), str(timestamp_))
+ all_trace_list.append((timestamp_, line_))
+
+def write_to_file(data, file_name):
+ with codecs.open(file_name, 'w+', encoding='utf-8') as fp:
+ fp.write("# tracer: nop\n")
+ fp.write("#\n")
+ fp.write("# _-----=> irqs-off\n")
+ fp.write("# / _----=> need-resched\n")
+ fp.write("# | / _---=> hardirq/softirq\n")
+ fp.write("# || / _--=> preempt-depth\n")
+ fp.write("# ||| / delay\n")
+ fp.write("# TASK-PID TGID CPU# |||| TIMESTAMP FUNCTION\n")
+ fp.write("# | | | | |||| | |\n")
+ for mtuple in data:
+ fp.write(mtuple[1])
+ fp.write("\n")
+
+def main():
+ handle_option()
+ if len(files) == 0:
+ exit(-1)
+
+ for i, val in enumerate(files):
+ device_name = "[device_{}]".format(str(i))
+ all_traces_dict[device_name] = read_files(val, device_name)
+
+ all_time_sorted_list = sorted(all_real_time_dict.items(), key=lambda \
+ all_real_time_dict: all_real_time_dict[1]["realtime_ts"])
+ base_real_time = all_time_sorted_list[0][1]["realtime_ts"]
+ base_time_stamp = all_time_sorted_list[0][1]["timestamp"]
+ all_trace_list = [] # [(timestamp, line)]
+ for mtuple in all_time_sorted_list:
+ target_device = mtuple[0]
+ change_trace_time(all_trace_list, \
+ base_real_time, \
+ base_time_stamp, \
+ target_device)
+ # Sort by timestamp from small to large
+ all_trace_sorted_list = sorted(all_trace_list, key=lambda x: x[0])
+ curtime = time.strftime("%Y%m%d_%H%M%S", time.localtime())
+ write_to_file(all_trace_sorted_list, "multi_trace_"+str(curtime)+".ftrace")
+
+if __name__ == '__main__':
+ main()