mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.5.0__cp311-cp311-win_amd64.whl

mindspore/ops_generate/ops_def_cc_generator.py

@@ -0,0 +1,288 @@
+# 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.
+# ============================================================================
+"""
+Module for generating C++ operator definition files.
+"""
+
+import os
+import math
+
+import gen_constants as K
+import gen_utils
+
+# refactored
+from op_proto import OpProto
+import template
+
+from base_generator import BaseGenerator
+
+
+class OpsDefCcGenerator(BaseGenerator):
+    """
+    Generates C++ definition files for operators.
+    """
+
+    def __init__(self):
+        """
+        Initializes templates for generating C++ operator definitions.
+        """
+        self.include_template = template.Template("""#include "${path}/${operator_name}.h\"\n""")
+        self.func_impl_declaration_template = template.Template("${class_name}FuncImpl g${class_name}FuncImpl;")
+        self.empty_func_impl_declaration_template = template.Template("static OpFuncImpl g${class_name}FuncImpl;")
+        self.func_impl_define_template = template.Template("g${class_name}FuncImpl")
+        self.OP_PROTO_TEMPLATE = template.OP_PROTO_TEMPLATE
+        self.CC_OPS_DEF_TEMPLATE = template.Template(K.CC_OPS_DEF)
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates C++ code for operator definitions and saves it to a file.
+
+        Args:
+            work_path (str): The directory to save the generated files.
+            op_protos (list): A list of operator prototypes.
+        """
+        gen_cc_list = list()
+        gen_include_list = list()
+        gen_deprecated_cc_list = list()
+
+        for op_proto in op_protos:
+            operator_name = op_proto.op_name
+            class_name = op_proto.op_class.name
+            if "deprecated" not in operator_name:
+                gen_include_list.append(self.include_template.replace(path=K.MS_OPS_FUNC_IMPL_PATH,
+                                                                      operator_name=operator_name))
+                func_impl_declaration_str = self.func_impl_declaration_template.replace(class_name=class_name)
+            else:
+                func_impl_declaration_str = self.empty_func_impl_declaration_template.replace(class_name=class_name)
+            func_impl_define = self.func_impl_define_template.replace(class_name=class_name)
+
+            # process input
+            args_dict, cc_index_str, input_args_str = process_input_args(op_proto)
+
+            # Process outputs.
+            return_args_str = get_cc_op_def_return(args_dict, op_proto)
+
+
+            inputs_args = self.process_args(op_proto.op_args)
+            signature_code = generate_cc_op_signature(op_proto.op_args_signature, inputs_args)
+            enable_dispatch = "true" if op_proto.op_dispatch and op_proto.op_dispatch.enable else "false"
+            is_view = "true" if op_proto.op_view else "false"
+            is_graph_view = "true" if op_proto.op_graph_view else "false"
+            op_def_cc = self.OP_PROTO_TEMPLATE.replace(class_name=class_name,
+                                                       input_args=input_args_str,
+                                                       return_args=return_args_str,
+                                                       signatures=signature_code,
+                                                       indexes=cc_index_str,
+                                                       enable_dispatch=enable_dispatch,
+                                                       is_view=is_view,
+                                                       is_graph_view=is_graph_view,
+                                                       func_impl_declaration=func_impl_declaration_str,
+                                                       func_impl_define=func_impl_define)
+            if op_proto.op_view:
+                view_op_def = op_def_cc.replace(class_name, class_name + "View")
+                op_def_cc += view_op_def
+
+            if "deprecated" not in operator_name:
+                gen_cc_list.append(op_def_cc)
+            else:
+                gen_deprecated_cc_list.append(op_def_cc)
+
+        op_size = len(gen_include_list)
+        max_op_size_in_one_file = 300
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        for numbering in range(math.ceil(op_size / max_op_size_in_one_file)):
+            gen_include = ''.join(
+                gen_include_list[numbering*max_op_size_in_one_file: (numbering+1)*max_op_size_in_one_file])
+            gen_cc = ''.join(
+                gen_cc_list[numbering*max_op_size_in_one_file: (numbering+1)*max_op_size_in_one_file])
+            cc_ops_def = self.CC_OPS_DEF_TEMPLATE.replace(auto_generate_path=K.MS_OP_DEF_AUTO_GENERATE_PATH,
+                                                          gen_include=gen_include,
+                                                          gen_cc_code=gen_cc)
+
+            file_name = f"gen_ops_def_{chr(ord('a') + numbering)}.cc"
+            ops_def_cc_file_str = template.CC_LICENSE_STR + cc_ops_def
+            gen_utils.save_file(save_path, file_name, ops_def_cc_file_str)
+
+        deprecated_cc_ops_def = self.CC_OPS_DEF_TEMPLATE.replace(auto_generate_path=K.MS_OP_DEF_AUTO_GENERATE_PATH,
+                                                                 gen_include='',
+                                                                 gen_cc_code=''.join(gen_deprecated_cc_list))
+        file_name = "gen_deprecated_ops_def.cc"
+        deprecated_ops_def_cc_file_str = template.CC_LICENSE_STR + deprecated_cc_ops_def
+        gen_utils.save_file(save_path, file_name,
+                            deprecated_ops_def_cc_file_str)
+
+    def process_args(self, op_args):
+        """
+        Processes operator arguments to extract input names.
+
+        Args:
+            op_args (list): A list of operator arguments.
+
+        Returns:
+            list: A list of input argument names.
+        """
+        inputs_name = []
+        for arg in op_args:
+            if not arg.is_prim_init:
+                inputs_name.append(arg.arg_name)
+        return inputs_name
+
+
+def process_input_args(op_proto: OpProto):
+    """
+    Processes input arguments for C++ code generation.
+
+    Args:
+        op_proto (OpProto): The operator prototype.
+
+    Returns:
+        tuple: A tuple containing processed argument data.
+    """
+    cc_index_str = ''
+    input_args_str = ''
+    args_dict = {}
+    op_args = op_proto.op_args
+    for i, op_arg in enumerate(op_args):
+        arg_name = op_arg.arg_name
+        args_dict[arg_name] = i
+        cc_index_str += f"""{{"{arg_name}", {i}}},\n"""
+        dtype = op_arg.arg_dtype
+        cc_dtype_str = gen_utils.convert_dtype_str(dtype)
+
+        is_prim_init = 1 if op_arg.is_prim_init else 0
+        arg_handler_str = op_arg.arg_handler
+
+        type_cast = op_arg.type_cast
+        type_cast_str = "" if type_cast is None else \
+            ", ".join('DT_' + type.replace('[', '_').replace(']', '').upper() for type in type_cast)
+
+        # default: None is regarded as an optional argument.
+        is_optional_str = "true" if op_arg.default == "None" else "false"
+
+        input_args_str += f"""\n    {{/*.arg_name_=*/"{arg_name}", /*.arg_dtype_=*/{cc_dtype_str}, """ + \
+                          f"""/*.as_init_arg_=*/{is_prim_init}, /*.arg_handler_=*/"{arg_handler_str}", """ + \
+                          f"""/*.cast_dtype_ =*/{{{type_cast_str}}}, /*.is_optional_=*/{is_optional_str}}},"""
+    return args_dict, cc_index_str, input_args_str
+
+
+def get_cc_op_def_return(args_dict, op_proto: OpProto):
+    """
+    Generates return argument strings for C++ operator definition.
+
+    Args:
+        args_dict (dict): A dictionary mapping argument names to indexes.
+        op_proto (OpProto): The operator prototype.
+
+    Returns:
+        str: A string containing return argument data.
+    """
+    return_args_str = ''
+    returns = op_proto.op_returns
+    for return_item in returns:
+        return_name = return_item.arg_name
+        return_dtype = return_item.arg_dtype
+        ref_name = return_item.inplace
+        ref_index_str = args_dict.get(ref_name) if ref_name else -1
+        cc_return_type_str = 'DT_' + return_dtype.replace('[', '_').replace(']', '').upper()
+        return_args_str += f"""{{/*.arg_name_=*/"{return_name}", /*.arg_dtype_=*/{cc_return_type_str},
+            /*.inplace_input_index_=*/{ref_index_str}}},\n"""
+    return return_args_str
+
+
+def generate_cc_op_signature(args_signature, args_name):
+    """
+    Generates C++ signature code for operator arguments.
+
+    Args:
+        args_signature (dict): A dictionary containing argument signatures.
+        args_name (list): A list of argument names.
+
+    Returns:
+        str: A string containing the generated signature code.
+    """
+    if args_signature is None:
+        return ''
+    signature_code = ''
+
+    # Init rw.
+    read_list, ref_list, write_list = gen_utils.init_args_signature_rw(args_signature)
+
+    # Init dtype group.
+    same_dtype_groups, _ = gen_utils.get_same_dtype_groups(args_signature, args_name)
+    for arg_name in args_name:
+        enum_rw = signature_get_rw_label_cc(arg_name, write_list, read_list, ref_list)
+        enum_dtype = signature_get_enum_dtype_cc(same_dtype_groups.get(arg_name))
+        signature = f"""Signature("{arg_name}", {enum_rw}, """ \
+                    f"""         SignatureEnumKind::kKindPositionalKeyword, nullptr, {enum_dtype}),\n """
+        signature_code += signature
+    return signature_code
+
+
+def signature_get_rw_label_cc(rw_op_name, write_list, read_list, ref_list):
+    """
+    Determines the read-write label for a C++ signature.
+
+    Args:
+        rw_op_name (str): The name of the read-write operation.
+        write_list (list): A list of write operations.
+        read_list (list): A list of read operations.
+        ref_list (list): A list of reference operations.
+
+    Returns:
+        str: The read-write label code.
+    """
+    # Define a dictionary mapping operation names to their corresponding RW labels
+    rw_label_map = {
+        'kRWWrite': write_list,
+        'kRWRead': read_list,
+        'kRWRef': ref_list
+    }
+
+    # Initialize with the default label
+    rw_label = 'kRWDefault'
+
+    # Check each list to see if the operation name matches and update the label if it does
+    for label, names in rw_label_map.items():
+        if rw_op_name in names:
+            rw_label = label
+            break  # Exit the loop once a match is found
+
+    return f'SignatureEnumRW::{rw_label}'
+
+
+def signature_get_enum_dtype_cc(index):
+    """
+    Generates C++ enum data type code for a signature.
+
+    Args:
+        index (int): The index of the data type.
+
+    Returns:
+        str: The enum data type code.
+    """
+    enum_type = 'SignatureEnumDType::'
+    type_map = {0: 'kDType',
+                1: 'kDType1',
+                2: 'kDType2',
+                3: 'kDType3',
+                4: 'kDType4',
+                5: 'kDType5',
+                6: 'kDType6',
+                7: 'kDType7',
+                8: 'kDType8',
+                9: 'kDType9'}
+    if index in type_map:
+        return enum_type + type_map[index]
+    return enum_type + 'kDTypeEmptyDefaultValue'

mindspore/ops_generate/ops_def_h_generator.py

@@ -0,0 +1,74 @@
+# 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 defines the OpHeaderFileGenerator class for generating header files for operator definitions.
+
+The generator creates C++ header files that declare external operator definitions based on operator prototypes
+and any additional operators provided. This is useful for managing operator interfaces in a consistent way.
+"""
+
+import os
+
+import template
+from template import Template
+from gen_utils import save_file
+import gen_constants as K
+from base_generator import BaseGenerator
+
+
+class OpsDefHGenerator(BaseGenerator):
+    """
+    Generates header files for operator definitions.
+
+    This class is responsible for creating C++ header files that declare external operator definitions
+    using templates. It processes a list of operator prototypes and can also include additional operators
+    provided as extra arguments.
+    """
+
+    def __init__(self):
+        """Initializes the OpHeaderFileGenerator and its templates."""
+        super().__init__()
+        self.extern_template = Template("OPS_API extern OpDef g${op_name};\n")
+        self.GEN_OPS_DEF_HEADER_TEMPLATE = template.GEN_OPS_DEF_HEADER_TEMPLATE
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the operator definition header file and saves it to the specified path.
+
+        This method constructs the header content by creating extern declarations for each operator defined
+        in the provided operator prototypes and any additional operators specified. The generated content
+        is then saved to a C++ header file.
+
+        Args:
+            work_path (str): The directory path where the generated header file will be saved.
+            op_protos (list): A list of operator prototypes containing information about the operators.
+
+        Returns:
+            None
+        """
+        extern_str = ''
+        extra_ops = []
+        for op_proto in op_protos:
+            extern_str += self.extern_template.replace(op_name=op_proto.op_class.name)
+            if op_proto.op_view:
+                extra_ops.append(op_proto.op_class.name + "View")
+        for class_name in extra_ops or []:
+            extern_str += self.extern_template.replace(op_name=class_name)
+
+        ops_header_file = self.GEN_OPS_DEF_HEADER_TEMPLATE.replace(extern_variable=extern_str)
+
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        file_name = "gen_ops_def.h"
+        save_file(save_path, file_name, ops_header_file)

mindspore/ops_generate/ops_name_h_generator.py

@@ -0,0 +1,68 @@
+# 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.
+# ============================================================================
+"""
+Module for generating C++ header files with operator name definitions.
+
+This module defines the `OpsNameHGenerator` class, which produces C++ code to define
+constants for operator names based on given prototypes.
+"""
+
+import os
+
+import gen_constants as K
+import gen_utils
+import pyboost_utils
+
+# refactored
+import template
+
+from base_generator import BaseGenerator
+
+
+class OpsNameHGenerator(BaseGenerator):
+    """
+    Class for generating C++ header files containing operator name constants.
+    """
+
+    def __init__(self):
+        """
+        Initializes the OpsNameHGenerator instance.
+        """
+        self.op_name_op_def_template = template.Template(K.OP_NAME_OP_DEF)
+        self.op_def_body_template = template.Template("""constexpr auto kName${k_name_op} = "${k_name_op}";\n""")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates C++ code for operator names and saves it to a header file.
+
+        Args:
+            work_path (str): The directory to save the generated files.
+            op_protos (list): A list of operator prototypes.
+
+        Returns:
+            None
+        """
+        op_name_gen_list = []
+        for op_proto in op_protos:
+            k_name_op = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            op_name_gen_list.append(self.op_def_body_template.replace(k_name_op=k_name_op))
+
+        op_name_code = self.op_name_op_def_template.replace(ops_namespace_body=op_name_gen_list)
+
+        op_name_code = template.CC_LICENSE_STR + op_name_code
+
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        file_name = "gen_ops_name.h"
+        gen_utils.save_file(save_path, file_name, op_name_code)

