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

mindspore/ops_generate/gen_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# Copyright 2023-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.
@@ -13,342 +13,40 @@
 # limitations under the License.
 # ============================================================================
 """
-Generate operator definition from ops.yaml
+Auto generate ops files.
 """
-import argparse
-import copy
 import logging
-import os
-import shutil
-import pathlib
-from gen_utils import (check_change_and_replace_file, merge_files,
-                       merge_files_append, safe_load_yaml)
-from op_prim_py_generator import OpPrimPyGenerator
-from op_def_py_generator import OpDefPyGenerator
-from aclnn_kernel_register_auto_cc_generator import AclnnKernelRegisterAutoCcGenerator
-from cpp_create_prim_instance_helper_generator import CppCreatePrimInstanceHelperGenerator
-from ops_def_cc_generator import OpsDefCcGenerator
-from ops_def_h_generator import OpsDefHGenerator
-from ops_primitive_h_generator import OpsPrimitiveHGenerator
-from lite_ops_cpp_generator import LiteOpsCcGenerator, LiteOpsHGenerator
-from ops_name_h_generator import OpsNameHGenerator
-from functional_map_cpp_generator import FunctionalMapCppGenerator
-from add_tensor_docs_generator import AddTensorDocsGenerator
-from functional_overload_py_generator import FunctionalOverloadPyGenerator
 
-from op_proto import OpProto
-from op_api_proto import load_api_protos_from_yaml
-from tensor_func_reg_cpp_generator import TensorFuncRegCppGenerator
-from gen_pyboost_func import gen_pyboost_code
+from resources.resource_manager import prepare_resources
+from common import gen_utils
 
-import gen_constants as K
+from op_def.gen_op_def import generate_ops_def_files
+from op_def_py.gen_op_def_py import generate_ops_py_files
+from api.gen_api import generate_api_files
+from aclnn.aclnn_kernel_register_auto_cc_generator import generate_aclnn_reg_file
+from pyboost.gen_pyboost_func import gen_pyboost_code
 
 
-def generate_ops_prim_file(work_path, op_protos, doc_dict, file_pre):
-    generator = OpPrimPyGenerator()
-    generator.generate(work_path, op_protos, doc_dict, file_pre)
+module_generators = [
+    generate_ops_py_files,    # generate ops python files
+    generate_ops_def_files,   # generate ops definition files
+    gen_pyboost_code,         # generate pyboost code
+    generate_aclnn_reg_file,  # generate aclnn kernelmod register
+    generate_api_files        # generate api definition files
+]
 
 
-def generate_ops_def_file(work_path, os_protos, doc_dict, file_pre):
-    generator = OpDefPyGenerator()
-    generator.generate(work_path, os_protos, doc_dict, file_pre)
+def main():
+    resource_mgr = prepare_resources()
 
+    for generator in module_generators:
+        generator(resource_mgr)
 
