tvm Namespace Reference

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
	parser
	relay
	Relay: a high level functional IR for TVM.
	runtime
	script
	support
	te
	Tensor expression language DSL.
	tir
	topi
	transform

Classes
class	AffineType
	Managed reference to AffineTypeNode. More...
class	AffineTypeNode
	AffineType representation. More...
class	ArrayIndexPath
class	ArrayIndexPathNode
struct	AttrError
	Error thrown during attribute checking. More...
class	AttrFieldInfo
	AttrFieldInfo. More...
class	AttrFieldInfoNode
	Information about attribute fields in string representations. More...
class	AttributeAccessPath
class	AttributeAccessPathNode
class	AttrRegistry
class	AttrRegistryMap
	Map<Key, ValueType> used to store meta-data. More...
class	AttrRegistryMapContainerMap
	Generic attribute map. More...
class	Attrs
	Managed reference to BaseAttrsNode. More...
class	AttrsNode
	The base class of the all the Use "curiously recurring template pattern". More...
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	BaseAttrsNode
	Base class of all attribute class. More...
class	BaseExpr
	Managed reference to BaseExprNode. More...
class	BaseExprNode
	Base type of all the expressions. More...
class	BaseFunc
	Managed reference to BaseFuncNode. More...
class	BaseFuncNode
	Base node of all functions. More...
class	BaseTensorType
	Managed reference to BaseTensorTypeNode. More...
class	BaseTensorTypeNode
	Base of all Tensor types This container can hold TensorType or GenericTensorType. More...
class	BaseValueEqual
	Equality definition of base value class. More...
class	BaseValueHash
	Hash definition of base value classes. More...
class	Bool
	Boolean constant. More...
class	CompilationConfig
	Managed reference class to CompilationConfig. 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	CompileError
	Custom Error class to be thrown during compilation. More...
class	ConstantInfo
struct	ConstantInfoNode
class	ConstantMemoryPools
struct	ConstantMemoryPoolsNode
class	ConstantPoolInfo
struct	ConstantPoolInfoNode
class	Constructor
	Managed reference to ConstructorNode. More...
class	ConstructorNode
	ADT constructor. Constructors compare by pointer equality. More...
class	ContextManager
	A context type that delegates EnterWithScope and ExitWithScope to user-provided functions. More...
class	Diagnostic
class	DiagnosticBuilder
	A wrapper around std::stringstream to build a diagnostic. More...
class	DiagnosticContext
class	DiagnosticContextNode
class	DiagnosticNode
	A compiler diagnostic message. More...
class	DiagnosticRenderer
class	DiagnosticRendererNode
	Display diagnostics in a given display format. More...
class	DictAttrs
	Managed reference to DictAttrsNode. 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	EnvFunc
	Managed reference to EnvFuncNode. More...
class	EnvFuncNode
	A serializable function backed by TVM's global environment. More...
struct	ErrorBuilder
	A wrapper around std::stringstream to build error. More...
class	ErrorReporter
	An abstraction around how errors are stored and reported. Designed to be opaque to users, so we can support a robust and simpler error reporting mode, as well as a more complex mode. More...
class	FloatImm
	Managed reference class to FloatImmNode. More...
class	FloatImmNode
	Constant floating point literals in the program. More...
class	FuncType
	Managed reference to FuncTypeNode. More...
class	FuncTypeNode
	Function type. 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	GlobalTypeVar
	Managed reference to GlobalTypeVarNode. More...
class	GlobalTypeVarNode
	A global type variable that is used for defining new types or type aliases. More...
class	GlobalVar
	Managed reference to GlobalVarNode. More...
class	GlobalVarNode
	Global variable that lives in the top-level module. More...
class	GlobalVarSupply
	Managed reference class to GlobalVarSupplyNode. More...
class	GlobalVarSupplyNode
	GlobalVarSupply can be used to generate unique GlobalVars. More...
class	IncompleteType
	Managed reference to IncompleteTypeNode. More...
class	IncompleteTypeNode
	Intermediate values that is used to indicate incomplete type during type inference. More...
class	Integer
	Container of constant int that adds more constructors. More...
class	IntImm
	Managed reference class to IntImmNode. More...
class	IntImmNode
	Constant integer literals in the program. More...
class	IRModule
	Managed reference class to IRModuleNode. More...
class	IRModuleNode
	IRModule that holds functions and type definitions. More...
class	MapValuePath
class	MapValuePathNode
class	MemoryInfo
	Defines memory info. More...
class	MemoryInfoNode
	Memory information of special memory region. Use MemoryInfo as its container type. More...