mindspore/ops_generate/ops_primitive_h_generator.py

@@ -0,0 +1,81 @@
+# 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.
+# ============================================================================
+"""
+Module for generating C++ header files for operator primitives.
+
+This module defines the `OpsPrimitiveHGenerator` class, which creates C++ header files
+containing definitions for operator primitives based on provided operator prototypes.
+"""
+
+import os
+
+import gen_constants as K
+import gen_utils
+import pyboost_utils
+
+# refactored
+import template
+
+from base_generator import BaseGenerator
+
+
+class OpsPrimitiveHGenerator(BaseGenerator):
+    """
+    This class generates the header file for operator primitives.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with templates for operator primitive definitions.
+        """
+        self.op_prim_op_def_template = template.Template(K.OP_PRIM_OP_DEF)
+        self.op_def_template = template.Template(
+            "GVAR_DEF(PrimitivePtr, kPrim${k_name_op}, std::make_shared<Primitive>(ops::kName${k_name_op}))\n")
+        self.op_def_rw_template = template.Template(
+            "GVAR_DEF(PrimitivePtr, kPrim${k_name_op}, std::make_shared<Primitive>(ops::kName${k_name_op}, "
+            "true, kPrimTypeBuiltIn, true))\n")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the header file content for operator primitives and saves it.
+
+        Args:
+            work_path (str): The directory to save the generated files.
+            op_protos (list): A list of operator prototypes.
+
+        Returns:
+            None
+
+        The method generates the content of the header file for each operator primitive
+        defined in the 'op_protos' list and saves it to the specified work path.
+        """
+        ops_prim_gen_list = []
+        for op_proto in op_protos:
+            k_name_op = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            if op_proto.op_args_signature:
+                if op_proto.op_args_signature.rw_write:
+                    ops_prim_gen_list.append(self.op_def_rw_template.replace(k_name_op=k_name_op))
+                    continue
+
+            ops_prim_gen_list.append(self.op_def_template.replace(k_name_op=k_name_op))
+
+        op_prim_op_def = self.op_prim_op_def_template.replace(auto_gen_path=K.MS_OP_DEF_AUTO_GENERATE_PATH,
+                                                              ops_prim_gen=ops_prim_gen_list)
+
+        res_str = template.CC_LICENSE_STR + op_prim_op_def
+
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        file_name = "gen_ops_primitive.h"
+        gen_utils.save_file(save_path, file_name, res_str)