-def generate_ops_py_files(work_path, op_protos, doc_dict, file_pre):
-    """
-    Generate ops python file from yaml.
-    """
-    generate_ops_prim_file(work_path, op_protos, doc_dict, file_pre)
-    generate_ops_def_file(work_path, op_protos, doc_dict, 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 call_ops_def_cc_generator(work_path, op_protos):
-    generator = OpsDefCcGenerator()
-    generator.generate(work_path, op_protos)
-
-
-def call_ops_def_h_generator(work_path, op_protos):
-    generator = OpsDefHGenerator()
-    generator.generate(work_path, op_protos)
-
-
-def call_ops_primitive_h_generator(work_path, op_protos):
-    generator = OpsPrimitiveHGenerator()
-    generator.generate(work_path, op_protos)
-
-
-def call_lite_ops_h_generator(work_path, op_protos):
-    h_generator = LiteOpsHGenerator()
-    h_generator.generate(work_path, op_protos)
-
-
-def call_lite_ops_cc_generator(work_path, op_protos):
-    generator = LiteOpsCcGenerator()
-    generator.generate(work_path, op_protos)
-
-
-def call_ops_name_h_generator(work_path, op_protos):
-    h_generator = OpsNameHGenerator()
-    h_generator.generate(work_path, op_protos)
-
-
-def generate_ops_cc_files(work_path, op_protos, op_protos_with_deprecated):
-    """
-    Generate ops c++ file from yaml.
-    """
-    call_ops_def_cc_generator(work_path, op_protos_with_deprecated)
-    call_ops_def_h_generator(work_path, op_protos_with_deprecated)
-    call_ops_primitive_h_generator(work_path, op_protos)
-    call_lite_ops_h_generator(work_path, op_protos)
-    call_lite_ops_cc_generator(work_path, op_protos)
-    call_ops_name_h_generator(work_path, op_protos)
-
-
-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_create_instance_helper_file(work_path, op_protos_with_deprecated):
-    """
-    Generate C++ helper file from yaml.
-    """
-    generator = CppCreatePrimInstanceHelperGenerator()
-    generator.generate(work_path, op_protos_with_deprecated)
-
-
-def generate_aclnn_reg_file(work_path, op_protos):
-    """
-    Generate nnacl kernelmod register
-    """
-    generator = AclnnKernelRegisterAutoCcGenerator()
-    generator.generate(work_path, op_protos)
-
-
-def generate_arg_handler_files(work_path):
-    """
-    Generate arg handler files.
-    """
-    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, 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, 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 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(work_path, tensor_docs_data):
-    generator = AddTensorDocsGenerator()
-    generator.generate(work_path, tensor_docs_data)
-
-
-def gen_functional_overload_py(work_path, mint_func_protos, function_doc_data, alias_api_mapping):
-    generator = FunctionalOverloadPyGenerator()
-    generator.generate(work_path, mint_func_protos, function_doc_data, alias_api_mapping)
-
-
-def main(args):
-    current_path = os.path.dirname(os.path.realpath(__file__))
-    work_path = os.path.join(current_path, '../../../../')
-
-    if args.clear_auto_gen:
-        delete_auto_gen_files(work_path)
-
-    # merge ops yaml
-    (doc_yaml_path, ops_yaml_path, deprecated_ops_yaml_path, ops_api_yaml_path,
-     tensor_method_doc_yaml_path, mint_func_doc_yaml_path) = merge_ops_yaml(work_path)
-
-    # make auto_generate dir
-    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
-    generate_arg_handler_files(work_path)
-
-    # read ops definition str and tensor method doc str
-    ops_yaml_dict = safe_load_yaml(ops_yaml_path)
-    doc_yaml_dict = safe_load_yaml(doc_yaml_path)
-    deprecated_ops_yaml_dict = safe_load_yaml(deprecated_ops_yaml_path)
-    ops_api_yaml_dict = safe_load_yaml(ops_api_yaml_path)
-    tensor_method_doc_yaml_dict = safe_load_yaml(tensor_method_doc_yaml_path)
-    mint_function_doc_yaml_dict = safe_load_yaml(mint_func_doc_yaml_path)
-
-    op_protos = load_op_protos_from_ops_yaml(ops_yaml_dict)
-    deprecated_op_protos = load_deprecated_op_protos_from_ops_yaml(deprecated_ops_yaml_dict)
-    tensor_method_protos, mint_func_protos, alias_api_mapping \
-        = load_api_protos_from_yaml(ops_api_yaml_dict, op_protos, deprecated_op_protos)
-    # for generate tensor method deprecated in graph mode
-    op_protos_with_deprecated = get_tensor_op_protos_with_deprecated(tensor_method_protos, op_protos)
-
-    # generate ops python files
-    generate_ops_py_files(work_path, op_protos, doc_yaml_dict, "gen")
-    # generate ops c++ files
-    generate_ops_cc_files(work_path, op_protos, op_protos_with_deprecated)
-    # generate create prim instance helper file
-    generate_create_instance_helper_file(work_path, op_protos_with_deprecated)
-    # generate pyboost code
-    gen_pyboost_code(work_path, op_protos, doc_yaml_dict, tensor_method_protos, mint_func_protos, alias_api_mapping)
-    # generate aclnn kernelmod register
-    generate_aclnn_reg_file(work_path, op_protos)
-    # 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(work_path, tensor_method_doc_yaml_dict)
-    # generate functional_overload.py which init pybind mint APIs from cpp
-    gen_functional_overload_py(work_path, mint_func_protos, mint_function_doc_yaml_dict, alias_api_mapping)
-
-
-def delete_auto_gen_files(work_path):
-    """
-    Deletes auto-generated files and folders.
-    """
-    auto_gen_code_file = get_auto_gen_path_from_gitignore(work_path)
-
-    for name in auto_gen_code_file:
-        # Recursively delete all single-level folder names
-        if name.rstrip('/').count('/') == 0:
-            for dir_path, dir_names, _ in os.walk(work_path, topdown=False):
-                for dirname in dir_names:
-                    if dirname == name.rstrip('/'):
-                        folder_path = os.path.join(dir_path, dirname)
-                        logging.info("Recursively deleting folder: %s", folder_path)
-                        shutil.rmtree(folder_path)
-            continue
-
-        # Delete all individual files or folders
-        tmp_path = os.path.join(work_path, name)
-        if os.path.exists(tmp_path):
-            if os.path.isdir(tmp_path):
-                logging.info("Deleting folder: %s", tmp_path)
-                shutil.rmtree(tmp_path)
-            elif os.path.isfile(tmp_path):
-                logging.info("Deleting file: %s", tmp_path)
-                os.remove(tmp_path)
-        else:
-            logging.info("The path is not exist: %s", tmp_path)
-
-
-def get_auto_gen_path_from_gitignore(work_path):
-    """
-    Extracts a list of auto-gen file and folder paths from the "# auto gen code files" section in the .gitignore file.
-    """
-    file_path = os.path.join(work_path, ".gitignore")
-    auto_gen_code_file_started = False
-    auto_gen_code_file = []
-    with open(file_path, 'r') as f:
-        for line in f.readlines():
-            if line.strip() == "# auto gen code files":
-                auto_gen_code_file_started = True
-                continue
-            if auto_gen_code_file_started:
-                if line.strip() and not line.strip().startswith("#"):
-                    auto_gen_code_file.append(line.strip())
-                else:
-                    break
-    return auto_gen_code_file
-
-
-def load_op_protos_from_ops_yaml(ops_yaml_data):
-    op_protos = []
-    for operator_name, operator_data in ops_yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        op_protos.append(op_proto)
-    return op_protos
-
-
-def load_deprecated_op_protos_from_ops_yaml(ops_yaml_data):
-    op_protos = []
-    for operator_name, operator_data in ops_yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        op_proto.op_name = 'deprecated_' + operator_name
-        op_protos.append(op_proto)
-    return op_protos
-
-
-def merge_ops_yaml(work_path):
-    """
-    Merges operator YAML files scattered in different directories into a single file.
-
-    Args:
-        work_path (str): The path to the working directory.
-
-    Returns:
-        tuple: Paths to the merged documentation and operators YAML files.
-    """
-    ops_yaml_dir_path = os.path.join(work_path, K.MS_OP_DEF_YAML_PATH)
-    ops_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'ops.yaml')
-    infer_ops_yaml_dir_path = os.path.join(ops_yaml_dir_path, "infer")
-    merge_files(ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
-    merge_files_append(infer_ops_yaml_dir_path, ops_yaml_path, '*op.yaml')
-
-    doc_yaml_dir_path = os.path.join(ops_yaml_dir_path, "doc")
-    doc_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'ops_doc.yaml')
-    merge_files(doc_yaml_dir_path, doc_yaml_path, '*doc.yaml')
-
-    ops_api_yaml_dir_path = os.path.join(work_path, K.MS_OP_API_YAML_PATH)
-    ops_api_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'api_def.yaml')
-    merge_files(ops_api_yaml_dir_path, ops_api_yaml_path, '*.yaml')
-
-    deprecated_ops_yaml_dir_path = os.path.join(work_path, K.MS_OP_DEPRECATED_DEF_YAML_PATH)
-    deprecated_ops_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'deprecated_ops.yaml')
-    merge_files(deprecated_ops_yaml_dir_path, deprecated_ops_yaml_path, '*_method.yaml')
-
-    tensor_method_doc_yaml_dir_path = os.path.join(work_path, K.MS_TENSOR_METHOD_DOC_YAML_PATH)
-    tensor_method_doc_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'tensor_method_doc.yaml')
-    merge_files(tensor_method_doc_yaml_dir_path, tensor_method_doc_yaml_path, '*doc.yaml')
-
-    mint_func_doc_yaml_dir_path = os.path.join(work_path, K.MS_MINT_FUNC_DOC_YAML_PATH)
-    mint_func_doc_yaml_path = os.path.join(work_path, K.PY_OPS_GEN_PATH, 'mint_func_doc.yaml')
-    merge_files(mint_func_doc_yaml_dir_path, mint_func_doc_yaml_path, '*doc.yaml')
-
-    return (doc_yaml_path, ops_yaml_path, deprecated_ops_yaml_path,
-            ops_api_yaml_path, tensor_method_doc_yaml_path, mint_func_doc_yaml_path)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--clear_auto_gen', default=False, help='clear all auto gen files')
-    return parser.parse_args()
-
+    gen_utils.clear_obsolete_auto_gen_files()
 
 if __name__ == "__main__":
     try:
