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

mindspore/ops_generate/functions_cc_generator.py

@@ -0,0 +1,233 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""
+This module provides classes for generating C++ header and implementation files for functions based on op_protos.
+"""
+
+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
+
+
+class FunctionsHeaderGenerator(BaseGenerator):
+    """
+    Generates C++ header files for backend functions based on operator prototypes.
+    """
+
+    def __init__(self):
+        """
+        Initialize the functions header generator with templates for code generation.
+        """
+        self.FUNCTIONS_H_TEMPLATE = template.FUNCTIONS_H_TEMPLATE
+        self.function_interface_template = Template("${return_type} BACKEND_EXPORT ${op_name}(${input_args});")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generate the header file for backend functions.
+
+        Args:
+            work_path (str): The directory where the generated file should be saved.
+            op_protos (list): A list of operator prototypes used to generate the header.
+        """
+        functions_list = []
+        for op_proto in op_protos:
+            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+                continue
+            input_args_with_type_str = self._get_input_args(op_proto)
+            return_type_str = _get_return_type_str(op_proto)
+            functions = self.function_interface_template.replace(op_name=op_proto.op_name,
+                                                                 input_args=input_args_with_type_str,
+                                                                 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)
+        file_name = "functions.h"
+        save_file(save_path, file_name, pyboost_func_h_str)
+
+    def _get_input_args(self, op_proto):
+        """
+        Get the input arguments with type information for the function interface.
+
+        Args:
+            op_proto: The operator prototype.
+
+        Returns:
+            str: A string of input arguments with types.
+        """
+        args_list = []
+        for op_arg in op_proto.op_args:
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            args_list.append("const " + input_dtype + " &" + op_arg.arg_name)
+        return args_list
+
+
+class FunctionsGenerator(BaseGenerator):
+    """
+    Generates C++ implementation files for backend functions based on operator prototypes.
+    """
+
+    def __init__(self):
+        """
+        Initialize the functions generator with templates for code generation.
+        """
+        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'
+        )
+        self.clone_inplace_input_template = Template(
+            'GetCloneFunc()(op, prim::kPrim${class_name}, device_target, {${grad_args}});'
+        )
+
+    def generate(self, work_path, op_protos):
+        """
+        Generate the implementation file for backend functions.
+
+        Args:
+            work_path (str): The directory where the generated file should be saved.
+            op_protos (list): A list of operator prototypes used to generate the implementation.
+        """
+        func_include_headers_list = []
+        op_call_with_grad_list = []
+        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))
+        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)
+        file_name = "functions.cc"
+        save_file(save_path, file_name, pyboost_func_h_str)
+
+    def _get_function_body(self, op_proto):
+        """
+        Get the function body for a given operator prototype.
+
+        Args:
+            op_proto: The operator prototype.
+
+        Returns:
+            str: The generated function body.
+        """
+        input_args = self._get_input_args(op_proto, False)
+        input_args_with_type = self._get_input_args(op_proto, True)
+        inplace_clone_args = self._get_clone_input_args(op_proto, False, False)
+        clone_func_str = self._get_clone_inplace_str(op_proto.op_inplace, op_proto.op_class.name, inplace_clone_args)
+        return_type_str = _get_return_type_str(op_proto)
+        return self.FUNCTION_BODY_TEMPLATE.replace(op_name=op_proto.op_name,
+                                                   class_name=op_proto.op_class.name,
+                                                   input_args=input_args,
+                                                   clone_func=clone_func_str,
+                                                   input_args_with_type=input_args_with_type,
+                                                   return_type=return_type_str)
+
+    def _get_input_args(self, op_proto, has_type):
+        """
+        Get the input arguments for the function body.
+
+        Args:
+            op_proto: The operator prototype.
+            has_type (bool): Whether to include type information for the arguments.
+
+        Returns:
+            str: A string of input arguments, with or without types.
+        """
+        args_list = []
+        for op_arg in op_proto.op_args:
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            if has_type:
+                args_list.append("const " + input_dtype + " &" + op_arg.arg_name)
+            else:
+                args_list.append(op_arg.arg_name)
+        return args_list
+
+    def _get_clone_inplace_str(self, is_inplace_op: bool, class_name: str, grad_args: list):
+        """
+        Generates the view base str of arguments for the operator.
+
+        This method constructs a list of argument names that need to be cast to their corresponding types.
+
+        Args:
+            is_view_or_inplace (bool): Whether the op is view op or inplace op.
+            grad_args (list): grad args
+
+        Returns:
+            str: Formatted view or inplace first argument names.
+        """
+        if not is_inplace_op:
+            return ''
+        return self.clone_inplace_input_template.replace(class_name=class_name, grad_args=grad_args)
+
+    def _get_clone_input_args(self, op_proto, has_type, with_optional):
+        """
+        Get the input arguments for the DoGrad function.
+
+        Args:
+            op_proto: The operator prototype.
+            has_type (bool): Whether to include type information for the arguments.
+
+        Returns:
+            list: A list of input arguments for the DoGrad function.
+        """
+        args_list = []
+        for op_arg in op_proto.op_args:
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            if has_type:
+                args_list.append(f"const {input_dtype} &{op_arg.arg_name}")
+            else:
+                if not with_optional and is_optional_param(op_arg):
+                    args_list.append(f"OptionalToValue({op_arg.arg_name})")
+                else:
+                    args_list.append(f"{op_arg.arg_name}")
+        return args_list
+
+
+def _get_return_type_str(op_proto):
+    """
+    Get the return type string for the function.
+
+    Args:
+        op_proto: The operator prototype.
+
+    Returns:
+        str: The return type as a string.
+    """
+    returns_type = []
+    type_convert_to_base = {
+        'std::vector<mindspore::tensor::TensorPtr>': 'std::vector<mindspore::tensor::BaseTensorPtr>',
+        'mindspore::tensor::TensorPtr': 'mindspore::tensor::BaseTensorPtr'
+    }
+    for return_obj in op_proto.op_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

