tvm.ir

Common data structures across all IR variants.

Classes:

`Constructor`(name_hint, inputs, belong_to)	Relay ADT constructor.
`TypeData`(header, type_vars, constructors)	Stores the definition for an Algebraic Data Type (ADT) in Relay.
`TensorAffineType`(scale, zero_point, dtype[, ...])	The quantized type of a tensor, with scale, zero point, and datatype
`TupleAffineType`(types)	Affine types of a node with multiple outputs
`Attrs`	Attribute node, which is mainly use for defining attributes of relay operators.
`DictAttrs`	Dictionary attributes.
`EnvFunc`	Environment function.
`Node`	Base class of all IR Nodes.
`SourceName`(name)	A identifier for a source location.
`Span`(source_name, line, end_line, column, ...)	Specifies a location in a source program.
`SequentialSpan`(spans)	A sequence of source spans
`Array`	Array container of TVM.
`Map`	Map container of TVM.
`BaseExpr`	Base class of all the expressions.
`GlobalVar`(name_hint[, type_annot])	A global variable in the IR.
`PrimExpr`	Base class of all primitive expressions.
`Range`(begin[, end, span])	Represent a range in TVM.
`RelayExpr`	Base class of all non-primitive expressions.
`BaseFunc`	Base class of all functions.
`CallingConv`(value)	Possible kinds of calling conventions.
`GlobalInfo`	Base node for all global info that can appear in the IR
`DummyGlobalInfo`()
`VDevice`([target, vdevice_id, memory_scope])
`ConstantMemoryPools`(pools)	This object contains a list of ConstantPoolInfo objects to be used as read-only memory in the compilation
`ConstantPoolInfo`(pool_name, targets[, ...])	ConstantPoolInfo object holds information related to RO memory pools where the statically sized allocate nodes are pooled into.
`PoolInfo`()	PoolInfo object holds information related to memory pools where the statically sized allocate nodes will pooled into.
`PoolInfoProperties`([size_hint_bytes, ...])	PoolInfo object holds information related to memory pools where the statically sized allocate nodes will pooled into.
`WorkspaceMemoryPools`(pools)	This object contains a list of WorkspacePoolInfo objects to be used as workspace memory in the compilation
`WorkspacePoolInfo`(pool_name, targets[, ...])	WorkspacePoolInfo object holds information related to RW memory pools where the statically sized allocate nodes will pooled into.
`IRModule`([functions, type_definitions, ...])	IRModule that holds functions and type definitions.
`Op`()	Primitive operator in the IR.
`TensorType`(shape[, dtype])	A concrete TensorType in Relay.
`FuncType`(arg_types, ret_type[, type_params, ...])	Function type.
`GlobalTypeVar`(name_hint[, kind])	A global type variable that is used for defining new types or type aliases.
`IncompleteType`([kind])	Incomplete type during type inference.
`PointerType`(element_type[, storage_scope])	PointerType used in the low-level TIR.
`PrimType`(dtype)	Primitive data type in the low level IR
`RelayRefType`(value)	Reference Type in relay.
`TupleType`(fields)	The type of tuple values.
`Type`	The base class of all types.
`TypeConstraint`	Abstract class representing a type constraint.
`TypeKind`(value)	Possible kinds of TypeVars.
`TypeVar`(name_hint[, kind])	Type parameter in functions.
`TypeCall`(func, args)	Type function application.
`TypeRelation`(func, args, num_inputs, attrs)	User defined type relation, it is an input-output relation on types.

Functions:

`make_node`(type_key, **kwargs)	Make a new IR node by its type key and fields
`assert_structural_equal`(lhs, rhs[, ...])	Assert lhs and rhs are structurally equal to each other.
`load_json`(json_str)	Load tvm object from json_str.
`save_json`(node)	Save tvm object as json string.
`structural_equal`(lhs, rhs[, map_free_vars])	Check structural equality of lhs and rhs.
`structural_hash`(node[, map_free_vars])	Compute structural hash of node
`register_intrin_lowering`(op_name, target, *)	Register Op lowering function
`register_op_attr`(op_name, attr_key[, value, ...])	Register an operator property of an operator by name.

class tvm.ir.Constructor(name_hint, inputs, belong_to)

Relay ADT constructor.

Parameters:

name_hint (str) – Name of constructor (only a hint).
inputs (List[Type]) – Input types.
belong_to (GlobalTypeVar) – Denotes which ADT the constructor belongs to.

