mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/ops_generate/{gen_aclnn_implement.py → aclnn/gen_aclnn_implement.py}

@@ -17,16 +17,16 @@ Generate aclnn kernelmod or call func by input name in ops.yaml
 """
 import argparse
 import os
-import stat
 import re
 import pathlib
 import logging
-import gen_utils
-import template
-from op_proto import OpProto
-from pyboost_utils import AclnnUtils, get_dtypes
-from gen_constants import MS_OPS_KERNEL_PATH
-import gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+import common.gen_constants as K
+from common.op_proto import OpProto
+from common.gen_constants import MS_OPS_KERNEL_PATH
+from pyboost.pyboost_utils import AclnnUtils, get_dtypes
+
 auto_gen = ''
 
 
@@ -37,25 +37,21 @@ def gen_h(kernelmod_name, aclnn_name, op_proto, kernelmod_h_path, need_update_sh
     if not need_update_shape:
         update_shape = "\n  "
 
-    temp_file = kernelmod_h_path + "_tmp.h"
-    old_file = kernelmod_h_path + ".h"
-    flags = os.O_WRONLY | os.O_CREAT
-    mode = stat.S_IWUSR | stat.S_IRUSR
+    file_path = kernelmod_h_path + ".h"
     aclnn_kernel_h_str = template.ACLNN_KERNEL_H_TEMPLATE.replace(aclnn_name=aclnn_name,
                                                                   op_name=op_name.upper(),
                                                                   auto_gen=auto_gen.upper(),
                                                                   kernelmod_name=kernelmod_name,
                                                                   update_shape=update_shape,
                                                                   ops_kernel_path=MS_OPS_KERNEL_PATH)
-    with os.fdopen(os.open(temp_file, flags, mode), 'w') as h_file:
-        h_file.write(aclnn_kernel_h_str)
-    gen_utils.check_change_and_replace_file(old_file, temp_file)
+    gen_utils.save_file(os.path.dirname(file_path), os.path.basename(file_path), aclnn_kernel_h_str)
 
 
 def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_shape):
     """generate cc files"""
     op_name = op_proto.op_name
-    tuple_tensor_not_supported = template.TUPLE_TENSOR_NOT_SUPPORTED.replace(op_name=op_name)
+    tuple_tensor_not_supported = template.TUPLE_TENSOR_NOT_SUPPORTED.replace(
+        op_name=op_name)
     input_templete = '\n  '
     inputs = ''
     input_dtypes, output_dtypes, _ = get_dtypes(op_proto)
@@ -65,7 +61,7 @@ def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_
         if dtype != 'tensor':
             if dtype == 'int':
                 dtype = 'int64_t'
-            input_templete += "  auto {} = transform::ConvertKernelTensor<{}>(inputs[kIndex{}]);\n".format(
+            input_templete += "  auto {} = device::ascend::ConvertKernelTensor<{}>(inputs[kIndex{}]);\n".format(
                 n.arg_name, dtype, idx)
             input_name = n.arg_name + ", "
         if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
@@ -78,7 +74,7 @@ def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_
         if dtype != 'tensor':
             if dtype == 'int':
                 dtype = 'int64_t'
-            input_templete += "  auto {} = transform::ConvertKernelTensor<{}>(outputs[kIndex{}]);\n".format(
+            input_templete += "  auto {} = device::ascend::ConvertKernelTensor<{}>(outputs[kIndex{}]);\n".format(
                 n.arg_name, dtype, idx)
             output_name = n.arg_name + ", "
         if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
@@ -86,14 +82,12 @@ def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_
         inputs += output_name
     inputs = inputs[:-2]
 
-    update_shape = template.update_output_shape_and_size_template.replace(kernelmod_name=kernelmod_name)
+    update_shape = template.update_output_shape_and_size_template.replace(
+        kernelmod_name=kernelmod_name)
     if not need_update_shape:
         update_shape = ""
 
-    temp_file = kernelmod_cc_path + "_tmp.cc"
-    old_file = kernelmod_cc_path + ".cc"
-    flags = os.O_WRONLY | os.O_CREAT
-    mode = stat.S_IWUSR | stat.S_IRUSR
+    file_path = kernelmod_cc_path + ".cc"
     aclnn_kernel_cc_str = template.ACLNN_KERNEL_CC_TEMPLATE.replace(kernelmod_name=kernelmod_name,
                                                                     input_templete=input_templete,
                                                                     inputs=inputs,
@@ -102,9 +96,7 @@ def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_
                                                                     auto_gen_path=MS_OPS_KERNEL_PATH,
                                                                     op_name=op_name,
                                                                     auto_gen=auto_gen) + "    "
-    with os.fdopen(os.open(temp_file, flags, mode), 'w') as cc_file:
-        cc_file.write(aclnn_kernel_cc_str)
-    gen_utils.check_change_and_replace_file(old_file, temp_file)
+    gen_utils.save_file(os.path.dirname(file_path), os.path.basename(file_path), aclnn_kernel_cc_str)
 
 
 def generate(kernelmod_name, class_name, op_proto, h_and_cc, need_update_shape):
@@ -119,13 +111,12 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
     op_name = op_proto.op_name
     skip_aclnn_list = {"slice", "expand_dims", "squeeze", "split", "generator"}
     if op_name in skip_aclnn_list:
-        logging.warning("Operator {%s} has no aclnn interface, no aclnn kernel will be generated.", op_name)
+        logging.warning(
+            "Operator {%s} has no aclnn interface, no aclnn kernel will be generated.", op_name)
         return
     if check_op_registed(op_proto.op_name) and not auto:
         logging.warning("Kernel {%s} is already registered.", op_name)
         return
-    current_path = os.path.dirname(os.path.realpath(__file__))
-    work_path = os.path.join(current_path, '../../../../')
 
     aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
     # merge inner ops
@@ -133,39 +124,39 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
     aclnn_name = ''.join(word.capitalize() for word in op_name.split('_'))
     kernelmod_name = op_proto.op_dispatch.ascend
     if not dispatch or not op_proto.op_dispatch.enable:
-        raise ValueError("Op {} is not enabled dispatch, please check.".format(op_name))
+        raise ValueError(
+            "Op {} is not enabled dispatch, please check.".format(op_name))
     global auto_gen
     if auto:
-        if check_op_registed(op_name, True):
-            # Don't auto generate kernelmod if it is achieved manually.
-            return
         auto_gen = "_auto_gen"
         kernelmod_name = aclnn_name + "Ascend"
         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)
+        pathlib.Path(os.path.join(K.WORK_DIR, aclnn_path)
+                     ).mkdir(parents=True, exist_ok=True)
     if dispatch.ascend is None:
         raise ValueError("KernelMod {} is auto generated. If need achieve it, "
                          "please provide the KernelMod name in dispatch.".format(op_name))
     op_class = op_proto.op_class
     if op_class is not None and op_class.name is not None:
         aclnn_name = op_class.name
-    kernelmod_h_and_cc_path = os.path.join(work_path, aclnn_path + '{}_aclnn_kernel'.format(op_name))
-    generate(kernelmod_name, aclnn_name, op_proto, kernelmod_h_and_cc_path, need_update_shape)
+    kernelmod_h_and_cc_path = os.path.join(
+        K.WORK_DIR, aclnn_path + '{}_aclnn_kernel'.format(op_name))
+    generate(kernelmod_name, aclnn_name, op_proto,
+             kernelmod_h_and_cc_path, need_update_shape)
 
 
 def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
     '''get registered ops by search files'''
     # 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)
+    search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
         for root_path, _, files in os.walk(search_path):
             for file_name in files:
                 with open(os.path.join(root_path, file_name), "r") as f:
                     file_context = f.read()
-                    search_re = re.search(r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
+                    search_re = re.search(
+                        r"(?<=KERNEL_FACTORY_REG\()\w+(?=,)", file_context)
                     if search_re:
                         ret.append(search_re.group())
     except OSError:
@@ -175,7 +166,8 @@ def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 
 registed_ops = get_registed_ops()
-manual_registed_ops = get_registed_ops(f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+manual_registed_ops = get_registed_ops(
+    f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
 
 
 def check_op_registed(op_name, manual=False):
@@ -186,9 +178,7 @@ def check_op_registed(op_name, manual=False):
 
 def generate_aclnn_reg_code(yaml_data):
     """generate aclnn register code"""
-    current_path = os.path.dirname(os.path.realpath(__file__))
-    work_path = os.path.join(current_path, '../../../../')
-    ops_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, "ops.yaml")
+    ops_yaml_path = os.path.join(K.WORK_DIR, K.PY_OPS_GEN_PATH, "ops.yaml")
     yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
 
     reg_code = f"""
