mindspore 2.0.0a0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/profiler/envprofiling.py

@@ -16,53 +16,63 @@
 import json
 import os
 import time
-from enum import Enum
 from mindspore.profiler import Profiler
-from mindspore.profiler.profiling import AICORE_METRICS_DICT
+from mindspore.profiler.profiling import AICORE_METRICS_DICT, DeviceSupportParam, ALWAYS_VALID_PARAM
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
 from mindspore.profiler.parser.integrator import DeviceTarget
 
 from mindspore import log as logger, context
 
 
-class DeviceSupportParam(Enum):
-    """The device target enum."""
-    CPU = ['start', 'output_path']
-    GPU = ['start', 'output_path', 'data_process', 'timeline_limit', 'sync_enable']
-    ASCEND = ['start', 'output_path', 'data_process', 'timeline_limit', 'profile_memory', 'parallel_strategy',
-              'profile_communication', 'aicore_metrics', 'l2_cache']
-
-
 def get_profiling_options():
     """Get profiling options."""
     try:
         options = json.loads(os.environ.get("MS_PROFILER_OPTIONS", "{}"))
     except json.JSONDecodeError:
-        return None
+        return {"error": True}
     return options
 
 
-def parse_device_support_param(options):
+def parse_device_support_param(origin_options, final_options, factor_s_to_us=1e6):
     """Parse platform support parameters."""
     device_target = context.get_context("device_target").upper()
-    for param in options.keys():
-        if param not in DeviceSupportParam.__getattr__(f'{device_target}').value:
-            logger.warning(f"The parameter '{param}' is not supported on {device_target} currently.")
+    op_time = final_options.get("op_time")
+    support_list = DeviceSupportParam.__getattr__(f'{device_target}').value
+    all_param = list(set(origin_options) | set(final_options))
+    for param in all_param:
+        if param not in support_list and param in list(origin_options.keys()):
+            logger.warning(f"[Profiler]'{param}' is an invalid param which doesn't work.")
+        if param in support_list:
+            if not op_time and param in origin_options.keys() and param not in ALWAYS_VALID_PARAM:
+                logger.warning(f"When op_time is set to False, the parameter '{param}' setting is invalid.")
+        if param not in support_list and final_options.get(param):
+            final_options.pop(param)
+
+    simple_options = {
+        "start_time": int(time.time() * factor_s_to_us),
+        "file_output_path": "",
+        "pid": os.getpid(),
+    }
+    final_options.update(simple_options)
+    return final_options
 
 
 def construct_profiling_options():
     """Construct profiling options to determine which profiling data should be collected."""
     profiling_options = get_profiling_options()
-    if profiling_options is None:
-        raise RuntimeError(
+    if profiling_options.get('error'):
+        error_config = {"start": False}
+        if os.getenv("MS_PROFILER_RUN_CONFIG"):
+            return error_config
+        os.environ["MS_PROFILER_RUN_CONFIG"] = json.dumps(error_config)
+        logger.error(
             "The format of MS_PROFILER_OPTIONS is incorrect. "
             "The MS_PROFILER_OPTIONS parameter configuration may refer to "
             "'https://www.mindspore.cn/mindinsight/docs/zh-CN/master/performance_profiling_ascend.html'."
         )
-    options = combine_profile_options(profiling_options)
-    conbine_options = parse_profiling_args(options)
+        return error_config
+    conbine_options = combine_profile_options(profiling_options)
     if conbine_options.get("start"):
-        parse_device_support_param(profiling_options)
         output_path = conbine_options.get("output_path")
         if not output_path:
             output_path = os.path.join(os.getcwd(), "data")
@@ -87,11 +97,20 @@ def parse_pubilc_args(options):
             "The 'data_process' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
             f" but got type {type(options.get('data_process'))}, it will be set to true.")
         options["data_process"] = True