class tvm.ir.TypeData(header, type_vars, constructors)

Stores the definition for an Algebraic Data Type (ADT) in Relay.

Note that ADT definitions are treated as type-level functions because the type parameters need to be given for an instance of the ADT. Thus, any global type var that is an ADT header needs to be wrapped in a type call that passes in the type params.

Parameters:

header (GlobalTypeVar) – The name of the ADT. ADTs with the same constructors but different names are treated as different types.
type_vars (List[TypeVar]) – Type variables that appear in constructors.
constructors (List[Constructor]) – The constructors for the ADT.

class tvm.ir.TensorAffineType(scale, zero_point, dtype, axis=-1)

The quantized type of a tensor, with scale, zero point, and datatype

The real space value is calculated as x = x_q * scale + zero_point

Parameters:

scale (Expr) – The scale
zero_point (Expr) – The zero_point
dtype (str) – The content data type.
axis (int) – The axis for per-channel quantization.

class tvm.ir.TupleAffineType(types)

Affine types of a node with multiple outputs

Parameters:: types (List[TensorAffineType]) – The shape of the Tensor

class tvm.ir.Attrs

Attribute node, which is mainly use for defining attributes of relay operators.

Used by function registered in python side, such as compute, schedule and alter_layout. Attrs is passed as the first argument to these functions.

Methods:

`list_field_info`()	Get fields information
`keys`()	Get list of names in the attribute.
`get_int_tuple`(key)	Get a python int tuple of a key
`get_int`(key)	Get a python int value of a key
`get_str`(key)	Get a python int value of a key

list_field_info()

Get fields information

Returns:: infos – List of field information
Return type:: list of AttrFieldInfo

keys()

Get list of names in the attribute.

Returns:: keys – List of keys
Return type:: list of str

get_int_tuple(key)

Get a python int tuple of a key

Parameters:: key (str)
Returns:: value
Return type:: Tuple of int

get_int(key)

Get a python int value of a key

Parameters:: key (str)
Returns:: value
Return type:: int

get_str(key)

Get a python int value of a key

Parameters:: key (str)
Returns:: value
Return type:: int

class tvm.ir.DictAttrs

Dictionary attributes.

Methods:

`keys`()	Get list of names in the attribute.
`get`(key[, default])	Get an element with a default value.
`items`()	Get items from the map.

keys()

Get list of names in the attribute.

Returns:: keys – List of keys
Return type:: list of str

get(key, default=None): Get an element with a default value.

items(): Get items from the map.

tvm.ir.make_node(type_key, **kwargs)

Make a new IR node by its type key and fields

Parameters:

type_key (str) – The type key of the node.
**kwargs (dict) – The fields of the node.

Returns:

node – The corresponding IR Node

Return type:

Node

Note

If the created node is instance of AttrsNode, then the creator function will also run bound checks and default value setup as supported by Attrs.

Example

The following code constructs a IntImm object

x = tvm.ir.make_node("IntImm", dtype="int32", value=10, span=None)
assert isinstance(x, tvm.tir.IntImm)
assert x.value == 10

class tvm.ir.EnvFunc

Environment function.

This is a global function object that can be serialized by its name.

Methods:

get(name)

Get a static env function

static get(name)

Get a static env function

Parameters:: name (str) – The name of the function.

class tvm.ir.Node: Base class of all IR Nodes.

class tvm.ir.SourceName(name)

A identifier for a source location.

Parameters:: name (str) – The name of the source.

class tvm.ir.Span(source_name, line, end_line, column, end_column)

Specifies a location in a source program.

Parameters:

source (SourceName) – The source name.
lineno (int) – The line number.
col_offset (int) – The column offset of the location.

class tvm.ir.SequentialSpan(spans)

A sequence of source spans

This span is specific for an expression, which is from multiple expressions after an IR transform.

Parameters:: spans (Array) – The array of spans.

tvm.ir.assert_structural_equal(lhs, rhs, map_free_vars=False)

Assert lhs and rhs are structurally equal to each other.

Parameters:

lhs (Object) – The left operand.
rhs (Object) – The left operand.
map_free_vars (bool) – Whether or not shall we map free vars that does not bound to any definitions as equal to each other.

:raises ValueError : if assertion does not hold.:

See also

structrual_equal

class tvm.ir.Array