@@ -205,17 +195,20 @@ namespace kernel {{
         if Ascend is not None:  # KernelMod is provided by yaml, don't auto generate it.
             continue
         if check_op_registed(operator_name):
-            logging.warning("Kernel {%s} is already registered.", operator_name)
+            logging.warning(
+                "Kernel {%s} is already registered.", operator_name)
             continue
         _, _, none_tensor_exist = get_dtypes(operator_data)
         if none_tensor_exist:
             gen_aclnn_kernel(operator_name, yaml_str, auto=True)
             continue
-        class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
+        class_name = ''.join(word.capitalize()
+                             for word in operator_name.split('_'))
         op_class = operator_data.get("class")
         if op_class and op_class.get("name") is not None:
             class_name = op_class.get("name")
-        inputs_outputs_num = len(operator_data.get("args")) + len(operator_data.get("returns"))
+        inputs_outputs_num = len(operator_data.get(
+            "args")) + len(operator_data.get("returns"))
         aclnn_name = AclnnUtils.get_aclnn_interface(class_name)
         reg_code += f"""
 MS_ACLNN_COMMON_KERNEL_FACTORY_REG({class_name}, {aclnn_name}, {inputs_outputs_num});"""
@@ -230,10 +223,13 @@ def generate_aclnn_reg_file(work_path, yaml_str):
     """
     Generate nnacl kernelmod register
     """
-    tmp_register_file = work_path + f'{MS_OPS_KERNEL_PATH}/ascend/opapi/tmp_aclnn_kernel_register.cc'
-    register_file = work_path + f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
+    tmp_register_file = work_path + \
+        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/tmp_aclnn_kernel_register.cc'
+    register_file = work_path + \
+        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
     reg_code = generate_aclnn_reg_code(yaml_str)
-    gen_utils.write_file(tmp_register_file, gen_utils.cc_license_str + reg_code)
+    gen_utils.save_file(
+        os.path.dirname(tmp_register_file), os.path.basename(tmp_register_file), gen_utils.cc_license_str + reg_code)
     gen_utils.check_change_and_replace_file(register_file, tmp_register_file)
 
 
@@ -243,7 +239,8 @@ def main(op_name, need_update_shape):
 
 
 parser = argparse.ArgumentParser(description="Generate aclnn KernelMod.")
-parser.add_argument('-n', '--name', type=str, default=None, help='Kernel name in yaml.')
+parser.add_argument('-n', '--name', type=str, default=None,
+                    help='Kernel name in yaml.')
 parser.add_argument('-d', '--need_update_shape', type=bool, default=False,
                     help="Some kernel like:unique need update shape and size after launch. Default: False")
 options, _ = parser.parse_known_args()
@@ -252,7 +249,8 @@ if __name__ == "__main__":
     try:
         name = options.name
         if name is None:
-            raise ValueError("Please provide op name to generate aclnn kernelmod.")
+            raise ValueError(
+                "Please provide op name to generate aclnn kernelmod.")
         is_need_update_shape = options.need_update_shape
         main(name, is_need_update_shape)
     except Exception as e:  # pylint: disable=W0703

mindspore/ops_generate/{add_tensor_docs_generator.py → api/add_tensor_docs_generator.py}

@@ -17,11 +17,11 @@ Generates mindspore/common/_tensor_docs.py that attaches docs to tensor func API
 """
 
 import os
-import gen_constants as K
-from gen_utils import save_file
-import template
-from template import Template
-from base_generator import BaseGenerator
+import common.gen_constants as K
+from common.gen_utils import save_file, safe_load_yaml_from_dir
+import common.template as template
+from common.template import Template
+from common.base_generator import BaseGenerator
 
 
 class AddTensorDocsGenerator(BaseGenerator):
@@ -32,8 +32,9 @@ class AddTensorDocsGenerator(BaseGenerator):
     def __init__(self):
         self.ADD_TENSOR_DOCS_TEMPLATE = template.ADD_TENSOR_DOCS_TEMPLATE
         self.attach_single_docstr_template = Template('attach_docstr("${api_name}", r"""${docstr}""")')
+        self.tensor_method_doc_yaml_dir_path = os.path.join(K.WORK_DIR, K.MS_TENSOR_METHOD_DOC_YAML_PATH)
 
-    def generate(self, work_path, tensor_docs_data):
+    def generate(self):
         """
         Generates the content for the helper file and saves it to the specified path.
 
@@ -45,10 +46,11 @@ class AddTensorDocsGenerator(BaseGenerator):
             None
         """
         add_doc_statements = []
+        tensor_docs_data = safe_load_yaml_from_dir(self.tensor_method_doc_yaml_dir_path)
         for api_name, tensor_doc in tensor_docs_data.items():
             single_add_doc_statement = self.attach_single_docstr_template.replace(api_name=api_name,
                                                                                   docstr=tensor_doc['description'])
             single_add_doc_statement += template.NEW_LINE
             add_doc_statements.append(single_add_doc_statement)
         _tensor_docs_py_str = self.ADD_TENSOR_DOCS_TEMPLATE.replace(add_doc_statements=add_doc_statements)
-        save_file(os.path.join(work_path, K.ADD_TENSOR_DOCS_PY_PATH), "_tensor_docs.py", _tensor_docs_py_str)
+        save_file(os.path.join(K.WORK_DIR, K.ADD_TENSOR_DOCS_PY_PATH), "_tensor_docs.py", _tensor_docs_py_str)

mindspore/ops_generate/{cpp_create_prim_instance_helper_generator.py → api/cpp_create_prim_instance_helper_generator.py}

@@ -18,14 +18,11 @@ Generates C++ helper files for primitive instance creation based on operator met
 
 import os
 
-import gen_constants as K
-import gen_utils
-import pyboost_utils
-
-# refactored
-import template
-
-from base_generator import BaseGenerator
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+from common.base_generator import BaseGenerator
+from pyboost import pyboost_utils
 
 
 class CppCreatePrimInstanceHelperGenerator(BaseGenerator):
@@ -56,7 +53,7 @@ class CppCreatePrimInstanceHelperGenerator(BaseGenerator):
         """
         py_arg_default = self.generate_op_arg_default_value(op_protos)
         py_labels = self.generate_op_labels(op_protos)
-        res_str = (template.PY_LICENCE_STR + py_arg_default + py_labels)
+        res_str = (template.PY_LICENSE_STR + py_arg_default + py_labels)
 
         save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
         file_name = "cpp_create_prim_instance_helper.py"

mindspore/ops_generate/{functional_map_cpp_generator.py → api/functional_map_cpp_generator.py}

@@ -17,11 +17,12 @@ Generates C++ functional map header files for graph mode.
 """
 
 import os
-import template
-import pyboost_utils
-import gen_constants as K
-from gen_utils import save_file
-from base_generator import BaseGenerator
+
+import common.gen_constants as K
+import common.template as template
+from common.gen_utils import save_file, OrderedSet
+from common.base_generator import BaseGenerator
+from pyboost import pyboost_utils
 
 
 class FunctionalMapCppGenerator(BaseGenerator):
@@ -79,9 +80,11 @@ class FunctionalMapCppGenerator(BaseGenerator):
         Returns:
             None
         """
+        ops_inc_head_set = set()
         dep_method_decl_list = self._get_dep_method_decl_list(tensor_method_protos_data)
-        tensor_method_overload_list = self._get_functional_method_map(tensor_method_protos_data, alias_func_mapping)
-        mint_overload_list = self._get_functional_mint_map(mint_func_protos_data, alias_func_mapping)
+        tensor_method_overload_list, op_inc_1 = self._get_functional_method_map(tensor_method_protos_data,
+                                                                                alias_func_mapping)
+        mint_overload_list, op_inc_2 = self._get_functional_mint_map(mint_func_protos_data, alias_func_mapping)
         tensor_method_kw_only_args_list = self._get_tensor_method_kwonlyargs_map(tensor_method_protos_data)
         mint_kw_only_args_list = self._get_mint_kwonlyargs_map(mint_func_protos_data, alias_func_mapping)
         tensor_varargs_map_list = self._get_tensor_varargs_map_list(tensor_method_protos_data)
@@ -90,8 +93,12 @@ class FunctionalMapCppGenerator(BaseGenerator):
             self._get_func_sigs_list(tensor_method_protos_data, alias_func_mapping, is_tensor_method=True))
         funcs_mint_sigs_map = (
             self._get_func_sigs_list(mint_func_protos_data, alias_func_mapping, is_tensor_method=False))
+        merge_op_inc = op_inc_1 | op_inc_2
+        for op_inc in merge_op_inc:
+            ops_inc_head_set.add(template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_inc[0].lower()))
         functional_map_cc_code = (
-            self.FUNCTIONAL_MAP_CC_TEMPLATE.replace(deprecated_method_decl=dep_method_decl_list,
+            self.FUNCTIONAL_MAP_CC_TEMPLATE.replace(ops_inc=list(sorted(ops_inc_head_set)),
+                                                    deprecated_method_decl=dep_method_decl_list,
                                                     tensor_method_map=tensor_method_overload_list,
                                                     mint_map=mint_overload_list,
                                                     tensor_method_kwonlyargs_map=tensor_method_kw_only_args_list,
@@ -100,7 +107,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
                                                     mint_varargs_map=mint_varargs_map_list,
                                                     tensor_method_sigs_map=funcs_sig_map_list,
                                                     mint_sigs_map=funcs_mint_sigs_map))
-        save_path = os.path.join(work_path, K.PIPELINE_PYBOOST_FUNC_GEN_PATH)
+        save_path = os.path.join(work_path, K.FUNCTIONAL_OVERLOAD_GEN_PATH)
         save_file(save_path, "functional_map.cc", functional_map_cc_code)
         save_file(save_path, "functional_map.h", self.FUNCTIONAL_MAP_H_TEMPLATE.replace())
 
@@ -138,7 +145,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
         Returns:
             str: Generated function signatures string.
         """
-        sig_set = set()
+        sig_set = OrderedSet()
         for tensor_proto in func_protos:
             sig_set.add(self._generate_single_signature_str(func_api_name, tensor_proto, is_tensor_method))
         sig_list = list(sig_set)
@@ -312,6 +319,8 @@ class FunctionalMapCppGenerator(BaseGenerator):
                 list: A list of strings, each representing a functional method map.
         """
 
+        op_inc_set = set()
+
         def get_sort_func_method_list(func_protos):
             """
             Retrieves a sorted list of operator primitives, prioritizing deprecated operators.
@@ -323,6 +332,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
                     func_method_list.append(k_op_name)
                 else:
                     func_method_list.append(self.k_prim_op_template.replace(camel_op_name=k_op_name))
+                    op_inc_set.add(k_op_name)
 
             func_method_list.sort(key=lambda x: x.startswith("Deprecated"), reverse=True)
             return func_method_list
@@ -340,13 +350,15 @@ class FunctionalMapCppGenerator(BaseGenerator):
                         self.functional_method_map_template.replace(op_name=alias,
                                                                     sort_func_method_list_str=sort_func_method_list))
 
-        return deprecated_method_decl_list
+        return deprecated_method_decl_list, op_inc_set
 
     def _get_functional_mint_map(self, mint_func_protos_data, alias_func_mapping):
         """
         mint_func_protos_data (dict): A dictionary mapping mint API names to their prototype data.
         """
 
+        op_inc_set = set()
+
         def get_mint_func_list(func_protos):
             """
             Retrieves a sorted list of operator primitives, prioritizing deprecated operators.
@@ -355,6 +367,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
             for func_proto in func_protos:
                 k_op_name = pyboost_utils.get_op_name(func_proto.op_proto.op_name, func_proto.op_proto.op_class.name)
                 func_method_list.append(self.k_prim_op_template.replace(camel_op_name=k_op_name))
+                op_inc_set.add(k_op_name)
 
             return func_method_list
 
@@ -369,7 +382,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
                     mint_func_decl_list.append(
                         self.functional_method_map_template.replace(op_name=alias,
                                                                     sort_func_method_list_str=mint_func_list))
-        return mint_func_decl_list
+        return mint_func_decl_list, op_inc_set
 
     def _get_and_append_single_op_kw_only_args_list(self, func_protos, single_op_kw_only_args_list):
         """

mindspore/ops_generate/{functional_overload_py_generator.py → api/functional_overload_py_generator.py}

@@ -21,12 +21,12 @@ constants for operator names based on given prototypes.
 
 import os
 
-import gen_constants as K
-import gen_utils
-import template
-from template import Template
+import common.gen_constants as K
+import common.gen_utils as gen_utils
+import common.template as template
+from common.template import Template
 
-from base_generator import BaseGenerator
+from common.base_generator import BaseGenerator
 
 
 class FunctionalOverloadPyGenerator(BaseGenerator):
@@ -40,6 +40,7 @@ class FunctionalOverloadPyGenerator(BaseGenerator):
         """
         self.FUNCTIONAL_OVERLOAD_PY_TEMPLATE = template.FUNCTIONAL_OVERLOAD_PY_TEMPLATE
 
+        self.mint_func_doc_yaml_dir_path = os.path.join(K.WORK_DIR, K.MS_MINT_FUNC_DOC_YAML_PATH)
         self.import_mint_template = Template("from mindspore._c_expression import _${cpp_func_name}_instance\n")
         self.mint_def_template = Template(
             'def ${mint_func_name}(*args, **kwargs):\n'
@@ -47,7 +48,7 @@ class FunctionalOverloadPyGenerator(BaseGenerator):
             '    return _${cpp_func_name}_instance(*args, **kwargs)\n\n\n'
         )
 
-    def generate(self, work_path, mint_func_protos_data, function_doc_data, alias_api_mapping):
+    def generate(self, work_path, mint_func_protos_data, alias_api_mapping):
         """
         Generates python code for operator names and saves it to a header file.
 
@@ -56,6 +57,7 @@ class FunctionalOverloadPyGenerator(BaseGenerator):
             function_doc_data (dict): A dictionary mapping function names to their docstring data.
             alias_api_mapping (dict): A dictionary mapping aliases to their prototype data.
         """
+        function_doc_data = gen_utils.safe_load_yaml_from_dir(self.mint_func_doc_yaml_dir_path)
         validate_func_docs(mint_func_protos_data, function_doc_data, alias_api_mapping)
         import_mint_list, mint_init_list, mint_def_list, add_to_all_list = [], [], [], []
         for mint_api_name, _ in mint_func_protos_data.items():

mindspore/ops_generate/{functions_cc_generator.py → api/functions_cc_generator.py}

@@ -18,12 +18,12 @@ This module provides classes for generating C++ header and implementation files
 
 import os
 
-import template
-from template import Template
-import gen_constants as K
-from gen_utils import save_file
-from base_generator import BaseGenerator
-from pyboost_utils import is_optional_param, get_input_dtype, get_return_type
+import common.template as template
+from common.template import Template
+import common.gen_constants as K
+from common.gen_utils import save_file
+from common.base_generator import BaseGenerator
+from pyboost.pyboost_utils import is_optional_param, get_input_dtype, get_return_type
 
 
 class FunctionsHeaderGenerator(BaseGenerator):
@@ -57,7 +57,7 @@ class FunctionsHeaderGenerator(BaseGenerator):
                                                                  return_type=return_type_str)
             functions_list.append(functions)
         pyboost_func_h_str = self.FUNCTIONS_H_TEMPLATE.replace(op_call_with_grad=functions_list)