-        arguments = parse_args()
-        main(arguments)
-    # pylint: disable=broad-except
-    except Exception as e:
+        main()
+    except Exception as e: # pylint: disable=broad-except
         logging.critical("Auto generate failed, err info: %s", e)
         raise e

mindspore/ops_generate/op_def/gen_op_def.py

@@ -0,0 +1,90 @@
+# 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 operator definitions from ops.yaml
+"""
+import copy
+
+from common import gen_constants as K
+from resources.resource_list import ResourceType
+
+from .ops_def_cc_generator import OpsDefCcGenerator
+from .ops_def_h_generator import OpsDefHGenerator
+from .ops_name_h_generator import OpsNameHGenerator
+from .ops_primitive_h_generator import OpsPrimitiveHGenerator
+from .lite_ops_cpp_generator import LiteOpsCcGenerator, LiteOpsHGenerator
+
+
+def call_ops_def_cc_generator(work_path, op_protos):
+    generator = OpsDefCcGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_ops_def_h_generator(work_path, op_protos):
+    generator = OpsDefHGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_ops_primitive_h_generator(work_path, op_protos):
+    generator = OpsPrimitiveHGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_lite_ops_h_generator(work_path, op_protos):
+    h_generator = LiteOpsHGenerator()
+    h_generator.generate(work_path, op_protos)
+
+
+def call_lite_ops_cc_generator(work_path, op_protos):
+    generator = LiteOpsCcGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_ops_name_h_generator(work_path, op_protos):
+    h_generator = OpsNameHGenerator()
+    h_generator.generate(work_path, op_protos)
+
+
+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_ops_def_files(resource_mgr):
+    """
+    Generate ops c++ file from yaml.
+    """
+    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)
+    # for generate tensor method deprecated in graph mode
+    op_protos_with_deprecated = get_tensor_op_protos_with_deprecated(tensor_method_protos, op_protos)
+    call_ops_def_cc_generator(work_path, op_protos_with_deprecated)
+    call_ops_def_h_generator(work_path, op_protos_with_deprecated)
+    call_ops_primitive_h_generator(work_path, op_protos)
+    call_lite_ops_h_generator(work_path, op_protos)
+    call_lite_ops_cc_generator(work_path, op_protos)
+    call_ops_name_h_generator(work_path, op_protos)

mindspore/ops_generate/{lite_ops_cpp_generator.py → op_def/lite_ops_cpp_generator.py}

@@ -18,14 +18,44 @@ Generates C++ header and source files for lite operations based on YAML configur
 
 import os
 
-import gen_constants as K
-import gen_utils
-import pyboost_utils
+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
 
-# refactored
-import template
 
-from base_generator import BaseGenerator
+LITE_OPS_H = """
+#ifndef MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
+#define MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
+
+#include <vector>
+#include "ops/base_operator.h"
+
+namespace mindspore::ops {
+$ops_namespace_body
+
+}  // namespace mindspore::ops
+#endif  // MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
+"""
+
+INC_OPS_HEAD = """
+#include "$auto_gen_path/gen_ops_name_${ch}.h"
+"""
+
+LITE_OPS_CC = """
+#include "$auto_gen_path/gen_lite_ops.h"
+${inc_ops_head_str}
+#include "mindapi/helper.h"
+#include "ops/primitive_c.h"
+#include "ops/base_operator.h"
+#include "abstract/abstract_value.h"
+
+namespace mindspore::ops {
+$ops_namespace_body
+
+}  // namespace mindspore::ops
+    """
 
 
 class LiteOpsHGenerator(BaseGenerator):
@@ -37,7 +67,7 @@ class LiteOpsHGenerator(BaseGenerator):
         """
         Initializes the generator with the necessary templates for generating C++ header files.
         """
-        self.lite_ops_h_template = template.Template(K.LITE_OPS_H)
+        self.lite_ops_h_template = template.Template(LITE_OPS_H)
         self.lite_ops_class_template = template.op_cc_template
         self.arg_prim_init_template = template.Template("\n"
                                                         "  void set_${arg_name}(const ${dtype} &${arg_name});\n"
@@ -89,9 +119,11 @@ class LiteOpsCcGenerator(BaseGenerator):
         """
         Initializes the generator with the necessary templates for generating C++ source files.
         """
-        self.lite_ops_cc_template = template.Template(K.LITE_OPS_CC)
+        self.inc_ops_head_templat = template.Template(INC_OPS_HEAD)
+        self.lite_ops_cc_template = template.Template(LITE_OPS_CC)
         self.op_template = template.op_template
-        self.register_primitive_c_template = template.Template("REGISTER_PRIMITIVE_C(kName${op_name}, ${op_name});\n"
+        self.register_primitive_c_template = template.Template("${op_name}::${op_name}():BaseOperator(kName${op_name}) {}\n"
+                                                               "REGISTER_PRIMITIVE_C(kName${op_name}, ${op_name});\n"
                                                                "MIND_API_OPERATOR_IMPL(${op_name}, BaseOperator);\n\n")
 
     def generate(self, work_path, op_protos):
@@ -106,6 +138,7 @@ class LiteOpsCcGenerator(BaseGenerator):
             None
         """
         lite_ops_cc_gen_list = []
