mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops_generate/pyboost/pyboost_functions_impl_cpp_generator.py

@@ -55,10 +55,18 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
             'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToTensor(${input}, ${need_contiguous}, '
             'op_run_info->requires_grad);\n'
         )
+        self.convert_to_tensor_view_template = Template(
+            'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToTensor(${input}, ${need_contiguous}, '
+            'requires_grad);\n'
+        )
         self.convert_to_tensor_list_template = Template(
             'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToValueTuple(${input}, ${need_contiguous}, '
             'op_run_info->requires_grad);\n'
         )
+        self.convert_to_tensor_list_view_template = Template(
+            'auto ${output} = PyNativeAlgo::Common::ConvertStubNodeToValueTuple(${input}, ${need_contiguous}, '
+            'requires_grad);\n'
+        )
         self.implicit_cast_template = Template(
             '// Do mixed precision and implicit cast\n' \
             'static const std::vector<std::vector<size_t>> same_type_table{${same_type}};\n' \
@@ -73,8 +81,10 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
         self.OP_DEF_INC_HEAD_TEMPLATE = template.OP_DEF_INC_HEAD_TEMPLATE
 
         self.PYBOOST_CORE_BODY_TEMPLATE = template.PYBOOST_CORE_BODY_TEMPLATE
+        self.PYBOOST_CORE_BODY_VIEW_TEMPLATE = template.PYBOOST_CORE_BODY_VIEW_TEMPLATE
         self.PYBOOST_CORE_BODY_COMM_TEMPLATE = template.PYBOOST_CORE_BODY_COMM_TEMPLATE
         self.PYBOOST_CORE_BODY_SYNC_TEMPLATE = template.PYBOOST_CORE_BODY_SYNC_TEMPLATE
+        self.PYBOOST_CORE_BODY_VIEW_SYNC_TEMPLATE = template.PYBOOST_CORE_BODY_VIEW_SYNC_TEMPLATE
 
     def generate(self, work_path, op_protos):
         """
@@ -148,10 +158,10 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
         cast_args_str = self._get_cast_to_value_str(op_proto)
         op_input_args_str = self._get_input_args_str(op_proto)
         output_num_str = len(op_proto.op_returns)
+        has_side_effect_str = 'true' if op_proto.op_view or op_proto.op_inplace else 'false'
         pyboost_core_body_tpl = self._get_pyboost_core_body_tpl(op_proto)
         if op_proto.op_view:
             implicit_cast_str = ''
-            cast_args_str = call_args_str
         else:
             implicit_cast_str = self.implicit_cast_template.replace(cast_args=cast_args_str,
                                                                     type_num=type_num,
@@ -170,6 +180,7 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
                                              call_args=call_args_str,
                                              cast_args=cast_args_str,
                                              output_num=output_num_str,
+                                             has_side_effect=has_side_effect_str,
                                              operator_name=op_proto.op_name)
 
     def _generate_parser_func(self, op_proto: OpProto) -> str:
@@ -232,23 +243,28 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
         """
         convert_stub_str = ''
         need_contiguous = 'true'
+        convert_to_tensor_template = self.convert_to_tensor_template
+        convert_to_tensor_list_template = self.convert_to_tensor_list_template
         if op_proto.op_view:
             # View/ACLNN op does not need to convert to contiguous tensor.
             need_contiguous = 'false'
+            convert_to_tensor_template = self.convert_to_tensor_view_template
+            convert_to_tensor_list_template = self.convert_to_tensor_list_view_template
+
         for op_arg in op_proto.op_args:
             if pyboost_utils.is_tensor(op_arg):
                 convert_stub_output_name = op_arg.arg_name + '_optional' if is_optional_param(op_arg) \
                     else op_arg.arg_name + "_tensor"
-                convert_stub_str += self.convert_to_tensor_template.replace(input=op_arg.arg_name,
-                                                                            output=convert_stub_output_name,
-                                                                            need_contiguous=need_contiguous)
+                convert_stub_str += convert_to_tensor_template.replace(input=op_arg.arg_name,
+                                                                       output=convert_stub_output_name,
+                                                                       need_contiguous=need_contiguous)
             elif pyboost_utils.is_tensor_list(op_arg):
                 # To adapt the cases where TensorList is optional.
                 convert_stub_output_name = op_arg.arg_name + '_optional' if is_optional_param(op_arg) \
                     else op_arg.arg_name + "_tensor_list"
-                convert_stub_str += self.convert_to_tensor_list_template.replace(input=op_arg.arg_name,
-                                                                                 output=convert_stub_output_name,
-                                                                                 need_contiguous=need_contiguous)
+                convert_stub_str += convert_to_tensor_list_template.replace(input=op_arg.arg_name,
+                                                                            output=convert_stub_output_name,
+                                                                            need_contiguous=need_contiguous)
         return convert_stub_str
 
     def _get_call_args_str(self, op_proto: OpProto):
@@ -311,6 +327,10 @@ class PyboostFunctionsImplGenerator(BaseGenerator):
     def _get_pyboost_core_body_tpl(self, op_proto: OpProto):
         if len(op_proto.op_returns) == 1 and is_tensor_list(op_proto.op_returns[0]):
             # op output size is unknown
-            return self.PYBOOST_CORE_BODY_SYNC_TEMPLATE
-        return self.PYBOOST_CORE_BODY_COMM_TEMPLATE \
-            if op_proto.op_dispatch.is_comm_op else self.PYBOOST_CORE_BODY_TEMPLATE
+            return self.PYBOOST_CORE_BODY_VIEW_SYNC_TEMPLATE\
+                if op_proto.op_view else self.PYBOOST_CORE_BODY_SYNC_TEMPLATE
+        if op_proto.op_view:
+            return self.PYBOOST_CORE_BODY_VIEW_TEMPLATE
+        if op_proto.op_dispatch.is_comm_op:
+            return self.PYBOOST_CORE_BODY_COMM_TEMPLATE
+        return self.PYBOOST_CORE_BODY_TEMPLATE

mindspore/ops_generate/pyboost/pyboost_grad_function_cpp_generator.py

@@ -49,6 +49,8 @@ class PyboostGradFunctionsGenerator(BaseGenerator):
         self.GEN_OPS_DEF_HEADER_TEMPLATE = template.GEN_OPS_DEF_HEADER_TEMPLATE
         self.contiguous_template = Template(
             "convert_$arg_name = runtime::ValueConverter::ContiguousTensorValue($device_target, convert_$arg_name);\n")
+        self.PYBOOST_GRAD_FUNCTION_TEMPLATE = template.PYBOOST_GRAD_FUNCTION_TEMPLATE
+        self.PYBOOST_VIEW_GRAD_FUNCTION_TEMPLATE = template.PYBOOST_VIEW_GRAD_FUNCTION_TEMPLATE
 
     def generate(self, work_path, op_protos):
         """
@@ -69,8 +71,7 @@ class PyboostGradFunctionsGenerator(BaseGenerator):
         pyboost_func_reg_def = ''
         pyboost_func_include_headers_str = ''
         for op_proto in op_protos:
-            if (op_proto.op_dispatch is None) or (not op_proto.op_dispatch.enable) \
-                    or op_proto.op_dispatch.is_comm_op:
+            if (op_proto.op_dispatch is None) or (not op_proto.op_dispatch.enable):
                 continue
             op_parser = OpTemplateParser(op_proto)
             op_pyboost_func_name = op_parser.get_pyboost_func_name()
@@ -85,7 +86,8 @@ class PyboostGradFunctionsGenerator(BaseGenerator):
             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(
+            pyboost_grad_function_template = self._get_pyboost_grad_function_template(op_proto)
+            pyboost_func_str += pyboost_grad_function_template.replace(
                 func_name=op_pyboost_func_name,
                 op_name=op_name_str,
                 op_args=op_args_str,
@@ -108,6 +110,11 @@ class PyboostGradFunctionsGenerator(BaseGenerator):
         file_name = "pyboost_grad_functions.cc"
         save_file(save_path, file_name, pyboost_func_file)
 
+    def _get_pyboost_grad_function_template(self, op_proto: OpProto):
+        if op_proto.op_view:
+            return self.PYBOOST_VIEW_GRAD_FUNCTION_TEMPLATE
+        return self.PYBOOST_GRAD_FUNCTION_TEMPLATE
+
     def _convert_value_type(self, op_proto: OpProto) -> str:
         """
         Generates the code for converting the operator's input values to the required types.

mindspore/ops_generate/pyboost/pyboost_internal_kernel_info_adapter_generator.py

@@ -51,7 +51,7 @@ class PyboostKernelInfoAdapterGenerator(BaseGenerator):
         self.kernel_info_adapter_cpp_template = template.PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_CPP_TEMPLATE
         self.kernel_info_adapter_register_template = Template(KERNEL_INFO_ADAPTER_REGISTER)
         self.merged_op_headers_template = Template(
-            "#include \"plugin/device/ascend/kernel/internal/pyboost/${operator_name}.h\"\n")
+            "#include \"kernel/ascend/internal/pyboost/${operator_name}.h\"\n")
 
     def generate(self, work_path, op_protos):
         """

mindspore/ops_generate/pyboost/pyboost_native_grad_functions_generator.py

@@ -51,8 +51,11 @@ class PyboostGradFunctionsCppGenerator(BaseGenerator):
 
     def __init__(self):
         self.PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE = template.PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE
+        self.PYBOOST_NATIVE_VIEW_GRAD_FUNCTION_TEMPLATE = template.PYBOOST_NATIVE_VIEW_GRAD_FUNCTION_TEMPLATE
         self.PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE = template.PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE
         self.native_function_multi_output_template = template.MULTI_OUTPUT_TEMPLATE
+        self.native_view_function_output_template =\
+            "const auto &output_value = runtime::ValueConverter::ToValue(outputs);\n"
         self.native_function_single_output_template = "const auto &output_value = op->outputs()[0];\n"
         self.native_include_header_template = Template(
             f'#include "{K.MS_PYBOOST_BASE_PATH}/auto_generate/${{operator_name}}.h"\n')
@@ -93,15 +96,15 @@ class PyboostGradFunctionsCppGenerator(BaseGenerator):
             output_expr = self._get_output_expr(op_proto)
 
             pyboost_func_str += \
-                template.PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE.replace(func_name=op_proto.op_class.name,
-                                                                       op_name=op_proto.op_class.name,
-                                                                       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,
-                                                                       operator_name=op_proto.op_name)
+                self._get_native_grad_function_template(op_proto).replace(func_name=op_proto.op_class.name,
+                                                                          op_name=op_proto.op_class.name,
+                                                                          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,
+                                                                          operator_name=op_proto.op_name)
             pyboost_func_str = pyboost_func_str + template.NEW_LINE
             pyboost_func_include_headers_str += (
                 self.native_include_header_template.replace(operator_name=op_proto.op_name))
@@ -114,6 +117,11 @@ class PyboostGradFunctionsCppGenerator(BaseGenerator):
         save_file(os.path.join(work_path, K.PYBOOST_NATIVE_GRAD_FUNC_GEN_PATH),
                   "pyboost_native_grad_functions.cc", native_grad_func_file)
 
+    def _get_native_grad_function_template(self, op_proto):
+        if op_proto.op_view:
+            return self.PYBOOST_NATIVE_VIEW_GRAD_FUNCTION_TEMPLATE
+        return self.PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE
+
     def _convert_native_value_type(self, op_proto: OpProto) -> str:
         """
         Generates native value conversion functions for operator arguments.
