mindspore 2.6.0__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops_generate/common/gen_constants.py

@@ -55,13 +55,13 @@ TENSOR_PY_CC_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_register/auto_generate
 
 # yaml keys def
 OP_KEYS = {'args', 'args_signature', 'returns', 'function', 'class', 'view', 'graph_view', 'dispatch', 'labels',
-           'bprop_expander'}
+           'bprop_expander', 'non-differentiable'}
 ARG_KEYS = {'dtype', 'default', 'prim_init', 'type_cast', 'arg_handler'}
 RETURN_KEYS = {'dtype', 'inplace', 'type_cast'}
 ARG_SIGNATURE_KEYS = {'rw_write', 'rw_read', 'rw_ref', 'dtype_group'}
 CLASS_KEYS = {'name', 'disable'}
 FUNCTION_KEYS = {'name', 'disable'}
-DISPATCH_KEYS = {'enable', 'is_comm_op', 'Ascend', 'GPU', 'CPU'}
+DISPATCH_KEYS = {'enable', 'is_comm_op', 'Ascend', 'InternalOpAscend', 'GPU', 'CPU'}
 TENSOR_FUNC_KEYS = {'op_yaml', 'py_method', 'kwonlyargs',
                     'varargs', 'alias', 'Ascend', 'GPU', 'CPU', 'interface'}
 
@@ -89,3 +89,8 @@ MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
 MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH = "mindspore/ccsrc/pyboost/functions/auto_generate"
 MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")
 MS_PYBOOST_BASE_PATH = "mindspore/ccsrc/pyboost"
+MS_PYBOOST_INTERNAL_FUNCTIONS_AUTO_GEN_PATH = os.path.join(MS_OPS_KERNEL_PATH,
+                                                           "ascend/pyboost/internal/functions")
+MS_INTERNAL_PYBOOST_GEN_PATH = "mindspore/ccsrc/plugin/device/ascend/kernel/internal/pyboost/auto_gen"
+MS_PLUGIN_INTERNAL_PATH = "mindspore/ccsrc/plugin/device/ascend/kernel/internal"
+MS_OPS_PYBOOST_INTERNAL = "mindspore/ops/kernel/ascend/pyboost/internal"

mindspore/ops_generate/common/gen_utils.py

@@ -121,25 +121,6 @@ def merge_files(origin_dir, merged_file_path, file_format):
     merge_files_to_one_file(op_yaml_file_names, merged_file_path)
 
 
-def merge_files_append(origin_dir, merged_file_path, file_format):
-    """
-    Merge multiple files into one file.
-    origin_dir: indicates the origin file directory.
-    merged_file_path: indicates the merged file path.
-    file_format: indicates the format of regular matching.
-    Files whose names meet the regular matching in 'origin_dir' directory will be merged into one file.
-    """
-    file_paths = glob.glob(os.path.join(origin_dir, file_format))
-    merged_content = ''
-    file_paths.sort()
-    for file_path in file_paths:
-        with open(file_path, 'r') as file:
-            merged_content += file.read()
-            merged_content += '\n'
-    with open(merged_file_path, 'a') as file:
-        file.write(merged_content)
-
-
 def safe_load_yaml(yaml_file_path):
     """
     Load yaml dictionary from file.

mindspore/ops_generate/common/op_proto.py

@@ -112,10 +112,12 @@ class OpDispatch:
         gpu (str): The dispatch type for the GPU.
     """
 
-    def __init__(self, enable=False, is_comm_op=False, ascend='default', cpu='default', gpu='default'):
+    def __init__(self, enable=False, is_comm_op=False, ascend='default',
+                 internal_op_ascend='None', cpu='default', gpu='default'):
         self.enable = enable
         self.is_comm_op = is_comm_op
         self.ascend = ascend
+        self.internal_op_ascend = internal_op_ascend
         self.cpu = cpu
         self.gpu = gpu
 
@@ -151,7 +153,8 @@ class OpProto:
                  op_inplace=False,
                  op_labels=None,
                  op_deprecated=None,
-                 bprop_expander=True):
+                 bprop_expander=True,
+                 non_differentiable=False):
         self.op_name = op_name
         self.op_args = op_args
         self.op_function = op_function
@@ -165,6 +168,7 @@ class OpProto:
         self.op_labels = op_labels
         self.op_deprecated = op_deprecated
         self.bprop_expander = bprop_expander