mindspore/ops_generate/gen_aclnn_implement.py

@@ -22,82 +22,43 @@ 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
 auto_gen = ''
 
 
-def gen_h(op_name, aclnn_name, op_yaml, kernelmod_h_path, need_update_shape):
+def gen_h(kernelmod_name, aclnn_name, op_proto, kernelmod_h_path, need_update_shape):
     """generate h files"""
-    kernelmod_name = op_yaml.get('dispatch').get("Ascend")
-    h_head = f"""
-#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_{op_name.upper()}_ACLNN{auto_gen.upper()}_KERNEL_MOD_H_
-#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_{op_name.upper()}_ACLNN{auto_gen.upper()}_KERNEL_MOD_H_
-#include <vector>
-#include "ops/base_operator.h"
-#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
-#include "transform/acl_ir/acl_convert.h"
-"""
-    update_shape = f"""
-  bool IsNeedUpdateOutputShapeAndSize() override {{ return true; }}
-  void UpdateOutputShapeAndSize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
-"""
+    op_name = op_proto.op_name
+    update_shape = template.UPDATE_OUTPUT_SHAPE_AND_SIZE
     if not need_update_shape:
-        update_shape = ""
-    h_body = f"""
-namespace mindspore {{
-namespace kernel {{
-
-class {kernelmod_name} : public AclnnKernelMod {{
- public:
-  {kernelmod_name}() : AclnnKernelMod(std::move("{aclnn_name}")) {{}}
-  ~{kernelmod_name}() = default;
-  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
-              const std::vector<KernelTensor *> &outputs, void *stream_ptr) override;
-  void GetWorkSpaceInfo(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
-  {update_shape}
-
- private:
-  DEFINE_GET_WORKSPACE_FOR_RESIZE()
-}};
-}}  // namespace kernel
-}}  // namespace mindspore
+        update_shape = "\n  "
 
-#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_{op_name.upper()}_ACLNN{auto_gen.upper()}_KERNEL_MOD_H_
-"""
     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
+    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(gen_utils.cc_license_str + h_head + h_body)
+        h_file.write(aclnn_kernel_h_str)
     gen_utils.check_change_and_replace_file(old_file, temp_file)
 
 
