mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/profiler/parser/ascend_msprof_generator.py

@@ -0,0 +1,199 @@
+# Copyright 2023 Huawei Technologies 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.
+# ============================================================================
+"""msprof data generate model"""
+import csv
+import fnmatch
+import os
+
+import numpy as np
+
+
+class AscendMsprofDataGenerator:
+    """Generate ascend data from files."""
+
+    def __init__(self, source_path):
+        self.source_path = source_path
+        self.op_summary = None
+        self.op_statistic = None
+        self.steptrace = []
+
+        self.invalid_index = 1000
+        self.op_summary_basis_name = {
+            'Model ID': {'index': self.invalid_index, 'dtype': ('Model ID', int)},
+            'Task ID': {'index': self.invalid_index, 'dtype': ('Task ID', int)},
+            'Stream ID': {'index': self.invalid_index, 'dtype': ('Stream ID', int)},
+            'Op Name': {'index': self.invalid_index, 'dtype': ('Op Name', object)},
+            'OP Type': {'index': self.invalid_index, 'dtype': ('Op Type', object)},
+            'Task Type': {'index': self.invalid_index, 'dtype': ('Task Type', object)},
+            'Task Start Time(us)': {'index': self.invalid_index, 'dtype': ('Task Start Time', float)},
+            'Task Duration(us)': {'index': self.invalid_index, 'dtype': ('Task Duration', float)},
+            'Task Wait Time(us)': {'index': self.invalid_index, 'dtype': ('Task Wait Time', float)},
+            'Input Shapes': {'index': self.invalid_index, 'dtype': ('Input Shapes', object)},
+            'Input Data Types': {'index': self.invalid_index, 'dtype': ('Input Data Types', object)},
+            'Input Formats': {'index': self.invalid_index, 'dtype': ('Input Formats', object)},
+            'Output Shapes': {'index': self.invalid_index, 'dtype': ('Output Shapes', object)},
+            'Output Data Types': {'index': self.invalid_index, 'dtype': ('Output Data Types', object)},
+            'Output Formats': {'index': self.invalid_index, 'dtype': ('Output Formats', object)},
+        }
+        self.op_summary_extend_name = {
+            'vector_fops': {'index': self.invalid_index, 'dtype': ('vector_fops', float)},
+            'cube_fops': {'index': self.invalid_index, 'dtype': ('cube_fops', float)},
+        }
+        self.op_summary_name = None
+
+        self.op_statistic_name = {
+            'OP Type': {'index': self.invalid_index, 'dtype': ('Op Type', object)},
+            'Count': {'index': self.invalid_index, 'dtype': ('Count', int)},
+            'Total Time(us)': {'index': self.invalid_index, 'dtype': ('Total Time', float)},
+        }
+
+        self.steptrace_name = {
+            'Iteration ID': {'index': self.invalid_index, 'dtype': ('Iteration ID', int)},
+            'FP Start(us)': {'index': self.invalid_index, 'dtype': ('FP Start', float)},
+            'BP End(us)': {'index': self.invalid_index, 'dtype': ('BP End', float)},
+            'Iteration End(us)': {'index': self.invalid_index, 'dtype': ('Iteration End', float)},
+            'Iteration Time(us)': {'index': self.invalid_index, 'dtype': ('Iteration Time', float)},
+            'FP to BP Time(us)': {'index': self.invalid_index, 'dtype': ('FP to BP Time', float)},
+            'Iteration Refresh(us)': {'index': self.invalid_index, 'dtype': ('Iteration Refresh', float)},
+            'Data Aug Bound(us)': {'index': self.invalid_index, 'dtype': ('Data Aug Bound', float)},
+            'Model ID': {'index': self.invalid_index, 'dtype': ('Model ID', int)},
+        }
+
+    @staticmethod
+    def find_files(directory, pattern):
+        """Find files with feature 'pattern' from the directory"""
+
+        for root, _, files in os.walk(directory):
+            files.sort(key=lambda x: os.path.getctime(os.path.join(directory, x)))
+            for basename in files:
+                if fnmatch.fnmatch(basename, pattern):
+                    filename = os.path.join(root, basename)
+                    yield filename
+
+    def link_index_with_name(self, header, name_dict):
+        """link index with row name"""
+        for index, value in enumerate(header):
+            if value in name_dict:
+                name_dict[value]['index'] = index
+        for value in name_dict.values():
+            if value['index'] == self.invalid_index:
+                return False
+        return True
+
+    def parse(self):
+        """read msprof data generate DataFrame data"""
+        self._read_op_summary()
+
+        self._read_op_statistic()
+
+        self._read_steptrace()
+
+        return self.op_summary, self.op_statistic, self.steptrace
+
+    def _read_op_summary(self):
+        """read op summary to memory"""
+        op_summary = []
+        for file in self.find_files(self.source_path, "op_summary*.csv"):
+            with open(file, newline='') as csvfile:
+                iteration = int(file.split('_')[-1].split('.')[0])
+                reader = csv.reader(csvfile, delimiter=',', quotechar='"')
+                header = next(reader)
+                self.link_index_with_name(header, self.op_summary_basis_name)
+                extend_flag = self.link_index_with_name(header, self.op_summary_extend_name)
+                if extend_flag:
+                    self.op_summary_name = {**self.op_summary_basis_name, **self.op_summary_extend_name}
+                else:
+                    self.op_summary_name = self.op_summary_basis_name
+                self.op_summary_name['Iteration ID'] = {'index': -1, 'dtype': ('Iteration ID', object)}
+                for row in reader:
+                    row = [row[index.get('index')] for index in self.op_summary_name.values()]
+                    row[self.op_summary_name['Iteration ID']['index']] = iteration
+                    row = ['0' if i == 'N/A' else i for i in row]
+                    op_summary.append(tuple(row))
+
+        op_summary_dt = np.dtype([value['dtype'] for value in self.op_summary_name.values()])
+
+        self.op_summary = np.array(op_summary, dtype=op_summary_dt)
+        self.op_summary['Task Start Time'] = self.op_summary['Task Start Time'] * 1e-3
+        self.op_summary['Task Duration'] = self.op_summary['Task Duration'] * 1e-3
+        self.op_summary['Task Wait Time'] = self.op_summary['Task Wait Time'] * 1e-3
+
+    def _read_op_statistic(self):
+        """read op statistic to memory"""
+        op_statistic = []
+        for file in self.find_files(self.source_path, "op_statistic*.csv"):
+            with open(file, newline='') as csvfile:
+                reader = csv.reader(csvfile, delimiter=',', quotechar='"')
+                header = next(reader)
+                self.link_index_with_name(header, self.op_statistic_name)
+                for row in reader:
+                    row = [row[index.get('index')] for index in self.op_statistic_name.values()]
+                    row = ['0' if i == 'N/A' else i for i in row]
+                    op_statistic.append(tuple(row))
+
+        op_statistic_dt = np.dtype([value['dtype'] for value in self.op_statistic_name.values()])
+        self.op_statistic = np.array(op_statistic, dtype=op_statistic_dt)
+        self.op_statistic['Total Time'] = self.op_statistic['Total Time'] * 1e-3
+
+    def _read_steptrace(self):
+        """read steptrace to memory"""
+        steptrace = []
+        header = []
+        for file in self.find_files(self.source_path, "step_trace*.csv"):
+            with open(file, newline='') as csvfile:
+                reader = csv.reader(csvfile, delimiter=',', quotechar='"')
+                header = next(reader)
+                self.link_index_with_name(header, self.steptrace_name)
+                for row in reader:
+                    rows = [row[index.get('index')] for index in self.steptrace_name.values()]
+                    if row[9:]:
+                        rows.extend(row[9:len(header)])
+                    if len(rows) < len(header):
+                        rows.extend([0 for _ in range(len(header) - len(rows))])
+                    rows = ['0' if i == 'N/A' else i for i in rows]
+                    steptrace.append(tuple(rows))
+            break
+
+        hccl_data = self.op_summary[(self.op_summary['Task Type'] == 'HCCL') & (self.op_summary['Iteration ID'] == 1)][
+            ['Task ID', 'Stream ID', 'Op Name']]
+
+        index = len(self.steptrace_name)
+        for name in hccl_data:
+            if index >= len(header):
+                break
+            name = f"stream_{name['Stream ID']}_{name['Task ID']}_{name['Op Name']}"
+            self.steptrace_name[name] = {'index': index, 'dtype': (name, float)}
+            index += 1
+            self.steptrace_name[f'{name} duration'] = {'index': index, 'dtype': (f'{name} duration', float)}
+            index += 1
+
+        for i in range(len(self.steptrace_name), len(header), 2):
+            name = f'hccl_{i}'
+            self.steptrace_name[name] = {'index': i, 'dtype': (name, float)}
+            self.steptrace_name[f'{name} duration'] = {'index': i+1, 'dtype': (f'{name} duration', float)}
+
+        steptrace_dt = np.dtype([value['dtype'] for value in self.steptrace_name.values()])
+
+        self.steptrace = np.array(steptrace, dtype=steptrace_dt)
+        self.steptrace['FP Start'] = self.steptrace['FP Start'] * 1e-3
+        self.steptrace['BP End'] = self.steptrace['BP End'] * 1e-3
+        self.steptrace['Iteration End'] = self.steptrace['Iteration End'] * 1e-3
+        self.steptrace['Iteration Time'] = self.steptrace['Iteration Time'] * 1e-3
+        self.steptrace['FP to BP Time'] = self.steptrace['FP to BP Time'] * 1e-3
+        self.steptrace['Iteration Refresh'] = self.steptrace['Iteration Refresh'] * 1e-3
+        self.steptrace['Data Aug Bound'] = self.steptrace['Data Aug Bound'] * 1e-3
+
+        for name in self.steptrace.dtype.names[9:]:
+            self.steptrace[name] = self.steptrace[name] * 1e-3