+        self.non_differentiable = non_differentiable
 
     @staticmethod
     def load_from_yaml(op_name, op_data):
@@ -208,10 +212,12 @@ class OpProto:
         # get op deprecated
         op_deprecated = op_data.get('deprecated', None)
         bprop_expander = op_data.get('bprop_expander', True)
+        non_differentiable = op_data.get('non-differentiable', False)
         op_proto = OpProto(op_name=op_name, op_args=op_args, op_returns=op_returns, op_function=op_function,
                            op_class=op_class, op_dispatch=op_dispatch, op_args_signature=op_args_signature,
                            op_view=op_view, op_graph_view=op_graph_view, op_inplace=op_inplace, op_labels=op_labels,
-                           op_deprecated=op_deprecated, bprop_expander=bprop_expander)
+                           op_deprecated=op_deprecated, bprop_expander=bprop_expander,
+                           non_differentiable=non_differentiable)
         return op_proto
 
 
@@ -401,9 +407,10 @@ def get_op_dispatch(op_name, op_data):
             f'The dispatch enable value should be bool, but get {type(enable)}, op name is {op_name}.')
     is_comm_op = op_dispatch.get('is_comm_op', False)
     ascend = op_dispatch.get('Ascend', 'default')
+    internal_op_ascend = op_dispatch.get('InternalOpAscend', 'None')
     cpu = op_dispatch.get('CPU', 'default')
     gpu = op_dispatch.get('GPU', 'default')
-    return OpDispatch(enable, is_comm_op, ascend, cpu, gpu)
+    return OpDispatch(enable, is_comm_op, ascend, internal_op_ascend, cpu, gpu)
 
 
 def get_op_class(op_name, op_data) -> OpClass:

mindspore/ops_generate/common/template.py

@@ -93,7 +93,6 @@ ${func_impl_name}_impl = _Pyboost${class_name}Prim()
 """)
 
 IMPORT_PYBOOST_PRIM_HEADER = f"""
-from mindspore.common._stub_tensor import _convert_stub
 from mindspore.ops._utils.arg_handler import *
 """
 
@@ -118,19 +117,89 @@ REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE = Template(
 REGISTER_PYBOOST_GRAD_TEMPLATE = Template("${register_func}")
 
 PYBOOST_FUNCTION_HEADER_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_functions_h.tpl'))
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_h.tpl'))
 
-PYBOOST_FUNCTION_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_function.tpl'))
+PYBOOST_CORE_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_header.tpl'))
+PYBOOST_INTERNAL_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/internal/template/pyboost_internal_header_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_header_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_source_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_CUSTOMIZE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_customize_source_template.tpl'))
+
+PYBOOST_INTERNAL_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_source_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_functions_header_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_functions_source_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_function_template.tpl'))
+
+PYBOOST_KERNEL_INFO_ADAPTER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/kernel_info_adapter.tpl'))
+
+PYBOOST_KERNEL_INFO_ADAPTER_H_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/kernel_info_adapter_h.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_H_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_h.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_CPP_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_cpp.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_SINGLE_CPP_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_single_cpp.tpl'))
 
-PYBOOST_COMM_FUNCTION_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_comm_function.tpl'))
+PYBOOST_REGISTRY_BODY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_registry_body_cc.tpl'))
 
-PYBOOST_FUNCTION_DYNAMIC_OUTPUT_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_function_dynamic_output.tpl'))
+PYBOOST_CORE_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body.tpl'))
 
-PYBOOST_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_functions_cc.tpl'))
+PYBOOST_CORE_BODY_COMM_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body_comm.tpl'))
+
+PYBOOST_CORE_BODY_SYNC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body_sync.tpl'))
+
+PYBOOST_REGISTRY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_registry_cc.tpl'))
+
+PYBOOST_API_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_cc.tpl'))
+
+PYBOOST_API_BODY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_body_cc.tpl'))
+
+PYBOOST_CORE_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_cc.tpl'))
 
 PYBOOST_OVERLOAD_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
     os.path.join(
@@ -213,6 +282,10 @@ PYBOOST_OP_REGISTER_TEMPLATE = Template.load_from_file(
 PYBOOST_ASCEND_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_header_template.tpl'))
+PYBOOST_ASCEND_INTERNAL_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/internal/template/pyboost_internal_header_template.tpl')
+)
 
 PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
@@ -226,6 +299,8 @@ PYBOOST_ASCEND_SINGLE_HCLL_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_hccl_op_header_template.tpl'))
 
+PYBOOST_CALL_FUNC_TEMPLATE = Template('${return_type} Call(${call_args_with_type}) override;')
+
 PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_op_source_template.tpl'))
@@ -373,7 +448,6 @@ from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops._utils.arg_dtype_cast import type_it
 from mindspore.ops._utils.arg_handler import *
 from mindspore._c_expression import OpDtype
-from mindspore.common._stub_tensor import _convert_stub
 from mindspore.common.jit_context import jit_context
 from mindspore._checkparam import is_stub_tensor
 """
