mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/profiler/parser/minddata_analyzer.py

@@ -78,8 +78,8 @@ class MinddataProfilingAnalyzer:
         try:
             validated_dir = validate_and_normalize_path(dir_name)
         except RuntimeError as path_error:
-            logger.warning('<%s> <%s> is invalid.', dir_type, validated_dir)
-            raise ProfilerPathErrorException(dir_type + 'is invalid.') from path_error
+            logger.warning('<%s> is invalid.', dir_type)
+            raise ProfilerPathErrorException(dir_type + ' is invalid.') from path_error
 
         if not os.path.isdir(validated_dir):
             logger.warning('<%s> <%s> not found.', dir_type, validated_dir)
@@ -350,8 +350,8 @@ class MinddataProfilingAnalyzer:
         # Initialize flag that 'device_queue_profiling_<device_id>.txt' has not yet been found
         device_queue_file_found = False
 
-        txt_names = [os.path.join(source_dir, txt_name.format(self._device_id)) for txt_name in
-                     ('device_queue_profiling_{}.txt', 'dataset_iterator_profiling_{}.txt')]
+        txt_names = [os.path.join(source_dir, txt_name.format(self._device_id))
+                     for txt_name in ('device_queue_profiling_{}.txt', 'dataset_iterator_profiling_{}.txt')]
 
         # Search for a device trace profiling file
         if os.path.exists(txt_names[0]):
@@ -743,14 +743,14 @@ class BottleneckAnalyzer:
                     queue_usage_analysis.append(
                         f"{self.pipeline_ops[op_id]}'s input queue is empty {self.queue_empty_freq_pct[in_op_id]}% "
                         f"of the time. This might indicate dataset bottlenecks. Hence host cannot keep up with "
-                        f"the device {self.queue_empty_freq_pct[in_op_id]}% of the time."
-                        f" Device waits whenever input queue is empty.")
+                        f"the device {self.queue_empty_freq_pct[in_op_id]}% of the time. "
+                        f"Device waits whenever input queue is empty.")
             elif in_op_id != self.op_id_not_exist and out_q != self.queue_usage_not_exist:
                 in_q = self.queue_utilization_pct[in_op_id]
                 if in_q != self.queue_usage_not_exist and in_q - out_q > self._IN_OUT_QUEUE_UTIL_PCT_DIFF_MAXIMUM:
                     queue_usage_analysis.append(
-                        f"{self.pipeline_ops[op_id]}'s input queue usage={in_q}% is greater output "
-                        f"queue usage={out_q}%. This indicates child op {self.pipeline_ops[in_op_id]} "
+                        f"{self.pipeline_ops[op_id]}'s input queue usage={in_q}% is greater output queue "
+                        f"usage={out_q}%. This indicates child op {self.pipeline_ops[in_op_id]} "
                         f"might be producing faster than its parent {self.pipeline_ops[op_id]} can consume. "
                         f"If this op has low CPU utilization, try increasing "
                         f"prefetch_size or increasing num_workers.")

mindspore/profiler/parser/msadvisor_analyzer.py

@@ -43,34 +43,21 @@ class Msadvisor:
         output_path = validate_and_normalize_path(output_path)
         logger.info("MSAdvisor is running. Log and result files are saved in %s", output_path)
 
-        try:
-            running_result = subprocess.run(["msadvisor", "-d", output_path, "-c", "all"],
-                                            capture_output=True, check=True)
-        except FileNotFoundError as err:
-            logger.warning("MSAdvisor: command not found,"
-                           "please check if installed ascend-toolkit and set environment path correctly.")
-            raise err
-        except OSError as err:
-            logger.warning("Cannot execute binary file: Exec format error.")
-            raise err
-        finally:
-            pass
+        subprocess.run(["msadvisor", "-d", output_path, "-c", "all"],
+                       capture_output=True, check=True)
+        logger.info("MSAdvisor process finished.")
 
-        if running_result.returncode == 0:
-            logger.info("MSAdvisor process finished.")
-
-            recommendation_path = os.path.join(output_path, "recommendation")
-            recommendation_path = validate_and_normalize_path(recommendation_path)
-            os.chmod(recommendation_path, stat.S_IRWXU)
-            file_list = os.listdir(recommendation_path)
-            file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(recommendation_path, fn)))
-            recommendation_path = os.path.join(recommendation_path, file_list[-1])
-            recommendation_path = validate_and_normalize_path(recommendation_path)
-            os.chmod(recommendation_path, stat.S_IRUSR | stat.S_IRUSR)
-        else:
-            logger.warning("MSAdvisor running failed,"
-                           "please check MSAdvisor running log.")
+        # Modified recommendation file permission, only Owner can read and write.
+        recommendation_path = os.path.join(output_path, "recommendation")
+        recommendation_path = validate_and_normalize_path(recommendation_path)
+        os.chmod(recommendation_path, stat.S_IRWXU)
+        file_list = os.listdir(recommendation_path)
+        file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(recommendation_path, fn)))
+        recommendation_path = os.path.join(recommendation_path, file_list[-1])
+        recommendation_path = validate_and_normalize_path(recommendation_path)
+        os.chmod(recommendation_path, stat.S_IRUSR | stat.S_IWUSR)
 
