From d130bd71b0b1eac316a9405fd336b56044e15035 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=A3=98=E5=87=AF=E8=BE=BE?= <kdaqiu@163.com>
Date: Tue, 28 Nov 2023 19:07:59 +0800
Subject: [PATCH 1/2] Add timeline advice.

---
 .../advice_factory/timeline_advice_factory.py |  45 +++++++
 .../common_func_advisor/constant.py           |   6 +
 profiler/advisor/advisor_backend/interface.py |   4 +-
 .../timeline_advice/__init__.py               |  14 ++
 .../timeline_advice/cann_sche_advice.py       |  81 +++++++++++
 .../timeline_advice/optimizer_advice.py       |  55 ++++++++
 .../timeline_advice/timeline_advice_base.py   | 112 +++++++++++++++
 .../timeline_advice/torch_sche_advice.py      |  80 +++++++++++
 profiler/advisor/timeline_perf_analysis.ipynb | 127 ++++++++++++++++++
 9 files changed, 523 insertions(+), 1 deletion(-)
 create mode 100644 profiler/advisor/advisor_backend/advice_factory/timeline_advice_factory.py
 create mode 100644 profiler/advisor/advisor_backend/timeline_advice/__init__.py
 create mode 100644 profiler/advisor/advisor_backend/timeline_advice/cann_sche_advice.py
 create mode 100644 profiler/advisor/advisor_backend/timeline_advice/optimizer_advice.py
 create mode 100644 profiler/advisor/advisor_backend/timeline_advice/timeline_advice_base.py
 create mode 100644 profiler/advisor/advisor_backend/timeline_advice/torch_sche_advice.py
 create mode 100644 profiler/advisor/timeline_perf_analysis.ipynb

diff --git a/profiler/advisor/advisor_backend/advice_factory/timeline_advice_factory.py b/profiler/advisor/advisor_backend/advice_factory/timeline_advice_factory.py
new file mode 100644
index 000000000..9cad12101
--- /dev/null
+++ b/profiler/advisor/advisor_backend/advice_factory/timeline_advice_factory.py
@@ -0,0 +1,45 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
+import os
+import sys
+from advice_factory.advice_factory import AdviceFactory
+from common_func.path_manager import PathManager
+from common_func_advisor.constant import Constant
+from timeline_advice.optimizer_advice import OptimizerAdvice
+from timeline_advice.torch_sche_advice import TorchScheAdvice
+from timeline_advice.cann_sche_advice import CannScheAdvice
+
+class TimelineAdviceFactory(AdviceFactory):
+    ADVICE_LIB = {
+        Constant.OPTIM: OptimizerAdvice,
+        Constant.TORCH_SCHE: TorchScheAdvice,
+        Constant.CANN_SCHE: CannScheAdvice
+    }
+
+    def __init__(self, collection_path: str):
+        super().__init__(collection_path)
+
+    def path_check(self):
+        """
+        check whether input path is valid
+        """
+        PathManager.check_input_directory_path(self.collection_path)
+
+    def produce_advice(self, advice: str):
+        """
+        produce data for input mode and advice
+        """
+        self.advice_check(advice)
+        return self.ADVICE_LIB.get(advice)(self.collection_path).run()
diff --git a/profiler/advisor/advisor_backend/common_func_advisor/constant.py b/profiler/advisor/advisor_backend/common_func_advisor/constant.py
index 9cf2080ac..77807782b 100644
--- a/profiler/advisor/advisor_backend/common_func_advisor/constant.py
+++ b/profiler/advisor/advisor_backend/common_func_advisor/constant.py
@@ -27,6 +27,12 @@ class Constant:
     SLOW_LINK = "slow link"
     KERNEL = "kernel"
 
+    # timeline
+    OPTIM = "optimizer"
+    TORCH_SCHE = "torch_sche"
+    CANN_SCHE = "cann_sche"
+    CANN_SCHE_THRESHOLD = 0.2 # schedule ratio
+
     COLLECTION_PATH = "collection_path"
     CLUSTER_ANALYSIS_OUTPUT = "cluster_analysis_output"
     CLUSTER_STEP_TIME_CSV = "cluster_step_trace_time.csv"