class	MissingArrayElementPath
class	MissingArrayElementPathNode
class	MissingMapEntryPath
class	MissingMapEntryPathNode
class	NameSupply
	Managed reference class to NameSupplyNode. More...
class	NameSupplyNode
	NameSupply can be used to generate unique names. More...
struct	NDArrayContainerTrait
class	NodeFunctor
	A dynamically dispatched functor on the type of the first argument. More...
class	NodeFunctor< R(const ObjectRef &n, Args...)>
class	ObjectPath
class	ObjectPathNode
	Path to an object from some root object. More...
class	ObjectPathPair
class	ObjectPathPairNode
	Pair of ObjectPaths, one for each object being tested for structural equality. More...
class	Op
	Managed reference class to OpNode. More...
class	OpAttrMap
	Map<Op,ValueType> used to store meta-information about Op. More...
class	OpNode
	Primitive Op(builtin intrinsics) More...
class	OpRegEntry
	Helper structure to register operators. More...
class	PointerType
class	PointerTypeNode
	Low-level raw pointer type. More...
class	PoolInfo
	Base class for WorkspacePoolInfo and ConstantPoolInfo. More...
struct	PoolInfoNode
	Describes a pool of memory accessible by one or more targets. More...
class	PoolInfoProperties
struct	PoolInfoPropertiesNode
	Describes a pool of memory properties. More...
class	PrimExpr
	Reference to PrimExprNode. More...
class	PrimExprNode
	Base node of all primitive expressions. More...
class	PrimType
class	PrimTypeNode
	Primitive data types used in the low-level IR. More...
class	Range
	Range constainer. More...
class	RangeNode
	range over one dimension More...
class	ReflectionVTable
	Virtual function table to support IR/AST node reflection. More...
class	RelayExpr
	Managed reference to RelayExprNode. More...
class	RelayExprNode
	Base node of all non-primitive expressions. More...
class	RelayRefType
	Managed reference to RelayRefTypeNode. More...
class	RelayRefTypeNode
	Reference Type High-level Relay IR. More...
class	ReprPrinter
	A printer class to print the AST/IR nodes. More...
class	RootPath
class	RootPathNode
class	SEqualHandlerDefault
	The default handler for equality testing. More...
class	SEqualReducer
	A Reducer class to reduce the structural equality result of two objects. More...
class	SHashHandlerDefault
	The default handler for hash key computation. More...
class	SHashReducer
	A Reducer class to reduce the structural hash value. More...
class	SourceName
	The source name of a file span. More...
class	SourceNameNode
	The name of a source fragment. More...
class	Span
class	SpanNode
	Stores locations in frontend source that generated a node. More...
class	StructuralEqual
	Content-aware structural equality comparator for objects. More...
class	StructuralHash
	Content-aware structural hasing. More...
class	Target
	Managed reference class to TargetNode. More...
class	TargetKind
	Managed reference class to TargetKindNode. 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	TargetKindRegEntry
	Helper structure to register TargetKind. More...
class	TargetNode
	Compilation target. More...
class	TargetTag
	Managed reference class to TargetTagNode. More...
class	TargetTagNode
	A target tag. More...
class	TargetTagRegEntry
class	TensorAffineType
	Managed reference to AffineTypes. More...
class	TensorAffineTypeNode
	TensorAffineType representation. More...
class	TensorType
	Managed reference to TensorTypeNode. More...
class	TensorTypeNode
	This is the most commonly used type in relay. TensorType have a fixed dimension, data type. More...
class	TracedArray
	Traced wrapper for Array objects. More...
class	TracedArrayIterator
	Iterator class for TracedArray<T> More...
class	TracedBasicValue
	Traced wrapper for basic values (i.e. non-TVM objects) More...
class	TracedMap
	Traced wrapper for Map objects. More...
class	TracedMapIterator
	Iterator class for TracedMap<K, V> More...
class	TracedObject
	Traced wrapper for regular (non-container) TVM objects. More...
class	TracedOptional
	Traced wrapper for Optional objects. More...
class	TupleAffineType
	Managed reference to TupleAffineTypes. More...
class	TupleAffineTypeNode
	TupleAffineType representation. More...
class	TupleType
	Managed reference to TupleTypeNode. More...
class	TupleTypeNode
	The type of tuple values. More...
class	Type
	Managed reference to TypeNode. More...
class	TypeCall
	Managed reference to TypeCallNode. More...
class	TypeCallNode
	Type function application. More...
class	TypeConstraint
	Managed reference to TypeConstraintNode. More...
