mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/rewrite/__init__.py

@@ -25,5 +25,4 @@ from .sparsify.sparsify import sparsify
 from .sparsify.utils import ArgType, SparseFunc
 
 
-__all__ = ["SymbolTree", "Node", "NodeType", "ScopedValue", "ValueType", "PatternEngine", "PatternNode", "VarNode",
-           "Replacement"]
+__all__ = ["SymbolTree", "Node", "NodeType", "ScopedValue", "ValueType"]

mindspore/rewrite/common/namespace.py

@@ -85,12 +85,12 @@ def is_third_party(func_obj):
     # A module without __file__ attribute (normally to be a c++ lib) is considered to be third party module.
     if not hasattr(module, '__file__'):
         return True
-    module_path = os.path.abspath(module.__file__)
+    module_path = os.path.realpath(module.__file__)
     for path in _ignore_third_party_paths:
         if module_path.startswith(path):
             return False
     # Python builtin modules are treated as third-party libraries.
-    python_builtin_dir = os.path.abspath(os.path.dirname(os.__file__))
+    python_builtin_dir = os.path.realpath(os.path.dirname(os.__file__))
     if module_path.startswith(python_builtin_dir):
         return True
     # Check if module is under user workspace directory.
@@ -106,8 +106,8 @@ def is_third_party(func_obj):
 
 def get_top_level_module_path(module_path):
     """Get the path of the top level package of the current working directory."""
-    module_abspath = os.path.abspath(module_path)
-    upper_path = os.path.abspath(os.path.dirname(module_abspath))
+    module_abspath = os.path.realpath(module_path)
+    upper_path = os.path.realpath(os.path.dirname(module_abspath))
     if module_abspath == upper_path:
         return module_abspath
     # Check whether __init__.py exists in the upper directory.

mindspore/rewrite/symbol_tree/symbol_tree.py

@@ -307,7 +307,7 @@ class SymbolTree(Observer, Observable, NodeManager):
     @staticmethod
     def _get_valid_import_info(import_node: ast.ImportFrom, file_path: str):
         """Get valid import info while import_node.module is at form of relative path"""
-        file_path = os.path.dirname(os.path.abspath(file_path))
+        file_path = os.path.dirname(os.path.realpath(file_path))
         # get real path from import_node.level
         # from .(A) import xxx: current path
         # from ..(A) import xxx: last level path
@@ -1452,7 +1452,7 @@ class SymbolTree(Observer, Observable, NodeManager):
         return self._saved_file_name
 
     def save_network_to_file(self):
-        abs_path = os.path.abspath(self._saved_file_name)
+        abs_path = os.path.realpath(self._saved_file_name)
         if os.path.isfile(abs_path):
             os.remove(abs_path)
         with os.fdopen(os.open(self._saved_file_name, os.O_WRONLY | os.O_CREAT, stat.S_IRWXU), 'wb') as f:
@@ -1563,7 +1563,7 @@ class SymbolTree(Observer, Observable, NodeManager):
         When level_num = 1(e.g. from .xxx import yyy), current path will be saved.
         When level_num = 2(e.g. from ..xxx import yyy), the path one level above the current path will be saved.
         """
-        file_path = os.path.dirname(os.path.abspath(file_path))
+        file_path = os.path.dirname(os.path.realpath(file_path))
         file_path = os.path.normcase(file_path)
         file_path = os.path.normpath(file_path)
         if level_num > 1:

mindspore/run_check/_check_version.py

@@ -20,7 +20,6 @@ import sys
 import time
 import subprocess
 import glob
-from copy import deepcopy
 from pathlib import Path
 from abc import abstractmethod, ABCMeta
 from packaging import version
@@ -159,7 +158,7 @@ class GPUEnvChecker(EnvChecker):
         """Get cuda bin path by lib path."""
         path_list = []
         for path in self.cuda_lib_path:
-            path = os.path.abspath(path.strip() + "/bin/")
+            path = os.path.realpath(path.strip() + "/bin/")
             if Path(path).is_dir():
                 path_list.append(path)
         return np.unique(path_list)
@@ -235,7 +234,7 @@ class GPUEnvChecker(EnvChecker):
                     continue
                 path = path.partition(lib_name)[0]
                 if path:
-                    path_list.append(os.path.abspath(path.strip() + "../"))
+                    path_list.append(os.path.realpath(path.strip() + "../"))
             return np.unique(path_list)
         except subprocess.TimeoutExpired:
             logger.warning("Failed to check cuda version due to the ldd command timeout. Please confirm that "
@@ -259,46 +258,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.2", "7.3"]
-        atlas_nnae_version = "/usr/local/Ascend/nnae/latest/compiler/version.info"
-        atlas_toolkit_version = "/usr/local/Ascend/ascend-toolkit/latest/compiler/version.info"
-        hisi_fwk_version = "/usr/local/Ascend/latest/compiler/version.info"
-        if os.path.exists(atlas_nnae_version):
-            # atlas default path
-            self.fwk_path = "/usr/local/Ascend/nnae/latest"
-            self.op_impl_path = "/usr/local/Ascend/nnae/latest/opp/built-in/op_impl/ai_core/tbe"
-            self.tbe_path = self.fwk_path + "/lib64"
-            self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
-            self.fwk_version = atlas_nnae_version
-            self.op_path = "/usr/local/Ascend/nnae/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/nnae/latest"
-        elif os.path.exists(atlas_toolkit_version):
-            # atlas default path
-            self.fwk_path = "/usr/local/Ascend/ascend-toolkit/latest"
-            self.op_impl_path = "/usr/local/Ascend/ascend-toolkit/latest/opp/built-in/op_impl/ai_core/tbe"
-            self.tbe_path = self.fwk_path + "/lib64"
-            self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
-            self.fwk_version = atlas_toolkit_version
-            self.op_path = "/usr/local/Ascend/ascend-toolkit/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/ascend-toolkit/latest"
-        elif os.path.exists(hisi_fwk_version):
-            # hisi default path
-            self.fwk_path = "/usr/local/Ascend/latest"
-            self.op_impl_path = "/usr/local/Ascend/latest/opp/built-in/op_impl/ai_core/tbe"
-            self.tbe_path = self.fwk_path + "/lib64"
-            self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
-            self.fwk_version = hisi_fwk_version
-            self.op_path = "/usr/local/Ascend/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/latest"
-        else:
-            # custom or unknown environment
-            self.fwk_path = ""
-            self.op_impl_path = ""
-            self.tbe_path = ""
-            self.cce_path = ""
-            self.fwk_version = ""
-            self.op_path = ""
-            self.aicpu_path = ""
+        self.version = ["7.3", "7.5"]
 
         # env
         self.path = os.getenv("PATH")
@@ -306,12 +266,12 @@ class AscendEnvChecker(EnvChecker):
         self.ld_lib_path = os.getenv("LD_LIBRARY_PATH")
         self.ascend_opp_path = os.getenv("ASCEND_OPP_PATH")
         self.ascend_aicpu_path = os.getenv("ASCEND_AICPU_PATH")
+        self.compiler_version = self.ascend_opp_path.split("opp")[0] + "compiler/version.info"
 
         # check content
         self.path_check = "/compiler/ccec_compiler/bin"
         self.python_path_check = "opp/built-in/op_impl/ai_core/tbe"
         self.ld_lib_path_check_fwk = "/lib64"
-        self.ld_lib_path_check_addons = "/add-ons"
         self.ascend_opp_path_check = "/op"
         self.v = ""
 
@@ -322,36 +282,46 @@ class AscendEnvChecker(EnvChecker):
         else:
             os.environ[env_name] = env_value + ":" + os.environ[env_name]
 
-    @staticmethod
-    def _check_and_set_env(env_name, env_value, is_append=False):
-        """check and set environment variable by its name"""
-        if env_value is None:
+    def check_custom_version(self):
+        """custom op version check"""
+        custom_ascendc_soc_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                              "../lib/plugin/ascend/custom_ascendc_ops/op_impl/ai_core/tbe/kernel",
+                                              MSContext.get_instance().get_ascend_soc_version())
+        if not os.path.exists(custom_ascendc_soc_dir):
+            logger.debug(f"The path {custom_ascendc_soc_dir} of the custom ascend c operator does not exist.")
+            return False
+
+        if not Path(self.compiler_version).is_file():
             return True
 
-        if not Path(env_value).is_dir():
-            logger.error(
-                f"No such directory: {env_value}. Please check if Ascend AI software package (Ascend Data Center"
-                " Solution) is installed correctly.")
-            return False
+        cur_version = self._read_version(self.compiler_version)
+        custom_version_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                           "../lib/plugin/ascend/custom_ascendc_ops/version.info")
+        with open(custom_version_path, 'r') as f:
+            all_info = f.readlines()
+            for line in all_info:
+                full_version = line.strip().split("=")[1]
+                compile_version = '.'.join(full_version.split('.')[0:2])
+        if cur_version == compile_version:
+            return True
 
-        if is_append:
-            AscendEnvChecker._concat_variable(env_name, env_value)
-        else:
-            os.environ[env_name] = env_value
-        return True
+        logger.warning(
+            f"The version {compile_version} used for compiling the custom operator does not match "
+            f"Ascend AI software package version {cur_version} in the current environment.")
+        return False
 
     def check_env(self):
         self._check_env()
 
     def check_version(self):
-        if not Path(self.fwk_version).is_file():
+        if not Path(self.compiler_version).is_file():
             logger.warning("Using custom Ascend AI software package (Ascend Data Center Solution) path, package "
                            "version checking is skipped. Please make sure Ascend AI software package (Ascend Data "
                            "Center Solution) version is supported. For details, refer to the installation guidelines "
                            "https://www.mindspore.cn/install")
             return
 
-        v = self._read_version(self.fwk_version)
+        v = self._read_version(self.compiler_version)
         if v not in self.version:
             v_list = str([x for x in self.version])
             logger.warning(f"MindSpore version {__version__} and Ascend AI software package (Ascend Data Center "
@@ -397,10 +367,10 @@ class AscendEnvChecker(EnvChecker):
                 time.sleep(1)
 
     def set_env(self):
-        curr_path = os.path.abspath(os.path.dirname(__file__))
-        cust_aicpu_path = os.path.abspath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
-        cust_aicore_path = os.path.abspath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
-        cust_ascendc_path = os.path.abspath(os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_ops"))
+        curr_path = os.path.realpath(os.path.dirname(__file__))
+        cust_aicpu_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
+        cust_aicore_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
+        cust_ascendc_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_ops"))
         if os.getenv('ASCEND_CUSTOM_OPP_PATH'):
             os.environ['ASCEND_CUSTOM_OPP_PATH'] = os.environ['ASCEND_CUSTOM_OPP_PATH'] + ":" + \
                                                    cust_ascendc_path + ":" + cust_aicore_path + ":" + cust_aicpu_path
@@ -410,47 +380,11 @@ class AscendEnvChecker(EnvChecker):
         akg_dir = os.path.join(plugin_dir, "ascend")
         AscendEnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
 
-        if not self.tbe_path:
-            self._check_env()
-            return
-
-        try:
-            origin_path = deepcopy(sys.path)
-            import te  # pylint: disable=unused-import
-        # pylint: disable=broad-except
-        except Exception:
-            sys.path = deepcopy(origin_path)
-            if Path(self.tbe_path).is_dir():
-                os.environ['LD_LIBRARY_PATH'] = self.tbe_path + ":" + os.environ['LD_LIBRARY_PATH']
-            else:
-                logger.error(
-                    f"No such directory: {self.tbe_path}. Please check if Ascend AI software package (Ascend Data "
-                    "Center Solution) is installed correctly.")
-                return
+        self._check_env()
 
         # check te version after set te env
         self.check_deps_version()
 
-        if Path(self.op_impl_path).is_dir():
-            # python path for sub process
-            AscendEnvChecker._concat_variable('PYTHONPATH', self.op_impl_path)
-            # sys path for this process
-            sys.path.append(self.op_impl_path)
-
-            os.environ['TBE_IMPL_PATH'] = self.op_impl_path
-        else:
-            logger.error(
-                f"No such directory: {self.op_impl_path}. Please check if Ascend AI software package (Ascend Data "
-                "Center Solution) is installed correctly.")
-            return
-
-        if not AscendEnvChecker._check_and_set_env('PATH', self.cce_path, True):
-            return
-        if not AscendEnvChecker._check_and_set_env('ASCEND_OPP_PATH', self.op_path):
-            return
-        if not AscendEnvChecker._check_and_set_env('ASCEND_AICPU_PATH', self.aicpu_path):
-            return
-
     def _check_env(self):
         """ascend dependence path check"""
         if self.path is None or self.path_check not in self.path:
@@ -464,8 +398,7 @@ class AscendEnvChecker(EnvChecker):
                 "Environment Variable PYTHONPATH is set. For details, refer to the installation guidelines: "
                 "https://www.mindspore.cn/install")
 
-        if self.ld_lib_path is None or not (self.ld_lib_path_check_fwk in self.ld_lib_path and
-                                            self.ld_lib_path_check_addons in self.ld_lib_path):
+        if self.ld_lib_path is None or not self.ld_lib_path_check_fwk in self.ld_lib_path:
             logger.warning("Can not find driver so(need by mindspore-ascend). Please check whether the "
                            "Environment Variable LD_LIBRARY_PATH is set. For details, refer to the installation "
                            "guidelines: https://www.mindspore.cn/install")