+        inc_ops_head_list = set()
         for op_proto in op_protos:
             arg_prim_init_str = ""
             op_name = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
@@ -120,9 +153,12 @@ class LiteOpsCcGenerator(BaseGenerator):
 
             self.register_primitive_c_template.replace(op_name=op_name)
             lite_ops_cc_gen_list.append(arg_prim_init_str + self.register_primitive_c_template.replace(op_name=op_name))
-
+            inc_ops_head_list.add(self.inc_ops_head_templat.replace(auto_gen_path=K.OP_DEF_AUTO_GENERATE_PATH,
+                                                                    ch=op_name[0].lower()))
+        sorted_inc_ops_head_str = sorted(inc_ops_head_list)
         lite_ops_cc = self.lite_ops_cc_template.replace(auto_gen_path=K.OP_DEF_AUTO_GENERATE_PATH,
-                                                        ops_namespace_body=lite_ops_cc_gen_list)
+                                                        ops_namespace_body=lite_ops_cc_gen_list,
+                                                        inc_ops_head_str=sorted_inc_ops_head_str)
 
         res_str = template.CC_LICENSE_STR + lite_ops_cc
         save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)

mindspore/ops_generate/{ops_def_cc_generator.py → op_def/ops_def_cc_generator.py}

@@ -19,14 +19,25 @@ Module for generating C++ operator definition files.
 import os
 import math
 
