mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

mindspore/ops_generate/api/functions_cc_generator.py

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

mindspore/ops_generate/api/gen_api.py

@@ -0,0 +1,103 @@
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""
+Generate api definition files
+"""
+import copy
+
+from resources.resource_list import ResourceType
+from common import gen_constants as K
+from tensor_py_cc_generator import TensorPyCppGenerator
+
+from .tensor_func_reg_cpp_generator import TensorFuncRegCppGenerator
+from .functional_map_cpp_generator import FunctionalMapCppGenerator
+from .add_tensor_docs_generator import AddTensorDocsGenerator
+from .functional_overload_py_generator import FunctionalOverloadPyGenerator
+from .cpp_create_prim_instance_helper_generator import CppCreatePrimInstanceHelperGenerator
+
+
+def gen_tensor_func_code(work_path, op_protos, func_protos, alias_api_mapping):
+    generator = TensorFuncRegCppGenerator()
+    generator.generate(work_path, op_protos, func_protos, alias_api_mapping)
+
+
+def gen_functional_map_code(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping):
+    generator = FunctionalMapCppGenerator()
+    generator.generate(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping)
+
+
+def gen_tensor_docs_code():
+    generator = AddTensorDocsGenerator()
+    generator.generate()
+
+
+def gen_functional_overload_py(work_path, mint_func_protos, alias_api_mapping):
+    generator = FunctionalOverloadPyGenerator()
+    generator.generate(work_path, mint_func_protos, alias_api_mapping)
+
+
+def gen_tensor_py_cc(work_path, tensor_method_protos, alias_api_mapping):
+    generator = TensorPyCppGenerator()
+    generator.generate(work_path, tensor_method_protos, alias_api_mapping)
+
+
+def generate_create_instance_helper_file(resource_mgr):
+    """
+    Generate C++ helper file from yaml.
+    """
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    tensor_method_protos = resource_mgr.get_resource(ResourceType.TENSOR_METHOD_PROTOS)
+    op_protos_with_deprecated = get_tensor_op_protos_with_deprecated(tensor_method_protos, op_protos)
+    generator = CppCreatePrimInstanceHelperGenerator()
+    generator.generate(K.WORK_DIR, op_protos_with_deprecated)
+
+
+def get_tensor_op_protos_with_deprecated(func_protos, op_protos):
+    """
+    Get op_protos with deprecated op_protos from func_protos.
+    """
+    tensor_op_protos = copy.deepcopy(op_protos)
+    for _, item in func_protos.items():
+        for func_proto in item:
+            op_name = func_proto.op_proto.op_name
+            if "deprecated" in func_proto.op_proto.op_name:
+                func_proto.op_proto.op_class.name = ''.join(word.capitalize() for word in op_name.split('_'))
+                if func_proto.op_proto.op_name[-1] == '_':
+                    func_proto.op_proto.op_class.name += '_'
+                tensor_op_protos.append(func_proto.op_proto)
+    return tensor_op_protos
+
+
+def generate_api_files(resource_mgr):
+    """
+    Generate api-related files.
+    """
+    work_path = K.WORK_DIR
+    op_protos = resource_mgr.get_resource(ResourceType.OP_PROTO)
+    tensor_method_protos = resource_mgr.get_resource(ResourceType.TENSOR_METHOD_PROTOS)
+    mint_func_protos = resource_mgr.get_resource(ResourceType.MINT_FUNC_PROTOS)
+    alias_api_mapping = resource_mgr.get_resource(ResourceType.ALIAS_API_MAPPING)
+    # generate create prim instance helper file
+    generate_create_instance_helper_file(resource_mgr)
+    # generate tensor_py func code
+    gen_tensor_func_code(work_path, op_protos, tensor_method_protos, alias_api_mapping)
+    # generate functional map code
+    gen_functional_map_code(work_path, tensor_method_protos, mint_func_protos, alias_api_mapping)
+    # generate _tensor_docs.py that attaches docs to tensor func APIs when import mindspore
+    gen_tensor_docs_code()
+    # generate functional_overload.py which init pybind mint APIs from cpp
+    gen_functional_overload_py(work_path, mint_func_protos, alias_api_mapping)
+    # generate tensor_py.cc
+    gen_tensor_py_cc(work_path, tensor_method_protos, alias_api_mapping)

mindspore/ops_generate/api/op_api_proto.py

@@ -0,0 +1,235 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Tensor Func Proto module for defining tensor_py function prototypes and their arguments."""
+import ast
+import os
+from collections import defaultdict
+
+import common.gen_constants as K
+from common.gen_utils import safe_load_yaml_from_dir
+from resources.resource_loader import ResourceLoader
+from resources.resource_list import ResourceType
+
+
+class OpApiProto:
+    """
+    Represents a tensor function prototype with associated function name, operation prototype, and target devices.
+    """
+
+    def __init__(self,
+                 func_name,
+                 op_proto,
+                 py_method,
+                 kw_only_args,
+                 varargs,
+                 ascend,
+                 gpu,
+                 cpu):
+        self.func_name = func_name
+        self.op_proto = op_proto
+        self.py_method = py_method
+        self.kw_only_args = kw_only_args
+        self.varargs = varargs
+        self.ascend = ascend
+        self.gpu = gpu
+        self.cpu = cpu
+
+
+def get_tensor_method_ast_dict():
+    """
+        Generates a dictionary mapping function names to their Abstract Syntax Tree (AST) nodes
+        for all functions defined in the 'tensor_method.py' file.
+    """
+    tensor_method_ast_dict = dict()
+    tensor_method_file = os.path.join(
+        K.WORK_DIR, K.PY_MS_DIR, 'ops/tensor_method.py')
+    with open(tensor_method_file, "r", encoding="utf-8") as file:
+        tree = ast.parse(file.read(), filename=tensor_method_file)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            tensor_method_ast_dict[node.name] = node
+    return tensor_method_ast_dict
+
+
+class OpApiProtoLoader(ResourceLoader):
+    """
+    Loads api related proto data.
+    """
+    def __init__(self, op_protos, deprecated_op_protos, func_op_protos):
+        self.op_api_data = safe_load_yaml_from_dir(os.path.join(K.WORK_DIR, K.MS_OP_API_YAML_PATH))
+        self.op_protos = op_protos + func_op_protos
+        self.deprecated_op_protos = deprecated_op_protos
+
+    def load(self):
+        """
+        Loads tensor function prototypes from YAML data and returns them as a dictionary.
+        """
+        op_protos_dict = {}
+        for op_proto in self.op_protos:
+            op_protos_dict[op_proto.op_name] = op_proto
+        for deprecated_op_proto in self.deprecated_op_protos:
+            op_protos_dict[deprecated_op_proto.op_name] = deprecated_op_proto
+        tensor_method_protos = defaultdict(list)
+        mint_func_protos = defaultdict(list)
+        alias_api_mapping = defaultdict(list)
+        tensor_method_def_ast_dict = get_tensor_method_ast_dict()
+        for func_name, tensor_func_data in self.op_api_data.items():
+            func_data_list = [tensor_func_data] if isinstance(
+                tensor_func_data, dict) else tensor_func_data
+            for func_data in func_data_list:
+                func_keys = func_data.keys()
+                check_op_api_yaml_keys(func_name, set(
+                    func_keys), K.TENSOR_FUNC_KEYS)
+                if 'alias' in func_data:
+                    alias_api_mapping[func_data['alias']].append(func_name)
+                    continue
+                op_name = _get_op_name_from_op_yaml(func_name, func_data)
+                op_proto = op_protos_dict.get(op_name, None)
+                if op_proto is None:
+                    raise TypeError(
+                        f"For generating tensor functions, op_proto should not be empty. Func name is {func_name}")
+                py_method = func_data.get('py_method', '')
+                if py_method == '':
+                    raise TypeError(
+                        f'For generating tensor functions, py method should not be empty. Func name is {func_name}')
+                if py_method not in tensor_method_def_ast_dict:
+                    raise TypeError(
+                        f"{py_method} is not defined in tensor_method.py.")
+                kw_only_args = func_data.get('kwonlyargs', None)
+                if kw_only_args:
+                    kw_only_args = [item.strip()
+                                    for item in kw_only_args.split(',')]
+                    check_kwonlyargs(func_data, kw_only_args, op_name,
+                                     op_proto, py_method, tensor_method_def_ast_dict)
+                varargs = func_data.get('varargs', None)
+                if varargs:
+                    varargs = [item.strip() for item in varargs.split(',')]
+                    check_varargs(varargs, op_name)
+                ascend = func_data.get('Ascend', 'aclnn')
+                gpu = func_data.get('GPU', 'aclnn')
+                cpu = func_data.get('CPU', 'aclnn')
+                interface = func_data.get('interface')
+                if interface is None:
+                    raise ValueError(
+                        f"For generating tensor or functional interfaces, field interface must exist. "
+                        f"Op name is {func_name}")
+
+                interface = ', '.join(part.strip()
+                                      for part in interface.split(','))
+
+                if interface not in {'tensor', 'function', 'tensor, function', 'function, tensor'}:
+                    raise ValueError(
+                        f"The value of field 'interface' must be one of 'tensor', 'function', "
+                        f"'tensor, function', or 'function, tensor'. File name is {func_name}.yaml"
+                    )
+
+                proto = OpApiProto(func_name=func_name, op_proto=op_proto, py_method=py_method,
+                                   kw_only_args=kw_only_args, varargs=varargs, ascend=ascend, gpu=gpu, cpu=cpu)
+
+                if 'tensor' in interface:
+                    tensor_method_protos[func_name].append(proto)
+                if 'function' in interface:
+                    mint_func_protos[func_name].append(proto)
+
+        return {ResourceType.TENSOR_METHOD_PROTOS: tensor_method_protos,
+                ResourceType.MINT_FUNC_PROTOS: mint_func_protos,
+                ResourceType.ALIAS_API_MAPPING: alias_api_mapping}
+
+
+
+
+def check_kwonlyargs(func_data, kw_only_args, op_name, op_proto, py_method, tensor_method_def_ast_dict):
+    """
+    Verifies that the keyword-only arguments (kwonlyargs) specified in the YAML definition
+    match the order and names of the keyword-only arguments in the Python method definition.
+    """
+    op_args = op_proto.op_args
+    kw_args_start_idx = len(op_args) - len(kw_only_args)
+    node = tensor_method_def_ast_dict[py_method]
+    tensor_method_kwonlyargs = [arg.arg for arg in node.args.kwonlyargs]
+    for idx, kw_arg in enumerate(kw_only_args):
+        kw_args_idx = kw_args_start_idx + idx
+        if kw_args_idx > len(op_args) or kw_arg != op_args[kw_args_idx].arg_name:
+            op_kw_args = [op_arg.arg_name for op_arg in op_args]
+            op_yaml = func_data.get('op_yaml')
+            raise TypeError(
+                f"For generating tensor functions from {op_name}.yaml, "
+                f"the order of kwonlyargs should be consistent with the definition in the {op_yaml}. "
+                f"Expect kwonlyarg: {op_kw_args[kw_args_start_idx:]}, current kwonlyarg: {kw_only_args}.")
+    if tensor_method_kwonlyargs != kw_only_args:
+        raise TypeError(f"The order of kwonlyargs in {py_method} should be consistent with the definition. "
+                        f"Expect kwonlyarg: {kw_only_args}, current kwonlyarg: {tensor_method_kwonlyargs}.")
+
+
+def check_varargs(varargs, op_name):
+    if len(varargs) != 1:
+        raise ValueError(
+            f'There must be only one variable argument. But got {len(varargs)} in {op_name}')
+
+
+def _get_op_name_from_op_yaml(func_name: str, func_data: dict) -> str:
+    """Extracts the operation name from the given YAML function data."""
+    op_yaml = func_data.get('op_yaml', '')
+    if op_yaml == '':
+        raise TypeError(
+            f'For generating tensor functions, op yaml should not be empty, func name is {func_name}')
+    if 'deprecated' in op_yaml:
+        op_name = op_yaml.replace('/', '_').replace('_method.yaml', '')
+    else:
+        op_name = op_yaml.replace('_op.yaml', '')
+    if op_name == '':
+        raise TypeError(
+            f'For generating tensor functions, op name should not be empty, func name is {func_name}')
+    return op_name
+
+
+def check_op_api_yaml_keys(func_name: str, input_keys: set, compare_keys: set):
+    diff_keys = input_keys - compare_keys
+    if diff_keys:
+        raise TypeError(
+            f'The definition of keys in yaml has faults, func name is {func_name}, wrong keys are {diff_keys}.')
+
+
+def categorize_func_data(func_protos_data):
+    """
+    Categorizes function prototypes into single, overloaded function prototypes.
+
+    Args:
+        func_protos_data (dict): Dictionary where keys are function API names and values are lists of
+                                 function prototypes associated with each API.
+
+    Returns:
+        tuple:
+            - single_op_func_data (dict): Function prototypes for operations with a single definition.
+            - overload_op_func_data (dict): Function prototypes for operations with overloaded definitions.
+    """
+    single_op_func_data = {}
+    overload_op_func_data = {}
+    all_op_func_data = {}
+    op_class_name_set = set()
+    for func_api_name, func_protos in func_protos_data.items():
+        if len(func_protos) == 1:
+            func_name = func_protos[0].func_name
+            if func_name not in single_op_func_data:
+                single_op_func_data[func_name] = func_protos[0]
+                all_op_func_data[func_name] = func_protos
+        elif len(func_protos) > 1:
+            overload_op_func_data[func_api_name] = func_protos
+            all_op_func_data[func_api_name] = func_protos
+        for func_proto in func_protos:
+            op_class_name_set.add(func_proto.op_proto.op_class.name)
+
+    return all_op_func_data, single_op_func_data, overload_op_func_data, op_class_name_set