@@ -172,6 +180,8 @@ class PyboostGradFunctionsCppGenerator(BaseGenerator):
         Returns:
             str: The output expression used in the function implementation.
         """
+        if op_proto.op_view:
+            return self.native_view_function_output_template
         output_expr = self.native_function_single_output_template
         if pyboost_utils.is_op_multi_output(op_proto.op_returns):
             output_expr = self.native_function_multi_output_template

mindspore/ops_generate/pyboost/pyboost_op_cpp_code_generator.py

@@ -40,6 +40,25 @@ def check_no_basic_int_type(op_args):
     return True
 
 
+def get_inplace_indices(op_proto):
+    """
+    Extracts the indices of inplace arguments from the operation prototype.
+
+    Args:
+        op_proto (OpProto): The operator prototype containing argument information.
+
+    Returns:
+        list: A list of indices for inplace arguments.
+    """
+    inplace_args = []
+    for arg in op_proto.op_returns:
+        if arg.inplace != '':
+            inplace_args.append(arg.inplace)
+    input_args = [arg.arg_name for arg in op_proto.op_args]
+    inplace_indices = [input_args.index(arg) for arg in inplace_args]
+    return inplace_indices
+
+
 class PyboostCommonOpHeaderGenerator(BaseGenerator):
     """
     Generates common C++ headers for PyBoost operations.