class	TypeConstraintNode
	Potential Constraints in a function. More...
class	TypeData
	Stores all data for an Algebraic Data Type (ADT). More...
class	TypeDataNode
	TypeData container node. 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	TypeFunctor
class	TypeFunctor< R(const Type &n, Args...)>
class	TypeMutator
	TypeMutator that mutates expressions. More...
class	TypeNode
	Type is the base type of all types. More...
class	TypeRelation
	Managed reference to TypeRelationNode. More...
class	TypeRelationNode
	User defined type relation, it is an input-output relation on types. More...
class	TypeReporter
	Container class of TypeReporter. More...
class	TypeReporterNode
	reporter that reports back to the type resolution information. More...
class	TypeVar
	Managed reference to TypeVarNode. More...
class	TypeVarNode
	Type parameter in functions. More...
class	TypeVisitor
	A type visitor that recursively visit types. More...
class	UnknownAttributeAccessPath
class	UnknownAttributeAccessPathNode
class	VirtualDevice
	Managed reference class to VirtualDeviceNode. More...
class	VirtualDeviceCache
	A cache of VirtualDevices. This can be used: 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	With
	RAII wrapper function to enter and exit a context object similar to python's with syntax. More...
class	WorkspaceMemoryPools
struct	WorkspaceMemoryPoolsNode
class	WorkspacePoolInfo
struct	WorkspacePoolInfoNode

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 = TypedPackedFunc< TargetJSON(TargetJSON)>
using	FTVMRelayToTIR = transform::Pass
	RelayToTIR tvm::transform::Pass specific to a TargetKind. More...
using	FTVMTIRToRuntime = runtime::TypedPackedFunc< runtime::Module(IRModule, Target)>
	TIRToRuntime conversion specific to a TargetKind. More...
using	MemoryScope = String

Enumerations
enum	DiagnosticLevel : int {   DiagnosticLevel::kBug = 10, DiagnosticLevel::kError = 20, DiagnosticLevel::kWarning = 30, DiagnosticLevel::kNote = 40,   DiagnosticLevel::kHelp = 50 }
	The diagnostic level, controls the printing of the message. More...
enum	CallingConv : int { CallingConv::kDefault = 0, CallingConv::kCPackedFunc = 1, CallingConv::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)
String	PrettyPrint (const ObjectRef &node)
	Pretty print a node for debug purposes. More...
String	AsText (const ObjectRef &node, bool show_meta_data=true, runtime::TypedPackedFunc< String(ObjectRef)> annotate=nullptr)
	Render the node as a string in the text format. More...
bool	IsPrimitiveOp (const RelayExpr &expr)
	Check that an expression is a "primitive operator". 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...
template<typename RefT >
detail::TracedObjectWrapperSelector< RefT >::Type	MakeTraced (const RefT &object)
	Wrap the given root object in an appropriate traced wrapper class. More...
template<typename RefT >
detail::TracedObjectWrapperSelector< RefT >::Type	MakeTraced (const RefT &object, ObjectPath path)
	Wrap the given object with the given path in an appropriate traced wrapper class. 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...
void	CheckAndUpdateHostConsistency (Map< Target, IRModule > *ir_modules, Target *host)
	Check and update host field of the given legacy heterogeneous targets and target host.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	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 DLDeviceType	kNullDeviceType = static_cast<DLDeviceType>(0)
