mindspore 2.4.1__cp39-none-any.whl → 2.5.0__cp39-none-any.whl

mindspore/ops_generate/gen_pyboost_func.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# 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.
@@ -16,1037 +16,136 @@
 Generate pyboost function from pyboost_op.yaml
 """
 
-import os
-import re
-import pathlib
-from dataclasses import dataclass
-import pyboost_utils
-from pyboost_utils import get_convert_type_str, get_input_dtype, get_return_type, tuple_input_to_cpp_type, \
-    number_input_to_cpp_type, get_const_number_convert, get_tuple_input_convert, get_pyboost_name, is_cube, \
-    AclnnUtils, get_disable_flag, is_optional_param, get_value_convert_type_str, is_pyboost_enable
-import template
-from template import CppTemplate
-from op_proto import OpProto
-from gen_utils import check_change_and_replace_file, py_licence_str, write_file
-import gen_constants as K
-
-
-@dataclass
-class FuncHeaderData:
-    work_path: str
-    op_header_template_path: list
-    code_generate_path: list
-    op_name_str: str
-    operator_name: str
-    call_args_with_type: list
-    cpp_func_return: str
-
-
-def generate_pyboost_base_op_header_code(work_path, op_name_str, operator_name, call_args_with_type, cpp_func_return):
-    """ generate_pyboost_base_op_header_code """
-    pyboost_op_header_str = template.PYBOOST_BASE_OP_DEFINE_TEMPLATE.replace(op_name=op_name_str,
-                                                                             op_name_upper=op_name_str.upper(),
-                                                                             call_args=call_args_with_type,
-                                                                             return_type=cpp_func_return)
-    op_header_dir_path = os.path.join(work_path, f"{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/")
-    pathlib.Path(op_header_dir_path).mkdir(parents=True, exist_ok=True)
-    tmp_op_file_path = os.path.join(op_header_dir_path, "tmp_" + operator_name + ".h")
-    dst_op_file_path = os.path.join(op_header_dir_path, operator_name + ".h")
-    write_file(tmp_op_file_path, pyboost_op_header_str)
-    check_change_and_replace_file(dst_op_file_path, tmp_op_file_path)
-
-
-def generate_pyboost_op_header_code(header_data: FuncHeaderData):
-    """ generate_pyboost_op_header_code """
-
-    for tpl_path, gen_path in zip(header_data.op_header_template_path, header_data.code_generate_path):
-        pyboost_op_str = tpl_path.replace(op_name=header_data.op_name_str,
-                                          op_name_upper=header_data.op_name_str.upper(),
-                                          operator_name=header_data.operator_name,
-                                          call_args_with_type=header_data.call_args_with_type,
-                                          return_type=header_data.cpp_func_return)
-        op_header_dir_path = os.path.join(header_data.work_path, gen_path)
-        pathlib.Path(op_header_dir_path).mkdir(parents=True, exist_ok=True)
-        tmp_op_file_path = os.path.join(op_header_dir_path, "tmp_" + header_data.operator_name + ".h")
-        dst_op_file_path = os.path.join(op_header_dir_path, header_data.operator_name + ".h")
-        write_file(tmp_op_file_path, pyboost_op_str)
-        check_change_and_replace_file(dst_op_file_path, tmp_op_file_path)
-
-
-class TemplatePaths:
-    """
-    template paths for code auto generation
-    """
-
-    def __init__(self, op_header_template_path, op_call_template_path, op_source_template_path, op_custom_template_path,
-                 op_view_template_path, code_generate_path):
-        self.op_header_template_path = op_header_template_path
-        self.op_call_template_path = op_call_template_path
-        self.op_source_template_path = op_source_template_path
-        self.op_custom_template_path = op_custom_template_path
-        self.op_view_template_path = op_view_template_path
-        self.code_generate_path = code_generate_path
-
-
-def generate_malloc_input(need_malloc_tensors):
-    """
-    generate malloc inputs
-    :param need_malloc_tensors:
-    :return:
-    """
-    malloc_inputs = ''
-    args_list = ''
-    for item in need_malloc_tensors:
-        args_list += f'{item}, '
-    args_list = args_list[:-2]
-    if args_list:
-        malloc_inputs += f'PyBoostUtils::MallocOpInputs(device_context, {args_list});\n'
-    return malloc_inputs
-
-
-def generate_get_inputs_kernel_tensors(call_args):
-    """
-    generate get inputs kernel tensors
-    :param call_args:
-    :return:
-    """
-    inputs_kernel_tensors = ''
-    args_list = ''
-    for item in call_args:
-        args_list += f'{item}, '
-    args_list = args_list[:-2]
-    if args_list:
-        inputs_kernel_tensors += f'const auto &input_address_info = PyBoostUtils::GetAddressInfo(' \
-                                 f'device_context, op->stream_id(), op->input_abs(), {args_list});\n'
-    return inputs_kernel_tensors
-
-
-def generate_create_input_address(need_malloc_tensors):
-    """create input address"""
-    create_input_address = ''
-    args_list = ''
-    for item in need_malloc_tensors:
-        args_list += f'{item}, '
-    args_list = args_list[:-2]
-    if args_list:
-        create_input_address = f'PyBoostUtils::PrepareOpInputs(device_context_, op->stream_id(), {args_list});\n'
-    return create_input_address
-
-
-def generate_tensor_cpu_cast_input_code(call_args_with_tensor, call_tensors):
-    """ generate_tensor_cpu_cast_input_code """
-    cast_input = ""
-    real_call_args_tensor = call_args_with_tensor.copy()
-    for i, tensor in enumerate(call_args_with_tensor):
-        is_tuple_tensor = real_call_args_tensor[i].endswith("_vector")
-        is_tensor = real_call_args_tensor[i] in call_tensors
-        if is_tensor:
-            cast_input += f'const auto &real_{tensor} = PyBoostUtils::CastTensor({tensor}, ' \
-                          f'select_kernel.input_type()[{i}].dtype, "CPU");\n'
-            real_call_args_tensor[i] = "real_" + real_call_args_tensor[i]
-        if is_tuple_tensor:
-            cast_input += f'const auto &real_{tensor} = PyBoostUtils::CastTensor({tensor}, ' \
-                          f'select_kernel.input_type()[{i}].dtype, "CPU");\n'
-            real_call_args_tensor[i] = "PyBoostUtils::ConvertTensorVectorToTuple(real_" + real_call_args_tensor[i] + ")"
-    if cast_input != "":
-        cast_input = "auto &select_kernel = kernel_attr_pair.second;\n" + cast_input
-    return cast_input, real_call_args_tensor
-
-
-def generate_pyboost_op_source_code(work_path, op_proto, template_paths, converter):
-    """ generate_pyboost_op_source_code """
-    # PyBoost source generate
-    operator_name = converter.functional_name
-    call_args_tensor = []
-    for type, arg_name in zip(converter.call_args_types, converter.call_args):
-        if type in ("BaseTensorPtr", "std::optional<BaseTensorPtr>"):
-            call_args_tensor.append(arg_name)
-
-    for call_tpl, src_tpl, view_tpl, cus_tpl, gen_path in zip(template_paths.op_call_template_path,
-                                                              template_paths.op_source_template_path,
-                                                              template_paths.op_view_template_path,
-                                                              template_paths.op_custom_template_path,
-                                                              template_paths.code_generate_path):
-        is_ascend = 'ascend' in gen_path
-        is_cpu = 'cpu' in gen_path
-        is_gpu = 'gpu' in gen_path
-        malloc_inputs = generate_malloc_input(converter.need_malloc_tensors)
-        create_input_address = generate_create_input_address(converter.need_malloc_tensors)
-        get_inputs_kernel_tensors = generate_get_inputs_kernel_tensors(converter.call_args_with_tensor)
-
-        # call_impl
-        call_impl = ''
-        customize_include = ''
-        op_name_str = op_proto.class_name
-        cube_math_type = ''
-        get_cube_math_type = ''
-        real_output = ', ' + converter.op_outputs
-        proto_operator_name = op_proto.operator_name
-        register_custom_kernel = ''
-        if is_ascend and op_proto.ascend != 'default':
-            call_impl = cus_tpl.replace(call_args=converter.call_args,
-                                        return_values=converter.call_func_outputs,
-                                        customize_func=op_proto.ascend + "Customize",
-                                        )
-            customize_include = f'#include "{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/customize/{operator_name.lower()}.h"'
-        elif is_cpu and op_proto.cpu != 'default':
-            call_impl = cus_tpl.replace(call_args=converter.call_args,
-                                        return_values=converter.call_func_outputs,
-                                        customize_func=op_proto.cpu + "Customize",
-                                        )
-            customize_include = f'#include "{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/customize/{operator_name.lower()}.h"'
-            register_custom_kernel = "MS_REG_PYBOOST_CPU_CUSTOM_KERNEL({});".format(op_name_str)
-        elif is_gpu and op_proto.gpu != 'default':
-            call_impl = cus_tpl.replace(call_args=converter.call_args,
-                                        return_values=converter.call_func_outputs,
-                                        customize_func=op_proto.gpu + "Customize",
-                                        )
-            customize_include = f'#include "{K.MS_OPS_KERNEL_PATH}/gpu/pyboost/customize/{operator_name.lower()}.h"'
-            register_custom_kernel = "MS_REG_PYBOOST_GPU_CUSTOM_KERNEL({});".format(op_name_str)
-        elif op_proto.is_view:
-            call_impl = view_tpl.replace(op_name=op_proto.class_name,
-                                         call_args=converter.call_args,
-                                         call_tensors=call_args_tensor,
-                                         return_values=converter.call_func_outputs,
-                                         input=converter.call_args[0])
-            customize_include = f'#include "{K.MS_OPS_VIEW_PATH}/{proto_operator_name}_strides_calc.h"'
-        else:
-            cast_input_code, real_call_args_tensor = generate_tensor_cpu_cast_input_code(
-                converter.call_args_with_tensor, call_args_tensor)
-            if is_ascend and is_cube(op_proto.class_name):
-                get_cube_math_type = f'// cubeMathType: 0 - KEEP_DTYPE, 1 - ALLOW_FP32_DOWN_PRECISION\n'
-                get_cube_math_type += "auto cube_math_type = GetCubeMathType();"
-                cube_math_type = ', cube_math_type'
-            aclnn_name = AclnnUtils.get_aclnn_interface(op_name_str)
-            if converter.inplace_process != '':
-                real_output = ''
-            customize_include = f'#include "{K.MS_OP_DEF_AUTO_GENERATE_PATH}/gen_ops_primitive.h"'
-
-            call_impl = call_tpl.replace(aclnn_name=aclnn_name,
-                                         call_args=converter.call_args,
-                                         call_tensors=call_args_tensor,
-                                         value_tuple_convert=converter.value_tuple_convert,
-                                         const_number_convert=converter.const_number_convert,
-                                         create_input_address=create_input_address,
-                                         tensor_list_convert=converter.tensor_list_convert,
-                                         call_args_with_tensor=converter.call_args_with_tensor,
-                                         malloc_inputs=malloc_inputs,
-                                         get_inputs_kernel_tensors=get_inputs_kernel_tensors,
-                                         get_cube_math_type=get_cube_math_type,
-                                         cube_math_type=cube_math_type,
-                                         real_call_args=converter.call_args_after_convert,
-                                         return_values=converter.call_func_outputs,
-                                         outputs=real_output,
-                                         inplace_process=converter.inplace_process,
-                                         cast_input_code=cast_input_code,
-                                         real_call_args_tensor=real_call_args_tensor,
-                                         class_name=op_proto.class_name,
-                                         op_name_str=op_name_str)
-
-        pyboost_op_source_str = src_tpl.replace(op_name=op_name_str,
-                                                operator_name=operator_name,
-                                                call_args_with_type=converter.call_args_with_types,
-                                                return_type=converter.cpp_func_return,
-                                                customize_include=customize_include,
-                                                call_impl=call_impl,
-                                                register_custom_kernel=register_custom_kernel)
-        op_header_dir_path = os.path.join(work_path, gen_path)
-        tmp_op_source_file_path = os.path.join(op_header_dir_path, "tmp_" + operator_name.lower() + ".cc")
-        dst_op_source_file_path = os.path.join(op_header_dir_path, operator_name.lower() + ".cc")
-        write_file(tmp_op_source_file_path, pyboost_op_source_str)
-        check_change_and_replace_file(dst_op_source_file_path, tmp_op_source_file_path)
-
-
-def generate_pyboost_op_register_source_code(work_path, all_ops, all_operator_names):
-    """ generate_pyboost_op_register_source_code """
-    include_str = ''
-    factory_str = ''
-    for op_name in all_ops:
-        factory_str += "template class OpFactory<{0}>;\n".format(op_name)
-    for operator_name in all_operator_names:
-        include_str += f'#include "{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/{operator_name}.h"\n'
-    op_register_file_str = template.PYBOOST_OP_REGISTER_TEMPLATE.replace(op_includes=include_str,
-                                                                         op_factory_templates=factory_str)
-    op_register_dir_path = os.path.join(work_path, f"{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/")
-    pathlib.Path(op_register_dir_path).mkdir(parents=True, exist_ok=True)
-    tmp_op_register_file_path = os.path.join(op_register_dir_path, "tmp_" + "op_register.cc")
-    dst_op_register_file_path = os.path.join(op_register_dir_path, "op_register.cc")
-    write_file(tmp_op_register_file_path, op_register_file_str)
-    check_change_and_replace_file(dst_op_register_file_path, tmp_op_register_file_path)
-
-
-def generate_pyboost_op_return_code(op_proto):
-    """ generate_pyboost_op_return_code """
-    returns_type = []
-    for return_obj in op_proto.returns:
-        returns_type.append(get_return_type(return_obj.arg_dtype))
-    if len(returns_type) == 1:
-        cpp_func_return = returns_type[0]
-    elif not returns_type:
-        raise Exception("No return")
-    else:
-        cpp_func_return = "std::tuple("
-        cpp_func_return += ','.join(s for s in returns_type)
-        cpp_func_return += ")"
-    return returns_type, cpp_func_return
-
-
-def generate_pyboost_op_func_return_type(op_proto):
-    """ generate_pyboost_op_func_return_type """
-    returns_type = []
-    type_convert_to_base = {
-        'std::vector<tensor::TensorPtr>': 'std::vector<tensor::BaseTensorPtr>',
-        'tensor::TensorPtr': 'tensor::BaseTensorPtr'
-    }
-    for return_obj in op_proto.returns:
-        temp_return = get_return_type(return_obj.arg_dtype)
-        if temp_return in type_convert_to_base:
-            returns_type.append(type_convert_to_base[temp_return])
-        else:
-            raise Exception("Not return found")
-    if len(returns_type) == 1:
-        cpp_func_return = returns_type[0]
-    elif len(returns_type) > 1:
-        cpp_func_return = "std::tuple<"
-        cpp_func_return += ','.join(s for s in returns_type)
-        cpp_func_return += ">"
-    else:
-        raise Exception("Not return found")
-    return cpp_func_return
-
-
-def generate_pyboost_outputs(op_proto):
-    """ generate_pyboost_outputs """
-    op_outputs = ''
-    call_outputs = ''
-    returns_type = []
-    for return_obj in op_proto.returns:
-        returns_type.append(get_return_type(return_obj.arg_dtype))
-
-    if len(returns_type) == 1:
-        if returns_type[0] == 'tensor::TensorPtr':
-            op_outputs = 'outputs[0]'
-            call_outputs = 'outputs_[0]'
-        elif returns_type[0] == "std::vector<tensor::TensorPtr>":
-            op_outputs = 'outputs'
-            call_outputs = 'outputs_'
-        else:
-            raise Exception("Not support return type {}".format(returns_type[0]))
-    elif len(returns_type) > 1:
-        outputs_str = ''
-        for i in range(len(returns_type)):
-            outputs_str += 'outputs[{}],'.format(i)
-        op_outputs = outputs_str[:-1]
-
-        outputs_str = ''
-        for i in range(len(returns_type)):
-            outputs_str += 'outputs_[{}],'.format(i)
-        outputs_str = outputs_str[:-1]
-        call_outputs = "std::make_tuple(" + outputs_str + ")"
-
-    return op_outputs, call_outputs
-
-
-def generate_ops_header_files(work_path, yaml_data, extra_ops=None):
-    """
-    :param work_path:
-    :param yaml_data:
-    :prama extra_ops(default:None):
-    :return: void
-    """
-    extern_str = ''
-    extern_template = CppTemplate("OPS_API extern OpDef g${op_name};\n")
-    for operator_name, operator_data in yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        extern_str += extern_template.replace(op_name=op_proto.class_name)
-    for class_name in extra_ops:
-        extern_str += extern_template.replace(op_name=class_name)
-    ops_header_file = template.GEN_OPS_DEF_HEADER_TEMPLATE.replace(extern_variable=extern_str)
-    dir_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    dst_file_path = os.path.join(dir_path, "gen_ops_def.h")
-    tmp_file_path = os.path.join(dir_path, "tmp_gen_ops_def.h")
-    write_file(tmp_file_path, ops_header_file)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
-
-
-def generate_parser_func(op_proto: OpProto) -> str:
-    """
-    Generate parser func
-    :param op_proto:
-    :return: str
-    """
-    convert_template = CppTemplate("auto $arg_name = converter.${convert_func}(args, $arg_index);\n")
-    parser_func_str = ''
-    for index, arg in enumerate(op_proto.op_args):
-        is_optional = is_optional_param(arg)
-        if arg.is_type_id:
-            arg.arg_dtype = 'type'
-        convert_type_str = get_convert_type_str(arg.arg_dtype, is_optional)
-        parser_func_str += convert_template.replace(arg_name=arg.arg_name, convert_func=convert_type_str,
-                                                    arg_index=pyboost_utils.get_index(index))
-    return parser_func_str
-
-
-def get_convert_tensor_template():
-    """
-    Get convert tensor template
-    """
-    convert_to_tensor_template = CppTemplate(
-        'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToTensor(${input}, ${need_contiguous}, ' \
-        'op_run_info->requires_grad);\n')
-    convert_to_tensor_list_template = CppTemplate(
-        'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToValueTuple(${input}, ${need_contiguous}, ' \
-        'op_run_info->requires_grad);\n')
-    return convert_to_tensor_template, convert_to_tensor_list_template
-
-
-def generate_pyboost_functions(work_path, yaml_data):
-    """
-    Generate pyboost functions file from yaml.
-    """
-    pyboost_func_str = ''
-    pyboost_func_pybind_def = ''
-    pyboost_func_include_headers_str = ''
-    pyboost_func_include_header_template = CppTemplate(
-        f'#include "{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/${{operator_name}}.h"\n')
-    for operator_name, operator_data in yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_dispatch:
-            continue
-        op_def_name_str = f"g{op_proto.class_name}"
-        operator_name = op_proto.operator_name
-        op_name_str = op_proto.class_name
-        op_args_str = [op_arg.arg_name for op_arg in op_proto.op_args]
-        parser_body_str = generate_parser_func(op_proto)
-        convert_to_tensor_template, convert_to_tensor_list_template = get_convert_tensor_template()
-
-        grad_args_str = []
-        call_args_str = []
-        cast_args_str = []
-        convert_stub_str = ''
-        optional_to_value_str = ''
-        need_contiguous = 'true'
-        value_str = '_value'
-        if op_proto.is_view:
-            # view/aclnn op no need to contiguous tensor.
-            need_contiguous = 'false'
-        for op_arg in op_proto.op_args:
-            cast_str = 'cast_'
-            convert_optional_to_value_template = CppTemplate(
-                "auto ${output} = PyNativeAlgo::PyBoost::OptionalToValue(${input});\n")
-            if pyboost_utils.is_tensor(op_arg):
-                if is_optional_param(op_arg):
-                    convert_stub_output_name = op_arg.arg_name + '_optional'
-                    convert_stub_str += convert_to_tensor_template.replace(output=convert_stub_output_name,
-                                                                           input=op_arg.arg_name,
-                                                                           need_contiguous=need_contiguous)
-                    cast_output = cast_str + convert_stub_output_name
-
-                    convert_optional_to_value_name = op_arg.arg_name + value_str
-                    optional_to_value_str += \
-                        convert_optional_to_value_template.replace(input=cast_output,
-                                                                   output=convert_optional_to_value_name)
-                    call_arg = convert_stub_output_name
-                    grad_arg = convert_optional_to_value_name
-                    cast_arg = cast_output
-                else:
-                    convert_stub_output_name = op_arg.arg_name + "_tensor"
-                    convert_stub_str += convert_to_tensor_template.replace(input=op_arg.arg_name,
-                                                                           output=convert_stub_output_name,
-                                                                           need_contiguous=need_contiguous)
-                    call_arg = convert_stub_output_name
-                    grad_arg = cast_str + convert_stub_output_name
-                    cast_arg = grad_arg
-            elif pyboost_utils.is_tensor_list(op_arg):
-                if is_optional_param(op_arg):
-                    # to adapt the cases that TensorList is optional.
-                    convert_stub_output_name = op_arg.arg_name + '_optional'
-                    convert_stub_str += convert_to_tensor_list_template.replace(output=convert_stub_output_name,
-                                                                                input=op_arg.arg_name,
-                                                                                need_contiguous=need_contiguous)
-                    cast_output = cast_str + convert_stub_output_name
-
-                    convert_optional_to_value_name = op_arg.arg_name + value_str
-                    optional_to_value_str += \
-                        convert_optional_to_value_template.replace(input=cast_output,
-                                                                   output=convert_optional_to_value_name)
-                    call_arg = convert_stub_output_name
-                    grad_arg = convert_optional_to_value_name
-                    cast_arg = cast_output
-                else:
-                    convert_stub_output_name = op_arg.arg_name + "_tensor_list"
-                    convert_stub_str += convert_to_tensor_list_template.replace(input=op_arg.arg_name,
-                                                                                output=convert_stub_output_name,
-                                                                                need_contiguous=need_contiguous)
-                    call_arg = convert_stub_output_name
-                    grad_arg = cast_str + convert_stub_output_name
-                    cast_arg = grad_arg
-            else:
-                call_arg = op_arg.arg_name
-                grad_arg = cast_str + op_arg.arg_name
-                cast_arg = grad_arg
-                if is_optional_param(op_arg):
-                    convert_optional_to_value_name = op_arg.arg_name + value_str
-                    optional_to_value_str += \
-                        convert_optional_to_value_template.replace(input=call_arg,
-                                                                   output=convert_optional_to_value_name)
-                    grad_arg = convert_optional_to_value_name
-            grad_args_str.append(grad_arg)
-            call_args_str.append(call_arg)
-            cast_args_str.append(cast_arg)
-        type_num, same_type = gen_signature_same_type_table(op_proto.indexes, operator_data)
-
-        funcion_tpl = template.PYBOOS_COMM_FUNCTION_TEMPLATE \
-            if op_proto.is_comm_op else template.PYBOOST_FUNCTION_TEMPLATE
-        pyboost_func_str += funcion_tpl.replace(func_name=op_proto.pyboost_function_name,
-                                                op_def_name=op_def_name_str, same_type=same_type,
-                                                type_num=type_num, parser_body=parser_body_str,
-                                                op_name=op_name_str,
-                                                convert_stub=convert_stub_str,
-                                                optional_to_value=optional_to_value_str,
-                                                call_args=call_args_str, grad_args=grad_args_str,
-                                                cast_args=cast_args_str, op_args=op_args_str,
-                                                class_name=op_proto.class_name)
-        pyboost_func_str = pyboost_func_str + template.NEW_LINE + template.NEW_LINE
-        pyboost_func_pybind_def += template.REGISTER_DEFINE_TEMPLATE.replace(
-            pyboost_op_name=get_pyboost_name(op_proto.operator_name),
-            pyboost_cfunc_name=op_proto.pyboost_function_name, class_name=op_proto.class_name)
-        pyboost_func_include_headers_str += pyboost_func_include_header_template.replace(operator_name=operator_name)
-    register_func_str = template.REGISTER_TEMPLATE.replace(register_func=pyboost_func_pybind_def)
-    pyboost_func_file = template.PYBOOST_HEADER_TEMPLATE.replace(include_op_header=pyboost_func_include_headers_str,
-                                                                 function_body=pyboost_func_str,
-                                                                 register_function_body=register_func_str)
-    dir_path = os.path.join(work_path, "mindspore/ccsrc/pipeline/pynative/op_function/auto_generate")
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    tmp_file_path = os.path.join(dir_path, "tmp_pyboost_functions.cc")
-    dst_file_path = os.path.join(dir_path, "pyboost_functions.cc")
-    write_file(tmp_file_path, pyboost_func_file)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
-
-
-def convert_value_type(op_proto: OpProto) -> str:
-    """
-    Generate parser func
-    :param op_proto:
-    :return: str
-    """
-    convert_template = CppTemplate(
-        "auto convert_$arg_name = ValueConverter::${convert_func}(op_runner_info->inputs[$arg_index]);\n")
-    parser_func_str = ''
-    for index, arg in enumerate(op_proto.op_args):
-        is_optional = is_optional_param(arg)
-        convert_type_str = get_value_convert_type_str(arg.arg_dtype, is_optional)
-        parser_func_str += convert_template.replace(arg_name=arg.arg_name, convert_func=convert_type_str,
-                                                    arg_index=pyboost_utils.get_index(index))
-    return parser_func_str
-
-
-def convert_native_value_type(op_proto: OpProto) -> str:
-    """
-    Generate native convert func
-    :param op_proto:
-    :return: str
-    """
-    convert_template = CppTemplate(
-        "auto convert_$arg_name = runtime::ValueConverter::${convert_func}(ConvertNode2Value($arg_name));\n")
-    parser_func_str = ''
-    for arg in op_proto.op_args:
-        is_optional = is_optional_param(arg)
-        convert_type_str = get_value_convert_type_str(arg.arg_dtype, is_optional)
-        parser_func_str += convert_template.replace(arg_name=arg.arg_name, convert_func=convert_type_str)
-    return parser_func_str
-
-
-def contiguous_tensor_value(op_proto: OpProto, device_target: str) -> str:
-    """
-    Generate parser func
-    :param device_target:
-    :param op_proto:
-    :return: str
-    """
-    # Do nothing in view op
-    if op_proto.is_view:
-        return ''
-    contiguous_template = CppTemplate(
-        "convert_$arg_name = runtime::ValueConverter::ContiguousTensorValue($device_target, convert_$arg_name);\n")
-    contiguous_func_str = ''
-    need_contiguous_dtype = {'tensor', 'tuple[tensor]'}
-    for arg in op_proto.op_args:
-        if arg.arg_dtype not in need_contiguous_dtype:
-            continue
-        contiguous_func_str += contiguous_template.replace(arg_name=arg.arg_name, device_target=device_target)
-    return contiguous_func_str
-
+from pyboost_inner_prim_generator import PyboostInnerPrimGenerator
+from pyboost_functions_py_generator import PyboostFunctionsPyGenerator
+from pyboost_functions_h_generator import PyboostFunctionsHeaderGenerator
+from pyboost_functions_cpp_generator import PyboostFunctionsGenerator
+from pyboost_grad_function_cpp_generator import PyboostGradFunctionsGenerator
+from pyboost_native_grad_functions_generator import (
+    PyboostGradFunctionsHeaderGenerator,
+    PyboostGradFunctionsCppGenerator,
+)
+from pyboost_op_cpp_code_generator import (
+    PyboostCommonOpHeaderGenerator,
+    PyboostOpFunctionGenerator,
+    PyboostOpHeaderGenerator,
+    delete_residual_files,
+    PyboostOpRegisterCppCodeGenerator,
+)
+from pyboost_overload_functions_cpp_generator import PyboostOverloadFunctionsGenerator
+from auto_grad_impl_cc_generator import AutoGradImplGenerator
+from auto_grad_reg_cc_generator import AutoGradRegHeaderGenerator
+from functions_cc_generator import FunctionsGenerator, FunctionsHeaderGenerator
+
+
+def gen_pyboost_code(work_path, op_protos, doc_yaml_data, tensor_method_protos, mint_func_protos, alias_func_mapping):
+    """ gen_pyboost_code """
+    call_pyboost_inner_prim_generator(work_path, op_protos)
+    call_pyboost_functions_py_generator(work_path, op_protos, doc_yaml_data)
+    call_pyboost_functions_h_generator(work_path, op_protos)
+    call_pyboost_functions_cpp_generator(work_path, op_protos, tensor_method_protos)
+    call_pyboost_overload_functions_cpp_generator(work_path, op_protos, mint_func_protos, alias_func_mapping)
+    call_pyboost_grad_functions_cpp_generator(work_path, op_protos)
+    call_pyboost_native_grad_functions_generator(work_path, op_protos)
+    call_pyboost_op_cpp_code_generator(work_path, op_protos)
+    # op splice
+    call_pyboost_auto_grad_cpp_code_generator(work_path, op_protos)
 
-def generate_pyboost_grad_functions(work_path, yaml_data):
-    """
-    Generate pyboostgrad  functions file from yaml.
-    """
-    pyboost_func_str = ''
-    pyboost_func_reg_def = ''
-    pyboost_func_include_headers_str = ''
-    pyboost_func_include_header_template = CppTemplate(
-        f'#include "{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/${{operator_name}}.h"\n')
-    for operator_name, operator_data in yaml_data.items():
-        if not is_pyboost_enable(operator_data):
-            continue
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_dispatch:
-            continue
-        operator_name = op_proto.operator_name
-        op_name_str = op_proto.class_name
-        op_args_str = [op_arg.arg_name for op_arg in op_proto.op_args]
-        convert_value_type_str = convert_value_type(op_proto)
-        device_target = "op_runner_info->device_target"
-        convert_value_type_str += contiguous_tensor_value(op_proto, device_target)
 
-        call_args_str = []
-        for op_arg in op_proto.op_args:
-            call_arg = 'convert_' + op_arg.arg_name
-            call_args_str.append(call_arg)
-        pyboost_func_str += template.PYBOOST_GRAD_FUNCTION_TEMPLATE.replace(func_name=op_proto.pyboost_function_name,
-                                                                            op_name=op_name_str,
-                                                                            op_args=op_args_str,
-                                                                            convert_body=convert_value_type_str,
-                                                                            call_args=call_args_str)
-        pyboost_func_str = pyboost_func_str + template.NEW_LINE
-        pyboost_func_reg_def += template.REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE.replace(
-            pyboost_op_name=op_proto.class_name,
-            pyboost_cfunc_name=op_proto.pyboost_function_name)
-        pyboost_func_include_headers_str += pyboost_func_include_header_template.replace(operator_name=operator_name)
+def call_pyboost_auto_grad_cpp_code_generator(work_path, op_protos):
+    call_auto_grad_impl_cc_generator(work_path, op_protos)
+    call_auto_grad_reg_header_generator(work_path, op_protos)
+    call_functions_header_generator(work_path, op_protos)
+    call_functions_cc_generator(work_path, op_protos)
 
-    register_func_str = template.REGISTER_PYBOOST_GRAD_TEMPLATE.replace(register_func=pyboost_func_reg_def)
-    pyboost_func_file = \
-        template.PYBOOST_GRAD_HEADER_TEMPLATE.replace(include_op_header=pyboost_func_include_headers_str,
-                                                      function_body=pyboost_func_str,
-                                                      register_function_body=register_func_str)
-    dir_path = os.path.join(work_path, "mindspore/ccsrc/runtime/pynative/op_function/auto_generate")
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    tmp_file_path = os.path.join(dir_path, "tmp_pyboost_grad_functions.cc")
-    dst_file_path = os.path.join(dir_path, "pyboost_grad_functions.cc")
-    write_file(tmp_file_path, pyboost_func_file)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
 
+def call_auto_grad_impl_cc_generator(work_path, op_protos):
+    generator = AutoGradImplGenerator()
+    generator.generate(work_path, op_protos)
 
-def generate_pyboost_native_grad_functions(work_path, yaml_data):
-    """
-    Generate pyboost native grad  functions file from yaml.
-    """
-    pyboost_func_str = ''
-    pyboost_func_include_headers_str = ''
-    native_function_headers_str = ''
-    native_include_header_template = CppTemplate(
-        f'#include "{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/${{operator_name}}.h"\n')
-    native_function_header_template = CppTemplate("static NodePtr $func_name(${call_args_with_type});\n")
-    native_function_sigle_output_template = "const auto &output_value = op->outputs()[0];\n"
-    native_function_multi_output_template = template.MULTI_OUTPUT_TEMPLATE
-    for operator_name, operator_data in yaml_data.items():
-        if not is_pyboost_enable(operator_data):
-            continue
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_dispatch:
-            continue
-        operator_name = op_proto.operator_name
-        op_name_str = op_proto.class_name
-        op_args_str = [op_arg.arg_name for op_arg in op_proto.op_args]
-        convert_value_type_str = convert_native_value_type(op_proto)
-        convert_value_type_str += contiguous_tensor_value(op_proto, "device_target_")
-        first_var_name = op_proto.op_args[0].arg_name
-        call_args_str = []
-        call_args_with_type = []
-        output_expr = native_function_sigle_output_template
-        if op_proto.is_multi_output:
-            output_expr = native_function_multi_output_template
-        for op_arg in op_proto.op_args:
-            call_arg = 'convert_' + op_arg.arg_name
-            call_args_str.append(call_arg)
-            call_args_with_type.append('const NodePtr &' + op_arg.arg_name)
-        pyboost_func_str += \
-            template.PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE.replace(func_name=op_name_str,
-                                                                   op_name=op_name_str,
-                                                                   op_args=op_args_str,
-                                                                   convert_body=convert_value_type_str,
-                                                                   call_args=call_args_str,
-                                                                   call_args_with_type=call_args_with_type,
-                                                                   first_var_name=first_var_name,
-                                                                   output_expr=output_expr)
-        pyboost_func_str = pyboost_func_str + template.NEW_LINE
-        pyboost_func_include_headers_str += native_include_header_template.replace(operator_name=operator_name)
-        func_header = native_function_header_template.replace(func_name=op_name_str,
-                                                              call_args_with_type=call_args_with_type)
-        native_function_headers_str += func_header
-    native_grad_func_file = \
-        template.PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE.replace(include_op_header=pyboost_func_include_headers_str,
-                                                                function_body=pyboost_func_str)
-    native_grad_func_header_file = template.PYBOOST_NATIVE_GRAD_FUNCTIONS_HEADER_TEMPLATE.replace(
-        native_grad_func_def=native_function_headers_str)
-    dir_path = os.path.join(work_path, "mindspore/ccsrc/pipeline/pynative/grad/function/auto_generate")
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    tmp_file_path = os.path.join(dir_path, "tmp_pyboost_native_grad_functions.cc")
-    dst_file_path = os.path.join(dir_path, "pyboost_native_grad_functions.cc")
-    write_file(tmp_file_path, native_grad_func_file)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
-    tmp_file_path = os.path.join(dir_path, "tmp_pyboost_native_grad_functions.h")
-    dst_file_path = os.path.join(dir_path, "pyboost_native_grad_functions.h")
-    write_file(tmp_file_path, native_grad_func_header_file)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
 
+def call_auto_grad_reg_header_generator(work_path, op_protos):
+    generator = AutoGradRegHeaderGenerator()
+    generator.generate(work_path, op_protos)
 
-def generate_inplace_process_cpp_code(op_proto):
-    """ generate_ref_process_cpp_code """
-    inplace_process = f'// RefOps update output by input tensor\n'
-    has_ref = False
-    for index, return_obj in enumerate(op_proto.returns):
-        if return_obj.inplace != '':
-            inplace_process += f'outputs_[{index}]->set_device_address(' \
-                               f'{return_obj.inplace}_tensor->device_address()); '
-            has_ref = True
-            break
-    if has_ref:
-        return inplace_process
-    return ''
 
+def call_functions_header_generator(work_path, op_protos):
+    generator = FunctionsHeaderGenerator()
+    generator.generate(work_path, op_protos)
 
-def get_auto_generate_template():
-    """
-    get template collections
-    :return: TemplatePaths
-    """
-    op_header_template_path = [template.PYBOOST_ASCEND_OP_HEADER_TEMPLATE, template.PYBOOST_GPU_OP_HEADER_TEMPLATE,
-                               template.PYBOOST_CPU_OP_HEADER_TEMPLATE]
-    op_call_template_path = [template.PYBOOST_ASCEND_CALL_TEMPLATE, template.PYBOOST_GPU_CALL_TEMPLATE,
-                             template.PYBOOST_CPU_CALL_TEMPLATE]
-    op_source_template_path = [template.PYBOOST_ASCEND_OP_SOURCE_TEMPLATE, template.PYBOOST_GPU_OP_SOURCE_TEMPLATE,
-                               template.PYBOOST_CPU_OP_SOURCE_TEMPLATE]
-    op_custom_template_path = [template.PYBOOST_ASCEND_CUSTOMIZE_CALL_TEMPLATE,
-                               template.PYBOOST_GPU_CUSTOMIZE_CALL_TEMPLATE,
-                               template.PYBOOST_CPU_CUSTOMIZE_CALL_TEMPLATE]
-    op_view_template_path = [template.PYBOOST_ASCEND_VIEW_CALL_TEMPLATE, template.PYBOOST_GPU_VIEW_CALL_TEMPLATE,
-                             template.PYBOOST_CPU_VIEW_CALL_TEMPLATE]
-    code_generate_path = [f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/auto_generate/" for device in
-                          ["ascend", "gpu", "cpu"]]
-    return TemplatePaths(op_header_template_path, op_call_template_path, op_source_template_path,
-                         op_custom_template_path,
-                         op_view_template_path, code_generate_path)
 
+def call_functions_cc_generator(work_path, op_protos):
+    generator = FunctionsGenerator()
+    generator.generate(work_path, op_protos)
 
-class OpTemplateConverter:
-    """
-    template converter
-    """
 
-    def __init__(self, op_proto):
-        self.op_proto = op_proto
-        self.op_name = op_proto.class_name
-        self.functional_name = op_proto.operator_name
-        self.call_args = self.parse_original_call_args(op_proto.op_args)
-        self.call_args_types = self.parse_call_args_types(op_proto.op_args)
-        self.call_args_with_types = self.parse_call_args_with_types(self.call_args, self.call_args_types)
-        self.need_malloc_tensors, self.tensor_list_convert, self.call_args_with_tensor = \
-            self.parse_need_malloc_tensors(op_proto.op_args, self.call_args)
-        self.call_args_after_convert, self.value_tuple_convert, self.const_number_convert = \
-            self.op_args_converter(op_proto.op_args, self.call_args)
-        self.cpp_func_return = generate_pyboost_op_func_return_type(op_proto)
-        self.op_outputs, self.call_func_outputs = generate_pyboost_outputs(op_proto)
-        self.inplace_process = generate_inplace_process_cpp_code(op_proto)
+def call_pyboost_inner_prim_generator(work_path, op_protos):
+    generator = PyboostInnerPrimGenerator()
+    generator.generate(work_path, op_protos)
 
-    @staticmethod
-    def parse_call_args_types(op_args):
-        """
-        :param op_args:
-        :return: call_args_types
-        """
-        call_args_types = []
-        for op_arg in op_args:
-            is_optional = is_optional_param(op_arg)
-            call_args_types.append(get_input_dtype(op_arg.arg_dtype, is_optional))
-        return call_args_types
 
-    @staticmethod
-    def parse_call_args_with_types(call_args, call_args_types):
-        """
-        :param call_args:
-        :param call_args_types:
-        :return: call_args_with_types
-        """
-        call_args_with_types = []
-        for type_name, arg_name in zip(call_args_types, call_args):
-            call_args_with_types.append("const " + type_name + " &" + arg_name)
-        return call_args_with_types
+def call_pyboost_functions_py_generator(work_path, op_protos, doc_yaml_data):
+    generator = PyboostFunctionsPyGenerator()
+    generator.generate(work_path, op_protos, doc_yaml_data)
 
-    @staticmethod
-    def parse_need_malloc_tensors(op_args, call_args):
-        """
-        :param op_args:
-        :param call_args:
-        :return: need_malloc_tensors
-        """
-        need_malloc_tensors = []
-        tensor_list_convert = []
-        call_args_with_tensor = []
-        for op_arg, call_arg in zip(op_args, call_args):
-            if pyboost_utils.is_tensor(op_arg):
-                call_arg = op_arg.arg_name + "_tensor"
-                need_malloc_tensors.append(call_arg)
-                call_args_with_tensor.append(call_arg)
-            elif tuple_input_to_cpp_type(op_arg.arg_dtype) and pyboost_utils.is_tensor_list(op_arg):
-                need_malloc_tensors.append(call_arg + "_vector")
-                tensor_list_convert.append(get_tuple_input_convert(call_arg, op_arg.arg_dtype))
-                call_args_with_tensor.append(call_arg + "_vector")
-            else:
-                call_args_with_tensor.append(call_arg)
-        return need_malloc_tensors, tensor_list_convert, call_args_with_tensor
 
-    @staticmethod
-    def parse_original_call_args(op_args):
-        """
-        :param op_args:
-        :return: call_args
-        """
-        call_args = []
-        for op_arg in op_args:
-            if pyboost_utils.is_tensor(op_arg):
-                call_arg = op_arg.arg_name + "_tensor"
-            elif pyboost_utils.is_tensor_list(op_arg):
-                call_arg = op_arg.arg_name + "_tensor_list"
-            else:
-                call_arg = op_arg.arg_name
-            call_args.append(call_arg)
-        return call_args
+def call_pyboost_functions_h_generator(work_path, op_protos):
+    generator = PyboostFunctionsHeaderGenerator()
+    generator.generate(work_path, op_protos)
 
-    @staticmethod
-    def op_args_converter(op_args, call_args):
-        """Convert ValutePtr to cpp data type"""
-        call_args_after_convert = []
-        value_tuple_convert = []
-        const_number_convert = []
-        for op_arg, call_arg in zip(op_args, call_args):
-            if number_input_to_cpp_type(op_arg.arg_dtype):
-                call_args_after_convert.append(call_arg + "_imm")
-                const_number_convert.append(get_const_number_convert(call_arg, op_arg))
-            elif tuple_input_to_cpp_type(op_arg.arg_dtype):
-                call_args_after_convert.append(call_arg + "_vector")
-                value_tuple_convert.append(get_tuple_input_convert(call_arg, op_arg.arg_dtype))
-            else:
-                call_args_after_convert.append(call_arg)
-        if const_number_convert:
-            const_number_convert.insert(0, '// Convert ValuePtr to c++ scalar\n')
-        if value_tuple_convert:
-            value_tuple_convert.insert(0, '// ValueTuple to std::vector\n')
-        return call_args_after_convert, value_tuple_convert, const_number_convert
 
+def call_pyboost_functions_cpp_generator(work_path, op_protos, tensor_method_protos):
+    generator = PyboostFunctionsGenerator()
+    generator.generate(work_path, op_protos, tensor_method_protos)
 
-def delete_residual_files(work_path, all_operator_name, code_generate_path_list):
-    """
-    Delete residual files.
-    """
-    code_generate_path_list.append(f"{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/")
-    for code_generate_path in code_generate_path_list:
-        all_files_name = []
-        code_generate_path = os.path.join(work_path, code_generate_path)
-        if os.path.exists(code_generate_path):
-            all_files_name = os.listdir(code_generate_path)
-        all_registered_op = set(item.split(".")[0] for item in all_files_name)
-        need_clean_op = all_registered_op - set(all_operator_name)
-        for file in all_files_name:
-            if file == "op_register.cc":
-                continue
-            for clean_name in need_clean_op:
-                judge_file = file.split(".")[0]
-                if judge_file == clean_name:
-                    file_path = os.path.join(code_generate_path, file)
-                    if os.path.exists(file_path):
-                        os.remove(file_path)
 
+def call_pyboost_overload_functions_cpp_generator(work_path, op_protos, mint_func_protos, alias_func_mapping):
+    generator = PyboostOverloadFunctionsGenerator()
+    generator.generate(work_path, op_protos, mint_func_protos, alias_func_mapping)
 
-def generate_pyboost_op_cpp_code(work_path, yaml_data):
-    """
-    Generate pyboost op cpp code from yaml.
-    """
 
-    all_op_names = []
-    all_functional_names = []
-    all_operator_name = []
-    for operator_name, operator_data in yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_dispatch:
-            continue
-        template_paths = get_auto_generate_template()
-        converter = OpTemplateConverter(op_proto)
-        functional_name = converter.functional_name
+def call_pyboost_grad_functions_cpp_generator(work_path, op_protos):
+    generator = PyboostGradFunctionsGenerator()
+    generator.generate(work_path, op_protos)
 
-        op_name_str = converter.op_name
 
-        all_op_names.append(op_name_str)
-        all_operator_name.append(operator_name)
-        all_functional_names.append(functional_name)
+def call_pyboost_native_grad_functions_generator(work_path, op_protos):
+    h_generator = PyboostGradFunctionsHeaderGenerator()
+    h_generator.generate(work_path, op_protos)
 
-        call_args_with_types = converter.call_args_with_types
-        cpp_func_return = converter.cpp_func_return
+    cc_generator = PyboostGradFunctionsCppGenerator()
+    cc_generator.generate(work_path, op_protos)
 
-        generate_pyboost_base_op_header_code(work_path, op_name_str, functional_name, call_args_with_types,
-                                             cpp_func_return)
-        header_data = FuncHeaderData(work_path, template_paths.op_header_template_path,
-                                     template_paths.code_generate_path, op_name_str,
-                                     functional_name, call_args_with_types, cpp_func_return)
-        generate_pyboost_op_header_code(header_data)
-        generate_pyboost_op_source_code(work_path, op_proto, template_paths, converter)
-    delete_residual_files(work_path, all_operator_name, template_paths.code_generate_path)
-    generate_pyboost_op_register_source_code(work_path, all_op_names, all_functional_names)
 
+def call_pyboost_op_cpp_code_generator(work_path, op_protos):
+    delete_residual_files(work_path, op_protos)
+    call_PyboostCommonOpCppCodeGenerator(work_path, op_protos)
+    call_PyboostOpHeaderGenerator(work_path, op_protos)
+    call_merge_pyboost_op_cpp_code_generator(work_path, op_protos)
+    call_PyboostOpRegisterCppCodeGenerator(work_path, op_protos)
 
-def gen_pyboost_inner_prim(work_path, op_yaml_data):
-    """
-    gen pyboost inner prim
-    :param work_path:
-    :param op_yaml_data:
-    :return:
-    """
-    gen_py = ''
-    gen_header = py_licence_str + template.IMPORT_PYBOOST_PRIM_HEADER
-    for operator_name, operator_data in op_yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_pyboost:
-            continue
-        if not op_proto.prim_init:
-            continue
-        gen_header += template.PYBOOST_PY_FUNC_IMPORT_HEADEAR.replace(class_name=op_proto.class_name)
-        args = operator_data.get('args')
-        input_args = []
-        processed_args = []
-        process_func = ''
-        for arg_name, arg_info in args.items():
-            arg_handler = arg_info.get('arg_handler')
-            processed_arg = arg_name
-            if arg_handler is not None and arg_handler != 'dtype_to_type_id':
-                process_func += \
-                    f"""converted_{arg_name} = {arg_handler}('{operator_name}', '{arg_name}', {arg_name})\n"""
-                processed_arg = 'converted_' + arg_name
-            input_args.append(arg_name)
-            processed_args.append(processed_arg)
-        gen_py += template.PYTHON_PRIM_TEMPLATE.replace(class_name=op_proto.class_name, input_args=input_args,
-                                                        process_func=process_func, func_impl_name=operator_name,
-                                                        processed_args=processed_args)
-    dir_path = os.path.join(work_path, "mindspore/python/mindspore/ops/auto_generate")
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    dst_file_path = os.path.join(dir_path, "pyboost_inner_prim.py")
-    tmp_file_path = os.path.join(dir_path, "tmp_pyboost_inner_prim.py")
-    write_file(tmp_file_path, gen_header + gen_py)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
 
+def call_merge_pyboost_op_cpp_code_generator(work_path, op_protos):
+    generator = PyboostOpFunctionGenerator()
+    generator.generate(work_path, op_protos)
 
-def process_args(args):
-    """
-    process args
-    :return: func args, input_args
-    """
-    func_args = []
-    input_args = []
-    for arg_name, arg_info in args.items():
-        init_value = arg_info.get('init')
-        arg_handler = arg_info.get('arg_handler')
-        input_arg = arg_name
-        if arg_handler is not None and arg_handler != 'dtype_to_type_id':
-            input_arg = 'converted_' + arg_name
-        if init_value is None:
-            default_key = 'default'
-            default_value = arg_info.get(default_key)
-            default_value = '=' + str(default_value) if default_key in arg_info else ''
-            func_args.append(arg_name + default_value)
-            input_args.append(input_arg)
-        else:
-            if init_value == 'NO_VALUE':
-                func_args.append(f"""{arg_name}""")
-            else:
-                func_args.append(f"""{arg_name}={init_value}""")
-    return func_args, input_args
 
+def call_PyboostCommonOpCppCodeGenerator(work_path, op_protos):
+    generator = PyboostCommonOpHeaderGenerator()
+    generator.generate(work_path, op_protos)
 
-def gen_pyboost_py_func(work_path, op_yaml_data, doc_data):
-    """ gen_pyboost_py_func """
-    gen_py = ''
-    op_desc_dict = {}
 
-    py_header = py_licence_str + template.IMPORT_PYBOOST_FUNC_HEADER
-    for operator_name, operator_desc in doc_data.items():
-        desc = operator_desc.get("description")
-        op_desc_dict[operator_name] = desc
-    for operator_name, operator_data in op_yaml_data.items():
-        op_proto = OpProto.load_from_yaml(operator_name, operator_data)
-        if not op_proto.is_pyboost:
-            continue
-        func_def = operator_data.get('function')
-        func_name = operator_name
-        if func_def is not None:
-            func_disable = get_disable_flag(func_def)
-            if func_disable:
-                continue
-            item = func_def.get("name")
-            if item is not None:
-                func_name = item
-        if func_name.endswith("_ext"):
-            func_name = func_name[:-4]
-        else:
-            continue
-        func_impl_name = func_name
-        if func_name.endswith("_"):
-            func_impl_name = func_name[:-1]
-        description = op_desc_dict.get(operator_name)
-        args = operator_data.get('args')
-        func_args, input_args = process_args(args)
-        gen_py += template.PYBOOST_PY_FUNC_TEMPLATE.replace(func_name=func_name, description=description,
-                                                            func_args=func_args,
-                                                            func_impl_name=func_impl_name,
-                                                            input_args=input_args)
-    dir_path = os.path.join(work_path, "mindspore/python/mindspore/ops/auto_generate")
-    pathlib.Path(dir_path).mkdir(parents=True, exist_ok=True)
-    dst_file_path = os.path.join(dir_path, "gen_extend_func.py")
-    tmp_file_path = os.path.join(dir_path, "tmp_gen_extend_func.py")
-    write_file(tmp_file_path, py_header + gen_py)
-    check_change_and_replace_file(dst_file_path, tmp_file_path)
+def call_PyboostOpHeaderGenerator(work_path, op_protos):
+    generator = PyboostOpHeaderGenerator('ascend')
+    generator.generate(work_path, op_protos)
 
+    generator = PyboostOpHeaderGenerator('gpu')
+    generator.generate(work_path, op_protos)
 
-def gen_signature_same_type_table(args_map, operator_data):
-    """
-    gen signature same type table
-    :param operator_name:
-    :param operator_data:
-    :return:
-    """
-    args_signature = operator_data.get('args_signature')
-    signature_table = ''
-    type_num = 0
-    if args_signature is not None:
-        dtype_group = args_signature.get('dtype_group')
-        if dtype_group is not None:
-            match = re.findall(r'\((.*?)\)', dtype_group)
-            for item in match:
-                name_args = item.replace(' ', '').split(",")
-                signature_table += '{'
-                for arg in name_args:
-                    arg_index = args_map[arg]
-                    signature_table += f"""{arg_index}, """
-                signature_table = signature_table[:-2]
-                signature_table += '}, '
-                type_num += 1
-            signature_table = signature_table[:-2]
-    return type_num, signature_table
+    generator = PyboostOpHeaderGenerator('cpu')
+    generator.generate(work_path, op_protos)
 
 
-def gen_pyboost_code(work_path, ops_yaml_data, doc_yaml_data, extra_ops):
-    """ gen_pyboost_code """
-    # generate pyboost inner prim
-    gen_pyboost_inner_prim(work_path, ops_yaml_data)
-    # generate pyboost py func
-    gen_pyboost_py_func(work_path, ops_yaml_data, doc_yaml_data)
-    # generate ops header file
-    generate_ops_header_files(work_path, ops_yaml_data, extra_ops)
-    # generate pyboost functions
-    generate_pyboost_functions(work_path, ops_yaml_data)
-    # generate pyboost grad functions
-    generate_pyboost_grad_functions(work_path, ops_yaml_data)
-    # generate pyboost native grad functions
-    generate_pyboost_native_grad_functions(work_path, ops_yaml_data)
-    # generate pyboost backend cpp code
-    generate_pyboost_op_cpp_code(work_path, ops_yaml_data)
+def call_PyboostOpRegisterCppCodeGenerator(work_path, op_protos):
+    op_register_cpp_generator = PyboostOpRegisterCppCodeGenerator()
+    op_register_cpp_generator.generate(work_path, op_protos)