@@ -68,6 +87,8 @@ class PyboostCommonOpHeaderGenerator(BaseGenerator):
             None
         """
         for op_proto in op_protos:
+            if is_op_multi_output(op_proto.op_returns):
+                print(op_proto.op_name)
             if op_proto.op_dispatch is None:
                 continue
             op_parser = OpTemplateParser(op_proto)
@@ -114,8 +135,11 @@ class PyboostOpHeaderGenerator(BaseGenerator):
             raise ValueError(
                 f"Device must be ascend, gpu, or cpu, {device} is not supported")
         self.PYBOOST_OP_HEADER_TEMPLATE = template_dict[device]
-        self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/auto_generate/"
-        self.hccl_code_generate_path = "mindspore/ccsrc/plugin/device/ascend/kernel/hccl/pyboost/auto_generate/"
+        if device == "ascend":
+            self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
+        else:
+            self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/auto_generate/"
+        self.hccl_code_generate_path = "mindspore/ops/kernel/ascend/hccl/pyboost/auto_generate/"
         self.device = device
 
     def generate(self, work_path, op_protos):
@@ -174,7 +198,10 @@ class PyboostInternalOpHeaderGenerator(BaseGenerator):
             raise ValueError(
                 f"Currently, only support 'ascend' for internal operations, {device} is not supported.")
         self.pyboost_internal_op_header_template = template.PYBOOST_ASCEND_INTERNAL_OP_HEADER_TEMPLATE
-        self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/internal/auto_generate/"
+        if device == "ascend":
+            self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/internal/auto_generate/"
+        else:
+            self.code_generate_path = f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/internal/auto_generate/"
         self.device = device
 
     def generate(self, work_path, op_protos):
@@ -234,7 +261,7 @@ class PyboostOpCppGenerator:
             PYBOOST_CUSTOMIZE_CALL_TEMPLATE = template.PYBOOST_ASCEND_CUSTOMIZE_CALL_TEMPLATE
             PYBOOST_SINGLE_OP_HEADER_TEMPLATE = template.PYBOOST_ASCEND_SINGLE_OP_HEADER_TEMPLATE
             PYBOOST_SINGLE_OP_SOURCE_TEMPLATE = template.PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE
-            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/auto_generate/"
+            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
             self.device_reg_str = "Ascend"
         elif device == 'cpu':
             PYBOOST_CUSTOMIZE_CALL_TEMPLATE = template.PYBOOST_CPU_CUSTOMIZE_CALL_TEMPLATE
@@ -296,9 +323,12 @@ class PyboostOpCppGenerator:
                 if arg.inplace != '':
                     check_inplace_func = f'ThrowExpectionWhenInternalOverlap({arg.inplace}_tensor);'
                     break
+            inplace_indices = get_inplace_indices(op_proto)
+            inplace_indices_str = ', '.join(str(i) for i in inplace_indices)
             call_impl = self.PYBOOST_CUSTOMIZE_CALL_TEMPLATE.replace(
                 call_args=call_args,
                 return_values=call_func_outputs,
+                inplace_indices=inplace_indices_str,
                 customize_func=getattr(
                     op_proto.op_dispatch, self.device) + "Customize",
                 check_expression=check_inplace_func,
@@ -309,10 +339,16 @@ must be provided for comm op {operator_name}")
 
             if is_ascend_comm_op:
                 customize_include = \
-                    f'#include "mindspore/ccsrc/plugin/device/ascend/kernel/hccl/pyboost/{operator_name.lower()}.h"\n'
+                    f'#include "mindspore/ops/kernel/ascend/hccl/pyboost/{operator_name.lower()}.h"\n'
             else:
-                customize_include = \
-                    f'#include "{K.MS_OPS_KERNEL_PATH}/{self.device}/pyboost/customize/{operator_name.lower()}.h"\n'
+                if self.device == 'ascend':
+                    customize_include = (
+                        f'#include "{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/customize/'
+                        f'{operator_name.lower()}.h"\n'
+                    )
+                else:
+                    customize_include = \
+                        f'#include "{K.MS_OPS_KERNEL_PATH}/{self.device}/pyboost/customize/{operator_name.lower()}.h"\n'
 
             register_custom = self._get_register_custom_kernel(op_proto)
             cpp_func_return = _generate_cpp_func_return(op_proto)
@@ -386,7 +422,7 @@ class PyboostViewOpCppGenerator:
             PYBOOST_VIEW_CALL_TEMPLATE = template.PYBOOST_ASCEND_VIEW_CALL_TEMPLATE
             PYBOOST_SINGLE_OP_HEADER_TEMPLATE = template.PYBOOST_ASCEND_SINGLE_OP_HEADER_TEMPLATE
             PYBOOST_SINGLE_OP_SOURCE_TEMPLATE = template.PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE
-            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/auto_generate/"
+            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
             self.device_reg_str = "Ascend"
         elif device == 'cpu':
             PYBOOST_VIEW_CALL_TEMPLATE = template.PYBOOST_CPU_VIEW_CALL_TEMPLATE
@@ -425,7 +461,6 @@ class PyboostViewOpCppGenerator:
             merge_op_header (list): A list to store the generated C++ header code for view operations.
             merge_op_function (list): A list to store the generated C++ source code for view operations.
         """