diff --git a/profiler/advisor/advisor_backend/interface.py b/profiler/advisor/advisor_backend/interface.py
index e4d3bf563..4263ec58f 100644
--- a/profiler/advisor/advisor_backend/interface.py
+++ b/profiler/advisor/advisor_backend/interface.py
@@ -21,6 +21,7 @@ sys.path.append(
     os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "cluster_analyse"))
 from common_func_advisor.constant import Constant
 from advisor_backend.advice_factory.cluster_advice_factory import ClusterAdviceFactory
+from advisor_backend.advice_factory.timeline_advice_factory import TimelineAdviceFactory
 
 
 class Interface:
@@ -38,7 +39,8 @@ class Interface:
 
 class FactoryController:
     FACTORY_LIB = {
-        Constant.CLUSTER: ClusterAdviceFactory
+        Constant.CLUSTER: ClusterAdviceFactory,
+        Constant.TIMELINE: TimelineAdviceFactory
     }
 
     def __init__(self, collection_path: str):
diff --git a/profiler/advisor/advisor_backend/timeline_advice/__init__.py b/profiler/advisor/advisor_backend/timeline_advice/__init__.py
new file mode 100644
index 000000000..8400fd5ec
--- /dev/null
+++ b/profiler/advisor/advisor_backend/timeline_advice/__init__.py
@@ -0,0 +1,14 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
diff --git a/profiler/advisor/advisor_backend/timeline_advice/cann_sche_advice.py b/profiler/advisor/advisor_backend/timeline_advice/cann_sche_advice.py
new file mode 100644
index 000000000..7df82108b
--- /dev/null
+++ b/profiler/advisor/advisor_backend/timeline_advice/cann_sche_advice.py
@@ -0,0 +1,81 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
+
+from timeline_advice.timeline_advice_base import TimelineAdviceBase
+from common_func_advisor.constant import Constant
+from collections import defaultdict
+
+class CannScheAdvice(TimelineAdviceBase):
+    def __init__(self, collection_path: str):
+        super().__init__(collection_path)
+        self.cur_data = dict()
+        self.cur_bottleneck = str()
+        self.cur_advice = str()
+
+    def run(self):
+        if not self.path_check():
+            return self.output_format_data
+        self.preparse()
+        self.process()
+        self.output()
+        return self.output_format_data
+
+    def process(self):
+        if not self.preparse_data[self.PREPARSE_TYPE.OVERLAP_CPT]:
+            print("[ERROR] Please set Activity with NPU and set Level to Level1 at lease.")
+            return
+        compute_time, communication_time, free_time = self.get_ratio_from_overlap()
+        all_time = compute_time + communication_time + free_time
+        self.cur_data = self.get_dev_delay()
+
+        cmp_ratio = compute_time / all_time if all_time > 0 else 0.0
+        cmu_ratio = communication_time / all_time if all_time > 0 else 0.0
+        free_ratio = free_time / all_time if all_time > 0 else 0.0
+        if free_ratio > Constant.CANN_SCHE_THRESHOLD:
+            self.cur_advice = "Optimize your model to reduce scheduling time by analyse PyTorch's profiling data."
+        self.cur_bottleneck = "The proportion of scheduling time is {:.2f}%, computing time is {:.2f}%," \
+            "and communication time is {:.2f}%.".format(free_ratio * 100, cmp_ratio * 100, cmu_ratio * 100)
+
+    def get_ratio_from_overlap(self):
+        compute_time = 0.0
+        communication_time = 0.0
+        free_time = 0.0
+        for entry in self.preparse_data[self.PREPARSE_TYPE.OVERLAP_CPT]:
+            compute_time += entry.get("dur", 0)
+        for entry in self.preparse_data[self.PREPARSE_TYPE.OVERLAP_FREE]:
+            free_time += entry.get("dur", 0)
+        for entry in self.preparse_data[self.PREPARSE_TYPE.OVERLAP_CMU]:
+            communication_time += entry.get("dur", 0)
+        return compute_time, communication_time, free_time
+
+    def get_dev_delay(self):
+        h2d_data = self.preparse_data[self.PREPARSE_TYPE.HOST_TO_DEVICE]
+        h2d_pair_data = defaultdict(list)
+        ret_data = list()
+        index = 0
+        for entry in h2d_data:
+            name = entry.get("name")
+            if not name:
+                continue
+            h2d_pair_data[name].append(entry)
+            if len(h2d_pair_data[name]) == 2:
+                start_idx = 0 if h2d_pair_data[name][0].get("ph") == "s" else 1
+                end_idx = 1 if start_idx == 0 else 1
+                start_entry = h2d_pair_data[name][start_idx]
+                end_entry = h2d_pair_data[name][end_idx]
+                ret_data.append((start_entry.get("ts"), end_entry.get("ts") - start_entry.get("ts")))
+                index += 1
+        ret_data.sort(key=lambda x : x[0])
+        return ret_data
diff --git a/profiler/advisor/advisor_backend/timeline_advice/optimizer_advice.py b/profiler/advisor/advisor_backend/timeline_advice/optimizer_advice.py
new file mode 100644
index 000000000..ca24bb5ec
--- /dev/null
+++ b/profiler/advisor/advisor_backend/timeline_advice/optimizer_advice.py
@@ -0,0 +1,55 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
+
+from timeline_advice.timeline_advice_base import TimelineAdviceBase
+
+class OptimizerAdvice(TimelineAdviceBase):
+    OPTIMIZER_MAP = {
+        "Optimizer.step#SGD.step": "torch_npu.optim.NpuFusedSGD",
+        "Optimizer.step#Adadelta.step": "torch_npu.optim.NpuFusedAdadelta",
+        "Optimizer.step#Lamb.step": "torch_npu.optim.NpuFusedLamb",
+        "Optimizer.step#Adam.step": "torch_npu.optim.NpuFusedAdam",
+        "Optimizer.step#AdamW.step": "torch_npu.optim.NpuFusedAdamW",
+        "Optimizer.step#AdamP.step": "torch_npu.optim.NpuFusedAdamP",
+        "Optimizer.step#BertAdam.step": "torch_npu.optim.NpuFusedBertAdam",
+        "Optimizer.step#RMSprop.step": "torch_npu.optim.NpuFusedRMSprop",
+        "Optimizer.step#RMSpropTF.step": "torch_npu.optim.NpuFusedRMSpropTF",
+    }
+
+    def __init__(self, collection_path: str):
+        super().__init__(collection_path)
+        self.cur_data = list()
+        self.cur_bottleneck = str()
+        self.cur_advice = str()
+
+    def run(self):
+        if not self.path_check():
+            return self.output_format_data
+        self.preparse()
+        self.process()
+        self.output()
+        return self.output_format_data
+
+    def process(self):
+        if not self.preparse_data[self.PREPARSE_TYPE.OPTIMIZER]:
+            return
+
+        self.cur_data = list(set([entry.get("name", None) for entry in self.preparse_data[self.PREPARSE_TYPE.OPTIMIZER]]))
+        for index, opt_name in enumerate(self.cur_data):
+            self.cur_advice += f"You can choose {self.OPTIMIZER_MAP[opt_name]} to replace the current Optimizer: {opt_name}."
+            if index != len(self.cur_data) - 1:
+                self.cur_advice += "\n"
+        self.cur_bottleneck = self.cur_advice
+
diff --git a/profiler/advisor/advisor_backend/timeline_advice/timeline_advice_base.py b/profiler/advisor/advisor_backend/timeline_advice/timeline_advice_base.py
new file mode 100644
index 000000000..a16e962d5
--- /dev/null
+++ b/profiler/advisor/advisor_backend/timeline_advice/timeline_advice_base.py
@@ -0,0 +1,112 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
+
+from advice_base import AdviceBase
+from abc import abstractmethod
+import os
+import json
+from collections import defaultdict
+
+class TimelineAdviceBase(AdviceBase):
+    class PREPARSE_TYPE:
+        OPTIMIZER = 0
+        STEP = 1
+        OVERLAP_CPT = 2
+        OVERLAP_FREE = 3
+        OVERLAP_CMU =4
+        ENQUEUE = 5
+        DEQUEUE = 6
+        HOST_TO_DEVICE = 7
+
+    def __init__(self, collection_path: str):
+        super().__init__(collection_path)
+        self.trace_view_path = ""
+        self.has_preparse = False
+        self.preparse_data = defaultdict(list)
+
+    def path_check(self):
+        """
+        check whether input path is valid
+        """
+        if not os.path.exists(self.collection_path):
+            print("[ERROR] Path: {} is not exist.".format(self.collection_path))
+            return False
+        if os.path.isdir(self.collection_path) and self.collection_path.endswith("ascend_pt"):
+            self.trace_view_path = os.path.join(self.collection_path, "ASCEND_PROFILER_OUTPUT", "trace_view.json")
+            if not os.path.exists(self.trace_view_path):
+                print("[ERROR] trace_view.json is not exist in the Path: {}.".format(os.path.join(self.collection_path, "ASCEND_PROFILER_OUTPUT")))
+                return False
+        elif os.path.isfile(self.collection_path) and os.path.basename(self.collection_path) == "trace_view.json":
+            self.trace_view_path = self.collection_path
+        else:
+            print("[ERROR] Please input ascend_pt or trace_view.json.")
+            return False
+        print("[INFO] Start to analyse the target file: {}".format(self.trace_view_path))
+        return True
+        
+
+    @abstractmethod
+    def run(self):
+        """
+        analyze profiling data and advice
+        """
+
+    @abstractmethod
+    def output(self):
+        """
+        output relevant data
+        """
+        self.output_format_data[self.DATA] = self.cur_data
+        self.output_format_data[self.BOTTLENECK] = self.cur_bottleneck
+        self.output_format_data[self.ADVICE] = self.cur_advice
+
+    def preparse(self):
+        if self.has_preparse:
+            return
+        with open(self.trace_view_path, 'r') as f:
+            json_reader = json.load(f)
+            for entry in json_reader:
+                name = entry.get("name", None)
+                cat = entry.get("cat", None)
+                if name and name.startswith("Optimizer.step#") and name.endswith(".step"):
+                    self.preparse_data[self.PREPARSE_TYPE.OPTIMIZER].append(entry)
+                elif name and name.startswith("ProfilerStep#"):
+                    self.preparse_data[self.PREPARSE_TYPE.STEP].append(entry)
+                elif name == "Computing":
+                    self.preparse_data[self.PREPARSE_TYPE.OVERLAP_CPT].append(entry)
+                elif name == "Free":
+                    self.preparse_data[self.PREPARSE_TYPE.OVERLAP_FREE].append(entry)
+                elif name == "Communication(Not Overlapped)":
+                    self.preparse_data[self.PREPARSE_TYPE.OVERLAP_CMU].append(entry)
+
+                if cat == "enqueue":
+                    self.preparse_data[self.PREPARSE_TYPE.ENQUEUE].append(entry)
+                elif cat == "dequeue":
+                    self.preparse_data[self.PREPARSE_TYPE.DEQUEUE].append(entry)
+                elif cat == "HostToDevice":
+                    self.preparse_data[self.PREPARSE_TYPE.HOST_TO_DEVICE].append(entry)
+        sort_list = [
+            self.PREPARSE_TYPE.OVERLAP_CPT,
+            self.PREPARSE_TYPE.OVERLAP_FREE,
+            self.PREPARSE_TYPE.OVERLAP_CMU,
+            self.PREPARSE_TYPE.ENQUEUE,
+            self.PREPARSE_TYPE.DEQUEUE,
+            self.PREPARSE_TYPE.HOST_TO_DEVICE
+        ]
+        for sort_entry in sort_list:
+            if self.preparse_data[sort_entry]:
+                self.preparse_data[sort_entry].sort(key=lambda x : float(x.get("ts")))
+        self.preparse = True
+        
\ No newline at end of file
diff --git a/profiler/advisor/advisor_backend/timeline_advice/torch_sche_advice.py b/profiler/advisor/advisor_backend/timeline_advice/torch_sche_advice.py
new file mode 100644
index 000000000..c91491d06
--- /dev/null
+++ b/profiler/advisor/advisor_backend/timeline_advice/torch_sche_advice.py
@@ -0,0 +1,80 @@
+# Copyright (c) 2023, Huawei Technologies Co., Ltd.
+# 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.
+
+from timeline_advice.timeline_advice_base import TimelineAdviceBase
+import json
+
+class TorchScheAdvice(TimelineAdviceBase):
+    def __init__(self, collection_path: str):
+        super().__init__(collection_path)
+        self.cur_data = list()
+        self.cur_bottleneck = str()
+        self.cur_advice = str()
+
+    def run(self):
+        if not self.path_check():
+            return self.output_format_data
+        self.preparse()
+        self.process()
+        self.output()
+        return self.output_format_data
+
+    def process(self):
+        if not self.preparse_data[self.PREPARSE_TYPE.ENQUEUE] or not self.preparse_data[self.PREPARSE_TYPE.DEQUEUE]:
+            print("[ERROR] Please set Activity with CPU at least.")
+            return
+        self.cur_data = self.get_taskq_size()
+        sche_ratio = self.get_sche_ratio()
+        self.cur_bottleneck = "The proportion of scheduling time is {:.2f}%.".format(sche_ratio * 100)
+        self.cur_advice = "Optimize your model to reduce scheduling time by using NPU fused operator or get help from engineers."
+
+    def get_taskq_size(self):
+        enque_data = self.preparse_data[self.PREPARSE_TYPE.ENQUEUE]
+        deque_data = self.preparse_data[self.PREPARSE_TYPE.DEQUEUE]
+        merge_data = enque_data + deque_data
+        merge_data.sort(key=lambda x : float(x.get("ts")))
+        taskq_size = list()
+        cur_size = 0
+        for entry in merge_data:
+            if entry.get("cat") == "enqueue":
+                cur_size += 1
+            elif entry.get("cat") == "dequeue":
+                cur_size -= 1
+            taskq_size.append((entry.get("ts") , cur_size))
+        return self.data_format(taskq_size)
+
+    def data_format(self, tasq_size):
+        time_stamp = [entry[0] for entry in tasq_size]
+        size_info = [entry[1] for entry in tasq_size]
+        time_stamp = [int(entry - time_stamp[0]) for entry in time_stamp]
+        ret_time_stamp = [i for i in range(time_stamp[-1] + 1)]
+        ret_size_info = [0] * (time_stamp[-1] + 1)
+        for idx, idx_ret in enumerate(time_stamp):
+            ret_size_info[idx_ret] = size_info[idx]
+        temp_data = [None] * len(ret_time_stamp)
+        for i in range(len(ret_time_stamp)):
+            temp_data[i] = (ret_time_stamp[i], ret_size_info[i])
+        return temp_data
+
+    def get_sche_ratio(self) -> float:
+        all_time, deque_time = 0.0, 0.0
+        ratio = 0.0
+        for entry in self.preparse_data[self.PREPARSE_TYPE.STEP]:
+            all_time += entry.get("dur", 0)
+        for entry in self.preparse_data[self.PREPARSE_TYPE.DEQUEUE]:
+            deque_time += entry.get("dur", 0)
+        if all_time > 0:
+            ratio = deque_time / all_time
+        return ratio
diff --git a/profiler/advisor/timeline_perf_analysis.ipynb b/profiler/advisor/timeline_perf_analysis.ipynb
new file mode 100644
index 000000000..e0374b8ab
--- /dev/null
+++ b/profiler/advisor/timeline_perf_analysis.ipynb
@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from advisor_backend.interface import Interface\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Timeline调优分析\n",
+    "\n",
+    "## 1. Timeline分析的数据准备\n",
+    "我们当前支持Ascend PyTorch Profiler方式采集后的ascend_pt目录，并支持单独分析ascend_pt/ASCEND_PROFILER_OUTPUT目录下的trace_view.json文件。\n",
+    "\n",
+    "## 2. Timeline分析解决的问题\n",
+    "当前的功能主要有三项：1）识别当前可选择的NPU亲和优化器；2）PTA调度分析（分析TaskQueue中的算子个数）；3）CANN调度分析（分析CANN组件算子下发到Device侧的效率）"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# EDIT THE PROFILING DATA PATH\n",
+    "timeline_path = \"YOUR PATH\"\n",
+    "interface = Interface(timeline_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1）亲和优化器识别"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = interface.get_data('timeline', 'optimizer')\n",
+    "# 打印当前使用的优化器\n",
+    "data = dataset.get('data')\n",
+    "print(data)\n",
+    "\n",
+    "# 如果使用了原生优化器，则打印优化建议\n",
+    "advice = dataset.get('advice')\n",
+    "print(advice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2）PTA调度分析"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = interface.get_data('timeline', 'torch_sche')\n",
+    "data = dataset.get('data')\n",
+    "\n",
+    "x = [entry[0] for entry in data]\n",
+    "y = [entry[1] for entry in data]\n",
+    "\n",
+    "plt.figure(figsize=(12, 8))\n",
+    "plt.xlabel('Times(us)')\n",
+    "plt.ylabel('Size')\n",
+    "plt.title('TaskQueue')\n",
+    "\n",
+    "plt.plot(x, y)\n",
+    "plt.show()\n",
+    "print(dataset.get('bottleneck'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3）CANN调度分析"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = interface.get_data('timeline', 'cann_sche')\n",
+    "data = dataset.get('data')\n",
+    "\n",
+    "x = [i for i in range(len(data))]\n",
+    "y = [entry[1] for entry in data]\n",
+    "\n",
+    "plt.figure(figsize=(12, 8))\n",
+    "plt.xlabel('Op')\n",
+    "plt.ylabel('Delay(us)')\n",
+    "plt.title('Host to Device')\n",
+    "\n",
+    "plt.plot(x, y)\n",
+    "plt.show()\n",
+    "print(dataset.get('bottleneck'))"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
-- 
Gitee