+        # Modified log file permission, only Owner can read and write.
         log_path = os.path.join(output_path, "log")
         log_path = validate_and_normalize_path(log_path)
         os.chmod(log_path, stat.S_IRWXU)
@@ -82,7 +69,7 @@ class Msadvisor:
         file_list = os.listdir(log_path)
         log_path = os.path.join(log_path, file_list[0])
         log_path = validate_and_normalize_path(log_path)
-        os.chmod(log_path, stat.S_IRUSR | stat.S_IRUSR)
+        os.chmod(log_path, stat.S_IRUSR | stat.S_IWUSR)
 
     def analyse(self):
         """

mindspore/profiler/parser/msadvisor_parser.py

@@ -85,9 +85,7 @@ class MsadvisorParser:
         task_type = "AI_CORE"
 
         try:
-            ts = float(op[2]) * MS_TO_US
-            dur = float(op[3]) * MS_TO_US
-            sid = float(op[1])
+            ts, dur, sid = float(op[2]) * MS_TO_US, float(op[3]) * MS_TO_US, float(op[1])
         except ValueError as err:
             logger.warning("The aicore timeline file content is abnormal. Failed to format aicore timeline file")
             raise err
@@ -192,7 +190,7 @@ class MsadvisorParser:
                     if tid == 1:
                         self._time_start = op.get("ts")
                     total_duration = op.get("ts") - self._time_start
-                    if total_duration > 1*MIN_TO_US or tid > 10000:
+                    if total_duration > 1 * MIN_TO_US or tid > 10000:
                         self._time_end = op.get("ts")
                         break
                     if tid > 1:

mindspore/profiler/parser/optime_parser.py

@@ -36,7 +36,7 @@ class OPComputeTimeParser:
     """
 
     _dst_file_title = 'title:op compute time'