@@ -509,6 +583,9 @@ FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
 FUNCTION_BODY_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/function_body.tpl'))
 
+FUNCTION_COMM_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/comm_function_body.tpl'))
+
 FUNCTIONS_H_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/functions_h.tpl'))
 

mindspore/ops_generate/gen_ops.py

@@ -47,6 +47,6 @@ def main():
 if __name__ == "__main__":
     try:
         main()
-    except Exception as e: # pylint: disable=broad-except
+    except Exception as e:
         logging.critical("Auto generate failed, err info: %s", e)
         raise e

mindspore/ops_generate/op_def/lite_ops_cpp_generator.py

@@ -24,7 +24,6 @@ import common.template as template
 from common.base_generator import BaseGenerator
 from pyboost import pyboost_utils
 
-
 LITE_OPS_H = """
 #ifndef MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
 #define MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
@@ -122,9 +121,10 @@ class LiteOpsCcGenerator(BaseGenerator):
         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("${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")
+        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):
         """

mindspore/ops_generate/op_def/ops_name_h_generator.py

@@ -19,15 +19,12 @@ This module defines the `OpsNameHGenerator` class, which produces C++ code to de
 constants for operator names based on given prototypes.
 """
 
-import os
-
 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
 
-
 OP_NAME_OP_DEF = """
 #ifndef MINDSPORE_CORE_OP_NAME_${suffix}_H_
 #define MINDSPORE_CORE_OP_NAME_${suffix}_H_

mindspore/ops_generate/op_def/ops_primitive_h_generator.py

@@ -19,15 +19,12 @@ This module defines the `OpsPrimitiveHGenerator` class, which creates C++ header
 containing definitions for operator primitives based on provided operator prototypes.
 """
 
-import os
-
 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
 
-
 OP_PRIM_OP_DEF_H = """
 #ifndef MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
 #define MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
@@ -42,7 +39,6 @@ $ops_prim_gen
 #endif  // MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
 """
 
-
 OP_PRIM_OP_DEF_CC = """
 
 #include "$auto_gen_path/gen_ops_primitive_${suffix}.h"

mindspore/ops_generate/op_def_py/op_prim_py_generator.py

@@ -142,7 +142,10 @@ class OpPrimPyGenerator(BaseGenerator):
                 # step1.3: get args set prim arg expression:
                 assign_str = self._get_assign_str_by_type_it(op_proto.op_class.name, arg)
                 if arg.arg_handler:
-                    assign_str = f"""        self._set_prim_arg_with_handler("{arg.arg_name}", {assign_str}, {arg.arg_handler})"""
+                    assign_str = (
+                        f'        self._set_prim_arg_with_handler('
+                        f'"{arg.arg_name}", {assign_str}, {arg.arg_handler})'
+                    )
                 else:
                     assign_str = f"""        self._set_prim_arg("{arg.arg_name}", {assign_str})"""
                 args_assign.append(assign_str)
@@ -318,7 +321,7 @@ class OpPrimPyGenerator(BaseGenerator):
             call_method_body_str += f"""
         # Add for jit context.
         if jit_context() and jit_context().compiled:
-            return None"""
+            return jit_context().default_output()"""
             pyboost_func_name = pyboost_utils.get_pyboost_name(op_proto.op_name)
             call_method_body_str += f"""
         res = {pyboost_func_name}(self, [{call_args_list_str}])"""

mindspore/ops_generate/pyboost/auto_grad_impl_cc_generator.py

@@ -58,7 +58,7 @@ class AutoGradImplGenerator(BaseGenerator):
         do_grad_op_list = []
         ops_inc_head_set = set()
         for op_proto in op_protos:
-            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+            if op_proto.op_dispatch is None:
                 continue
             auto_grad_reg_list.append(self.auto_grad_reg_template.replace(class_name=op_proto.op_class.name))
             do_grad_op_list.append(self._get_single_do_grad_op(op_proto))
@@ -80,24 +80,38 @@ class AutoGradImplGenerator(BaseGenerator):
         Returns:
             str: The generated DoGrad function string.
         """
