| ►Ndmlc | |
| ►Nserializer | |
| CHandler< DLDataType > | |
| CHandler< DLDevice > | |
| ►Ntvm | Performance counters for profiling via the PAPI library |
| ►Narith | Namespace of arithmetic analysis |
| CConstIntBoundNode | Constant integer up and lower bound(inclusive). Useful for value bound analysis |
| CConstIntBound | Reference class to ConstIntBoundNode |
| CConstIntBoundAnalyzer | Analyzer to get constant integer bound over expression |
| CModularSetNode | Range of a linear integer function. Use to do specify the possible index values |
| CModularSet | Reference of ModularSetNode |
| CModularSetAnalyzer | Analyzer to get modular information over expression |
| CRewriteSimplifier | Rewrite-rule based simplifier |
| CCanonicalSimplifier | Canonical-form based simplifier |
| CTransitiveComparisonAnalyzer | Using previously specified knowns, compare the expressions provided |
| CConstraintContext | Constraint context |
| CIntSetAnalyzer | Integer set analyzer |
| CAnalyzer | Analyzer that contains bunch of sub-analyzers |
| CIntSetNode | Base class of all Integer set containers. represent a set of integers in one dimension |
| CIntSet | Managed reference to IntSetNode |
| CIntGroupBoundsNode | Represent integer grouped bounds which are classified into lower bounds (inclusive), upper bounds (inclusive) and equalities. It also contains coefficient as a multiplier for the bounds, i.e., coef * var >= lower coef * var == equal coef * var <= upper |
| CIntGroupBounds | Managed reference to IntGroupBoundsNode |
| CIntConstraintsNode | Represent integer constrains including (integer) variables, their ranges and the relations between them (either equations or inequalities) |
| CIntConstraints | Managed reference to IntConstraintsNode |
| CIntConstraintsTransformNode | We can have different set of variables to represent the same constraints. For example, the following two systems are equivalent, {a + b = 0 | a >= 0, b >= 0} and {m - n = 0 | m >= 0, n <= 0} This data structure represents the transformation between two equivalent linear systems. In the above example, src : {a + b = 0 | a >= 0, b >= 0} dst : {m - n = 0 | m >= 0, n <= 0} src_to_dst : {a -> m, b -> -n} dst_to_src : {m -> a, n -> -b} |
| CIntConstraintsTransform | Managed reference to IntConstraintsTransformNode |
| CIterMapExprNode | Base class of all iter map expressions |
| CIterMapExpr | Managed reference to IterMapExprNode |
| CIterMarkNode | Mark the source as an iterator in [0, extent) |
| CIterMark | Managed reference to IterMarkExprNode |
| CIterSplitExprNode | Split of an iterator |
| CIterSplitExpr | Managed reference to IterSplitExprNode |
| CIterSumExprNode | Fuse multiple iterators by summing them with scaling |
| CIterSumExpr | Managed reference to IterSumExprNode |
| CIterMapResultNode | Result of DetectIterMap |
| CIterMapResult | Managed reference to IterMapResultNode |
| ►Ndetail | |
| CAttrNopEntry | |
| CAttrNormalVisitor | |
| CAttrsSEqualVisitor | |
| CAttrsSHashVisitor | |
| CAttrInitEntry | |
| CAttrInitVisitor | |
| CTypeName | Helper struct to get the type name known to tvm |
| CTypeName< int > | |
| CTypeName< int64_t > | |
| CTypeName< uint64_t > | |
| CTypeName< DataType > | |
| CTypeName< bool > | |
| CTypeName< void * > | |
| CTypeName< double > | |
| CAttrDocEntry | |
| CAttrDocVisitor | |
| CAttrExistVisitor | |
| CAttrTriggerNonDefaultEntry | |
| CAttrNonDefaultVisitor | |
| CImplVisitAttrs | |
| CImplVisitAttrs< T, true > | |
| CImplSEqualReduce | |
| CImplSEqualReduce< T, true > | |
| CImplSHashReduce | |
| CImplSHashReduce< T, true > | |
| CReflectionTrait | |
| CSelectVisitAttrs | |
| CSelectVisitAttrs< T, TraitName, false > | |
| CSelectSEqualReduce | |
| CSelectSEqualReduce< T, TraitName, false > | |
| CSelectSHashReduce | |
| CSelectSHashReduce< T, TraitName, false > | |
| CValueTypeInfoMaker | |
| Cis_specialized | |
| Cis_specialized< Container< Args... >, Container > | |
| ►Ninstrument | |
| CPassInstrumentNode | PassInstrumentNode forms an instrument implementation. It provides API for users to register callbacks at different instrumentation points |
| CPassInstrument | Managed reference class for PassInstrumentNode |
| ►Nir | |
| CCalleeCollector | |
| ►Nmeta_schedule | |
| CArgInfoNode | The argument information |
| CArgInfo | Managed reference to ArgInfoNode |
| CTensorInfoNode | The tensor argument information |
| CTensorInfo | Managed reference to TensorInfoNode |
| CBuilderInputNode | The builder's input, containing an IRModule and the target |
| CBuilderInput | Managed reference to BuilderInputNode |
| CBuilderResultNode | The builder's output, containing the artifact path or error message if any |
| CBuilderResult | Managed reference to BuilderResultNode |
| CBuilderNode | The abstract builder interface |
| CBuilder | Managed reference to BuilderNode |
| CPyBuilderNode | An abstract builder with customized build method on the python-side |
| CCostModelNode | Cost model |
| CPyCostModelNode | The cost model with customized methods on the python-side |
| CCostModel | Managed reference to CostModelNode |
| CWorkloadNode | A workload, i.e. an IRModule and its structural hash |
| CWorkload | Managed reference to WorkloadNode |
| CWorkloadHash | The hash method for Workload |
| CWorkloadEqual | The equality check for Workload |
| CTuningRecordNode | The class of tuning records |
| CTuningRecord | The managed reference of TuningRecordNode |
| CDatabaseNode | |
| CPyDatabaseNode | The database with customized methods on the python-side |
| CDatabase | Managed reference to DatabaseNode |
| CExtractedTaskNode | A tuning task extracted from the high-level IR |
| CExtractedTask | Managed reference to ExtractedTaskNode |
| CFeatureExtractorNode | Extractor for features from measure candidates for use in cost model |
| CPyFeatureExtractorNode | The feature extractor with customized methods on the python-side |
| CFeatureExtractor | Managed reference to FeatureExtractorNode |
| CMeasureCallbackNode | Rules to apply after measure results is available |
| CPyMeasureCallbackNode | The measure callback with customized methods on the python-side |
| CMeasureCallback | Managed reference to MeasureCallbackNode |
| CMeasureCandidateNode | The schedule (with input shapes) to be measured |
| CMeasureCandidate | Managed reference to MeasureCandidateNode |
| CMutatorNode | Mutator is designed to mutate the trace to explore the design space |
| CMutator | Managed reference to MutatorNode |
| CPyMutatorNode | The mutator with customized methods on the python-side |
| CPostprocNode | Rules to apply a postprocessor to a schedule |
| CPostproc | Managed reference to PostprocNode |
| CPyPostprocNode | The postprocessor with customized methods on the python-side |
| CScopedTimer | |
| CProfilerNode | A generic profiler |
| CProfiler | Managed reference to ProfilerNode |
| CRunnerInputNode | Runner's input containing path of artifact, type of device and argument info |
| CRunnerInput | Managed reference to RunnerInputNode |
| CRunnerResultNode | Runner's output containing measurement result of MeasureCandidate or error msg if any |
| CRunnerResult | Managed reference to RunnerResultNode |
| CRunnerFutureNode | A class to asynchronously fetch runner's output |
| CRunnerFuture | Managed reference to RunnerFutureNode |
| CRunnerNode | The abstract runner interface |
| CRunner | Managed reference to RunnerNode |
| CPyRunnerNode | An abstract runner with customized build method on the python-side |
| CScheduleRuleNode | Rules to modify a block in a schedule |
| CScheduleRule | Managed reference to ScheduleRuleNode |
| CPyScheduleRuleNode | The schedule rule with customized methods on the python-side |
| CSearchStrategyNode | The search strategy for measure candidates generation |
| CSearchStrategy | Managed reference to SearchStrategyNode |
| CPySearchStrategyNode | The python side customizable class for measure candidate generation |
| CSpaceGeneratorNode | The abstract class for design space generation |
| CSpaceGenerator | Managed reference to SpaceGeneratorNode |
| CPySpaceGeneratorNode | The design space generator with customized methods on the python-side |
| CTaskRecordNode | |
| CTaskRecord | Managed reference to TaskRecordNode |
| CTaskSchedulerNode | The abstract interface of task schedulers |
| CPyTaskSchedulerNode | The task scheduler with customized methods on the python-side |
| CTaskScheduler | Managed reference to TaskSchedulerNode |
| CTuneContextNode | The auto tuning context |
| CTuneContext | Managed reference to TuneContextNode |
| ►Nrelax | |
| ►Ndistributed | |
| CAxis | Tensor axis |
| CAxisHash | |
| CAxisGroupHash | |
| CAxisShardingSpecEqual | |
| CAxisShardingSpecHash | |
| CAxisGroupGraph | A graph whose nodes are tensor axes, and the edge means some information can be propagated through the two axes. Although it only does sharding propagation, this data structure can be extended to perform all kinds of propagation that happens on tensor axes |
| CDeviceMeshNode | |
| CDeviceMesh | Managed reference to a DeviceMesh |
| CPlacementSpecNode | Describes how data is distributed in one dimension of the device mesh |
| CPlacementSpec | Managed reference to PlacementSpecNode |
| CShardingNode | |
| CPlacementNode | Describes how data is distributed in each dimension of the device mesh |
| CPlacement | Managed reference to a Placement |
| CDTensorStructInfoNode | StructInfo of DTensor (Distributed Tensor) |
| CDTensorStructInfo | Managed reference to DTensorStructInfoNode |
| ►Ntransform | |
| CFusionPatternNode | The pattern object used as the input of FuseOpsByPattern. For bindings to be fused, it needs to be matched with pattern and the check function needs to return true |
| CFusionPattern | |
| CPatternCheckContextNode | The input of FusionPattern::check |
| CPatternCheckContext | |
| CVarUsageInfo | A utility struct returned by CollectVarUsage |
| CAllReduceAttrs | Attributes used in allreduce operators |
| CAllGatherAttrs | Attributes used in allgather operators |
| CScatterCollectiveAttrs | Attributes used in scatter operators |
| CInitAttrs | Attributes used in full/full_like, ones/ones_like, and zeros/zeros_like operators |
| CTriluAttrs | Attributes used in tril and triu operator |
| CAstypeAttrs | Attributes used in astype operator |
| CWrapParamAttrs | Attributes used in wrap_param operator |
| CDistributionAttrs | Attributes for redistribute and annotate_sharding operator |
| CResize2DAttrs | Attributes used in image resize2d operator |
| CTakeAttrs | Attributes used in take operator |
| CStridedSliceAttrs | Attributes used in strided_slice operator |
| CMatmulAttrs | Attributes for matmul operator |
| CEinsumAttrs | Attributes used in einsum operator |
| CConcatAttrs | Attributes used in concat operators |
| CExpandDimsAttrs | Attributes used in expand_dims operators |
| CLayoutTransformAttrs | Attributes used in layout_transform operator |
| CPermuteDimsAttrs | Attributes used in permute_dims operator |
| CSplitAttrs | Attributes used in split operator |
| CSqueezeAttrs | Attributes used in squeeze operators |
| CRepeatAttrs | Attributes used in repeat operators |
| CTileAttrs | Attributes used in tile operators |
| CFlipAttrs | Attributes used in flip operators |
| CGatherElementsAttrs | Attributes used in gather_elements operators |
| CGatherNDAttrs | Attributes used in gather_nd operators |
| CScatterElementsAttrs | Attributes used in scatter_elements operators |
| CScatterNDAttrs | Attributes used in scatter_nd operators |
| COneHotAttrs | Attributes used in one_hot operator |
| CConv1DAttrs | Attributes used in Conv1d operator |
| CConv2DAttrs | Attributes used in Conv2d operator |
| CConv3DAttrs | Attributes used in Conv3d operator |
| CConv1DTransposeAttrs | Attributes used in Conv1DTranspose operator |
| CConv2DTransposeAttrs | Attributes used in Conv2d operator |
| CPool1DAttrs | Attributes used in max_pool1d and avg_pool1d operator |
| CPool2DAttrs | Attributes used in max_pool2d and avg_pool2d operator |
| CPool3DAttrs | Attributes used in max_pool3d and avg_pool3d operator |
| CAdaptivePool1DAttrs | Attributes for 1d adaptive pool operator |
| CAdaptivePool2DAttrs | Attributes for 2d adaptive pool operator |
| CAdaptivePool3DAttrs | Attributes for 3d adaptive pool operator |
| CSoftmaxAttrs | Attributes used in softmax operators |
| CLeakyReluAttrs | Attributes used in softmax operators |
| CBatchNormAttrs | Attributes used in batch_norm operator |
| CLayerNormAttrs | Attributes used in layer_norm operator |
| CGroupNormAttrs | Attributes used in group_norm operator |
| CRMSNormAttrs | Attributes used in rms_norm operator |
| CNLLLossAttrs | Attributes used in nll_loss operator |
| CDropoutAttrs | Attributes used in dropout operator |
| CAttentionAttrs | Attributes used in Attention operator |
| CPadAttrs | Attributes used for the padding operator |
| CCallTIRWithGradAttrs | Attributes used in call_tir_with_grad |
| CCallTIRInplaceAttrs | Attributes used in call_tir_inplace |
| CCallInplacePackedAttrs | Attributes used in call_inplace_packed |
| CToVDeviceAttrs | Attributes used in to_vdevice |
| CHintOnDeviceAttrs | Attributes used in hint_on_device |
| CQuantizeAttrs | Attributes for relax.quantize/relax.dequantize operator |
| CMultinomialFromUniformAttrs | Attributes used in multinomial_from_uniform operator |
| CArgmaxArgminAttrs | Attributes for search operators |
| CSortAttrs | Attributes used in sort operator |
| CArgsortAttrs | Attributes used in argsort operator |
| CTopKAttrs | Attributes used in topk operator |
| CStatisticalAttrs | Attributes for statistical operators |
| CScanopAttrs | Attributes used in scan operators like cumsum, cumprod |
| CDataflowBlockRewriteNode | Statement rewriter for relax.DataflowBlock |
| CDataflowBlockRewrite | A statement rewriter for relax.DataflowBlock |
| CBlockBuilderNode | A builder to build Relax binding blocks |
| ►CBlockBuilder | |
| CDisableOperatorSpecificNormalizationForTVMScript | A marker struct to disable FNormalize |
| CDFPatternNode | Base type of all dataflow patterns |
| CDFPattern | Managed reference to dataflow patterns |
| CPairCons | Constraint of a DFPattern edge (producer -> consumer) in graph-level matching |
| CDFConstraintNode | Additional constraints on the graph |
| CDFConstraint | |
| CPatternSeqNode | A sequence of DFPatterns that the previous DFPattern is connected to the next one |
| CPatternSeq | Managed reference to pattern sequences |
| CPatternContextNode | A context to manage the graph-level pattern matching |
| CPatternContext | Managed reference to a pattern context |
| CExprPatternNode | Pattern for Relax Expression |
| CExprPattern | Managed reference to an ExprPattern |
| CVarPatternNode | A Pattern to Match a Relax Variable |
| CVarPattern | Managed reference to a VarPattern |
| CDataflowVarPatternNode | A Pattern to Match a Relax Dataflow Variable |
| CDataflowVarPattern | Managed reference to a DataflowVarPattern |
| CGlobalVarPatternNode | A Pattern to Match a Relax Global Variable |
| CGlobalVarPattern | Managed reference to a GlobalVarPattern |
| CConstantPatternNode | A Pattern to Match a Relax Constant |
| CConstantPattern | Managed reference to a ConstantPattern |
| CCallPatternNode | A pattern to match a callable node in Relax |
| CCallPattern | |
| CPrimArrPatternNode | A pattern to match an array of PrimExpr |
| CPrimArrPattern | Managed reference to a PrimArrPattern |
| CFunctionPatternNode | A pattern to match a Relax Function |
| CFunctionPattern | Managed reference to FunctionPatternNode |
| CTuplePatternNode | Pattern to match a tuple of ordered expressions |
| CTuplePattern | Managed reference to TuplePatternNode |
| CUnorderedTuplePatternNode | A pattern to match multiple expressions unorderedly |
| CUnorderedTuplePattern | Managed reference to UnorderedTuplePatternNode |
| CTupleGetItemPatternNode | A pattern to match n'th indexing to a tuple |
| CTupleGetItemPattern | Managed reference to TupleGetItemPatternNode |
| CAndPatternNode | Match a conjunction of other patterns |
| CAndPattern | Managed reference to AndPatternNode |
| COrPatternNode | Match a disjunction of other patterns |
| COrPattern | Managed reference to OrPatternNode |
| CNotPatternNode | Pattern for rejecting a certain pattern |
| CNotPattern | Managed reference to NotPatternNode |
| CWildcardPatternNode | Wildcard Pattern is a pattern that can match anything |
| CWildcardPattern | Managed reference to WildcardPatternNode |
| CTypePatternNode | Pattern for matching a certain type |
| CTypePattern | Managed reference to TypePatternNode |
| CStructInfoPatternNode | Pattern for matching a certain struct info |
| CStructInfoPattern | |
| CShapePatternNode | A pattern that asserting a root pattern has a certain shape |
| CShapePattern | Managed reference to ShapePatternNode |
| CSameShapeConstraintNode | A pattern that asserting multiple root patterns have the same shape |
| CSameShapeConstraint | Managed reference to SameShapePatternNode |
| CDataTypePatternNode | A pattern that asserting a root pattern has a certain data type |
| CDataTypePattern | Managed reference to DataTypePatternNode |
| CAttrPatternNode | A pattern that asserting a root pattern has certain attributes |
| CAttrPattern | Managed reference to AttrPatternNode |
| CExternFuncPatternNode | A pattern of external function |
| CExternFuncPattern | Managed reference to ExternFuncPatternNode |
| CDFPatternFunctor | A dynamical functor that dispatches on in the first DFPattern argument |
| CDFPatternFunctor< R(const DFPattern &n, Args...)> | |
| CDFPatternVisitor | A simple visitor wrapper around DFPatternFunctor. Recursively visit the content |
| CExecBuilderNode | A builder provides api to build VM executable with instructions |
| CExecBuilder | |
| CIdNode | The unique identifier of variables |
| CId | |
| CStructInfoNode | Base type of all structure information |
| CStructInfo | Managed reference to StructInfoNode |
| CCallNode | Call corresponds to callable invocation. Corresponds to operation in computational graph terminology |
| CCall | |
| CTupleNode | Tuple container |
| CTuple | |
| CTupleGetItemNode | Get index-th field out of a tuple |
| CTupleGetItem | |
| CLeafExprNode | Base type of all (non-function) leaf Exprs |
| CLeafExpr | Managed reference to BaseExprNode |
| CShapeExprNode | A shape expression which allows users to construct a shape containing PrimExpr |
| CShapeExpr | |
| CVarNode | The variable class for all Relax bindings |
| CVar | |
| CDataflowVarNode | A sub-type of the variable node used to mark dataflow variables from normal visible "function local" bindings |
| CDataflowVar | |
| CConstantNode | Constant tensor |
| CConstant | |
| CPrimValueNode | PrimValue |
| CPrimValue | Managed reference to PrimValueNode |
| CStringImmNode | Represent a string literal constant |
| CStringImm | Managed reference to StringImm |
| CDataTypeImmNode | Represent a data type constant |
| CDataTypeImm | Managed reference to DataTypeImm |
| CBindingNode | The base class of a variable binding in Relax |
| CBinding | |
| CMatchCastNode | Runtime-match the value to the struct info |
| CMatchCast | Managed reference to MatchCastNode |
| CVarBindingNode | |
| CVarBinding | |
| CBindingBlockNode | |
| CBindingBlock | |
| CDataflowBlockNode | |
| CDataflowBlock | |
| CSeqExprNode | A sequence of blocks followed by an expression |
| CSeqExpr | |
| CIfNode | Condition expression |
| CIf | |
| CFunctionNode | A Relax function |
| CFunction | |
| CExternFuncNode | The extern function, which can represent packed function |
| CExternFunc | |
| CExprFunctor | A dynamical functor that dispatches on in the first Expr argument. You can use this as a more powerful Visitor, since it allows you to define function signatures of Visit Function |
| CExprFunctor< R(const Expr &n, Args...)> | |
| CExprVisitor | A simple visitor wrapper around ExprFunctor. Recursively visit the content |
| CExprMutatorBase | A mutator works in unnormalized form |
| CExprMutator | A mutator works in normal form |
| CNestedMsg | Container that stores possibly nested message with leaf message type T |
| CObjectStructInfoNode | Opaque object |
| CObjectStructInfo | Managed reference to ObjectStructInfoNode |
| CPrimStructInfoNode | Primitive value |
| CPrimStructInfo | Managed reference to PrimStructInfoNode |
| CShapeStructInfoNode | StructInfo of shape value |
| CShapeStructInfo | Managed reference to ShapeStructInfoNode |
| CTensorStructInfoNode | StructInfo of Tensor |
| CTensorStructInfo | Managed reference to TensorStructInfoNode |
| CTupleStructInfoNode | StructInfo of Tuple |
| CTupleStructInfo | Managed reference to TupleStructInfoNode |
| CFuncStructInfoNode | Structure information about function |
| CFuncStructInfo | Managed reference to FuncStructInfoNode |
| CStructInfoFunctor | |
| CStructInfoFunctor< R(const StructInfo &n, Args...)> | |
| CStructInfoVisitor | A struct info visitor |
| CStructInfoMutator | StructInfoMutator that mutates struct info |
| CMatchResultNode | |
| CMatchResult | Managed reference to MatchResultNode |
| CChoiceNode | Choice manages a set of keys for transformation and constraint functions |
| CChoice | Managed reference to ChoiceNode |
| CKnobNode | Knob manages a set of valid choices for an optimization |
| CKnob | Managed reference to KnobNode |
| CTraceNode | Trace manages history of optimization decisions |
| CTrace | Managed reference to TraceNode |
| CTuningRecordNode | The class of tuning records |
| CTuningRecord | The managed reference of TuningRecordNode |
| CWorkloadEqual | The equality check for Workload |
| CDatabaseNode | |
| CDatabase | Managed reference to DatabaseNode |
| CShapeTypeNode | |
| CShapeType | |
| CTensorTypeNode | Dynamic version of TensorType |
| CTensorType | Managed reference to TensorTypeNode |
| CObjectTypeNode | |
| CObjectType | |
| CPackedFuncTypeNode | |
| CPackedFuncType | |
| ►Nruntime | |
| ►Ncuda_ipc | |
| CCUDAIPCMemoryObj | The CUDA IPC (interprocess communication) memory object, which internally contains data pointers to CUDA IPC memory. It is be useful for efficient all-reduce implementation |
| CCUDAIPCMemory | Managed reference to CUDAIPCMemoryObj |
| ►Nmemory | |
| CBuffer | |
| CAllocator | |
| CMemoryManager | |
| CStorageObj | An object representing a storage allocation |
| CStorage | Reference to storage |
| ►Nprofiling | |
| CDeviceWrapperNode | Wrapper for Device because Device is not passable across the PackedFunc interface |
| CDeviceWrapper | Wrapper for Device |
| CReportNode | Data collected from a profiling run. Includes per-call metrics and per-device metrics |
| CReport | |
| CMetricCollectorNode | Interface for user defined profiling metric collection |
| CMetricCollector | Wrapper for MetricCollectorNode |
| CCallFrame | |
| CProfiler | |
| CDurationNode | |
| CPercentNode | |
| CCountNode | |
| CRatioNode | |
| ►Nrelax_vm | |
| ►CInstruction | A single virtual machine instruction |
| CArg | The auxiliary data structure for instruction argument |
| CVMFuncInfo | Information entry in executable function table |
| CVMExecutable | The virtual machine executable emitted by the VM compiler |
| ►CNDArrayCacheMetadata | Metadata for NDArray cache, which by default, is named as "ndarray-cache.json" |
| ►CFileRecord | Each shard of NDArray cache, which by default, is named as "params_shard_x.bin" |
| CParamRecord | Metadata of each parameter |
| CVMClosureObj | An object representing a vm closure |
| CVMClosure | Reference to closure |
| CVMExtensionNode | Represent a VM extension. A VM extension allows the user to extend the VM with target specific functionalities. The VM holds the reference of the extensions to ensure the extensions have the same lifetime as the VM |
| CVMExtension | Managed reference to VM extension |
| CVirtualMachine | The virtual machine |
| ►Nthreading | |
| CThreadGroup | A platform-agnostic abstraction for managing a collection of thread pool threads |
| CPackedFuncValueConverter< tvm::IntImm > | |
| CPackedFuncValueConverter< tvm::Integer > | |
| CPackedFuncValueConverter< tvm::Bool > | |
| CPackedFuncValueConverter< tvm::FloatImm > | |
| CPackedFuncValueConverter< runtime::Int > | |
| CArrayNode | Array node content in array |
| Cis_valid_iterator | Helper struct for type-checking |
| Cis_valid_iterator< Optional< T >, IterType > | |
| ►CArray | Array, container representing a contiguous sequence of ObjectRefs |
| CValueConverter | |
| CObjectHash | String-aware ObjectRef equal functor |
| CObjectEqual | String-aware ObjectRef hash functor |
| CInplaceArrayBase | Base template for classes with array like memory layout |
| CIterAdapter | Iterator adapter that adapts TIter to return another type |
| CReverseIterAdapter | Iterator adapter that adapts TIter to return another type |
| CBoxNode | |
| CBox | |
| ►CMapNode | Shared content of all specializations of hash map |
| Citerator | |
| CSmallMapNode | A specialization of small-sized hash map |
| CDenseMapNode | A specialization of hash map that implements the idea of array-based hash map. Another reference implementation can be found [1] |
| ►CMap | Map container of NodeRef->NodeRef in DSL graph. Map implements copy on write semantics, which means map is mutable but copy will happen when array is referenced in more than two places |
| Citerator | Iterator of the hash map |
| CNullOptType | Helper to represent nullptr for optional |
| COptional | Optional container that to represent to a Nullable variant of T |
| ►CShapeTupleObj | An object representing a shape tuple |
| CFromStd | An object representing shape tuple moved from std::vector |
| CShapeTuple | Reference to shape tuple objects |
| ►CStringObj | An object representing string. It's POD type |
| CFromStd | An object representing string moved from std::string |
| CString | Reference to string objects |
| CVariant | |
| CDataType | Runtime primitive data type |
| CDeviceAPI | TVM Runtime Device API, abstracts the device specific interface for memory management |
| CDiscoWorker | A worker in Disco. It takes a channel to communication with the controler. The worker can be run in a separate thread or process as long as the channel supports bi-directional communication in-between |
| CThreadLocalDiscoWorker | A threadlocal wrapper of DiscoWorker |
| CDRefObj | An object that exists on all workers |
| CDRef | Managed reference to DRefObj |
| CSessionObj | A Disco interactive session. It allows users to interact with the Disco command queue with various PackedFunc calling convention |
| CSession | Managed reference to SessionObj |
| CDiscoChannel | A bi-directional channel for controler-worker communication. This channel is primarily used to transfer control messages but not data |
| CWorkerZeroData | A special communication channel between controler and worker-0, assuming they are always collocated in the same process |
| CObjAllocatorBase | Base class of object allocators that implements make. Use curiously recurring template pattern |
| ►CSimpleObjAllocator | |
| CArrayHandler | |
| CHandler | |
| CModule | Module container of TVM |
| CModuleNode | Base container of module |
| ►CNDArray | Managed NDArray. The array is backed by reference counted blocks |
| CContainer | Object container class that backs NDArray |
| CContainerBase | The container base structure contains all the fields except for the Object header |
| CNVTXScopedRange | A class to create a NVTX range. No-op if TVM is not built against NVTX |
| CTypeIndex | Namespace for the list of type index |
| CObject | Base class of all object containers |
| CObjectPtr | A custom smart pointer for Object |
| CObjectRef | Base class of all object reference |
| CObjectPtrHash | ObjectRef hash functor |
| CObjectPtrEqual | ObjectRef equal functor |
| CTypedPackedFunc | Please refer to TypedPackedFunc<R(Args..)> |
| CSignaturePrinter | |
| ►CPackedFuncObj | Object container class that backs PackedFunc |
| CExtractor | Internal struct for extracting the callable method from callable type |
| CPackedFuncSubObj | Derived object class for constructing PackedFuncObj |
| CPackedFunc | Packed function is a type-erased function. The arguments are passed by packed format |
| CTypedPackedFunc< R(Args...)> | A PackedFunc wrapper to provide typed function signature. It is backed by a PackedFunc internally |
| CTVMArgs | Arguments into TVM functions |
| CObjectTypeChecker | Type traits for runtime type check during FFI conversion |
| CObjectTypeChecker< Array< T > > | |
| CObjectTypeChecker< Map< K, V > > | |
| CObjectTypeChecker< Variant< OnlyVariant > > | |
| CObjectTypeChecker< Variant< FirstVariant, RemainingVariants... > > | |
| CTVMPODValue_ | Internal base class to handle conversion to POD values |
| CTVMPODValue_CRTP_ | A utility class that adds methods useful for each POD type |
| CTVMArgValue | A single argument value to PackedFunc. Containing both type_code and TVMValue |
| CTVMMovableArgValue_ | Internal auxiliary struct for TypedPackedFunc to indicate a movable argument |
| CTVMMovableArgValueWithContext_ | Internal auxiliary struct for TypedPackedFunc to indicate a movable argument with additional context information (function name and argument index) for better error reporting |
| CTVMRetValue | Return Value container, Unlike TVMArgValue, which only holds reference and do not delete the underlying container during destruction |
| CPackedFuncValueConverter | Type trait to specify special value conversion rules from TVMArgValue and TVMRetValue |
| CTVMArgsSetter | |
| CTVMArgsSetterApply | |
| CPackedFuncValueConverter<::tvm::runtime::String > | |
| CPackedFuncValueConverter< Array< T > > | |
| CPackedFuncValueConverter< Map< T, U > > | |
| CPackedFuncValueConverter< Optional< T > > | |
| CPackedFuncValueConverter< Variant< VariantTypes... > > | |
| CTimerNode | Base class for all implementations |
| CTimer | Timer for a specific device |
| CWrappedPythonObject | A class that wraps a Python object and preserves its ownership |
| CRegistry | Registry for global function |
| CPackedFuncValueConverter< tvm::tir::StringImm > | |
| CPackedFuncValueConverter< PrimExpr > | |
| ►Nscript | |
| ►Nir_builder | |
| ►Ndetails | |
| CNamer | |
| ►Nir | |
| CIRModuleFrameNode | A frame that represents the IRModule frame with functions and global variables |
| CIRModuleFrame | Managed reference to IRModuleFrameNode |
| ►Nrelax | |
| CRelaxFrameNode | The base ir_builder frame for the relax dialect |
| CRelaxFrame | |
| CSeqExprFrameNode | The base ir_builder frame for frames with SeqExpr i.e. Functions, If branches |
| CSeqExprFrame | |
| CFunctionFrameNode | The ir_builder frame for the relax function |
| CFunctionFrame | |
| CBlockFrameNode | The ir_builder frame for relax binding blocks |
| CBlockFrame | |
| CIfFrameNode | A frame that represents if statement |
| CIfFrame | Managed reference to IfFrameNode |
| CThenFrameNode | A frame that represents then |
| CThenFrame | Managed reference to ThenFrameNode |
| CElseFrameNode | A frame that represents else |
| CElseFrame | Managed reference to ElseFrameNode |
| ►Ntir | |
| CTIRFrameNode | A base frame that represents the TIR fame with body of statements |
| CTIRFrame | Managed reference to TIRFrameNode |
| CPrimFuncFrameNode | A frame that represents the PrimFunc containing TIR statements |
| CPrimFuncFrame | Managed reference to PrimFuncFrameNode |
| CBlockFrameNode | A frame that represents the block |
| CBlockFrame | Managed reference to BlockFrameNode |
| CBlockInitFrameNode | A frame that represents the block initialization statment |
| CBlockInitFrame | Managed reference to BlockInitFrameNode |
| CForFrameNode | A frame that represents the for loop |
| CForFrame | Managed reference to ForFrameNode |
| CAssertFrameNode | A frame that represents the assert statement. Proceeds if the condition is true, otherwise aborts with the message |
| CAssertFrame | Managed reference to AssertFrameNode |
| CLetFrameNode | A frame represents the let binding expression, which binds a var |
| CLetFrame | Managed reference to LetFrameNode |
| CLaunchThreadFrameNode | The LaunchThreadFrameNode |
| CLaunchThreadFrame | Managed reference to LaunchThreadFrameNode |
| CRealizeFrameNode | A frame that represents realization |
| CRealizeFrame | Managed reference to RealizeFrameNode |
| CAllocateFrameNode | A frame represents the allocate |
| CAllocateFrame | Managed reference to AllocateFrameNode |
| CAllocateConstFrameNode | A frame represents the allocate constant |
| CAllocateConstFrame | Managed reference to AllocateConstFrameNode |
| CAttrFrameNode | A frame that represents attribute node |
| CAttrFrame | Managed reference to AttrFrameNode |
| CWhileFrameNode | A frame that represents while loop |
| CWhileFrame | Managed reference to WhileFrameNode |
| CIfFrameNode | A frame that represents if statement |
| CIfFrame | Managed reference to IfFrameNode |
| CThenFrameNode | A frame that represents then |
| CThenFrame | Managed reference to ThenFrameNode |
| CElseFrameNode | A frame that represents else |
| CElseFrame | Managed reference to ElseFrameNode |
| CDeclBufferFrameNode | |
| CDeclBufferFrame | |
| CIRBuilderFrameNode | |
| CIRBuilderFrame | Managed reference to an IRBuilderFrameNode |
| CIRBuilderNode | A dialect-agnostic IRBuilder that constructs any IR of TVM. An idiomatic use of this class is to put this inside the RAII with-scope, call dialect-specific methods accordingly. Upon exiting the scope |
| CIRBuilder | Managed reference to an IRBuilderNode |
| ►Nprinter | |
| CDocNode | The base class of all Doc |
| CDoc | Reference type of DocNode |
| CExprDocNode | The base class of expression doc |
| CExprDoc | Reference type of ExprDocNode |
| CStmtDocNode | The base class of statement doc |
| CStmtDoc | Reference type of StmtDocNode |
| CStmtBlockDocNode | The container doc that holds a list of StmtDoc |
| CStmtBlockDoc | Reference type of StmtBlockDocNode |
| CLiteralDocNode | Doc that represents literal value |
| CLiteralDoc | Reference type of LiteralDocNode |
| CIdDocNode | Doc that represents identifier |
| CIdDoc | Reference type of IdDocNode |
| CAttrAccessDocNode | Doc that represents attribute access on another expression |
| CAttrAccessDoc | Reference type of AttrAccessDocNode |
| CIndexDocNode | Doc that represents index access on another expression |
| CIndexDoc | Reference type of IndexDocNode |
| CCallDocNode | Doc that represents function call |
| CCallDoc | Reference type of CallDocNode |
| COperationDocNode | Doc that represents operation |
| COperationDoc | Reference type of OperationDocNode |
| CLambdaDocNode | Doc that represents anonymous function |
| CLambdaDoc | Reference type of LambdaDocNode |
| CTupleDocNode | Doc that represents tuple literal |
| CTupleDoc | Reference type of TupleDocNode |
| CListDocNode | Doc that represents list literal |
| CListDoc | Reference type of ListDocNode |
| CDictDocNode | Doc that represents dictionary literal |
| CDictDoc | Reference type of DictDocNode |
| CSliceDocNode | Doc that represents slice in Index expression |
| CSliceDoc | Reference type of SliceDocNode |
| CAssignDocNode | Doc that represents assign statement |
| CAssignDoc | Reference type of AssignDocNode |
| CIfDocNode | Doc that represent if-then-else statement |
| CIfDoc | Reference type of IfDocNode |
| CWhileDocNode | Doc that represents while statement |
| CWhileDoc | Reference type of WhileDocNode |
| CForDocNode | Doc that represents for statement |
| CForDoc | Reference type of ForDocNode |
| CScopeDocNode | Doc that represents special scopes |
| CScopeDoc | Reference type of ScopeDocNode |
| CExprStmtDocNode | Doc that represents an expression as statement |
| CExprStmtDoc | Reference type of ExprStmtDocNode |
| CAssertDocNode | Doc that represents assert statement |
| CAssertDoc | Reference type of AssertDocNode |
| CReturnDocNode | Doc that represents return statement |
| CReturnDoc | Reference type of ReturnDocNode |
| CFunctionDocNode | Doc that represents function definition |
| CFunctionDoc | Reference type of FunctionDocNode |
| CClassDocNode | Doc that represents class definition |
| CClassDoc | Reference type of ClassDocNode |
| CCommentDocNode | Doc that represents comment |
| CCommentDoc | Reference type of CommentDocNode |
| CDocStringDocNode | Doc that represents docstring |
| CDocStringDoc | Reference type of DocStringDocNode |
| CFrameNode | |
| CFrame | Reference type of FrameNode |
| ►CIRDocsifierNode | IRDocsifier is the top-level interface in the IR->Doc process |
| CVariableInfo | Information about a variable, including its optional name and its doc creator |
| CIRDocsifier | Reference type of IRDocsifierNode |
| CIRDocsifierFunctor | Dynamic dispatch functor based on ObjectPath |
| ►Nsupport | |
| CLinearCongruentialEngine | This linear congruential engine is a drop-in replacement for std::minstd_rand. It strictly corresponds to std::minstd_rand and is designed to be platform-independent |
| ►CSpan | A partial implementation of the C++20 std::span |
| Citerator_base | |
| ►Nte | Tensor expression language DSL |
| CTensorDom | Temporary data structure to store union of bounds of each axis of Tensor |
| COperationNode | Base class of all operation nodes |
| CPlaceholderOpNode | A placeholder op represents an input placeholder |
| CPlaceholderOp | Managed reference to PlaceholderOpNode |
| CBaseComputeOpNode | A Compute op that compute a tensor on certain domain. This is the base class for ComputeOp (operating on a scalar at a time) |
| CComputeOpNode | A Compute op that compute a tensor on certain domain |
| CComputeOp | Managed reference to ComputeOpNode |
| CScanOpNode | Symbolic scan |
| CScanOp | Managed reference to ScanOpNode |
| CExternOpNode | External computation that cannot be splitted |
| CExternOp | Managed reference to ExternOpNode |
| COperation | Operation that produces tensors |
| CTensorNode | Node to represent a tensor |
| ►CTensor | Tensor structure representing a possible input, or intermediate computation result |
| CSlice | Data structure to represent a slice that fixes first k coordinates. This is used to enable syntax sugar of Tensor[x][y][z] to get the element |
| ►Ntir | |
| CBufferAxisHash | |
| CBufferAxisGraphExtractor | Construct an axis group graph from a PrimFunc. Two buffer axis are connected if they are accessed by the same index |
| CExprDeepEqual | Compare two expressions recursively and check if they are equal to each other without var remapping |
| CMemCpyDetails | Helper struct for return value of IdentifyMemCpy |
| CBlockDependenceInfoNode | An object that helps build and query block level dependences using the 2 core objects BlockScope and StmtSRef |
| CBlockDependenceInfo | Managed reference to BlockDependenceInfoNode |
| CStmtSRefNode | An object that refers to schedulable elements (block/for-loop) in TensorIR, aka "sref" |
| CStmtSRef | Managed reference to StmtSRefNode |
| CSRefTreeCreator | |
| CDependencyNode | A tuple (src, dst, kind) representing certain types of dependency. For example, (A, B, kRAW) means block B depends on block A, and the dependency kind is read-after-write, which means block B reads the result written by block A |
| CDependency | Managed reference to DependencyNode |
| CBlockScopeNode | An object with 1-to-1 correspondence with each block reference in the sref tree. This data structure is used to track the producer-consumer dependencies between blocks. For example even leaf nodes have a scope node, even though they have no dependencies |
| CBlockScope | Managed reference to BlockScopeNode |
| CBufferNode | Node to represent a buffer |
| CBuffer | Buffer is a symbolic n-darray structure. It is a composition of primitive symbolic types, used to specify the memory layout of the Tensor used in program input |
| CDataProducerNode | Base node for data producers |
| CDataProducer | Managed reference to DataProducerNode |
| CLayoutAxis | |
| CLayoutNode | Layout is to describe how data is organized within an N-dimention tensor. It is composed of upper cases, lower cases and numbers, where upper case indicates a primal axis and the corresponding lower case with factor size indicates the subordinate axis. For example, NCHW16c can describe a 5-D tensor of [batch_size, channel, height, width, channel_block]. Here subordinate axis channel_block=16 is the factor size of the primal axis C (channel). Layout for scalar is defined, while both its name and axes have size 0 |
| CLayout | Managed reference to LayoutNode |
| CBijectiveLayoutNode | |
| CBijectiveLayout | Bijective function mapping for data layout transformation. Given two Layout, BijectiveLayout build and store the mapping rules, provides API to transform N-dimention tensor from the source indices (i0, i1, .., im) to the destination indices (j0, j1, .., jm) |
| CDataTypeLegalizer | Legalize the data types of expressions to make sure they are consistent with other parts of the program |
| CIndexDataTypeRewriter | Data type rewriter for buffer indices |
| CIndexDataTypeNormalizer | Normalize the data types of buffer shapes and indices to the same data type |
| CStringImmNode | String constants, only used in asserts |
| CStringImm | Managed reference to StringImmNode |
| CCastNode | Cast value from one data type to another |
| CCast | Managed reference to CastNode |
| CBinaryOpNode | Base template to implement binary ops |
| CAddNode |
|
| CAdd | Managed reference to AddNode |
| CSubNode |
|
| CSub | Managed reference to SubNode |
| CMulNode |
|
| CMul | Managed reference to MulNode |
| CDivNode | / b in the C semnatics |
| CDiv | Managed reference to DivNode |
| CModNode | % b in the C semnatics |
| CMod | Managed reference to ModNode |
| CFloorDivNode | Floor division, floor(a/b) |
| CFloorDiv | Managed reference to FloorDivNode |
| CFloorModNode | The remainder of the floordiv |
| CFloorMod | Managed reference to FloorModNode |
| CMinNode | Min(a, b) |
| CMin | Managed reference to MinNode |
| CMaxNode | Max(a, b) |
| CMax | Managed reference to MaxNode |
| CCmpOpNode | Base template to implement comparison ops |
| CEQNode | == b |
| CEQ | Managed reference to EQNode |
| CNENode | != b |
| CNE | Managed reference to NENode |
| CLTNode | < b |
| CLT | Managed reference to LTNode |
| CLENode | <= b |
| CLE | Managed reference to LENode |
| CGTNode | > b |
| CGT | Managed reference to GTNode |
| CGENode | >= b |
| CGE | Managed reference to GENode |
| CAndNode | && b |
| CAnd | Managed reference to AndNode |
| COrNode | || b |
| COr | Managed reference to OrNode |
| CNotNode | !a |
| CNot | Managed reference to NotNode |
| CSelectNode | Return true_value if condition is true, otherwise return false_value |
| CSelect | Managed reference to SelectNode |
| CBufferLoadNode | Load value from the high dimension buffer |
| CBufferLoad | Managed reference to BufferLoadNode |
| CProducerLoadNode | Load value from the result produced by the producer |
| CProducerLoad | Managed reference to ProducerLoadNode |
| CRampNode | Construct a vector with lanes elements where its i-th element equals base + i * stride. This is useful to construct a index for a continuous vector load |
| CRamp | Managed reference to RampNode |
| CBroadcastNode | Create a vector where all the elements are value |
| CBroadcast | Managed reference to BroadcastNode |
| CLetNode | Let binding. Bind var to value then evaluate body |
| CLet | Managed reference to LetNode |
| CCallNode | Call node |
| CCall | Managed reference to CallNode |
| CShuffleNode | Shuffle instruction. vec = concat(vectors) result = (vec[indices[0]], vec[indices[1]] ...) |
| CShuffle | Managed reference to ShuffleNode |
| CCommReducerNode | A commutative reducer node to represent a commutative binary operator with identity element |
| CCommReducer | Managed reference to CommReducerNode |
| CReduceNode | Reduction operator |
| CReduce | Managed reference to ReduceNode |
| CAnyNode | Any shape |
| CAny | Managed reference to AnyNode |
| CExprFunctor | A dynamical functor that dispatches on in the first Expr argument. You can use this as a more powerful Visitor, since it allows you to define function signatures of Visit Function |
| CExprFunctor< R(const PrimExpr &n, Args...)> | |
| CExprVisitor | ExprVisitor |
| CExprMutator | ExprMutator that mutates expressions |
| CPrimFuncNode | Primitive functions that contains TIR statements |
| CPrimFunc | Managed reference to PrimFuncNode |
| CTensorIntrinNode | Tensor intrinsics for tensorization |
| CTensorIntrin | Managed reference to TensorIntrinNode |
| CIndexMapNode | Defines a mapping between two representations of indices into a buffer |
| CIndexMap | |
| CInstructionKindNode | Kind of an instruction, e.g. Split, Reorder, etc. Besides the name, every kind of instruction has its own properties, including: 1) A boolean indicating if the instruction is pure, i.e. change nothing in the schedule state 2) A functor that applies the instruction to a TensorIR schedule 3) A functor that converts the instruction to a statement in python syntax 4) A functor that serialize its attributes to JSON 5) A functor that deserialize its attributes from JSON |
| CInstructionKind | Managed reference to InstructionKindNode |
| CInstructionNode | Schedule instructions each corresponds to a schedule primitive |
| CInstruction | Managed reference to InstructionNode |
| CInstructionKindRegEntry | An entry in the registry of InstructionKind |
| CBlockRVNode | A random variable that evaluates to a TensorIR block |
| CBlockRV | Managed reference to BlockRVNode |
| CLoopRVNode | A random variable that evaluates to a TensorIR for loop |
| CLoopRV | Managed reference to LoopRVNode |
| CScheduleNode | The user-facing schedule class |
| CSchedule | Managed reference to ScheduleNode |
| CBlockInfo | The information about a TensorIR block, it contains two categories of information 1) Info on the block scope rooted at a specific block, including dependency tracking, flags indicating if the scope is a stage pipeline, etc. 2) Info on the block itself, including if the block has a quasi-affine binding, if the regions it reads are completely covered by their producers, etc |
| CScheduleStateNode | The state of scheduling, which exposes a Replace method as the primary interface for all the scheduling primitives to manipulate the TensorIR |
| CScheduleState | Managed reference to ScheduleStateNode |
| CTraceNode | An execution trace of a scheduling program |
| CTrace | Managed reference to TraceNode |
| CStmtNode | Base node of all statements |
| CStmt | Container of all statements |
| CLetStmtNode | Let binding, bind var to value, then run body |
| CLetStmt | Managed reference to LetStmtNode |
| CAttrStmtNode | Define certain auxiliary attribute for the body to be a symbolic value. This provide auxiliary information for IR passes that transforms body |
| CAttrStmt | Managed reference to AttrStmtNode |
| CAssertStmtNode | Assert condition, if an error occurs, return the error message |
| CAssertStmt | Managed reference to AssertStmtNode |
| CBufferStoreNode | Store value to the high dimension buffer |
| CBufferStore | Managed reference to BufferStoreNode |
| CBufferRealizeNode | Annotate the region where the buffer need to be read and write in the body. We only need to allocate the space for the corresponding region |
| CBufferRealize | Managed reference to BufferRealizeNode |
| CProducerStoreNode | Store value into mult-dimensional array that will be read by the consumer of the producer |
| CProducerStore | Managed reference to ProducerStoreNode |
| CProducerRealizeNode | Annotate the bounds where the data produced by the producer need to be written and read in body. We will need to allocate space for the corresponding regions |
| CProducerRealize | Managed reference to ProducerRealizeNode |
| CAllocateNode | Allocate a buffer that can be used in body |
| CAllocate | Managed reference to AllocateNode |
| CAllocateConstNode | Allocate a buffer that can be used in body |
| CAllocateConst | Managed reference to AllocateConstNode |
| CDeclBufferNode | Declare a buffer that can be used in the body |
| CDeclBuffer | Managed reference to DeclBufferNode |
| CSeqStmtNode | The container of seq statement. Represent a sequence of statements |
| CEvaluateNode | Evaluates an expression. This is mostly used for putting a Call node into Stmt |
| CEvaluate | Managed reference to EvaluateNode |
| ►CSeqStmt | Sequence statement |
| CFlattener | Helper class to flatten sequence of arguments into Array |
| CIfThenElseNode | IfThenElse statement |
| CIfThenElse | Managed reference to IfThenElseNode |
| CForNode | A for loop, with possible type annotations |
| CFor | Managed reference to ForNode |
| CWhileNode | A While loop |
| CWhile | Managed reference to WhileNode |
| CPrefetchNode | A prefetch hint for a buffer |
| CPrefetch | Managed reference to PrefetchNode |
| CBufferRegionNode | Representing the region of multi-dimensional buffer access |
| CBufferRegion | Managed reference to BufferRegionNode |
| CMatchBufferRegionNode | Match introduces a constraint that the source buffer region can be remapped to the data layout specified by the buffer field. The constraint can be checked in later part of lowering (or optionally during runtime) |
| CMatchBufferRegion | Managed reference to MatchBufferRegionNode |
| CBlockNode | A block is a basic schedule unit in TIR |
| CBlock | Managed reference to BlockNode |
| CBlockRealizeNode | A block realization node represents execution of the block at the binding values |
| CBlockRealize | Managed reference to BlockRealizeNode |
| CStmtFunctor | Same as ExprFunctor except it is applied on statements |
| CStmtFunctor< R(const Stmt &n, Args... args)> | |
| CStmtVisitor | StmtVisitor |
| CStmtMutator | StmtMutator that mutates the statements |
| CStmtExprVisitor | Visitor that recursively visit stmts and exprs on them |
| CStmtExprMutator | Mutator that recursively mutates stmts and exprs on them |
| CVarNode | A variable node in the IR |
| CVar | Named variable in TIR |
| CSizeVarNode | A variable node represent a tensor index size, whose value must be non-negative |
| CSizeVar | Named variable represents a tensor index size |
| CIterVarNode | An iteration variable representing an iteration over a one dimensional interval |
| CIterVar | Iteration Variable, represents an iteration over an integer interval |
| ►Ntopi | |
| CEinsumEquation | |
| ►Ntransform | |
| CGlobalVarReplacer | |
| CPassContextNode | PassContextNode contains the information that a pass can rely on, such as analysis results |
| CPassContext | PassContext that is used to configure the pass behavior |
| CPassInfoNode | Meta data that will be used to help optimization and analysis |
| CPassInfo | Managed reference class for PassInfoNode |
| CPassNode | PassNode is the base type of differnt types of optimization passes. It is designed as a pure class and implemented by different pass subclasses at different granularity of Relax nodes |
| CPass | |
| CSequentialNode | The SequentialNode contains a set of passes that transform Relax programs from one AST to another semantically equivalent one |
| CSequential | |
| CAttrError | Error thrown during attribute checking |
| CAttrFieldInfoNode | Information about attribute fields in string representations |
| CAttrFieldInfo | AttrFieldInfo |
| CBaseAttrsNode | Base class of all attribute class |
| CAttrs | Managed reference to BaseAttrsNode |
| CDictAttrsNode | 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 |
| CDictAttrs | Managed reference to DictAttrsNode |
| CAttrsNode | The base class of the all the Use "curiously recurring template pattern" |
| CDiagnosticNode | A compiler diagnostic message |
| CDiagnostic | |
| CDiagnosticBuilder | A wrapper around std::stringstream to build a diagnostic |
| CDiagnosticRendererNode | Display diagnostics in a given display format |
| CDiagnosticRenderer | |
| CDiagnosticContextNode | |
| CDiagnosticContext | |
| CEnvFuncNode | A serializable function backed by TVM's global environment |
| CEnvFunc | Managed reference to EnvFuncNode |
| CTypedEnvFunc | Please refer to TypedEnvFunc<R(Args..)> |
| CTypedEnvFunc< R(Args...)> | A typed version of EnvFunc. It is backed by a GlobalFuncNode internally |
| CBaseExprNode | Base type of all the expressions |
| CBaseExpr | Managed reference to BaseExprNode |
| CPrimExprNode | Base node of all primitive expressions |
| CPrimExpr | Reference to PrimExprNode |
| CRelaxExprNode | Base node of all non-primitive expressions |
| CRelaxExpr | Managed reference to RelaxExprNode |
| CGlobalVarNode | Global variable that lives in the top-level module |
| CGlobalVar | Managed reference to GlobalVarNode |
| CIntImmNode | Constant integer literals in the program |
| CIntImm | Managed reference class to IntImmNode |
| CFloatImmNode | Constant floating point literals in the program |
| CFloatImm | Managed reference class to FloatImmNode |
| CBool | Boolean constant |
| CInteger | Container of constant int that adds more constructors |
| CRangeNode | Range over one dimension |
| CRange | Range container
|
| CBaseFuncNode | Base node of all functions |
| CBaseFunc | Managed reference to BaseFuncNode |
| CGlobalInfoNode | GlobalInfo are globally static object that are referred by the IR itself. Base node for all global info that can appear in the IR |
| CGlobalInfo | Managed reference to GlobalInfoNode |
| CVDeviceNode | A global info subclass for virtual devices |
| CVDevice | Managed reference to VDeviceNode |
| CDummyGlobalInfoNode | A dummy global info sub-class for testing purpose |
| CDummyGlobalInfo | Managed reference to DummyGlobalInfoNode |
| CGlobalVarSupplyNode | GlobalVarSupply can be used to generate unique GlobalVars |
| CGlobalVarSupply | Managed reference class to GlobalVarSupplyNode |
| CIRModuleNode | IRModule that holds functions and type definitions |
| CIRModule | Managed reference class to IRModuleNode |
| CNameSupplyNode | NameSupply can be used to generate unique names |
| CNameSupply | Managed reference class to NameSupplyNode |
| COpAttrMap | Map<Op,ValueType> used to store meta-information about Op |
| COpNode | Primitive Op(builtin intrinsics) |
| COp | Managed reference class to OpNode |
| COpRegEntry | Helper structure to register operators |
| CSourceNameNode | The name of a source fragment |
| CSourceName | The source name of a file span |
| CSpanNode | Stores locations in frontend source that generated a node |
| CSpan | |
| CSequentialSpanNode | Store a list of spans for an expr generated from mulitple source exprs |
| CSequentialSpan | Reference class of SequentialSpanNode |
| CSourceNode | |
| CSource | |
| CSourceMapNode | Stores locations in frontend source that generated a node |
| CSourceMap | |
| CTypeNode | Type is the base type of all types |
| CType | Managed reference to TypeNode |
| CPrimTypeNode | Primitive data types used in the low-level IR |
| CPrimType | |
| CPointerTypeNode | Low-level raw pointer type |
| CPointerType | |
| CTupleTypeNode | The type of tuple values |
| CTupleType | Managed reference to TupleTypeNode |
| CFuncTypeNode | Function type |
| CFuncType | Managed reference to FuncTypeNode |
| CTypeFunctor | |
| CTypeFunctor< R(const Type &n, Args...)> | |
| CTypeVisitor | A type visitor that recursively visit types |
| CTypeMutator | TypeMutator that mutates expressions |
| CAttrRegistryMapContainerMap | Generic attribute map |
| CAttrRegistryMap | Map<Key, ValueType> used to store meta-data |
| CNodeFunctor | A dynamically dispatched functor on the type of the first argument |
| CNodeFunctor< R(const ObjectRef &n, Args...)> | |
| CObjectPathNode | Path to an object from some root object |
| CObjectPath | |
| CRootPathNode | |
| CRootPath | |
| CAttributeAccessPathNode | |
| CAttributeAccessPath | |
| CUnknownAttributeAccessPathNode | |
| CUnknownAttributeAccessPath | |
| CArrayIndexPathNode | |
| CArrayIndexPath | |
| CMissingArrayElementPathNode | |
| CMissingArrayElementPath | |
| CMapValuePathNode | |
| CMapValuePath | |
| CMissingMapEntryPathNode | |
| CMissingMapEntryPath | |
| CAttrVisitor | Visitor class to get the attributes of an AST/IR node. The content is going to be called for each field |
| ►CReflectionVTable | Virtual function table to support IR/AST node reflection |
| CRegistry | Registry of a reflection table |
| CReprPrinter | A printer class to print the AST/IR nodes |
| CReprLegacyPrinter | Legacy behavior of ReprPrinter |
| CPrinterConfigNode | |
| CPrinterConfig | |
| CTVMScriptPrinter | Legacy behavior of ReprPrinter |
| CBaseValueEqual | Equality definition of base value class |
| CObjectPathPairNode | Pair of ObjectPaths, one for each object being tested for structural equality |
| CObjectPathPair | |
| CStructuralEqual | Content-aware structural equality comparator for objects |
| ►CSEqualReducer | A Reducer class to reduce the structural equality result of two objects |
| CHandler | Internal handler that defines custom behaviors. |
| CSEqualHandlerDefault | The default handler for equality testing |
| CBaseValueHash | Hash definition of base value classes |
| CStructuralHash | Content-aware structural hashing |
| ►CSHashReducer | A Reducer class to reduce the structural hash value |
| CHandler | Internal handler that defines custom behaviors |
| CSHashHandlerDefault | The default handler for hash key computation |
| CNDArrayContainerTrait | |
| CWith | RAII wrapper function to enter and exit a context object similar to python's with syntax |
| CTargetTagNode | A target tag |
| CTargetTag | Managed reference class to TargetTagNode |
| CTargetTagRegEntry | |
| CTargetNode | Compilation target |
| CTarget | Managed reference class to TargetNode |
| CMemoryInfoNode | Memory information of special memory region. Use MemoryInfo as its container type |
| CMemoryInfo | Defines memory info |
| CTargetKindAttrMap | Map<TargetKind, ValueType> used to store meta-information about TargetKind |
| CTargetKindNode | Target kind, specifies the kind of the target |
| CTargetKind | Managed reference class to TargetKindNode |
| CTargetKindRegEntry | Helper structure to register TargetKind |
| CVirtualDeviceNode | 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 Relax program |
| CVirtualDevice | Managed reference class to VirtualDeviceNode |
| CVirtualDeviceCache | A cache of VirtualDevices. This can be used: |
| CAttrRegistry | |
| CGlobalVar | |
| CTVMByteArray | Byte array type used to pass in byte array When kTVMBytes is used as data type |
| CTVMParallelGroupEnv | Environment for TVM parallel task |
| CTVMValue | Union type of values being passed through API and function calls |
1.9.1