Array container of TVM.

You do not need to create Array explicitly. Normally python list and tuple will be converted automatically to Array during tvm function call. You may get Array in return values of TVM function call.

class tvm.ir.Map

Map container of TVM.

You do not need to create Map explicitly. Normally python dict will be converted automatically to Map during tvm function call. You can use convert to create a dict[Object-> Object] into a Map

Methods:

`items`()	Get the items from the map
`get`(key[, default])	Get an element with a default value.

items(): Get the items from the map

get(key, default=None)

Get an element with a default value.

Parameters:

key (object) – The attribute key.
default (object) – The default object.

Returns:

value – The result value.

Return type:

object

class tvm.ir.BaseExpr: Base class of all the expressions.

class tvm.ir.GlobalVar(name_hint: str, type_annot: Type | None = None)

A global variable in the IR.

GlobalVar is used to refer to the global functions stored in the IRModule.

Parameters:: name_hint (str) – The name of the variable.

Methods:

astext([show_meta_data, annotate])

Get the text format of the expression.

astext(show_meta_data: bool = True, annotate: Callable[[Object], str] | None = None) → str

Get the text format of the expression.

Parameters:

show_meta_data (bool) – Whether to include meta data section in the text if there is meta data.
annotate (Optional[Object->str]) – Optionally annotate function to provide additional information in the comment block.

Returns:

text – The text format of the expression.

Return type:

str

Notes

The meta data section is necessary to fully parse the text format. However, it can contain dumps that are big (e.g constant weights), so it can be helpful to skip printing the meta data section.

class tvm.ir.PrimExpr

Base class of all primitive expressions.

PrimExpr is used in the low-level code optimizations and integer analysis.

class tvm.ir.Range(begin: PrimExpr, end: PrimExpr | None = None, span: Span | None = None)

Represent a range in TVM.

You do not need to create a Range explicitly. Python lists and tuples will be converted automatically to a Range in API functions.

Parameters:

begin (PrimExpr) – The begin value of the range when end is None. Otherwise it is the length of the range.
end (Optional[PrimExpr]) – The end value of the range.
span (Optional[Span]) – The location of this node in the source code.

Note

The constructor creates the range [begin, end) if the end argument is not None. Otherwise, it creates [0, begin).

Methods:

from_min_extent(min_value, extent[, span])

Construct a Range by min and extent.

static from_min_extent(min_value: PrimExpr, extent: PrimExpr, span: Span | None = None) → Range

Construct a Range by min and extent.

This constructs a range in [min_value, min_value + extent)

Parameters:

min_value (PrimExpr) – The minimum value of the range.
extent (PrimExpr) – The extent of the range.
span (Optional[Span]) – The location of this node in the source code.

Returns:

rng – The constructed range.

Return type:

Range

class tvm.ir.RelayExpr

Base class of all non-primitive expressions.

Attributes:

`checked_type`	Get the checked type of tvm.relay.Expr.
`struct_info`	Get the struct info field

property checked_type

Get the checked type of tvm.relay.Expr.

Returns:: checked_type – The checked type.
Return type:: tvm.relay.Type

property struct_info: StructInfo | None

Get the struct info field

Returns:: struct_info – The struct info if available.
Return type:: tvm.relax.StructInfo

class tvm.ir.BaseFunc

Base class of all functions.

Attributes:

attrs

Return the attrs member of the function.

Methods:

`with_attr`(attr_key_or_dict[, attr_value])	Create a new copy of the function and update the attribute.
`with_attrs`(attr_map)	Copy the IRModule and add the given attribute map to it.
`without_attr`(attr_key)	Create a new copy of the function with an attribute without provided key.

property attrs: Return the attrs member of the function.

with_attr(attr_key_or_dict, attr_value=None) → BaseFunc

Create a new copy of the function and update the attribute.

Parameters:

attr_key_or_dict (Union[str, dict]) – The attribute key to use or a dict containing multiple key value pairs.
attr_value (Object) – The new attribute value.

Returns:

func – A new copy of the function

Return type:

BaseFunc

with_attrs(attr_map: DictAttrs | Dict[str, Object]) → BaseFunc

Copy the IRModule and add the given attribute map to it. :param attr_map: The attribute map :type attr_map: Union[DictAttrs, Dict[str, Object]]

Returns:: func – A new copy of the function
Return type:: BaseFunc

