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

mindspore/ops/primitive.py

@@ -171,6 +171,9 @@ class Primitive(Primitive_):
                     if not isinstance(in_value, int) and self.name not in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY:
                         raise TypeError(f'The {log_info}: {strategy} of {self.name} is not valid,'
                                         f' the value of strategy must be int type, but got:{type(in_value)}')
+                    if isinstance(in_value, Layout) and (self.name in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY):
+                        is_layout.append(True)
+                        continue
                 is_layout.append(False)
                 continue
             is_layout.append(True)
@@ -188,9 +191,17 @@ class Primitive(Primitive_):
                 raise TypeError(f'{log_info} must be tuple type, but got:{type(layout)}')
             layout_value = ()
             for in_ele in layout:
-                if not isinstance(in_ele, Layout):
-                    raise TypeError(f"The {log_info} item should be a object of class Layout.")
-                layout_value += (in_ele.to_dict(),)
+                if isinstance(in_ele, Layout):
+                    layout_value += (in_ele.to_dict(),)
+                elif isinstance(in_ele, tuple):
+                    new_layout_list = ()
+                    for ele in in_ele:
+                        if not isinstance(ele, Layout):
+                            raise TypeError(f"The {log_info} item should be a object of class Layout.")
+                        new_layout_list += (ele.to_dict(),)
+                    layout_value += (new_layout_list,)
+                else:
+                    raise TypeError(f"The {log_info} item should be a object of class Layout or a tuple.")
         return layout_value
 
     def _check_shard_strategy_in_out_match(self, in_strategy, out_strategy):
@@ -299,7 +310,8 @@ class Primitive(Primitive_):
         if out_strategy is not None:
             out_is_layout = self._check_shard_strategy(out_strategy, "out_strategy")
         self._check_shard_strategy_in_out_match(in_strategy, out_strategy)
-        if in_is_layout is not None and out_is_layout is not None and in_is_layout[0] != out_is_layout[0]:
+        if in_is_layout is not None and out_is_layout is not None and (
+                (in_is_layout[0] != out_is_layout[0]) and (self.name not in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY)):
             raise ValueError(f'The in_strategy type must equal to the out_strategy type, '
                              f'one using tuple(tuple) and the other using tuple(Layout) is not allowed.')
         in_layout_value = None
@@ -549,7 +561,7 @@ class PrimitiveWithCheck(Primitive):
     the shape and type. Method infer_value() can also be defined (such as PrimitiveWithInfer) for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.
@@ -643,7 +655,7 @@ class PrimitiveWithInfer(Primitive):
     logic of the shape and type. The infer_value() is used for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.

mindspore/ops_generate/arg_dtype_cast.py

@@ -238,6 +238,8 @@ def type_it(op_name, arg_name, data, src_type, dst_type):
     """
     cast operator argument data type.
     """
+    if isinstance(data, type(None)):
+        return data
     if not isinstance(src_type, tuple):
         src_type = int(src_type)
     else:

mindspore/ops_generate/gen_aclnn_implement.py

@@ -23,6 +23,7 @@ import pathlib
 import logging
 import gen_utils
 from pyboost_utils import AclnnUtils, get_dtypes
+from gen_constants import MS_OPS_KERNEL_PATH
 
 auto_gen = ''
 
@@ -35,7 +36,7 @@ def gen_h(op_name, aclnn_name, op_yaml, kernelmod_h_path, need_update_shape):
 #define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_{op_name.upper()}_ACLNN{auto_gen.upper()}_KERNEL_MOD_H_
 #include <vector>
 #include "ops/base_operator.h"
-#include "plugin/device/ascend/kernel/opapi/aclnn_kernel_mod.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
 #include "transform/acl_ir/acl_convert.h"
 """
     update_shape = f"""