-        input_args_str = self._get_input_args(op_proto, False, False)
-        input_args_with_optional_str = self._get_input_args(op_proto, False, True)
-        input_args_with_type_str = self._get_input_args(op_proto, True, False)
+        input_args_str = self._get_input_args(op_proto, False, False, op_proto.op_view)
+        input_args_with_optional_str = self._get_input_args(op_proto, False, True, op_proto.op_view)
+        input_args_with_type_str = self._get_input_args(op_proto, True, False, op_proto.op_view)
+        inner_grad_args_with_type = self._get_input_args(op_proto, True, False, False)
         multi_output_str = 'Multi' if is_op_multi_output(op_proto.op_returns) else ''
         view_arg_str = self._get_view_str(op_proto.op_view, input_args_str)
         grad_args_with_type_str = self.do_grad_op_args_with_type.replace(input_args_with_type=input_args_with_type_str)
+        inner_grad_args_with_type =\
+            self.do_grad_op_args_with_type.replace(input_args_with_type=inner_grad_args_with_type)
         op_def_name_str = "g" + op_proto.op_class.name
-        bprop_expander = "true" if op_proto.bprop_expander else "false"
+        TRUE = "true"
+        FALSE = "false"
+        bprop_expander = TRUE if op_proto.bprop_expander else FALSE
+        non_differentiable = TRUE if op_proto.non_differentiable else FALSE
+        if not op_proto.op_view:
+            convert_basic_to_value = ''
+        else:
+            input_args_with_optional_str, convert_basic_to_value = self._get_convert_str(op_proto,
+                                                                                         input_args_with_optional_str)
         return self.DO_GRAD_FUNCTION_BODY_TEMPLATE.replace(class_name=op_proto.op_class.name,
+                                                           inner_grad_args_with_type=inner_grad_args_with_type,
                                                            grad_args_with_type=grad_args_with_type_str,
                                                            grad_input_args=input_args_str,
                                                            grad_input_args_with_optional=input_args_with_optional_str,
                                                            is_multi=multi_output_str,
                                                            view_arg=view_arg_str,
                                                            op_def_name=op_def_name_str,
-                                                           bprop_expander=bprop_expander)
+                                                           bprop_expander=bprop_expander,
+                                                           non_differentiable=non_differentiable,
+                                                           convert_basic_to_value=convert_basic_to_value)
 
-    def _get_input_args(self, op_proto, has_type, with_optional):
+    def _get_input_args(self, op_proto, has_type, with_optional, use_basic_type=False):
         """
         Get the input arguments for the DoGrad function.
 
@@ -110,7 +124,7 @@ class AutoGradImplGenerator(BaseGenerator):
         """
         args_list = []
         for op_arg in op_proto.op_args:
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg), use_basic_type)
             if has_type:
                 args_list.append(f"const {input_dtype} &{op_arg.arg_name}_tensor")
             else:
@@ -120,6 +134,33 @@ class AutoGradImplGenerator(BaseGenerator):
                     args_list.append(f"{op_arg.arg_name}_tensor")
         return args_list
 
