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

mindspore/ops_generate/aclnn/aclnn_kernel_register_auto_cc_generator.py

@@ -30,7 +30,7 @@ from resources.resource_list import ResourceType
 
 
 ACLNN_REG_CODE = """
-#include "$ops_gen_kernel_path/ascend/opapi/aclnn_kernel_mod.h"
+#include "$ops_gen_kernel_path/ascend/aclnn/kernel_mod_impl/aclnn_kernel_mod.h"
 
 namespace mindspore {
 namespace kernel {
@@ -88,14 +88,14 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
         res_str = template.CC_LICENSE_STR + reg_code
 
         save_path = os.path.join(
-            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/opapi/auto_generate")
+            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/auto_generate")
         file_name = "aclnn_kernel_register_auto.cc"
         gen_utils.save_file(save_path, file_name, res_str)
 
 
-def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/'):
     '''get registered ops by search files'''
-    # default search in 'ops/kernel/ascend/opapi/'
+    # default search in 'ops/kernel/ascend/aclnn/kernel_mod_impl/'
     search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
@@ -117,7 +117,7 @@ def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 registed_ops = get_registed_ops()
 manual_registed_ops = get_registed_ops(
-    f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+    f'{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/')
 
 
 def check_op_registed(op_name, manual=False):

mindspore/ops_generate/aclnn/gen_aclnn_implement.py

@@ -118,7 +118,7 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
         logging.warning("Kernel {%s} is already registered.", op_name)
         return
 
-    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
+    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/'
     # merge inner ops
     dispatch = op_proto.op_dispatch
     aclnn_name = ''.join(word.capitalize() for word in op_name.split('_'))
@@ -130,7 +130,7 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
     if auto:
         auto_gen = "_auto_gen"
         kernelmod_name = aclnn_name + "Ascend"
-        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_auto_gen/'
+        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_auto_gen/'
         pathlib.Path(os.path.join(K.WORK_DIR, aclnn_path)
                      ).mkdir(parents=True, exist_ok=True)
     if dispatch.ascend is None:
@@ -145,9 +145,9 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
              kernelmod_h_and_cc_path, need_update_shape)
 
 
-def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/'):
     '''get registered ops by search files'''
-    # default search in 'ops/kernel/ascend/opapi/'
+    # default search in 'ops/kernel/ascend/aclnn/kernel_mod_impl/'
     search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
@@ -167,7 +167,7 @@ def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 registed_ops = get_registed_ops()
 manual_registed_ops = get_registed_ops(
-    f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+    f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/')
 
 
 def check_op_registed(op_name, manual=False):
@@ -182,7 +182,7 @@ def generate_aclnn_reg_code(yaml_data):
     yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
 
     reg_code = f"""