@@ -78,7 +79,7 @@ def gen_cc(op_name, class_name, op_yaml, kernelmod_cc_path, need_update_shape):
     """generate cc files"""
     kernelmod_name = op_yaml.get('dispatch').get("Ascend")
     cc_head = f"""
-#include "plugin/device/ascend/kernel/opapi/aclnn{auto_gen}/{op_name}_aclnn_kernel.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn{auto_gen}/{op_name}_aclnn_kernel.h"
 #include <algorithm>
 #include <vector>
 #include <memory>
@@ -135,8 +136,7 @@ bool {kernelmod_name}::Launch(const std::vector<KernelTensor *> &inputs, const s
                               const std::vector<KernelTensor *> &outputs, void *stream_ptr) {{
   MS_EXCEPTION_IF_NULL(stream_ptr);
   {input_templete}
-  ParseGenExecutor(GEN_EXECUTOR_BOOST(op_type_, hash_id_, {inputs}));
-  RunOp(stream_ptr, workspace);
+  RunOp(stream_ptr, workspace, {inputs});
   return true;
 }}
 """
@@ -177,10 +177,10 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
     if check_op_registed(op_name) and not auto:
         logging.warning("Kernel {%s} is already registered.", op_name)
         return
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
 
-    aclnn_path = 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn/'
+    aclnn_path = '{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
     # merge inner ops
     op_yaml = yaml_str.get(op_name)
     class_name = ''.join(word.capitalize() for word in op_name.split('_'))
@@ -196,7 +196,7 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
             return
         auto_gen = "_auto_gen"
         dispatch['Ascend'] = class_name + "Ascend"