From 27801c2f59a5e981c346080ca5a14310d34780ed Mon Sep 17 00:00:00 2001
From: kdaqiu <kdaqiu@163.com>
Date: Thu, 30 Nov 2023 18:36:47 +0800
Subject: [PATCH 2/2] Add Jupyter file.

---
 profiler/advisor/timeline_perf_analysis.ipynb | 105 ++++++++++++++++--
 1 file changed, 93 insertions(+), 12 deletions(-)

diff --git a/profiler/advisor/timeline_perf_analysis.ipynb b/profiler/advisor/timeline_perf_analysis.ipynb
index e0374b8ab..1bf65d5cc 100644
--- a/profiler/advisor/timeline_perf_analysis.ipynb
+++ b/profiler/advisor/timeline_perf_analysis.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -21,17 +21,17 @@
     "我们当前支持Ascend PyTorch Profiler方式采集后的ascend_pt目录，并支持单独分析ascend_pt/ASCEND_PROFILER_OUTPUT目录下的trace_view.json文件。\n",
     "\n",
     "## 2. Timeline分析解决的问题\n",
-    "当前的功能主要有三项：1）识别当前可选择的NPU亲和优化器；2）PTA调度分析（分析TaskQueue中的算子个数）；3）CANN调度分析（分析CANN组件算子下发到Device侧的效率）"
+    "当前的功能主要有三项：1）识别当前可选择的NPU亲和优化器；2）PTA调度分析（分析TaskQueue消费能力）；3）CANN调度分析（分析CANN组件算子下发到Device侧的效率）"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "# EDIT THE PROFILING DATA PATH\n",
-    "timeline_path = \"YOUR PATH\"\n",
+    "timeline_path = \"[YOUR PATH]\"\n",
     "interface = Interface(timeline_path)"
    ]
   },
