runtime implementation for LibTorch/TorchScript. More...

Namespaces
	arith
	namespace of arithmetic analysis.

	attr
	Generic attribute names that can be attached to any function.

	auto_scheduler

	codegen
	namespace for target translation and codegen.

	detail

	instrument

	meta_schedule

	relay
	Relay: a high level functional IR for TVM.

	runtime

	script

	support

	te
	Tensor expression language DSL.

	tir

	topi

	transform

Classes
class	ConstructorNode
	ADT constructor. Constructors compare by pointer equality. More...

class	Constructor
	Managed reference to ConstructorNode. More...

class	TypeDataNode
	TypeData container node. More...

class	TypeData
	Stores all data for an Algebraic Data Type (ADT). More...

class	AffineTypeNode
	AffineType representation. More...

class	AffineType
	Managed reference to AffineTypeNode. More...

class	TensorAffineTypeNode
	TensorAffineType representation. More...

class	TensorAffineType
	Managed reference to AffineTypes. More...

class	TupleAffineTypeNode
	TupleAffineType representation. More...

class	TupleAffineType
	Managed reference to TupleAffineTypes. More...

struct	AttrError
	Error thrown during attribute checking. More...

class	AttrFieldInfoNode
	Information about attribute fields in string representations. More...

class	AttrFieldInfo
	AttrFieldInfo. More...

class	BaseAttrsNode
	Base class of all attribute class. More...

class	Attrs
	Managed reference to BaseAttrsNode. More...

class	DictAttrsNode
	Specialized attribute type that is backed by a map. The DictAttrsNode implements the Attrs behavior, its fields are directly accessible via object.field_name like other normal nodes. More...

class	DictAttrs
	Managed reference to DictAttrsNode. More...

class	AttrsNode
	The base class of the all the Use "curiously recurring template pattern". More...

class	DiagnosticNode
	A compiler diagnostic message. More...

class	Diagnostic

class	DiagnosticBuilder
	A wrapper around std::stringstream to build a diagnostic. More...

class	DiagnosticRendererNode
	Display diagnostics in a given display format. More...

class	DiagnosticRenderer

class	DiagnosticContextNode

class	DiagnosticContext

class	EnvFuncNode
	A serializable function backed by TVM's global environment. More...

class	EnvFunc
	Managed reference to EnvFuncNode. More...

class	TypedEnvFunc
	Please refer to TypedEnvFunc<R(Args..)>. More...

class	TypedEnvFunc< R(Args...)>
	A typed version of EnvFunc. It is backed by a GlobalFuncNode internally. More...

class	BaseExprNode
	Base type of all the expressions. More...

class	BaseExpr
	Managed reference to BaseExprNode. More...

class	PrimExprNode
	Base node of all primitive expressions. More...

class	PrimExpr
	Reference to PrimExprNode. More...

class	RelayExprNode
	Base node of all non-primitive expressions. More...

class	RelayExpr
	Managed reference to RelayExprNode. More...

class	GlobalVarNode
	Global variable that lives in the top-level module. More...

class	GlobalVar
	Managed reference to GlobalVarNode. More...

class	IntImmNode
	Constant integer literals in the program. More...

class	IntImm
	Managed reference class to IntImmNode. More...

class	FloatImmNode
	Constant floating point literals in the program. More...

class	FloatImm
	Managed reference class to FloatImmNode. More...

class	Bool
	Boolean constant. More...

class	Integer
	Container of constant int that adds more constructors. More...

class	RangeNode
	range over one dimension More...

class	Range
	Range container More...

class	BaseFuncNode
	Base node of all functions. More...

class	BaseFunc
	Managed reference to BaseFuncNode. More...

class	GlobalVarSupplyNode
	GlobalVarSupply can be used to generate unique GlobalVars. More...

class	GlobalVarSupply
	Managed reference class to GlobalVarSupplyNode. More...

struct	PoolInfoNode
	Describes a pool of memory accessible by one or more targets. More...

class	PoolInfo
	Base class for WorkspacePoolInfo and ConstantPoolInfo. More...

struct	PoolInfoPropertiesNode
	Describes a pool of memory properties. More...

class	PoolInfoProperties

struct	WorkspacePoolInfoNode

class	WorkspacePoolInfo

struct	ConstantInfoNode

class	ConstantInfo

struct	ConstantPoolInfoNode

class	ConstantPoolInfo

struct	WorkspaceMemoryPoolsNode

class	WorkspaceMemoryPools

struct	ConstantMemoryPoolsNode

class	ConstantMemoryPools

class	IRModuleNode
	IRModule that holds functions and type definitions. More...

class	IRModule
	Managed reference class to IRModuleNode. More...

class	NameSupplyNode
	NameSupply can be used to generate unique names. More...

class	NameSupply
	Managed reference class to NameSupplyNode. More...

class	OpAttrMap
	Map<Op,ValueType> used to store meta-information about Op. More...

class	OpNode
	Primitive Op(builtin intrinsics) More...

class	Op
	Managed reference class to OpNode. More...

class	OpRegEntry
	Helper structure to register operators. More...

class	SIBuilder
	Source Information Builder, SIBuilder provides helper APIs for filling spans, particularly useful for one-to-many, many-to-one and many-to-many IR transformations. More...

class	SourceNameNode
	The name of a source fragment. More...

class	SourceName
	The source name of a file span. More...

class	SpanNode
	Stores locations in frontend source that generated a node. More...

class	Span

class	SequentialSpanNode
	Store a list of spans for an expr generated from mulitple source exprs. More...

class	SequentialSpan
	Reference class of SequentialSpanNode. More...

class	SourceNode

class	Source

class	SourceMapNode
	Stores locations in frontend source that generated a node. More...

class	SourceMap

class	BaseTensorTypeNode
	Base of all Tensor types This container can hold TensorType or GenericTensorType. More...

class	BaseTensorType
	Managed reference to BaseTensorTypeNode. More...

class	TensorTypeNode
	This is the most commonly used type in relay. TensorType have a fixed dimension, data type. More...

class	TensorType
	Managed reference to TensorTypeNode. More...

class	TypeNode
	Type is the base type of all types. More...

class	Type
	Managed reference to TypeNode. More...

class	PrimTypeNode
	Primitive data types used in the low-level IR. More...

class	PrimType

class	PointerTypeNode
	Low-level raw pointer type. More...

class	PointerType

class	TypeVarNode
	Type parameter in functions. More...

class	TypeVar
	Managed reference to TypeVarNode. More...

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

class	GlobalTypeVar
	Managed reference to GlobalTypeVarNode. More...

class	TupleTypeNode
	The type of tuple values. More...

class	TupleType
	Managed reference to TupleTypeNode. More...

class	TypeConstraintNode
	Potential Constraints in a function. More...

class	TypeConstraint
	Managed reference to TypeConstraintNode. More...

class	FuncTypeNode
	Function type. More...

class	FuncType
	Managed reference to FuncTypeNode. More...

class	IncompleteTypeNode
	Intermediate values that is used to indicate incomplete type during type inference. More...

class	IncompleteType
	Managed reference to IncompleteTypeNode. More...

class	RelayRefTypeNode
	Reference Type High-level Relay IR. More...

class	RelayRefType
	Managed reference to RelayRefTypeNode. More...

class	TypeFunctor

class	TypeFunctor< R(const Type &n, Args...)>

class	TypeVisitor
	A type visitor that recursively visit types. More...

class	TypeMutator
	TypeMutator that mutates expressions. More...

class	TypeCallNode
	Type function application. More...

class	TypeCall
	Managed reference to TypeCallNode. More...

class	TypeReporterNode
	reporter that reports back to the type resolution information. More...

class	TypeReporter
	Container class of TypeReporter. More...

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

class	TypeRelation
	Managed reference to TypeRelationNode. More...

class	AttrRegistryMapContainerMap
	Generic attribute map. More...

class	AttrRegistryMap
	Map<Key, ValueType> used to store meta-data. More...

class	NodeFunctor
	A dynamically dispatched functor on the type of the first argument. More...

class	NodeFunctor< R(const ObjectRef &n, Args...)>

class	ObjectPathNode
	Path to an object from some root object. More...

class	ObjectPath

class	RootPathNode

class	RootPath

class	AttributeAccessPathNode

class	AttributeAccessPath

class	UnknownAttributeAccessPathNode

class	UnknownAttributeAccessPath

class	ArrayIndexPathNode

class	ArrayIndexPath

class	MissingArrayElementPathNode

class	MissingArrayElementPath

class	MapValuePathNode

class	MapValuePath

class	MissingMapEntryPathNode

class	MissingMapEntryPath

class	AttrVisitor
	Visitor class to get the attributes of an AST/IR node. The content is going to be called for each field. More...

class	ReflectionVTable
	Virtual function table to support IR/AST node reflection. More...

class	ReprPrinter
	A printer class to print the AST/IR nodes. More...

class	ReprLegacyPrinter
	Legacy behavior of ReprPrinter. More...

class	PrinterConfigNode

class	PrinterConfig

class	TVMScriptPrinter
	Legacy behavior of ReprPrinter. More...

class	BaseValueEqual
	Equality definition of base value class. More...

class	ObjectPathPairNode
	Pair of `ObjectPath`s, one for each object being tested for structural equality. More...