-        aclnn_path = 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn_auto_gen/'
+        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_auto_gen/'
         pathlib.Path(os.path.join(work_path, aclnn_path)).mkdir(parents=True, exist_ok=True)
     if dispatch.get("Ascend") is None:
         raise ValueError("KernelMod {} is auto generated. If need achieve it, "
@@ -208,10 +208,10 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
     generate(op_name, class_name, op_yaml, kernelmod_h_and_cc_path, need_update_shape)
 
 
-def get_registed_ops(file_path='mindspore/ccsrc/plugin/device/ascend/kernel/opapi/'):
+def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
     '''get registered ops by search files'''
-    # default search in 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/'
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    # default search in 'ops/kernel/ascend/opapi/'
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
     search_path = os.path.join(work_path, file_path)
     ret = []
@@ -230,7 +230,7 @@ def get_registed_ops(file_path='mindspore/ccsrc/plugin/device/ascend/kernel/opap
 
 
 registed_ops = get_registed_ops()
-manual_registed_ops = get_registed_ops('mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn/')
+manual_registed_ops = get_registed_ops(f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
 
 
 def check_op_registed(op_name, manual=False):

mindspore/ops_generate/gen_constants.py

@@ -0,0 +1,36 @@
+# Copyright 2024 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.
+# ============================================================================
+"""
+Generate constants
+"""
+import os
+
+# op_def
+OP_DEF_AUTO_GENERATE_PATH = "op_def/auto_generate"
+MS_OP_DEF_AUTO_GENERATE_PATH = "mindspore/ops/op_def/auto_generate"
+YAML_PATH = "op_def/yaml"
+MS_YAML_PATH = "mindspore/ops/" + YAML_PATH
+PY_AUTO_GEN_PATH = "mindspore/python/mindspore/ops/auto_generate"
+PY_OPS_GEN_PATH = "mindspore/python/mindspore/ops_generate"
+
+# infer
+MS_OPS_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl"
+
+# view
+MS_OPS_VIEW_PATH = "mindspore/ops/view"
+
+# kernel
+MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
+MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")

mindspore/ops_generate/gen_ops.py

@@ -28,6 +28,7 @@ import template
 from template import CppTemplate
 from gen_pyboost_func import gen_pyboost_code
 from gen_aclnn_implement import gen_aclnn_kernel
+import gen_constants as K
 
 
 def _get_op_name(yaml_key, yaml_value):
@@ -185,6 +186,7 @@ def generate_py_op_signature(op_name, args_signature, args_name, args_default):
     """
     Generate __mindspore_signature__
     """
+
     def _check_signature_arg_valid(op_name, sig_arg_names, args_names):
         for sig_arg_name in sig_arg_names:
             if sig_arg_name not in args_names:
@@ -635,7 +637,7 @@ def generate_op_prim_opdef(yaml_data):
 #include <memory>
 #include "ir/anf.h"
 #include "ir/primitive.h"
-#include "ops/auto_generate/gen_ops_name.h"
+#include "{K.MS_OP_DEF_AUTO_GENERATE_PATH}/gen_ops_name.h"
 #include "mindapi/base/macros.h"
 
 namespace mindspore::prim {{
@@ -665,7 +667,7 @@ def generate_lite_ops(yaml_data):
 
 #include <vector>
 #include "ops/base_operator.h"
-#include "ops/auto_generate/gen_ops_name.h"
+#include "{K.OP_DEF_AUTO_GENERATE_PATH}/gen_ops_name.h"
 
 namespace mindspore::ops {{
 """
@@ -674,14 +676,14 @@ namespace mindspore::ops {{
 #endif  // MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
 """
 
-    lite_ops_cc_head = """
-#include "ops/auto_generate/gen_lite_ops.h"
-#include "mindapi/src/helper.h"
+    lite_ops_cc_head = f"""
+#include "{K.OP_DEF_AUTO_GENERATE_PATH}/gen_lite_ops.h"
+#include "mindapi/helper.h"
 #include "ops/primitive_c.h"
 #include "ops/base_operator.h"
 #include "abstract/abstract_value.h"
 
-namespace mindspore::ops {
+namespace mindspore::ops {{
 """
 
     lite_ops_cc_end = f"""}}  // namespace mindspore::ops
@@ -694,7 +696,7 @@ namespace mindspore::ops {
     lite_ops_cc_gen += lite_ops_cc_head
     for operator_name, operator_data in yaml_data.items():
         op_name = _get_op_name(operator_name, operator_data)
-        lite_ops_h_gen += f"""class MIND_API {op_name} : public BaseOperator {{
+        lite_ops_h_gen += f"""class OPS_API {op_name} : public BaseOperator {{
  public:
   MIND_API_BASE_MEMBER({op_name});
   {op_name}() : BaseOperator(kName{op_name}) {{}}\n"""
@@ -740,12 +742,10 @@ def generate_cc_opdef(yaml_data):
     """
     gen_cc_code = f"""\n
 namespace mindspore::ops {{"""
-    gen_opdef_map = f"""
-std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
     gen_include = f"""\n
-#include \"ops/auto_generate/gen_ops_def.h\""""
+#include \"{K.MS_OP_DEF_AUTO_GENERATE_PATH}/gen_ops_def.h\""""
     gen_include += f"""
-#include \"mindspore/core/ir/signature.h\""""
+#include \"ir/signature.h\""""
 
     for operator_name, operator_data in yaml_data.items():
         args = operator_data.get('args')
@@ -764,15 +764,13 @@ std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
 
         is_view = operator_data.get('view')
         if is_view:
-            is_view = "true"
+            is_view_s = "true"
         else:
-            is_view = "false"
-        is_view_str = f"""{is_view}"""
-
+            is_view_s = "false"
+        is_view_str = f"""{is_view_s}"""
 
-        gen_include += f"""\n#include "ops/ops_func_impl/{operator_name}.h\""""
+        gen_include += f"""\n#include "{K.MS_OPS_FUNC_IMPL_PATH}/{operator_name}.h\""""
         cc_index_str = ''
-        gen_opdef_map += f"""\n  {{"{class_name}", &g{class_name}}},"""
         input_args_str = ''
         args_dict = {}
         for i, (arg_name, arg_info) in enumerate(args.items()):
@@ -814,8 +812,9 @@ std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
                                                        indexes=cc_index_str, enable_dispatch=enable_dispatch_str,
                                                        is_view=is_view_str)
         gen_cc_code += op_def_cc
-    gen_opdef_map += f"""\n}};"""
-    gen_cc_code += gen_opdef_map
+        if is_view:
+            view_op_def = op_def_cc.replace(class_name, class_name+"View")
+            gen_cc_code += view_op_def
 
     cc_opdef_end = f"""\n}}  // namespace mindspore::ops\n"""
     return gen_include + gen_cc_code + cc_opdef_end
@@ -835,7 +834,6 @@ from mindspore._c_expression import OpDtype
 from mindspore.common._stub_tensor import _convert_stub
 """
 
-
 ops_py_def_header = f"""
 \"\"\"Operators definition generated by gen_ops.py, includes functions.\"\"\"
 
@@ -847,8 +845,8 @@ from mindspore.ops._primitive_cache import _get_cache_prim
 
 
 def generate_ops_prim_file(work_path, yaml_str, doc_str, file_pre):
-    py_path = os.path.join(work_path, f'mindspore/python/mindspore/ops/auto_generate/{file_pre}_ops_prim.py')
-    tmp_py_path = os.path.join(work_path, f'mindspore/python/mindspore/ops/auto_generate/tmp_{file_pre}_ops_prim.py')
+    py_path = os.path.join(work_path, f'{K.PY_AUTO_GEN_PATH}/{file_pre}_ops_prim.py')
+    tmp_py_path = os.path.join(work_path, f'{K.PY_AUTO_GEN_PATH}/tmp_{file_pre}_ops_prim.py')
     pyboost_import_header = generate_pyboost_import_header(yaml_str)
     py_prim = generate_py_primitive(yaml_str, doc_str)
     write_file(tmp_py_path, py_licence_str + ops_py_prim_header + pyboost_import_header + py_prim)
@@ -856,8 +854,8 @@ def generate_ops_prim_file(work_path, yaml_str, doc_str, file_pre):
 
 
 def generate_ops_def_file(work_path, yaml_str, doc_str, file_pre):
-    py_path = os.path.join(work_path, f'mindspore/python/mindspore/ops/auto_generate/{file_pre}_ops_def.py')
-    tmp_py_path = os.path.join(work_path, f'mindspore/python/mindspore/ops/auto_generate/tmp_{file_pre}_ops_def.py')
+    py_path = os.path.join(work_path, f'{K.PY_AUTO_GEN_PATH}/{file_pre}_ops_def.py')
+    tmp_py_path = os.path.join(work_path, f'{K.PY_AUTO_GEN_PATH}/tmp_{file_pre}_ops_def.py')
     py_func = generate_py_op_func(yaml_str, doc_str)
     write_file(tmp_py_path, py_licence_str + ops_py_def_header + py_func)
     check_change_and_replace_file(py_path, tmp_py_path)
@@ -869,6 +867,8 @@ def generate_ops_py_files(work_path, yaml_str, doc_str, file_pre):
     """
     generate_ops_prim_file(work_path, yaml_str, doc_str, file_pre)
     generate_ops_def_file(work_path, yaml_str, doc_str, file_pre)
+    shutil.copy(os.path.join(work_path, K.PY_OPS_GEN_PATH, 'ops_auto_generate_init.txt'),
+                os.path.join(work_path, K.PY_AUTO_GEN_PATH, "__init__.py"))
 
 
 def generate_ops_cc_files(work_path, yaml_str):
@@ -876,35 +876,35 @@ def generate_ops_cc_files(work_path, yaml_str):
     Generate ops c++ file from yaml.
     """
     # ops_def
-    op_cc_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/gen_ops_def.cc')
-    tmp_op_cc_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/tmp_gen_ops_def.cc')
+    op_cc_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'gen_ops_def.cc')
+    tmp_op_cc_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'tmp_gen_ops_def.cc')
     cc_def_code = generate_cc_opdef(yaml_str)
     write_file(tmp_op_cc_path, cc_license_str + cc_def_code)
     check_change_and_replace_file(op_cc_path, tmp_op_cc_path)
 
     # ops_primitive
-    op_prim_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/gen_ops_primitive.h')
-    tmp_op_prim_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/tmp_gen_ops_primitive.h')
+    op_prim_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'gen_ops_primitive.h')
+    tmp_op_prim_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'tmp_gen_ops_primitive.h')
     op_prim_code = generate_op_prim_opdef(yaml_str)
     write_file(tmp_op_prim_path, cc_license_str + op_prim_code)
     check_change_and_replace_file(op_prim_path, tmp_op_prim_path)
 
     # lite_h_ops
-    lite_ops_h_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/gen_lite_ops.h')
-    tmp_lite_ops_h_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/tmp_gen_lite_ops.h')
+    lite_ops_h_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'gen_lite_ops.h')
+    tmp_lite_ops_h_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'tmp_gen_lite_ops.h')
     lite_ops_h_code, lite_ops_cc_code = generate_lite_ops(yaml_str)
     write_file(tmp_lite_ops_h_path, cc_license_str + lite_ops_h_code)
     check_change_and_replace_file(lite_ops_h_path, tmp_lite_ops_h_path)
 
     # lite_cc_ops
-    lite_ops_cc_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/gen_lite_ops.cc')
-    tmp_lite_ops_cc_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/tmp_gen_lite_ops.cc')
+    lite_ops_cc_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'gen_lite_ops.cc')
+    tmp_lite_ops_cc_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'tmp_gen_lite_ops.cc')
     write_file(tmp_lite_ops_cc_path, cc_license_str + lite_ops_cc_code)
     check_change_and_replace_file(lite_ops_cc_path, tmp_lite_ops_cc_path)
 
     # ops_names
-    op_name_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/gen_ops_name.h')
-    tmp_op_name_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/tmp_gen_ops_name.h')
+    op_name_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'gen_ops_name.h')
+    tmp_op_name_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH, 'tmp_gen_ops_name.h')
     op_name_code = generate_op_name_opdef(yaml_str)
     write_file(tmp_op_name_path, cc_license_str + op_name_code)
     check_change_and_replace_file(op_name_path, tmp_op_name_path)