constexpr DLDeviceType	kInvalidDeviceType = static_cast<DLDeviceType>(-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.

Performance counters for profiling via the PAPI library.

Typedef Documentation

DataType

using tvm::DataType = typedef runtime::DataType

Device

using tvm::Device = typedef DLDevice

FTVMRelayToTIR

using tvm::FTVMRelayToTIR = typedef transform::Pass

RelayToTIR tvm::transform::Pass specific to a TargetKind.

Called before the default lowering passes.

Parameters

mod	The module that an optimization pass runs on.
pass_ctx	The pass context that can provide information for the optimization.

Returns

The transformed module.

FTVMTargetParser

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

FTVMTIRToRuntime

using tvm::FTVMTIRToRuntime = typedef runtime::TypedPackedFunc<runtime::Module(IRModule, Target)>

TIRToRuntime conversion specific to a TargetKind.

This function is responsible for scanning an IRModule for appropriate Target-specific functions and generating a Runtime module representing the compiled output

Parameters

ir_module	Unified IRModule
target	Target to filter on or retrieve arguments from

Returns

Runtime Module containing compiled functions

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	(	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.

add() [2/6]

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

inline

add() [3/6]

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

inline

add() [4/6]

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

inline

add() [5/6]

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

inline

add() [6/6]

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

inline

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

AsText()

String tvm::AsText	(	const ObjectRef &	node,
		bool	show_meta_data = true,
		runtime::TypedPackedFunc< String(ObjectRef)>	annotate = nullptr
	)

Render the node as a string in the text format.

Parameters

node	The node to be rendered.
show_meta_data	Whether to print meta data section.
annotate	An optional callback function for attaching additional comment block to an expr.

Note

We support a limited set of IR nodes that are part of relay IR and

See also

PrettyPrint.

Returns

The text representation.

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	(	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_and() [2/3]

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

inline

bitwise_and() [3/3]

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

inline

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	(	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_or() [2/3]

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

inline

bitwise_or() [3/3]

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

inline

bitwise_xor() [1/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.

bitwise_xor() [2/3]

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

inline

bitwise_xor() [3/3]

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

inline

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< 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.

build() [3/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.

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() [1/2]

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

CheckAndUpdateHostConsistency() [2/2]

void tvm::CheckAndUpdateHostConsistency	(	Map< Target, IRModule > *	ir_modules,
		Target *	host
	)

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

Parameters

ir_modules	The pointer to a Map objects with keys being Target objects
host	The 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	(	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.

div() [2/6]

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

inline

div() [3/6]

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

inline

div() [4/6]

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

inline

div() [5/6]

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

inline

div() [6/6]

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

inline

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::ObjectRef &

node

)

Dump the node to stderr, used for debug purposes.

Parameters

node	The input node

Dump() [2/2]

void tvm::Dump

(

const runtime::Object *

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

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	(	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.

floordiv() [2/3]

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

inline

floordiv() [3/3]

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

inline

floormod() [1/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.

floormod() [2/3]

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

inline

floormod() [3/3]

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

inline

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	(	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() [2/6]

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

inline

greater() [3/6]

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

inline

greater() [4/6]

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

inline

greater() [5/6]

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

inline

greater() [6/6]

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

inline

greater_equal() [1/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.

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 ( float  a, const PrimExpr &  b, Span  span = Span()  )

inline

greater_equal() [4/6]

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

inline

greater_equal() [5/6]

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

inline

greater_equal() [6/6]

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

inline

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	(	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.

indexdiv() [2/3]

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

inline

indexdiv() [3/3]

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

inline

indexmod() [1/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.

indexmod() [2/3]

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

inline

indexmod() [3/3]

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

inline

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	(	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.

left_shift() [2/3]

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

inline

left_shift() [3/3]

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

inline

less() [1/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() [2/6]

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

inline

less() [3/6]

PrimExpr tvm::less ( const PrimExpr &  a, float  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 ( const PrimExpr &  a, double  b, Span  span = Span()  )

inline

less_equal() [1/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.

less_equal() [2/6]

PrimExpr tvm::less_equal ( int  a, const PrimExpr &  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 ( const PrimExpr &  a, float  b, Span  span = Span()  )

inline

less_equal() [5/6]

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

inline

less_equal() [6/6]

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

inline

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	(	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_and() [2/3]

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

inline

logical_and() [3/3]

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

inline

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	(	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.

logical_or() [2/3]

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

inline

logical_or() [3/3]

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

inline

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< 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.

LowerSchedule() [2/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.

MakeTraced() [1/2]

template<typename RefT >

detail::TracedObjectWrapperSelector<RefT>::Type tvm::MakeTraced

(

const RefT &

object

)

Wrap the given root object in an appropriate traced wrapper class.

MakeTraced() [2/2]

template<typename RefT >

detail::TracedObjectWrapperSelector<RefT>::Type tvm::MakeTraced	(	const RefT &	object,
		ObjectPath	path
	)

Wrap the given object with the given path in an appropriate traced wrapper class.

max() [1/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() [2/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() [3/7]

PrimExpr tvm::max ( const PrimExpr &  a, float  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 ( const PrimExpr &  a, int  b, Span  span = Span()  )

inline

max() [7/7]

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

inline

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	(	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.

min() [2/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() [3/7]

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

inline

min() [4/7]

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

inline

min() [5/7]

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

inline

min() [6/7]

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

inline

min() [7/7]

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

inline

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	(	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.

mul() [2/6]

PrimExpr tvm::mul ( const PrimExpr &  a, double  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 ( int  a, const PrimExpr &  b, Span  span = Span()  )

inline

mul() [5/6]

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

inline

mul() [6/6]

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

inline

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 &() [1/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 &() [2/3]

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

inline

operator &() [3/3]

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

inline

operator &&() [1/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 &&() [2/6]

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

inline

operator &&() [3/6]

Bool tvm::operator&& ( bool  a, const 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&& ( bool  a, const PrimExpr &  b  )

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/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*() [2/6]

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

inline

operator*() [3/6]

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

inline

operator*() [4/6]

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

inline

operator*() [5/6]

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

inline

operator*() [6/6]

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

inline

operator*=()

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

inline

operator+() [1/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+() [2/6]

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

inline

operator+() [3/6]

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

inline

operator+() [4/6]

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

inline

operator+() [5/6]

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

inline

operator+() [6/6]

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

inline

operator+=()

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

inline

operator-() [1/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-() [2/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-() [3/7]

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

inline

operator-() [4/7]

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

inline

operator-() [5/7]

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

inline

operator-() [6/7]

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

inline

operator-() [7/7]

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

inline

operator-=()

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

inline

operator/() [1/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/() [2/2]

template<typename TB >

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

inline

operator/=()

template<typename TB >

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

inline

operator<() [1/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<() [2/6]

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

inline

operator<() [3/6]

PrimExpr tvm::operator< ( const PrimExpr &  a, float  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< ( const PrimExpr &  a, double  b  )

inline

operator<<() [1/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<<() [2/3]

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

inline

operator<<() [3/3]

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

inline

operator<=() [1/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<=() [2/6]

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

inline

operator<=() [3/6]

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

inline

operator<=() [4/6]

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

inline

operator<=() [5/6]

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

inline

operator<=() [6/6]

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

inline

operator==() [1/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==() [2/4]

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

inline

operator==() [3/4]

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

inline

operator==() [4/4]

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

inline

operator>() [1/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>() [2/6]

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

inline

operator>() [3/6]

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

inline

operator>() [4/6]

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

inline

operator>() [5/6]

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

inline

operator>() [6/6]

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

inline

operator>=() [1/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>=() [2/6]

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

inline

operator>=() [3/6]

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

inline

operator>=() [4/6]

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

inline

operator>=() [5/6]

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

inline

operator>=() [6/6]

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

inline

operator>>() [1/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>>() [2/3]

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

inline

operator>>() [3/3]

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

inline

operator^() [1/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^() [2/3]

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

inline

operator^() [3/3]

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

inline

operator|() [1/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|() [2/3]

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

inline

operator|() [3/3]

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

inline

operator||() [1/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||() [2/6]

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

inline

operator||() [3/6]

Bool tvm::operator|| ( bool  a, const 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|| ( bool  a, const PrimExpr &  b  )

inline

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.

PrettyPrint()

String tvm::PrettyPrint

(

const ObjectRef &

node

)

Pretty print a node for debug purposes.

Parameters

node	The node to be printed.

Returns

The text reperesentation.

Note

This function does not show version or meta-data. Use AsText if you want to store the text.

See also

AsText.

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	(	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.

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 ( const PrimExpr &  a, int  b, Span  span = Span()  )

inline

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	(	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.

sub() [2/6]

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

inline

sub() [3/6]

PrimExpr tvm::sub ( const PrimExpr &  a, double  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 ( const PrimExpr &  a, float  b, Span  span = Span()  )

inline

sub() [6/6]

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

inline

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	(	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.

truncdiv() [2/3]

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

inline

truncdiv() [3/3]

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

inline

truncmod() [1/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.

truncmod() [2/3]

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

inline

truncmod() [3/3]

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

inline

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 DLDeviceType tvm::kInvalidDeviceType = static_cast<DLDeviceType>(-1)

kNullDeviceType

constexpr DLDeviceType tvm::kNullDeviceType = static_cast<DLDeviceType>(0)

kUSMPAlgorithmOption

constexpr const char* tvm::kUSMPAlgorithmOption = "tir.usmp.algorithm"

PassContext option to select the memory planning algorithm in USMP.

kUSMPCustomAlgorithmOption

constexpr const char* tvm::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.

kUSMPEnableOption

constexpr const char* tvm::kUSMPEnableOption = "tir.usmp.enable"

PassContext option to enable the USMP.

kUSMPUseWorkspaceIO

constexpr const char* tvm::kUSMPUseWorkspaceIO = "tir.usmp.use_workspace_io"

PassContext option to enable placing I/O tensors in the workspace.

kVirtualDevice

constexpr const char* tvm::kVirtualDevice = "virtual_device"

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 {}

Examples:

/workspace/include/tvm/script/ir_builder/base.h.