class	ObjectPathPair

class	StructuralEqual
	Content-aware structural equality comparator for objects. More...

class	SEqualReducer
	A Reducer class to reduce the structural equality result of two objects. More...

class	SEqualHandlerDefault
	The default handler for equality testing. More...

class	BaseValueHash
	Hash definition of base value classes. More...

class	StructuralHash
	Content-aware structural hashing. More...

class	SHashReducer
	A Reducer class to reduce the structural hash value. More...

class	SHashHandlerDefault
	The default handler for hash key computation. More...

struct	NDArrayContainerTrait

class	AttrRegistry

class	With
	RAII wrapper function to enter and exit a context object similar to python's with syntax. More...

class	CompilationConfigNode
	Gathers the `Targets` and distinguished `VirtualDevices` in canonical form needed to compile a Relay module for execution over possibly heterogeneous devices. Centralizes the validation and canonicalization logic needed to transition from targets supplied by the Python APIs to a single internal representation. Also holds a cache of canonical `VirtualDevices` so that structural equal virtual devices have pointer equal canonical virtual devices. More...

class	CompilationConfig
	Managed reference class to `CompilationConfig`. More...

class	GenericFunc
	Generic function that can be specialized on a per-target basis. More...

class	GenericFuncNode
	Represents a generic function that can be specialized on a per-target basis. More...

class	TargetTagNode
	A target tag. More...

class	TargetTag
	Managed reference class to TargetTagNode. More...

class	TargetTagRegEntry

class	TargetNode
	Compilation target. More...

class	Target
	Managed reference class to TargetNode. More...

class	MemoryInfoNode
	Memory information of special memory region. Use MemoryInfo as its container type. More...

class	MemoryInfo
	Defines memory info. More...

class	TargetKindAttrMap
	Map<TargetKind, ValueType> used to store meta-information about TargetKind. More...

class	TargetKindNode
	Target kind, specifies the kind of the target. More...

class	TargetKind
	Managed reference class to TargetKindNode. More...

class	TargetKindRegEntry
	Helper structure to register TargetKind. More...

class	VirtualDeviceNode
	Describes at compile time the constraints on where data is to be stored at runtime down to the (virtual) device and memory scope level, and how to compile code to compute that data. Used by the `PlanDevices` pass to collect and solve (virtual) device constraints for the whole Relay program. More...

class	VirtualDevice
	Managed reference class to `VirtualDeviceNode`. More...

class	VirtualDeviceCache
	A cache of `VirtualDevices`. This can be used: More...

Typedefs
using	TypeRelationFn = TypedEnvFunc< bool(const Array< Type > &args, int num_inputs, const Attrs &attrs, const TypeReporter &reporter)>
	User defined type constraint function. More...

using	DataType = runtime::DataType

using	Device = DLDevice

using	TargetFeatures = Map< String, ObjectRef >
	Map containing parsed features of a specific Target. More...

using	TargetJSON = Map< String, ObjectRef >
	TargetParser to apply on instantiation of a given TargetKind. More...

using	FTVMTargetParser = runtime::TypedPackedFunc< TargetJSON(TargetJSON)>

using	MemoryScope = String

Enumerations
enum class	DiagnosticLevel : int { kBug = 10 , kError = 20 , kWarning = 30 , kNote = 40 , kHelp = 50 }
	The diagnostic level, controls the printing of the message. More...

enum class	CallingConv : int { kDefault = 0 , kCPackedFunc = 1 , kDeviceKernelLaunch = 2 }
	Possible Calling conventions. More...

enum	TypeKind : int { kType = 0 , kShapeVar = 1 , kBaseType = 2 , kConstraint = 4 , kAdtHandle = 5 , kTypeData = 6 }
	Possible kinds of TypeVars. More...

Functions
transform::Sequential	MixedModulePassManager (IRModule mixed_mod, Target target)
	Configures and returns the composite Pass for the fused module (pre split) that contains device and host code. More...

transform::Sequential	DeviceModulePassManager (IRModule mixed_mod, Target target)
	Configures and returns the composite Pass for the device Target after device/host from mixed module. More...

transform::Sequential	HostModulePassManager (IRModule mixed_mod, Target target_host)
	Configures and returns the composite Pass for the host Target after device/host from mixed module. More...

IRModule	LowerModule (IRModule mod, bool simple_mode=false)
	Lower an IRModule (optimize with it with the pass list defined in CreatePassList) More...

IRModule	LowerPrimFunc (tvm::tir::PrimFunc func, const std::string &name, bool simple_mode=false)
	Lower a primfunc and name (convert to IRModule, and optimize it with the pass list defined in CreatePassList) More...

IRModule	LowerSchedule (te::Schedule sch, const Array< te::Tensor > &args, const std::string &name, const std::unordered_map< te::Tensor, tir::Buffer > &binds, GlobalVarSupply global_var_supply, bool simple_mode=false)
	Build an IRModule given a TE schedule, args and binds. This function also applies the lowering passes defined in CreatePassList. More...

IRModule	LowerSchedule (te::Schedule sch, const Array< ObjectRef > &args, const std::string &name, const std::unordered_map< te::Tensor, tir::Buffer > &binds, GlobalVarSupply global_var_supply, bool simple_mode=false)
	Build an IRModule given a TE schedule, args and binds. This function also applies the lowering passes defined in CreatePassList. More...

IRModule	ScheduleToModule (te::Schedule sch, const Array< ObjectRef > &args, const std::string &name, const std::unordered_map< te::Tensor, tir::Buffer > &binds, GlobalVarSupply global_var_supply)
	Create an IRModule out of a TE Schedule. It does not apply lowering passes. If you want to apply lowering passes as well, use LowerSchedule. More...

runtime::Module	build (const IRModule &funcs, const Target &target, const Target &target_host)
	Build a device and host module for a specific target from an IRModule. More...

runtime::Module	build (const Map< Target, IRModule > &input, const Target &target_host)
	Build a device and host module for a specific target from a map contains target to IRModule. This function is used for heterogeneous build. More...

runtime::Module	build (const Map< String, IRModule > &input, const Target &target_host)
	Build a device and host module for a specific target from a map contains target to IRModule. This function is used for heterogeneous build. More...

template<typename TObjectRef >
TObjectRef	NullValue ()
	Create a NodeRef type that represents null. More...

template<>
DataType	NullValue< DataType > ()

template<typename TAttrs >
TAttrs	AttrsWithDefaultValues ()
	Create an Attr object with all default values. More...

template<typename TFunc >
TFunc	WithAttr (TFunc input, const std::string &attr_key, ObjectRef attr_value)
	Copy the function or module, but overrides the attribute value key with the value. More...

template<typename TFunc >
TFunc	WithAttrs (TFunc input, Map< String, ObjectRef > attrs)
	Copy the function or module, but overrides the attributes with the entries from `attrs`. More...

template<typename TFunc >
TFunc	WithoutAttr (TFunc input, const std::string &attr_key)
	Copy the function or module, but removes the specified attribute. More...

DiagnosticRenderer	TerminalRenderer (std::ostream &ostream)

PrimExpr	operator+ (PrimExpr a, PrimExpr b)
	add operator More...

PrimExpr	operator- (PrimExpr a, PrimExpr b)
	subtraction operator More...

PrimExpr	operator- (PrimExpr a)
	negation. More...

PrimExpr	operator* (PrimExpr a, PrimExpr b)
	multiplication operator More...

PrimExpr	operator/ (PrimExpr a, PrimExpr b)
	division operator More...

PrimExpr	operator<< (PrimExpr a, PrimExpr b)
	left shift operator More...

PrimExpr	operator>> (PrimExpr a, PrimExpr b)
	right shift operator More...

PrimExpr	operator> (PrimExpr a, PrimExpr b)
	greater More...

PrimExpr	operator>= (PrimExpr a, PrimExpr b)
	greater_equal More...

PrimExpr	operator< (PrimExpr a, PrimExpr b)
	less More...

PrimExpr	operator<= (PrimExpr a, PrimExpr b)
	less_equal More...

PrimExpr	operator== (PrimExpr a, PrimExpr b)
	equal More...

PrimExpr	operator!= (PrimExpr a, PrimExpr b)
	not_equal More...

PrimExpr	operator&& (PrimExpr a, PrimExpr b)
	and More...

PrimExpr	operator\|\| (PrimExpr a, PrimExpr b)
	or More...

PrimExpr	operator! (PrimExpr a)
	not More...

PrimExpr	operator& (PrimExpr a, PrimExpr b)
	take bitwise and of two values More...

PrimExpr	operator\| (PrimExpr a, PrimExpr b)
	take bitwise or of two values More...

PrimExpr	operator^ (PrimExpr a, PrimExpr b)
	take bitwise xor of two values More...

PrimExpr	operator~ (PrimExpr a)
	take bitwise negation of two values More...

Bool	operator\|\| (const Bool &a, bool b)

Bool	operator\|\| (bool a, const Bool &b)

Bool	operator\|\| (const Bool &a, const Bool &b)

Bool	operator&& (const Bool &a, bool b)

Bool	operator&& (bool a, const Bool &b)

Bool	operator&& (const Bool &a, const Bool &b)

bool	operator== (const Bool &a, bool b)