@@ -958,7 +958,7 @@ def generate_create_instance_helper_file(work_path, yaml_str):
     """
     Generate C++ helper file from yaml.
     """
-    dst_dir = os.path.join(work_path, 'mindspore/python/mindspore/ops/auto_generate')
+    dst_dir = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
     op_py_path = os.path.join(dst_dir, 'cpp_create_prim_instance_helper.py')
     tmp_op_py_path = os.path.join(dst_dir, 'tmp_cpp_create_prim_instance_helper.py')
     py_labels = generate_op_labels(yaml_str)
@@ -969,13 +969,13 @@ def generate_create_instance_helper_file(work_path, yaml_str):
 
 def generate_aclnn_reg_code(yaml_data):
     """generate aclnn register code"""
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
-    ops_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops.yaml')
+    ops_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, "ops.yaml")
     yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
 
     reg_code = f"""
-#include "plugin/device/ascend/kernel/opapi/aclnn_kernel_mod.h"
+#include "{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
 
 namespace mindspore {{
 namespace kernel {{
@@ -1010,8 +1010,8 @@ def generate_aclnn_reg_file(work_path, yaml_str):
     """
     Generate nnacl kernelmod register
     """
-    tmp_register_file = work_path + 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/tmp_aclnn_kernel_register.cc'
-    register_file = work_path + 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn_kernel_register_auto.cc'
+    tmp_register_file = work_path + f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/tmp_aclnn_kernel_register.cc'
+    register_file = work_path + f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
     reg_code = generate_aclnn_reg_code(yaml_str)
     write_file(tmp_register_file, cc_license_str + reg_code)
     check_change_and_replace_file(register_file, tmp_register_file)
@@ -1021,39 +1021,52 @@ def generate_arg_handler_files(work_path):
     """
     Generate arg handler files.
     """
-    dst_dir = os.path.join(work_path, 'mindspore/python/mindspore/ops/auto_generate')
-    src_arg_handler_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/arg_handler.py')
+    dst_dir = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
+    src_arg_handler_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'arg_handler.py')
     dst_arg_handler_path = os.path.join(dst_dir, 'gen_arg_handler.py')
     tmp_dst_arg_handler_path = os.path.join(dst_dir, 'tmp_gen_arg_handler.py')
     if not os.path.exists(dst_dir):
-        os.makedirs(dst_dir)
+        os.makedirs(dst_dir, mode=0o700)
     shutil.copy(src_arg_handler_path, tmp_dst_arg_handler_path)
     check_change_and_replace_file(dst_arg_handler_path, tmp_dst_arg_handler_path)
 
-    src_arg_dtype_cast_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/arg_dtype_cast.py')
+    src_arg_dtype_cast_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'arg_dtype_cast.py')
     dst_arg_dtype_cast_path = os.path.join(dst_dir, 'gen_arg_dtype_cast.py')
     tmp_arg_dtype_cast_path = os.path.join(dst_dir, 'tmp_arg_dtype_cast.py')
     shutil.copy(src_arg_dtype_cast_path, tmp_arg_dtype_cast_path)
     check_change_and_replace_file(dst_arg_dtype_cast_path, tmp_arg_dtype_cast_path)
 
 
+def get_view_ops(yaml_data):
+    """
+    Get ops with view: True
+    """
+    view_ops = []
+    for operator_name, operator_data in yaml_data.items():
+        class_name = _get_op_name(operator_name, operator_data)
+        view = operator_data.get("view")
+        if view:
+            view_ops.append(class_name + "View")
+    return view_ops
+
+
 def main():
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
 
     # merge ops yaml
-    ops_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops.yaml')
-    doc_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_generate/ops_doc.yaml')
+    ops_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'ops.yaml')
+    doc_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'ops_doc.yaml')
 
-    ops_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/')
-    infer_ops_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/infer/')
-    doc_yaml_dir_path = os.path.join(work_path, 'mindspore/core/ops/ops_def/doc/')
+    ops_yaml_dir_path = os.path.join(work_path, K.MS_YAML_PATH)
+    infer_ops_yaml_dir_path = os.path.join(ops_yaml_dir_path, "infer")
+    doc_yaml_dir_path = os.path.join(ops_yaml_dir_path, "doc")
     merge_files(ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
     merge_files_append(infer_ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
     merge_files(doc_yaml_dir_path, doc_yaml_path, '*doc.yaml')
 
     # make auto_generate dir
-    cc_path = os.path.join(work_path, 'mindspore/core/ops/auto_generate/')
+    cc_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
     pathlib.Path(cc_path).mkdir(parents=True, exist_ok=True)
 
     # generate arg_handler files
@@ -1070,8 +1083,10 @@ def main():
     generate_ops_cc_files(work_path, ops_yaml_str)
     # generate create prim instance helper file
     generate_create_instance_helper_file(work_path, ops_yaml_str)
+    # get view extra ops
+    extra_ops = get_view_ops(ops_yaml_str)
     # generate pyboost code
-    gen_pyboost_code(work_path, ops_yaml_str, doc_yaml_str)
+    gen_pyboost_code(work_path, ops_yaml_str, doc_yaml_str, extra_ops)
     # generate aclnn kernelmod register
     generate_aclnn_reg_file(work_path, ops_yaml_str)
 

mindspore/ops_generate/gen_ops_inner_prim.py

@@ -42,7 +42,7 @@ class DtypeToEnum(Primitive):
     def __call__(self, op_name, arg_name, dtype):
         """Run in PyNative mode"""
         if not isinstance(dtype, typing.Type):
-            raise TypeError(f"For '{op_name}', the input '{arg_name}' should be mindpsore dtype, but got {dtype}.")
+            raise TypeError(f"For '{op_name}', the input '{arg_name}' should be mindspore dtype, but got {dtype}.")
         return typing.type_to_type_id(dtype)