generate_composite_decl

Generates the composite declaration attribute required when implementing custom op lowerings.

Warning

Implementing custom op lowerings uses authoring APIs from coreai-core (such as coreai._compiler.dialects). The leading underscore on _compiler marks this as private upstream API — it may move or change without notice across coreai-core releases.

Overview

When lowering a custom op to a coreai.graph composite, the graph must carry a CompositeDeclaration attribute that specifies the composite name, input and output names, and any op-specific attributes. generate_composite_decl builds this attribute from its arguments.

Public import:

from coreai_torch import generate_composite_decl

Declaration

def generate_composite_decl(
    context,
    op_name: str,
    input_names: list[str],
    output_names: list[str],
    op_attributes: dict[str, Any],
) -> CompositeDeclaration

Parameters

Parameter	Type	Description
context	Context	The Core AI Context. Pass value.context from any Value in scope.
op_name	str	Name of the composite op as it appears in the composite_decl attribute.
input_names	list[str]	Names for the composite inputs, in argument order.
output_names	list[str]	Names for the composite outputs, in result order.
op_attributes	dict[str, Any]	Op-specific attributes to embed in the declaration. The "version" key is required; pass 1 for the current API version.

Returns

A CompositeDeclaration Core AI attribute to pass as composite_decl when defining a coreai.graph.

Discussion

Use this function inside a lowering function registered with TorchConverter.register_torch_lowering().

The following example registers a lowering for a custom op "mylib::my_custom_op":

from coreai_torch import generate_composite_decl, TorchConverter


def my_custom_op_conversion(values_map, node, loc):
    arg0 = values_map[node.args[0].name]
    arg1 = values_map[node.args[1].name]
    op_attributes = {
        "some_attribute": 0.5,
        "version": 1,
    }
    composite_decl = generate_composite_decl(
        arg0.context,
        "my_custom_op",
        ["argument0", "argument1"],
        ["output"],
        op_attributes,
    )

    # The decorator transforms this function: calling it returns an OpResultList
    @coreai.graph(no_inline=True, composite_decl=composite_decl)
    def my_custom_op_impl(argument0: Value, argument1: Value) -> Value:
        ...
        return result

    return my_custom_op_impl(arg0, arg1)[0]


converter = TorchConverter()
converter.register_torch_lowering("mylib::my_custom_op")(my_custom_op_conversion)

The coreai.graph decorator always returns an OpResultList. Index it at [0] when the composite produces a single output.

For a full walkthrough of custom op lowering, see Custom Op Lowering.