bool	operator== (bool a, const Bool &b)

bool	operator== (const Bool &a, const Bool &b)

bool	IsPrimitiveOp (const RelayExpr &expr)
	Check that an expression is a "primitive operator". More...

String	TypeKind2String (TypeKind kind)
	Converts a TypeKind to a string. More...

Type	VoidType ()

bool	IsVoidType (const Type &type)
	Check whether the tyep represents void. More...

Type	Bind (const Type &type, const Map< TypeVar, Type > &args_map)
	Bind free type variables in the type. More...

Optional< String >	GetAttrKeyByAddress (const Object object, const void attr_address)
	Given an object and an address of its attribute, return the key of the attribute. More...

void	Dump (const runtime::ObjectRef &node)
	Dump the node to stderr, used for debug purposes. More...

void	Dump (const runtime::Object *node)
	Dump the node to stderr, used for debug purposes. More...

std::string	SaveJSON (const runtime::ObjectRef &node)
	save the node as well as all the node it depends on as json. This can be used to serialize any TVM object More...

runtime::ObjectRef	LoadJSON (std::string json_str)
	Internal implementation of LoadJSON Load tvm Node object from json and return a shared_ptr of Node. More...

GlobalVar	WithFields (GlobalVar global_var, Optional< String > opt_name_hint={}, Optional< Type > opt_type={}, Optional< VirtualDevice > opt_virtual_device={}, Optional< Span > opt_span={})
	Returns `global_var` with the given properties. A null property denotes 'no change'. Returns `global_var` if all properties are unchanged. Otherwise, returns a copy with the new fields. More...

void	CheckAndUpdateHostConsistency (Target target, Target host)
	Check and update host field of the given legacy target and target host pair. Note that this function is for legacy target api compatibility issue only, not recommended for other use. More...

MemoryInfo	GetMemoryInfo (const std::string &scope)
	get memory info given scope More...

Type	GetType (const PrimExpr &expr)
	Get the type of the expression under the unified type system. More...

Type	GetTypeFromRuntimeDataType (const DataType &dtype)
	Get the type corresponding to DataType. More...

runtime::DataType	GetRuntimeDataType (const Type &type)
	Get the implied DataType for storing values with type during runtime. More...

PrimExpr	ret (PrimExpr value, Span span=Span())
	Return the value. More...

PrimExpr	max_value (const DataType &dtype, Span span=Span())

PrimExpr	min_value (const DataType &dtype, Span span=Span())

PrimExpr	infinity (const DataType &dtype, Span span=Span())

PrimExpr	cast (const DataType &t, PrimExpr value, Span span=Span())
	cast value to type. More...

PrimExpr	reinterpret (const DataType &t, PrimExpr value, Span span=Span())
	perform reinterpret cast value to type. More...

PrimExpr	add (PrimExpr a, PrimExpr b, Span span=Span())
	add operator More...

PrimExpr	sub (PrimExpr a, PrimExpr b, Span span=Span())
	subtraction operator More...

PrimExpr	neg (PrimExpr a, Span span=Span())
	negation. More...

PrimExpr	mul (PrimExpr a, PrimExpr b, Span span=Span())
	multiplication operator More...

PrimExpr	left_shift (PrimExpr a, PrimExpr b, Span span=Span())
	left shift operator More...

PrimExpr	right_shift (PrimExpr a, PrimExpr b, Span span=Span())
	right shift operator More...

PrimExpr	greater (PrimExpr a, PrimExpr b, Span span=Span())
	greater More...

PrimExpr	greater_equal (PrimExpr a, PrimExpr b, Span span=Span())
	greater_equal More...

PrimExpr	less (PrimExpr a, PrimExpr b, Span span=Span())
	less More...

PrimExpr	less_equal (PrimExpr a, PrimExpr b, Span span=Span())
	less_equal More...

PrimExpr	equal (PrimExpr a, PrimExpr b, Span span=Span())
	equal More...

PrimExpr	not_equal (PrimExpr a, PrimExpr b, Span span=Span())
	not_equal More...

PrimExpr	logical_and (PrimExpr a, PrimExpr b, Span span=Span())
	and More...

PrimExpr	logical_or (PrimExpr a, PrimExpr b, Span span=Span())
	or More...

PrimExpr	logical_not (PrimExpr a, Span span=Span())
	not More...

PrimExpr	div (PrimExpr a, PrimExpr b, Span span=Span())
	compute division in C semantics. More...

PrimExpr	truncdiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute trunc(a / b) More...

PrimExpr	truncmod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder of truncdiv More...

PrimExpr	indexdiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute floor(a / b) where a and b are non-negative. More...

PrimExpr	shapediv (PrimExpr a, PrimExpr b, Span span=Span())
	compute ceil(a / b) where a and b are non-negative. More...

PrimExpr	indexmod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder floor(a / b) where a and b are non-negative. More...

PrimExpr	floordiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute floor(a / b) More...

PrimExpr	ceildiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute ceil(a / b) More...

PrimExpr	floormod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder of floordiv More...

PrimExpr	max (PrimExpr a, PrimExpr b, Span span=Span())
	take maximum of two values More...

PrimExpr	min (PrimExpr a, PrimExpr b, Span span=Span())
	take minimum of two values More...

