| ►Ndmlc | |
| ►Nserializer | |
| CHandler< DLDataType > | |
| CHandler< DLDevice > | |
| ►Ntvm | Runtime implementation for LibTorch/TorchScript |
| ►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 |
| Nattr | Generic attribute names that can be attached to any function |
| ►Nauto_scheduler | |
| CTuningOptionsNode | Tuning and measurement options |
| CTuningOptions | Managed reference to TuningOptionsNode |
| CAccessAnalyzerNode | Static analyzer for a ComputeDAG |
| CAccessAnalyzer | Managed reference to AccessAnalyzerNode |
| CComputeDAGNode | The auto-scheduler's computational graph and related program analyses |
| CComputeDAG | Managed reference to ComputeDAGNode |
| CCostModelNode | The base class for cost model |
| CCostModel | Managed reference to CostModelNode |
| CRandomModelNode | The cost model returning random value for all predictions |
| CRandomModel | Managed reference to RandomModelNode |
| CPythonBasedModelNode | A wrapper for cost model defined by python code This class will call functions defined in the python |
| CPythonBasedModel | Managed reference to PythonBasedModelNode |
| CStageAttributes | Stage-level attributes |
| CStageNode | A op stage in the compute declaration. Similar to te::Stage in include/tvm/te/schedule.h |
| CStage | Managed reference to StageNode |
| ►CAttachMapNode | Stores the compute_at relation between stages This stores a bi-directional mapping from stages and iter: |
| CIterKeyHash | |
| CAttachMap | Managed reference to AttachMapNode |
| CStateNode | A state in the search process. It consists of the current loop structure and a list of transformation steps used to construct it. Each State corresponds to a specific schedule for its ComputeDAG |
| CState | Managed reference to StateNode |
| CMeasureInputNode | Store the input of a measurement |
| CMeasureInput | Managed reference to MeasureInputNode |
| CBuildResultNode | Store the result of a build |
| CBuildResult | Managed reference to BuildResultNode |
| CMeasureResultNode | Store the results of a measurement |
| CMeasureResult | Managed reference to MeasureResultNode |
| CMeasureCallbackNode | Bass class of measurement callbacks |
| CMeasureCallback | Managed reference to MeasureCallbackNode |
| CPythonBasedMeasureCallbackNode | A wrapper for measure callback defined by python code This class will call functions defined in the python |
| CPythonBasedMeasureCallback | Managed reference to PythonBasedMeasureCallbackNode |
| CProgramBuilderNode | ProgramBuilder that builds the programs |
| CProgramBuilder | Managed reference to ProgramBuilderNode |
| CProgramRunnerNode | ProgramRunner that runs the built programs and measure the time cost |
| CProgramRunner | Managed reference to ProgramRunnerNode |
| CLocalBuilderNode | LocalBuilder use local CPU cores to build programs in parallel |
| CLocalBuilder | Managed reference to LocalBuilderNode |
| CLocalRunnerNode | LocalRunner that uses local CPU/GPU to measure the time cost of programs |
| CLocalRunner | Managed reference to LocalRunnerNode |
| CRPCRunnerNode | RPCRunner that uses RPC call to measures the time cost of programs on remote devices. Or sometime we may need to use RPC even in local running to insulate the thread environment. (e.g. running CUDA programs) |
| CRPCRunner | Managed reference to RPCRunnerNode |
| CProgramMeasurerNode | Measurer that measures the time costs of tvm programs This class combines ProgramBuilder and ProgramRunner, and provides a simpler API |
| CProgramMeasurer | Managed reference to ProgramMeasurerNode |
| CRecordToFileNode | Callback for logging the input and results of measurements to file |
| CRecordToFile | Managed reference to RecordToFileNode |
| CRecordReaderNode | Log reader to load step logs from a file |
| CRecordReader | Managed reference to RecordReaderNode |
| CSearchCallbackNode | Callback function to be called by the search process. This interface allows to do extra initializations before schedule search or extra check during/after the schedule search |
| CSearchCallback | Managed reference to SearchCallbackNode |
| CPreloadMeasuredStatesNode | Preload measured states from a log file. This can resume the state of the search policy |
| CPreloadMeasuredStates | Managed reference to PreloadMeasuredStatesNode |
| CSearchPolicyKey | Attribute keys of ops used for SearchPolicy |
| CSearchPolicyNode | The base class of search policies |
| CSearchPolicy | Managed reference to SearchPolicyNode |
| CHardwareParamsNode | The parameters of target hardware used to guide the SearchPolicy |
| CHardwareParams | Managed reference to HardwareParamsNode |
| CSearchTaskNode | The computation information and hardware parameters for a specific schedule search task |
| CSearchTask | Managed reference to SearchTaskNode |
| CIteratorNode | An iterator of a for-loop Similar to tvm::IterVar in include/tvm/tir/expr.h |
| CIterator | Managed reference to IteratorNode |
| CStepNode | The base class of transformation steps. Each step has its corresponding tvm.te schedule primitives |
| CStep | Managed reference to StepNode |
| CAnnotationStepNode | Annotation step that corresponds to vectorize, parallel, unroll and thread binding. (i.e. te::Stage::vectorize, te::Stage::parallel, te::Stage::vectorize, te::Stage::bind) |
| CAnnotationStep | Managed reference to AnnotationStepNode |
| CFuseStepNode | Fuse step that corresponds to te::Stage::fuse |
| CFuseStep | Managed reference to FuseStepNode |
| CPragmaStepNode | Pragma step that corresponds to te::Stage::pragma |
| CPragmaStep | Managed reference to PragmaStepNode |
| CReorderStepNode | Reorder step that corresponds to te::Stage::reorder |
| CReorderStep | Managed reference to ReorderStepNode |
| CSplitStepNode | Split step that corresponds to te::Stage::split with additional support of multiple-level of factors |
| CSplitStep | Managed reference to SplitStepNode |
| CFollowSplitStepNode | Similar to SplitStepNode, but uses split factors from another step (i.e. Follow another split step) |
| CFollowSplitStep | Managed reference to FollowSplitStepNode |
| CFollowFusedSplitStepNode | Similar to FollowSplitStep, but uses split factors from multiple steps |
| CFollowFusedSplitStep | Managed reference to FollowFusedSplitStepNode |
| CStorageAlignStepNode | Storage align step that corresponds to te::Stage::storage_align |
| CStorageAlignStep | Managed reference to StorageAlignStepNode |
| CComputeAtStepNode | Compute at step that corresponds to te::Stage::compute_at |
| CComputeAtStep | Managed reference to ComputeAtStepNode |
| CComputeInlineStepNode | Compute inline step that corresponds to te::Stage::compute_inline |
| CComputeInlineStep | Managed reference to ComputeInlineStepNode |
| CComputeRootStepNode | Compute root step that corresponds to te::Stage::compute_root |
| CComputeRootStep | Managed reference to ComputeRootStepNode |
| CCacheReadStepNode | Cache read step that corresponds to te::Schedule::cache_read |
| CCacheReadStep | Managed reference to CacheReadStepNode |
| CCacheWriteStepNode | Cache write step that corresponds to te::Schedule::cache_write |
| CCacheWriteStep | Managed reference to CacheWriteStepNode |
| CRfactorStepNode | Reduction factor step that corresponds to te::Schedule::rfactor |
| CRfactorStep | Managed reference to RfactorStepNode |
| Ncodegen | Namespace for target translation and codegen |
| ►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 |
| ►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 |
| ►Nrelay | Relay: a high level functional IR for TVM |
| Nattr | Namespace of the attributes that can be attached to a relay::Function |
| Nlegalize | |
| ►Nqnn | |
| Ntransform | |
| CRequantizeAttrs | Attribute for requantize operator |
| CQuantizeAttrs | Attribute for quantize operator |
| CSimulatedQuantizeAttrs | |
| CDequantizeAttrs | Attribute for dequantize operator |
| CBroadcastAttrs | Attribute for broadcast operator |
| Ntransform | |
| CPatternNode | Base type for declaring relay pattern |
| CPattern | Pattern is the base type for an ADT match pattern in Relay |
| CPatternWildcardNode | PatternWildcard container node |
| CPatternWildcard | |
| CPatternVarNode | PatternVar container node |
| CPatternVar | |
| CPatternConstructorNode | PatternVar container node |
| CPatternConstructor | |
| CPatternTupleNode | PatternVar container node |
| CPatternTuple | |
| CClauseNode | Clause container node |
| CClause | |
| CMatchNode | Match container node |
| CMatch | |
| CArgsortAttrs | Attributes used in argsort operators |
| CTopKAttrs | |
| CSearchSortedAttrs | |
| CCastHintAttrs | Annotate an expression to be cast into specific data type |
| CCompilerAttrs | Options for the operators used to annotate a compiler |
| CBitPackAttrs | Attributes used in bitpack operators |
| CBinaryConv2DAttrs | Attribues used in bitserial convolution operators |
| CBinaryDenseAttrs | |
| CCallLoweredAttrs | Metadata for calls to TIR functions, useful for program analysis crossing Relay and TIR |
| CDebugAttrs | Options for the debug operators |
| CDeviceCopyAttrs | Options for the device copy operators |
| CResize1DAttrs | Attributes used in image resize1d operator |
| CResize2DAttrs | Attributes used in image resize2d operator |
| CResize3DAttrs | Attributes used in image resize3d operator |
| CCropAndResizeAttrs | Attributes used in image crop_and_resize operator |
| CDilation2DAttrs | Attributes used in dilation operators |
| CAffineGridAttrs | Attributes used in image affine_grid operator |
| CGridSampleAttrs | Attributes used in image grid_sample operator |
| CAllocStorageAttrs | Options for allocating storage |
| CAllocTensorAttrs | Options for allocating tensors |
| CBiasAddAttrs | Add a 1D Tensor to an axis of a data |
| CConv1DAttrs | Attributes used in 1D convolution operators |
| CConv2DAttrs | Attributes used in convolution operators |
| CConvWinogradWeightTransformAttrs | Attributes used in winograd weight transformation operators |
| CConvGemmWeightTransformAttrs | Attributes used in gemm weight transformation operators |
| CConv2DWinogradAttrs | Attributes used in convolution operators with winograd algorithm |
| CConv2DWinogradNNPACKWeightTransformAttrs | Attributes used in winograd weight transformation operators |
| CConv3DAttrs | Attributes used in convolution operators |
| CConv3DTransposeAttrs | Attributes used in transposed convolution operator |
| CConv3DWinogradAttrs | Attributes used in 3d winograd convolution operators |
| CSoftmaxAttrs | Attributes used in softmax operators |
| CConv2DTransposeAttrs | Attributes used in transposed convolution operator |
| CDilateAttrs | Attributes used in dilate operator |
| CConv1DTransposeAttrs | Attributes used in 1D transposed convolution operator |
| CMaxPool2DAttrs | Attributes for max pool operator |
| CAvgPool2DAttrs | Attributes for avg pool operator |
| CGlobalPool2DAttrs | Attributes for global pool operator |
| CAdaptivePool1DAttrs | Attributes for 1d adaptive pool operator |
| CAdaptivePool2DAttrs | Attributes for 2d adaptive pool operator |
| CAdaptivePool3DAttrs | Attributes for 3d adaptive pool operator |
| CMaxPool1DAttrs | Attributes for 1D max pool operator |
| CAvgPool1DAttrs | Attributes for 1D avg pool operator |
| CMaxPool3DAttrs | Attributes for 3D max pool operator |
| CAvgPool3DAttrs | Attributes for 3D avg pool operator |
| CMatmulAttrs | Attributes for matmul operator |
| CDenseAttrs | Attributes for dense operator |
| CDensePackAttrs | Attributes for dense_pack operator |
| CBatchMatmulAttrs | Attributes for batch matmul operator |
| CSparseDenseAttrs | Attributes for sparse_dense operator |
| CSparseTransposeAttrs | Attributes for sparse_transpose operator |
| CSparseConv2DAttrs | Attributes for sparse_dense operator |
| CFIFOBufferAttrs | Attributes for FIFO buffer operator |
| CUpSamplingAttrs | Attributes for upsampling operator |
| CUpSampling3DAttrs | Attributes for upsampling3d operator |
| CPadAttrs | Attributes used for the padding operator |
| CMirrorPadAttrs | Attributes used for the MirrorPadding operator |
| CLeakyReluAttrs | Attributes for leaky relu operator |
| CPReluAttrs | Attributes for prelu operator |
| CDropoutAttrs | Attributes used in dropout operator |
| CBatchNormAttrs | Attributes used in batch_norm operator |
| CInstanceNormAttrs | Attributes used in instance_norm operator |
| CLayerNormAttrs | Attributes used in layer_norm operator |
| CGroupNormAttrs | Attributes used in group_norm operator |
| CLRNAttrs | Attributes for LRN operator |
| CL2NormalizeAttrs | Attributes for L2Normalize operator |
| CDeformableConv2DAttrs | Attributes for DeformableConv2D operator |
| CSubPixelAttrs | Attributes used in subpixel operators |
| CCorrelationAttrs | Attributes used in correlation operators |
| CSpaceToBatchNDAttrs | Attributes used in SpaceToBatchND operator |
| CBatchToSpaceNDAttrs | Attributes used in BatchToSpaceND operator |
| CNLLLossAttrs | Attributes used in NLLLoss operator |
| COnDeviceAttrs | Attributes for the "on_device" annotation (ie operator) |
| CThreefryGenerateAttrs | |
| CUniformAttrs | |
| CNormalAttrs | |
| CMultinomialAttrs | |
| CReduceAttrs | Attributes for Reduce operators |
| CArgReduceAttrs | Attributes for Reduce operators which reduce by finding a single element. E.g. argmin |
| CVarianceAttrs | |
| CSlidingWindowAttrs | Attributes used for the sliding_window operator |
| CCastAttrs | Data type cast |
| CExpandDimsAttrs | Attributes used in expand_dims operators |
| CDynExpandDimsAttrs | Attributes used in dynamic expand_dims operators |
| CConcatenateAttrs | Attributes used in concatenate operators |
| CTransposeAttrs | Attributes used in transpose operators |
| CReshapeAttrs | Attributes used in reshape operators |
| CReshapeLikeAttrs | Attributes used in MXNet-style reshape_like operators |
| CScatterElementsAttrs | |
| CScatterNDAttrs | |
| CGatherAttrs | |
| CGatherNDAttrs | |
| CTakeAttrs | |
| CInitOpAttrs | Attributes that specify a tensor |
| CArangeAttrs | Attributes used in arange operators |
| CMeshgridAttrs | Attributes used in meshgrid operators |
| CStackAttrs | Attributes used in stack operators |
| CRepeatAttrs | Attributes used in repeat operators |
| CTileAttrs | Attributes used in tile operators |
| CReverseAttrs | Attributes used in reverse operators |
| CReverseSequenceAttrs | Attributes used in reverse_sequence operators |
| CSqueezeAttrs | Attributes used in squeeze operators |
| CSplitAttrs | |
| CStridedSliceAttrs | Attributes for StridedSlice operator |
| CSliceLikeAttrs | |
| CClipAttrs | Attributes for Clip operator |
| CFixedPointMultiplyAttrs | Attributes for FixedPointMultiply operator |
| CFixedPointMultiplyPerAxisAttrs | Attributes for per channel/per axes FixedPointMultiply operator |
| CLayoutTransformAttrs | Attributes for LayoutTransform operator |
| CAutoSchedulerLayoutTransformAttrs | Attributes for AutoSchedulerLayoutTransform operator |
| CMetaScheduleLayoutTransformAttrs | Attributes for MetaScheduleLayoutTransform operator |
| CShapeOfAttrs | Attributes for ShapeOf operator |
| CSequenceMaskAttrs | |
| CSparseToDenseAttrs | Attributes used in sparse_to_dense operator |
| CNdarraySizeAttrs | Attributes for ndarray_size operator |
| COneHotAttrs | Attributes used in one-hot operator |
| CMatrixSetDiagAttrs | Attributes used in matrix_set_diag operator |
| CScanopAttrs | Attributes used in cumsum and cumprod operator |
| CUniqueAttrs | Attributes used in unique operator |
| CEinsumAttrs | Attributes used in einsum operator |
| CStftAttrs | Attributes used in stft operator |
| CDFTAttrs | Attributes used in DFT operator |
| CTriluAttrs | |
| CMultiBoxPriorAttrs | Attributes used in multibox_prior operators |
| CMultiBoxTransformLocAttrs | |
| CGetValidCountsAttrs | Attributes used in get_valid_counts operator |
| CNonMaximumSuppressionAttrs | Attributes used in non_maximum_suppression operator |
| CAllClassNonMaximumSuppressionAttrs | Attributes used in all_class_non_maximum_suppression operator |
| CRegularNonMaximumSuppressionAttrs | Attributes used in regular_non_maximum_suppression operator |
| CROIAlignAttrs | Attributes used in roi_align operators |
| CROIPoolAttrs | Attributes used in roi_pool operators |
| CYoloReorgAttrs | Attributes used in yolo reorg operators |
| CProposalAttrs | Attributes used in proposal operators |
| CShapeFuncAttrs | Options for the shape function operator |
| CReshapeTensorAttrs | Attributes for VM reshape_tensor operator |
| CRelayNode | This is the base node container of all relay structures |
| CIdNode | The unique identifier of variables |
| CId | |
| CDFPatternCallbackNode | Base type of all dataflow pattern callbacks |
| CDFPatternCallback | Managed reference to dataflow pattern callbacks |
| CDFPatternNode | Base type of all dataflow patterns |
| CDFPattern | Managed reference to dataflow patterns |
| CExprPatternNode | Pattern for Relay Expression |
| CExprPattern | A pattern which matches a literal expression |
| CVarPatternNode | Container for Var |
| CVarPattern | |
| CConstantPatternNode | Container for Constant |
| CConstantPattern | |
| CCallPatternNode | CallPattern container |
| CCallPattern | |
| CFunctionPatternNode | Relay Function container |
| CFunctionPattern | Managed reference to FunctionNode |
| CLetPatternNode | A binding of a sub-network |
| CLetPattern | Let binding that binds a local var |
| CTuplePatternNode | Tuple container |
| CTuplePattern | |
| CTupleGetItemPatternNode | |
| CIfPatternNode | |
| CIfPattern | |
| CTupleGetItemPattern | |
| CAltPatternNode | Pattern for Alternate Expressions |
| CAltPattern | A pattern which matches either of two patterns |
| CWildcardPatternNode | Wildcard Pattern |
| CWildcardPattern | A pattern which matches anything |
| CTypePatternNode | Pattern for Types |
| CTypePattern | A pattern which matches a type in another pattern |
| CShapePatternNode | Pattern for Shapes |
| CShapePattern | A pattern which matches a type in another pattern |
| CDataTypePatternNode | Pattern for Types |
| CDataTypePattern | A pattern which matches a type in another pattern |
| CAttrPatternNode | Pattern for Attributes |
| CAttrPattern | A pattern which matches attributes in another pattern |
| CDominatorPatternNode | Dominated Graph Pattern Pattern for fuzzy subgraphs where all outputs of the parent are used finally by the child, and every operation between the parent and the child matches the path |
| CDominatorPattern | A pattern which matches a variable length dominator path |
| CDFPatternPrinter | A printer class to print pattern |
| 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 |
| CErrorBuilder | A wrapper around std::stringstream to build error. include/tvm/ir/type.h Can be consumed by CompileError to construct an error |
| CCompileError | Custom Error class to be thrown during compilation |
| CErrorReporter | 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 |
| CExecutorNode | Executor information |
| CExecutor | Managed reference class to ExecutorNode |
| CExecutorRegEntry | Helper structure to register Executors |
| CConstantNode | Constant tensor type |
| CConstant | |
| CTupleNode | Tuple container |
| CTuple | |
| CVarNode | Container for Var |
| CVar | |
| CCallNode | Call container |
| CCall | |
| CLetNode | A binding of a sub-network |
| CLet | |
| CIfNode | Container of If |
| CIf | |
| CTupleGetItemNode | |
| CTupleGetItem | |
| CRefCreateNode | |
| CRefCreate | |
| CRefReadNode | |
| CRefRead | |
| CRefWriteNode | |
| CRefWrite | |
| CTempExprNode | Base class of the temporary expression |
| CTempExpr | |
| 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 |
| CExprMutator | A wrapper around ExprFunctor which functionally updates the AST |
| CMixedModeVisitor | A wrapper around ExprVisitor which traverses the Dataflow Normal AST |
| CMixedModeMutator | Non-recursive DFS Graph Traversal for Custom Rewriting Passes |
| CExprRewriter | A non-iterating Expression Rewriter |
| Cv_info | A struct to keep info of traversed expr in ExpandDataflow function |
| CFeatureSet | A finite set of Feature |
| CFunctionNode | Relay Function container |
| CFunction | Managed reference to FunctionNode |
| CInterpreterClosureObj | The container type of Closures used by the interpreter |
| CInterpreterClosure | |
| CRecClosureObj | The container type of RecClosure |
| CRecClosure | |
| CRefValueObj | |
| CRefValue | |
| CConstructorValueObj | |
| CConstructorValue | |
| COpImplementationNode | Operator implementation that includes compute and schedule function |
| COpImplementation | Operator implementation class |
| COpSpecializationNode | Specialized implementations for operators under certain conditions |
| COpSpecialization | Operator specialization class |
| COpStrategyNode | Operator strategy to choose implementation |
| COpStrategy | Operator strategy class |
| CPatternFunctor | A dynamical functor on ADT patterns that dispatches on its first argument. You can use this as a more powerful visitor, since it allows you to define the types of further arguments to VisitPattern |
| CPatternFunctor< R(const Pattern &n, Args...)> | |
| CPatternVisitor | A simple visitor wrapper around PatternFunctor |
| CPatternMutator | A wrapper around ExprFunctor which functionally updates the AST |
| CRuntimeNode | Runtime information |
| CRuntime | Managed reference class to RuntimeNode |
| CRuntimeRegEntry | Helper structure to register Runtimes |
| ►Nruntime | |
| Ncontrib | |
| ►Nmemory | |
| CBuffer | |
| CAllocator | |
| CMemoryManager | |
| CStorageObj | An object representing a storage allocation |
| CStorage | Reference to storage |
| ►Nmetadata | |
| CMetadataNode | |
| CMetadata | |
| CTensorInfoNode | |
| CTensorInfo | |
| CConstantInfoMetadataNode | |
| CConstantInfoMetadata | |
| CMetadataBaseNode | Common base class for all Metadata |
| CMetadataBase | Reference class for the common MetadataBaseNode class |
| CArrayAccessor | A span-like class which permits access to Array fields with complex elements. These array fields should be accessed from C++ using the Metadata wrapper classes. This class lazily instantiates those wrappers as they are accessed |
| CArrayIterator | An iterator implementation that lazily instantiates the C++ wrapping Metadata class |
| CArrayAccessor< const char *, ::tvm::runtime::String > | A specialization of ArrayAccessor for String. This class is needed because the String constructor signature is different from the typical Metadata subclass |
| CMetadataArrayNode | Container for arrays in the metadata |
| CMetadataArray | Reference class for MetadataArray |
| ►Nmicro_rpc | |
| CFrameBuffer | |
| CPacketFieldSizeBytes | |
| CUnframer | |
| CFramer | |
| CSessionHeader | |
| CSession | CRT communication session management class. Assumes the following properties provided by the underlying transport: |
| CWriteStream | |
| ►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 | |
| Nsymbol | Namespace for constant symbols |
| ►Nthreading | |
| CThreadGroup | A platform-agnostic abstraction for managing a collection of thread pool threads |
| ►Nvm | |
| CInstruction | A single virtual machine instruction |
| CExecutable | The executable emitted by the VM compiler |
| CVMClosureObj | An object representing a vm closure |
| CVMClosure | Reference to closure |
| CVMFunction | A representation of a Relay function in the VM |
| CVMFrame | A representation of a stack frame |
| CVirtualMachine | The virtual machine |
| CPackedFuncValueConverter< PrimExpr > | |
| CPackedFuncValueConverter< tvm::Integer > | |
| CPackedFuncValueConverter< tvm::Bool > | |
| CADTObj | An object representing a structure or enumeration |
| CADT | Reference to algebraic data type objects |
| 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 |
| CClosureObj | An object representing a closure. This object is used by both the Relay VM and interpreter |
| CClosure | Reference to closure |
| ►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 |
| 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 |
| 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 > > | |
| CTVMPODValue_ | Internal base class to handle conversion to POD values |
| 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< 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 |
| ►Nscript | |
| ►Nir_builder | |
| ►Ndetails | |
| CNamer | |
| ►Nir | |
| CIRModuleFrameNode | A frame that represents the IRModule frame with functions and global variables |
| CIRModuleFrame | Managed reference to IRModuleFrameNode |
| ►Ntir | |
| Naxis | |
| 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) and TensorComputeOp (operating on a TensorSlice at a time) |
| CComputeOpNode | A Compute op that compute a tensor on certain domain |
| CComputeOp | Managed reference to ComputeOpNode |
| CTensorComputeOpNode | A TenorCompute op that compute a tensor with an tensor intrinsic |
| CTensorComputeOp | Managed reference to TensorComputeOpNode |
| CScanOpNode | Symbolic scan |
| CScanOp | Managed reference to ScanOpNode |
| CExternOpNode | External computation that cannot be splitted |
| CExternOp | Managed reference to ExternOpNode |
| CHybridOpNode | A computation operator that generated by hybrid script |
| CHybridOp | Managed reference to HybridOpNode |
| CStage | Stage, contains scheduling for a stage of computation |
| CSchedule | Global schedule container For operations and all the operations they depend on. The schedule per Operation is named as stage |
| CScheduleContext | Context helper to collect debug information of Schedule |
| CIterVarRelation | The schedule relation between IterVars can be Split, Fuse |
| CIterVarAttr | Additional scheduable attributes about IterVar |
| CStageNode | Stage |
| CScheduleNode | Node container for schedule |
| CIterVarAttrNode | Node container for IterVar attr |
| CIterVarRelationNode | Base node of iteration var |
| CSplitNode | Split the parent domain into product of outer and iter |
| CSplit | Managed reference to SplitNode |
| CFuseNode | Fuse two domains into one domain |
| CFuse | Managed reference to FuseNode |
| CRebaseNode | Rebase the iteration to make min to be 0. This is useful to normalize the Schedule to make every leaf variable's min to be 0 |
| CRebase | Managed reference to RebaseNode |
| CSingletonNode | Singleton iterator [0, 1) |
| CSingleton | Managed reference to SingletonNode |
| CTransformNode | Transform iterator according to some arbitrary expression |
| CTransform | |
| CSpecializedConditionNode | Container for specialization conditions |
| CSpecializedCondition | Specialized condition to enable op specialization |
| 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 |
| CTensorIntrinNode | Node to represent a Tensor intrinsic operator |
| CTensorIntrin | Managed reference to TensorIntrinNode |
| CTensorIntrinCallNode | |
| CTensorIntrinCall | Managed reference to TensorIntrinCallNode |
| ►Ntir | |
| Nattr | PrimFunc specific attribute names |
| Nbuiltin | Collection of builtin intrinsics as ops |
| Ntransform | |
| ►Nusmp | |
| ►Nalgo | |
| CGreedyBase | This is the base class for Greedy Algorithms where the sorting is specialized in the extended classes based on the greedy criteria |
| Ntransform | |
| CBufferInfoNode | Describes an abstract memory buffer that will get allocated inside a pool. The actual memory buffer in represented by PoolAllocationNode after static memory planning |
| CBufferInfo | |
| CBufferInfoAnalysisNode | This is a composite node that is produced by extract_buffer_info analysis pass that contains useful global information that could be useful for memory planning algorithms |
| CBufferInfoAnalysis | |
| CPoolAllocationNode | The pool allocation produced after the USMP algorithm |
| CPoolAllocation | |
| CAllocatedPoolInfoNode | This object contains information post-allocation for PoolInfo objects |
| CAllocatedPoolInfo | |
| 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 | |
| Ncontrib | |
| Ncuda | |
| Ngeneric | |
| Nnn | |
| Nrocm | |
| Nvision | |
| Nx86 | |
| CEinsumEquation | |
| ►Ntransform | |
| 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 Relay nodes |
| CPass | |
| CSequentialNode | The SequentialNode contains a set of passes that transform Relay programs from one AST to another semantically equivalent one |
| CSequential | |
| CConstructorNode | ADT constructor. Constructors compare by pointer equality |
| CConstructor | Managed reference to ConstructorNode |
| CTypeDataNode | TypeData container node |
| CTypeData | Stores all data for an Algebraic Data Type (ADT) |
| CAffineTypeNode | AffineType representation |
| CAffineType | Managed reference to AffineTypeNode |
| CTensorAffineTypeNode | TensorAffineType representation |
| CTensorAffineType | Managed reference to AffineTypes |
| CTupleAffineTypeNode | TupleAffineType representation |
| CTupleAffineType | Managed reference to TupleAffineTypes |
| 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 |
| CRelayExprNode | Base node of all non-primitive expressions |
| CRelayExpr | Managed reference to RelayExprNode |
| 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 |
| CGlobalVarSupplyNode | GlobalVarSupply can be used to generate unique GlobalVars |
| CGlobalVarSupply | Managed reference class to GlobalVarSupplyNode |
| CPoolInfoNode | Describes a pool of memory accessible by one or more targets |
| CPoolInfo | Base class for WorkspacePoolInfo and ConstantPoolInfo |
| CPoolInfoPropertiesNode | Describes a pool of memory properties |
| CPoolInfoProperties | |
| CWorkspacePoolInfoNode | |
| CWorkspacePoolInfo | |
| CConstantInfoNode | |
| CConstantInfo | |
| CConstantPoolInfoNode | |
| CConstantPoolInfo | |
| CWorkspaceMemoryPoolsNode | |
| CWorkspaceMemoryPools | |
| CConstantMemoryPoolsNode | |
| CConstantMemoryPools | |
| 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 |
| CSIBuilder | Source Information Builder, SIBuilder provides helper APIs for filling spans, particularly useful for one-to-many, many-to-one and many-to-many IR transformations |
| 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 | |
| CBaseTensorTypeNode | Base of all Tensor types This container can hold TensorType or GenericTensorType |
| CBaseTensorType | Managed reference to BaseTensorTypeNode |
| CTensorTypeNode | This is the most commonly used type in relay. TensorType have a fixed dimension, data type |
| CTensorType | Managed reference to TensorTypeNode |
| 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 | |
| CTypeVarNode | Type parameter in functions |
| CTypeVar | Managed reference to TypeVarNode |
| CGlobalTypeVarNode | A global type variable that is used for defining new types or type aliases |
| CGlobalTypeVar | Managed reference to GlobalTypeVarNode |
| CTupleTypeNode | The type of tuple values |
| CTupleType | Managed reference to TupleTypeNode |
| CTypeConstraintNode | Potential Constraints in a function |
| CTypeConstraint | Managed reference to TypeConstraintNode |
| CFuncTypeNode | Function type |
| CFuncType | Managed reference to FuncTypeNode |
| CIncompleteTypeNode | Intermediate values that is used to indicate incomplete type during type inference |
| CIncompleteType | Managed reference to IncompleteTypeNode |
| CRelayRefTypeNode | Reference Type High-level Relay IR |
| CRelayRefType | Managed reference to RelayRefTypeNode |
| CTypeFunctor | |
| CTypeFunctor< R(const Type &n, Args...)> | |
| CTypeVisitor | A type visitor that recursively visit types |
| CTypeMutator | TypeMutator that mutates expressions |
| CTypeCallNode | Type function application |
| CTypeCall | Managed reference to TypeCallNode |
| CTypeReporterNode | Reporter that reports back to the type resolution information |
| CTypeReporter | Container class of TypeReporter |
| CTypeRelationNode | User defined type relation, it is an input-output relation on types |
| CTypeRelation | Managed reference to TypeRelationNode |
| 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 | |
| CAttrRegistry | |
| CWith | RAII wrapper function to enter and exit a context object similar to python's with syntax |
| CCompilationConfigNode | 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 |
| CCompilationConfig | Managed reference class to CompilationConfig |
| CGenericFunc | Generic function that can be specialized on a per-target basis |
| CGenericFuncNode | Represents a generic function that can be specialized on a per-target basis |
| 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 Relay program |
| CVirtualDevice | Managed reference class to VirtualDeviceNode |
| CVirtualDeviceCache | A cache of VirtualDevices. This can be used: |
1.9.1