without_attr(attr_key: str) → BaseFunc

Create a new copy of the function with an attribute without provided key.

Parameters:: attr_key (str) – The attribute key to delete from the attrubte pairs.
Returns:: func – A new copy of the function
Return type:: BaseFunc

class tvm.ir.CallingConv(value): Possible kinds of calling conventions.

class tvm.ir.GlobalInfo

Base node for all global info that can appear in the IR

Methods:

same_as(other)

Overload with structural equality.

same_as(other): Overload with structural equality.

class tvm.ir.DummyGlobalInfo

class tvm.ir.VDevice(target=None, vdevice_id: int = 0, memory_scope: str = 'global')

class tvm.ir.ConstantMemoryPools(pools: List[ConstantPoolInfo])

This object contains a list of ConstantPoolInfo objects to be used as read-only memory in the compilation

Parameters:: pools (List[ConstantPoolInfo]) – The list of ConstantPoolInfo objects to be used with the compilation

class tvm.ir.ConstantPoolInfo(pool_name: str, targets, constant_info_arr=None, pool_info_properties=None)

ConstantPoolInfo object holds information related to RO memory pools where the statically sized allocate nodes are pooled into.

Parameters:

pool_name (str) – The name of the memory pool
targets (list[Target]) – describes which targets could access the pool
pool_info_properties (PoolInfoProperties) – The properties of the pool.

class tvm.ir.PoolInfo: PoolInfo object holds information related to memory pools where the statically sized allocate nodes will pooled into. This is a base class for WorkspacePoolInfo and ConstantPoolInfo.

class tvm.ir.PoolInfoProperties(size_hint_bytes: int | None = -1, clock_frequency_hz: int | None = -1, read_bandwidth_bytes_per_cycle: int | None = -1, write_bandwidth_bytes_per_cycle: int | None = -1, read_latency_cycles: int | None = 0, write_latency_cycles: int | None = 0, target_burst_bytes=None)

PoolInfo object holds information related to memory pools where the statically sized allocate nodes will pooled into.

Parameters:

size_hint_bytes (Optional[int]) – The expected size hint to be used by the allocator. The default value would be -1 which means the pool is not size restricted.
clock_frequency_hz (Optional[int]) – The clock frequency that the memory pool runs at in Hz. If not specified/known, this will default to -1 indicating it hasn’t been defined.
read_bandwidth_bytes_per_cycle (Optional[int]) – The read bandwidth of the memory pool in bytes/cycle. If not specified/known, this will default to -1 indicating it hasn’t been defined.
write_bandwidth_bytes_per_cycle (Optional[int]) – The write bandwidth of the memory pool in bytes/cycle. If not specified/known, this will default to -1 indicating it hasn’t been defined.
read_latency_cycles (Optional[int]) – The read latency of the memory pool in cycles. If not specified/known, this will default to 0.
write_latency_cycles (Optional[int]) – The write latency of the memory pool in cycles. If not specified/known, this will default to 0.
target_burst_bytes (Optional[Union[Dict[Target, int], None]]) – The burst length of the memory pool in bytes per target. If not specified/known for a given target, a burst length of 1 byte will be assumed.

class tvm.ir.WorkspaceMemoryPools(pools: List[WorkspacePoolInfo])

This object contains a list of WorkspacePoolInfo objects to be used as workspace memory in the compilation

Parameters:: pools (List[WorkspacePoolInfo]) – The list of ConstantPoolInfo objects to be used with the compilation

class tvm.ir.WorkspacePoolInfo(pool_name: str, targets, pool_info_properties=None)

WorkspacePoolInfo object holds information related to RW memory pools where the statically sized allocate nodes will pooled into.

Parameters:

pool_name (str) – The name of the memory pool
targets (list[Target]) – A list of targets which could access the pool
pool_info_properties (PoolInfoProperties) – The properties of the pool.

class tvm.ir.IRModule(functions=None, type_definitions=None, attrs=None, global_infos=None)

IRModule that holds functions and type definitions.

IRModule is the basic unit for all IR transformations across the stack.

Parameters:: functions (Optional[dict].) – Map of global var to BaseFunc

Methods:

`functions_items`()	Get items in self.functions.items() in alphabetical order.
`update`(other)	Insert functions in another Module to current one.
`update_func`(var, func)	Update the function corresponding to a global variable in the module.
`update_global_info`(name, global_info)	Update global info in the module
`get_global_var`(name)	Get a global variable in the function by name.
`get_global_vars`()	Collect all global vars defined in this module.
`replace_global_vars`(replacements)	Replace GlobalVar instances within the module
`get_global_type_vars`()	Collect all global type vars defined in this module.
`get_global_type_var`(name)	Get a global type variable in the function by name.
`get_constructor`(tag)	Look up an ADT constructor by tag.
`from_expr`(expr[, functions, type_defs])	Construct a module from a standalone expression.
`get_attr`(attr_key)	Get the IRModule attribute.
`with_attr`(attr_key, attr_value)	Copy the IRModule and add an attribute to it.
`without_attr`(attr_key)	Copy the IRModule and remove an attribute key and its associated value.
`with_attrs`(attr_map)	Copy the IRModule and add the given attribute map to it.
`astext`([show_meta_data, annotate])	Get the text format of the expression.

functions_items()

Get items in self.functions.items() in alphabetical order.

Returns:: items – The functions items.
Return type:: List[Tuple[GlobalVar, Function]]

update(other)

Insert functions in another Module to current one.

Parameters:: other (IRModule) – The module to merge into the current Module.

update_func(var, func)

Update the function corresponding to a global variable in the module.

Parameters:

var (GlobalVar) – The global variable.
func (tvm.relay.Function) – The function to be inserted.

update_global_info(name, global_info)

Update global info in the module

Parameters:

name (str) – The name for the global info.
global_info (List[GlobalInfo]) – The global info to be updated.

get_global_var(name)

Get a global variable in the function by name.

Parameters:: name (str) – The name of the global variable.
Returns:: global_var – The global variable mapped to name.
Return type:: GlobalVar
Raises:: tvm.error.TVMError if we cannot find corresponding global var. –

get_global_vars()

Collect all global vars defined in this module.

Returns:: global_vars – An array of global vars.
Return type:: Array[GlobalVar]

replace_global_vars(replacements: Dict[str | GlobalVar, str | GlobalVar]) → IRModule

Replace GlobalVar instances within the module

Replace GlobalVars within the IRModule. Since the IRModule may contain internal references to a GlobalVar, either in TIR or in Relax, this method should be used whenever replacing or renaming a GlobalVar.

Parameters:: replacements (Dict[Union[str, _expr.GlobalVar], Union[str, _expr.GlobalVar]]) – A dictionary where each key is a GlobalVar to be replaced, and the corresponding value is the GlobalVar with which to replace it.
Returns:: The updated module
Return type:: IRModule

get_global_type_vars()

Collect all global type vars defined in this module.

Returns:: global_type_vars – An array of global type vars.
Return type:: Array[GlobalTypeVar]

get_global_type_var(name)

Get a global type variable in the function by name.

Parameters:: name (str) – The name of the global type variable.
Returns:: global_type_var – The global variable mapped to name.
Return type:: GlobalTypeVar
Raises:: tvm.error.TVMError if we cannot find corresponding global type var. –

get_constructor(tag)

Look up an ADT constructor by tag.

Parameters:: tag (int) – The tag for a constructor.
Returns:: constructor – The constructor associated with the given tag,
Return type:: Constructor
Raises:: tvm.error.TVMError if the corresponding constructor cannot be found. –

static from_expr(expr, functions=None, type_defs=None)

Construct a module from a standalone expression.

Parameters:

expr (RelayExpr) – The starting expression
global_funcs (Optional[dict]) – Map of global vars to function definitions
type_defs (Optional[dict]) – Map of global type vars to type definitions

Returns:

mod – A module containing the passed definitions, where expr is set as the entry point (wrapped in a function if necessary)

Return type:

Module

get_attr(attr_key)

Get the IRModule attribute.

Parameters:: attr_key (str) – The attribute key.
Returns:: attr_value – Attribute value
Return type:: Any

with_attr(attr_key, attr_value)

Copy the IRModule and add an attribute to it.

Parameters:

attr_key (str) – The attribute key.
attr_value (Object) – The new attribute value.

Returns:

mod – A new copy of the IRModule with the attribute

Return type:

IRModule

without_attr(attr_key: str) → IRModule

Copy the IRModule and remove an attribute key and its associated value. :param attr_key: The attribute key. :type attr_key: str

Returns:: mod – A new copy of the IRModule without the attribute
Return type:: IRModule

