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

mindspore/ops_generate/gen_utils.py

@@ -1,209 +0,0 @@
-# Copyright 2023-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 operator utils function
-"""
-import os
-import glob
-import hashlib
-import stat
-import yaml
-
-
-py_licence_str = f"""# Copyright 2023 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.
-# ============================================================================
-"""
-
-cc_license_str = f"""/**
- * Copyright 2023 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.
- */"""
-
-
-def convert_dtype_str(dtype_str):
-    """
-    Convert dtype str to expression in ops file
-    """
-    return 'DT_' + dtype_str.replace('[', '_').replace(']', '').upper()
-
-
-def get_type_str(type_str):
-    """
-    Get the unified type str for operator arg dtype.
-    """
-    # add more type here
-    type_kind_set = {
-        'int',
-        'float',
-        'bool',
-        'number',
-        'tuple[int]',
-        'tuple[float]',
-        'tuple[bool]',
-        'tuple[tensor]',
-        'tuple[str]',
-        'list[int]',
-        'list[float]',
-        'list[bool]',
-        'list[tensor]',
-        'list[str]',
-        'tensor',
-        'type',
-    }
-    if type_str in type_kind_set:
-        return "OpDtype." + convert_dtype_str(type_str)
-    raise TypeError(f"""Unsupported type {type_str} for args.""")
-
-
-def get_file_md5(file_path):
-    """
-    Get the md5 value for file.
-    """
-    if not os.path.exists(file_path):
-        return ""
-    if os.path.isdir(file_path):
-        return ""
-    with open(file_path, 'rb') as f:
-        data = f.read()
-    md5_value = hashlib.md5(data).hexdigest()
-    return md5_value
-
-
-def check_change_and_replace_file(last_file_path, tmp_file_path):
-    """
-    Compare tmp_file with the md5 value of the last generated file.
-    If the md5 value is the same, retain the last generated file.
-    Otherwise, update the last generated file to tmp_file.
-    """
-    last_md5 = get_file_md5(last_file_path)
-    tmp_md5 = get_file_md5(tmp_file_path)
-
-    if last_md5 == tmp_md5:
-        os.remove(tmp_file_path)
-    else:
-        if os.path.exists(last_file_path):
-            os.remove(last_file_path)
-        os.rename(tmp_file_path, last_file_path)
-
-
-def merge_files_to_one_file(file_paths, merged_file_path):
-    """
-    Merge multiple files into one file.
-    """
-    merged_content = ''
-    file_paths.sort()
-    for file_path in file_paths:
-        with open(file_path, 'r') as file:
-            merged_content += file.read()
-            merged_content += '\n'
-    with open(merged_file_path, 'w') as file:
-        file.write(merged_content)
-
-
-def merge_files(origin_dir, merged_file_path, file_format):
-    """
-    Merge multiple files into one file.
-    origin_dir: indicates the origin file directory.
-    merged_file_path: indicates the merged file path.
-    file_format: indicates the format of regular matching.
-    Files whose names meet the regular matching in 'origin_dir' directory will be merged into one file.
-    """
-    op_yaml_file_names = glob.glob(os.path.join(origin_dir, file_format))
-    merge_files_to_one_file(op_yaml_file_names, merged_file_path)
-
-
-def merge_files_append(origin_dir, merged_file_path, file_format):
-    """
-    Merge multiple files into one file.
-    origin_dir: indicates the origin file directory.
-    merged_file_path: indicates the merged file path.
-    file_format: indicates the format of regular matching.
-    Files whose names meet the regular matching in 'origin_dir' directory will be merged into one file.
-    """
-    file_paths = glob.glob(os.path.join(origin_dir, file_format))
-    merged_content = ''
-    file_paths.sort()
-    for file_path in file_paths:
-        with open(file_path, 'r') as file:
-            merged_content += file.read()
-            merged_content += '\n'
-    with open(merged_file_path, 'a') as file:
-        file.write(merged_content)
-
-
-def safe_load_yaml(yaml_file_path):
-    """
-    Load yaml dictionary from file.
-    """
-    yaml_str = dict()
-    with open(yaml_file_path, 'r') as yaml_file:
-        yaml_str.update(yaml.safe_load(yaml_file))
-    return yaml_str
-
-
-def get_assign_str_by_type_it(class_name, arg_info, arg_name, dtype):
-    """
-    Make type_it(arg, src_types, dst_type) python sentences.
-    """
-    assign_str = ""
-    type_cast = arg_info.get('type_cast')
-    if type_cast is not None:
-        type_cast_tuple = tuple(ct.strip() for ct in type_cast.split(","))
-        assign_str += f"type_it('{class_name}', '{arg_name}', {arg_name}, "
-        if len(type_cast_tuple) == 1:
-            assign_str += get_type_str(type_cast_tuple[0]) + ', '
-        else:
-            assign_str += '(' + ', '.join(get_type_str(ct) for ct in type_cast_tuple) + '), '
-        assign_str += get_type_str(dtype) + ')'
-    else:
-        assign_str = arg_name
-    return assign_str
-
-
-def write_file(path, data):
-    """
-    write data to path
-    :param path:
-    :param data:
-    :return:
-    """
-    flags = os.O_RDWR | os.O_CREAT
-    mode = stat.S_IWUSR | stat.S_IRUSR
-    fd = os.open(path, flags, mode)
-    with os.fdopen(fd, "w") as f:
-        f.write(data)

mindspore/ops_generate/op_proto.py

@@ -1,145 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-"""Op Proto."""
-from pyboost_utils import convert_python_func_name_to_c, is_op_multi_output
-
-
-class Arg:
-    def __init__(self, arg_name, arg_dtype, type_cast, is_type_id=False, as_init_arg=False, default=-1, inplace=''):
-        self.arg_name = arg_name
-        self.arg_dtype = arg_dtype
-        self.type_cast = type_cast
-        self.is_type_id = is_type_id
-        self.as_init_arg = as_init_arg
-        self.default = default
-        self.inplace = inplace
-
-
-class OpProto:
-    """
-    This class defines mindspore op prototype, we parse ops.yaml to the object, to auto generate primitive
-    and pyboost function.
-    """
-
-    def __init__(self,
-                 operator_name,
-                 op_args,
-                 returns,
-                 class_name,
-                 is_pyboost,
-                 is_view,
-                 cpu,
-                 gpu,
-                 ascend,
-                 prim_init,
-                 is_dispatch,
-                 is_multi_output,
-                 is_comm_op):
-        self.operator_name = operator_name
-        self.class_name = class_name
-        self.op_args = op_args
-        self.returns = returns
-        self.indexes = {arg.arg_name: index for index, arg in enumerate(op_args)}
-        self.pyboost_function_name = "Pyboost_" + self.class_name
-        self.is_pyboost = is_pyboost
-        self.is_view = is_view
-        self.cpu = cpu
-        self.gpu = gpu
-        self.ascend = ascend
-        self.prim_init = prim_init
-        self.is_dispatch = is_dispatch
-        self.is_multi_output = is_multi_output
-        self.is_comm_op = is_comm_op
-
-    @staticmethod
-    def get_device_special_name(dispatch, gpu, cpu, ascend):
-        if 'GPU' in dispatch.keys():
-            gpu = dispatch['GPU']
-        if 'CPU' in dispatch.keys():
-            cpu = dispatch['CPU']
-        if 'Ascend' in dispatch.keys():
-            ascend = dispatch['Ascend']
-        return gpu, cpu, ascend
-
-    @staticmethod
-    def load_from_yaml(op_name, yaml):
-        """
-        load from yaml
-        :param op_name:
-        :param yaml:
-        :return:
-        """
-        if 'args' not in yaml.keys():
-            raise TypeError("op define need key 'args'")
-        args_dict = yaml.get('args')
-        op_args = []
-        default_str = 'default'
-        is_type_id = False
-        prim_init = False
-        for arg_name in args_dict.keys():
-            arg_dtype = args_dict[arg_name]['dtype']
-            if arg_dtype == 'TypeId':
-                arg_dtype = 'int'
-            default = None
-            as_init_arg = False
-            is_type_id = False
-            type_cast = []
-            if default_str in args_dict[arg_name]:
-                default = args_dict[arg_name][default_str]
-                as_init_arg = True
-            if 'prim_init' in args_dict[arg_name]:
-                prim_init = args_dict[arg_name]['prim_init']
-            if 'type_cast' in args_dict[arg_name]:
-                type_cast = [cast_type.strip() for cast_type in args_dict[arg_name]['type_cast'].split(',')]
-            arg_handler_key = 'arg_handler'
-            if arg_handler_key in args_dict[arg_name] and args_dict[arg_name][arg_handler_key] == 'dtype_to_type_id':
-                is_type_id = True
-            arg = Arg(arg_name, arg_dtype, type_cast, is_type_id, as_init_arg, default)
-            op_args.append(arg)
-        if 'returns' not in yaml.keys():
-            raise TypeError("op define need key 'returns'")
-
-        is_pyboost = False
-        is_dispatch = False
-        is_comm_op = False
-        gpu = default_str
-        cpu = default_str
-        ascend = default_str
-        dispatch_key = 'dispatch'
-        if dispatch_key in yaml.keys():
-            is_dispatch = True
-            is_pyboost = yaml[dispatch_key].get('enable')
-            gpu, cpu, ascend = OpProto.get_device_special_name(yaml[dispatch_key], gpu, cpu, ascend)
-            is_comm_op = yaml[dispatch_key].get('is_comm_op')
-        return_dict = yaml['returns']
-        class_name = convert_python_func_name_to_c(op_name)
-        class_key = 'class'
-        if class_key in yaml.keys() and 'name' in yaml[class_key].keys():
-            class_name = yaml[class_key]['name']
-        return_args = []
-        for return_name in return_dict.keys():
-            inplace = ''
-            if 'inplace' in return_dict[return_name]:
-                inplace = return_dict[return_name]['inplace']
-            dtype = return_dict[return_name]['dtype']
-            arg = Arg(return_name, dtype, type_cast=[], inplace=inplace)
-            return_args.append(arg)
-        is_multi_output = is_op_multi_output(return_args)
-        is_view = False
-        if 'view' in yaml.keys():
-            is_view = True
-        op_proto = OpProto(op_name, op_args, return_args, class_name,
-                           is_pyboost, is_view, cpu, gpu, ascend, prim_init, is_dispatch, is_multi_output, is_comm_op)
-        return op_proto

mindspore/ops_generate/template.py

@@ -1,261 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-"""Template."""
-import re
-import os
-import gen_constants as K
-
-
-class CppTemplate:
-    """
-    template for generate c++ code
-    """
-    regular_str = r"(^[^\n\S]*)?\$([^\d\W]\w*|\{,?[^\d\W]\w*\,?})"
-    regular_match = re.compile(regular_str, re.MULTILINE)
-
-    def __init__(self, code_pattern):
-        self.code_pattern = code_pattern
-
-    @staticmethod
-    def load_from_file(file_path):
-        with open(file_path, "r") as f:
-            return CppTemplate(f.read())
-
-    def replace(self, **kwargs):
-        """
-        replace param.
-        :param kwargs:
-        :return:
-        """
-
-        def find(key: str):
-            if key in kwargs:
-                return kwargs[key]
-            raise TypeError(f"{key} should be in kwargs!")
-
-        def add_indent(indent, var):
-            return "".join([indent + line + "\n" for data in var for line in str(data).splitlines()]).rstrip()
-
-        def extract_variable(key):
-            start = ""
-            end = ""
-            if key[0] == "{":
-                key = key[1:-1]
-                if key[0] == ",":
-                    start = ","
-                    key = key[1:]
-                if key[-1] == ",":
-                    end = ", "
-                    key = key[:-1]
-            return find(key), start, end
-
-        def match_rule(match):
-            indent = match.group(1)
-            key = match.group(2)
-            var, start, end = extract_variable(key)
-            if indent is not None:
-                if not isinstance(var, list):
-                    return add_indent(indent, [var])
-                return add_indent(indent, var)
-            if isinstance(var, list):
-                code = ", ".join(str(x) for x in var)
-                if not var:
-                    return code
-                return start + code + end
-            return str(var)
-
-        return self.regular_match.sub(match_rule, self.code_pattern)
-
-
-NEW_LINE = "\n"
-WORK_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../../../")
-
-PYTHON_PRIM_TEMPLATE = CppTemplate("""
-
-class _Pyboost${class_name}Prim(${class_name}Prim_):
-    def __call__(self, ${input_args}):
-        ${process_func}
-        return _convert_stub(super().__call__(${processed_args}))
-
-
-${func_impl_name}_impl = _Pyboost${class_name}Prim()
-""")
-
-IMPORT_PYBOOST_PRIM_HEADER = f"""
-from mindspore.common._stub_tensor import _convert_stub
-from mindspore.ops.auto_generate.gen_arg_handler import *
-"""
-
-IMPORT_PYBOOST_FUNC_HEADER = f"""
-from mindspore.common import dtype as mstype
-from mindspore.ops.auto_generate.pyboost_inner_prim import *
-
-"""
-
-REGISTER_DEFINE_TEMPLATE = CppTemplate(
-    """
-    (void)py::class_<${class_name}PrimAdapter, PrimitiveFunctionAdapter, std::shared_ptr<${class_name}PrimAdapter>>(
-      *m, "${class_name}Prim_")
-      .def(py::init<>())
-      .def("__call__", &${class_name}PrimAdapter::Call, "Call ${class_name} op.");
-    m->def(\"${pyboost_op_name}\", &mindspore::pynative::${pyboost_cfunc_name}, \"Encrypt the data.\");""")
-REGISTER_TEMPLATE = CppTemplate("void RegisterPyBoostFunction(py::module *m) {${register_func}\n}")
-
-REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE = CppTemplate(
-    "MS_REG_PYBOOST_GRAD_OP(${pyboost_op_name}, mindspore::runtime::${pyboost_cfunc_name});\n")
-REGISTER_PYBOOST_GRAD_TEMPLATE = CppTemplate("${register_func}")
-
-PYBOOST_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_function.tpl'))
-
-PYBOOS_COMM_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_comm_function.tpl'))
-
-PYBOOST_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_function_header.tpl'))
-
-PYBOOST_GRAD_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/runtime/pynative/op_function/template/pyboost_grad_function.tpl'))
-
-PYBOOST_GRAD_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/runtime/pynative/op_function/template/pyboost_grad_function_header.tpl'))
-
-PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/grad/function/template/native_grad_function.tpl'))
-
-PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ccsrc/pipeline/pynative/grad/function/template/pyboost_native_grad_functions.tpl'))
-
-PYBOOST_NATIVE_GRAD_FUNCTIONS_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ccsrc/pipeline/pynative/grad/function/template/pyboost_native_grad_functions_header.tpl'))
-
-GEN_OPS_DEF_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/python/mindspore/ops_generate/gen_ops_def_header.tpl'))
-
-PYBOOST_BASE_OP_DEFINE_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_op_header.tpl'))
-
-PYBOOST_OP_REGISTER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_op_register.tpl'))
-
-# Ascend op generate
-PYBOOST_ASCEND_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_header_template.tpl'))
-
-PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_source_template.tpl'))
-
-PYBOOST_ASCEND_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_ascend_call_template.tpl'))
-
-PYBOOST_ASCEND_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/'
-                 'pyboost_view_template.tpl'))
-
-PYBOOST_ASCEND_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template'
-                 '/pyboost_ascend_customize_call_template.tpl'))
-
-# GPU op generate
-PYBOOST_GPU_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_header_template.tpl'))
-
-PYBOOST_GPU_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_source_template.tpl'))
-
-PYBOOST_GPU_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_call_template.tpl'))
-
-PYBOOST_GPU_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_view_template.tpl'))
-
-PYBOOST_GPU_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 './mindspore/ops/kernel/gpu/pyboost/template'
-                 '/pyboost_gpu_customize_call_template.tpl'))
-
-# CPU op generate
-PYBOOST_CPU_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_header_template.tpl'))
-
-PYBOOST_CPU_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_source_template.tpl'))
-
-PYBOOST_CPU_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_call_template.tpl'))
-
-PYBOOST_CPU_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_view_template.tpl'))
-
-PYBOOST_CPU_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH,
-                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template'
-                 '/pyboost_cpu_customize_call_template.tpl'))
-
-PYBOOST_PY_FUNC_IMPORT_HEADEAR = CppTemplate(
-    """from mindspore._c_expression import ${class_name}Prim_\n"""
-)
-
-PYBOOST_PY_FUNC_TEMPLATE = CppTemplate("""
-def ${func_name}(${func_args}):
-    r\"\"\"
-    ${description}
-    \"\"\"
-    return ${func_impl_name}_impl(${input_args})\n\n""")
-
-OP_PROTO_TEMPLATE = CppTemplate("""
-${class_name}FuncImpl g${class_name}FuncImpl;
-OpDef g${class_name} = {
-  /*.name_=*/"${class_name}",
-  /*.args_=*/ {
-    ${input_args}
-  },
-  /* .returns_ = */ {
-    ${return_args}
-  },
-  /*.signatures_ =*/ {
-    ${signatures}
-  },
-  /*.indexes_ =*/ {
-    ${indexes}
-  },
-  /*.func_impl_=*/g${class_name}FuncImpl,
-  /*.enable_dispatch_ =*/${enable_dispatch},
-  /*.is_view_ =*/${is_view},
-};
-REGISTER_PRIMITIVE_OP_DEF(${class_name}, &g${class_name});
-""")
-
-MULTI_OUTPUT_TEMPLATE = """
-ValuePtrList values;
-(void)std::transform(op->outputs().begin(), op->outputs().end(), std::back_inserter(values),
-                   [](const auto &value){ return value;});
-auto output_value = std::make_shared<ValueTuple>(values);
-"""