PrimExpr	bitwise_and (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise and of two values More...

PrimExpr	bitwise_or (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise or of two values More...

PrimExpr	bitwise_xor (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise xor of two values More...

PrimExpr	bitwise_neg (PrimExpr a, Span span=Span())
	take bitwise negation of two values More...

PrimExpr	if_then_else (PrimExpr cond, PrimExpr true_value, PrimExpr false_value, Span span=Span())
	Conditional expression. More...

PrimExpr	likely (PrimExpr cond, Span span=Span())
	Mark condition as likely. More...

PrimExpr	pow (PrimExpr x, PrimExpr y, Span span=Span())
	Calculate power(x, y) More...

PrimExpr	abs (PrimExpr x, Span span=Span())
	Calculate absolute value of x. More...

PrimExpr	isnan (PrimExpr x, Span span=Span())
	Check if x is NaN. More...

PrimExpr	isfinite (PrimExpr x, Span span=Span())
	Check if x is finite. More...

PrimExpr	isinf (PrimExpr x, Span span=Span())
	Check if x is infinite. More...

PrimExpr	sum (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	sum of source expression over axis More...

PrimExpr	all (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	logical And of source expression over axis More...

PrimExpr	any (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	logical Or of source expression over axis More...

PrimExpr	max (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	max of source expression over axis More...

PrimExpr	min (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	max of source expression over axis More...

PrimExpr	prod (PrimExpr source, Array< tir::IterVar > axis, Array< PrimExpr > init={}, Span span=Span())
	product of source expression over axis More...

PrimExpr	floor (PrimExpr x, Span span=Span())
	Calculate floor(x) More...

PrimExpr	ceil (PrimExpr x, Span span=Span())
	Calculate ceil(x) More...

PrimExpr	round (PrimExpr x, Span span=Span())
	Calculate round(x) More...

PrimExpr	nearbyint (PrimExpr x, Span span=Span())
	Calculates std::nearbyint(x) More...

PrimExpr	trunc (PrimExpr x, Span span=Span())
	Calculate trunc(x) More...

PrimExpr	LargeUIntImm (DataType dtype, int64_t low, int64_t high, Span span=Span())
	Construct a large uint constant by its low 32 bits and high 32bits. More...

PrimExpr	q_multiply_shift (PrimExpr x, PrimExpr y, PrimExpr q, PrimExpr s, Span span=Span())
	Execute a multiplication between two Q-numbers x and y followed by a right shift s. The mathematical expression is: More...

PrimExpr	fast_erf_float_expr (PrimExpr arg, int bits)
	Fast_erf_float expression from Eigen. More...

PrimExpr	exp (PrimExpr x, Span span=Span())

PrimExpr	exp2 (PrimExpr x, Span span=Span())

PrimExpr	exp10 (PrimExpr x, Span span=Span())

PrimExpr	erf (PrimExpr x, Span span=Span())

PrimExpr	tanh (PrimExpr x, Span span=Span())

PrimExpr	sigmoid (PrimExpr x, Span span=Span())

PrimExpr	sqrt (PrimExpr x, Span span=Span())

PrimExpr	rsqrt (PrimExpr x, Span span=Span())

PrimExpr	log (PrimExpr x, Span span=Span())

PrimExpr	log2 (PrimExpr x, Span span=Span())

PrimExpr	log10 (PrimExpr x, Span span=Span())

PrimExpr	log1p (PrimExpr x, Span span=Span())

PrimExpr	popcount (PrimExpr x, Span span=Span())

PrimExpr	tan (PrimExpr x, Span span=Span())

PrimExpr	cos (PrimExpr x, Span span=Span())

PrimExpr	cosh (PrimExpr x, Span span=Span())

PrimExpr	sin (PrimExpr x, Span span=Span())

PrimExpr	sinh (PrimExpr x, Span span=Span())

PrimExpr	asin (PrimExpr x, Span span=Span())

PrimExpr	acos (PrimExpr x, Span span=Span())

PrimExpr	atan (PrimExpr x, Span span=Span())

PrimExpr	acosh (PrimExpr x, Span span=Span())

PrimExpr	asinh (PrimExpr x, Span span=Span())

PrimExpr	atanh (PrimExpr x, Span span=Span())

PrimExpr	clz (PrimExpr x, Span span=Span())

PrimExpr	atan2 (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	nextafter (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	copysign (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	hypot (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	ldexp (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	operator+= (PrimExpr &a, PrimExpr b)

PrimExpr	operator-= (PrimExpr &a, PrimExpr b)

PrimExpr	operator*= (PrimExpr &a, PrimExpr b)

PrimExpr	operator+ (const PrimExpr &a, float b)

PrimExpr	operator+ (float a, const PrimExpr &b)

PrimExpr	operator+ (int a, const PrimExpr &b)

PrimExpr	operator+ (const PrimExpr &a, int b)

PrimExpr	operator+ (const PrimExpr &a, double b)

PrimExpr	operator- (const PrimExpr &a, float b)

PrimExpr	operator- (float a, const PrimExpr &b)

PrimExpr	operator- (int a, const PrimExpr &b)

PrimExpr	operator- (const PrimExpr &a, int b)

PrimExpr	operator- (const PrimExpr &a, double b)

PrimExpr	operator* (const PrimExpr &a, float b)

PrimExpr	operator* (float a, const PrimExpr &b)

PrimExpr	operator* (int a, const PrimExpr &b)

PrimExpr	operator* (const PrimExpr &a, int b)

PrimExpr	operator* (const PrimExpr &a, double b)

PrimExpr	operator> (const PrimExpr &a, float b)

PrimExpr	operator> (float a, const PrimExpr &b)

PrimExpr	operator> (int a, const PrimExpr &b)

PrimExpr	operator> (const PrimExpr &a, int b)

PrimExpr	operator> (const PrimExpr &a, double b)

PrimExpr	operator>= (const PrimExpr &a, float b)

PrimExpr	operator>= (float a, const PrimExpr &b)

PrimExpr	operator>= (int a, const PrimExpr &b)

PrimExpr	operator>= (const PrimExpr &a, int b)

PrimExpr	operator>= (const PrimExpr &a, double b)

PrimExpr	operator< (const PrimExpr &a, float b)

PrimExpr	operator< (float a, const PrimExpr &b)

PrimExpr	operator< (int a, const PrimExpr &b)

PrimExpr	operator< (const PrimExpr &a, int b)

PrimExpr	operator< (const PrimExpr &a, double b)

PrimExpr	operator<= (const PrimExpr &a, float b)

PrimExpr	operator<= (float a, const PrimExpr &b)

PrimExpr	operator<= (int a, const PrimExpr &b)

PrimExpr	operator<= (const PrimExpr &a, int b)

PrimExpr	operator<= (const PrimExpr &a, double b)

PrimExpr	max (const PrimExpr &a, float b, Span span=Span())

PrimExpr	max (float a, const PrimExpr &b, Span span=Span())

PrimExpr	max (int a, const PrimExpr &b, Span span=Span())

PrimExpr	max (const PrimExpr &a, int b, Span span=Span())

PrimExpr	max (const PrimExpr &a, double b, Span span=Span())

PrimExpr	min (const PrimExpr &a, float b, Span span=Span())

PrimExpr	min (float a, const PrimExpr &b, Span span=Span())

PrimExpr	min (int a, const PrimExpr &b, Span span=Span())

PrimExpr	min (const PrimExpr &a, int b, Span span=Span())

PrimExpr	min (const PrimExpr &a, double b, Span span=Span())

PrimExpr	div (const PrimExpr &a, float b, Span span=Span())

PrimExpr	div (float a, const PrimExpr &b, Span span=Span())

PrimExpr	div (int a, const PrimExpr &b, Span span=Span())

PrimExpr	div (const PrimExpr &a, int b, Span span=Span())

PrimExpr	div (const PrimExpr &a, double b, Span span=Span())

PrimExpr	add (const PrimExpr &a, float b, Span span=Span())

PrimExpr	add (float a, const PrimExpr &b, Span span=Span())

PrimExpr	add (int a, const PrimExpr &b, Span span=Span())

PrimExpr	add (const PrimExpr &a, int b, Span span=Span())

PrimExpr	add (const PrimExpr &a, double b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, float b, Span span=Span())

PrimExpr	sub (float a, const PrimExpr &b, Span span=Span())

PrimExpr	sub (int a, const PrimExpr &b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, int b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, double b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, float b, Span span=Span())

PrimExpr	mul (float a, const PrimExpr &b, Span span=Span())

PrimExpr	mul (int a, const PrimExpr &b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, int b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, double b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, float b, Span span=Span())

PrimExpr	greater (float a, const PrimExpr &b, Span span=Span())

PrimExpr	greater (int a, const PrimExpr &b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, int b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, double b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, float b, Span span=Span())

PrimExpr	greater_equal (float a, const PrimExpr &b, Span span=Span())

PrimExpr	greater_equal (int a, const PrimExpr &b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, int b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, double b, Span span=Span())

PrimExpr	less (const PrimExpr &a, float b, Span span=Span())

PrimExpr	less (float a, const PrimExpr &b, Span span=Span())

PrimExpr	less (int a, const PrimExpr &b, Span span=Span())

PrimExpr	less (const PrimExpr &a, int b, Span span=Span())

PrimExpr	less (const PrimExpr &a, double b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, float b, Span span=Span())

PrimExpr	less_equal (float a, const PrimExpr &b, Span span=Span())

PrimExpr	less_equal (int a, const PrimExpr &b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, int b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, double b, Span span=Span())

PrimExpr	indexdiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	indexdiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	indexmod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	indexmod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	truncdiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	truncdiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	truncmod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	truncmod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	floordiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	floordiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	floormod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	floormod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	right_shift (const PrimExpr &a, int b, Span span=Span())

PrimExpr	right_shift (int a, const PrimExpr &b, Span span=Span())

PrimExpr	left_shift (const PrimExpr &a, int b, Span span=Span())

PrimExpr	left_shift (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_and (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_and (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_or (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_or (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_xor (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_xor (int a, const PrimExpr &b, Span span=Span())

PrimExpr	operator>> (const PrimExpr &a, int b)

PrimExpr	operator>> (int a, const PrimExpr &b)

PrimExpr	operator<< (const PrimExpr &a, int b)

PrimExpr	operator<< (int a, const PrimExpr &b)

PrimExpr	operator& (const PrimExpr &a, int b)

PrimExpr	operator& (int a, const PrimExpr &b)

PrimExpr	operator\| (const PrimExpr &a, int b)

PrimExpr	operator\| (int a, const PrimExpr &b)

PrimExpr	operator^ (const PrimExpr &a, int b)

PrimExpr	operator^ (int a, const PrimExpr &b)

PrimExpr	operator&& (const PrimExpr &a, bool b)

PrimExpr	operator&& (bool a, const PrimExpr &b)

PrimExpr	operator\|\| (const PrimExpr &a, bool b)

PrimExpr	operator\|\| (bool a, const PrimExpr &b)

PrimExpr	logical_and (const PrimExpr &a, bool b, Span span=Span())

PrimExpr	logical_and (bool a, const PrimExpr &b, Span span=Span())

PrimExpr	logical_or (const PrimExpr &a, bool b, Span span=Span())

PrimExpr	logical_or (bool a, const PrimExpr &b, Span span=Span())

template<typename TA >
void	DivAmbiguityError (const TA &a)
	Helper function to raise a compiler error about division ambiguity. More...

template<typename TB >
PrimExpr	operator/ (const PrimExpr &a, const TB &b)

template<typename TB >
PrimExpr	operator/= (const PrimExpr &a, const TB &b)

template<typename TB >
PrimExpr	operator% (const PrimExpr &a, const TB &b)

Variables
constexpr runtime::NullOptType	NullOpt {}

constexpr int	kNullDeviceType = 0

constexpr int	kInvalidDeviceType = -1

constexpr const char *	kVirtualDevice = "virtual_device"

constexpr const char *	kUSMPEnableOption = "tir.usmp.enable"
	PassContext option to enable the USMP. More...

constexpr const char *	kUSMPAlgorithmOption = "tir.usmp.algorithm"
	PassContext option to select the memory planning algorithm in USMP. More...

constexpr const char *	kUSMPUseWorkspaceIO = "tir.usmp.use_workspace_io"
	PassContext option to enable placing I/O tensors in the workspace. More...

constexpr const char *	kUSMPCustomAlgorithmOption = "tir.usmp.custom_algorithm"
	PassContext option to specify a custom memory planning algorithm in USMP. The algorithm should be provided as registered PackedFunc with the name tir.usmp.algorithm.NAME. More...

Detailed Description

runtime implementation for LibTorch/TorchScript.

An object that builds and maintains block scope and StmtSref mapping for Dependence analysis.

Performance counters for profiling via the PAPI library.

Typedef Documentation

◆ DataType

using tvm::DataType = typedef runtime::DataType

◆ Device

using tvm::Device = typedef DLDevice

◆ FTVMTargetParser

using tvm::FTVMTargetParser = typedef runtime::TypedPackedFunc<TargetJSON(TargetJSON)>

◆ MemoryScope

using tvm::MemoryScope = typedef String

Abstract label for an area of memory.

Currently uninterpreted and arbitrary. Likely to be replaced by a structured representation of a memory pool in the future. Please try to use this alias instead of String to aid future code migration.

◆ TargetFeatures

using tvm::TargetFeatures = typedef Map<String, ObjectRef>

Map containing parsed features of a specific Target.

◆ TargetJSON

using tvm::TargetJSON = typedef Map<String, ObjectRef>

TargetParser to apply on instantiation of a given TargetKind.

Parameters

target_json Target in JSON format to be transformed during parsing.

Returns: The transformed Target JSON object.

◆ TypeRelationFn

using tvm::TypeRelationFn = typedef TypedEnvFunc<bool(const Array<Type>& args, int num_inputs, const Attrs& attrs, const TypeReporter& reporter)>

User defined type constraint function.

If the input type information can be used to fully decide the IncompleteTypes, then the function should call reporter.Assign to report the new types, and return true. Otherwise, the function should return false.

Parameters

args	The arguments to the relation. The types are stored in the form of [input_type_0, input_type_1, ... input_type_n, output_type_0, output_type_1, ... output_type_m]
num_inputs	Number of input types in the args.
attrs	The additional attributes of the operator.
reporter	The reporter to report solution to.

Returns: false if This relation cannot be resolved. true if this relation has been resolved.

Enumeration Type Documentation

◆ CallingConv

enum tvm::CallingConv : int

strong

Possible Calling conventions.

NOTE: The calling convention also implies the way we implement the function during lowering.

Enumerator

kDefault

Default calling convention.

Uses the native calling convention of the target.
Implementation: specified by the native target.

kCPackedFunc

PackedFunc that exposes a CPackedFunc signature.

Calling by PackedFunc calling convention.
Implementation: Expose a function with the CPackedFunc signature.

kDeviceKernelLaunch

Device kernel launch.

Call by PackedFunc calling convention.
Implementation: defined by device runtime(e.g. runtime/cuda)

◆ DiagnosticLevel

enum tvm::DiagnosticLevel : int

strong

The diagnostic level, controls the printing of the message.

Enumerator
kBug
kError
kWarning
kNote
kHelp

◆ TypeKind

enum tvm::TypeKind : int

Possible kinds of TypeVars.

Enumerator
kType
kShapeVar	Template variable in shape expression.
kBaseType
kConstraint
kAdtHandle
kTypeData

Function Documentation

◆ abs()

PrimExpr tvm::abs	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate absolute value of x.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The aboslute value of input data x

◆ acos()

PrimExpr tvm::acos	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ acosh()

PrimExpr tvm::acosh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ add() [1/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ add() [2/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ add() [3/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ add() [4/6]

PrimExpr tvm::add	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ add() [5/6]

PrimExpr tvm::add	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ add() [6/6]

PrimExpr tvm::add	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

add operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ all()

PrimExpr tvm::all	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

logical And of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

◆ any()

PrimExpr tvm::any	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

logical Or of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ asin()

PrimExpr tvm::asin	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ asinh()

PrimExpr tvm::asinh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ atan()

PrimExpr tvm::atan	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ atan2()

PrimExpr tvm::atan2	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ atanh()

PrimExpr tvm::atanh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ AttrsWithDefaultValues()

template<typename TAttrs >

TAttrs tvm::AttrsWithDefaultValues ( )

inline

Create an Attr object with all default values.

Template Parameters

TAttrNode the type to be created.

Returns: A instance that will represent None.

◆ Bind()

Type tvm::Bind	(	const Type &	type,
		const Map< TypeVar, Type > &	args_map
	)

Bind free type variables in the type.

Parameters

type	The type to be updated.
args_map	The binding map.

◆ bitwise_and() [1/3]

PrimExpr tvm::bitwise_and	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_and() [2/3]

PrimExpr tvm::bitwise_and	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_and() [3/3]

PrimExpr tvm::bitwise_and	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise and of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_neg()

PrimExpr tvm::bitwise_neg	(	PrimExpr	a,
		Span	span = `Span()`
	)

take bitwise negation of two values

Parameters

a	the input expression.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_or() [1/3]

PrimExpr tvm::bitwise_or	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_or() [2/3]

PrimExpr tvm::bitwise_or	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_or() [3/3]

PrimExpr tvm::bitwise_or	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise or of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_xor() [1/3]

PrimExpr tvm::bitwise_xor	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_xor() [2/3]

PrimExpr tvm::bitwise_xor	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_xor() [3/3]

PrimExpr tvm::bitwise_xor	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise xor of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ build() [1/3]

runtime::Module tvm::build	(	const IRModule &	funcs,
		const Target &	target,
		const Target &	target_host
	)

Build a device and host module for a specific target from an IRModule.

Parameters

funcs	The functions to be built.
target	The target device to build for.
target_host	The target for building host code. To use the default, pass Target()

Returns: The built module.

◆ build() [2/3]

runtime::Module tvm::build	(	const Map< String, IRModule > &	input,
		const Target &	target_host
	)

Build a device and host module for a specific target from a map contains target to IRModule. This function is used for heterogeneous build.

Parameters

input	The map contains target string to an IRModule.
target_host	The target for building host code. To use the default, pass Target().

Returns: The built module that contains code for different processors.

◆ build() [3/3]

runtime::Module tvm::build	(	const Map< Target, IRModule > &	input,
		const Target &	target_host
	)

Build a device and host module for a specific target from a map contains target to IRModule. This function is used for heterogeneous build.

Parameters

input	The map contains target to an IRModule.
target_host	The target for building host code. To use the default, pass Target().

Returns: The built module that contains code for different processors.

◆ cast()

PrimExpr tvm::cast	(	const DataType &	t,
		PrimExpr	value,
		Span	span = `Span()`
	)

cast value to type.

Parameters

t	the target type.
value	The value
span	The location of this operation in the source.

Returns: The result expression.

Note: This function may return value if the type is the same.

◆ ceil()

PrimExpr tvm::ceil	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate ceil(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ ceildiv()

PrimExpr tvm::ceildiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute ceil(a / b)

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ CheckAndUpdateHostConsistency()

void tvm::CheckAndUpdateHostConsistency	(	Target *	target,
		Target *	host
	)

Check and update host field of the given legacy target and target host pair. Note that this function is for legacy target api compatibility issue only, not recommended for other use.

Parameters

target	The pointer to a Target typed object with host field to be updated
host	The pointer to a Target typed object for target host to be updated

◆ clz()

PrimExpr tvm::clz	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ copysign()

PrimExpr tvm::copysign	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ cos()

PrimExpr tvm::cos	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ cosh()

PrimExpr tvm::cosh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ DeviceModulePassManager()

transform::Sequential tvm::DeviceModulePassManager	(	IRModule	mixed_mod,
		Target	target
	)

Configures and returns the composite Pass for the device Target after device/host from mixed module.

Parameters

mixed_mod	The optimized mixed module.
target	The device Target.

Returns: The composite Pass for the device module.

◆ div() [1/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ div() [2/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ div() [3/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ div() [4/6]

PrimExpr tvm::div	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ div() [5/6]

PrimExpr tvm::div	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ div() [6/6]

PrimExpr tvm::div	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute division in C semantics.

a / b as in C/C++.

When operands are integers, it directly corresponds to truncdiv.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ DivAmbiguityError()

template<typename TA >

void tvm::DivAmbiguityError ( const TA & a )

inline

Helper function to raise a compiler error about division ambiguity.

Note: The call to this function will always results in a compiler error.

Template Parameters

TA	Any class type.

◆ Dump() [1/2]

void tvm::Dump ( const runtime::Object * node )

Dump the node to stderr, used for debug purposes.

Parameters

node	The input node

◆ Dump() [2/2]

void tvm::Dump ( const runtime::ObjectRef & node )

Dump the node to stderr, used for debug purposes.

Parameters

node	The input node

◆ equal()

PrimExpr tvm::equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ erf()

PrimExpr tvm::erf	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp()

PrimExpr tvm::exp	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp10()

PrimExpr tvm::exp10	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp2()

PrimExpr tvm::exp2	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ fast_erf_float_expr()

PrimExpr tvm::fast_erf_float_expr	(	PrimExpr	arg,
		int	bits
	)

Fast_erf_float expression from Eigen.

Parameters

arg	The input expression.
bits	The number of bits in the type.

Returns: The constructed expression.

◆ floor()

PrimExpr tvm::floor	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate floor(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ floordiv() [1/3]

PrimExpr tvm::floordiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ floordiv() [2/3]

PrimExpr tvm::floordiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ floordiv() [3/3]

PrimExpr tvm::floordiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute floor(a / b)

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ floormod() [1/3]

PrimExpr tvm::floormod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ floormod() [2/3]

PrimExpr tvm::floormod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ floormod() [3/3]

PrimExpr tvm::floormod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder of floordiv

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ GetAttrKeyByAddress()

Optional<String> tvm::GetAttrKeyByAddress	(	const Object *	object,
		const void *	attr_address
	)

Given an object and an address of its attribute, return the key of the attribute.

Returns: nullptr if no attribute with the given address exists.

◆ GetMemoryInfo()

MemoryInfo tvm::GetMemoryInfo ( const std::string & scope )

get memory info given scope

Parameters

scope The scope name.

Returns: info The memory info.

◆ GetRuntimeDataType()

runtime::DataType tvm::GetRuntimeDataType ( const Type & type )

Get the implied DataType for storing values with type during runtime.

Parameters

type	The input type.

Returns: The result runtime::DataType.

See also: tvm/ir/type.h for discussion about the relation between Type and runtime::DataType.

◆ GetType()

Type tvm::GetType ( const PrimExpr & expr )

Get the type of the expression under the unified type system.

This function could return a more refined type than the runtime type provided by expr->dtype

Parameters

expr	The input parameter.

Returns: The result type.

See also: tvm/ir/type.h for discussion about the relation between Type and runtime::DataType.

◆ GetTypeFromRuntimeDataType()

Type tvm::GetTypeFromRuntimeDataType ( const DataType & dtype )

Get the type corresponding to DataType.

Parameters

dtype The data type

Returns: The result type

See also: tvm/ir/type.h for discussion about the relation between Type and runtime::DataType.

◆ greater() [1/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ greater() [2/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ greater() [3/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ greater() [4/6]

PrimExpr tvm::greater	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater() [5/6]

PrimExpr tvm::greater	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater() [6/6]

PrimExpr tvm::greater	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

greater

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ greater_equal() [1/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [2/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [3/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [4/6]

PrimExpr tvm::greater_equal	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [5/6]

PrimExpr tvm::greater_equal	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [6/6]

PrimExpr tvm::greater_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

greater_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ HostModulePassManager()

transform::Sequential tvm::HostModulePassManager	(	IRModule	mixed_mod,
		Target	target_host
	)

Configures and returns the composite Pass for the host Target after device/host from mixed module.

Parameters

mixed_mod	The optimized mixed module.
target_host	The host Target.

Returns: The composite Pass for the host module.

◆ hypot()

PrimExpr tvm::hypot	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ if_then_else()

PrimExpr tvm::if_then_else	(	PrimExpr	cond,
		PrimExpr	true_value,
		PrimExpr	false_value,
		Span	span = `Span()`
	)

Conditional expression.

Parameters

cond	The condition
true_value	The value when results are true.
false_value	The value when results are false.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ indexdiv() [1/3]

PrimExpr tvm::indexdiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ indexdiv() [2/3]

PrimExpr tvm::indexdiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ indexdiv() [3/3]

PrimExpr tvm::indexdiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute floor(a / b) where a and b are non-negative.

Use this function for index split calculation.

This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ indexmod() [1/3]

PrimExpr tvm::indexmod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ indexmod() [2/3]

PrimExpr tvm::indexmod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ indexmod() [3/3]

PrimExpr tvm::indexmod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder floor(a / b) where a and b are non-negative.

Use this function for index split calculation. This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ infinity()

PrimExpr tvm::infinity	(	const DataType &	dtype,
		Span	span = `Span()`
	)

Get the value of infinity.

Parameters

dtype	The data type.
span	The location of this operation in the source.

Returns: the infinity value in this format.

◆ isfinite()

PrimExpr tvm::isfinite	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is finite.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ isinf()

PrimExpr tvm::isinf	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is infinite.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ isnan()

PrimExpr tvm::isnan	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is NaN.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ IsPrimitiveOp()

bool tvm::IsPrimitiveOp ( const RelayExpr & expr )

inline

Check that an expression is a "primitive operator".

Will return true if the expression is an operator which matches the form of primitive operators registered directly by the Relay codebase.

That is the arguments are all type variables, and there is a single type relation applied to the input and output types.

Parameters

expr	An expression.

Returns: Whether the expression is primitive op.

◆ IsVoidType()

bool tvm::IsVoidType ( const Type & type )

inline

Check whether the tyep represents void.

Returns: The check result.

◆ LargeUIntImm()

PrimExpr tvm::LargeUIntImm	(	DataType	dtype,
		int64_t	low,
		int64_t	high,
		Span	span = `Span()`
	)

Construct a large uint constant by its low 32 bits and high 32bits.

Parameters

dtype	The final data type.
low	The lower 32 bits.
high	The higher 32 bits.
span	The location of this operation in the source.

Returns: The constructed expression.

◆ ldexp()

PrimExpr tvm::ldexp	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ left_shift() [1/3]

PrimExpr tvm::left_shift	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ left_shift() [2/3]

PrimExpr tvm::left_shift	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ left_shift() [3/3]

PrimExpr tvm::left_shift	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

left shift operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ less() [1/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ less() [2/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ less() [3/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ less() [4/6]

PrimExpr tvm::less	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less() [5/6]

PrimExpr tvm::less	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less() [6/6]

PrimExpr tvm::less	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

less

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ less_equal() [1/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [2/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [3/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [4/6]

PrimExpr tvm::less_equal	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [5/6]

PrimExpr tvm::less_equal	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [6/6]

PrimExpr tvm::less_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

less_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ likely()

PrimExpr tvm::likely	(	PrimExpr	cond,
		Span	span = `Span()`
	)

Mark condition as likely.

Parameters

cond	The condition
span	The location of this operation in the source.

Returns: The marked expression.

◆ LoadJSON()

runtime::ObjectRef tvm::LoadJSON ( std::string json_str )

Internal implementation of LoadJSON Load tvm Node object from json and return a shared_ptr of Node.

Parameters

json_str The json string to load from.

Returns: The shared_ptr of the Node.

◆ log()

PrimExpr tvm::log	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log10()

PrimExpr tvm::log10	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log1p()

PrimExpr tvm::log1p	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log2()

PrimExpr tvm::log2	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ logical_and() [1/3]

PrimExpr tvm::logical_and	(	bool	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ logical_and() [2/3]

PrimExpr tvm::logical_and	(	const PrimExpr &	a,
		bool	b,
		Span	span = `Span()`
	)

inline

◆ logical_and() [3/3]

PrimExpr tvm::logical_and	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

and

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ logical_not()

PrimExpr tvm::logical_not	(	PrimExpr	a,
		Span	span = `Span()`
	)

not

Parameters

a	left operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ logical_or() [1/3]

PrimExpr tvm::logical_or	(	bool	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ logical_or() [2/3]

PrimExpr tvm::logical_or	(	const PrimExpr &	a,
		bool	b,
		Span	span = `Span()`
	)

inline

◆ logical_or() [3/3]

PrimExpr tvm::logical_or	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

or

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ LowerModule()

IRModule tvm::LowerModule	(	IRModule	mod,
		bool	simple_mode = `false`
	)

Lower an IRModule (optimize with it with the pass list defined in CreatePassList)

Parameters

mod	The IRmodule to lower
simple_mode	Disables the loop partition pass. Defaults to false.

Returns: The result module.

◆ LowerPrimFunc()

IRModule tvm::LowerPrimFunc	(	tvm::tir::PrimFunc	func,
		const std::string &	name,
		bool	simple_mode = `false`
	)

Lower a primfunc and name (convert to IRModule, and optimize it with the pass list defined in CreatePassList)

Parameters

func	The PrimFunc to lower
name	The name of the lowered function.
simple_mode	Disables the loop partition pass. Defaults to false.

Returns: The result module.

◆ LowerSchedule() [1/2]

IRModule tvm::LowerSchedule	(	te::Schedule	sch,
		const Array< ObjectRef > &	args,
		const std::string &	name,
		const std::unordered_map< te::Tensor, tir::Buffer > &	binds,
		GlobalVarSupply	global_var_supply,
		bool	simple_mode = `false`
	)

Build an IRModule given a TE schedule, args and binds. This function also applies the lowering passes defined in CreatePassList.

Parameters

sch	The TE schedule to lower.
args	The arguments to the function (Array of Tensor, Buffer and Vars)
name	The name of the lowered function.
binds	Buffer assignments.
global_var_supply	The GlobalVarSupply to be used in the module.
simple_mode	Disables the loop partition pass. Defaults to false.

Returns: The result module.

◆ LowerSchedule() [2/2]

IRModule tvm::LowerSchedule	(	te::Schedule	sch,
		const Array< te::Tensor > &	args,
		const std::string &	name,
		const std::unordered_map< te::Tensor, tir::Buffer > &	binds,
		GlobalVarSupply	global_var_supply,
		bool	simple_mode = `false`
	)

Build an IRModule given a TE schedule, args and binds. This function also applies the lowering passes defined in CreatePassList.

Parameters

sch	The TE schedule to lower.
args	The arguments to the function.
name	The name of the lowered function.
binds	Buffer assignments.
global_var_supply	The GlobalVarSupply to be used in the module.
simple_mode	Disables the loop partition pass. Defaults to false.

Returns: The result module.

◆ max() [1/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ max() [2/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ max() [3/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ max() [4/7]

PrimExpr tvm::max	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ max() [5/7]

PrimExpr tvm::max	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ max() [6/7]

PrimExpr tvm::max	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take maximum of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ max() [7/7]

PrimExpr tvm::max	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

max of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ max_value()

PrimExpr tvm::max_value	(	const DataType &	dtype,
		Span	span = `Span()`
	)

Query the maximum possible value of dtype.

Parameters

dtype	The data type.
span	The location of this operation in the source.

Returns: the maximum possible value in this format.

◆ min() [1/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ min() [2/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ min() [3/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ min() [4/7]

PrimExpr tvm::min	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ min() [5/7]

PrimExpr tvm::min	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ min() [6/7]

PrimExpr tvm::min	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take minimum of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

Examples: /workspace/include/tvm/runtime/threading_backend.h.

◆ min() [7/7]

PrimExpr tvm::min	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

max of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ min_value()

PrimExpr tvm::min_value	(	const DataType &	dtype,
		Span	span = `Span()`
	)

Query the minimum possible value of dtype.

Parameters

dtype	The data type.
span	The location of this operation in the source.

Returns: the minimum possible value in this format.

◆ MixedModulePassManager()

transform::Sequential tvm::MixedModulePassManager	(	IRModule	mixed_mod,
		Target	target
	)

Configures and returns the composite Pass for the fused module (pre split) that contains device and host code.

Parameters

mixed_mod	The original mixed module.
target	The device Target.

Returns: The composite Pass for the fused module.

◆ mul() [1/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ mul() [2/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ mul() [3/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ mul() [4/6]

PrimExpr tvm::mul	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ mul() [5/6]

PrimExpr tvm::mul	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ mul() [6/6]

PrimExpr tvm::mul	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

multiplication operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ nearbyint()

PrimExpr tvm::nearbyint	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculates std::nearbyint(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression. This is a faster alternate to round.

◆ neg()

PrimExpr tvm::neg	(	PrimExpr	a,
		Span	span = `Span()`
	)

negation.

Parameters

a	input.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ nextafter()

PrimExpr tvm::nextafter	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ not_equal()

PrimExpr tvm::not_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

not_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ NullValue()

template<typename TObjectRef >

TObjectRef tvm::NullValue ( )

inline

Create a NodeRef type that represents null.

Template Parameters

TNodeRef the type to be created.

Returns: A instance that will represent None.

◆ NullValue< DataType >()

template<>

DataType tvm::NullValue< DataType > ( )

inline

◆ operator!()

PrimExpr tvm::operator! ( PrimExpr a )

not

Parameters

a	left operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator!=()

PrimExpr tvm::operator!=	(	PrimExpr	a,
		PrimExpr	b
	)

not_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator%()

template<typename TB >

PrimExpr tvm::operator%	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator&() [1/3]

PrimExpr tvm::operator&	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator&() [2/3]

PrimExpr tvm::operator&	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator&() [3/3]

PrimExpr tvm::operator&	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise and of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator&&() [1/6]

Bool tvm::operator&&	(	bool	a,
		const Bool &	b
	)

inline

◆ operator&&() [2/6]

PrimExpr tvm::operator&&	(	bool	a,
		const PrimExpr &	b
	)

inline

◆ operator&&() [3/6]

Bool tvm::operator&&	(	const Bool &	a,
		bool	b
	)

inline

◆ operator&&() [4/6]

Bool tvm::operator&&	(	const Bool &	a,
		const Bool &	b
	)

inline

◆ operator&&() [5/6]

PrimExpr tvm::operator&&	(	const PrimExpr &	a,
		bool	b
	)

inline

◆ operator&&() [6/6]

PrimExpr tvm::operator&&	(	PrimExpr	a,
		PrimExpr	b
	)

and

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator*() [1/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator*() [2/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator*() [3/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator*() [4/6]

PrimExpr tvm::operator*	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator*() [5/6]

PrimExpr tvm::operator*	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator*() [6/6]

PrimExpr tvm::operator*	(	PrimExpr	a,
		PrimExpr	b
	)

multiplication operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator*=()

PrimExpr tvm::operator*=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator+() [1/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator+() [2/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator+() [3/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator+() [4/6]

PrimExpr tvm::operator+	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator+() [5/6]

PrimExpr tvm::operator+	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator+() [6/6]

PrimExpr tvm::operator+	(	PrimExpr	a,
		PrimExpr	b
	)

add operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator+=()

PrimExpr tvm::operator+=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator-() [1/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator-() [2/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator-() [3/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator-() [4/7]

PrimExpr tvm::operator-	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator-() [5/7]

PrimExpr tvm::operator-	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator-() [6/7]

PrimExpr tvm::operator- ( PrimExpr a )

negation.

Parameters

a input.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator-() [7/7]

PrimExpr tvm::operator-	(	PrimExpr	a,
		PrimExpr	b
	)

subtraction operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator-=()

PrimExpr tvm::operator-=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator/() [1/2]

template<typename TB >

PrimExpr tvm::operator/	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator/() [2/2]

PrimExpr tvm::operator/	(	PrimExpr	a,
		PrimExpr	b
	)

division operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator/=()

template<typename TB >

PrimExpr tvm::operator/=	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator<() [1/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator<() [2/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator<() [3/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<() [4/6]

PrimExpr tvm::operator<	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator<() [5/6]

PrimExpr tvm::operator<	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<() [6/6]

PrimExpr tvm::operator<	(	PrimExpr	a,
		PrimExpr	b
	)

less

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator<<() [1/3]

PrimExpr tvm::operator<<	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<<() [2/3]

PrimExpr tvm::operator<<	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<<() [3/3]

PrimExpr tvm::operator<<	(	PrimExpr	a,
		PrimExpr	b
	)

left shift operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator<=() [1/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator<=() [2/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator<=() [3/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<=() [4/6]

PrimExpr tvm::operator<=	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator<=() [5/6]

PrimExpr tvm::operator<=	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<=() [6/6]

PrimExpr tvm::operator<=	(	PrimExpr	a,
		PrimExpr	b
	)

less_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator==() [1/4]

bool tvm::operator==	(	bool	a,
		const Bool &	b
	)

inline

◆ operator==() [2/4]

bool tvm::operator==	(	const Bool &	a,
		bool	b
	)

inline

◆ operator==() [3/4]

bool tvm::operator==	(	const Bool &	a,
		const Bool &	b
	)

inline

◆ operator==() [4/4]

PrimExpr tvm::operator==	(	PrimExpr	a,
		PrimExpr	b
	)

equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>() [1/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator>() [2/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator>() [3/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>() [4/6]

PrimExpr tvm::operator>	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator>() [5/6]

PrimExpr tvm::operator>	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>() [6/6]

PrimExpr tvm::operator>	(	PrimExpr	a,
		PrimExpr	b
	)

greater

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>=() [1/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator>=() [2/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator>=() [3/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>=() [4/6]

PrimExpr tvm::operator>=	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator>=() [5/6]

PrimExpr tvm::operator>=	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>=() [6/6]

PrimExpr tvm::operator>=	(	PrimExpr	a,
		PrimExpr	b
	)

greater_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>>() [1/3]

PrimExpr tvm::operator>>	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>>() [2/3]

PrimExpr tvm::operator>>	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>>() [3/3]

PrimExpr tvm::operator>>	(	PrimExpr	a,
		PrimExpr	b
	)

right shift operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator^() [1/3]

PrimExpr tvm::operator^	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator^() [2/3]

PrimExpr tvm::operator^	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator^() [3/3]

PrimExpr tvm::operator^	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise xor of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator|() [1/3]

PrimExpr tvm::operator\|	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator|() [2/3]

PrimExpr tvm::operator\|	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator|() [3/3]

PrimExpr tvm::operator\|	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise or of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator||() [1/6]

Bool tvm::operator\|\|	(	bool	a,
		const Bool &	b
	)

inline

◆ operator||() [2/6]

PrimExpr tvm::operator\|\|	(	bool	a,
		const PrimExpr &	b
	)

inline

◆ operator||() [3/6]

Bool tvm::operator\|\|	(	const Bool &	a,
		bool	b
	)

inline

◆ operator||() [4/6]

Bool tvm::operator\|\|	(	const Bool &	a,
		const Bool &	b
	)

inline

◆ operator||() [5/6]

PrimExpr tvm::operator\|\|	(	const PrimExpr &	a,
		bool	b
	)

inline

◆ operator||() [6/6]

PrimExpr tvm::operator\|\|	(	PrimExpr	a,
		PrimExpr	b
	)

or

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator~()

PrimExpr tvm::operator~ ( PrimExpr a )

take bitwise negation of two values

Parameters

a	the input expression.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ popcount()

PrimExpr tvm::popcount	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ pow()

PrimExpr tvm::pow	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

Calculate power(x, y)

Parameters

x	The left operand.
y	The right operand.
span	The location of this operation in the source.

◆ prod()

PrimExpr tvm::prod	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

product of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ q_multiply_shift()

PrimExpr tvm::q_multiply_shift	(	PrimExpr	x,
		PrimExpr	y,
		PrimExpr	q,
		PrimExpr	s,
		Span	span = `Span()`
	)

Execute a multiplication between two Q-numbers x and y followed by a right shift s. The mathematical expression is:

out = round(x*y*2^-s)

Please note that the two Q-numbers x and y are supposed to have the same number of fractional bits q.

More about Q-numbers here: https://en.wikipedia.org/wiki/Q_(number_format)

The rounding rule is to the nearest value, rounding half up (i.e., round(x.1) = x and round (x.5) = x+1)

Parameters

x	first Q-number
y	second Q-number
q	number of fractional bits in x and y. Needs to be > 0
s	integer right shift
span	The location of this operation in the source.

Returns: The constructed expression.

◆ reinterpret()

PrimExpr tvm::reinterpret	(	const DataType &	t,
		PrimExpr	value,
		Span	span = `Span()`
	)

perform reinterpret cast value to type.

Parameters

t	the target type.
value	The value
span	The location of this operation in the source.

Returns: The result expression.

Note: This function may return value if the type is the same.

◆ ret()

PrimExpr tvm::ret	(	PrimExpr	value,
		Span	span = `Span()`
	)

Return the value.

Parameters

value	The returned value.
span	The location of this operation in the source.

Returns: The return expression.

◆ right_shift() [1/3]

PrimExpr tvm::right_shift	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ right_shift() [2/3]

PrimExpr tvm::right_shift	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ right_shift() [3/3]

PrimExpr tvm::right_shift	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

right shift operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ round()

PrimExpr tvm::round	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate round(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ rsqrt()

PrimExpr tvm::rsqrt	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ SaveJSON()

std::string tvm::SaveJSON ( const runtime::ObjectRef & node )

save the node as well as all the node it depends on as json. This can be used to serialize any TVM object

Returns: the string representation of the node.

◆ ScheduleToModule()

IRModule tvm::ScheduleToModule	(	te::Schedule	sch,
		const Array< ObjectRef > &	args,
		const std::string &	name,
		const std::unordered_map< te::Tensor, tir::Buffer > &	binds,
		GlobalVarSupply	global_var_supply
	)

Create an IRModule out of a TE Schedule. It does not apply lowering passes. If you want to apply lowering passes as well, use LowerSchedule.

Parameters

sch	The schedule
args	The arguments to the function.
name	The name of the lowered function.
binds	Buffer assignments.
global_var_supply	The GlobalVarSupply to be used in the module and when creating GlobalVars.

Returns: The result module.

◆ shapediv()

PrimExpr tvm::shapediv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute ceil(a / b) where a and b are non-negative.

Use this function for shape split calculation.

This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for shape types(int32, int64) when possible.

◆ sigmoid()

PrimExpr tvm::sigmoid	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sin()

PrimExpr tvm::sin	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sinh()

PrimExpr tvm::sinh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sqrt()

PrimExpr tvm::sqrt	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sub() [1/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ sub() [2/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ sub() [3/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ sub() [4/6]

PrimExpr tvm::sub	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ sub() [5/6]

PrimExpr tvm::sub	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ sub() [6/6]

PrimExpr tvm::sub	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

subtraction operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ sum()

PrimExpr tvm::sum	(	PrimExpr	source,
		Array< tir::IterVar >	axis,
		Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

sum of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ tan()

PrimExpr tvm::tan	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ tanh()

PrimExpr tvm::tanh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ TerminalRenderer()

DiagnosticRenderer tvm::TerminalRenderer ( std::ostream & ostream )

◆ trunc()

PrimExpr tvm::trunc	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate trunc(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ truncdiv() [1/3]

PrimExpr tvm::truncdiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ truncdiv() [2/3]

PrimExpr tvm::truncdiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ truncdiv() [3/3]

PrimExpr tvm::truncdiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute trunc(a / b)

This is the default integer division behavior in C.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ truncmod() [1/3]

PrimExpr tvm::truncmod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ truncmod() [2/3]

PrimExpr tvm::truncmod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ truncmod() [3/3]

PrimExpr tvm::truncmod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder of truncdiv

This is the default integer division behavior in C.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ TypeKind2String()

String tvm::TypeKind2String ( TypeKind kind )

inline

Converts a TypeKind to a string.

◆ VoidType()

Type tvm::VoidType ( )

inline

Returns: a type that represents void.

◆ WithAttr()

template<typename TFunc >

TFunc tvm::WithAttr	(	TFunc	input,
		const std::string &	attr_key,
		ObjectRef	attr_value
	)

inline

Copy the function or module, but overrides the attribute value key with the value.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attr_key	The attribute key.
attr_value	The value attribute value.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with updated attributes.

Note: This function performs copy on write optimization for func and module. If we move a uniquely referenced func or module into WithAttr, then no additional copy will be performed.

This is also why we make it as a function instead of a member function and why we pass by value in the first argument.

// Recommended way to trigger copy on write
func = WithAttr(std::move(func), "key1", value1);
func = WithAttr(std::move(func), "key2", value2);

◆ WithAttrs()

template<typename TFunc >

TFunc tvm::WithAttrs	(	TFunc	input,
		Map< String, ObjectRef >	attrs
	)

inline

Copy the function or module, but overrides the attributes with the entries from attrs.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attrs	Key/values attributes to add to `input`.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with updated attributes.

◆ WithFields()

GlobalVar tvm::WithFields	(	GlobalVar	global_var,
		Optional< String >	opt_name_hint = `{}`,
		Optional< Type >	opt_type = `{}`,
		Optional< VirtualDevice >	opt_virtual_device = `{}`,
		Optional< Span >	opt_span = `{}`
	)

Returns global_var with the given properties. A null property denotes 'no change'. Returns global_var if all properties are unchanged. Otherwise, returns a copy with the new fields.

◆ WithoutAttr()

template<typename TFunc >

TFunc tvm::WithoutAttr	(	TFunc	input,
		const std::string &	attr_key
	)

inline

Copy the function or module, but removes the specified attribute.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attr_key	The attribute key.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with removed attribute.

Note: This function performs copy on write optimization for func and module. If we move a uniquely referenced func or module into WithoutAttr, then no additional copy will be performed.

This is also why we make it as a function instead of a member function and why we pass by value in the first argument.

// Recommended way to trigger copy on write
func = WithoutAttr(std::move(func), "key1");
func = WithoutAttr(std::move(func), "key2");

Variable Documentation

◆ kInvalidDeviceType

constexpr int tvm::kInvalidDeviceType = -1

constexpr

◆ kNullDeviceType

constexpr int tvm::kNullDeviceType = 0

constexpr

◆ kUSMPAlgorithmOption

constexpr const char* tvm::kUSMPAlgorithmOption = "tir.usmp.algorithm"

constexpr

PassContext option to select the memory planning algorithm in USMP.

◆ kUSMPCustomAlgorithmOption

constexpr const char* tvm::kUSMPCustomAlgorithmOption = "tir.usmp.custom_algorithm"

constexpr

PassContext option to specify a custom memory planning algorithm in USMP. The algorithm should be provided as registered PackedFunc with the name tir.usmp.algorithm.NAME.

◆ kUSMPEnableOption

constexpr const char* tvm::kUSMPEnableOption = "tir.usmp.enable"

constexpr

PassContext option to enable the USMP.

◆ kUSMPUseWorkspaceIO

constexpr const char* tvm::kUSMPUseWorkspaceIO = "tir.usmp.use_workspace_io"

constexpr

PassContext option to enable placing I/O tensors in the workspace.

◆ kVirtualDevice

constexpr const char* tvm::kVirtualDevice = "virtual_device"

constexpr

brief The attribute key for the virtual device. This key will be promoted to first class on functions. For use in the parser and printer only.

Type: VirtualDevice

◆ NullOpt

constexpr runtime::NullOptType tvm::NullOpt {}

constexpr

Examples: /workspace/include/tvm/script/ir_builder/base.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ DataType

◆ Device

◆ FTVMTargetParser

◆ MemoryScope

◆ TargetFeatures

◆ TargetJSON

◆ TypeRelationFn

Enumeration Type Documentation

◆ CallingConv

◆ DiagnosticLevel

◆ TypeKind

Function Documentation

◆ abs()

◆ acos()

◆ acosh()

◆ add() [1/6]

◆ add() [2/6]

◆ add() [3/6]

◆ add() [4/6]

◆ add() [5/6]

◆ add() [6/6]

◆ all()

◆ any()

◆ asin()

◆ asinh()

◆ atan()

◆ atan2()

◆ atanh()

◆ AttrsWithDefaultValues()

◆ Bind()

◆ bitwise_and() [1/3]

◆ bitwise_and() [2/3]

◆ bitwise_and() [3/3]

◆ bitwise_neg()

◆ bitwise_or() [1/3]

◆ bitwise_or() [2/3]

◆ bitwise_or() [3/3]

◆ bitwise_xor() [1/3]

◆ bitwise_xor() [2/3]

◆ bitwise_xor() [3/3]

◆ build() [1/3]

◆ build() [2/3]

◆ build() [3/3]

◆ cast()

◆ ceil()

◆ ceildiv()

◆ CheckAndUpdateHostConsistency()

◆ clz()

◆ copysign()

◆ cos()

◆ cosh()

◆ DeviceModulePassManager()

◆ div() [1/6]

◆ div() [2/6]

◆ div() [3/6]

◆ div() [4/6]

◆ div() [5/6]

◆ div() [6/6]

◆ DivAmbiguityError()

◆ Dump() [1/2]

◆ Dump() [2/2]

◆ equal()

◆ erf()

◆ exp()

◆ exp10()

◆ exp2()

◆ fast_erf_float_expr()

◆ floor()

◆ floordiv() [1/3]

◆ floordiv() [2/3]

◆ floordiv() [3/3]

◆ floormod() [1/3]