CUTLASS: Class List

| CUTLASS CUDA Templates for Linear Algebra Subroutines and Solvers

- Main Page
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123456]

►N cutlass |
►N arch |
C Mma | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, complex< double >, LayoutA, complex< double >, LayoutB, complex< double >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, complex< double >, LayoutA, double, LayoutB, complex< double >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, complex< float >, LayoutA, complex< float >, LayoutB, complex< float >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, complex< float >, LayoutA, float, LayoutB, complex< float >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, double, LayoutA, complex< double >, LayoutB, complex< double >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, double, LayoutA, double, LayoutB, double, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, Operator > | Matrix multiply-add operation - specialized for 1x1x1x1 matrix multiply operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, float, LayoutA, complex< float >, LayoutB, complex< float >, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, float, LayoutA, float, LayoutB, float, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, half_t, LayoutA, half_t, LayoutB, float, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 1 >, 1, int, LayoutA, int, LayoutB, int, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 2 >, 1, int16_t, layout::RowMajor, int16_t, layout::ColumnMajor, int, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 1, 4 >, 1, int8_t, LayoutA, int8_t, LayoutB, int, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 1, 2, 1 >, 1, half_t, LayoutA, half_t, LayoutB, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 16, 16, 4 >, 32, half_t, LayoutA, half_t, LayoutB, ElementC, LayoutC, Operator > | Matrix multiply-add operation specialized for the entire warp
C Mma< gemm::GemmShape< 16, 8, 8 >, 32, half_t, layout::RowMajor, half_t, layout::ColumnMajor, float, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F32 = F16 * F16 + F32
C Mma< gemm::GemmShape< 16, 8, 8 >, 32, half_t, layout::RowMajor, half_t, layout::ColumnMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation - F16 = F16 * F16 + F16
C Mma< gemm::GemmShape< 2, 1, 1 >, 1, half_t, LayoutA, half_t, LayoutB, half_t, LayoutC, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 2, 2, 1 >, 1, half_t, layout::ColumnMajor, half_t, layout::RowMajor, half_t, layout::ColumnMajor, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 2, 2, 1 >, 1, half_t, layout::ColumnMajor, half_t, layout::RowMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 8, 8, 128 >, 32, uint1b_t, layout::RowMajor, uint1b_t, layout::ColumnMajor, int, layout::RowMajor, OpXorPopc > | Matrix multiply-add operation
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, int8_t, layout::RowMajor, int8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = S8 * S8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, int8_t, layout::RowMajor, int8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = S8 * S8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, int8_t, layout::RowMajor, uint8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = S8 * U8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, int8_t, layout::RowMajor, uint8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = S8 * U8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, uint8_t, layout::RowMajor, int8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = U8 * S8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, uint8_t, layout::RowMajor, int8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = U8 * S8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, uint8_t, layout::RowMajor, uint8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = S8 * U8 + S32
C Mma< gemm::GemmShape< 8, 8, 16 >, 32, uint8_t, layout::RowMajor, uint8_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = S8 * U8 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, int4b_t, layout::RowMajor, int4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = S4 * S4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, int4b_t, layout::RowMajor, int4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = S4 * S4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, int4b_t, layout::RowMajor, uint4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = S4 * U4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, int4b_t, layout::RowMajor, uint4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = S4 * U4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, uint4b_t, layout::RowMajor, int4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = U4 * S4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, uint4b_t, layout::RowMajor, int4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = U4 * S4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, uint4b_t, layout::RowMajor, uint4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: S32 = U4 * U4 + S32
C Mma< gemm::GemmShape< 8, 8, 32 >, 32, uint4b_t, layout::RowMajor, uint4b_t, layout::ColumnMajor, int, layout::RowMajor, OpMultiplyAddSaturate > | Matrix multiply-add operation: S32 = U4 * U4 + S32
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::ColumnMajor, half_t, layout::ColumnMajor, float, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F32 = F16 * F16 + F32
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::ColumnMajor, half_t, layout::ColumnMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F16 = F16 * F16 + F16
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::ColumnMajor, half_t, layout::RowMajor, float, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F32 = F16 * F16 + F32
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::ColumnMajor, half_t, layout::RowMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F16 = F16 * F16 + F16
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::RowMajor, half_t, layout::ColumnMajor, float, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F32 = F16 * F16 + F32
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::RowMajor, half_t, layout::ColumnMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F16 = F16 * F16 + F16
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::RowMajor, half_t, layout::RowMajor, float, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F32 = F16 * F16 + F32
C Mma< gemm::GemmShape< 8, 8, 4 >, 8, half_t, layout::RowMajor, half_t, layout::RowMajor, half_t, layout::RowMajor, OpMultiplyAdd > | Matrix multiply-add operation: F16 = F16 * F16 + F16
C PtxWmma | WMMA Matrix multiply-add operation
C PtxWmmaLoadA | WMMA PTX string load for A, B, and C matrices
C PtxWmmaLoadB |
C PtxWmmaLoadC |
C PtxWmmaStoreD | WMMA store for matrix D
C Sm50 |
C Sm60 |
C Sm61 |
C Sm70 |
C Sm72 |
C Sm75 |
C Wmma< Shape_, cutlass::half_t, LayoutA_, cutlass::half_t, LayoutB_, ElementC_, LayoutC_, cutlass::arch::OpMultiplyAdd > |
C Wmma< Shape_, cutlass::int4b_t, LayoutA_, cutlass::int4b_t, LayoutB_, int32_t, LayoutC_, cutlass::arch::OpMultiplyAdd > |
C Wmma< Shape_, cutlass::uint1b_t, LayoutA_, cutlass::uint1b_t, LayoutB_, int32_t, LayoutC_, cutlass::arch::OpXorPopc > |
C Wmma< Shape_, int8_t, LayoutA_, int8_t, LayoutB_, int32_t, LayoutC_, cutlass::arch::OpMultiplyAdd > |
C Wmma< Shape_, uint8_t, LayoutA_, uint8_t, LayoutB_, int32_t, LayoutC_, cutlass::arch::OpMultiplyAdd > |
►N device_memory |
►C allocation | Device allocation abstraction that tracks size and capacity
C deleter | Delete functor for CUDA device memory
►N epilogue |
►N thread |
►C Convert |
C Params | Host-constructable parameters structure
►C LinearCombination |
C Params | Host-constructable parameters structure
►C LinearCombinationClamp |
C Params | Host-constructable parameters structure
►C LinearCombinationRelu |
C Params | Host-constructable parameters structure
►C LinearCombinationRelu< ElementOutput_, Count, int, float, Round > |
C Params | Host-constructable parameters structure
►C ReductionOpPlus |
C Params | Host-constructable parameters structure
►N threadblock |
►N detail |
C RowArrangement | RowArrangement determines how one or more warps cover a region of consecutive rows
C RowArrangement< Shape, WarpsRemaining, ElementsPerAccess, ElementSize, false > | RowArrangement in which each warp's access is a 1D tiled arrangement
►C RowArrangement< Shape, WarpsRemaining, ElementsPerAccess, ElementSize, true > | RowArrangement in which each warp's access is a 2D tiled arrangement
C Detail |
C DefaultEpilogueComplexTensorOp | Defines sensible defaults for epilogues for TensorOps
C DefaultEpilogueSimt | Defines sensible defaults for epilogues for SimtOps
C DefaultEpilogueTensorOp | Defines sensible defaults for epilogues for TensorOps
C DefaultEpilogueVoltaTensorOp | Defines sensible defaults for epilogues for TensorOps
C DefaultEpilogueWmmaTensorOp | Defines sensible defaults for epilogues for WMMA TensorOps
C DefaultInterleavedEpilogueTensorOp |
►C DefaultInterleavedThreadMapTensorOp | Defines the optimal thread map for TensorOp accumulator layouts
C Detail |
►C DefaultThreadMapSimt | Defines the optimal thread map for SIMT accumulator layouts
C Detail |
►C DefaultThreadMapTensorOp | Defines the optimal thread map for TensorOp accumulator layouts
C Detail |
C DefaultThreadMapVoltaTensorOp | Defines the optimal thread map for TensorOp accumulator layouts
►C DefaultThreadMapVoltaTensorOp< ThreadblockShape_, WarpShape_, PartitionsK, ElementOutput_, ElementsPerAccess, float > | Defines the optimal thread map for TensorOp accumulator layouts
C Detail |
►C DefaultThreadMapVoltaTensorOp< ThreadblockShape_, WarpShape_, PartitionsK, ElementOutput_, ElementsPerAccess, half_t > | Defines the optimal thread map for TensorOp accumulator layouts
C Detail |
►C DefaultThreadMapWmmaTensorOp | Defines the optimal thread map for Wmma TensorOp accumulator layouts
C Detail |
►C DirectEpilogueTensorOp | Epilogue operator
C Params | Parameters structure for host-constructible state
C SharedStorage | Shared storage allocation needed by the epilogue
C Epilogue | Epilogue operator without splitk
►C EpilogueBase | Base class for epilogues defining warp-level
C SharedStorage | Shared storage allocation needed by the epilogue
►C InterleavedEpilogue | Epilogue operator without splitk
C SharedStorage | Shared storage allocation needed by the epilogue
►C InterleavedOutputTileThreadMap |
C Detail |
►C InterleavedPredicatedTileIterator |
C Mask | Mask object
C Params |
►C OutputTileOptimalThreadMap |
C CompactedThreadMap | Compacted thread map in which the 4D region is contiguous
C Detail |
C OutputTileShape | Tuple defining point in output tile
C OutputTileThreadMap |
►C PredicatedTileIterator |
C Mask | Mask object
C Params |
C SharedLoadIterator |
►N warp |
C FragmentIteratorComplexTensorOp |
C FragmentIteratorComplexTensorOp< WarpShape_, OperatorShape_, OperatorElementC_, OperatorFragmentC_, layout::RowMajor > | Partial specialization for row-major shared memory
C FragmentIteratorSimt | Fragment iterator for SIMT accumulator arrangements
C FragmentIteratorSimt< WarpShape_, Operator_, layout::RowMajor, MmaSimtPolicy_ > | Partial specialization for row-major shared memory
C FragmentIteratorTensorOp |
C FragmentIteratorTensorOp< WarpShape_, OperatorShape_, OperatorElementC_, OperatorFragmentC_, layout::ColumnMajorInterleaved< InterleavedK > > | Dedicated to interleaved layout
C FragmentIteratorTensorOp< WarpShape_, OperatorShape_, OperatorElementC_, OperatorFragmentC_, layout::RowMajor > | Partial specialization for row-major shared memory
C FragmentIteratorVoltaTensorOp |
C FragmentIteratorVoltaTensorOp< WarpShape_, gemm::GemmShape< 32, 32, 4 >, float, layout::RowMajor > | Partial specialization for row-major shared memory
C FragmentIteratorVoltaTensorOp< WarpShape_, gemm::GemmShape< 32, 32, 4 >, half_t, layout::RowMajor > | Partial specialization for row-major shared memory
C FragmentIteratorWmmaTensorOp |
C FragmentIteratorWmmaTensorOp< WarpShape_, OperatorShape_, OperatorElementC_, OperatorFragmentC_, layout::RowMajor > | Partial specialization for row-major shared memory
C SimtPolicy |
C SimtPolicy< WarpShape_, Operator_, layout::RowMajor, MmaSimtPolicy_ > | Partial specialization for row-major
C TensorOpPolicy | Policy details related to the epilogue
C TensorOpPolicy< WarpShape, OperatorShape, layout::ColumnMajorInterleaved< InterleavedK > > | Partial specialization for column-major-interleaved
C TensorOpPolicy< WarpShape, OperatorShape, layout::RowMajor > | Partial specialization for row-major
C TileIteratorSimt | Template for reading and writing tiles of accumulators to shared memory
C TileIteratorSimt< WarpShape_, Operator_, Element_, layout::RowMajor, MmaSimtPolicy_ > | Template for reading and writing tiles of accumulators to shared memory
C TileIteratorTensorOp | Template for reading and writing tiles of accumulators to shared memory
►C TileIteratorTensorOp< WarpShape_, OperatorShape_, Element_, layout::RowMajor > | Template for reading and writing tiles of accumulators to shared memory
C Detail |
C TileIteratorVoltaTensorOp | Template for reading and writing tiles of accumulators to shared memory
►C TileIteratorVoltaTensorOp< WarpShape_, gemm::GemmShape< 32, 32, 4 >, float, layout::RowMajor > | Template for reading and writing tiles of accumulators to shared memory
C Detail |
►C TileIteratorVoltaTensorOp< WarpShape_, gemm::GemmShape< 32, 32, 4 >, half_t, layout::RowMajor > | Template for reading and writing tiles of accumulators to shared memory
C Detail |
C TileIteratorWmmaTensorOp | Template for reading and writing tiles of accumulators to shared memory
C TileIteratorWmmaTensorOp< WarpShape_, OperatorShape_, OperatorFragment_, layout::RowMajor > | Template for reading and writing tiles of accumulators to shared memory
C VoltaTensorOpPolicy | Policy details related to the epilogue
C VoltaTensorOpPolicy< WarpShape_, gemm::GemmShape< 32, 32, 4 >, float, layout::RowMajor > | Partial specialization for row-major
C VoltaTensorOpPolicy< WarpShape_, gemm::GemmShape< 32, 32, 4 >, half_t, layout::RowMajor > | Partial specialization for row-major
►C EpilogueWorkspace |
C Params | Parameters structure
C SharedStorage | Shared storage allocation needed by the epilogue
►N gemm |
►N device |
C DefaultGemmConfiguration |
C DefaultGemmConfiguration< arch::OpClassSimt, ArchTag, ElementA, ElementB, ElementC, ElementAccumulator > |
C DefaultGemmConfiguration< arch::OpClassSimt, ArchTag, int8_t, int8_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm70, ElementA, ElementB, ElementC, ElementAccumulator > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, ElementA, ElementB, ElementC, ElementAccumulator > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, int4b_t, int4b_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, int4b_t, uint4b_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, int8_t, int8_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, int8_t, uint8_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, uint4b_t, int4b_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, uint4b_t, uint4b_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, uint8_t, int8_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassTensorOp, arch::Sm75, uint8_t, uint8_t, ElementC, int32_t > |
C DefaultGemmConfiguration< arch::OpClassWmmaTensorOp, ArchTag, ElementA, ElementB, ElementC, ElementAccumulator > |
►C Gemm |
C Arguments | Argument structure
►C Gemm< ElementA_, LayoutA_, ElementB_, LayoutB_, ElementC_, layout::ColumnMajor, ElementAccumulator_, OperatorClass_, ArchTag_, ThreadblockShape_, WarpShape_, InstructionShape_, EpilogueOutputOp_, ThreadblockSwizzle_, Stages, AlignmentA, AlignmentB, SplitKSerial, Operator_, IsBetaZero > | Parital specialization for column-major output exchanges problem size and operand
C Arguments | Argument structure
►C GemmBatched |
C Arguments | Argument structure
►C GemmBatched< ElementA_, LayoutA_, ElementB_, LayoutB_, ElementC_, layout::ColumnMajor, ElementAccumulator_, OperatorClass_, ArchTag_, ThreadblockShape_, WarpShape_, InstructionShape_, EpilogueOutputOp_, ThreadblockSwizzle_, Stages, AlignmentA, AlignmentB, Operator_ > | Parital specialization for column-major output exchanges problem size and operand
C Arguments | Argument structure
►C GemmComplex |
C Arguments | Argument structure
►C GemmComplex< ElementA_, LayoutA_, ElementB_, LayoutB_, ElementC_, layout::ColumnMajor, ElementAccumulator_, OperatorClass_, ArchTag_, ThreadblockShape_, WarpShape_, InstructionShape_, EpilogueOutputOp_, ThreadblockSwizzle_, Stages, TransformA, TransformB, SplitKSerial > | Parital specialization for column-major output exchanges problem size and operand
C Arguments | Argument structure
►C GemmSplitKParallel |
C Arguments | Argument structure
►C GemmSplitKParallel< ElementA_, LayoutA_, ElementB_, LayoutB_, ElementC_, layout::ColumnMajor, ElementAccumulator_, OperatorClass_, ArchTag_, ThreadblockShape_, WarpShape_, InstructionShape_, EpilogueOutputOp_, ConvertScaledOp_, ReductionOp_, ThreadblockSwizzle_, Stages, kAlignmentA, kAlignmentB, Operator_ > | Partial specialization for column-major output
C Arguments | Argument structure
►N kernel |
►N detail |
C GemvBatchedStridedEpilogueScaling |
C DefaultGemm |
C DefaultGemm< ElementA, layout::ColumnMajorInterleaved< InterleavedK >, kAlignmentA, ElementB, layout::RowMajorInterleaved< InterleavedK >, kAlignmentB, ElementC, layout::ColumnMajorInterleaved< InterleavedK >, int32_t, arch::OpClassTensorOp, arch::Sm75, ThreadblockShape, WarpShape, InstructionShape, EpilogueOutputOp, ThreadblockSwizzle, 2, SplitKSerial, Operator, IsBetaZero > | Partial specialization for Turing Integer Matrix Multiply Interleaved layout
C DefaultGemm< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementC, layout::RowMajor, ElementAccumulator, arch::OpClassSimt, ArchTag, ThreadblockShape, WarpShape, GemmShape< 1, 1, 1 >, EpilogueOutputOp, ThreadblockSwizzle, 2, SplitKSerial, Operator > | Partial specialization for SIMT
C DefaultGemm< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementC, layout::RowMajor, ElementAccumulator, arch::OpClassTensorOp, arch::Sm70, ThreadblockShape, WarpShape, GemmShape< 8, 8, 4 >, EpilogueOutputOp, ThreadblockSwizzle, 2, SplitKSerial, Operator > | Partial specialization for Volta architecture
C DefaultGemm< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementC, layout::RowMajor, ElementAccumulator, arch::OpClassTensorOp, arch::Sm75, ThreadblockShape, WarpShape, InstructionShape, EpilogueOutputOp, ThreadblockSwizzle, 2, SplitKSerial, Operator > | Partial specialization for Turing Architecture
C DefaultGemm< int8_t, LayoutA, kAlignmentA, int8_t, LayoutB, kAlignmentB, ElementC, LayoutC, ElementAccumulator, arch::OpClassSimt, ArchTag, ThreadblockShape, WarpShape, GemmShape< 1, 1, 4 >, EpilogueOutputOp, ThreadblockSwizzle, 2, SplitKSerial, Operator, false > | Partial specialization for SIMT DP4A
C DefaultGemmSplitKParallel |
C DefaultGemv |
►C Gemm |
C Params | Parameters structure
C SharedStorage | Shared memory storage structure
►C GemmBatched |
C Params | Parameters structure
C SharedStorage | Shared memory storage structure
►C GemmSplitKParallel |
C Params | Parameters structure
C SharedStorage | Shared memory storage structure
►N thread |
►N detail |
C EnableMma_Crow_SM60 | Determines whether to enable thread::Gemm<> specializations compatible with SM50
C Mma_HFMA2 | Structure to compute the matrix product for HFMA
C Mma_HFMA2< Shape, layout::ColumnMajor, layout::ColumnMajor, layout::ColumnMajor, true > |
C Mma_HFMA2< Shape, layout::ColumnMajor, layout::ColumnMajor, layout::RowMajor, true > |
C Mma_HFMA2< Shape, layout::ColumnMajor, layout::RowMajor, layout::ColumnMajor, true > |
C Mma_HFMA2< Shape, layout::ColumnMajor, layout::RowMajor, layout::RowMajor, true > |
C Mma_HFMA2< Shape, layout::RowMajor, layout::ColumnMajor, layout::ColumnMajor, true > |
C Mma_HFMA2< Shape, layout::RowMajor, layout::ColumnMajor, layout::RowMajor, true > |
C Mma_HFMA2< Shape, layout::RowMajor, layout::RowMajor, layout::ColumnMajor, true > |
C Mma_HFMA2< Shape, layout::RowMajor, layout::RowMajor, layout::RowMajor, true > |
C Mma_HFMA2< Shape, LayoutA, LayoutB, layout::ColumnMajor, false > |
C Mma_HFMA2< Shape, LayoutA, LayoutB, layout::RowMajor, false > |
C Mma | Structure to compute the matrix product
C Mma< Shape_, ElementA_, LayoutA_, ElementB_, LayoutB_, ElementC_, LayoutC_, arch::OpMultiplyAdd, bool > | Gemplate that handles conventional layouts for FFMA and DFMA GEMM
C Mma< Shape_, half_t, LayoutA, half_t, LayoutB, half_t, LayoutC, arch::OpMultiplyAdd > | Structure to compute the matrix product
C Mma< Shape_, half_t, LayoutA_, half_t, LayoutB_, half_t, layout::RowMajor, arch::OpMultiplyAdd, typename platform::enable_if< detail::EnableMma_Crow_SM60< LayoutA_, LayoutB_ >::value >::type > | Computes matrix product when C is row-major
C Mma< Shape_, int8_t, layout::ColumnMajor, int8_t, layout::RowMajor, int32_t, LayoutC_, arch::OpMultiplyAdd, int8_t > | Gemplate that handles conventional layouts for IDP4A
C Mma< Shape_, int8_t, layout::RowMajor, int8_t, layout::ColumnMajor, int32_t, LayoutC_, arch::OpMultiplyAdd, bool > | Gemplate that handles conventional layouts for IDP4A
C MmaGeneric | Gemplate that handles all packed matrix layouts
►N threadblock |
C DefaultGemvCore |
C DefaultMma |
C DefaultMma< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementAccumulator, layout::ColumnMajorInterleaved< InterleavedK >, OperatorClass, ArchTag, ThreadblockShape, WarpShape, InstructionShape, 2, Operator, true > | Specialization for column-major-interleaved output
C DefaultMma< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementAccumulator, layout::RowMajor, arch::OpClassSimt, ArchTag, ThreadblockShape, WarpShape, InstructionShape, 2, Operator, false > | Specialization for row-major output (OperatorClass Simt)
C DefaultMma< ElementA, LayoutA, kAlignmentA, ElementB, LayoutB, kAlignmentB, ElementAccumulator, layout::RowMajor, arch::OpClassTensorOp, ArchTag, ThreadblockShape, WarpShape, InstructionShape, 2, Operator, false > | Specialization for row-major output (OperatorClass Simt)
C DefaultMma< int8_t, LayoutA, kAlignmentA, int8_t, LayoutB, kAlignmentB, ElementAccumulator, layout::RowMajor, arch::OpClassSimt, ArchTag, ThreadblockShape, WarpShape, GemmShape< 1, 1, 4 >, 2, Operator, false > |
C DefaultMmaCore |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 1 >, ElementA_, layout::ColumnMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 1 >, ElementA_, layout::ColumnMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 1 >, ElementA_, layout::ColumnMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_, > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 1 >, ElementA_, layout::RowMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 1 >, ElementA_, layout::RowMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 4 >, int8_t, layout::ColumnMajor, int8_t, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > | Partial specialization:
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 4 >, int8_t, layout::ColumnMajor, int8_t, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 4 >, int8_t, layout::RowMajor, int8_t, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > | Partial specialization:
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 1, 1, 4 >, int8_t, layout::RowMajor, int8_t, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassSimt, 2, Operator_ > | Partial specialization:
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 8, 8, 4 >, ElementA_, layout::ColumnMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 8, 8, 4 >, ElementA_, layout::ColumnMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 8, 8, 4 >, ElementA_, layout::RowMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, GemmShape< 8, 8, 4 >, ElementA_, layout::RowMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, InstructionShape_, ElementA_, layout::ColumnMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, InstructionShape_, ElementA_, layout::ColumnMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, InstructionShape_, ElementA_, layout::ColumnMajorInterleaved< InterleavedK >, ElementB_, layout::RowMajorInterleaved< InterleavedK >, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_, AccumulatorsInRowMajor > |
C DefaultMmaCore< Shape_, WarpShape_, InstructionShape_, ElementA_, layout::RowMajor, ElementB_, layout::ColumnMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C DefaultMmaCore< Shape_, WarpShape_, InstructionShape_, ElementA_, layout::RowMajor, ElementB_, layout::RowMajor, ElementC_, LayoutC_, arch::OpClassTensorOp, 2, Operator_ > |
C GemmBatchedIdentityThreadblockSwizzle | Threadblock swizzling function for batched GEMMs
C GemmHorizontalThreadblockSwizzle | Threadblock swizzling function for GEMMs
C GemmIdentityThreadblockSwizzle | Threadblock swizzling function for GEMMs
C GemmSplitKHorizontalThreadblockSwizzle | Threadblock swizzling function for split-K GEMMs
C GemmSplitKIdentityThreadblockSwizzle | Threadblock swizzling function for split-K GEMMs
C Gemv | Structure to compute the matrix-vector product using SIMT math instructions
C GemvBatchedStridedThreadblockDefaultSwizzle | Threadblock swizzling function for batched GEMVs
►C MmaBase |
C SharedStorage | Shared storage object needed by threadblock-scoped GEMM
C MmaPipelined | Structure to compute the matrix product targeting CUDA cores and SIMT math instructions
C MmaPolicy | Policy object describing MmaTensorOp
C MmaSingleStage | Structure to compute the matrix product targeting CUDA cores and SIMT math instructions
►N warp |
C DefaultMmaTensorOp | Partial specialization for m-by-n-by-kgroup
C MmaComplexTensorOp |
C MmaComplexTensorOp< Shape_, complex< RealElementA >, LayoutA_, complex< RealElementB >, LayoutB_, complex< RealElementC >, LayoutC_, Policy_, TransformA, TransformB, Enable > | Partial specialization for complex*complex+complex => complex using real-valued TensorOps
C MmaSimt | Structure to compute the matrix product targeting CUDA cores and SIMT math instructions
C MmaSimtPolicy | Describes the arrangement and configuration of per-lane operations in warp-level matrix multiply
C MmaSimtTileIterator |
C MmaSimtTileIterator< Shape_, Operand::kA, Element_, layout::ColumnMajor, Policy_, PartitionsK, PartitionGroupSize > |
C MmaSimtTileIterator< Shape_, Operand::kA, Element_, layout::ColumnMajorInterleaved< 4 >, Policy_, PartitionsK, PartitionGroupSize > |
C MmaSimtTileIterator< Shape_, Operand::kB, Element_, layout::RowMajor, Policy_, PartitionsK, PartitionGroupSize > |
C MmaSimtTileIterator< Shape_, Operand::kB, Element_, layout::RowMajorInterleaved< 4 >, Policy_, PartitionsK, PartitionGroupSize > |
C MmaSimtTileIterator< Shape_, Operand::kC, Element_, layout::ColumnMajor, Policy_ > |
C MmaSimtTileIterator< Shape_, Operand::kC, Element_, layout::RowMajor, Policy_ > |
C MmaTensorOp | Structure to compute the matrix product targeting CUDA cores and SIMT math instructions
C MmaTensorOpAccumulatorTileIterator |
►C MmaTensorOpAccumulatorTileIterator< Shape_, Element_, cutlass::layout::ColumnMajor, InstructionShape_, OpDelta_ > |
C Policy | Internal structure of iterator - made public to enable introspection
►C MmaTensorOpAccumulatorTileIterator< Shape_, Element_, cutlass::layout::ColumnMajorInterleaved< InterleavedN >, InstructionShape_, OpDelta_ > |
C Policy | Internal structure of iterator - made public to enable introspection
►C MmaTensorOpAccumulatorTileIterator< Shape_, Element_, cutlass::layout::RowMajor, InstructionShape_, OpDelta_ > |
C Policy | Internal structure of iterator - made public to enable introspection
C MmaTensorOpMultiplicandTileIterator |
C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::ColumnMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::ColumnMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::RowMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::RowMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
►C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::TensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, 64 >, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
C Policy | Internal structure of iterator - made public to enable introspection
►C MmaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::TensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, InstructionShape_, OpDelta_, 32, PartitionsK_ > |
C Policy | Internal structure of iterator - made public to enable introspection
C MmaTensorOpPolicy | Policy
C MmaVoltaTensorOp | Structure to compute the matrix product targeting CUDA cores and SIMT math instructions
►C MmaVoltaTensorOpAccumulatorTileIterator |
C Policy | Internal structure of iterator - made public to enable introspection
C MmaVoltaTensorOpMultiplicandTileIterator |
C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand::kA, Element_, cutlass::layout::ColumnMajorVoltaTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value >, InstructionShape_, OpDelta_, 32 > |
►C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand::kA, Element_, cutlass::layout::VoltaTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value >, InstructionShape_, OpDelta_, 32 > |
C Policy | Internal structure of iterator - made public to enable introspection
C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand::kB, Element_, cutlass::layout::RowMajorVoltaTensorOpMultiplicandBCongruous< sizeof_bits< Element_ >::value >, InstructionShape_, OpDelta_, 32 > |
►C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand::kB, Element_, cutlass::layout::VoltaTensorOpMultiplicandBCongruous< sizeof_bits< Element_ >::value >, InstructionShape_, OpDelta_, 32 > |
C Policy | Internal structure of iterator - made public to enable introspection
C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::ColumnMajorVoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, KBlock >, InstructionShape_, OpDelta_, 32 > |
C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::RowMajorVoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, KBlock >, InstructionShape_, OpDelta_, 32 > |
►C MmaVoltaTensorOpMultiplicandTileIterator< Shape_, Operand_, Element_, cutlass::layout::VoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, KBlock >, InstructionShape_, OpDelta_, 32 > |
C Policy | Internal structure of iterator - made public to enable introspection
C WarpSize | Query the number of threads per warp
C BatchedGemmCoord |
C GemmCoord |
C GemmShape | Shape of a matrix multiply-add operation
►N layout |
C ColumnMajor | Mapping function for column-major matrices
C ColumnMajorBlockLinear |
C ColumnMajorInterleaved |
C ColumnMajorTensorOpMultiplicandCongruous |
C ColumnMajorTensorOpMultiplicandCrosswise |
C ColumnMajorVoltaTensorOpMultiplicandBCongruous | Template mapping a column-major view of pitch-linear memory to VoltaTensorOpMultiplicandCongruous
C ColumnMajorVoltaTensorOpMultiplicandCongruous | Template mapping a column-major view of pitch-linear memory to VoltaTensorOpMultiplicandCongruous
C ColumnMajorVoltaTensorOpMultiplicandCrosswise |
C ContiguousMatrix |
C GeneralMatrix |
C LayoutTranspose | Defines transposes of matrix layouts
C LayoutTranspose< layout::ColumnMajor > | Transpose of column-major is row-major
C LayoutTranspose< layout::RowMajor > | Transpose of row-major is column-major
C PackedVectorLayout | Tensor layout for densely packed vectors
C PitchLinear | Mapping function for pitch-linear memory
C PitchLinearCoord | Coordinate in pitch-linear space
C PitchLinearShape | Template defining a shape used by pitch-linear operators
C RowMajor | Mapping function for row-major matrices
C RowMajorBlockLinear |
C RowMajorInterleaved |
C RowMajorTensorOpMultiplicandCongruous |
C RowMajorTensorOpMultiplicandCrosswise |
C RowMajorVoltaTensorOpMultiplicandBCongruous | Template mapping a row-major view of pitch-linear memory to VoltaTensorOpMultiplicandCongruous
C RowMajorVoltaTensorOpMultiplicandCongruous | Template mapping a row-major view of pitch-linear memory to VoltaTensorOpMultiplicandCongruous
C RowMajorVoltaTensorOpMultiplicandCrosswise |
C TensorCxRSKx | Mapping function for 4-D CxRSKx tensors
C TensorNCHW | Mapping function for 4-D NCHW tensors
C TensorNCxHWx | Mapping function for 4-D NC/xHWx tensors
C TensorNHWC | Mapping function for 4-D NHWC tensors
C TensorOpMultiplicand |
C TensorOpMultiplicandColumnMajorInterleaved | Template based on element size (in bits) - defined in terms of pitch-linear memory
C TensorOpMultiplicandCongruous |
C TensorOpMultiplicandCongruous< 32, Crosswise > |
C TensorOpMultiplicandCrosswise |
C TensorOpMultiplicandRowMajorInterleaved | Template based on element size (in bits) - defined in terms of pitch-linear memory
C VoltaTensorOpMultiplicandBCongruous | Template based on element size (in bits) - defined in terms of pitch-linear memory
C VoltaTensorOpMultiplicandCongruous | Template based on element size (in bits) - defined in terms of pitch-linear memory
C VoltaTensorOpMultiplicandCrosswise |
►N library |
C GemmArguments | Arguments for GEMM
C GemmArrayArguments | Arguments for GEMM - used by all the GEMM operations
C GemmArrayConfiguration | Configuration for batched GEMM in which multiple matrix products are computed
C GemmBatchedConfiguration | Configuration for batched GEMM in which multiple matrix products are computed
C GemmConfiguration | Configuration for basic GEMM operations
C GemmDescription | Description of all GEMM computations
C GemmPlanarComplexBatchedConfiguration | Batched complex valued GEMM in which real and imaginary parts are separated by a stride
C GemmPlanarComplexConfiguration | Complex valued GEMM in which real and imaginary parts are separated by a stride
C Manifest | Manifest of CUTLASS Library
C MathInstructionDescription |
C Operation | Base class for all device-wide operations
C OperationDescription | High-level description of an operation
C TensorDescription | Structure describing the properties of a tensor
C TileDescription | Structure describing the tiled structure of a GEMM-like computation
►N platform |
C aligned_chunk |
C aligned_storage | Std::aligned_storage
►C alignment_of | Std::alignment_of
C pad |
C alignment_of< const value_t > |
C alignment_of< const volatile value_t > |
C alignment_of< double2 > |
C alignment_of< double4 > |
C alignment_of< float4 > |
C alignment_of< int4 > |
C alignment_of< long4 > |
C alignment_of< longlong2 > |
C alignment_of< longlong4 > |
C alignment_of< uint4 > |
C alignment_of< ulong4 > |
C alignment_of< ulonglong2 > |
C alignment_of< ulonglong4 > |
C alignment_of< volatile value_t > |
C bool_constant | Std::bool_constant
C conditional | Std::conditional (true specialization)
C conditional< false, T, F > | Std::conditional (false specialization)
C default_delete | Default deleter
C default_delete< T[]> | Partial specialization for deleting array types
C enable_if | Std::enable_if (true specialization)
C enable_if< false, T > | Std::enable_if (false specialization)
C integral_constant | Std::integral_constant
C is_arithmetic | Std::is_arithmetic
C is_base_of | Std::is_base_of
►C is_base_of_helper | Helper for std::is_base_of
C dummy |
C is_floating_point | Std::is_floating_point
C is_fundamental | Std::is_fundamental
C is_integral | Std::is_integral
C is_integral< char > |
C is_integral< const T > |
C is_integral< const volatile T > |
C is_integral< int > |
C is_integral< long > |
C is_integral< long long > |
C is_integral< short > |
C is_integral< signed char > |
C is_integral< unsigned char > |
C is_integral< unsigned int > |
C is_integral< unsigned long > |
C is_integral< unsigned long long > |
C is_integral< unsigned short > |
C is_integral< volatile T > |
C is_pointer | Std::is_pointer
C is_pointer_helper | Helper for std::is_pointer (false specialization)
C is_pointer_helper< T * > | Helper for std::is_pointer (true specialization)
C is_same | Std::is_same (false specialization)
C is_same< A, A > | Std::is_same (true specialization)
C is_trivially_copyable |
C is_void | Std::is_void
C is_volatile | Std::is_volatile
C is_volatile< volatile T > |
C nullptr_t | Std::nullptr_t
C remove_const | Std::remove_const (non-const specialization)
C remove_const< const T > | Std::remove_const (const specialization)
C remove_cv | Std::remove_cv
C remove_volatile | Std::remove_volatile (non-volatile specialization)
C remove_volatile< volatile T > | Std::remove_volatile (volatile specialization)
C unique_ptr | Std::unique_ptr
►N reduction |
►N kernel |
►C ReduceSplitK |
C Params | Params structure
C SharedStorage |
►N thread |
C Reduce | Structure to compute the thread level reduction
C Reduce< plus< half_t >, AlignedArray< half_t, N > > | Partial specializations of Reduce for AlignedArray<half_t, N>
C Reduce< plus< half_t >, Array< half_t, N > > | Partial specializations of Reduce for Array<half_t, N>
C Reduce< plus< T >, Array< T, N > > | Partial specialization of Reduce for Array<T, N>
C Reduce< plus< T >, T > | Partial Specialization of Reduce for "plus" (a functional operator)
►C ReduceAdd | Mixed-precision reduction
C Params |
C BatchedReduction |
►C BatchedReductionTraits |
C Params |
C DefaultBlockSwizzle |
►N reference |
►N detail |
C Cast |
C Cast< float, int8_t > |
C Cast< float, uint8_t > |
►N device |
►N detail |
►C RandomGaussianFunc |
C Params | Parameters structure
►C RandomUniformFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorCopyDiagonalInFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorCopyDiagonalOutFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorFillDiagonalFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorFillLinearFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorFillRandomGaussianFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorFillRandomUniformFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorUpdateDiagonalFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►C TensorUpdateOffDiagonalFunc | Computes a random Gaussian distribution
C Params | Parameters structure
►N kernel |
►N detail | Defines several helpers
C TensorForEachHelper | Helper to perform for-each operation
C TensorForEachHelper< Func, Rank, 0 > | Helper to perform for-each operation
►N thread |
C Gemm | Thread-level blocked general matrix product
C BlockForEach |
C Gemm |
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, AccumulatorType, arch::OpMultiplyAdd > | Partial specialization for multiply-add
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, AccumulatorType, arch::OpMultiplyAddSaturate > | Partial specialization for multiply-add-saturate
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, AccumulatorType, arch::OpXorPopc > | Parital specialization for XOR-popc
C TensorDiagonalForEach | Launches a kernel calling a functor for each element along a tensor's diagonal
C TensorForEach | Launches a kernel calling a functor for each element in a tensor's index space
►N host |
►N detail | Defines several helpers
C RandomGaussianFunc |
C RandomGaussianFunc< complex< Element > > | Partial specialization for initializing a complex value
C RandomUniformFunc |
C RandomUniformFunc< complex< Element > > | Partial specialization for initializing a complex value
C TensorContainsFunc | < Layout function
C TensorCopyIf | Helper to conditionally copy between tensor views
C TensorEqualsFunc | < Layout function
C TensorFillDiagonalFunc | < Layout function
C TensorFillFunc | < Layout function
C TensorFillGaussianFunc | Computes a random Gaussian distribution
C TensorFillLinearFunc | < Layout function
C TensorFillRandomUniformFunc | Computes a random Gaussian distribution
C TensorForEachHelper | Helper to perform for-each operation
C TensorForEachHelper< Func, Rank, 0 > | Helper to perform for-each operation
C TensorFuncBinaryOp | Helper to apply a binary operator in place
C TensorUpdateOffDiagonalFunc | < Layout function
C TrivialConvert | Helper to convert between types
C BlockForEach |
C Gemm |
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, ComputeType, arch::OpMultiplyAdd > | Partial specialization for multiply-add
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, ComputeType, arch::OpMultiplyAddSaturate > | Partial specialization for multiply-add-saturate
C Gemm< ElementA, LayoutA, ElementB, LayoutB, ElementC, LayoutC, ScalarType, ComputeType, arch::OpXorPopc > | Parital specialization for XOR-popc
►N thread |
C Matrix | Per-thread matrix object storing a packed matrix
►N transform |
►N thread |
C Transpose | Transforms a fragment by doing a transpose
C Transpose< ElementCount_, layout::PitchLinearShape< 4, 4 >, int8_t > | Specialization for int8_t 4x4 transpose
►N threadblock |
C PredicatedTileAccessIterator |
C PredicatedTileAccessIterator2dThreadTile |
►C PredicatedTileAccessIterator2dThreadTile< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator2dThreadTile< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator2dThreadTile< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator< Shape_, Element_, layout::ColumnMajorInterleaved< InterleavedK >, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileAccessIterator< Shape_, Element_, layout::RowMajorInterleaved< InterleavedK >, AdvanceRank, ThreadMap_, AccessType_ > |
C Params | Parameters object is precomputed state and is host-constructible
C PredicatedTileIterator |
C PredicatedTileIterator2dThreadTile |
►C PredicatedTileIterator2dThreadTile< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, Transpose_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator2dThreadTile< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, Transpose_ > |
C AccessType |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator2dThreadTile< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, Transpose_ > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, AccessSize > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator< Shape_, Element_, layout::ColumnMajorInterleaved< InterleavedK >, AdvanceRank, ThreadMap_, AccessSize > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, AccessSize > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, AccessSize > |
C Params | Parameters object is precomputed state and is host-constructible
►C PredicatedTileIterator< Shape_, Element_, layout::RowMajorInterleaved< InterleavedK >, AdvanceRank, ThreadMap_, AccessSize > |
C Params | Parameters object is precomputed state and is host-constructible
C RegularTileAccessIterator |
C RegularTileAccessIterator< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::ColumnMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::ColumnMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::RowMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileAccessIterator< Shape_, Element_, layout::RowMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
►C RegularTileAccessIterator< Shape_, Element_, layout::TensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
►C RegularTileAccessIterator< Shape_, Element_, layout::TensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
C RegularTileIterator |
C RegularTileIterator2dThreadTile |
C RegularTileIterator2dThreadTile< Shape_, Element_, layout::ColumnMajorInterleaved< 4 >, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for interleaved layout + 2d thread-tiled threadmapping
C RegularTileIterator2dThreadTile< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for pitch-linear + 2d thread-tiled threadmapping
C RegularTileIterator2dThreadTile< Shape_, Element_, layout::RowMajorInterleaved< 4 >, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for interleaved layout + 2d thread-tiled threadmapping
C RegularTileIterator< Shape_, Element_, layout::ColumnMajor, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for pitch-linear
C RegularTileIterator< Shape_, Element_, layout::ColumnMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::ColumnMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::ColumnMajorVoltaTensorOpMultiplicandBCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::ColumnMajorVoltaTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::ColumnMajorVoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Shape_::kRow >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::PitchLinear, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for pitch-linear
C RegularTileIterator< Shape_, Element_, layout::RowMajor, AdvanceRank, ThreadMap_, Alignment > | Regular tile iterator specialized for pitch-linear
C RegularTileIterator< Shape_, Element_, layout::RowMajorTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::RowMajorTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::RowMajorVoltaTensorOpMultiplicandBCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::RowMajorVoltaTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C RegularTileIterator< Shape_, Element_, layout::RowMajorVoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Shape_::kColumn >, AdvanceRank, ThreadMap_, Alignment > |
►C RegularTileIterator< Shape_, Element_, layout::TensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value, int(128/sizeof(Element_))>, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
►C RegularTileIterator< Shape_, Element_, layout::TensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Crosswise >, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
►C RegularTileIterator< Shape_, Element_, layout::VoltaTensorOpMultiplicandBCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
►C RegularTileIterator< Shape_, Element_, layout::VoltaTensorOpMultiplicandCongruous< sizeof_bits< Element_ >::value >, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
►C RegularTileIterator< Shape_, Element_, layout::VoltaTensorOpMultiplicandCrosswise< sizeof_bits< Element_ >::value, Shape_::kContiguous >, AdvanceRank, ThreadMap_, Alignment > |
C Detail | Internal details made public to facilitate introspection
C PitchLinear2DThreadTileStripminedThreadMap |
►C PitchLinear2DThreadTileStripminedThreadMap< Shape_, Threads, cutlass::layout::PitchLinearShape< 4, 4 > > |
C Detail | Internal implementation details
►C PitchLinearStripminedThreadMap |
C Detail | Internal implementation details
C PitchLinearTilePolicyStripminedThreadContiguous |
C PitchLinearTilePolicyStripminedThreadStrided |
►C PitchLinearWarpRakedThreadMap |
C Detail | Internal details made public to facilitate introspection Iterations along each dimension (concept: PitchLinearShape)
►C PitchLinearWarpStripedThreadMap |
C Detail | Internal details made public to facilitate introspection Iterations along each dimension (concept: PitchLinearShape)
►C TransposePitchLinearThreadMap |
C Detail | Internal details made public to facilitate introspection Iterations along each dimension (concept: PitchLinearShape)
C TransposePitchLinearThreadMap2DThreadTile | Thread Mapping a 2D threadtiled mapping as a tranposed Pitchlinear2DThreadTile mapping
C TransposePitchLinearThreadMapSimt |
C AlignedArray | Aligned array type
C AlignedBuffer | Modifies semantics of cutlass::Array<> to provide guaranteed alignment
►C Array< T, N, false > | Statically sized array for any data type
C const_iterator | Bidirectional constant iterator over elements
C const_reference | Reference object extracts sub-byte items
C const_reverse_iterator | Bidirectional constant iterator over elements
C iterator | Bidirectional iterator over elements
C reference | Reference object inserts or extracts sub-byte items
C reverse_iterator | Bidirectional iterator over elements
►C Array< T, N, true > | Statically sized array for any data type
C const_iterator | Bidirectional constant iterator over elements
C const_reverse_iterator | Bidirectional constant iterator over elements
C iterator | Bidirectional iterator over elements
C reverse_iterator | Bidirectional iterator over elements
C CommandLine |
C complex |
C ConstSubbyteReference |
C Coord | Statically-sized array specifying Coords within a tensor
C cuda_exception | C++ exception wrapper for CUDA `cudaError_t`
C Distribution | Distribution type
C divide_assert |
C divides |
C divides< Array< half_t, N > > |
C divides< Array< T, N > > |
C FloatType | Defines a floating-point type based on the number of exponent and mantissa bits
C FloatType< 11, 52 > |
C FloatType< 5, 10 > |
C FloatType< 8, 23 > |
C half_t | IEEE half-precision floating-point type
C HostTensor | Host tensor
C IdentityTensorLayout |
C integer_subbyte | 4-bit signed integer type
C IntegerType | Defines integers based on size and whether they are signed
C IntegerType< 1, false > |
C IntegerType< 1, true > |
C IntegerType< 16, false > |
C IntegerType< 16, true > |
C IntegerType< 32, false > |
C IntegerType< 32, true > |
C IntegerType< 4, false > |
C IntegerType< 4, true > |
C IntegerType< 64, false > |
C IntegerType< 64, true > |
C IntegerType< 8, false > |
C IntegerType< 8, true > |
C is_pow2 |
C KernelLaunchConfiguration | Structure containing the basic launch configuration of a CUDA kernel
C log2_down |
C log2_down< N, 1, Count > |
C log2_up |
C log2_up< N, 1, Count > |
C MatrixCoord |
C MatrixShape | Describes the size of a matrix tile
C Max |
C maximum |
C maximum< Array< T, N > > |
C maximum< float > |
C Min |
C minimum |
C minimum< Array< T, N > > |
C minimum< float > |
C minus |
C minus< Array< half_t, N > > |
C minus< Array< T, N > > |
C multiplies |
C multiplies< Array< half_t, N > > |
C multiplies< Array< T, N > > |
C multiply_add | Fused multiply-add
C multiply_add< Array< half_t, N >, Array< half_t, N >, Array< half_t, N > > | Fused multiply-add
C multiply_add< Array< T, N >, Array< T, N >, Array< T, N > > | Fused multiply-add
C multiply_add< complex< T >, complex< T >, complex< T > > | Fused multiply-add
C multiply_add< complex< T >, T, complex< T > > | Fused multiply-add
C multiply_add< T, complex< T >, complex< T > > | Fused multiply-add
C negate |
C negate< Array< half_t, N > > |
C negate< Array< T, N > > |
C NumericArrayConverter | Conversion operator for Array
C NumericArrayConverter< float, half_t, 2, Round > | Partial specialization for Array<float, 2> <= Array<half_t, 2>, round to nearest
C NumericArrayConverter< float, half_t, N, Round > | Partial specialization for Array<half> <= Array<float>
C NumericArrayConverter< half_t, float, 2, FloatRoundStyle::round_to_nearest > | Partial specialization for Array<half, 2> <= Array<float, 2>, round to nearest
C NumericArrayConverter< half_t, float, N, Round > | Partial specialization for Array<half> <= Array<float>
C NumericConverter |
C NumericConverter< float, half_t, Round > | Partial specialization for float <= half_t
C NumericConverter< half_t, float, FloatRoundStyle::round_to_nearest > | Specialization for round-to-nearest
C NumericConverter< half_t, float, FloatRoundStyle::round_toward_zero > | Specialization for round-toward-zero
C NumericConverter< int8_t, float, Round > |
C NumericConverter< T, T, Round > | Partial specialization for float <= half_t
C NumericConverterClamp |
C plus |
C plus< Array< half_t, N > > |
C plus< Array< T, N > > |
►C PredicateVector | Statically sized array of bits implementing
C ConstIterator | An iterator implementing Predicate Iterator Concept enabling sequential read and write access to predicates
C Iterator | An iterator implementing Predicate Iterator Concept enabling sequential read and write access to predicates
C TrivialIterator | Iterator that always returns true
C RealType | Used to determine the real-valued underlying type of a numeric type T
C RealType< complex< T > > | Partial specialization for complex-valued type
C ReferenceFactory |
C ReferenceFactory< Element, false > |
C ReferenceFactory< Element, true > |
C ScalarIO | Helper to enable formatted printing of CUTLASS scalar types to an ostream
C Semaphore | CTA-wide semaphore for inter-CTA synchronization
C sizeof_bits | Defines the size of an element in bits
C sizeof_bits< Array< T, N, RegisterSized > > | Statically sized array for any data type
C sizeof_bits< bin1_t > | Defines the size of an element in bits - specialized for bin1_t
C sizeof_bits< int4b_t > | Defines the size of an element in bits - specialized for int4b_t
C sizeof_bits< uint1b_t > | Defines the size of an element in bits - specialized for uint1b_t
C sizeof_bits< uint4b_t > | Defines the size of an element in bits - specialized for uint4b_t
C sqrt_est |
C SubbyteReference |
C Tensor4DCoord | Defines a canonical 4D coordinate used by tensor operations
C TensorRef |
C TensorView |
C TypeTraits |
►C TypeTraits< complex< double > > |
C integer_type |
C unsigned_type |
C TypeTraits< complex< float > > |
C TypeTraits< complex< half > > |
C TypeTraits< complex< half_t > > |
C TypeTraits< double > |
C TypeTraits< float > |
C TypeTraits< half_t > |
C TypeTraits< int > |
C TypeTraits< int64_t > |
C TypeTraits< int8_t > |
C TypeTraits< uint64_t > |
C TypeTraits< uint8_t > |
C TypeTraits< unsigned > |
C xor_add | Fused multiply-add
►Nstd | STL namespace
C numeric_limits< cutlass::half_t > | Numeric limits
C DebugType |
C DebugValue |