with_attrs(attr_map: DictAttrs | Dict[str, Object]) → IRModule

Copy the IRModule and add the given attribute map to it. :param attr_map: The attribute map :type attr_map: Union[DictAttrs, Dict[str, Object]]

Returns:: mod – A new copy of the IRModule with the attribute
Return type:: IRModule

astext(show_meta_data=True, annotate=None)

Get the text format of the expression.

Parameters:

show_meta_data (bool) – Whether to include meta data section in the text if there is meta data.
annotate (Optional[Object->str]) – Optionally annotate function to provide additional information in the comment block.

Returns:

text – The text format of the expression.

Return type:

str

Notes

The meta data section is necessary to fully parse the text format. However, it can contain dumps that are big (e.g constant weights), so it can be helpful to skip printing the meta data section.

class tvm.ir.Op

Primitive operator in the IR.

Methods:

`astext`([show_meta_data, annotate])	Get the text format of the expression.
`get`(op_name)	Get the Op for a given name
`get_attr`(attr_name)	Get additional attribute about the operator.
`has_attr`(attr_name)	Check whether the operator has additional attribute.
`set_attr`(attr_name, value[, plevel])	Set attribute about the operator.
`reset_attr`(attr_name)	Reset attribute about the operator.
`add_type_rel`(rel_name[, type_rel_func])	Attach the type function corresponding to the return type.
`add_argument`(name, type, description)	Add arguments information to the function.
`set_support_level`(level)	Set the support level of op.
`set_num_inputs`(n)	Set the support level of op.
`set_attrs_type_key`(key)	Set the attribute type key of op.
`list_op_names`()	List all the op names in the op registry.

astext(show_meta_data=True, annotate=None)

Get the text format of the expression.

Parameters:

show_meta_data (bool) – Whether to include meta data section in the text if there is meta data.
annotate (Optional[Object->str]) – Optionally annotate function to provide additional information in the comment block.

Returns:

text – The text format of the expression.

Return type:

str

Notes

The meta data section is necessary to fully parse the text format. However, it can contain dumps that are big (e.g constant weights), so it can be helpful to skip printing the meta data section.

static get(op_name)

Get the Op for a given name

Parameters:: op_name (str) – The operator name
Returns:: op – The op of the corresponding name
Return type:: Op

get_attr(attr_name)

Get additional attribute about the operator.

Parameters:: attr_name (str) – The attribute name.
Returns:: value – The attribute value
Return type:: object

has_attr(attr_name)

Check whether the operator has additional attribute.

Parameters:: attr_name (str) – The attribute name.
Returns:: value – Whether the operator has additional attribute
Return type:: bool

set_attr(attr_name, value, plevel=10)

Set attribute about the operator.

Parameters:

attr_name (str) – The attribute name
value (object) – The attribute value
plevel (int) – The priority level

reset_attr(attr_name)

Reset attribute about the operator.

Parameters:: attr_name (str) – The attribute name

add_type_rel(rel_name, type_rel_func=None)

Attach the type function corresponding to the return type.

Parameters:

rel_name (str) – The type relation name to register.
type_rel_func (Optional[function (args: List[Type], attrs: Attrs) -> Type]) –
The backing relation function which can solve an arbitrary relation on variables. Differences with type_rel_func in C++:
1. When type_rel_func is not None
  1. OpAddTypeRel on C++ side will adjust type_rel_func with TypeReporter to calling convention of relay type system.
  2. type_rel_func returns output argument’s type, return None means can’t infer output’s type.
  3. only support single output operators for now, the last argument is output tensor.
2. when type_rel_func is None, will call predefined type_rel_funcs in relay
  according to tvm.relay.type_relation. + rel_name.

add_argument(name, type, description)

Add arguments information to the function.

Parameters:

name (str) – The argument name.
type (str) – The argument type.
description (str) – The argument description.

set_support_level(level)

Set the support level of op.

Parameters:: level (int) – The support level.

set_num_inputs(n)

Set the support level of op.

Parameters:: n (int) – The input number.

set_attrs_type_key(key)

Set the attribute type key of op.

Parameters:: key (str) – The type key.

static list_op_names()

List all the op names in the op registry.

Returns:: value – The registered op names
Return type:: List[str]

tvm.ir.register_intrin_lowering(op_name, target, *, f=None, level=10)

Register Op lowering function

Parameters:

op_name (str) – The op name
target (str) – The target string for given intrinsic lowering function
f (function, optional) – The function to be registered.
level (int) – The priority level

Returns:

fregister – Register op lowering function if f is not specified.

Return type:

function

tvm.ir.register_op_attr(op_name, attr_key, value=None, level=10)

Register an operator property of an operator by name.

Parameters:

op_name (str) – The name of operator
attr_key (str) – The attribute name.
value (object, optional) – The value to set
level (int, optional) – The priority level

Returns:

fregister – Register function if value is not specified.

Return type:

function

class tvm.ir.TensorType(shape, dtype='float32')

A concrete TensorType in Relay.

This is the type assigned to tensors with a known dtype and shape. For example, a tensor of float32 and (5, 5).

Parameters:

shape (List[tvm.ir.PrimExpr]) – The shape of the Tensor
dtype (Optional[str]) – The content data type.

Attributes:

concrete_shape

Get shape of the type as concrete tuple of int.

property concrete_shape

Get shape of the type as concrete tuple of int.

Returns:: shape – The concrete shape of the Type.
Return type:: List[int]

:raises TypeError : If the shape is symbolic:

class tvm.ir.FuncType(arg_types, ret_type, type_params=None, type_constraints=None)

Function type.

A function type consists of a list of type parameters to enable the definition of generic functions, a set of type constraints which we omit for the time being, a sequence of argument types, and a return type.

We can informally write them as: forall (type_params), (arg_types) -> ret_type where type_constraints

Parameters:

arg_types (List[tvm.relay.Type]) – The argument types
ret_type (tvm.relay.Type) – The return type.
type_params (Optional[List[tvm.relay.TypeVar]]) – The type parameters
type_constraints (Optional[List[tvm.relay.TypeConstraint]]) – The type constraints.

class tvm.ir.GlobalTypeVar(name_hint, kind=TypeKind.AdtHandle)

A global type variable that is used for defining new types or type aliases.

Parameters:

name_hint (str) – The name of the type variable. This name only acts as a hint, and is not used for equality.
kind (Optional[TypeKind]) – The kind of the type parameter.

class tvm.ir.IncompleteType(kind=TypeKind.Type)

Incomplete type during type inference.

kindOptional[TypeKind]: The kind of the incomplete type.

class tvm.ir.PointerType(element_type, storage_scope='')

PointerType used in the low-level TIR.

Parameters:

element_type (tvm.ir.Type) – The type of pointer’s element.
storage_scope (str) – The storage scope into which the pointer addresses.

class tvm.ir.PrimType(dtype)

Primitive data type in the low level IR

Parameters:: dtype (str) – The runtime data type relates to the primtype.

class tvm.ir.RelayRefType(value)

Reference Type in relay.

Parameters:: value (Type) – The value type.

class tvm.ir.TupleType(fields)

The type of tuple values.

Parameters:: fields (List[Type]) – The fields in the tuple

class tvm.ir.Type

The base class of all types.

Methods:

same_as(other)

Compares two Relay types by referential equality.

same_as(other): Compares two Relay types by referential equality.

class tvm.ir.TypeConstraint: Abstract class representing a type constraint.

class tvm.ir.TypeKind(value): Possible kinds of TypeVars.

class tvm.ir.TypeVar(name_hint, kind=TypeKind.Type)

Type parameter in functions.

A type variable represents a type placeholder which will be filled in later on. This allows the user to write functions which are generic over types.

Parameters:

name_hint (str) – The name of the type variable. This name only acts as a hint, and is not used for equality.
kind (Optional[TypeKind]) – The kind of the type parameter.

class tvm.ir.TypeCall(func, args)

Type function application.

Parameters:

func (tvm.ir.Type) – The function.
args (List[tvm.ir.Type]) – The arguments.

Returns:

type_call – The type function application.

Return type:

TypeCall

class tvm.ir.TypeRelation(func, args, num_inputs, attrs)

User defined type relation, it is an input-output relation on types.

TypeRelation is more generalized than TypeCall as it allows inference: of both inputs and outputs.

Parameters:

func (EnvFunc) – User defined relation function.
args ([tvm.ir.Type]) – List of types to the func.
num_inputs (int) – Number of input arguments in args, this act as a hint for type inference.
attrs (Attrs) – The attribute attached to the relation information

Returns:

type_relation – The type relation.

Return type:

tvm.ir.TypeRelation