Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

Narg_capture
CMyHash
CArgCapture
CArgCaptureIO
CPrimitiveCppType
CPrimitiveCppType< PrimitiveType::Float >
CPrimitiveCppType< PrimitiveType::Double >
CPrimitiveCppType< PrimitiveType::X86_FP80 >
CPrimitiveCppType< PrimitiveType::Int8 >
CPrimitiveCppType< PrimitiveType::Int16 >
CPrimitiveCppType< PrimitiveType::Int32 >
CPrimitiveCppType< PrimitiveType::Int64 >
CPrimitiveCppType< PrimitiveType::UInt8 >
CPrimitiveCppType< PrimitiveType::UInt16 >
CPrimitiveCppType< PrimitiveType::UInt32 >
CPrimitiveCppType< PrimitiveType::UInt64 >
Ndaisy
Ntenstorrent
C__daisy_DeviceDeleter
Ndocc
Ncompile
CCompileExecutor
CCodegenBuildPool
CCompileState
CCodegenCompiler
CNoopCompiler
CFileCompileState
CLinkOptContributor
CSrcFileCompiler
CCodegenCompilerBuilderBase
CLibPath
CSrcFileCompilerBuilder
Ntarget
Net
Nblas
CGEMMNodeDispatcher_ETSOC_WithTransfers
CEtLibNodeMapper
CEtBuildArgs
CTargetOptions
CDoccTarget
Noffloading
CTransferArg
Nanalysis
CAnalysis
CAnalysisManager
CArgumentAttributes
CAttributes
CGlobalCFGNode
CGlobalCFGEdge
CGlobalCFGAnalysis
CSDFGHolder	This a wrapper around 1 SDFG (may include historic versions of the same SDFG in the future)
CSDFGRegistry
Nlifting
CNotImplementedException
CFunctionToSDFG
CBLASLifting
CFunctionLifting
CIntrinsicLifting
CLibFuncLifting
CLiftingReport
CLifting	Lifting is the process of converting a LLVM function into a SDFG
Npasses
CCodeGenerationPass
CDOCCPass
CDumpAttributesPass
CAttributesAnalysis
CDumpSDFGPass
CGlobalCFGPrinterPass
COPTReportPass
CRegionReport
CPassReportCollector
CFunctionToSDFGPass
CArgumentExpansionPass
CEinsumPass
CNormalizationPass
CSchedulingPass
CSDFGSimplifyPass
Nutil
CDoccPaths
CDefaultDoccPaths
CPlugin
CPluginRegistry
Nmlir
Nlinalg
CLinalgGenericToLinalgCustomBatchNorm2DNchw	Y = (x - E[x]) / sqrt(Var[x] + eps) * gamma + beta
CLinalgGenericToLinalgSoftmax	Y[..., d, ...] = exp(x) / sum_d(exp(x_d))
Nsdfg
CTensorInfo
CSDFGTranslator
Nsdfg
Nanalysis
CAnalysis
CAnalysisManager
CDataRwFlags
CRegionArgument
CArgumentsAnalysis
CAssumptionsAnalysis
CControlFlowAnalysis
CDataDependencyAnalysis	Computes the read-after-write relation between users
CLoopInfo	Is_perfectly_nested: is the entire loop hierarchy with loop at the top perfectly nested on every level is_perfectly_parallel: is the entire loop hierarchy with loop at the top perfectly parallel on every level num_loops [maps, fors, whiles]: number of X contained within, including the loop itself
CLocalLoopInfo	Meant to contain only per-loop data (does not reflect what loops nested inside do / have) This is a pre-processing step to collect the loop-nest-wide info
CLoopAnalysis
CLoopState
CAggregatedResult
CMemoryTile
CMemoryTileGroup
CMemoryLayoutAnalysis	Analysis that infers the assumed memory layouts of memlets
CPointerEscapeAnalyzer	Reusable BaseUserAnalyzer that detects pointer escapes
CPointerOverwriteAnalyzer	Reusable BaseUserAnalyzer that detects pointer overwrites
CPointerUsedAnalyzer	Indirect access via pointer happened
CReferenceAnalysis
CTypeAnalysis
CForwardingEscapePolicy
COffloadHolder
CExposedOffload
CDeviceFreeSite	A device-buffer deallocation site: the FREE-lifecycle offloading node together with the block it lives in
CDataTransferEliminationCandidateCollector
COffloadState
CDataTransferEliminationAnalysis
CDataFlowState
CElementIdMapDataFlowState
CForwardStructuredDataFlowAnalysis	Base class for forward data-flow analysis over structured control flow
CSolveProgress
CBaseUserAnalyzer
CBaseUserVisitor	Finds uses of containers
CForUser
CUser
CUsers
CUsersView
Nbuilder
CFunctionBuilder
CSDFGBuilder
CConditionalDeleter
CStructuredSDFGBuilder	Note: Even though the class references unique_ptr, it will never delete an SDFG it has a reference to
Ncodegen
CArgumentRegistry
CCodeGenerator	Base class for code generators
CCCodeGenerator
CCStyleBaseCodeGenerator
CCPPCodeGenerator
CCodeSnippet
CLibDependency
CDependencyState
CCodeSnippetFactory	Originally started out as a handler for additional source files, like hardware-accelerator kernels that are called from the main code, it has morphed more into a CodegenState That also includes library dependencies and header definitions that could be used with the existing arguments given to any dispatcher
CNestedCodeSnippetFactory	Used when we need to dispatch main SDFG elements into a subset of files (like offloaded kernels)
CBlockDispatcher
CAssignmentDispatcher
CDataFlowDispatcher
CCodegenOutput
CDispatchInput	Short-lived container for an input into a dispatcher (based on dflow edges) references are only valid up until the return of the dispatch call
CDispatchOutput
CLibraryNodeDispatcher	Base class for library node code generation dispatchers
CForDispatcher
CIfElseDispatcher
CLibraryNodeDispatcherBase
CSchedTypeMapDispatcher	Dispatches to the actual NodeDispatcher based on scheduleType and the MapDispatcherRegistry
CSequentialMapDispatcher
CNodeDispatcher	Base class for dispatching control flow nodes to code
CNodeDispatcherRegistry
CMapDispatcherRegistry	Registry for map-specific dispatchers based on schedule type
CReduceDispatcherRegistry	Registry for reduce-specific dispatchers based on schedule type
CLibraryNodeDispatcherRegistry	Registry for library node dispatchers
CSchedTypeReduceDispatcher	Dispatches to the actual NodeDispatcher based on the Reduce's schedule type and the ReduceDispatcherRegistry
CSequentialReduceDispatcher	Default (sequential) code generator for structured_control_flow::Reduce
CSequenceDispatcher
CWhileDispatcher
CBreakDispatcher
CContinueDispatcher
CReturnDispatcher
CCaptureVarPlan
CArgCapturePlan
CInstrumentationMemberInfo
CInstrumentationInfo
CInstrumentationPlan
CGroupSpan
CLoopHints	Loop properties a language may be able to express (e.g. clang loop pragmas in C)
CBody	An open region of emitted code, closed by LanguageExtension::end
CLanguageExtension
CCLanguageExtension
CCSymbolicPrinter
CCStyleLanguageExtension	Statement and control-flow syntax shared by the C family (C, C++, CUDA, HIP)
CCPPLanguageExtension
CCPPSymbolicPrinter
CLoopReport
CPrettyPrinter
CReference
Nstructured_control_flow
CBlock	A control flow node representing a basic block with dataflow computations
CAssignmentBlock
CControlFlowNode	Base class for all structured control flow nodes in a StructuredSDFG
CFor	Represents a traditional for-loop with sequential execution
CIfElse	Represents a conditional if-else control flow node with multiple cases
CMap	Represents a parallel map loop with configurable scheduling
CReductionInfo	A single reduction carried by a Reduce loop
CReduce	Represents a loop with an associative/commutative reduction carried dependency
CReturn	Represents a return statement that exits the function with a value
CSequence	A sequential container of control flow nodes
CScheduleType	Represents a schedule type for Map nodes
CScheduleType_Sequential	Sequential schedule type for Map nodes
CScheduleType_Unroll	Unroll annotation carried as a generic property on any ScheduleType
CScheduleType_NoFusion	No-fusion annotation carried as a generic property on any ScheduleType
CScheduleType_ZeroInit	Zero-initialization annotation carried as a generic property on any ScheduleType
CScheduleType_NestAnnotations	Annotations describing a whole loop nest rather than a single loop's execution strategy
CStructuredLoop	Base class for structured loop constructs
CWhile	Represents a while-loop with condition-controlled iteration
CBreak	Represents a break statement that exits the innermost loop
CContinue	Represents a continue statement that skips to the next loop iteration
Ncontrol_flow
CInterstateEdge	An edge connecting two states in an SDFG control-flow graph
CState	A state in a Stateful DataFlow Graph (SDFG)
CReturnState	A special state that returns a value from the SDFG
Nserializer
CCutoutSerializer
CJSONSerializer
CJSONSymbolicPrinter
CLibraryNodeSerializer	Base class for library node serialization
CLibraryNodeSerializerRegistry	Registry for library node serializers
Ndata_flow
CAccessNode	Node representing access to a data container in the dataflow graph
CConstantNode	Node representing a constant literal value in the dataflow graph
CCodeNode	Base class for computational nodes with inputs and outputs
CDataFlowGraph
CDataFlowNode	Abstract base class for all dataflow graph nodes
CSubgroupAccess	The operand elements one subgroup touches in a single access: for every lane, the operand coordinates it reads, in register order
CLibraryNode	Base class for all library nodes in the dataflow graph
CAtomicScalarOpImpl	A concrete lowering ("implementation") of an AtomicScalarOpNode
CAtomicScalarOpNode	Wrapper around typical atomic operations (add, sub, min, max, swap) on a single scalar value
CAtomicScalarOpCPUImpl	CPU (OpenMP) atomic implementation
CAtomicScalarOpGPUImpl	Shared base for the GPU implementations (CUDA and ROCm)
CAtomicScalarOpCudaImpl	CUDA atomic implementation
CAtomicScalarOpRocmImpl	ROCm atomic implementation
CAtomicScalarOpNodeSerializer
CAtomicScalarOpNodeDispatcher
CAtomicScalarOpCPUNodeDispatcher
CAtomicScalarOpGPUNodeDispatcher
CBarrierLocalNode
CBarrierLocalNodeSerializer
CCallNode
CCallNodeSerializer
CCallNodeDispatcher
CInvokeNode
CInvokeNodeSerializer
CInvokeNodeDispatcher
CConstSource
CInMemoryConstSource	Constant data stored inline in SDFG
CRawFileConstSource	Constant data stored in external files, using arg_capture_io code to read (raw data, no meta data inside the files themselves, meta data stored here)
CLoadConstNode
CLoadConstNodeSerializer
CLoadConstNodeDispatcher
CMetadataNode
CMetadataNodeSerializer
CMetadataDispatcher
CMemlet	Edge in the dataflow graph representing data movement
CPtrMetaDeleter
CMemoryAccessPattern
CConvexAccessPattern
CNoAccessPattern
CTensorLayoutPattern	A structured access described by a full affine tensor layout (shape, strides and offset in elements)
CPointerAccessMeta
CPointerReadOnly	The pointer is only used for reading
CPointerFullWriteOnly	The pointer is used solely to write, no reading and over all of the data
CPointerGenericAccess	It is unknown what is done with this pointer or it is a mix of reads and writes
CPointerInvalidate	Meaning the underlying memory will be deallocated and use of the pointer after this is no longer valid
CPointerAccessMetaSerializer
CTasklet	Simple computational operation in the dataflow graph
Nmath
Nblas
CBatchedGEMMNode
CBatchedGEMMNodeSerializer
CBLASNode	Base class for BLAS operation nodes
CBLASLibDependency
CDotNode
CDotNodeSerializer
CDotNodeDispatcher_BLAS
CGEMMNode
CGEMMNodeSerializer
CGEMMNodeDispatcher_BLAS
Ncmath
CCMathNode
CCMathNodeSerializer
CCMathNodeDispatcher
Ntensor
CArangeNode	Tensor node that generates a sequence of numbers
CArangeNodeSerializer
CBatchNormNode	In N, C, D0...Dn tensor, applies normalization to per channel in C across all the inner dimensions
CBatchNormNodeSerializer
CBroadcastNode
CBroadcastNodeSerializer
CClampNode	Computes Y = min(max(X, min), max) elementwise, where either bound may be omitted
CClampNodeSerializer
CConcatNode	Tensor concatenation node that can concatenate a number of tensors into another tensor
CConcatNodeSerializer
CConditionalTensorCopyNode	Conditional tensor copy node that copies values from one tensor or another depending on a tensor mask
CConditionalTensorCopyNodeSerializer
CConstPaddingNode	Applies padding by a constant value
CConstPaddingNodeSerializer
CConvNode	Convolution operation following ONNX Conv operator specification
CConvExpandPrerequisits
CConvNodeSerializer	Serializer for ConvNode
CTensorCopyNode	Tensor copy node that copies values form one container to another according to their tensor access
CTensorCopyNodeSerializer
CElementWiseDataflowTensorNode	Defined by each element of the output tensor (defined by shape) can be defined independently of any other output
CElementOutput
CElementInput
CBaseElementWiseDataflowTensorNodeSerializer
CBaseDeser
CSimpleElementWiseDataflowTensorNodeSerializer
CAbsNode
CAddNode
CCastNode
CCMathTensorNode
CCMathTensorNodeSerializer
CDivNode
CErfNode
CExpNode
CFillNode
CGELUNode	Applies the Gaussion Error Linear Units function
CGELUNodeSerializer
CLogicalNotNode
CMaximumNode
CMinimumNode
CMulNode
CPowNode
CReLUNode
CRsqrtNode
CSigmoidNode
CSqrtNode
CSubNode
CTanhNode
CTaskletTensorNode
CTaskletTensorNodeSerializer
CEluNode	Computes Y = X < 0 ?
CEluNodeSerializer
CEmbeddingNode	Embedding lookup node implementing aten.embedding(weight, indices)
CEmbeddingNodeSerializer
CEmbeddingRenormNode	In-place embedding renormalization implementing aten.embedding_renorm_
CEmbeddingRenormNodeSerializer
CIndexNode	Tensor advanced-indexing node
CIndexNodeSerializer
CLayerNormNode	Applies layer normalization over the trailing noramlized_shape dimensions of the input
CLayerNormNodeSerializer
CLeakyReLUNode	Computes Y = X > 0 ?
CLeakyReLUNodeSerializer
CMatMulNode	Tensor matrix multiplication following ONNX MatMul operator specification
CMatMulNodeSerializer	Serializer for MatMulNode
CMatMulNaiveExpander
CMatMulBlasExpander
CPoolingNode	N-dimensional pooling operation
CPoolingNodeSerializer	Serializer for PoolingNode
CReduceNode	Base class for tensor reduction operations
CReduceNodeSerializer
CMaxNode
CMeanNode
CMinNode
CSoftmaxNode
CStdNode
CSumNode
CSpatialTensorNode	Specialization of TensorNode for spatial operations such as Convolution and Pooling
CSpatialTensorNodeBaseSerializer
CBaseDeser
CInputContainerInfo
CMapDimension
CTensorLayout	The metadata associated with a addressing a tensor in elements Meant to be used with TensorNodes to describe their input's and outputs layouts and ease handling of such descriptions If the TensorType will keep existing it should also be switched to use this
CContractionTypes	Element types of a contraction such as a matmul
CTensorNode	Abstract base class for all tensor operations
CUpsampleBilinear2DNode	2D bilinear upsampling operation
CUpsampleBilinear2DNodeSerializer	Serializer for UpsampleBilinear2DNode
CMathNode	Base class for mathematical library nodes with expansion support
Nstdlib
CAllocaNode
CAllocaNodeSerializer
CAllocaNodeDispatcher
CAssertNode
CAssertNodeSerializer
CAssertNodeDispatcher
CCallocNode
CCallocNodeSerializer
CCallocNodeDispatcher
CFreeNode
CFreeNodeSerializer
CFreeNodeDispatcher
CMallocNode
CMallocNodeSerializer
CMallocNodeDispatcher
CMemcpyNode
CMemcpyNodeSerializer
CMemcpyNodeDispatcher
CMemmoveNode
CMemmoveNodeSerializer
CMemmoveNodeDispatcher
CMemsetNode
CMemsetNodeSerializer
CMemsetNodeDispatcher
CStdlibNode
CTrapNode
CTrapNodeSerializer
CTrapNodeDispatcher
CUnreachableNode
CUnreachableNodeSerializer
CUnreachableNodeDispatcher
Ndeepcopy
CStructuredSDFGDeepCopy
Ngraph
CDFSVisitor
Nmetadata
CRpcOptimizationMetadata
Npasses
Nexpansion
CLibNodeExpansionContext
CBlockOutcome
CNodeOutcome
Nscheduler
CSchedulerLoopInfo
CLoopScheduler
CCUDAOffloadScheduler
CCUDAScheduler
CLoopSchedulingPass
COMPScheduler
CROCMOffloadScheduler
CROCMScheduler
CSchedulerRegistry
CVectorizeScheduler
CRpcOptimizationPass
Nloop_fusion
CLoopFusionConfig
CFusionRegCandidate
CFusionArgCommonBlock
CFusionArgCommonAccesses
CFusionArg
CFusionLoopCandidate	Represents pre-cached data for 1 Loop that fullfills the prerequisits for fusing with another candidate Goal is to collect every harder to get data once for all involved loops
CPatternHandler
CMatchResult
CComplexFusionResult
CLoopFusionByAccessWorker
CPlan
CFusionRegs
CNeighboringPatternVisitor
CLoopFusionPass	A pass that performs loop fusion on a StructuredSDFG
CState
CLoopFusionHandler
CInOutCheckResult
Nnormalization
CLoopNormalFormPass
CMapDelinearizationPass	Splits flattened maps into nested maps along the divisions of their induction variables
CMapFusion
CMapFusionPass
CPerfectLoopDistributionPass
CStrideMinimization
Nrpc
CDaisytunerRpcContext
CRpcContext
CSimpleRpcContext
CSimpleRpcContextBuilder
CRpcOptimizationMetadata
CRpcLocalReplayRecipe	Placeholder for native recipes
CRpcSdfgResult
CRpcRegionResult	Result for a single tuned region
CRpcOptResponse
CRpcOptRequest
CApproximateMath	Marks every CMathNode as approximate, permitting fast device intrinsics (e.g. __expf)
CByteReferenceElimination
CConstantPropagation	Forward-propagates floating-point constant scalars into their uses
CDeadDataElimination
CDeadReferenceElimination
CLocalBufferReuseN
CMemletLinearization	Linearizes memlet base types by flattening nested arrays
CMemletSimplification	Simplifies mixed-radix index expressions in memlet subsets
CReferencePropagation
CTaskletFusion
CTensorToPointerConversion
CTrivialArrayElimination
CTrivialReferenceConversion
CDebugDumpPass
CDebugInfoPropagation
CLibNodeExpander
CExpandOutcome
CAccessNodeExpand
CExpandContext
CTypedLibNodeExpander
CCodeLibNodeExpander
CMathNodeExpander
CSingleExpanderHolder
CLibraryNodeExpansionPass	Looks for and expands library nodes in a single pass, potentially recursively
CLibNodeExpansionVisitor
CSwitchExpander	An expander that bundles several sub-expanders and switches to the correct one per node
CAllocationManagement
CTensorAllocationSizeInference	Records the byte size of pointer containers in their StorageType::allocation_size, derived from the Tensor-typed memlets connecting them to library nodes
CPass
CVisitorPass
CPipeline
CHierarchicalStatistics
CNode
CCompileStatistics
CCodegenStatistics
CBlockFusion
CNoLibnodesBlockFusionPass
CCommonAssignmentElimination
CConditionElimination
CDeadCFGElimination
CIteratorToIndvar
CSequenceFusion
CUnifyLoopExits
CUniqueLoopIndvars	Ensures every structured loop has a unique induction variable
CWhileToForConversion
CSymbolEvolution	Rewrites loop-carried scalar recurrences into closed-form expressions
CSymbolPromotion	Pass that promotes simple dataflow computations to symbolic expressions
CSymbolPropagation	Pass that propagates symbolic assignments through the SDFG
CExtendedBlockHoisting
CExtendedBlockSortingPass
CCollapsePass	Phased collapse pass: collects applicable collapses, then applies them
CDotExpansion
CBlockHoisting	Currently only looks at the first and lost block in the sequence of a if/else or Map node and thus provides very limited hoisting by itself
CBlockSortingPass
CCudaExpansion
CDataTransferMinimizationPass
CDeviceBufferReusePass	Coalesces pure device buffer allocations (deviceMalloc/deviceFree without any host/device transfer) so that non-overlapping buffers of the same element type share a single, max-sized allocation
CCandidate
CAllocRec
CBufferReuseMarker
CDeviceResidentArgPromotionPass	Promotes function pointer arguments to device-resident storage
CCUDAControlFlowOffloadTraits
CROCMControlFlowOffloadTraits
CGPUControlFlowOffloadPass	Offloads non-loop control flow directly nested in the SDFG root
CGPULoopReorderingPass	Phased GPU loop reordering pass
CGPUNestedOffloadPass	Depth-aware nested GPU offload pass
CGPUNestedParallelizationPass	Phased GPU nested map parallelization pass
CReductionSharedMemoryDelinearization	Materialize compact GPU reduction partials and their SDFG accesses
CRemoveRedundantTransfersPass
CRocmExpansion
CSyncConditionPropagation
CReadonlyTransferHoistingPass
CRedundantLoadEliminationPass
CState
CRedundantLoadVisitor
CRedundantZeroInitEliminationPass	Applies RedundantZeroInitElimination to every loop annotated as zero init (ScheduleType_ZeroInit)
CScalarPromotionPass	Promotes the array element a Reduce accumulates into, e.g
CTargetMappingVisitor	Generified version to map LibraryNodes for now
CTargetMappingPass
CTilingPass	Phased tiling pass: collects applicable tilings, then applies them
CTrivialLoopEliminationPass	Applies TrivialLoopElimination to a set of maps
Nplugins
CContext	TODO this class is broken
CPlugin
CTargetMappingPlan
CTargetMapper
CTargetMapperFactory
CTargetMapperRegistry
Nvisitor
CImmutableStructuredSDFGVisitor
CStructuredSDFGVisitor	Very specific implementation, that technically visits the SDFG of an StructuredSDFGBuilder and not just any SDFG
CNonStoppingStructuredSDFGVisitor
CActualStructuredSDFGVisitor	Visitor for Structured SDFG (not a builder)
CStructuredSDFGWalker	A sequential walker for traversing structured control flow nodes in a StructuredSDFG with iterators Iterators traverse the SDFG same as our visitors do
CParentScopeLoc
CIterator
Nsymbolic
Nmaps
CDependenceDeltas	Represents the set of dependence distance vectors between two access patterns
Npolyhedral
CIslCtx	Move-only RAII owner of an isl_ctx
CIslHandle	Move-only RAII owner of a reference-counted ISL object
CAssumption	Represents assumptions about a symbol's properties and behavior
CAssumptions	Map from symbols to their assumptions
Cconst_iterator	Visits the own entries, then the base's entries the own ones do not shadow
CCNFException	Exception thrown when CNF conversion fails
CDelinearizeResult
CInterval	Result of bounding an expression: an interval [lower, upper]
CBoundAnalysis	Computes bounds of symbolic expressions using assumptions
CAssumptionsBounds	Bundles Assumptions with both the loose and tight BoundAnalysis derived from them
CAffineDecomposition	Result of affine decomposition of an expression w.r.t
CIModFunction	Function class for integer modulo operation
CZExtI64Function	Function class for zero-extension to 64-bit integer
CTruncI32Function	Function class for truncation to 32-bit integer
CSizeOfTypeFunction	Function class representing sizeof for a type
CDynamicSizeOfFunction	Function class for dynamic sizeof operation
CMallocUsableSizeFunction	Function class for malloc_usable_size operation
Ntypes
CArray	Represents a c-style array type
CFunction	Represents a function type
CPointer	Represents a pointer type
CScalar	Represents a scalar primitive type
CStructure	Represents a structure type (similar to C struct)
CStructureDefinition	Defines the layout and members of a structure type
CTensor
CStorageType	Represents the storage location and management characteristics of data
CIType	Abstract base interface for all types in the sdfglib type system
Noffloading
CDataOffloadingNode	Name does not match current function
CDataOffloadingNodeSerializer
CCudaBatchedMatMulExpander
CCudaConcatExpander
CGPUConvExpander
CExternalDataOffloadingNode
CExternalDataOffloadingNodeDispatcher
CExternalDataOffloadingNodeSerializer
CTargetLibNodeExpander
CRocmBatchedMatMulExpander
CRocmConcatExpander
Nusers
CBaseUserAnalyzer
CBaseUserVisitor	Finds uses of containers
CLegacyUserVisitor	Traverses a structured SDFG and reports uses with the classic Users semantics: one user per access node and direction (READ/WRITE/VIEW/MOVE), deduplicated symbol reads, loop headers split into init / condition / update, and nothing after a Return
CUser
CForUser
CUsers
CUsersView
Nvisualizer
CDotVisualizer
CVisualizer
Neinsum
CEinsumIndexContribution	A single einsum dimension's contribution to one operand's access subset
CEinsumIndexing	How the consumed einsum dimensions map onto one operand's access subset
COperandContribution	A single consumed dimension's contribution to one operand, found during promotion
CPromotionCheck	Result of checking whether a loop can be folded into a cluster
CEinsumEdge
CEinsumEdgeOriginal
CEinsumEdgeVirtual
CEinsumCluster	Non-destructive counterpart of an EinsumNode
CEinsumDetection	Non-destructive detection of einsum clusters in a StructuredSDFG
CBlockState
CLoopScopeState
CEinsumDimension
CEinsumNode
CEinsumSerializer
CEinsumReplacementContext	ExpandContext for replacing an EinsumCluster with a new implementation
CEinsumReplacer	Interface for replacing an EinsumCluster with a different implementation
CEinsumDetectionPass
CEinsumConversion
CEinsumLower
CEinsumExpansion	Visitor that expands the EinsumNode with the legacy expand() method
CEinsum2MatMul	Proof-of-concept replacer that turns a matmul-shaped EinsumCluster into a MatMulNode
CMatMulAnalysis	Results of the applicability analysis that are reused by the replacement step
CEinsum2Dot
CEinsum2Gemm
CEinsumExtend
CEinsumLift
CEinsumPromotion
Nfp_math
CKernelValue	A value in a block under construction: an access node with the subset and base type of the memlet reading it
CBlockBuilder	Builds the dataflow of one block from expressions
CKernelBuilder	Builds loop nests over transient buffers into a sequence
CRowMajorB	The copy read_b_row_major() makes of B, and the contraction that reads it
COzakiMatMulNode	Y = A @ B with B given as its Ozaki slices, prepared once for many products, e.g
COzakiMatMulNodeSerializer
COzakiMatMulExpander
CContractionPrecision	How contractions (MatMul and GEMM nodes) of Float and Double compute, as users select it
CContractionPrecisionPass	Applies the transformation precision selects to every contraction it can; others stay native
CFPContraction	Floating-point contraction (-ffp-contract=fast): applies FuseFMA in every block until no multiplication feeding an addition is left to contract
CFuseFMA	Contracts a floating-point multiplication feeding an addition into a fused multiply-add
COzakiContraction	Emulates a floating-point matmul (MatMul or GEMM node) with exact Int8 matmuls (Ozaki scheme), at about the input's precision
CQuantizeContraction	Computes a floating-point matmul (MatMul or GEMM node) on integers, quantized with a scale per row of A and per column of B
CUnfuseFMA	Splits a fused multiply-add into a multiplication and an addition
Nparallelization
CLoopCarriedDependencyInfo	Extended loop-carried dependency information including distance vectors
CLoopCarriedDependencyPair	Per-pair loop-carried dependency record
CLoopCarriedDependencyAnalysis	Standalone loop-carried dependency analysis
CAutoParallelization	Classifies parallelizable For loops and lowers them to Map or Reduce
Ntransformations
CLoopParallelization	Converts a single For loop into a sequential Map
CLocalStorage	Local-storage transformation
CTileInfo	Normalized tile description handed from can_be_applied() to apply()
CSoftwarePipelining	Software-pipeline a sequential panel loop that cooperatively stages a shared-memory tile each iteration (the structure LocalStorage emits)
CTileFusion	Tile fusion transformation that merges two consecutive sibling tiled Maps
CTileVectorizer	Widen every cooperative shared-staging copy in a subtree to the widest legal vector transfer
CCollapseToDepth	Collapse a perfectly-nested map nest into a target number of loops
CLoopConditionNormalize	Loop condition normalization to convert inequality conditions to relational comparisons
CLoopDistribute	Loop distribution (loop fission) transformation
CLoopHeader	Bounds and step of a loop, keeping its induction variable
CLoopSwap	Two directly nested loops and their headers after swapping them
CLoopIndvarFinalize	Computes closed-form final value of induction variable after loop
CLoopInterchange	Loop interchange transformation that swaps two nested loops
CLoopPeeling	Loop peeling for a perfectly nested chain of compound-condition loops
CLoopRotate	Loop rotation transformation to convert negative stride to positive stride
CLoopShift	Loop shift transformation to change loop initialization value
CLoopSkewing	Loop skewing transformation for nested loops
CLoopSplit	Loop splitting transformation at a symbolic boundary
CLoopTiling	Loop tiling (blocking) transformation
CLoopUnitStride	Loop unit stride transformation to convert non-unit stride loops to unit stride
CMapCollapse	Map collapse transformation
CMapDelinearize	Splits a map into nested maps along the divisions of its induction variable; the inverse of MapCollapse
CMapFusion	Map fusion transformation that fuses two sequential maps
CFusionConsumerSubsetVisitor
CFusionConsumerUpdateVisitor
CMultiLevelTiling	Multi-level loop tiling transformation
CCUDAParallelizeNestedMap	Assigns a nested sequential map to the next available CUDA grid dimension
CGPUConditionPropagation
CGPUConditionPropagationScope	Root-anchored sweep of GPUConditionPropagation
CBarrierFinder
CGPULoopReordering
CGPUOffloadNestedLoop
COffloadTransform
CSideEffectFinder
CROCMParallelizeNestedMap	Assigns a nested sequential map to the next available ROCm grid dimension
COMPTransform	OMPTransform transformation for Map nodes
CRecorder	Records transformation history for replay and analysis
CMmaNestOutputUses	Collects the uses of an output container within a GPU MMA loop nest
CCFragmentLoad
CRedundantZeroInitElimination	Eliminates a zero-initialization nest that is redundant before a GPU MMA matmul nest
CReplayer	Replays recorded transformations on an SDFG
CStreamK	Stream-K work decomposition: replace a static output-tile grid whose blocks each own one tile with a fixed persistent grid whose blocks each walk an equal contiguous slice of the flattened (tile x k-panel) iteration space, merging partially-owned tiles via the reduction
CTransformation	Base class for all SDFG transformations
CInvalidTransformationException	Exception thrown when a transformation cannot be applied
CInvalidTransformationDescriptionException	Exception thrown when a transformation description is invalid
CTrivialLoopElimination	Eliminates a trivial map, i.e., a map executing exactly one iteration
CUnrollTransform	Marks a constant-trip loop for full unrolling
CVectorizeTransform	VectorizeTransform transformation for StructuredLoop nodes
CRPCNodeTransform
Ncuda
Nblas
CBatchedGEMMNodeDispatcher_CUBLASWithTransfers
CBatchedGEMMNodeDispatcher_CUBLASWithoutTransfers
CDotNodeDispatcher_CUBLASWithTransfers
CDotNodeDispatcher_CUBLASWithoutTransfers
CGEMMNodeDispatcher_CUBLASWithTransfers
CGEMMNodeDispatcher_CUBLASWithoutTransfers
Ntensor
CSoftmaxNodeDispatcher_CUDAWithTransfers
CSoftmaxNodeDispatcher_CUDAWithoutTransfers
Nstdlib
CMemcpyNodeDispatcher_CUDAWithTransfers
CMemcpyNodeDispatcher_CUDAWithoutTransfers
CMemsetNodeDispatcher_CUDAWithTransfers
CMemsetNodeDispatcher_CUDAWithoutTransfers
Ntiles
CPipelineCommitNodeDispatcher
CPipelineWaitNodeDispatcher
CTileCopyNodeDispatcher	Cooperative dispatcher for the whole-copy sdfg::tiles::TileCopyNode
CCudaLibraryNodeRewriter
CCudaLibraryNodeTransferExtractionVisitor
CCUDALanguageExtension
CScheduleType_CUDA_Offload	CUDA schedule type inheriting shared GPU functionality Provides CUDA-specific value() and default block size (32 for warp size)
CScheduleType_CUDA	CUDA schedule type inheriting shared GPU functionality Provides CUDA-specific value() and default block size (32 for warp size)
CCUDADataOffloadingNode
CCUDADataOffloadingNodeDispatcher
CCUDADataOffloadingNodeSerializer
CCUDAMapDispatcher
CCUDAOffloadDispatcherStrategy	CUDA specialization of gpu::GPUOffloadMapDispatcher
CCUDAReduceDispatcher	Atomics-based CUDA code generator for structured_control_flow::Reduce
CCUBLASDataTransferExtraction
CCUDAOffloadTransform
CCUDASoftmaxDataTransferExtraction
CCUDAStdlibDataTransferExtraction
CCUDATransform	Offloads a top-level loop to a CUDA kernel (X grid dimension)
Nrocm
Nblas
CBatchedGEMMNodeDispatcher_ROCMBLASWithTransfers
CBatchedGEMMNodeDispatcher_ROCMBLASWithoutTransfers
CDotNodeDispatcher_ROCMBLASWithTransfers
CDotNodeDispatcher_ROCMBLASWithoutTransfers
CGEMMNodeDispatcher_ROCMBLASWithTransfers
CGEMMNodeDispatcher_ROCMBLASWithoutTransfers
Nstdlib
CMemcpyNodeDispatcher_ROCMWithTransfers
CMemcpyNodeDispatcher_ROCMWithoutTransfers
CMemsetNodeDispatcher_ROCMWithTransfers
CMemsetNodeDispatcher_ROCMWithoutTransfers
Ntiles
CPipelineCommitNodeDispatcher
CPipelineWaitNodeDispatcher
CTileCopyNodeDispatcher	Cooperative dispatcher for the whole-copy sdfg::tiles::TileCopyNode
CRocmLibraryNodeRewriter
CRocmLibraryNodeTransferExtractionVisitor
CROCMLanguageExtension
CScheduleType_ROCM_Offload	ROCM schedule type inheriting shared GPU functionality Provides ROCM-specific value() and default block size (64 for wavefront size)
CScheduleType_ROCM	ROCM schedule type inheriting shared GPU functionality Provides ROCM-specific value() and default block size (64 for wavefront size)
CROCMDataOffloadingNode
CROCMDataOffloadingNodeDispatcher
CROCMDataOffloadingNodeSerializer
CROCMMapDispatcher
CROCMOffloadDispatcherStrategy	ROCm/HIP specialization of gpu::GPUOffloadMapDispatcher
CROCMReduceDispatcher	Atomics-based ROCm/HIP code generator for structured_control_flow::Reduce
CROCBLASDataTransferExtraction
CROCMOffloadTransform
CROCMStdlibDataTransferExtraction
CROCMTransform	Offloads a top-level loop to a ROCm/HIP kernel (X grid dimension)
Ngpu
Ncuda
CCudaComputeCapability	A CUDA compute capability together with the name(s) of the device(s) that report it
CCudaMmaSupport
CCudaArch
CCudaMmaFragmentStrategy	Classic rocwmma fragment-based emit strategy (load/store/mma_sync/fill_fragment)
CCudaWmmaLibDependency
Nrocm
CRocmMmaSupport
CRocmArch
CRocmDeviceInfo	A ROCm/HIP GPU device as reported by rocminfo: its LLVM/ROCm ISA (gfx) name together with the marketing name(s) of the device(s) that report it and the wavefront size
CRocmMmaBareStrategy	Raw v_mfma_f32_32x32x8f16 emit strategy (see RocmMfma32Support)
CRocmMmaFragmentStrategy	Classic rocwmma fragment-based emit strategy (load/store/mma_sync/fill_fragment)
CRocmWmmaLibDependency
CGpuMmaTransform
CBarrierLocalNodeDispatcher
CGpuArch
CFoldBarrier
CNestedFoldPlan
CGpuMmaDispatcherStrategy	Hardware-dependent emit primitives for the composable MMA library nodes
CGpuMmaNodeDispatcher	Shared storage for the strategy; each composable MMA node has its own dispatcher subclass
CGpuMmaMatmulDispatcher	A single MMA accumulation of A * B into a preinitialized accumulator (gpu::GpuMmaMatmul)
CGpuMmaFillDispatcher	Declare and zero-initialize an MMA accumulator fragment (gpu::GpuMmaFill)
CGpuMmaFragmentLoadDispatcher	Load a tile from memory into a fragment (gpu::GpuMmaFragmentLoad)
CGpuMmaFragmentStoreDispatcher	Store a fragment to a tile in memory (gpu::GpuMmaFragmentStore)
CGpuMmaEltwiseAddDispatcher	D = out_type(Acc + acc_type(C)), element-wise over the fragments (gpu::GpuMmaFragmentEltwiseAdd)
CGpuMmaEinsumReplacer
CEinsumMmaAnalysis
CGpuMmaEinsumTransform
CGpuMmaExpander
CGpuMmaFillNode	Prepares (declares and zero-initializes) a GPU MMA accumulator fragment
CGpuMmaFillNodeSerializer
CMmaBlockSize
CBlockCounts	Grouping of MMA blocks
CGpuMmaTiling
CGpuMmaSupport
CGpuMmaFromMemoryLayout	Describes how a single MMA fragment maps to memory relative to a base pointer
CGpuMmaFragmentEltwiseAddNode	Handles the addition of two MMA fragments and stores the result in a third fragment
CGpuMmaFragmentEltwiseAddNodeSerializer
CGpuMmaFragmentLoadNode	Loads a single MMA fragment from memory
CGpuMmaFragmentLoadNodeSerializer
CGpuMmaFragmentStoreNode	Stores a single MMA fragment to memory
CGpuMmaFragmentStoreNodeSerializer
CGpuMmaMatmulNode	A single GPU tensor-core matrix-multiply-accumulate (MMA) step
CGpuMmaMatmulNodeSerializer
CGPUOffloadDispatcherStrategy
CGPUOffloadBaseDispatcher	Shared scaffolding for the GPU offload dispatchers (Map and Reduce)
CGPUOffloadMapDispatcher	Map node policy for the GPU offload dispatcher
CGPUOffloadReduceDispatcher
CScheduleType_GPU_Offload	Base class for GPU schedule types (CUDA/ROCm) using CRTP pattern
CGPUReduceDispatcher	Atomics-based GPU code generator for structured_control_flow::Reduce
CReductionLayout	Dense mixed-radix indexing for a strided reduction output footprint
CDimension	One source-address axis, measured in scalar elements rather than bytes
CScheduleType_GPU_Base	Base class for GPU schedule types (CUDA/ROCm) using CRTP pattern
CGpuTileArrivalNode	Counts the arrival of a thread block at a shared work item and elects the last arriving block
CGpuTileArrivalNodeSerializer
CGpuTileArrivalDispatcher	Emits GpuTileArrivalNode for the CUDA and ROCm kernel language extensions
CGPUOffloadTransform
Ntiles
CGPUTileTarget	The built-in GPU backend for the tile algebra, shared by CUDA and ROCm
CReductionScheduleProposal	A schedule-only change; loop domains, access expressions, and nesting stay fixed
CReductionLoopDomain	One projected affine loop domain; geometry queries consume domains deepest first
CReductionBufferInfo	One accumulator's logical footprint and allocation contribution
CReductionKernelInfo	Aggregate reduction-owned shared storage; excludes unrelated staging buffers
CReductionBufferAnalysis	Infer reduction footprints and verify explicitly materialized buffers
CTileAnalysis	Schedule-aware tile analysis: for a (loop scope, container) that MemoryLayoutAnalysis resolves to a bounded tile, produces a tiles::Tile (geometry, thread/value partition, copy direction) for memory-level transformations to consume instead of re-deriving
CAccessSummary	How a container is accessed within a loop, read straight off the dataflow (memlet types), independent of any pointer-weak Users analysis
CBankModel	A banked on-chip memory: banks banks of bank_bytes each, every bank serving one word per cycle
CPackedBuffer	The packed local buffer as a value: its nested-array shape (axes), the matching per-axis element address (subset), and the scalar-offset layout
CPipelineCommitNode
CPipelineWaitNode
CPipelineCommitNodeSerializer
CPipelineWaitNodeSerializer
CTileCopyNode	A tiled copy carried as a value TiledCopy plan
CTileCopyNodeSerializer
CTileCopyNodeDispatcher	Reference (sequential, scalar) dispatcher for TileCopyNode
CLocalityPlan	How a tile relates to its enclosing parallel loop nest, and the storage space that relationship demands
CSwizzle	XOR-swizzle as a composition functor over a Layout
CComposedLayout	A layout with a swizzle on its output offset (S o L) — the bank-conflict ConflictPolicy::Swizzle
CAxisSchedule	Target-neutral cooperation facts derived from one loop's schedule
CTileAxis	One enclosing parallel loop of a tile: its schedule facts plus the tile-role (Private when its indvar addresses the tile base, Cooperative otherwise)
CTile	A container's staged region: source maps a tile coordinate to the global element, axes is the thread/value partition, and the read/write flags give the copy direction
CTileTarget
CTileTargetRegistry	Maps a schedule value() to the TileTarget that owns it
CTiledCopy
CTileGuard	The ragged-tile boundary predicate, stored per-dim
CDim
CTileGuardNormalization	Re-discharge every TileCopyNode's ragged boundary guard
Nomp
COMPMapDispatcher
COMPConvExpander
COMPTileTarget
CScheduleType_OMP	CPU parallel schedule type with OpenMP support
Nvectorize
CVectorizeDispatcher
CScheduleType_Vectorize	Vectorize schedule type
Nauto_util
COffloadingTypeCollector	Filters over elements that have a scheduleType or implementationType like Tenstorrent, CUDA etc
CDebugInfo
CElement
CInvalidSDFGException
CUnstructuredControlFlowException
CStringEnum
CFunction
CTransformReport
COptimizationReport
CPassReportConsumer
COptionSpec
COptionKey
COptions
COptionRegistry
CSDFG
CStructuredSDFG
C__daisy_metadata
CHttpResult