-import gen_constants as K
-import gen_utils
+import common.gen_constants as K
+import common.gen_utils as gen_utils
 
 # refactored
-from op_proto import OpProto
-import template
+from common.op_proto import OpProto
+import common.template as template
 
-from base_generator import BaseGenerator
+from common.base_generator import BaseGenerator
+
+
+CC_OPS_DEF = """
+
+#include "$auto_generate_path/gen_ops_def.h"
+#include "ir/signature.h"
+$gen_include
+
+namespace mindspore::ops {$gen_cc_code
+}  // namespace mindspore::ops
+"""
 
 
 class OpsDefCcGenerator(BaseGenerator):
@@ -43,7 +54,7 @@ class OpsDefCcGenerator(BaseGenerator):
         self.empty_func_impl_declaration_template = template.Template("static OpFuncImpl g${class_name}FuncImpl;")
         self.func_impl_define_template = template.Template("g${class_name}FuncImpl")
         self.OP_PROTO_TEMPLATE = template.OP_PROTO_TEMPLATE
-        self.CC_OPS_DEF_TEMPLATE = template.Template(K.CC_OPS_DEF)
+        self.CC_OPS_DEF_TEMPLATE = template.Template(CC_OPS_DEF)
 
     def generate(self, work_path, op_protos):
         """
@@ -60,7 +71,7 @@ class OpsDefCcGenerator(BaseGenerator):
         for op_proto in op_protos:
             operator_name = op_proto.op_name
             class_name = op_proto.op_class.name
-            if "deprecated" not in operator_name:
+            if not op_proto.func_op:
                 gen_include_list.append(self.include_template.replace(path=K.MS_OPS_FUNC_IMPL_PATH,
                                                                       operator_name=operator_name))
                 func_impl_declaration_str = self.func_impl_declaration_template.replace(class_name=class_name)

mindspore/ops_generate/{ops_def_h_generator.py → op_def/ops_def_h_generator.py}

@@ -21,11 +21,11 @@ and any additional operators provided. This is useful for managing operator inte
 
 import os
 
-import template
-from template import Template
-from gen_utils import save_file
-import gen_constants as K
-from base_generator import BaseGenerator
+import common.template as template
+from common.template import Template
+from common.gen_utils import save_file
+import common.gen_constants as K
+from common.base_generator import BaseGenerator
 
 
 class OpsDefHGenerator(BaseGenerator):