+    def _get_convert_str(self, op_proto, args_name):
+        """
+        Get the input convert func 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.
+            list: A list of convert functions.
+        """
+        args_name_list = []
+        convert_funcs = []
+        convert_types = ["tuple[int]", "list[int]", "int"]
+        convert_func_template = Template("const auto &${arg_name} = PackToValue(${input_name});")
+        for op_arg, arg_name in zip(op_proto.op_args, args_name):
+            if op_arg.arg_dtype not in convert_types:
+                args_name_list.append(arg_name)
+                continue
+            out_arg_name = arg_name + "_value"
+            input_name = arg_name
+            convert_funcs.append(convert_func_template.replace(arg_name=out_arg_name,
+                                                               input_name=input_name))
+            args_name_list.append(out_arg_name)
+        return args_name_list, convert_funcs
+
     def _get_view_str(self, is_view_op: bool, grad_args: list):
         """
         Get the view argument string for a DoGrad function.

mindspore/ops_generate/pyboost/auto_grad_reg_cc_generator.py

@@ -56,7 +56,7 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
         op_grad_func_obj_list = []
         index = 0
         for op_proto in op_protos:
-            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+            if op_proto.op_dispatch is None:
                 continue
             op_type_enum_list.append(self.op_type_enum_template.replace(class_name=op_proto.op_class.name,
                                                                         enum_val=index))
@@ -87,7 +87,7 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
         input_tensor_prt_args_str = ""
         for op_arg in op_proto.op_args:
             is_optional = is_optional_param(op_arg)
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional)
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional, op_proto.op_view)
             input_tensor_prt_args_str += f"const {input_dtype} &, "
 
         return self.op_grad_func_args_template.replace(input_tensor_prt_args=input_tensor_prt_args_str.rstrip(', '))

mindspore/ops_generate/pyboost/gen_pyboost_func.py

@@ -26,7 +26,11 @@ 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_functions_impl_cpp_generator import PyboostFunctionsImplGenerator
 from .pyboost_grad_function_cpp_generator import PyboostGradFunctionsGenerator
+from .pyboost_internal_functions_h_generator import PyboostInternalFunctionsHeaderGenerator
+from .pyboost_internal_functions_cpp_generator import PyboostInternalFunctionsCppGenerator
+from .pyboost_internal_kernel_info_adapter_generator import PyboostKernelInfoAdapterGenerator
 from .pyboost_native_grad_functions_generator import (
     PyboostGradFunctionsHeaderGenerator,
     PyboostGradFunctionsCppGenerator,
@@ -35,6 +39,7 @@ from .pyboost_op_cpp_code_generator import (
     PyboostCommonOpHeaderGenerator,
     PyboostOpFunctionGenerator,
     PyboostOpHeaderGenerator,
+    PyboostInternalOpHeaderGenerator,
     delete_residual_files,
     PyboostOpRegisterCppCodeGenerator,
 )
@@ -68,6 +73,9 @@ def gen_pyboost_code(resource_mgr):
     call_pyboost_functions_h_generator(work_path, op_protos)
     call_pyboost_functions_cpp_generator(work_path, op_protos)
     call_pyboost_overload_functions_cpp_generator(work_path, op_protos, mint_func_protos, alias_func_mapping)
+    call_pyboost_internal_functions_h_generator(work_path, op_protos)
+    call_pyboost_internal_functions_cpp_generator(work_path, op_protos)
+    call_pyboost_internal_kernel_info_adapter_generator(work_path, op_protos)
     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)
@@ -117,7 +125,27 @@ def call_pyboost_functions_h_generator(work_path, op_protos):
     generator.generate(work_path, op_protos)
 
 
+def call_pyboost_internal_functions_h_generator(work_path, op_protos):
+    "gen internal op functions headers"
+    generator = PyboostInternalFunctionsHeaderGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_pyboost_internal_functions_cpp_generator(work_path, op_protos):
+    "gen internal op functions sources"
+    generator = PyboostInternalFunctionsCppGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_pyboost_internal_kernel_info_adapter_generator(work_path, op_protos):
+    "gen kernel info adapter for internal op"
+    generator = PyboostKernelInfoAdapterGenerator()
+    generator.generate(work_path, op_protos)
+
+
 def call_pyboost_functions_cpp_generator(work_path, op_protos):
+    impl_generator = PyboostFunctionsImplGenerator()
+    impl_generator.generate(work_path, op_protos)
     generator = PyboostFunctionsGenerator()
     generator.generate(work_path, op_protos)
 
@@ -160,8 +188,11 @@ def call_PyboostCommonOpCppCodeGenerator(work_path, op_protos):
 
 
 def call_PyboostOpHeaderGenerator(work_path, op_protos):
+    """ generate pyboost op headers """
     generator = PyboostOpHeaderGenerator('ascend')
     generator.generate(work_path, op_protos)
+    generator = PyboostInternalOpHeaderGenerator('ascend')
+    generator.generate(work_path, op_protos)
 
     generator = PyboostOpHeaderGenerator('gpu')
     generator.generate(work_path, op_protos)