-#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_kernel_mod.h"
 
 namespace mindspore {{
 namespace kernel {{
@@ -224,9 +224,9 @@ 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'
+        f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/tmp_aclnn_kernel_register.cc'
     register_file = work_path + \
-        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
+        f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_kernel_register_auto.cc'
     reg_code = generate_aclnn_reg_code(yaml_str)
     gen_utils.save_file(
         os.path.dirname(tmp_register_file), os.path.basename(tmp_register_file), gen_utils.cc_license_str + reg_code)

mindspore/ops_generate/api/functions_cc_generator.py

@@ -23,6 +23,7 @@ from common.template import Template
 import common.gen_constants as K
 from common.gen_utils import save_file
 from common.base_generator import BaseGenerator
+from pyboost.op_template_parser import OpTemplateParser
 from pyboost.pyboost_utils import is_optional_param, get_input_dtype, get_return_type
 
 
@@ -39,7 +40,7 @@ class FunctionsHeaderGenerator(BaseGenerator):
         self.function_interface_template = Template("${return_type} BACKEND_EXPORT ${op_name}(${input_args});")
         self.function_interface_template_comm = Template(
             "${return_type} BACKEND_EXPORT ${op_name}_inner(${input_args}," \
-            "CommHandlePtr comm_handle, const std::string& target);"
+            "CommHandlePtr comm_handle, device::DeviceType target);"
         )
         self.function_interface_template_comm_return_handle = Template(
             "${return_type_with_handle} BACKEND_EXPORT ${op_name}(${input_args});"
@@ -112,10 +113,15 @@ class FunctionsGenerator(BaseGenerator):
         """
         self.FUNCTIONS_CC_TEMPLATE = template.FUNCTIONS_CC_TEMPLATE
         self.FUNCTION_BODY_TEMPLATE = template.FUNCTION_BODY_TEMPLATE
+        self.FUNCTION_VIEW_BODY_TEMPLATE = template.FUNCTION_VIEW_BODY_TEMPLATE
+        self.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE = template.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE
         self.FUNCTION_COMM_BODY_TEMPLATE = template.FUNCTION_COMM_BODY_TEMPLATE
         self.pyboost_func_include_header_template = Template(
             f'#include "{K.MS_PYBOOST_BASE_PATH}/auto_generate/${{operator_name}}.h"\n'
         )
+        self.pyboost_view_func_include_header_template = Template(
+            f'#include "{K.MS_OPS_VIEW_PATH}/${{operator_name}}_strides_calc.h"\n'
+        )
         self.clone_inplace_input_template = Template(
             'GetCloneFunc()(op, prim::kPrim${class_name}, device_target, {${grad_args}});'
         )
@@ -140,9 +146,14 @@ class FunctionsGenerator(BaseGenerator):
         for op_proto in op_protos:
             if op_proto.op_dispatch is None:
                 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))
+            if op_proto.op_view:
+                function_body, pyboost_func_include_header = self._get_function_view_body(op_proto)
+            else:
+                pyboost_func_include_header = self.pyboost_func_include_header_template.\
+                    replace(operator_name=op_proto.op_name)
+                function_body = self._get_function_body(op_proto)
+            func_include_headers_list.append(pyboost_func_include_header)
+            op_call_with_grad_list.append(function_body)
             ops_inc_head_set.add(
                 template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
         pyboost_func_h_str = self.FUNCTIONS_CC_TEMPLATE.replace(op_call_with_grad=op_call_with_grad_list,
@@ -152,6 +163,44 @@ class FunctionsGenerator(BaseGenerator):
         file_name = "functions.cc"
         save_file(save_path, file_name, pyboost_func_h_str)
 
+    def _get_function_view_body(self, op_proto):
+        """
+        Get the function body for a given view operator prototype.
+
+        Args:
+            op_proto: The operator prototype.
+
+        Returns:
+            str: The generated function body.
+        """
+        function_body_template = self.FUNCTION_VIEW_BODY_TEMPLATE
+        pyboost_func_include_header = self.pyboost_view_func_include_header_template.\
+            replace(operator_name=op_proto.op_name)
+        if not op_proto.bprop_expander or op_proto.op_name in ["reshape"]:
+            function_body_template = self.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE
+            pyboost_func_include_header = ""
+        op_parser = OpTemplateParser(op_proto)
+        input_args = self._get_input_args(op_proto, False)
+        input_args_with_type = self._get_input_args(op_proto, True)
+        call_args_with_type = op_parser.parse_call_args_with_types(True)
+        call_args = OpTemplateParser.parse_original_call_args(op_proto.op_args)
+        call_args_tensors = op_parser.get_call_args_tensor()
+        storage_calc_str = op_proto.op_class.name
+        return_values, _ = op_parser.generate_pyboost_outputs()
+        return_type_str = _get_return_type_str(op_proto)
+        function_body = function_body_template.replace(op_name=op_proto.op_name,
+                                                       class_name=op_proto.op_class.name,
+                                                       input_args_with_type=input_args_with_type,
+                                                       input_args=input_args,
+                                                       storage_calc=storage_calc_str,
+                                                       call_args_with_type=call_args_with_type,
+                                                       call_args=call_args,
+                                                       call_tensors=call_args_tensors,
+                                                       input=call_args[0],
+                                                       return_values=return_values,
+                                                       return_type=return_type_str)
+        return function_body, pyboost_func_include_header
+
     def _get_function_body(self, op_proto):
         """
         Get the function body for a given operator prototype.

mindspore/ops_generate/api/tensor_func_reg_cpp_generator.py

@@ -65,15 +65,15 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             '  ${device_dispatcher}\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'
-            '  return py::none();\n'
+            '  Py_RETURN_NONE;\n'
             '}'
         )
         self.pyboost_return_template = Template(
@@ -81,24 +81,32 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             'MS_LOG(INFO) << "Call Tensor${class_name}";\n'
             'auto res = mindspore::pynative::'
             '${pyboost_function}(mindspore::prim::kPrim${class_name}, parse_args.src_types_, ${convert_args});\n'
-            'trace::Capture(parse_args.arg_list_, mindspore::prim::kPrim${class_name}, &res);\n'
+            'trace::CapturePy(parse_args.arg_list_, mindspore::prim::kPrim${class_name}, &res);\n'
             'return res;\n'
         )
         self.callback_python_template = Template(
+            'py::object self_new = py::reinterpret_borrow<py::object>(self);\n'
+            'py::args py_args_new = py::reinterpret_borrow<py::args>(py_args);\n'
+            'py::dict empty_dict = py::dict();\n'
+            'py::kwargs py_kwargs_new = py::kwargs(empty_dict);\n'
+            'if (py_kwargs != NULL && py_kwargs != Py_None) {\n'
+            '  py_kwargs_new = py::reinterpret_borrow<py::kwargs>(py_kwargs);\n'
+            '}\n'
             'MS_LOG(INFO) << "Callback python method: ${py_method}";\n'
             'py::function fn = python_adapter::GetPyFn(\"mindspore.ops.tensor_method\", \"${py_method}\");\n'
-            'py::object res = fn(self, *py_args, **py_kwargs);\n'
-            'return res;\n'
+            'py::object res = fn(self_new, *py_args_new, **py_kwargs_new);\n'
+            'MS_LOG(INFO) << "after Callback python method: ${py_method}";\n'
+            'return res.release().ptr();\n'
         )
         self.callback_python_in_ut_template = Template(
             'MS_LOG(INFO) << "Callback python method in UT: ${py_method}";\n'
             'fn = python_adapter::GetPyFn(\"mindspore.ops.tensor_method\", \"${py_method}\");\n'
-            'res = fn(self, *py_args, **py_kwargs);\n'
+            'res = fn(self_new, *py_args_new, **py_kwargs_new);\n'
             'break;\n'
         )
         self.header_func_header_template = Template(
-            "py::object TensorMethod${cpp_func_name}"
-            "(const py::object &self, const py::args &py_args, const py::kwargs &py_kwargs);\n"
+            "PyObject* TensorMethod${cpp_func_name}"
+            "(PyObject* self, PyObject* py_args, PyObject* py_kwargs);\n"
         )
 
     def generate(self, work_path, op_protos, func_protos_data, alias_func_mapping):
@@ -303,15 +311,21 @@ class TensorFuncRegCppGenerator(BaseGenerator):
 
         max_size = 0
         self_index = 0
+        mark_side_effect_str = "pynative::PyNativeAlgo::PyBoost::MarkSideEffect(self);"
+        has_side_effect = False
         for tensor_proto in func_protos:
             op_proto = tensor_proto.op_proto
             op_args = op_proto.op_args
             max_size = max(len(op_args), max_size)
             self_index = self._get_input_tensor_index(tensor_proto)
+            if op_proto.op_view or op_proto.op_inplace:
+                has_side_effect = True
         cpp_func_name = pyboost_utils.format_func_api_name(func_api_name)
+        mark_side_effect = mark_side_effect_str if has_side_effect else ""
         overload_func_call_str = self.TENSOR_FUNC_OVERLOAD_CALL_BODY.replace(cpp_func_name=cpp_func_name,
                                                                              func_name=func_api_name,
                                                                              signatures=signatures_str,
+                                                                             mark_side_effect=mark_side_effect,
                                                                              dispatch_cases=dispatch_cases,
                                                                              max_args=max_size,
                                                                              self_index=self_index,
@@ -383,7 +397,7 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             dispatch_cases_str += self.single_case_template.replace(case_id=idx,
                                                                     device_dispatcher=device_dispatcher_str)
         dispatch_cases_str += 'default:\n'
-        dispatch_cases_str += '  return py::none();'
+        dispatch_cases_str += '  Py_RETURN_NONE;'
         return dispatch_cases_str
 
     def _get_ut_dispatch_cases(self, func_protos):

mindspore/ops_generate/common/gen_constants.py

@@ -42,16 +42,16 @@ MS_OP_API_YAML_PATH = "mindspore/ops/api_def"
 MS_TENSOR_METHOD_DOC_YAML_PATH = "mindspore/ops/api_def/method_doc"
 MS_MINT_FUNC_DOC_YAML_PATH = "mindspore/ops/api_def/function_doc"
 MS_MINT_FUNC_OVERLOAD_PATH = "mindspore/python/mindspore/ops"
-PYBOOST_NATIVE_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/grad/function/auto_generate"
-PYBOOST_AUTO_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
-PIPELINE_PYBOOST_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
+PYBOOST_NATIVE_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/backward/op_grad/auto_generate"
+PYBOOST_AUTO_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/forward/pyboost/auto_generate"
+PIPELINE_PYBOOST_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/forward/pyboost/auto_generate"
 FUNCTIONAL_OVERLOAD_GEN_PATH = "mindspore/ccsrc/frontend/operator/composite/auto_generate"
 PYBOOST_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pyboost/grad_functions/auto_generate"
-TENSOR_FUNC_REGISTER_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
-TENSOR_API_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_api/auto_generate"
+TENSOR_FUNC_REGISTER_PATH = "mindspore/ccsrc/pynative/forward/pyboost/auto_generate"
+TENSOR_API_PATH = "mindspore/ccsrc/pybind_api/ir/tensor/tensor_api/auto_generate"
 ADD_TENSOR_DOCS_PY_PATH = "mindspore/python/mindspore/common"
 ADD_MINT_DOCS_PY_PATH = "mindspore/python/mindspore/mint"
-TENSOR_PY_CC_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_register/auto_generate"
+TENSOR_PY_CC_PATH = "mindspore/ccsrc/pybind_api/ir/tensor/tensor_register/auto_generate"
 
 # yaml keys def
 OP_KEYS = {'args', 'args_signature', 'returns', 'function', 'class', 'view', 'graph_view', 'dispatch', 'labels',
@@ -80,6 +80,7 @@ INPUT_NAME_MAP = {"DeprecatedExpandAs": "input"}
 
 # infer
 MS_OPS_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl"
+MS_OPS_COMM_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl/communication"
 
 # view
 MS_OPS_VIEW_PATH = "mindspore/ops/view"
@@ -90,7 +91,7 @@ MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH = "mindspore/ccsrc/pyboost/functions/auto_gen
 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"
+                                                           "ascend/aclnn/pyboost_impl/internal/functions")
+MS_INTERNAL_PYBOOST_GEN_PATH = "mindspore/ops/kernel/ascend/internal/pyboost/auto_gen"
+MS_PLUGIN_INTERNAL_PATH = "mindspore/ops/kernel/ascend/internal"
+MS_OPS_PYBOOST_INTERNAL = "mindspore/ops/kernel/ascend/aclnn/pyboost_impl/internal"

mindspore/ops_generate/common/op_proto.py

@@ -225,10 +225,12 @@ class OpProtoLoader(ResourceLoader):
     """
     OpProtoLoader is a class for loading operator prototypes from YAML data.
     """
+
     def __init__(self):
         ops_yaml_path = os.path.join(K.WORK_DIR, K.MS_OP_DEF_YAML_PATH)
         infer_ops_yaml_path = os.path.join(ops_yaml_path, 'infer')
-        self.yaml_paths = [ops_yaml_path, infer_ops_yaml_path]
+        comm_ops_yaml_path = os.path.join(ops_yaml_path, 'communication')
+        self.yaml_paths = [ops_yaml_path, infer_ops_yaml_path, comm_ops_yaml_path]
         self.type = ResourceType.OP_PROTO
         self.is_deprecated = False
         self.func_op = False
@@ -257,6 +259,7 @@ class DeprecatedOpProtoLoader(OpProtoLoader):
     """
     DeprecatedOpProtoLoader is a class for loading deprecated operator prototypes from YAML data.
     """
+
     def __init__(self):
         super().__init__()
         self.yaml_paths = [os.path.join(K.WORK_DIR, K.MS_OP_DEPRECATED_DEF_YAML_PATH)]
@@ -269,6 +272,7 @@ class FuncOpProtoLoader(OpProtoLoader):
     """
     FuncOpProtoLoader is a class for loading func_op operator prototypes from YAML data.
     """
+
     def __init__(self):
         super().__init__()
         self.yaml_paths = [os.path.join(K.WORK_DIR, K.MS_OP_DEF_FUNC_OP_YAML_PATH)]
@@ -277,6 +281,19 @@ class FuncOpProtoLoader(OpProtoLoader):
         self.func_op = True
 
 
+class CustomOpProtoLoader(OpProtoLoader):
+    """
+    CustomOpProtoLoader is a class for loading custom_op operator prototypes from YAML data.
+    """
+
+    def __init__(self, yaml_dir_path):
+        super().__init__()
+        self.yaml_paths = [yaml_dir_path]
+        self.type = ResourceType.OP_PROTO
+        self.is_deprecated = False
+        self.func_op = False
+
+
 def get_op_args_signature(op_name, op_data):
     """
     Retrieves the argument signature from the operation data.