-def gen_cc(op_name, class_name, op_yaml, kernelmod_cc_path, need_update_shape):
+def gen_cc(kernelmod_name, aclnn_name, op_proto, kernelmod_cc_path, need_update_shape):
     """generate cc files"""
-    kernelmod_name = op_yaml.get('dispatch').get("Ascend")
-    cc_head = f"""
-#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn{auto_gen}/{op_name}_aclnn_kernel.h"
-#include <algorithm>
-#include <vector>
-#include <memory>
-#include <functional>
-#include "ir/tensor.h"
-#include "runtime/device/kernel_runtime.h"
-#include "transform/acl_ir/op_api_convert.h"
-#include "abstract/ops/primitive_infer_map.h"
-
-namespace mindspore {{
-namespace kernel {{
-"""
-    tuple_tensor_not_supported = f"""
-    It is not supported for {op_name} with tuple[tensor] inputs when using auto generate.
-    Please provide a KernelMod name in yaml and using python gen_aclnn_implement.py -n xx manually."""
-    input_templete = ''
+    op_name = op_proto.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_yaml)
+    input_dtypes, output_dtypes, _ = get_dtypes(op_proto)
     for idx, n in enumerate(input_dtypes):
         input_name = "inputs[kIndex" + str(idx) + "], "
         dtype = input_dtypes.get(n)
@@ -105,12 +66,12 @@ namespace kernel {{
             if dtype == 'int':
                 dtype = 'int64_t'
             input_templete += "  auto {} = transform::ConvertKernelTensor<{}>(inputs[kIndex{}]);\n".format(
-                n, dtype, idx)
-            input_name = n + ", "
+                n.arg_name, dtype, idx)
+            input_name = n.arg_name + ", "
         if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
             raise NotImplementedError(tuple_tensor_not_supported)
         inputs += input_name
-
+    input_templete = '' if input_templete == '\n  ' else input_templete
     for idx, n in enumerate(output_dtypes):
         output_name = "outputs[kIndex" + str(idx) + "], "
         dtype = output_dtypes.get(n)
@@ -118,76 +79,60 @@ namespace kernel {{
             if dtype == 'int':
                 dtype = 'int64_t'
             input_templete += "  auto {} = transform::ConvertKernelTensor<{}>(outputs[kIndex{}]);\n".format(
-                n, dtype, idx)
-            output_name = n + ", "
+                n.arg_name, dtype, idx)
+            output_name = n.arg_name + ", "
         if dtype == 'tuple[tensor]' and auto_gen == "_auto_gen":
             raise NotImplementedError(tuple_tensor_not_supported)
         inputs += output_name
     inputs = inputs[:-2]
-    workspace_info = f"""
-void {kernelmod_name}::GetWorkSpaceInfo(const std::vector<KernelTensor *> &inputs,
-                                        const std::vector<KernelTensor *> &outputs) {{
-  {input_templete}
-  GetWorkspaceForResize({inputs});
-}}
-"""
-    launch = f"""
-bool {kernelmod_name}::Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
-                              const std::vector<KernelTensor *> &outputs, void *stream_ptr) {{
-  MS_EXCEPTION_IF_NULL(stream_ptr);
-  {input_templete}
-  RunOp(stream_ptr, workspace, {inputs});
-  return true;
-}}
-"""
-    update_shape = f"""
-void {kernelmod_name}::UpdateOutputShapeAndSize(const std::vector<KernelTensor *> &,
-                                                const std::vector<KernelTensor *> &outputs) {{
-  // Delete these comment and complete the function:
-  // Using outputs[index_x]->SetShapeVector(update_shape) and outputs[index_x]->set_size(update_size)
-}}
-"""
+
+    update_shape = template.update_output_shape_and_size_template.replace(kernelmod_name=kernelmod_name)
     if not need_update_shape:
         update_shape = ""
 
-    reg = f"""
-MS_ACLNN_KERNEL_FACTORY_REG({class_name}, {kernelmod_name});
-}}  // namespace kernel
-}}  // namespace mindspore
-
-    """
     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
+    aclnn_kernel_cc_str = template.ACLNN_KERNEL_CC_TEMPLATE.replace(kernelmod_name=kernelmod_name,
+                                                                    input_templete=input_templete,
+                                                                    inputs=inputs,
+                                                                    update_shape=update_shape,
+                                                                    class_name=aclnn_name,
+                                                                    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(gen_utils.cc_license_str + cc_head + workspace_info + launch + update_shape + reg)
+        cc_file.write(aclnn_kernel_cc_str)
     gen_utils.check_change_and_replace_file(old_file, temp_file)
 
 
-def generate(op_name, class_name, op_yaml, h_and_cc, need_update_shape):
+def generate(kernelmod_name, class_name, op_proto, h_and_cc, need_update_shape):
     """generate cc and h files"""
     aclnn_name = AclnnUtils.get_aclnn_interface(class_name)
-    gen_h(op_name, aclnn_name, op_yaml, h_and_cc, need_update_shape)
-    gen_cc(op_name, class_name, op_yaml, h_and_cc, need_update_shape)
+    gen_h(kernelmod_name, aclnn_name, op_proto, h_and_cc, need_update_shape)
+    gen_cc(kernelmod_name, class_name, op_proto, h_and_cc, need_update_shape)
 
 
-def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
+def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
     """gen_aclnn_kernel function"""
-    if check_op_registed(op_name) and not auto:
+    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)
+        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 = '{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
+    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
     # merge inner ops
-    op_yaml = yaml_str.get(op_name)
-    class_name = ''.join(word.capitalize() for word in op_name.split('_'))
-    if op_yaml is None:
-        raise ValueError("Input op {} is not find in ops.yaml.".format(op_name))
-    dispatch = op_yaml.get("dispatch")
-    if not dispatch or not dispatch.get("enable"):
+    dispatch = op_proto.op_dispatch
+    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))
     global auto_gen
     if auto:
@@ -195,17 +140,17 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
             # Don't auto generate kernelmod if it is achieved manually.
             return
         auto_gen = "_auto_gen"
-        dispatch['Ascend'] = class_name + "Ascend"
+        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)
-    if dispatch.get("Ascend") is None:
+    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_yaml.get("class")
-    if op_class is not None and op_class.get("name") is not None:
-        class_name = op_class.get("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(op_name, class_name, op_yaml, kernelmod_h_and_cc_path, need_update_shape)
+    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/'):
@@ -235,12 +180,63 @@ manual_registed_ops = get_registed_ops(f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn
 
 def check_op_registed(op_name, manual=False):
     '''if op already registered return true'''
-    global registed_ops
-    global manual_registed_ops
     class_name = ''.join(word.capitalize() for word in op_name.split('_'))
     return (class_name in manual_registed_ops) if manual else (class_name in registed_ops)
 
 
+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")
+    yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
+
+    reg_code = f"""
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
+
+namespace mindspore {{
+namespace kernel {{
+"""
+    for operator_name, operator_data in yaml_data.items():
+        dispatch = operator_data.get("dispatch")
+        if not dispatch or not dispatch.get("enable"):
+            continue
+        Ascend = dispatch.get("Ascend")
+        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)
+            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('_'))
+        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"))
+        aclnn_name = AclnnUtils.get_aclnn_interface(class_name)
+        reg_code += f"""
+MS_ACLNN_COMMON_KERNEL_FACTORY_REG({class_name}, {aclnn_name}, {inputs_outputs_num});"""
+    reg_code += f"""
+}}  // namespace kernel
+}}  // namespace mindspore
+"""
+    return reg_code
+
+
+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'
+    reg_code = generate_aclnn_reg_code(yaml_str)
+    gen_utils.write_file(tmp_register_file, gen_utils.cc_license_str + reg_code)
+    gen_utils.check_change_and_replace_file(register_file, tmp_register_file)
+
+
 def main(op_name, need_update_shape):
     '''main func'''
     gen_aclnn_kernel(op_name, need_update_shape)
@@ -259,5 +255,5 @@ if __name__ == "__main__":
             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
+    except Exception as e:  # pylint: disable=W0703
         logging.exception("Generate aclnn kernelmod failed, err info: %s", e)