| Cdaisy::tenstorrent::__daisy_DeviceDeleter | |
| C__daisy_metadata | |
| Csdfg::passes::LibNodeExpander::AccessNodeExpand | |
| Csdfg::tiles::TileAnalysis::AccessSummary | How a container is accessed within a loop, read straight off the dataflow (memlet types), independent of any pointer-weak Users analysis |
| Csdfg::visitor::ActualStructuredSDFGVisitor | Visitor for Structured SDFG (not a builder) |
| Csdfg::einsum::EinsumDetection | Non-destructive detection of einsum clusters in a StructuredSDFG |
| Csdfg::passes::LibNodeExpansionVisitor< Holder > | |
| Csdfg::passes::RedundantLoadVisitor | |
| Csdfg::passes::loop_fusion::NeighboringPatternVisitor | |
| Csdfg::transformations::FusionConsumerSubsetVisitor | |
| Csdfg::transformations::FusionConsumerUpdateVisitor | |
| Csdfg::users::BaseUserVisitor | Finds uses of containers |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::users::LegacyUserVisitor | 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 |
| Csdfg::users::Users | |
| Csdfg::symbolic::AffineDecomposition | Result of affine decomposition of an expression w.r.t |
| Csdfg::analysis::LoopAnalysis::AggregatedResult | |
| Csdfg::passes::AllocRec | |
| Cdocc::analysis::Analysis | |
| Cdocc::analysis::GlobalCFGAnalysis | |
| Cdocc::analysis::SDFGRegistry | |
| Csdfg::analysis::Analysis | |
| Cdocc::passes::AttributesAnalysis | |
| Csdfg::analysis::ArgumentsAnalysis | |
| Csdfg::analysis::AssumptionsAnalysis | |
| Csdfg::analysis::ControlFlowAnalysis | |
| Csdfg::analysis::DataDependencyAnalysis | Computes the read-after-write relation between users |
| Csdfg::analysis::LoopAnalysis | |
| Csdfg::analysis::MemoryLayoutAnalysis | Analysis that infers the assumed memory layouts of memlets |
| Csdfg::analysis::ReferenceAnalysis | |
| Csdfg::analysis::TypeAnalysis | |
| Csdfg::parallelization::LoopCarriedDependencyAnalysis | Standalone loop-carried dependency analysis |
| Csdfg::tiles::ReductionBufferAnalysis | Infer reduction footprints and verify explicitly materialized buffers |
| Csdfg::tiles::TileAnalysis | 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 |
| Csdfg::users::Users | |
| Cdocc::analysis::AnalysisManager | |
| Csdfg::analysis::AnalysisManager | |
| Carg_capture::ArgCapture | |
| Carg_capture::ArgCaptureIO | |
| Csdfg::codegen::ArgCapturePlan | |
| Cdocc::analysis::ArgumentAttributes | |
| Csdfg::codegen::ArgumentRegistry | |
| Csdfg::symbolic::Assumption | Represents assumptions about a symbol's properties and behavior |
| Csdfg::symbolic::Assumptions | Map from symbols to their assumptions |
| Csdfg::symbolic::AssumptionsBounds | Bundles Assumptions with both the loose and tight BoundAnalysis derived from them |
| Csdfg::data_flow::AtomicScalarOpImpl | A concrete lowering ("implementation") of an AtomicScalarOpNode |
| Csdfg::data_flow::AtomicScalarOpCPUImpl | CPU (OpenMP) atomic implementation |
| Csdfg::data_flow::AtomicScalarOpGPUImpl | Shared base for the GPU implementations (CUDA and ROCm) |
| Csdfg::data_flow::AtomicScalarOpCudaImpl | CUDA atomic implementation |
| Csdfg::data_flow::AtomicScalarOpRocmImpl | ROCm atomic implementation |
| Cdocc::analysis::Attributes | |
| Csdfg::tiles::AxisSchedule | Target-neutral cooperation facts derived from one loop's schedule |
| Csdfg::tiles::BankModel | A banked on-chip memory: banks banks of bank_bytes each, every bank serving one word per cycle |
| Csdfg::math::tensor::BaseElementWiseDataflowTensorNodeSerializer::BaseDeser | |
| Csdfg::math::tensor::SpatialTensorNodeBaseSerializer::BaseDeser | |
| Csdfg::analysis::BaseUserAnalyzer | |
| Csdfg::analysis::PointerEscapeAnalyzer< ForwardingEscapePolicy > | |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::analysis::PointerUsedAnalyzer< ForwardingEscapePolicy > | |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::analysis::PointerEscapeAnalyzer< Policy, ForceDetailed > | Reusable BaseUserAnalyzer that detects pointer escapes |
| Csdfg::analysis::PointerOverwriteAnalyzer< Policy > | Reusable BaseUserAnalyzer that detects pointer overwrites |
| Csdfg::analysis::PointerUsedAnalyzer< Policy > | Indirect access via pointer happened |
| Csdfg::users::BaseUserVisitor | Finds uses of containers |
| Csdfg::users::BaseUserAnalyzer | |
| Csdfg::analysis::PointerEscapeAnalyzer< ForwardingEscapePolicy > | |
| Csdfg::analysis::PointerUsedAnalyzer< ForwardingEscapePolicy > | |
| Csdfg::analysis::PointerEscapeAnalyzer< Policy, ForceDetailed > | Reusable BaseUserAnalyzer that detects pointer escapes |
| Csdfg::analysis::PointerOverwriteAnalyzer< Policy > | Reusable BaseUserAnalyzer that detects pointer overwrites |
| Csdfg::analysis::PointerUsedAnalyzer< Policy > | Indirect access via pointer happened |
| Csdfg::users::BaseUserVisitor | Finds uses of containers |
| CSymEngine::BaseVisitor | |
| Csdfg::codegen::CPPSymbolicPrinter | |
| Csdfg::codegen::CSymbolicPrinter | |
| Csdfg::serializer::JSONSymbolicPrinter | |
| Csdfg::fp_math::BlockBuilder | Builds the dataflow of one block from expressions |
| Csdfg::gpu::BlockCounts | Grouping of MMA blocks |
| Csdfg::passes::expansion::BlockOutcome | |
| Csdfg::passes::expansion::NodeOutcome | |
| Csdfg::einsum::EinsumDetection::BlockState | |
| Csdfg::codegen::Body | An open region of emitted code, closed by LanguageExtension::end |
| Csdfg::symbolic::BoundAnalysis | Computes bounds of symbolic expressions using assumptions |
| Csdfg::passes::Candidate | |
| Csdfg::codegen::CaptureVarPlan | |
| Csdfg::transformations::MmaNestOutputUses::CFragmentLoad | |
| Cdocc::compile::CodegenCompiler | |
| Cdocc::compile::NoopCompiler | |
| Cdocc::compile::SrcFileCompiler | |
| Cdocc::compile::CodegenCompilerBuilderBase< T > | |
| Cdocc::compile::CodegenCompilerBuilderBase< SrcFileCompilerBuilder > | |
| Cdocc::compile::SrcFileCompilerBuilder | |
| Csdfg::codegen::CodeGenerator | Base class for code generators |
| Csdfg::codegen::CStyleBaseCodeGenerator | |
| Csdfg::codegen::CCodeGenerator | |
| Csdfg::codegen::CPPCodeGenerator | |
| Csdfg::codegen::CodegenOutput | |
| Csdfg::passes::CodegenStatistics | |
| Csdfg::codegen::CodeSnippet | |
| Csdfg::codegen::CodeSnippetFactory | 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 |
| Csdfg::codegen::NestedCodeSnippetFactory | Used when we need to dispatch main SDFG elements into a subset of files (like offloaded kernels) |
| Cdocc::compile::CompileExecutor | |
| Cdocc::compile::CodegenBuildPool | |
| Cdocc::compile::CompileState | |
| Cdocc::compile::FileCompileState | |
| Csdfg::passes::loop_fusion::ComplexFusionResult | |
| Csdfg::tiles::ComposedLayout | A layout with a swizzle on its output offset (S o L) — the bank-conflict ConflictPolicy::Swizzle |
| Csdfg::builder::ConditionalDeleter< T > | |
| Csdfg::symbolic::Assumptions::const_iterator | Visits the own entries, then the base's entries the own ones do not shadow |
| Csdfg::data_flow::ConstSource | |
| Csdfg::data_flow::InMemoryConstSource | Constant data stored inline in SDFG |
| Csdfg::data_flow::RawFileConstSource | 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) |
| Csdfg::plugins::Context | TODO this class is broken |
| Csdfg::fp_math::ContractionPrecision | How contractions (MatMul and GEMM nodes) of Float and Double compute, as users select it |
| Csdfg::math::tensor::ContractionTypes | Element types of a contraction such as a matmul |
| Csdfg::math::tensor::ConvNode::ConvExpandPrerequisits | |
| Csdfg::gpu::cuda::CudaComputeCapability | A CUDA compute capability together with the name(s) of the device(s) that report it |
| Csdfg::passes::CUDAControlFlowOffloadTraits | |
| Csdfg::codegen::DataFlowDispatcher | |
| Csdfg::data_flow::DataFlowGraph | |
| Csdfg::analysis::DataFlowState< T > | |
| Csdfg::analysis::DataFlowState< std::unordered_map< ElementId, ExposedOffload > > | |
| Csdfg::analysis::ElementIdMapDataFlowState< ExposedOffload, OffloadHolder > | |
| Csdfg::analysis::OffloadState | |
| Csdfg::analysis::DataFlowState< std::unordered_map< ElementId, T > > | |
| Csdfg::analysis::ElementIdMapDataFlowState< T, I > | |
| Csdfg::analysis::DataRwFlags | |
| Csdfg::analysis::RegionArgument | |
| Csdfg::analysis::DataTransferEliminationCandidateCollector | |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::DebugInfo | |
| Cboost::default_dfs_visitor | |
| Csdfg::graph::DFSVisitor | |
| Csdfg::symbolic::DelinearizeResult | |
| Csdfg::symbolic::maps::DependenceDeltas | Represents the set of dependence distance vectors between two access patterns |
| Csdfg::codegen::DependencyState | |
| Csdfg::analysis::DeviceFreeSite | A device-buffer deallocation site: the FREE-lifecycle offloading node together with the block it lives in |
| Csdfg::tiles::TileGuard::Dim | |
| Csdfg::gpu::ReductionLayout::Dimension | One source-address axis, measured in scalar elements rather than bytes |
| Csdfg::codegen::DispatchInput | 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 |
| Csdfg::codegen::DispatchOutput | |
| Cdocc::util::DoccPaths | |
| Cdocc::util::DefaultDoccPaths | |
| Cdocc::target::DoccTarget | |
| Csdfg::einsum::EinsumCluster | Non-destructive counterpart of an EinsumNode |
| Csdfg::einsum::EinsumDimension | |
| Csdfg::einsum::EinsumEdge | |
| Csdfg::einsum::EinsumEdgeOriginal | |
| Csdfg::einsum::EinsumEdgeVirtual | |
| Csdfg::einsum::EinsumIndexContribution | A single einsum dimension's contribution to one operand's access subset |
| Csdfg::einsum::EinsumIndexing | How the consumed einsum dimensions map onto one operand's access subset |
| Csdfg::einsum::EinsumReplacementContext | ExpandContext for replacing an EinsumCluster with a new implementation |
| Csdfg::einsum::EinsumReplacer | Interface for replacing an EinsumCluster with a different implementation |
| Csdfg::einsum::Einsum2MatMul | Proof-of-concept replacer that turns a matmul-shaped EinsumCluster into a MatMulNode |
| Csdfg::gpu::GpuMmaEinsumReplacer | |
| Csdfg::Element | |
| Csdfg::control_flow::InterstateEdge | An edge connecting two states in an SDFG control-flow graph |
| Csdfg::control_flow::State | A state in a Stateful DataFlow Graph (SDFG) |
| Csdfg::control_flow::ReturnState | A special state that returns a value from the SDFG |
| Csdfg::data_flow::DataFlowNode | Abstract base class for all dataflow graph nodes |
| Csdfg::data_flow::AccessNode | Node representing access to a data container in the dataflow graph |
| Csdfg::data_flow::ConstantNode | Node representing a constant literal value in the dataflow graph |
| Csdfg::data_flow::CodeNode | Base class for computational nodes with inputs and outputs |
| Csdfg::data_flow::LibraryNode | Base class for all library nodes in the dataflow graph |
| Csdfg::data_flow::AtomicScalarOpNode | Wrapper around typical atomic operations (add, sub, min, max, swap) on a single scalar value |
| Csdfg::data_flow::BarrierLocalNode | |
| Csdfg::data_flow::CallNode | |
| Csdfg::data_flow::InvokeNode | |
| Csdfg::data_flow::LoadConstNode | |
| Csdfg::data_flow::MetadataNode | |
| Csdfg::fp_math::OzakiMatMulNode | Y = A @ B with B given as its Ozaki slices, prepared once for many products, e.g |
| Csdfg::gpu::GpuMmaFillNode | Prepares (declares and zero-initializes) a GPU MMA accumulator fragment |
| Csdfg::gpu::GpuMmaFragmentEltwiseAddNode | Handles the addition of two MMA fragments and stores the result in a third fragment |
| Csdfg::gpu::GpuMmaFragmentLoadNode | Loads a single MMA fragment from memory |
| Csdfg::gpu::GpuMmaFragmentStoreNode | Stores a single MMA fragment to memory |
| Csdfg::gpu::GpuMmaMatmulNode | A single GPU tensor-core matrix-multiply-accumulate (MMA) step |
| Csdfg::gpu::GpuTileArrivalNode | Counts the arrival of a thread block at a shared work item and elects the last arriving block |
| Csdfg::math::MathNode | Base class for mathematical library nodes with expansion support |
| Csdfg::einsum::EinsumNode | |
| Csdfg::math::blas::BLASNode | Base class for BLAS operation nodes |
| Csdfg::math::blas::BatchedGEMMNode | |
| Csdfg::math::blas::DotNode | |
| Csdfg::math::blas::GEMMNode | |
| Csdfg::math::tensor::TensorNode | Abstract base class for all tensor operations |
| Csdfg::math::tensor::ArangeNode | Tensor node that generates a sequence of numbers |
| Csdfg::math::tensor::BatchNormNode | In N, C, D0...Dn tensor, applies normalization to per channel in C across all the inner dimensions |
| Csdfg::math::tensor::BroadcastNode | |
| Csdfg::math::tensor::ClampNode | Computes Y = min(max(X, min), max) elementwise, where either bound may be omitted |
| Csdfg::math::tensor::ConcatNode | Tensor concatenation node that can concatenate a number of tensors into another tensor |
| Csdfg::math::tensor::ConditionalTensorCopyNode | Conditional tensor copy node that copies values from one tensor or another depending on a tensor mask |
| Csdfg::math::tensor::ConstPaddingNode | Applies padding by a constant value |
| Csdfg::math::tensor::ElementWiseDataflowTensorNode | Defined by each element of the output tensor (defined by shape) can be defined independently of any other output |
| Csdfg::math::tensor::AbsNode | |
| Csdfg::math::tensor::AddNode | |
| Csdfg::math::tensor::CMathTensorNode | |
| Csdfg::math::tensor::CastNode | |
| Csdfg::math::tensor::DivNode | |
| Csdfg::math::tensor::ErfNode | |
| Csdfg::math::tensor::ExpNode | |
| Csdfg::math::tensor::FillNode | |
| Csdfg::math::tensor::GELUNode | Applies the Gaussion Error Linear Units function |
| Csdfg::math::tensor::LogicalNotNode | |
| Csdfg::math::tensor::MaximumNode | |
| Csdfg::math::tensor::MinimumNode | |
| Csdfg::math::tensor::MulNode | |
| Csdfg::math::tensor::PowNode | |
| Csdfg::math::tensor::ReLUNode | |
| Csdfg::math::tensor::RsqrtNode | |
| Csdfg::math::tensor::SigmoidNode | |
| Csdfg::math::tensor::SqrtNode | |
| Csdfg::math::tensor::SubNode | |
| Csdfg::math::tensor::TanhNode | |
| Csdfg::math::tensor::TaskletTensorNode | |
| Csdfg::math::tensor::EluNode | Computes Y = X < 0 ? |
| Csdfg::math::tensor::EmbeddingNode | Embedding lookup node implementing aten.embedding(weight, indices) |
| Csdfg::math::tensor::EmbeddingRenormNode | In-place embedding renormalization implementing aten.embedding_renorm_ |
| Csdfg::math::tensor::IndexNode | Tensor advanced-indexing node |
| Csdfg::math::tensor::LayerNormNode | Applies layer normalization over the trailing noramlized_shape dimensions of the input |
| Csdfg::math::tensor::LeakyReLUNode | Computes Y = X > 0 ? |
| Csdfg::math::tensor::MatMulNode | Tensor matrix multiplication following ONNX MatMul operator specification |
| Csdfg::math::tensor::ReduceNode | Base class for tensor reduction operations |
| Csdfg::math::tensor::MaxNode | |
| Csdfg::math::tensor::MeanNode | |
| Csdfg::math::tensor::MinNode | |
| Csdfg::math::tensor::SoftmaxNode | |
| Csdfg::math::tensor::StdNode | |
| Csdfg::math::tensor::SumNode | |
| Csdfg::math::tensor::SpatialTensorNode | Specialization of TensorNode for spatial operations such as Convolution and Pooling |
| Csdfg::math::tensor::ConvNode | Convolution operation following ONNX Conv operator specification |
| Csdfg::math::tensor::PoolingNode | N-dimensional pooling operation |
| Csdfg::math::tensor::TensorCopyNode | Tensor copy node that copies values form one container to another according to their tensor access |
| Csdfg::math::tensor::UpsampleBilinear2DNode | 2D bilinear upsampling operation |
| Csdfg::math::cmath::CMathNode | |
| Csdfg::offloading::DataOffloadingNode | Name does not match current function |
| Csdfg::cuda::CUDADataOffloadingNode | |
| Csdfg::offloading::ExternalDataOffloadingNode | |
| Csdfg::rocm::ROCMDataOffloadingNode | |
| Csdfg::stdlib::StdlibNode | |
| Csdfg::stdlib::AllocaNode | |
| Csdfg::stdlib::AssertNode | |
| Csdfg::stdlib::CallocNode | |
| Csdfg::stdlib::FreeNode | |
| Csdfg::stdlib::MallocNode | |
| Csdfg::stdlib::MemcpyNode | |
| Csdfg::stdlib::MemmoveNode | |
| Csdfg::stdlib::MemsetNode | |
| Csdfg::stdlib::TrapNode | |
| Csdfg::stdlib::UnreachableNode | |
| Csdfg::tiles::PipelineCommitNode | |
| Csdfg::tiles::PipelineWaitNode | |
| Csdfg::tiles::TileCopyNode | A tiled copy carried as a value TiledCopy plan |
| Csdfg::data_flow::Tasklet | Simple computational operation in the dataflow graph |
| Csdfg::data_flow::Memlet | Edge in the dataflow graph representing data movement |
| Csdfg::structured_control_flow::ControlFlowNode | Base class for all structured control flow nodes in a StructuredSDFG |
| Csdfg::structured_control_flow::AssignmentBlock | |
| Csdfg::structured_control_flow::Block | A control flow node representing a basic block with dataflow computations |
| Csdfg::structured_control_flow::Break | Represents a break statement that exits the innermost loop |
| Csdfg::structured_control_flow::Continue | Represents a continue statement that skips to the next loop iteration |
| Csdfg::structured_control_flow::IfElse | Represents a conditional if-else control flow node with multiple cases |
| Csdfg::structured_control_flow::Return | Represents a return statement that exits the function with a value |
| Csdfg::structured_control_flow::Sequence | A sequential container of control flow nodes |
| Csdfg::structured_control_flow::StructuredLoop | Base class for structured loop constructs |
| Csdfg::structured_control_flow::For | Represents a traditional for-loop with sequential execution |
| Csdfg::structured_control_flow::Map | Represents a parallel map loop with configurable scheduling |
| Csdfg::structured_control_flow::Reduce | Represents a loop with an associative/commutative reduction carried dependency |
| Csdfg::structured_control_flow::While | Represents a while-loop with condition-controlled iteration |
| Csdfg::math::tensor::ElementWiseDataflowTensorNode::ElementInput | |
| Csdfg::math::tensor::ElementWiseDataflowTensorNode::ElementOutput | |
| Cdocc::target::et::EtBuildArgs | |
| Cstd::exception | STL class |
| Cdocc::lifting::NotImplementedException | |
| Csdfg::InvalidSDFGException | |
| Csdfg::UnstructuredControlFlowException | |
| Csdfg::symbolic::CNFException | Exception thrown when CNF conversion fails |
| Csdfg::transformations::InvalidTransformationDescriptionException | Exception thrown when a transformation description is invalid |
| Csdfg::transformations::InvalidTransformationException | Exception thrown when a transformation cannot be applied |
| Csdfg::passes::LibNodeExpander::ExpandContext | |
| Csdfg::passes::expansion::LibNodeExpansionContext | |
| Csdfg::passes::LibNodeExpander::ExpandOutcome | |
| Csdfg::analysis::ExposedOffload | |
| Csdfg::gpu::FoldBarrier | |
| Csdfg::analysis::ForwardingEscapePolicy | |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::analysis::ForwardStructuredDataFlowAnalysis< State > | Base class for forward data-flow analysis over structured control flow |
| Csdfg::analysis::ForwardStructuredDataFlowAnalysis< OffloadState > | |
| Csdfg::analysis::DataTransferEliminationAnalysis | |
| Csdfg::Function | |
| Csdfg::SDFG | |
| Csdfg::StructuredSDFG | |
| Csdfg::builder::FunctionBuilder | |
| Csdfg::builder::SDFGBuilder | |
| Csdfg::builder::StructuredSDFGBuilder | Note: Even though the class references unique_ptr, it will never delete an SDFG it has a reference to |
| Cdocc::lifting::FunctionLifting | |
| Cdocc::lifting::BLASLifting | |
| Cdocc::lifting::IntrinsicLifting | |
| Cdocc::lifting::LibFuncLifting | |
| CSymEngine::FunctionSymbol | |
| Csdfg::symbolic::DynamicSizeOfFunction | Function class for dynamic sizeof operation |
| Csdfg::symbolic::IModFunction | Function class for integer modulo operation |
| Csdfg::symbolic::MallocUsableSizeFunction | Function class for malloc_usable_size operation |
| Csdfg::symbolic::SizeOfTypeFunction | Function class representing sizeof for a type |
| Csdfg::symbolic::TruncI32Function | Function class for truncation to 32-bit integer |
| Csdfg::symbolic::ZExtI64Function | Function class for zero-extension to 64-bit integer |
| Cdocc::lifting::FunctionToSDFG | |
| Csdfg::passes::loop_fusion::FusionArg | |
| Csdfg::passes::loop_fusion::FusionArgCommonAccesses | |
| Csdfg::passes::loop_fusion::FusionArgCommonBlock | |
| Csdfg::passes::loop_fusion::FusionLoopCandidate | 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 |
| Csdfg::passes::loop_fusion::FusionRegCandidate | |
| Csdfg::passes::loop_fusion::LoopFusionByAccessWorker::FusionRegs | |
| Cdocc::analysis::GlobalCFGEdge | |
| Cdocc::analysis::GlobalCFGNode | |
| Csdfg::gpu::GpuArch | |
| Csdfg::gpu::cuda::CudaArch | |
| Csdfg::gpu::rocm::RocmArch | |
| Csdfg::gpu::GpuMmaDispatcherStrategy | Hardware-dependent emit primitives for the composable MMA library nodes |
| Csdfg::gpu::cuda::CudaMmaFragmentStrategy | Classic rocwmma fragment-based emit strategy (load/store/mma_sync/fill_fragment) |
| Csdfg::gpu::rocm::RocmMmaBareStrategy | Raw v_mfma_f32_32x32x8f16 emit strategy (see RocmMfma32Support) |
| Csdfg::gpu::rocm::RocmMmaFragmentStrategy | Classic rocwmma fragment-based emit strategy (load/store/mma_sync/fill_fragment) |
| Csdfg::gpu::GpuMmaFromMemoryLayout | Describes how a single MMA fragment maps to memory relative to a base pointer |
| Csdfg::gpu::GpuMmaSupport | |
| Csdfg::gpu::cuda::CudaMmaSupport | |
| Csdfg::gpu::rocm::RocmMmaSupport | |
| Csdfg::gpu::GpuMmaTiling | |
| Csdfg::gpu::GPUOffloadDispatcherStrategy | |
| Csdfg::cuda::CUDAOffloadDispatcherStrategy | CUDA specialization of gpu::GPUOffloadMapDispatcher |
| Csdfg::rocm::ROCMOffloadDispatcherStrategy | ROCm/HIP specialization of gpu::GPUOffloadMapDispatcher |
| Csdfg::codegen::InstrumentationPlan::GroupSpan | |
| Csdfg::passes::HierarchicalStatistics | |
| Csdfg::passes::CompileStatistics | |
| CHttpResult | |
| Csdfg::visitor::ImmutableStructuredSDFGVisitor | |
| Csdfg::transformations::MmaNestOutputUses | Collects the uses of an output container within a GPU MMA loop nest |
| Csdfg::transformations::SideEffectFinder | |
| Csdfg::passes::loop_fusion::LoopFusionHandler::InOutCheckResult | |
| Csdfg::math::tensor::InputContainerInfo | |
| Csdfg::codegen::InstrumentationInfo | |
| Csdfg::codegen::InstrumentationMemberInfo | |
| Csdfg::codegen::InstrumentationPlan | |
| Csdfg::symbolic::Interval | Result of bounding an expression: an interval [lower, upper] |
| Csdfg::symbolic::polyhedral::IslCtx | Move-only RAII owner of an isl_ctx |
| Csdfg::symbolic::polyhedral::IslHandle< T, FreeFn > | Move-only RAII owner of a reference-counted ISL object |
| Csdfg::visitor::StructuredSDFGWalker::Iterator | |
| Csdfg::types::IType | Abstract base interface for all types in the sdfglib type system |
| Csdfg::codegen::Reference | |
| Csdfg::types::Array | Represents a c-style array type |
| Csdfg::types::Function | Represents a function type |
| Csdfg::types::Pointer | Represents a pointer type |
| Csdfg::types::Scalar | Represents a scalar primitive type |
| Csdfg::types::Structure | Represents a structure type (similar to C struct) |
| Csdfg::types::Tensor | |
| Csdfg::serializer::JSONSerializer | |
| Csdfg::serializer::CutoutSerializer | |
| Csdfg::fp_math::KernelBuilder | Builds loop nests over transient buffers into a sequence |
| Csdfg::fp_math::KernelValue | A value in a block under construction: an access node with the subset and base type of the memlet reading it |
| Csdfg::codegen::LanguageExtension | |
| Csdfg::codegen::CStyleLanguageExtension | Statement and control-flow syntax shared by the C family (C, C++, CUDA, HIP) |
| Csdfg::codegen::CLanguageExtension | |
| Csdfg::codegen::CPPLanguageExtension | |
| Csdfg::cuda::CUDALanguageExtension | |
| Csdfg::rocm::ROCMLanguageExtension | |
| Csdfg::codegen::LibDependency | |
| Csdfg::gpu::cuda::CudaWmmaLibDependency | |
| Csdfg::gpu::rocm::RocmWmmaLibDependency | |
| Csdfg::math::blas::BLASLibDependency | |
| Csdfg::passes::LibNodeExpander | |
| Csdfg::passes::TypedLibNodeExpander< OzakiMatMulNode > | |
| Csdfg::passes::CodeLibNodeExpander< OzakiMatMulNode > | |
| Csdfg::fp_math::OzakiMatMulExpander | |
| Csdfg::passes::TypedLibNodeExpander< math::tensor::MatMulNode > | |
| Csdfg::passes::CodeLibNodeExpander< math::tensor::MatMulNode > | |
| Csdfg::gpu::GpuMmaExpander | |
| Csdfg::passes::TypedLibNodeExpander< MatMulNode > | |
| Csdfg::passes::CodeLibNodeExpander< MatMulNode > | |
| Csdfg::math::tensor::MatMulBlasExpander | |
| Csdfg::math::tensor::MatMulNaiveExpander | |
| Csdfg::passes::TypedLibNodeExpander< math::tensor::ConvNode > | |
| Csdfg::passes::CodeLibNodeExpander< math::tensor::ConvNode > | |
| Csdfg::offloading::GPUConvExpander | |
| Csdfg::omp::OMPConvExpander | |
| Csdfg::passes::TypedLibNodeExpander< math::MathNode > | |
| Csdfg::passes::MathNodeExpander | |
| Csdfg::passes::SwitchExpander | An expander that bundles several sub-expanders and switches to the correct one per node |
| Csdfg::passes::TypedLibNodeExpander< T > | |
| Csdfg::passes::CodeLibNodeExpander< T > | |
| Cdocc::compile::LibPath | |
| Csdfg::codegen::LibraryNodeDispatcher | Base class for library node code generation dispatchers |
| Csdfg::codegen::LibraryNodeDispatcherBase< sdfg::math::blas::GEMMNode > | |
| Cdocc::target::et::blas::GEMMNodeDispatcher_ETSOC_WithTransfers | |
| Csdfg::codegen::LibraryNodeDispatcherBase< NodeType > | |
| Csdfg::cuda::CUDADataOffloadingNodeDispatcher | |
| Csdfg::cuda::blas::BatchedGEMMNodeDispatcher_CUBLASWithTransfers | |
| Csdfg::cuda::blas::BatchedGEMMNodeDispatcher_CUBLASWithoutTransfers | |
| Csdfg::cuda::blas::DotNodeDispatcher_CUBLASWithTransfers | |
| Csdfg::cuda::blas::DotNodeDispatcher_CUBLASWithoutTransfers | |
| Csdfg::cuda::blas::GEMMNodeDispatcher_CUBLASWithTransfers | |
| Csdfg::cuda::blas::GEMMNodeDispatcher_CUBLASWithoutTransfers | |
| Csdfg::cuda::stdlib::MemcpyNodeDispatcher_CUDAWithTransfers | |
| Csdfg::cuda::stdlib::MemcpyNodeDispatcher_CUDAWithoutTransfers | |
| Csdfg::cuda::stdlib::MemsetNodeDispatcher_CUDAWithTransfers | |
| Csdfg::cuda::stdlib::MemsetNodeDispatcher_CUDAWithoutTransfers | |
| Csdfg::cuda::tensor::SoftmaxNodeDispatcher_CUDAWithTransfers | |
| Csdfg::cuda::tensor::SoftmaxNodeDispatcher_CUDAWithoutTransfers | |
| Csdfg::cuda::tiles::PipelineCommitNodeDispatcher | |
| Csdfg::cuda::tiles::PipelineWaitNodeDispatcher | |
| Csdfg::cuda::tiles::TileCopyNodeDispatcher | Cooperative dispatcher for the whole-copy sdfg::tiles::TileCopyNode |
| Csdfg::data_flow::AtomicScalarOpNodeDispatcher | |
| Csdfg::data_flow::AtomicScalarOpCPUNodeDispatcher | |
| Csdfg::data_flow::AtomicScalarOpGPUNodeDispatcher | |
| Csdfg::data_flow::CallNodeDispatcher | |
| Csdfg::data_flow::InvokeNodeDispatcher | |
| Csdfg::data_flow::LoadConstNodeDispatcher | |
| Csdfg::data_flow::MetadataDispatcher | |
| Csdfg::gpu::BarrierLocalNodeDispatcher | |
| Csdfg::gpu::GpuMmaNodeDispatcher | Shared storage for the strategy; each composable MMA node has its own dispatcher subclass |
| Csdfg::gpu::GpuMmaEltwiseAddDispatcher | D = out_type(Acc + acc_type(C)), element-wise over the fragments (gpu::GpuMmaFragmentEltwiseAdd) |
| Csdfg::gpu::GpuMmaFillDispatcher | Declare and zero-initialize an MMA accumulator fragment (gpu::GpuMmaFill) |
| Csdfg::gpu::GpuMmaFragmentLoadDispatcher | Load a tile from memory into a fragment (gpu::GpuMmaFragmentLoad) |
| Csdfg::gpu::GpuMmaFragmentStoreDispatcher | Store a fragment to a tile in memory (gpu::GpuMmaFragmentStore) |
| Csdfg::gpu::GpuMmaMatmulDispatcher | A single MMA accumulation of A * B into a preinitialized accumulator (gpu::GpuMmaMatmul) |
| Csdfg::gpu::GpuTileArrivalDispatcher | Emits GpuTileArrivalNode for the CUDA and ROCm kernel language extensions |
| Csdfg::math::blas::DotNodeDispatcher_BLAS | |
| Csdfg::math::blas::GEMMNodeDispatcher_BLAS | |
| Csdfg::math::cmath::CMathNodeDispatcher | |
| Csdfg::offloading::ExternalDataOffloadingNodeDispatcher | |
| Csdfg::rocm::ROCMDataOffloadingNodeDispatcher | |
| Csdfg::rocm::blas::BatchedGEMMNodeDispatcher_ROCMBLASWithTransfers | |
| Csdfg::rocm::blas::BatchedGEMMNodeDispatcher_ROCMBLASWithoutTransfers | |
| Csdfg::rocm::blas::DotNodeDispatcher_ROCMBLASWithTransfers | |
| Csdfg::rocm::blas::DotNodeDispatcher_ROCMBLASWithoutTransfers | |
| Csdfg::rocm::blas::GEMMNodeDispatcher_ROCMBLASWithTransfers | |
| Csdfg::rocm::blas::GEMMNodeDispatcher_ROCMBLASWithoutTransfers | |
| Csdfg::rocm::stdlib::MemcpyNodeDispatcher_ROCMWithTransfers | |
| Csdfg::rocm::stdlib::MemcpyNodeDispatcher_ROCMWithoutTransfers | |
| Csdfg::rocm::stdlib::MemsetNodeDispatcher_ROCMWithTransfers | |
| Csdfg::rocm::stdlib::MemsetNodeDispatcher_ROCMWithoutTransfers | |
| Csdfg::rocm::tiles::PipelineCommitNodeDispatcher | |
| Csdfg::rocm::tiles::PipelineWaitNodeDispatcher | |
| Csdfg::rocm::tiles::TileCopyNodeDispatcher | Cooperative dispatcher for the whole-copy sdfg::tiles::TileCopyNode |
| Csdfg::stdlib::AllocaNodeDispatcher | |
| Csdfg::stdlib::AssertNodeDispatcher | |
| Csdfg::stdlib::CallocNodeDispatcher | |
| Csdfg::stdlib::FreeNodeDispatcher | |
| Csdfg::stdlib::MallocNodeDispatcher | |
| Csdfg::stdlib::MemcpyNodeDispatcher | |
| Csdfg::stdlib::MemmoveNodeDispatcher | |
| Csdfg::stdlib::MemsetNodeDispatcher | |
| Csdfg::stdlib::TrapNodeDispatcher | |
| Csdfg::stdlib::UnreachableNodeDispatcher | |
| Csdfg::tiles::TileCopyNodeDispatcher | Reference (sequential, scalar) dispatcher for TileCopyNode |
| Csdfg::codegen::LibraryNodeDispatcherRegistry | Registry for library node dispatchers |
| Csdfg::serializer::LibraryNodeSerializer | Base class for library node serialization |
| Csdfg::math::tensor::ReduceNodeSerializer< MaxNode > | |
| Csdfg::math::tensor::ReduceNodeSerializer< MeanNode > | |
| Csdfg::math::tensor::ReduceNodeSerializer< MinNode > | |
| Csdfg::math::tensor::ReduceNodeSerializer< SoftmaxNode > | |
| Csdfg::math::tensor::ReduceNodeSerializer< StdNode > | |
| Csdfg::math::tensor::ReduceNodeSerializer< SumNode > | |
| Csdfg::data_flow::AtomicScalarOpNodeSerializer | |
| Csdfg::data_flow::BarrierLocalNodeSerializer | |
| Csdfg::data_flow::CallNodeSerializer | |
| Csdfg::data_flow::InvokeNodeSerializer | |
| Csdfg::data_flow::LoadConstNodeSerializer | |
| Csdfg::data_flow::MetadataNodeSerializer | |
| Csdfg::einsum::EinsumSerializer | |
| Csdfg::fp_math::OzakiMatMulNodeSerializer | |
| Csdfg::gpu::GpuMmaFillNodeSerializer | |
| Csdfg::gpu::GpuMmaFragmentEltwiseAddNodeSerializer | |
| Csdfg::gpu::GpuMmaFragmentLoadNodeSerializer | |
| Csdfg::gpu::GpuMmaFragmentStoreNodeSerializer | |
| Csdfg::gpu::GpuMmaMatmulNodeSerializer | |
| Csdfg::gpu::GpuTileArrivalNodeSerializer | |
| Csdfg::math::blas::BatchedGEMMNodeSerializer | |
| Csdfg::math::blas::DotNodeSerializer | |
| Csdfg::math::blas::GEMMNodeSerializer | |
| Csdfg::math::cmath::CMathNodeSerializer | |
| Csdfg::math::tensor::ArangeNodeSerializer | |
| Csdfg::math::tensor::BaseElementWiseDataflowTensorNodeSerializer | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< AbsNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< AddNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< CastNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< DivNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< ErfNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< ExpNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< FillNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< LogicalNotNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< MaximumNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< MinimumNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< MulNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< PowNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< ReLUNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< RsqrtNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< SigmoidNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< SqrtNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< SubNode > | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< TanhNode > | |
| Csdfg::math::tensor::CMathTensorNodeSerializer | |
| Csdfg::math::tensor::GELUNodeSerializer | |
| Csdfg::math::tensor::SimpleElementWiseDataflowTensorNodeSerializer< T > | |
| Csdfg::math::tensor::TaskletTensorNodeSerializer | |
| Csdfg::math::tensor::BatchNormNodeSerializer | |
| Csdfg::math::tensor::BroadcastNodeSerializer | |
| Csdfg::math::tensor::ClampNodeSerializer | |
| Csdfg::math::tensor::ConcatNodeSerializer | |
| Csdfg::math::tensor::ConditionalTensorCopyNodeSerializer | |
| Csdfg::math::tensor::ConstPaddingNodeSerializer | |
| Csdfg::math::tensor::EluNodeSerializer | |
| Csdfg::math::tensor::EmbeddingNodeSerializer | |
| Csdfg::math::tensor::EmbeddingRenormNodeSerializer | |
| Csdfg::math::tensor::IndexNodeSerializer | |
| Csdfg::math::tensor::LayerNormNodeSerializer | |
| Csdfg::math::tensor::LeakyReLUNodeSerializer | |
| Csdfg::math::tensor::MatMulNodeSerializer | Serializer for MatMulNode |
| Csdfg::math::tensor::ReduceNodeSerializer< T > | |
| Csdfg::math::tensor::SpatialTensorNodeBaseSerializer | |
| Csdfg::math::tensor::ConvNodeSerializer | Serializer for ConvNode |
| Csdfg::math::tensor::PoolingNodeSerializer | Serializer for PoolingNode |
| Csdfg::math::tensor::TensorCopyNodeSerializer | |
| Csdfg::math::tensor::UpsampleBilinear2DNodeSerializer | Serializer for UpsampleBilinear2DNode |
| Csdfg::offloading::DataOffloadingNodeSerializer | |
| Csdfg::cuda::CUDADataOffloadingNodeSerializer | |
| Csdfg::rocm::ROCMDataOffloadingNodeSerializer | |
| Csdfg::offloading::ExternalDataOffloadingNodeSerializer | |
| Csdfg::stdlib::AllocaNodeSerializer | |
| Csdfg::stdlib::AssertNodeSerializer | |
| Csdfg::stdlib::CallocNodeSerializer | |
| Csdfg::stdlib::FreeNodeSerializer | |
| Csdfg::stdlib::MallocNodeSerializer | |
| Csdfg::stdlib::MemcpyNodeSerializer | |
| Csdfg::stdlib::MemmoveNodeSerializer | |
| Csdfg::stdlib::MemsetNodeSerializer | |
| Csdfg::stdlib::TrapNodeSerializer | |
| Csdfg::stdlib::UnreachableNodeSerializer | |
| Csdfg::tiles::PipelineCommitNodeSerializer | |
| Csdfg::tiles::PipelineWaitNodeSerializer | |
| Csdfg::tiles::TileCopyNodeSerializer | |
| Csdfg::serializer::LibraryNodeSerializerRegistry | Registry for library node serializers |
| Cdocc::lifting::Lifting | Lifting is the process of converting a LLVM function into a SDFG |
| Cdocc::lifting::LiftingReport | |
| Cdocc::compile::LinkOptContributor | |
| Cdocc::compile::SrcFileCompiler | |
| Csdfg::tiles::LocalityPlan | How a tile relates to its enclosing parallel loop nest, and the storage space that relationship demands |
| Csdfg::analysis::LocalLoopInfo | 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 |
| Csdfg::parallelization::LoopCarriedDependencyInfo | Extended loop-carried dependency information including distance vectors |
| Csdfg::parallelization::LoopCarriedDependencyPair | Per-pair loop-carried dependency record |
| Csdfg::passes::loop_fusion::LoopFusionByAccessWorker | |
| Csdfg::passes::loop_fusion::LoopFusionHandler | |
| Csdfg::passes::loop_fusion::LoopFusionConfig | |
| Csdfg::transformations::LoopHeader | Bounds and step of a loop, keeping its induction variable |
| Csdfg::codegen::LoopHints | Loop properties a language may be able to express (e.g. clang loop pragmas in C) |
| Csdfg::analysis::LoopInfo | 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 |
| Csdfg::passes::scheduler::LoopScheduler | |
| Csdfg::passes::scheduler::CUDAOffloadScheduler | |
| Csdfg::passes::scheduler::CUDAScheduler | |
| Csdfg::passes::scheduler::OMPScheduler | |
| Csdfg::passes::scheduler::ROCMOffloadScheduler | |
| Csdfg::passes::scheduler::ROCMScheduler | |
| Csdfg::passes::scheduler::VectorizeScheduler | |
| Csdfg::einsum::EinsumDetection::LoopScopeState | |
| Csdfg::analysis::LoopAnalysis::LoopState | |
| Csdfg::transformations::LoopSwap | Two directly nested loops and their headers after swapping them |
| Csdfg::math::tensor::MapDimension | |
| Csdfg::codegen::MapDispatcherRegistry | Registry for map-specific dispatchers based on schedule type |
| Csdfg::passes::loop_fusion::PatternHandler::MatchResult | |
| Csdfg::einsum::Einsum2MatMul::MatMulAnalysis | Results of the applicability analysis that are reused by the replacement step |
| Csdfg::gpu::GpuMmaEinsumReplacer::EinsumMmaAnalysis | |
| Csdfg::data_flow::MemoryAccessPattern | |
| Csdfg::data_flow::ConvexAccessPattern | |
| Csdfg::data_flow::NoAccessPattern | |
| Csdfg::data_flow::TensorLayoutPattern | A structured access described by a full affine tensor layout (shape, strides and offset in elements) |
| Csdfg::analysis::MemoryTile | |
| Csdfg::analysis::MemoryTileGroup | |
| Csdfg::gpu::MmaBlockSize | |
| Carg_capture::MyHash | |
| Csdfg::gpu::NestedFoldPlan | |
| Csdfg::passes::HierarchicalStatistics::Node | |
| Csdfg::codegen::NodeDispatcher | Base class for dispatching control flow nodes to code |
| Csdfg::codegen::AssignmentDispatcher | |
| Csdfg::codegen::BlockDispatcher | |
| Csdfg::codegen::BreakDispatcher | |
| Csdfg::codegen::ContinueDispatcher | |
| Csdfg::codegen::ForDispatcher | |
| Csdfg::codegen::IfElseDispatcher | |
| Csdfg::codegen::ReturnDispatcher | |
| Csdfg::codegen::SchedTypeMapDispatcher | Dispatches to the actual NodeDispatcher based on scheduleType and the MapDispatcherRegistry |
| Csdfg::codegen::SchedTypeReduceDispatcher | Dispatches to the actual NodeDispatcher based on the Reduce's schedule type and the ReduceDispatcherRegistry |
| Csdfg::codegen::SequenceDispatcher | |
| Csdfg::codegen::SequentialMapDispatcher | |
| Csdfg::codegen::SequentialReduceDispatcher | Default (sequential) code generator for structured_control_flow::Reduce |
| Csdfg::codegen::WhileDispatcher | |
| Csdfg::cuda::CUDAMapDispatcher | |
| Csdfg::gpu::GPUOffloadBaseDispatcher | Shared scaffolding for the GPU offload dispatchers (Map and Reduce) |
| Csdfg::gpu::GPUOffloadMapDispatcher | Map node policy for the GPU offload dispatcher |
| Csdfg::gpu::GPUOffloadReduceDispatcher | |
| Csdfg::gpu::GPUReduceDispatcher | Atomics-based GPU code generator for structured_control_flow::Reduce |
| Csdfg::cuda::CUDAReduceDispatcher | Atomics-based CUDA code generator for structured_control_flow::Reduce |
| Csdfg::rocm::ROCMReduceDispatcher | Atomics-based ROCm/HIP code generator for structured_control_flow::Reduce |
| Csdfg::omp::OMPMapDispatcher | |
| Csdfg::rocm::ROCMMapDispatcher | |
| Csdfg::vectorize::VectorizeDispatcher | |
| Csdfg::codegen::NodeDispatcherRegistry | |
| Csdfg::analysis::OffloadHolder | |
| Csdfg::einsum::OperandContribution | A single consumed dimension's contribution to one operand, found during promotion |
| COpRewritePattern | |
| Cmlir::linalg::LinalgGenericToLinalgCustomBatchNorm2DNchw | Y = (x - E[x]) / sqrt(Var[x] + eps) * gamma + beta |
| Cmlir::linalg::LinalgGenericToLinalgSoftmax | Y[..., d, ...] = exp(x) / sum_d(exp(x_d)) |
| Csdfg::OptimizationReport | |
| Csdfg::OptionKey< T > | |
| Csdfg::OptionRegistry | |
| Csdfg::Options | |
| Csdfg::OptionSpec | |
| Csdfg::tiles::PackedBuffer | The packed local buffer as a value: its nested-array shape (axes), the matching per-axis element address (subset), and the scalar-offset layout |
| Csdfg::visitor::StructuredSDFGWalker::ParentScopeLoc | |
| Csdfg::passes::Pass | |
| Csdfg::passes::GPUControlFlowOffloadPass< CUDAControlFlowOffloadTraits > | |
| Csdfg::passes::GPUControlFlowOffloadPass< ROCMControlFlowOffloadTraits > | |
| Csdfg::passes::VisitorPass< ApproximateMath > | |
| Csdfg::passes::VisitorPass< LocalBufferReuseN< math::tensor::ConvNode, math::tensor::BatchNormNode > > | |
| Csdfg::passes::VisitorPass< LocalBufferReuseN< math::tensor::BatchNormNode, math::tensor::ReLUNode > > | |
| Csdfg::passes::VisitorPass< LocalBufferReuseN< math::tensor::ConvNode, math::tensor::BatchNormNode, math::tensor::ReLUNode > > | |
| Csdfg::passes::VisitorPass< LocalBufferReuseN< math::tensor::ConvNode, math::tensor::BatchNormNode, math::tensor::ReLUNode, math::tensor::ConvNode > > | |
| Csdfg::passes::VisitorPass< LocalBufferReuseN< math::tensor::ConvNode, math::tensor::BatchNormNode, math::tensor::ReLUNode, math::tensor::ConvNode, math::tensor::BatchNormNode > > | |
| Csdfg::passes::VisitorPass< MemletLinearization > | |
| Csdfg::passes::VisitorPass< MemletSimplification > | |
| Csdfg::passes::VisitorPass< TaskletFusion > | |
| Csdfg::passes::VisitorPass< TensorToPointerConversion > | |
| Csdfg::passes::VisitorPass< TrivialReferenceConversion > | |
| Csdfg::passes::VisitorPass< AllocationManagement > | |
| Csdfg::passes::VisitorPass< BlockFusion > | |
| Csdfg::passes::VisitorPass< ConditionElimination > | |
| Csdfg::passes::VisitorPass< IteratorToIndvar > | |
| Csdfg::passes::VisitorPass< EinsumConversion > | |
| Csdfg::passes::VisitorPass< EinsumLower > | |
| Csdfg::passes::VisitorPass< EinsumExpansion > | |
| Csdfg::passes::VisitorPass< FPContraction > | |
| Csdfg::passes::VisitorPass< ExtendedBlockHoisting > | |
| Csdfg::passes::VisitorPass< DotExpansion > | |
| Csdfg::passes::VisitorPass< BlockHoisting > | |
| Csdfg::passes::VisitorPass< CudaExpansion > | |
| Csdfg::passes::VisitorPass< CudaLibraryNodeRewriter > | |
| Csdfg::passes::VisitorPass< CudaLibraryNodeTransferExtractionVisitor > | |
| Csdfg::passes::VisitorPass< RocmExpansion > | |
| Csdfg::passes::VisitorPass< RocmLibraryNodeRewriter > | |
| Csdfg::passes::VisitorPass< RocmLibraryNodeTransferExtractionVisitor > | |
| Csdfg::einsum::EinsumDetectionPass | |
| Csdfg::fp_math::ContractionPrecisionPass | Applies the transformation precision selects to every contraction it can; others stay native |
| Csdfg::parallelization::AutoParallelization | Classifies parallelizable For loops and lowers them to Map or Reduce |
| Csdfg::passes::BlockSortingPass | |
| Csdfg::passes::ExtendedBlockSortingPass | |
| Csdfg::passes::ByteReferenceElimination | |
| Csdfg::passes::CollapsePass | Phased collapse pass: collects applicable collapses, then applies them |
| Csdfg::passes::CommonAssignmentElimination | |
| Csdfg::passes::ConstantPropagation | Forward-propagates floating-point constant scalars into their uses |
| Csdfg::passes::DataTransferMinimizationPass | |
| Csdfg::passes::DeadCFGElimination | |
| Csdfg::passes::DeadDataElimination | |
| Csdfg::passes::DeadReferenceElimination | |
| Csdfg::passes::DebugDumpPass | |
| Csdfg::passes::DebugInfoPropagation | |
| Csdfg::passes::DeviceBufferReusePass | 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 |
| Csdfg::passes::DeviceResidentArgPromotionPass | Promotes function pointer arguments to device-resident storage |
| Csdfg::passes::GPUControlFlowOffloadPass< Traits > | Offloads non-loop control flow directly nested in the SDFG root |
| Csdfg::passes::GPULoopReorderingPass | Phased GPU loop reordering pass |
| Csdfg::passes::GPUNestedOffloadPass | Depth-aware nested GPU offload pass |
| Csdfg::passes::GPUNestedParallelizationPass | Phased GPU nested map parallelization pass |
| Csdfg::passes::LibraryNodeExpansionPass< Holder > | Looks for and expands library nodes in a single pass, potentially recursively |
| Csdfg::passes::NoLibnodesBlockFusionPass | |
| Csdfg::passes::Pipeline | |
| Csdfg::passes::ReadonlyTransferHoistingPass | |
| Csdfg::passes::ReductionSharedMemoryDelinearization | Materialize compact GPU reduction partials and their SDFG accesses |
| Csdfg::passes::RedundantLoadEliminationPass | |
| Csdfg::passes::RedundantZeroInitEliminationPass | Applies RedundantZeroInitElimination to every loop annotated as zero init (ScheduleType_ZeroInit) |
| Csdfg::passes::ReferencePropagation | |
| Csdfg::passes::RemoveRedundantTransfersPass | |
| Csdfg::passes::ScalarPromotionPass | Promotes the array element a Reduce accumulates into, e.g |
| Csdfg::passes::SequenceFusion | |
| Csdfg::passes::SymbolEvolution | Rewrites loop-carried scalar recurrences into closed-form expressions |
| Csdfg::passes::SymbolPromotion | Pass that promotes simple dataflow computations to symbolic expressions |
| Csdfg::passes::SymbolPropagation | Pass that propagates symbolic assignments through the SDFG |
| Csdfg::passes::SyncConditionPropagation | |
| Csdfg::passes::TargetMappingPass | |
| Csdfg::passes::TensorAllocationSizeInference | Records the byte size of pointer containers in their StorageType::allocation_size, derived from the Tensor-typed memlets connecting them to library nodes |
| Csdfg::passes::TilingPass | Phased tiling pass: collects applicable tilings, then applies them |
| Csdfg::passes::TrivialArrayElimination | |
| Csdfg::passes::TrivialLoopEliminationPass | Applies TrivialLoopElimination to a set of maps |
| Csdfg::passes::UnifyLoopExits | |
| Csdfg::passes::UniqueLoopIndvars | Ensures every structured loop has a unique induction variable |
| Csdfg::passes::VisitorPass< T > | |
| Csdfg::passes::WhileToForConversion | |
| Csdfg::passes::loop_fusion::LoopFusionPass | A pass that performs loop fusion on a StructuredSDFG |
| Csdfg::passes::normalization::LoopNormalFormPass | |
| Csdfg::passes::normalization::MapDelinearizationPass | Splits flattened maps into nested maps along the divisions of their induction variables |
| Csdfg::passes::normalization::MapFusionPass | |
| Csdfg::passes::normalization::PerfectLoopDistributionPass | |
| Csdfg::passes::normalization::StrideMinimization | |
| Csdfg::passes::scheduler::LoopSchedulingPass | |
| Csdfg::passes::scheduler::RpcOptimizationPass | |
| Csdfg::tiles::TileGuardNormalization | Re-discharge every TileCopyNode's ragged boundary guard |
| Cllvm::PassInfoMixin | |
| Cdocc::passes::ArgumentExpansionPass | |
| Cdocc::passes::CodeGenerationPass | |
| Cdocc::passes::DOCCPass< PassT > | |
| Cdocc::passes::DumpAttributesPass | |
| Cdocc::passes::DumpSDFGPass | |
| Cdocc::passes::EinsumPass | |
| Cdocc::passes::FunctionToSDFGPass | |
| Cdocc::passes::GlobalCFGPrinterPass | |
| Cdocc::passes::NormalizationPass | |
| Cdocc::passes::OPTReportPass | |
| Cdocc::passes::SDFGSimplifyPass | |
| Cdocc::passes::SchedulingPass | |
| Csdfg::PassReportConsumer | |
| Cdocc::passes::PassReportCollector | |
| Csdfg::passes::loop_fusion::PatternHandler | |
| Csdfg::passes::loop_fusion::LoopFusionHandler | |
| Csdfg::passes::loop_fusion::LoopFusionByAccessWorker::Plan | |
| Cdocc::Plugin | |
| Csdfg::plugins::Plugin | |
| Cdocc::PluginRegistry | |
| Csdfg::data_flow::PointerAccessMeta | |
| Csdfg::data_flow::PointerFullWriteOnly | The pointer is used solely to write, no reading and over all of the data |
| Csdfg::data_flow::PointerGenericAccess | It is unknown what is done with this pointer or it is a mix of reads and writes |
| Csdfg::data_flow::PointerInvalidate | Meaning the underlying memory will be deallocated and use of the pointer after this is no longer valid |
| Csdfg::data_flow::PointerReadOnly | The pointer is only used for reading |
| Csdfg::data_flow::PointerAccessMetaSerializer | |
| Csdfg::codegen::PrettyPrinter | |
| Carg_capture::PrimitiveCppType< T > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Double > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Float > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Int16 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Int32 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Int64 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::Int8 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::UInt16 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::UInt32 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::UInt64 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::UInt8 > | |
| Carg_capture::PrimitiveCppType< PrimitiveType::X86_FP80 > | |
| Csdfg::einsum::PromotionCheck | Result of checking whether a loop can be folded into a cluster |
| Csdfg::data_flow::PtrMetaDeleter< T > | |
| Csdfg::transformations::Recorder | Records transformation history for replay and analysis |
| Csdfg::codegen::ReduceDispatcherRegistry | Registry for reduce-specific dispatchers based on schedule type |
| Csdfg::tiles::ReductionBufferInfo | One accumulator's logical footprint and allocation contribution |
| Csdfg::structured_control_flow::ReductionInfo | A single reduction carried by a Reduce loop |
| Csdfg::tiles::ReductionKernelInfo | Aggregate reduction-owned shared storage; excludes unrelated staging buffers |
| Csdfg::gpu::ReductionLayout | Dense mixed-radix indexing for a strided reduction output footprint |
| Csdfg::tiles::ReductionLoopDomain | One projected affine loop domain; geometry queries consume domains deepest first |
| Csdfg::tiles::ReductionScheduleProposal | A schedule-only change; loop domains, access expressions, and nesting stay fixed |
| Cdocc::passes::RegionReport | |
| Csdfg::transformations::Replayer | Replays recorded transformations on an SDFG |
| Csdfg::passes::ROCMControlFlowOffloadTraits | |
| Csdfg::gpu::rocm::RocmDeviceInfo | 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 |
| Csdfg::fp_math::RowMajorB | The copy read_b_row_major() makes of B, and the contraction that reads it |
| Csdfg::passes::rpc::RpcContext | |
| Csdfg::passes::rpc::SimpleRpcContext | |
| Csdfg::passes::rpc::DaisytunerRpcContext | |
| Csdfg::passes::rpc::RpcLocalReplayRecipe | Placeholder for native recipes |
| Csdfg::metadata::RpcOptimizationMetadata | |
| Csdfg::passes::rpc::RpcOptimizationMetadata | |
| Csdfg::passes::rpc::RpcOptRequest | |
| Csdfg::passes::rpc::RpcOptResponse | |
| Csdfg::passes::rpc::RpcRegionResult | Result for a single tuned region |
| Csdfg::passes::rpc::RpcSdfgResult | |
| Csdfg::passes::scheduler::SchedulerLoopInfo | |
| Csdfg::passes::scheduler::SchedulerRegistry | |
| Csdfg::structured_control_flow::ScheduleType | Represents a schedule type for Map nodes |
| Csdfg::gpu::ScheduleType_GPU_Base< Derived > | Base class for GPU schedule types (CUDA/ROCm) using CRTP pattern |
| Csdfg::gpu::ScheduleType_GPU_Base< ScheduleType_CUDA > | |
| Csdfg::cuda::ScheduleType_CUDA | CUDA schedule type inheriting shared GPU functionality Provides CUDA-specific value() and default block size (32 for warp size) |
| Csdfg::gpu::ScheduleType_GPU_Base< ScheduleType_ROCM > | |
| Csdfg::rocm::ScheduleType_ROCM | ROCM schedule type inheriting shared GPU functionality Provides ROCM-specific value() and default block size (64 for wavefront size) |
| Csdfg::gpu::ScheduleType_GPU_Offload | Base class for GPU schedule types (CUDA/ROCm) using CRTP pattern |
| Csdfg::cuda::ScheduleType_CUDA_Offload | CUDA schedule type inheriting shared GPU functionality Provides CUDA-specific value() and default block size (32 for warp size) |
| Csdfg::rocm::ScheduleType_ROCM_Offload | ROCM schedule type inheriting shared GPU functionality Provides ROCM-specific value() and default block size (64 for wavefront size) |
| Csdfg::structured_control_flow::ScheduleType_NestAnnotations | Annotations describing a whole loop nest rather than a single loop's execution strategy |
| Csdfg::structured_control_flow::ScheduleType_NoFusion | No-fusion annotation carried as a generic property on any ScheduleType |
| Csdfg::omp::ScheduleType_OMP | CPU parallel schedule type with OpenMP support |
| Csdfg::structured_control_flow::ScheduleType_Sequential | Sequential schedule type for Map nodes |
| Csdfg::structured_control_flow::ScheduleType_Unroll | Unroll annotation carried as a generic property on any ScheduleType |
| Csdfg::vectorize::ScheduleType_Vectorize | Vectorize schedule type |
| Csdfg::structured_control_flow::ScheduleType_ZeroInit | Zero-initialization annotation carried as a generic property on any ScheduleType |
| Cdocc::analysis::SDFGHolder | This a wrapper around 1 SDFG (may include historic versions of the same SDFG in the future) |
| Cmlir::sdfg::SDFGTranslator | |
| Csdfg::passes::rpc::SimpleRpcContextBuilder | |
| Csdfg::passes::SingleExpanderHolder | |
| Csdfg::analysis::ForwardStructuredDataFlowAnalysis< State >::SolveProgress | |
| Csdfg::passes::loop_fusion::LoopFusionPass::State | |
| Csdfg::passes::RedundantLoadEliminationPass::State | |
| Csdfg::types::StorageType | Represents the storage location and management characteristics of data |
| Csdfg::StringEnum | |
| Csdfg::types::StructureDefinition | Defines the layout and members of a structure type |
| Csdfg::deepcopy::StructuredSDFGDeepCopy | |
| Csdfg::visitor::StructuredSDFGVisitor | Very specific implementation, that technically visits the SDFG of an StructuredSDFGBuilder and not just any SDFG |
| Csdfg::auto_util::OffloadingTypeCollector | Filters over elements that have a scheduleType or implementationType like Tenstorrent, CUDA etc |
| Csdfg::codegen::LoopReport | |
| Csdfg::cuda::CudaLibraryNodeRewriter | |
| Csdfg::einsum::EinsumExpansion | Visitor that expands the EinsumNode with the legacy expand() method |
| Csdfg::einsum::EinsumLower | |
| Csdfg::passes::BufferReuseMarker | |
| Csdfg::rocm::RocmLibraryNodeRewriter | |
| Csdfg::transformations::BarrierFinder | |
| Csdfg::visitor::NonStoppingStructuredSDFGVisitor | |
| Csdfg::passes::LocalBufferReuseN< T, S > | |
| Csdfg::cuda::CudaLibraryNodeTransferExtractionVisitor | |
| Csdfg::einsum::EinsumConversion | |
| Csdfg::fp_math::FPContraction | Floating-point contraction (-ffp-contract=fast): applies FuseFMA in every block until no multiplication feeding an addition is left to contract |
| Csdfg::passes::AllocationManagement | |
| Csdfg::passes::ApproximateMath | Marks every CMathNode as approximate, permitting fast device intrinsics (e.g. __expf) |
| Csdfg::passes::BlockFusion | |
| Csdfg::passes::BlockHoisting | 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 |
| Csdfg::passes::ExtendedBlockHoisting | |
| Csdfg::passes::ConditionElimination | |
| Csdfg::passes::CudaExpansion | |
| Csdfg::passes::DotExpansion | |
| Csdfg::passes::IteratorToIndvar | |
| Csdfg::passes::LocalBufferReuseN< LibNodes > | |
| Csdfg::passes::MemletLinearization | Linearizes memlet base types by flattening nested arrays |
| Csdfg::passes::MemletSimplification | Simplifies mixed-radix index expressions in memlet subsets |
| Csdfg::passes::RocmExpansion | |
| Csdfg::passes::TargetMappingVisitor | Generified version to map LibraryNodes for now |
| Csdfg::passes::TaskletFusion | |
| Csdfg::passes::TensorToPointerConversion | |
| Csdfg::passes::TrivialReferenceConversion | |
| Csdfg::passes::normalization::MapFusion | |
| Csdfg::rocm::RocmLibraryNodeTransferExtractionVisitor | |
| Csdfg::visitor::StructuredSDFGWalker | A sequential walker for traversing structured control flow nodes in a StructuredSDFG with iterators Iterators traverse the SDFG same as our visitors do |
| Csdfg::data_flow::SubgroupAccess | The operand elements one subgroup touches in a single access: for every lane, the operand coordinates it reads, in register order |
| Csdfg::tiles::Swizzle | XOR-swizzle as a composition functor over a Layout |
| Csdfg::offloading::TargetLibNodeExpander | |
| Csdfg::offloading::CudaBatchedMatMulExpander | |
| Csdfg::offloading::CudaConcatExpander | |
| Csdfg::offloading::RocmBatchedMatMulExpander | |
| Csdfg::offloading::RocmConcatExpander | |
| Csdfg::plugins::TargetMapper | |
| Cdocc::target::et::EtLibNodeMapper | |
| Csdfg::plugins::TargetMapperFactory | |
| Csdfg::plugins::TargetMapperRegistry | |
| Csdfg::plugins::TargetMappingPlan | |
| Cdocc::target::TargetOptions | |
| Cmlir::sdfg::TensorInfo | |
| Csdfg::math::tensor::TensorLayout | 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 |
| Csdfg::tiles::Tile | 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 |
| Csdfg::tiles::TileAxis | One enclosing parallel loop of a tile: its schedule facts plus the tile-role (Private when its indvar addresses the tile base, Cooperative otherwise) |
| Csdfg::tiles::TiledCopy | |
| Csdfg::tiles::TileGuard | The ragged-tile boundary predicate, stored per-dim |
| Csdfg::transformations::LocalStorage::TileInfo | Normalized tile description handed from can_be_applied() to apply() |
| Csdfg::tiles::TileTarget | |
| Csdfg::omp::OMPTileTarget | |
| Csdfg::tiles::GPUTileTarget | The built-in GPU backend for the tile algebra, shared by CUDA and ROCm |
| Csdfg::tiles::TileTargetRegistry | Maps a schedule value() to the TileTarget that owns it |
| Cdocc::offloading::TransferArg | |
| Csdfg::transformations::Transformation | Base class for all SDFG transformations |
| Csdfg::cuda::CUBLASDataTransferExtraction | |
| Csdfg::cuda::CUDASoftmaxDataTransferExtraction | |
| Csdfg::cuda::CUDAStdlibDataTransferExtraction | |
| Csdfg::einsum::Einsum2Dot | |
| Csdfg::einsum::Einsum2Gemm | |
| Csdfg::einsum::EinsumExtend | |
| Csdfg::einsum::EinsumLift | |
| Csdfg::einsum::EinsumPromotion | |
| Csdfg::fp_math::FuseFMA | Contracts a floating-point multiplication feeding an addition into a fused multiply-add |
| Csdfg::fp_math::OzakiContraction | Emulates a floating-point matmul (MatMul or GEMM node) with exact Int8 matmuls (Ozaki scheme), at about the input's precision |
| Csdfg::fp_math::QuantizeContraction | Computes a floating-point matmul (MatMul or GEMM node) on integers, quantized with a scale per row of A and per column of B |
| Csdfg::fp_math::UnfuseFMA | Splits a fused multiply-add into a multiplication and an addition |
| Csdfg::gpu::GpuMmaEinsumTransform | |
| Csdfg::gpu::rocm::GpuMmaTransform | |
| Csdfg::rocm::ROCBLASDataTransferExtraction | |
| Csdfg::rocm::ROCMStdlibDataTransferExtraction | |
| Csdfg::transformations::CUDAParallelizeNestedMap | Assigns a nested sequential map to the next available CUDA grid dimension |
| Csdfg::transformations::CollapseToDepth | Collapse a perfectly-nested map nest into a target number of loops |
| Csdfg::transformations::GPUConditionPropagation | |
| Csdfg::transformations::GPUConditionPropagationScope | Root-anchored sweep of GPUConditionPropagation |
| Csdfg::transformations::GPULoopReordering | |
| Csdfg::transformations::GPUOffloadNestedLoop< GPUType > | |
| Csdfg::transformations::LocalStorage | Local-storage transformation |
| Csdfg::transformations::LoopConditionNormalize | Loop condition normalization to convert inequality conditions to relational comparisons |
| Csdfg::transformations::LoopDistribute | Loop distribution (loop fission) transformation |
| Csdfg::transformations::LoopIndvarFinalize | Computes closed-form final value of induction variable after loop |
| Csdfg::transformations::LoopInterchange | Loop interchange transformation that swaps two nested loops |
| Csdfg::transformations::LoopParallelization | Converts a single For loop into a sequential Map |
| Csdfg::transformations::LoopPeeling | Loop peeling for a perfectly nested chain of compound-condition loops |
| Csdfg::transformations::LoopRotate | Loop rotation transformation to convert negative stride to positive stride |
| Csdfg::transformations::LoopShift | Loop shift transformation to change loop initialization value |
| Csdfg::transformations::LoopSkewing | Loop skewing transformation for nested loops |
| Csdfg::transformations::LoopSplit | Loop splitting transformation at a symbolic boundary |
| Csdfg::transformations::LoopTiling | Loop tiling (blocking) transformation |
| Csdfg::transformations::MultiLevelTiling | Multi-level loop tiling transformation |
| Csdfg::transformations::LoopUnitStride | Loop unit stride transformation to convert non-unit stride loops to unit stride |
| Csdfg::transformations::MapCollapse | Map collapse transformation |
| Csdfg::transformations::MapDelinearize | Splits a map into nested maps along the divisions of its induction variable; the inverse of MapCollapse |
| Csdfg::transformations::MapFusion | Map fusion transformation that fuses two sequential maps |
| Csdfg::transformations::OMPTransform | OMPTransform transformation for Map nodes |
| Csdfg::transformations::OffloadTransform | |
| Csdfg::gpu::GPUOffloadTransform< CUDADataOffloadingNode > | |
| Csdfg::cuda::CUDAOffloadTransform | |
| Csdfg::gpu::GPUOffloadTransform< ROCMDataOffloadingNode > | |
| Csdfg::rocm::ROCMOffloadTransform | |
| Csdfg::cuda::CUDATransform | Offloads a top-level loop to a CUDA kernel (X grid dimension) |
| Csdfg::gpu::GPUOffloadTransform< OffloaderNodeType > | |
| Csdfg::rocm::ROCMTransform | Offloads a top-level loop to a ROCm/HIP kernel (X grid dimension) |
| Csdfg::transformations::ROCMParallelizeNestedMap | Assigns a nested sequential map to the next available ROCm grid dimension |
| Csdfg::transformations::RPCNodeTransform | |
| Csdfg::transformations::RedundantZeroInitElimination | Eliminates a zero-initialization nest that is redundant before a GPU MMA matmul nest |
| Csdfg::transformations::SoftwarePipelining | Software-pipeline a sequential panel loop that cooperatively stages a shared-memory tile each iteration (the structure LocalStorage emits) |
| Csdfg::transformations::StreamK | 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 |
| Csdfg::transformations::TileFusion | Tile fusion transformation that merges two consecutive sibling tiled Maps |
| Csdfg::transformations::TileVectorizer | Widen every cooperative shared-staging copy in a subtree to the widest legal vector transfer |
| Csdfg::transformations::TrivialLoopElimination | Eliminates a trivial map, i.e., a map executing exactly one iteration |
| Csdfg::transformations::UnrollTransform | Marks a constant-trip loop for full unrolling |
| Csdfg::transformations::VectorizeTransform | VectorizeTransform transformation for StructuredLoop nodes |
| Csdfg::TransformReport | |
| Csdfg::analysis::User | |
| Csdfg::users::ForUser | |
| Csdfg::users::User | |
| Csdfg::users::ForUser | |
| Csdfg::analysis::UsersView | |
| Csdfg::users::UsersView | |
| Csdfg::visualizer::Visualizer | |
| Csdfg::visualizer::DotVisualizer | |
1.15.0