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

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.