-    if not isinstance(options.get("timeline_limit"), int):
+    if not isinstance(options.get("op_time"), bool):
+        logger.warning(
+            "The 'op_time' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
+            f" but got type {type(options.get('op_time'))}, it will be set to true.")
+        options["op_time"] = True
+    if isinstance(options.get("timeline_limit"), bool) or not isinstance(options.get("timeline_limit"), int):
         logger.warning(
             "The 'timeline_limit' parameter of the environment variable MS_PROFILE_OPTIONS must be int,"
             f" but got type {type(options.get('timeline_limit'))}, it will be set to 500.")
         options["timeline_limit"] = 500
+    if options.get('timeline_limit') <= 0:
+        logger.warning(
+            "The 'timeline_limit' parameter of the environment variable MS_PROFILE_OPTIONS must be greater than 0.")
+        options["timeline_limit"] = 500
     absolute_path = os.path.join(os.getcwd(), "data")
     if not isinstance(options.get("output_path"), str):
         logger.warning(
@@ -160,28 +179,25 @@ def parse_profiling_args(options):
 
 def combine_profile_options(profiling_options):
     """Combined profiling options."""
-    factor_s_to_us = 1e7
     output_path = os.path.join(os.getcwd(), "data")
-    if context.get_context("device_target").upper() == "GPU":
-        sync_enable = profiling_options.get("sync_enable", True)
-    else:
-        sync_enable = profiling_options.get("sync_enable", False)
-    options = {
+    config_options = {
         "start": profiling_options.get('start', False),
-        "start_time": int(time.time() * factor_s_to_us),
-        "pid": os.getpid(),
         "output_path": profiling_options.get('output_path', output_path),
-        "file_output_path": "",
         "profile_memory": profiling_options.get("profile_memory", False),
         "profile_communication": profiling_options.get("profile_communication", False),
         "aicore_metrics": profiling_options.get("aicore_metrics", 0),
         "l2_cache": profiling_options.get("l2_cache", False),
-        "sync_enable": sync_enable,
+        "sync_enable": profiling_options.get("sync_enable", True),
         "data_process": profiling_options.get("data_process", True),
         "timeline_limit": profiling_options.get("timeline_limit", 500),
         "parallel_strategy": profiling_options.get("parallel_strategy", True),
+        'op_time': profiling_options.get("op_time", True)
     }
-    return options
+    combine_options = parse_profiling_args(config_options)
+    if combine_options.get("start"):
+        final_options = parse_device_support_param(profiling_options, combine_options)
+        return final_options
+    return combine_options
 
 
 class EnvProfiler:
@@ -190,17 +206,22 @@ class EnvProfiler:
     def __init__(self):
         self._profiling_options = {}
 
-    def analyse(self):
-        """Determine whether to stop collecting and parsing performance data based on environment variables."""
+    def need_analyse(self):
+        """Determine whether the data needs to be parsed."""
         if not os.getenv("MS_PROFILER_OPTIONS"):
-            return
+            return False
         self._profiling_options = json.loads(os.getenv("MS_PROFILER_RUN_CONFIG", "{}"))
         if not self._profiling_options.get("pid", 0) == os.getpid():
-            return
+            return False
         if not self._profiling_options.get("start"):
-            return
-        profiler = Profiler(env_enable=self._profiling_options)
-        profiler.analyse()
+            return False
+        return True
+
+    def analyse(self):
+        """Determine whether to stop collecting and parsing performance data based on environment variables."""
+        if self.need_analyse():
+            profiler = Profiler(env_enable=self._profiling_options)
+            profiler.analyse()
 
 
 def profiler_check_env():
@@ -214,14 +235,15 @@ def profiler_check_env():
     if not config.get("start"):
         return
     Profiler(output_path=config.get("output_path"),
-             profile_memory=config.get("profile_memory"),
-             profile_communication=config.get("profile_communication"),
-             data_process=config.get("data_process"),
-             parallel_strategy=config.get("parallel_strategy"),
-             aicore_metrics=config.get("aicore_metrics"),
-             l2_cache=config.get("l2_cache"),
-             sync_enable=config.get("sync_enable"),
-             timeline_limit=config.get("timeline_limit"))
+             profile_memory=config.get("profile_memory", False),
+             profile_communication=config.get("profile_communication", False),
+             data_process=config.get("data_process", False),
+             parallel_strategy=config.get("parallel_strategy", False),
+             aicore_metrics=config.get("aicore_metrics", 0),
+             l2_cache=config.get("l2_cache", False),
+             sync_enable=config.get("sync_enable", False),
+             op_time=config.get("op_time", False),
+             timeline_limit=config.get("timeline_limit", 500))
 
 
 profiler_check_env()

mindspore/profiler/parser/ascend_timeline_generator.py

@@ -65,8 +65,7 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
 
         logger.info('Initiating timeline...')
         timeline_list = []
-        op_timeline_list = self._get_op_timeline(communication_info, source_path)
-        timeline_list.extend(op_timeline_list)
+        timeline_list.extend(self._get_op_timeline(communication_info, source_path))
 
         # Generate step time.
         self._set_step_start_and_end_op_name(timeline_list)
@@ -116,10 +115,9 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         self._format_meta_data_list.extend(self._timeline_meta)
         self._timeline_meta = self._format_meta_data_list
         # Get framework metadata.
-        framework_obj_list = framework_info.get('object')
         # The length of list is the number of operators.
-        self._timeline_summary['num_of_ops'] += len(framework_obj_list)
-        self._add_framework_info(framework_obj_list)
+        self._timeline_summary['num_of_ops'] += len(framework_info.get('object'))
+        self._add_framework_info(framework_info.get('object'))
         logger.info('Finished adding info into timeline...')
 
         # Update timeline summary info
@@ -212,28 +210,24 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
 
         try:
             with open(host_start_file_path) as f_obj:
-                lines = f_obj.readlines()
-                # lines[2] stores host monotonic_raw time of start training.
-                host_monotonic = int(lines[2].strip().split(':')[1])
+                # f_obj.readlines()[2] stores host monotonic_raw time of start training.
+                host_monotonic = int(f_obj.readlines()[2].strip().split(':')[1])
         except (IOError, OSError) as err:
             logger.critical('Error occurred when read host_start.log: %s', err)
             raise ProfilerIOException()
         try:
             with open(dev_start_file_path) as f_obj:
-                lines = f_obj.readlines()
-                # lines[2] stores device cycle counter of start training.
-                dev_cntvct = int(lines[2].strip().split(':')[1])
+                # f_obj.readlines()[2] stores device cycle counter of start training.
+                dev_cntvct = int(f_obj.readlines()[2].strip().split(':')[1])
         except (IOError, OSError) as err:
             logger.critical('Error occurred when read dev_start.log: %s', err)
             raise ProfilerIOException()
 
-        factor_ns_to_ms = 1e-6
-        factor_ten_ns_to_ns = 10
-        factor_ms_to_ns = 1e6
+        factor = {"factor_ns_to_ms": 1e-6, "factor_ten_ns_to_ns": 10, "factor_ms_to_ns": 1e6}
         for idx, time_item in enumerate(timeline_list):
-            host_time = int(float(time_item[self._start_time_idx]) * factor_ms_to_ns)
-            device_time = dev_cntvct * factor_ten_ns_to_ns + (host_time - host_monotonic)
-            timeline_list[idx][self._start_time_idx] = device_time * factor_ns_to_ms
+            host_time = int(float(time_item[self._start_time_idx]) * factor.get("factor_ms_to_ns"))
+            device_time = dev_cntvct * factor.get("factor_ten_ns_to_ns") + (host_time - host_monotonic)
+            timeline_list[idx][self._start_time_idx] = device_time * factor.get("factor_ns_to_ms")
 
     def _add_framework_info(self, framework_obj_list):
         """
@@ -297,30 +291,33 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         that communication inside each stage slow down the training.
         """
         is_pipeline_parallel = False
-        comm_merged_timeline, _, comm_display_timeline = self._get_merged_time_list(
+        time_info = {"receive_op_not_overlapped_timeline": [], "collective_comm_not_overlapped_timeline": [],
+                     "comm_not_overlapped_timeline": []}
+        comm_timeline = self._get_merged_time_list(
             comm_info, display_name="communication"
         )
-        aicore_timeline_interval, _, aicore_display_timeline = self._get_merged_time_list(
+        aicore_timeline = self._get_merged_time_list(
             aicore_info, get_interval_time=True
         )
         # Consider if the overlap will be 0 or not.
-        comm_not_overlapped_timeline = self._get_intersection_time(
-            aicore_timeline_interval, comm_merged_timeline
+        time_info["comm_not_overlapped_timeline"] = self._get_intersection_time(
+            aicore_timeline[0], comm_timeline[0]
         )
 
         # Process receive part.
         all_timeline = aicore_info + comm_info
         all_timeline.sort(key=lambda x: float(x[self._start_time_idx]))
-        receive_op_timeline, timeline_exclude_receive_op = self._produce_two_separated_timeline(
+        receive_timeline = self._produce_two_separated_timeline(
             all_timeline, "Receive-op"
         )
-        if receive_op_timeline:
+        if receive_timeline[0]:
             is_pipeline_parallel = True
-        receive_op_merged_timeline = self._get_merged_time_list(receive_op_timeline)[0]
+        receive_op_merged_timeline = self._get_merged_time_list(receive_timeline[0])[0]
         timeline_exclude_receive_op_interval = self._get_merged_time_list(
-            timeline_exclude_receive_op, get_interval_time=True
+            receive_timeline[1], get_interval_time=True
         )[0]
-        receive_op_not_overlapped_timeline = self._get_intersection_time(
+
+        time_info["receive_op_not_overlapped_timeline"] = self._get_intersection_time(
             timeline_exclude_receive_op_interval, receive_op_merged_timeline
         )
 
@@ -328,9 +325,9 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         collective_comm_timeline = self._produce_two_separated_timeline(
             comm_info, "Receive-op"
         )[-1]
-        collective_comm_merged_timeline = self._get_merged_time_list(collective_comm_timeline)[0]
-        collective_comm_not_overlapped_timeline = self._get_intersection_time(
-            aicore_timeline_interval, collective_comm_merged_timeline
+
+        time_info["collective_comm_not_overlapped_timeline"] = self._get_intersection_time(
+            aicore_timeline[0], self._get_merged_time_list(collective_comm_timeline)[0]
         )
 
         # Generate free time that exclude computation and communication time.
@@ -338,41 +335,51 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
             all_timeline, get_interval_time=True, display_name="free_time"
         )[1]
 
-        self._parse_cluster_metrices(step_info, receive_op_not_overlapped_timeline, comm_not_overlapped_timeline
-                                     , collective_comm_not_overlapped_timeline, is_pipeline_parallel)
+        self._parse_cluster_metrices(step_info, time_info.get("receive_op_not_overlapped_timeline"),
+                                     time_info.get("comm_not_overlapped_timeline"),
+                                     time_info.get("collective_comm_not_overlapped_timeline"), is_pipeline_parallel)
 
         res_timeline = []
-        res_timeline.extend(comm_not_overlapped_timeline)
-        res_timeline.extend(aicore_display_timeline)
-        res_timeline.extend(comm_display_timeline)
+        res_timeline.extend(time_info.get("comm_not_overlapped_timeline"))
+        res_timeline.extend(aicore_timeline[2])
+        res_timeline.extend(comm_timeline[2])
         res_timeline.extend(free_timeline)
 
         return res_timeline
 
-    def _parse_cluster_metrices(self, step_info, receive_op_not_overlapped_timeline, comm_not_overlapped_timeline
-                                , collective_comm_not_overlapped_timeline, is_pipeline_parallel):
+    def _parse_cluster_metrices(self, step_info, receive_op_not_overlapped_timeline, comm_not_overlapped_timeline,
+                                collective_comm_not_overlapped_timeline, is_pipeline_parallel):
         """Write the cluster metrices"""
-        step_num = len(step_info)
         # Compute these five metrics mentioned above per step.
         recieve_alone_time = self._compute_time_inside_step(receive_op_not_overlapped_timeline, step_info)
-        stage_time, computation_time = [], []
+        time_info = {"stage_time": [], "computation_time": []}
         comm_alone_time = self._compute_time_inside_step(comm_not_overlapped_timeline, step_info)
         collective_comm_alone_time = self._compute_time_inside_step(
             collective_comm_not_overlapped_timeline, step_info
         )
+        step_num = len(step_info)
         for step in range(step_num):
             try:
                 if is_pipeline_parallel:
-                    stage_time.append(step_info[step][self._duration_idx] - recieve_alone_time[step])
-                computation_time.append(step_info[step][self._duration_idx] - comm_alone_time[step])
+                    time_info.get("stage_time").append(step_info[step][self._duration_idx] - recieve_alone_time[step])
             except IndexError as err:
                 logger.error(err)
-        metrices_per_step_list = [computation_time, comm_alone_time, stage_time,
+
+            try:
+                time_info.get("computation_time").append(step_info[step][self._duration_idx] - comm_alone_time[step])
+            except IndexError as err:
+                logger.error(err)
+
+        metrices_per_step_list = [time_info.get("computation_time"), comm_alone_time, time_info.get("stage_time"),
                                   recieve_alone_time, collective_comm_alone_time]
         if step_num > 1:
             for metric in metrices_per_step_list:
                 metric.append(sum(metric[1:]) / (step_num - 1))
-        self._write_cluster_metrices(metrices_per_step_list, is_pipeline_parallel, "Ascend", self._rank_id)
+        try:
+            self._write_cluster_metrices(metrices_per_step_list, is_pipeline_parallel, "Ascend", self._rank_id)
+        except (IOError, OSError) as err:
+            logger.warning(err)
+            raise ProfilerIOException
 
     def _compute_time_inside_step(self, metric_timeline, step_time_list):
         """Compute per step time of metric_timeline."""

mindspore/profiler/parser/base_timeline_generator.py

@@ -107,8 +107,8 @@ class BaseTimelineGenerator:
     def get_parallel_context():
         """Get parallel context."""
         try:
-            parallel_mode = get_auto_parallel_context("parallel_mode")
-            stage_num = get_auto_parallel_context("pipeline_stages")
+            parallel_mode, stage_num = get_auto_parallel_context("parallel_mode"), get_auto_parallel_context(
+                "pipeline_stages")
         except RuntimeError:
             logger.warning("[profiler] the feature of cluster bottleneck analyse "
                            "is not supported in offline parse mode.")
@@ -231,10 +231,11 @@ class BaseTimelineGenerator:
             with os.fdopen(os.open(timeline_summary_file_path,
                                    os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as json_file:
                 json.dump(self._timeline_summary, json_file)
-            os.chmod(timeline_summary_file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical('Error occurred when write timeline summary file: %s', err)
             raise ProfilerIOException()
+        if os.path.exists(timeline_summary_file_path):
+            os.chmod(timeline_summary_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _get_device_process_label(self):
         """Get device process label."""
@@ -274,27 +275,27 @@ class BaseTimelineGenerator:
                 )
 
         # merged_display_list data used for ui page.
-        merged_display_list = [
-            [display_name, tid, time_merged_segment_list[i * 2],
-             (time_merged_segment_list[i * 2 + 1] - time_merged_segment_list[i * 2]) * factor, pid] for i in \
-            range(len(time_merged_segment_list) // 2)
-        ]
+        merged_display_list = []
+        for i in range(len(time_merged_segment_list) // 2):
+            merged_display_list.append([display_name, tid, time_merged_segment_list[i * 2],
+                                        (time_merged_segment_list[i * 2 + 1] - time_merged_segment_list[
+                                            i * 2]) * factor, pid])
 
         if get_interval_time:
             time_merged_segment_list = time_merged_segment_list[1:-1]
 
         # merged_res_list data used to compute overlap with other time_list.
-        merged_res_list = [
-            [display_name, tid, time_merged_segment_list[i * 2], time_merged_segment_list[i * 2 + 1], pid] for i in \
-            range(len(time_merged_segment_list) // 2)
-        ]
+        merged_res_list = []
+        for i in range(len(time_merged_segment_list) // 2):
+            merged_res_list.append(
+                [display_name, tid, time_merged_segment_list[i * 2], time_merged_segment_list[i * 2 + 1], pid])
 
         # interval_display_list is interval time used for ui page.
-        interval_display_list = [
-            [display_name, tid, time_merged_segment_list[i * 2],
-             (time_merged_segment_list[i * 2 + 1] - time_merged_segment_list[i * 2]) * factor, pid]
-            for i in range(len(time_merged_segment_list) // 2)
-        ]
+        interval_display_list = []
+        for i in range(len(time_merged_segment_list) // 2):
+            interval_display_list.append([display_name, tid, time_merged_segment_list[i * 2],
+                                          (time_merged_segment_list[i * 2 + 1] - time_merged_segment_list[
+                                              i * 2]) * factor, pid])
 
         return merged_res_list, interval_display_list, merged_display_list
 
@@ -327,17 +328,16 @@ class BaseTimelineGenerator:
 
         thread_name_meta_data["tid"] = tid
         thread_name_meta_data.get("args")["name"] = tid_name
-        thread_sort_meta_data = thread_name_meta_data.copy()
-        thread_sort_meta_data['name'] = "thread_sort_index"
-        thread_sort_meta_data["args"] = {"sort_index": sort_index}
+        self._format_meta_data_list.append(thread_name_meta_data)
+
+        thread_name_meta_data['name'] = "thread_sort_index"
+        thread_name_meta_data["args"] = {"sort_index": sort_index}
+        self._format_meta_data_list.append(thread_name_meta_data)
         timeline_dict["tid"] = tid
 
         if tid_name in self._thread_processed_list:
             return
-
         self._thread_processed_list.append(tid_name)
-        self._format_meta_data_list.append(thread_name_meta_data)
-        self._format_meta_data_list.append(thread_sort_meta_data)
 
     def _get_max_scope_name_num(self, timeline_list):
         """Get the max number of scope level from all operator."""
@@ -354,12 +354,11 @@ class BaseTimelineGenerator:
         # start and end index of time_item in timeline_list.
         scope_name_start_duration_dict = {}
         scope_name_time_list = []
-        op_full_name_idx, scope_name_idx, invalid_idx = 0, 0, -1
-        tid = "Scope Name"
+        sort_idx = {"op_full_name_idx": 0, "scope_name_idx": 0, "invalid_idx": -1}
         for idx, time_item in enumerate(timeline_list):
-            scope_name_list = time_item[op_full_name_idx].split('/')[:-1]
+            scope_name_list = time_item[sort_idx.get("op_full_name_idx")].split('/')[:-1]
             # skip Default/InitDataSetQueue operator.
-            if time_item[op_full_name_idx].startswith("Default/InitDataSetQueue"):
+            if time_item[sort_idx.get("op_full_name_idx")].startswith("Default/InitDataSetQueue"):
                 scope_name_list = []
             # process scope name of subgraph(Default/Gradients/recompute_Default) only.
             if scope_name_list and scope_name_list[0] != subgraph:
@@ -370,34 +369,32 @@ class BaseTimelineGenerator:
 
             # update the start and end index of time_item according to current scope_name
             for scope_name in scope_name_list:
-                init_start_end_idx_dict = {'start_item_idx': idx, 'end_item_idx': idx}
                 if scope_name not in scope_name_start_duration_dict:
-                    scope_name_start_duration_dict[scope_name] = init_start_end_idx_dict
-                if scope_name_start_duration_dict.get(scope_name)['start_item_idx'] == invalid_idx:
-                    scope_name_start_duration_dict[scope_name] = init_start_end_idx_dict
+                    scope_name_start_duration_dict[scope_name] = {'start_item_idx': idx, 'end_item_idx': idx}
+                if scope_name_start_duration_dict.get(scope_name)['start_item_idx'] == sort_idx.get("invalid_idx"):
+                    scope_name_start_duration_dict[scope_name] = {'start_item_idx': idx, 'end_item_idx': idx}
                 else:
                     scope_name_start_duration_dict.get(scope_name)['end_item_idx'] = idx
             # if the key(scope name) in scope_name_start_duration_dict does not appear in scope_name_list,
             # it means this key(scope name) is end and it is append to scope_name_time_list.
             for key, val in scope_name_start_duration_dict.items():
-                if val['start_item_idx'] == invalid_idx:
+                if val['start_item_idx'] == sort_idx.get("invalid_idx"):
                     continue
                 if (key not in scope_name_list) \
                         or idx == (len(timeline_list) - 1) \
-                        or time_item[op_full_name_idx] == self._step_end_op_name:
+                        or time_item[sort_idx.get("op_full_name_idx")] == self._step_end_op_name:
                     start_time = timeline_list[val['start_item_idx']][self._start_time_idx]
                     duration = (float(timeline_list[val['end_item_idx']][self._start_time_idx]) - float(start_time)) * \
                                factor_start_time_to_duration + \
                                float(timeline_list[val['end_item_idx']][self._duration_idx])
-                    scope_name_time_item = [key, tid, start_time, duration]
-                    scope_name_time_list.append(scope_name_time_item)
-                    scope_name_start_duration_dict.get(key)['start_item_idx'] = invalid_idx
+                    scope_name_time_list.append([key, "Scope Name", start_time, duration])
+                    scope_name_start_duration_dict.get(key)['start_item_idx'] = sort_idx.get("invalid_idx")
 
         # x[scope_name_idx] is a scope name like "0-Default".
         # if two element in scope_name_time_list have the same start time,
         # the previous element in list will displayed at the higher line in UI page.
         scope_name_time_list.sort(
-            key=lambda x: (float(x[self._start_time_idx]), int(x[scope_name_idx].split('-')[0]))
+            key=lambda x: (float(x[self._start_time_idx]), int(x[sort_idx.get("scope_name_idx")].split('-')[0]))
         )
 
         return scope_name_time_list
@@ -451,25 +448,21 @@ class BaseTimelineGenerator:
         )
         cluster_analyse_file_path = validate_and_normalize_path(cluster_analyse_file_path)
 
-        try:
-            with os.fdopen(os.open(cluster_analyse_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660),
-                           'w') as file_handle:
-                csv_writer = csv.writer(file_handle)
-                if is_pipeline_parallel:
-                    header = ['computation_time', 'communication_alone_time', 'stage_time',
-                              'receive_alone_time', 'collective_communication_alone_time']
-                    zip_metrices = zip(metrices[0], metrices[1], metrices[2], metrices[3], metrices[4])
-                else:
-                    header = ['computation_time', 'communication_alone_time']
-                    zip_metrices = zip(metrices[0], metrices[1])
-                csv_writer.writerow(header)
-                for row_data in zip_metrices:
-                    row_data = [round(val / unit, time_decimal_digits) for val in row_data]
-                    csv_writer.writerow(row_data)
-            os.chmod(cluster_analyse_file_path, stat.S_IREAD | stat.S_IWRITE)
-        except (IOError, OSError) as err:
-            logger.warning(f'Failed to save {cluster_analyse_file_path}. {err}')
-            raise ProfilerIOException
+        with os.fdopen(os.open(cluster_analyse_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660),
+                       'w') as file_handle:
+            csv_writer = csv.writer(file_handle)
+            if is_pipeline_parallel:
+                header = ['computation_time', 'communication_alone_time', 'stage_time',
+                          'receive_alone_time', 'collective_communication_alone_time']
+                zip_metrices = zip(metrices[0], metrices[1], metrices[2], metrices[3], metrices[4])
+            else:
+                header = ['computation_time', 'communication_alone_time']
+                zip_metrices = zip(metrices[0], metrices[1])
+            csv_writer.writerow(header)
+            for row_data in zip_metrices:
+                row_data = [round(val / unit, time_decimal_digits) for val in row_data]
+                csv_writer.writerow(row_data)
+        os.chmod(cluster_analyse_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _register_op_name(self, timeline_list):
         """Register op name to op name list."""