-        calc_args_temp = Template("{${call_args}}")
         for op_proto in op_protos:
             if op_proto.op_dispatch is None:
                 continue
@@ -433,7 +468,7 @@ class PyboostViewOpCppGenerator:
                 continue
             if getattr(op_proto.op_dispatch, self.device) == 'None':
                 continue
-            if not op_proto.op_view:
+            if not op_proto.op_view or not op_proto.bprop_expander:
                 continue
 
             op_parser = OpTemplateParser(op_proto)
@@ -441,16 +476,12 @@ class PyboostViewOpCppGenerator:
             call_args = OpTemplateParser.parse_original_call_args(op_proto.op_args)
             if op_proto.op_view and not check_no_basic_int_type(op_proto.op_args):
                 call_args_with_type = op_parser.parse_call_args_with_types(True)
-                storage_calc_str = op_proto.op_class.name + "BasicType"
-                calc_func_args_str = call_args
             else:
                 call_args_with_type = op_parser.parse_call_args_with_types()
-                storage_calc_str = op_proto.op_class.name
-                calc_func_args_str = calc_args_temp.replace(call_args=call_args)
+            storage_calc_str = op_proto.op_class.name
             _, call_func_outputs = op_parser.generate_pyboost_outputs()
             call_impl = self.PYBOOST_VIEW_CALL_TEMPLATE.replace(op_name=op_proto.op_class.name,
                                                                 storage_calc=storage_calc_str,
-                                                                calc_func_args=calc_func_args_str,
                                                                 call_args=call_args,
                                                                 call_tensors=call_args_tensor,
                                                                 return_values=call_func_outputs,
@@ -499,7 +530,7 @@ class AclnnOpCppCodeGenerator:
         if device == 'ascend':
             PYBOOST_CALL_TEMPLATE = template.PYBOOST_ASCEND_CALL_TEMPLATE
             PYBOOST_SINGLE_OP_SOURCE_TEMPLATE = template.PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE
-            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/auto_generate/"
+            gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
             self.device_reg_str = "Ascend"
         elif device == 'cpu':
             PYBOOST_CALL_TEMPLATE = template.PYBOOST_CPU_CALL_TEMPLATE
@@ -517,9 +548,14 @@ class AclnnOpCppCodeGenerator:
         self.PYBOOST_REG_OP_TEMPLATE = Template('MS_REG_PYBOOST_OP(${device}, ${op_name});' \
                                                 '${register_custom_kernel}')
         self.PYBOOST_CALL_TEMPLATE = PYBOOST_CALL_TEMPLATE
-        self.PYBOOST_SINGLE_OP_HEADER_TEMPLATE = template.Template(
-            '#include "kernel/${device}/pyboost/auto_generate/${operator_name}.h"\n'
-        )
+        if device == "ascend":
+            self.PYBOOST_SINGLE_OP_HEADER_TEMPLATE = template.Template(
+                '#include "kernel/ascend/aclnn/pyboost_impl/auto_generate/${operator_name}.h"\n'
+            )
+        else:
+            self.PYBOOST_SINGLE_OP_HEADER_TEMPLATE = template.Template(
+                '#include "kernel/${device}/pyboost/auto_generate/${operator_name}.h"\n'
+            )
 
         self.PYBOOST_SINGLE_OP_SOURCE_TEMPLATE = PYBOOST_SINGLE_OP_SOURCE_TEMPLATE
         self.gen_path = gen_path
@@ -581,6 +617,8 @@ class AclnnOpCppCodeGenerator:
             else:
                 call_args_with_type = op_parser.parse_call_args_with_types()
             inplace_process = _generate_inplace_process_cpp_code(op_proto)
+            inplace_indices = get_inplace_indices(op_proto)
+            inplace_indices_str = ', '.join(str(i) for i in inplace_indices)
             call_impl = self.PYBOOST_CALL_TEMPLATE.replace(aclnn_name=aclnn_name,
                                                            call_args=call_args,
                                                            call_tensors=call_args_tensor,
@@ -597,6 +635,7 @@ class AclnnOpCppCodeGenerator:
                                                            return_values=call_func_outputs,
                                                            outputs=real_output,
                                                            inplace_process=inplace_process,
+                                                           inplace_indices=inplace_indices_str,
                                                            cast_input_code=cast_input_code,
                                                            real_call_args_tensor=real_call_args_tensor,
                                                            class_name=op_proto.op_class.name,
@@ -636,11 +675,11 @@ class AclnnOpCppCodeGenerator:
             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'
+                              f'select_kernel.input_type()[{i}].dtype, device::DeviceType::kCPU);\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'
+                              f'select_kernel.input_type()[{i}].dtype, device::DeviceType::kCPU);\n'
                 real_call_args_tensor[i] = "PyBoostUtils::ConvertTensorVectorToTuple(real_" + real_call_args_tensor[
                     i] + ")"
         if cast_input != "":
@@ -710,9 +749,9 @@ class InternalOpCppCodeGenerator:
         self.internal_single_op_source_template = template.PYBOOST_INTERNAL_SINGLE_OP_SOURCE_TEMPLATE
         self.internal_single_op_customize_source_template = template.PYBOOST_INTERNAL_SINGLE_OP_CUSTOMIZE_TEMPLATE
         self.customize_inc_template = Template(
-            '#include "{ms_ops_kernel_path}/ascend/pyboost/internal/customize/${operator_name}.h"\n'
+            '#include "${ms_ops_kernel_path}/ascend/aclnn/pyboost_impl/internal/customize/${operator_name}.h"\n'
         )
-        self.gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/internal/auto_generate/"
+        self.gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/internal/auto_generate/"
 
     def generate_internal_op_cpp_code(self, work_path, op_protos):
         """
@@ -819,13 +858,13 @@ class InternalOpCppCodeGenerator:
             return_type=cpp_func_return)
         save_path = os.path.join(work_path, self.gen_path)
         save_file(save_path, f"{op_proto.op_name}.h", internal_op_header_str)
-        self.customize_inc_template.replace(
+        customize_inc_str = self.customize_inc_template.replace(
             ms_ops_kernel_path=K.MS_OPS_KERNEL_PATH,
             operator_name=op_proto.op_name)
         merge_op_header.append(
             self.internal_single_op_header_template.replace(
                 operator_name=op_proto.op_name,
-                customize_inc=self.customize_inc_template))
+                customize_inc=customize_inc_str))
 
         # generate op function
         _, call_func_outputs = op_parser.generate_pyboost_outputs()
@@ -890,10 +929,10 @@ class PyboostOpFunctionGenerator(BaseGenerator):
         self.PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = template.PYBOOST_ASCEND_OP_SOURCE_TEMPLATE
         self.PYBOOST_CPU_OP_SOURCE_TEMPLATE = template.PYBOOST_CPU_OP_SOURCE_TEMPLATE
         self.PYBOOST_GPU_OP_SOURCE_TEMPLATE = template.PYBOOST_GPU_OP_SOURCE_TEMPLATE
-        self.ascend_gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/auto_generate/"
+        self.ascend_gen_path = f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
         self.cpu_gen_path = f"{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/auto_generate/"
         self.gpu_gen_path = f"{K.MS_OPS_KERNEL_PATH}/gpu/pyboost/auto_generate/"
-        self.hccl_gen_path = "mindspore/ccsrc/plugin/device/ascend/kernel/hccl/pyboost/auto_generate/"
+        self.hccl_gen_path = "mindspore/ops/kernel/ascend/hccl/pyboost/auto_generate/"
 
     def generate(self, work_path, op_protos):
         """
@@ -1009,6 +1048,7 @@ class PyboostOpFunctionGenerator(BaseGenerator):
             ops_inc_head_set = set()
             for op_name_inc in op_inc_list[i]:
                 ops_inc_head_set.add(template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_name_inc[0].lower()))
+            op_header += '#include "kernel/cpu/pyboost/pyboost_op_plugin_utils.h"\n'
             cpu_pyboost_op_source = self.PYBOOST_CPU_OP_SOURCE_TEMPLATE.replace(
                 merge_op_header=op_header, merge_op_function=op_function, ops_inc=list(sorted(ops_inc_head_set)))
             save_file(os.path.join(work_path, self.cpu_gen_path), f"pyboost_cpu_ops_{i}.cc",
@@ -1150,7 +1190,10 @@ def delete_residual_files(work_path, op_protos):
     for op_proto in op_protos:
         all_operator_name.append(op_proto.op_name)
     devices = ["ascend", "gpu", "cpu"]
-    code_generate_path_list = [f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/auto_generate/" for device in devices]
+    code_generate_path_list = [f"{K.MS_OPS_KERNEL_PATH}/{device}/pyboost/auto_generate/"
+                               if device != "ascend" else
+                               f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/pyboost_impl/auto_generate/"
+                               for device in devices]
     code_generate_path_list.append(
         f"{K.MS_COMMON_PYBOOST_KERNEL_PATH}/auto_generate/")
     for code_generate_path in code_generate_path_list:

mindspore/ops_generate/pyboost/pyboost_overload_functions_cpp_generator.py

@@ -48,7 +48,7 @@ class PyboostOverloadFunctionsGenerator(BaseGenerator):
         self.PYBOOST_MINT_CLASS_DEF = template.PYBOOST_MINT_CLASS_DEF
         self.PYBOOST_OVERLOAD_MINT_CLASS_DEF = template.PYBOOST_OVERLOAD_MINT_CLASS_DEF
         self.TENSOR_FUNC_UT_BODY = template.TENSOR_FUNC_UT_BODY
-        self.TENSOR_FUNC_UT_OVERLOAD_BODY = template.TENSOR_FUNC_UT_OVERLOAD_BODY
+        self.PYBOOST_OVERLOAD_UT_BODY = template.PYBOOST_OVERLOAD_UT_BODY
 
         self.single_case_template = Template(
             'case ${case_id}:\n'
@@ -56,11 +56,11 @@ class PyboostOverloadFunctionsGenerator(BaseGenerator):
             '  break;\n'
         )
         self.device_dispatcher_template = Template(
-            'if (backend == kAscendDevice || backend == kDavinciDevice) {\n'
+            'if (backend == device::DeviceType::kAscend) {\n'
             '  ${ascend_dispatcher}\n'
-            '} else if (backend == kCPUDevice) {\n'
+            '} else if (backend == device::DeviceType::kCPU) {\n'
             '  ${cpu_dispatcher}\n'
-            '} else if (backend == kGPUDevice) {\n'
+            '} else if (backend == device::DeviceType::kGPU) {\n'
             '  ${gpu_dispatcher}\n'
             '} else {\n'
             '  MS_LOG(ERROR) << "Device target is not supported!";\n'
@@ -71,8 +71,8 @@ class PyboostOverloadFunctionsGenerator(BaseGenerator):
             '${arg_handler_processor}\n'
             'MS_LOG(INFO) << "Call Tensor${class_name}";\n'
             'auto res = ${pyboost_base_func_name}_OP(${prim_name}, parse_args.src_types_, ${convert_args});\n'
-            'trace::Capture(parse_args.arg_list_, mindspore::prim::kPrim${class_name}, &res);\n'
-            'return res;\n'
+            'trace::CapturePy(parse_args.arg_list_, mindspore::prim::kPrim${class_name}, &res);\n'
+            'return py::reinterpret_steal<py::object>(res);\n'
         )
         self.callback_python_template = Template(
             'MS_LOG(INFO) << "Callback python method: ${py_method}";\n'
@@ -161,13 +161,14 @@ class PyboostOverloadFunctionsGenerator(BaseGenerator):
             op_args = func_proto.op_proto.op_args
             max_size = len(op_args)
             ut_body = self.TENSOR_FUNC_UT_BODY.replace(py_method=func_proto.py_method)
-            func_call_body_list.append(self.PYBOOST_MINT_CLASS_DEF.replace(
+            func_call_body = self.PYBOOST_MINT_CLASS_DEF.replace(
                 class_name=class_name,
                 func_name=func_name,
                 device_dispatcher=device_dispatcher_str,
                 signatures=signature_str,
                 max_args=max_size,
-                ut_body=ut_body))
+                ut_body=ut_body)
+            func_call_body_list.append(func_call_body)
             cpp_class_name_list.append(class_name)
         return func_call_body_list, cpp_class_name_list
 
@@ -202,7 +203,7 @@ class PyboostOverloadFunctionsGenerator(BaseGenerator):
         signatures_str = self._generate_func_signatures_str(func_protos)
         dispatch_cases = self._get_dispatch_cases(func_protos)
         ut_dispatch_cases = self._get_ut_dispatch_cases(func_protos)
-        ut_overload_body = self.TENSOR_FUNC_UT_OVERLOAD_BODY.replace(ut_dispatch_cases=ut_dispatch_cases)
+        ut_overload_body = self.PYBOOST_OVERLOAD_UT_BODY.replace(ut_dispatch_cases=ut_dispatch_cases)
 
         max_size = 0
         for tensor_proto in func_protos:

mindspore/ops_generate/pyboost/pyboost_utils.py

@@ -78,14 +78,14 @@ def get_convert_type_str(dtype: str, optional, use_basic_type=False):
         'float': 'ToFloat',
         'bool': 'ToBool',
         'number': 'ToScalar',
-        'tuple[int]': 'ToIntList<py::tuple>',
-        'tuple[float]': 'ToFloatList<py::tuple>',
-        'tuple[bool]': 'ToBoolList<py::tuple>',
-        'tuple[tensor]': 'ToTensorList<py::tuple>',
-        'list[int]': 'ToIntList<py::list>',
-        'list[float]': 'ToFloatList<py::list>',
-        'list[bool]': 'ToBoolList<py::list>',
-        'list[tensor]': 'ToTensorList<py::list>',
+        'tuple[int]': 'ToIntList<CPythonTuple>',
+        'tuple[float]': 'ToFloatList<CPythonTuple>',
+        'tuple[bool]': 'ToBoolList<CPythonTuple>',
+        'tuple[tensor]': 'ToTensorList<CPythonTuple>',
+        'list[int]': 'ToIntList<CPythonList>',
+        'list[float]': 'ToFloatList<CPythonList>',
+        'list[bool]': 'ToBoolList<CPythonList>',
+        'list[tensor]': 'ToTensorList<CPythonList>',
         'tensor': 'ToTensor',
         'str': 'ToString',
         'type': 'ToDtype',
@@ -97,14 +97,14 @@ def get_convert_type_str(dtype: str, optional, use_basic_type=False):
         'tensor': 'ToTensorOptional',
         'type': 'ToDtypeOptional',
         'str': 'ToStringOptional',
-        'tuple[int]': 'ToIntListOptional<py::tuple>',
-        'tuple[float]': 'ToFloatListOptional<py::tuple>',
-        'tuple[bool]': 'ToBoolListOptional<py::tuple>',
-        'tuple[tensor]': 'ToTensorListOptional<py::tuple>',
-        'list[int]': 'ToIntListOptional<py::list>',
-        'list[float]': 'ToFloatListOptional<py::list>',
-        'list[bool]': 'ToBoolListOptional<py::list>',
-        'list[tensor]': 'ToTensorListOptional<py::list>',
+        'tuple[int]': 'ToIntListOptional<CPythonTuple>',
+        'tuple[float]': 'ToFloatListOptional<CPythonTuple>',
+        'tuple[bool]': 'ToBoolListOptional<CPythonTuple>',
+        'tuple[tensor]': 'ToTensorListOptional<CPythonTuple>',
+        'list[int]': 'ToIntListOptional<CPythonList>',
+        'list[float]': 'ToFloatListOptional<CPythonList>',
+        'list[bool]': 'ToBoolListOptional<CPythonList>',
+        'list[tensor]': 'ToTensorListOptional<CPythonList>',
     }
     basic_optional_type_convert = {
         'tuple[int]': "ToBasicIntVectorOptional",
@@ -385,6 +385,17 @@ def get_input_dtype(dtype: str, optional, use_basic_type=False):
     raise TypeError(f"""Unsupported convert type {dtype} for args.""")
 
 
+def get_output_dtype(dtype: str):
+    type_convert = {
+        'tensor': "mindspore::tensor::TensorPtr",
+        'tuple[tensor]': "std::vector<mindspore::tensor::TensorPtr>",
+        'list[tensor]': "std::vector<mindspore::tensor::TensorPtr>",
+    }
+    if dtype in type_convert:
+        return type_convert[dtype]
+    raise TypeError(f"""Unsupported convert type {dtype} for args.""")
+
+
 def is_cube(class_name):
     cube_set = {'Bmm', 'Baddbmm', 'MatMulExt', 'Mv'}
     if class_name in cube_set:

mindspore/ops_generate/resources/yaml_loader.py

@@ -29,6 +29,7 @@ class YamlLoader(ResourceLoader):
     """
     YamlLoader is a utility class for loading yaml files.
     """
+
     def __init__(self, resouce_type: ResourceType, yaml_path: Union[Sequence[str], str]):
         """
         Initialize YamlLoader.
@@ -65,15 +66,26 @@ class OpDocYamlLoader(YamlLoader):
     """
     OpDocYamlLoader is a class for loading op primitive doc yaml files.
     """
+
     def __init__(self):
         op_doc_yaml_path = os.path.join(K.WORK_DIR, K.MS_OP_DEF_YAML_PATH, "doc")
         super().__init__(ResourceType.OP_DOC_YAML, op_doc_yaml_path)
 
 
+class CustomOpDocYamlLoader(YamlLoader):
+    """
+    CustomOpDocYamlLoader is a class for loading op primitive doc yaml files.
+    """
+
+    def __init__(self, doc_yaml_path):
+        super().__init__(ResourceType.OP_DOC_YAML, doc_yaml_path)
+
+
 class TensorMethodDocYamlLoader(YamlLoader):
     """
     TensorMethodDocYamlLoader is a class for loading tensor method doc yaml files.
     """
+
     def __init__(self):
         tensor_method_doc_yaml_path = os.path.join(K.WORK_DIR, K.MS_TENSOR_METHOD_DOC_YAML_PATH)
         super().__init__(ResourceType.TENSOR_METHOD_DOC_YAML, tensor_method_doc_yaml_path)
@@ -83,6 +95,7 @@ class MintFuncDocYamlLoader(YamlLoader):
     """
     MintFuncDocYamlLoader is a class for loading mint func doc yaml files.
     """
+
     def __init__(self):
         mint_func_doc_yaml_path = os.path.join(K.WORK_DIR, K.MS_MINT_FUNC_DOC_YAML_PATH)
         super().__init__(ResourceType.MINT_FUNC_DOC_YAML, mint_func_doc_yaml_path)