-    _dst_file_column_title = 'op_name       compute_time(ms) stream_id'
+    _dst_file_column_title = 'op_name       compute_time(ms) stream_id execution_times'
     _dst_file_column_title += '\n------------  ---------------  ---------'
 
     def __init__(self, hwts_output_file, output_filename, op_task_info,
@@ -77,8 +77,7 @@ class OPComputeTimeParser:
             op_duration_str = str(item.duration / factor)
             if op_name in op_name_time_dict.keys():
                 op_name_time_dict[op_name] += op_duration
-                if item.task_id == op_name_task_dict[op_name]:
-                    op_name_count_dict[op_name] += 1
+                op_name_count_dict[op_name] += 1
                 op_name_start_time[op_name].append(
                     (op_start_time_str, op_duration_str)
                 )
@@ -120,7 +119,7 @@ class OPComputeTimeParser:
                     raise ValueError("The number of operations can not be 0.")
                 avg_time = time / op_name_count_dict.get(op_name)
                 total_time += avg_time
-                result_data += ("%s %s  %s\n" % (op_name, str(avg_time), stream_id))
+                result_data += ("%s %s %s %s\n" % (op_name, str(avg_time), stream_id, op_name_count_dict.get(op_name)))
         result_data += ("total op  %s 0" % (str(total_time)))
 
         timeline_data = []
@@ -225,25 +224,25 @@ class OPComputeTimeParser:
         """
         tmp_result_data = []
         op_map_list = self._get_op_task_id_map()
+        tmp_op_dict = dict()
 
         cur_index = 0
         length = len(op_map_list)
         min_cycle_counter = float("inf")
         while cur_index < length:
-            if cur_index + 1 == length:
-                break
-
-            op_start = op_map_list[cur_index]
-            op_end = op_map_list[cur_index + 1]
-            if op_start.status == "Start" and op_end.status == "End" \
-                    and op_start.op_name == op_end.op_name:
-                op_start.duration = op_end.cycle_counter - op_start.cycle_counter
-                tmp_result_data.append(op_start)
-                cur_index += 2
-                if not op_start.op_name.startswith("assign"):
-                    min_cycle_counter = min(min_cycle_counter, op_start.cycle_counter)
-            else:
-                cur_index += 1
+            op_time = op_map_list[cur_index]
+            if op_time.status == "Start":
+                tmp_op_dict[op_time.op_name] = op_time
+            elif op_time.status == "End" and op_time.op_name in tmp_op_dict:
+                op_start = tmp_op_dict.get(op_time.op_name, None)
+                if op_start:
+                    op_start.duration = op_time.cycle_counter - op_start.cycle_counter
+                    tmp_result_data.append(op_start)
+                    del tmp_op_dict[op_time.op_name]
+            if not op_time.op_name.startswith("assign"):
+                min_cycle_counter = min(min_cycle_counter, op_time.cycle_counter)
+
+            cur_index += 1
 
         # Update the value of minimum cycle counter.
         self._min_cycle_counter = min_cycle_counter / 1e5  # Convert the time unit from 10ns to 1ms

mindspore/profiler/parser/profiler_info.py

@@ -0,0 +1,108 @@
+# Copyright 2022 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.
+# ============================================================================
+"""Record profiler information"""
+import json
+import os
+import stat
+
+from mindspore.version import __version__ as ms_version
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+
+
+class ProfilerInfo:
+    """
+    This class is used to record profiler information.
+    it contains context_mode, rank_id, rank_size, parallel_mode, pipeline_stage_num, pipeline_stage_id,
+    profiling_start_time, profiling_stop_time, analyse_start_time, analyse_end_time
+    """
+
+    _file_name = "profiler_info_{}.json"
+    _file_path = ""
+    _profiler_info_dict = dict()
+
+    @staticmethod
+    def init_info(context_mode, rank_id):
+        """Profiler info initialization must include context_mode, rank_id and output_path."""
+        ProfilerInfo._profiler_info_dict["context_mode"] = context_mode
+        ProfilerInfo._profiler_info_dict["rank_id"] = rank_id
+        ProfilerInfo._profiler_info_dict["ms_version"] = ms_version
+        ProfilerInfo._file_name = ProfilerInfo._file_name.format(rank_id)
+
+    @staticmethod
+    def set_parallel_info(parallel_mode="", pipeline_stage_num=1, pipeline_stage_id=0):
+        """Set parallel info include parallel_mode, pipeline_stage_num and pipeline_stage_id."""
+        info = dict()
+        info["parallel_mode"] = parallel_mode
+        info["pipeline_stage_num"] = pipeline_stage_num
+        info["pipeline_stage_id"] = pipeline_stage_id
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_profiling_start_time(start_time):
+        """Set the profiling start time."""
+        info = dict()
+        info["profiling_start_time"] = start_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_profiling_stop_time(stop_time):
+        """Set the profiling stop time."""
+        info = dict()
+        info["profiling_stop_time"] = stop_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_analyse_start_time(start_time):
+        """Set the analyse start time."""
+        info = dict()
+        info["analyse_start_time"] = start_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_analyse_end_time(end_time):
+        """Set the analyse end time."""
+        info = dict()
+        info["analyse_end_time"] = end_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_graph_ids(graph_ids):
+        """Set the graph id list."""
+        ProfilerInfo._profiler_info_dict["graph_ids"] = graph_ids
+
+    @staticmethod
+    def set_rank_size(rank_size):
+        """Set the rank size."""
+        ProfilerInfo._profiler_info_dict["rank_size"] = rank_size
+
+    @staticmethod
+    def set_heterogeneous(is_heterogeneous):
+        """Set is it heterogeneous."""
+        ProfilerInfo._profiler_info_dict["is_heterogeneous"] = is_heterogeneous
+
+    @staticmethod
+    def get_profiler_info():
+        """Get the profiler info."""
+        return ProfilerInfo._profiler_info_dict
+
+    @staticmethod
+    def save(output_path):
+        """Save the profiler info to file."""
+        ProfilerInfo._file_path = os.path.join(output_path, ProfilerInfo._file_name)
+        ProfilerInfo._file_path = validate_and_normalize_path(ProfilerInfo._file_path)
+        with os.fdopen(os.open(ProfilerInfo._file_path,
+                               os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as json_file:
+            json.dump(ProfilerInfo._profiler_info_dict, json_file)
+        os.chmod(ProfilerInfo._file_path, stat.S_IREAD | stat.S_IWRITE)

mindspore/profiler/parser/step_trace_parser.py

@@ -188,7 +188,7 @@ class BaseStepTraceParser:
         }
         # update reduce info
         self._update_reduce_info(step_trace, row_data)
-        # save the row data
+        # save the row data, The unit of duration is 10ns
         if not self._header:
             self._header = list(row_data.keys())
             log.info("Profiler step trace header: %s", str(self._header))