@@ -44,9 +44,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] Start to analyse the target file: [YOUR PATH]\n",
+      "['Optimizer.step#AdamW.step']\n",
+      "You can choose torch_npu.optim.NpuFusedAdamW to replace the current Optimizer: Optimizer.step#AdamW.step.\n"
+     ]
+    }
+   ],
    "source": [
     "dataset = interface.get_data('timeline', 'optimizer')\n",
     "# 打印当前使用的优化器\n",
@@ -67,9 +77,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] Start to analyse the target file: [YOUR PATH]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The proportion of scheduling time is 8.38%.\n"
+     ]
+    }
+   ],
    "source": [
     "dataset = interface.get_data('timeline', 'torch_sche')\n",
     "data = dataset.get('data')\n",
@@ -96,9 +131,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] Start to analyse the target file: [YOUR PATH]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The proportion of scheduling time is 23.66%, computing time is 9.51%,and communication time is 66.82%.\n"
+     ]
+    }
+   ],
    "source": [
     "dataset = interface.get_data('timeline', 'cann_sche')\n",
     "data = dataset.get('data')\n",
@@ -115,13 +175,34 @@
     "plt.show()\n",
     "print(dataset.get('bottleneck'))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
+  "kernelspec": {
+   "display_name": "qkd",
+   "language": "python",
+   "name": "qkd"
+  },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.18"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
-- 
Gitee