-        save_path = os.path.join(work_path, K.MS_OPS_KERNEL_FUNCTIONS_AUTO_GEN_PATH)
+        save_path = os.path.join(work_path, K.MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH)
         file_name = "functions.h"
         save_file(save_path, file_name, pyboost_func_h_str)
 
@@ -90,7 +90,7 @@ class FunctionsGenerator(BaseGenerator):
         self.FUNCTIONS_CC_TEMPLATE = template.FUNCTIONS_CC_TEMPLATE
         self.FUNCTION_BODY_TEMPLATE = template.FUNCTION_BODY_TEMPLATE
         self.pyboost_func_include_header_template = Template(
-            f'#include "{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/${{operator_name}}.h"\n'
+            f'#include "{K.MS_PYBOOST_BASE_PATH}/auto_generate/${{operator_name}}.h"\n'
         )
         self.clone_inplace_input_template = Template(
             'GetCloneFunc()(op, prim::kPrim${class_name}, device_target, {${grad_args}});'
@@ -106,15 +106,19 @@ class FunctionsGenerator(BaseGenerator):
         """
         func_include_headers_list = []
         op_call_with_grad_list = []
+        ops_inc_head_set = set()
         for op_proto in op_protos:
             if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
                 continue
             func_include_headers_list.append(
                 self.pyboost_func_include_header_template.replace(operator_name=op_proto.op_name))
             op_call_with_grad_list.append(self._get_function_body(op_proto))
+            ops_inc_head_set.add(
+                template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
         pyboost_func_h_str = self.FUNCTIONS_CC_TEMPLATE.replace(op_call_with_grad=op_call_with_grad_list,
-                                                                pyboost_op_header_include=func_include_headers_list)
-        save_path = os.path.join(work_path, K.MS_OPS_KERNEL_FUNCTIONS_AUTO_GEN_PATH)
+                                                                pyboost_op_header_include=func_include_headers_list,
+                                                                ops_inc=list(sorted(ops_inc_head_set)))
+        save_path = os.path.join(work_path, K.MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH)
         file_name = "functions.cc"
         save_file(save_path, file_name, pyboost_func_h_str)
 

mindspore/ops_generate/api/gen_api.py

@@ -0,0 +1,103 @@
+# Copyright 2025 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 api definition files
+"""
+import copy
+
+from resources.resource_list import ResourceType
+from common import gen_constants as K
+from tensor_py_cc_generator import TensorPyCppGenerator
+
+from .tensor_func_reg_cpp_generator import TensorFuncRegCppGenerator
+from .functional_map_cpp_generator import FunctionalMapCppGenerator
+from .add_tensor_docs_generator import AddTensorDocsGenerator
+from .functional_overload_py_generator import FunctionalOverloadPyGenerator
+from .cpp_create_prim_instance_helper_generator import CppCreatePrimInstanceHelperGenerator
+
+
+def gen_tensor_func_code(work_path, op_protos, func_protos, alias_api_mapping):
+    generator = TensorFuncRegCppGenerator()
+    generator.generate(work_path, op_protos, func_protos, alias_api_mapping)
+
+
+def gen_functional_map_code(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping):
+    generator = FunctionalMapCppGenerator()
+    generator.generate(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping)
+
+
+def gen_tensor_docs_code():
+    generator = AddTensorDocsGenerator()
+    generator.generate()
+
+
+def gen_functional_overload_py(work_path, mint_func_protos, alias_api_mapping):
+    generator = FunctionalOverloadPyGenerator()
+    generator.generate(work_path, mint_func_protos, alias_api_mapping)
+
+
+def gen_tensor_py_cc(work_path, tensor_method_protos, alias_api_mapping):
+    generator = TensorPyCppGenerator()
+    generator.generate(work_path, tensor_method_protos, alias_api_mapping)
+
+
+def generate_create_instance_helper_file(resource_mgr):
+    """
+    Generate C++ helper file from yaml.
+    """
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    tensor_method_protos = resource_mgr.get_resource(ResourceType.TENSOR_METHOD_PROTOS)
+    op_protos_with_deprecated = get_tensor_op_protos_with_deprecated(tensor_method_protos, op_protos)
+    generator = CppCreatePrimInstanceHelperGenerator()
+    generator.generate(K.WORK_DIR, op_protos_with_deprecated)
+
+
+def get_tensor_op_protos_with_deprecated(func_protos, op_protos):
+    """
+    Get op_protos with deprecated op_protos from func_protos.
+    """
+    tensor_op_protos = copy.deepcopy(op_protos)
+    for _, item in func_protos.items():
+        for func_proto in item:
+            op_name = func_proto.op_proto.op_name
+            if "deprecated" in func_proto.op_proto.op_name:
+                func_proto.op_proto.op_class.name = ''.join(word.capitalize() for word in op_name.split('_'))
+                if func_proto.op_proto.op_name[-1] == '_':
+                    func_proto.op_proto.op_class.name += '_'
+                tensor_op_protos.append(func_proto.op_proto)
+    return tensor_op_protos
+
+
+def generate_api_files(resource_mgr):
+    """
+    Generate api-related files.
+    """
+    work_path = K.WORK_DIR
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    tensor_method_protos = resource_mgr.get_resource(ResourceType.TENSOR_METHOD_PROTOS)
+    mint_func_protos = resource_mgr.get_resource(ResourceType.MINT_FUNC_PROTOS)
+    alias_api_mapping = resource_mgr.get_resource(ResourceType.ALIAS_API_MAPPING)
+    # generate create prim instance helper file
+    generate_create_instance_helper_file(resource_mgr)
+    # generate tensor_py func code
+    gen_tensor_func_code(work_path, op_protos, tensor_method_protos, alias_api_mapping)
+    # generate functional map code
+    gen_functional_map_code(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping)
+    # generate _tensor_docs.py that attaches docs to tensor func APIs when import mindspore
+    gen_tensor_docs_code()
+    # generate functional_overload.py which init pybind mint APIs from cpp
+    gen_functional_overload_py(work_path, mint_func_protos, alias_api_mapping)
+    # generate tensor_py.cc
+    gen_tensor_py_cc(work_path, tensor_method_protos, alias_api_mapping)