mindspore/profiler/parser/ascend_op_generator.py

@@ -0,0 +1,276 @@
+# Copyright 2023 Huawei Technologies 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.
+# ============================================================================
+"""op analyse model"""
+import csv
+import json
+import logging
+import os
+import stat
+
+import numpy as np
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+class AscendOPGenerator:
+    """Generate ascend op data from DataFrame."""
+
+    def __init__(self, op_summary, op_statistic, dynamic_status=False):
+        self.op_summary = op_summary
+        self.op_statistic = op_statistic
+        self.dynamic_status = dynamic_status
+        self.op_detail = None
+        self.op_type = None
+        self.aicpu_detail = None
+        self.framework_raw = None
+        self.output_timeline_data = None
+
+        self.op_detail_dt = np.dtype(
+            [('full_op_name', object), ('task_duration', float), ('execution_frequency', int), ('task_type', object)])
+
+        self.op_type_dt = np.dtype(
+            [('op_type', object), ('total_time', float), ('execution_frequency', int), ('percent', float)])
+
+        self.aicpu_detail_dt = np.dtype(
+            [('serial_number', int), ('op_type', object), ('total_time', float), ('dispatch_time', float),
+             ('execution_time', float), ('run_start', float), ('run_end', float)])
+
+        self.framwork_raw_dt = np.dtype(
+            [('task_id', int), ('stream_id', int), ('block_dim', int), ('full_op_name', object), ('op_name', object),
+             ('op_type', object), ('subgraph', object), ('op_info', object), ('model_id', int),
+             ('kernel_type', object)])
+
+    def parse(self):
+        """
+        Analyse op summary op statistic generate op data.
+        """
+
+        # aicore intermediation detail
+        self.op_detail = self._parse_op_detail(self.op_summary)
+
+        # aicore intermediation type
+        self.op_type = self._parse_op_type(self.op_statistic)
+
+        # aicpu_intermediation
+        self.aicpu_detail = self._parse_aicpu_detail(self.op_summary)
+
+        # framwork_raw
+        self.framework_raw = self._parse_framework_raw(self.op_summary)
+
+        self.output_timeline_data = self.op_summary[self.op_summary['Task Type'] == 'AI_CORE'][
+            ['Op Name', 'Stream ID', 'Task Start Time', 'Task Duration']]
+
+    def write(self, aicore_intermediate_detail_path, aicore_intermediate_type_path, aicpu_intermediate_detail_path,
+              framework_raw_path, output_timeline_data_path):
+        """
+        Write the op_intermediate_detail.csv op_intermediate_type.csv aicpu_intermediate.csv and framework_raw.csv.
+
+        Args:
+            aicore_intermediate_detail_path(str): op_intermediate_detail.csv path.
+            aicore_intermediate_type_path(str): op_intermediate_type.csv path.
+            aicpu_intermediate_detail_path(str): aicpu_intermediate.csv path.
+            framework_raw_path: framework_raw.csv path
+            output_timeline_data_path : output_timeline_data.txt path
+        """
+        # aicore intermediation detail
+        if self.op_detail.shape[0] != 0:
+            try:
+                with os.fdopen(os.open(aicore_intermediate_detail_path,
+                                       os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                               'w') as aicore_detail:
+                    writer = csv.writer(aicore_detail)
+                    writer.writerow(self.op_detail.dtype.names)
+                    writer.writerows(self.op_detail.tolist())
+            except (IOError, OSError) as err:
+                logging.critical('Errot occurred when write aicore detail file: %s', err)
+                raise ProfilerIOException() from err
+            if os.path.exists(aicore_intermediate_detail_path):
+                os.chmod(aicore_intermediate_detail_path, stat.S_IREAD | stat.S_IWRITE)
+
+        # aicore intermediation type
+        if self.op_type.shape[0] != 0:
+            try:
+                with os.fdopen(os.open(aicore_intermediate_type_path,
+                                       os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                               'w') as aicore_type:
+                    writer = csv.writer(aicore_type)
+                    writer.writerow(self.op_type.dtype.names)
+                    writer.writerows(self.op_type.tolist())
+            except (IOError, OSError) as err:
+                logging.critical('Errot occurred when write aicore type file: %s', err)
+                raise ProfilerIOException() from err
+            if os.path.exists(aicore_intermediate_type_path):
+                os.chmod(aicore_intermediate_type_path, stat.S_IREAD | stat.S_IWRITE)
+
+        # aicpu_intermediation
+        if self.aicpu_detail.shape[0] != 0:
+            try:
+                with os.fdopen(os.open(aicpu_intermediate_detail_path,
+                                       os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                               'w') as aicpu_type:
+                    writer = csv.writer(aicpu_type)
+                    writer.writerow(self.aicpu_detail.dtype.names)
+                    writer.writerows(self.aicpu_detail.tolist())
+            except (IOError, OSError) as err:
+                logging.critical('Errot occurred when write aicpu detail file: %s', err)
+                raise ProfilerIOException()
+            if os.path.exists(aicpu_intermediate_detail_path):
+                os.chmod(aicpu_intermediate_detail_path, stat.S_IREAD | stat.S_IWRITE)
+
+        # framwork_raw
+        if self.framework_raw.shape[0] != 0:
+            try:
+                with os.fdopen(os.open(framework_raw_path,
+                                       os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                               'w') as framework:
+                    writer = csv.writer(framework)
+                    writer.writerow(self.framework_raw.dtype.names)
+                    writer.writerows(self.framework_raw.tolist())
+            except (IOError, OSError) as err:
+                logging.critical('Errot occurred when write framework file: %s', err)
+                raise ProfilerIOException() from err
+            if os.path.exists(framework_raw_path):
+                os.chmod(framework_raw_path, stat.S_IREAD | stat.S_IWRITE)
+
+        # output_timeline_data
+        if self.output_timeline_data.shape[0] != 0 and output_timeline_data_path:
+            try:
+                with os.fdopen(os.open(output_timeline_data_path,
+                                       os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                               'w') as output_timeline_data:
+                    writer = csv.writer(output_timeline_data)
+                    writer.writerow(['op_name', 'stream_id', 'start_time(us)', 'duration(ms)'])
+                    writer.writerows(self.output_timeline_data.tolist())
+            except (IOError, OSError) as err:
+                logging.critical('Error occurred when write output timeline data file: %s', err)
+                raise ProfilerIOException() from err
+            if os.path.exists(aicpu_intermediate_detail_path):
+                os.chmod(aicpu_intermediate_detail_path, stat.S_IREAD | stat.S_IWRITE)
+
+    def _parse_op_detail(self, op_summary):
+        """
+        Analyse op summary generate op detail data.
+
+        Args:
+            op_summary(DataFrame): op summary data.
+        """
+        groups, index, inverse, counts = np.unique(op_summary['Op Name'], return_index=True, return_inverse=True,
+                                                   return_counts=True)
+
+        op_detail = np.empty((len(groups),), dtype=self.op_detail_dt)
+        op_detail['full_op_name'] = groups
+        op_detail['task_type'] = op_summary[index]['Task Type']
+        nonzero_duration = np.bincount(inverse) != 0
+        op_detail['task_duration'] = np.where(nonzero_duration,
+                                              np.bincount(inverse, weights=op_summary['Task Duration']) / np.bincount(
+                                                  inverse), 0)
+        op_detail['execution_frequency'] = counts
+
+        return op_detail
+
+    def _parse_op_type(self, op_statistic):
+        """
+        Analyse op statistic generate op type data.
+
+        Args:
+            op_statistic(DataFrame): op statistic data.
+        """
+
+        groups, _, inverse, _ = np.unique(op_statistic['Op Type'], return_index=True, return_inverse=True,
+                                          return_counts=True)
+
+        op_type = np.empty((len(groups),), dtype=self.op_type_dt)
+        op_type['op_type'] = groups
+        op_type['total_time'] = np.bincount(inverse, weights=op_statistic['Total Time'])
+        op_type['execution_frequency'] = np.bincount(inverse, weights=op_statistic['Count'])
+        op_type['percent'] = op_type['total_time'] / np.sum(op_statistic['Total Time']) if np.sum(
+            op_statistic['Total Time']) != 0 else 0
+
+        return op_type
+
+    def _parse_aicpu_detail(self, op_summary):
+        """
+        Analyse op summary generate aicpu detail data.
+
+        Args:
+            op_summary(DataFrame): op summary data.
+        """
+
+        op_summary = op_summary[op_summary['Task Type'] == 'AI_CPU']
+
+        aicpu_detail = np.empty((len(op_summary),), dtype=self.aicpu_detail_dt)
+
+        aicpu_detail['serial_number'] = [i for i in range(1, op_summary.shape[0] + 1)]
+        aicpu_detail['op_type'] = op_summary['Op Type']
+        aicpu_detail['total_time'] = op_summary['Task Duration'] + op_summary['Task Wait Time']
+        aicpu_detail['dispatch_time'] = op_summary['Task Wait Time']
+        aicpu_detail['execution_time'] = op_summary['Task Duration']
+        aicpu_detail['run_start'] = op_summary['Task Start Time']
+        aicpu_detail['run_end'] = aicpu_detail['run_start'] + aicpu_detail['total_time']
+
+        return aicpu_detail
+
+    def _parse_framework_raw(self, op_summary):
+        """
+        Analyse op summary generate op framework data.
+
+        Args:
+            op_summary(DataFrame): op summary data.
+        """
+
+        def op_info_analyse(row):
+            """generate op info data"""
+            input_shapes = row['Input Shapes'].replace('"', '').split(';')
+            input_data_types = row['Input Data Types'].replace('_', '').split(';')
+            input_formats = row['Input Formats'].replace('_', '').split(';')
+            output_shapes = row['Output Shapes'].replace('"', '').split(';')
+            output_data_types = row['Output Data Types'].replace('_', '').split(';')
+            output_formats = row['Output Formats'].replace('_', '').split(';')
+            op_info = {}
+            if isinstance(input_shapes, list) and len(input_shapes) >= 1 and input_shapes[0] != '':
+                input_size = len(input_shapes)
+                for i in range(input_size):
+                    op_info[f'Input_{i}'] = {
+                        'format': input_formats[i],
+                        'data_type': input_data_types[i],
+                        'shape': input_shapes[i]
+                    }
+            if isinstance(output_shapes, list) and len(output_shapes) >= 1 and output_shapes[0] != '':
+                output_size = len(output_shapes)
+                for i in range(output_size):
+                    op_info[f'Output_{i}'] = {
+                        'format': output_formats[i],
+                        'data_type': output_data_types[i],
+                        'shape': output_shapes[i]
+                    }
+            return json.dumps(op_info)
+
+        if self.dynamic_status:
+            index = list(range(op_summary.shape[0]))
+        else:
+            _, index, _, _ = np.unique(op_summary['Op Name'], return_index=True, return_inverse=True,
+                                       return_counts=True)
+        framwork_raw = np.empty((len(index),), dtype=self.framwork_raw_dt)
+
+        framwork_raw['task_id'] = op_summary[index]['Task ID']
+        framwork_raw['stream_id'] = op_summary[index]['Stream ID']
+        framwork_raw['full_op_name'] = op_summary[index]['Op Name']
+        framwork_raw['op_name'] = [x[-1] for x in np.char.split(op_summary[index]['Op Name'].astype(str), sep='/')]
+        framwork_raw['op_type'] = op_summary[index]['Op Type']
+        framwork_raw['subgraph'] = [x[0] for x in np.char.split(op_summary[index]['Op Name'].astype(str), sep='/')]
+        framwork_raw['op_info'] = [op_info_analyse(x) for x in op_summary[index]]
+        framwork_raw['model_id'] = op_summary[index]['Model ID']
+        framwork_raw['kernel_type'] = op_summary[index]['Task Type']
+
+        return framwork_raw

mindspore/profiler/parser/ascend_steptrace_generator.py

@@ -0,0 +1,94 @@
+# Copyright 2023 Huawei Technologies 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.
+# ============================================================================
+""""step analyse model"""
+import csv
+import logging
+import os
+import stat
+
+import numpy as np
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+class AscendStepTraceGenerator:
+    """Generate ascend steptrace data from DataFrame."""
+
+    def __init__(self, steptrace):
+        self.steptrace = steptrace
+        self.steptrace_detail = None
+
+        self.steptrace_detail_dt = [
+            ('step_num', object), ('start_point', np.int64), ('end_point', np.int64),
+            ('total', np.int64), ('fp_point', np.int64), ('bp_point', np.int64),
+            ('iteration_interval', np.int64), ('fp_and_bp', np.int64), ('tail', np.int64)
+        ]
+
+    def parse(self):
+        """Analyse the original steptrace data generate steptrace data."""
+        if not isinstance(self.steptrace, np.ndarray) or self.steptrace.shape[0] == 0 or not self.steptrace.tolist():
+            return
+        for name in self.steptrace.dtype.names[9::2]:
+            self.steptrace_detail_dt.append((name, np.int64))
+            self.steptrace_detail_dt.append((f'{name}_start_point', np.int64))
+            self.steptrace_detail_dt.append((f'{name}_end_point', np.int64))
+        self.steptrace_detail_dt = np.dtype(self.steptrace_detail_dt)
+        self.steptrace_detail = np.empty((len(self.steptrace),), dtype=self.steptrace_detail_dt)
+
+        unit = 1e+5
+        self.steptrace_detail['step_num'] = self.steptrace['Iteration ID']
+        self.steptrace_detail['start_point'] = (self.steptrace['FP Start'] - self.steptrace['Data Aug Bound']) * unit
+        self.steptrace_detail['end_point'] = self.steptrace['Iteration End'] * unit
+        self.steptrace_detail['total'] = (self.steptrace['Iteration Time'] + self.steptrace['Data Aug Bound']) * unit
+        self.steptrace_detail['fp_point'] = self.steptrace['FP Start'] * unit
+        self.steptrace_detail['bp_point'] = self.steptrace['BP End'] * unit
+        self.steptrace_detail['iteration_interval'] = self.steptrace['Data Aug Bound'] * unit
+        self.steptrace_detail['fp_and_bp'] = self.steptrace['FP to BP Time'] * unit
+        self.steptrace_detail['tail'] = self.steptrace['Iteration Refresh'] * unit
+
+        for name in self.steptrace.dtype.names[9::2]:
+            self.steptrace_detail[name] = self.steptrace[f'{name} duration'] * unit
+            self.steptrace_detail[f'{name}_start_point'] = self.steptrace[name] * unit
+            self.steptrace_detail[f'{name}_end_point'] = (self.steptrace[name] + self.steptrace[
+                f'{name} duration']) * unit
+
+        if self.steptrace_detail.shape[0] > 1:
+            avg_values = np.mean(self.steptrace_detail.tolist(), axis=0)
+            avg_row = np.array([tuple(avg_values)], dtype=self.steptrace_detail_dt)
+        else:
+            avg_row = self.steptrace_detail[0]
+        avg_row['step_num'] = '-'
+        self.steptrace_detail = np.append(self.steptrace_detail, avg_row)
+
+    def write(self, step_trace_intermediate_file_path):
+        """
+        Write the step_trace_raw.cs
+
+        Args:
+            step_trace_intermediate_file_path(str): step_trace_raw.csv path.
+
+        """
+        if not isinstance(self.steptrace_detail, np.ndarray):
+            return
+        try:
+            with os.fdopen(os.open(step_trace_intermediate_file_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR), 'w') as st:
+                writer = csv.writer(st)
+                writer.writerow(self.steptrace_detail.dtype.names)
+                writer.writerows(self.steptrace_detail.tolist())
+        except (IOError, OSError) as err:
+            logging.critical('Errot occurred when write step trace file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(step_trace_intermediate_file_path):
+            os.chmod(step_trace_intermediate_file_path, stat.S_IREAD | stat.S_IWRITE)