Add files using upload-large-folder tool

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_tensor_op_f32_sm75.cu

@@ -0,0 +1,307 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide GEMM interface
+*/
+
+#include <iostream>
+
+#include "cutlass/cutlass.h"
+#include "cutlass/gemm/device/gemm.h"
+
+#include "../../common/cutlass_unit_test.h"
+
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/tensor_view_io.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/gemm.h"
+
+#include "testbed.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM75_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 128x256x32_64x64x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<128, 256, 32>,
+    cutlass::gemm::GemmShape<64, 64, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 128x256x32_64x64x32_brief) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<128, 256, 32>
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 256x128x32_64x64x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<256, 128, 32>,
+    cutlass::gemm::GemmShape<64, 64, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 128x128x32_64x64x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<128, 128, 32>,
+    cutlass::gemm::GemmShape<64, 64, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 128x128x32_64x64x32_brief) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<128, 128, 32>
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 64x128x32_32x64x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<64, 128, 32>,
+    cutlass::gemm::GemmShape<32, 64, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 64x128x32_32x64x32_brief) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<64, 128, 32>,
+    cutlass::gemm::GemmShape<32, 64, 32>
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 128x64x32_64x32x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<128, 64, 32>,
+    cutlass::gemm::GemmShape<64, 32, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+TEST(SM75_Device_Gemm_f16n_f16n_f16t_tensor_op_f32, 64x64x32_32x32x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<64, 64, 32>,
+    cutlass::gemm::GemmShape<32, 32, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      128 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_slicedk_sm75.cu

@@ -0,0 +1,88 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide GEMM interface
+*/
+
+#include <iostream>
+
+#include "cutlass/cutlass.h"
+#include "cutlass/gemm/device/gemm.h"
+
+#include "../../common/cutlass_unit_test.h"
+
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/tensor_view_io.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/gemm.h"
+
+#include "testbed.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM75_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_Device_Gemm_f16t_f16n_f16t_tensor_op_f16_sliced_k, 64x64x64_64x32x32) {
+
+  using ElementOutput = cutlass::half_t;
+  using ElementAccumulator = cutlass::half_t;
+
+  using Gemm = cutlass::gemm::device::Gemm<
+    cutlass::half_t,
+    cutlass::layout::RowMajor,
+    cutlass::half_t,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm75,
+    cutlass::gemm::GemmShape<64, 64, 64>,
+    cutlass::gemm::GemmShape<64, 32, 32>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      64 / cutlass::sizeof_bits<ElementOutput>::value,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    2
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemm<Gemm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif  // if (CUTLASS_ARCH_MMA_SM75_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_s8t_f16n_f32t_mixed_input_tensor_op_f32_sm80.cu

@@ -0,0 +1,97 @@
+/***************************************************************************************************
+ * Copyright (c) 2023 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide GEMM interface
+    
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/cutlass.h"
+
+#include "cutlass/gemm/device/gemm_universal.h"
+
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/gemm.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_universal.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+TEST(SM80_Device_GemmUniversal_s8t_f16n_f32t_mixed_input_tensor_op_f32, 128x128x64_64x64x64) {
+
+  using ElementA = int8_t;
+  using ElementB = cutlass::half_t;
+  using ElementOutput = float;
+  using ElementAccumulator = float;
+
+  using Gemm = cutlass::gemm::device::GemmUniversal<
+    ElementA, 
+    cutlass::layout::RowMajor, 
+    ElementB,
+    cutlass::layout::ColumnMajor, 
+    ElementOutput, 
+    cutlass::layout::RowMajor,
+    ElementAccumulator, 
+    cutlass::arch::OpClassTensorOp, 
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<128, 128, 64>,
+    cutlass::gemm::GemmShape<64, 64, 64>,
+    cutlass::gemm::GemmShape<16, 8, 16>,
+      cutlass::epilogue::thread::LinearCombination<
+          ElementOutput, 128 / cutlass::sizeof_bits<ElementOutput>::value,
+          ElementAccumulator, ElementAccumulator>,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>, 
+    4,   // Stages
+    16,  // AlignmentA
+    8,   // AlignmentB
+    cutlass::arch::OpMultiplyAddMixedInputUpcast,
+    cutlass::ComplexTransform::kNone,
+    cutlass::ComplexTransform::kNone
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllGemmUniversal<Gemm>());
+}
+////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/hemm_cf32h_cf32n_tensor_op_fast_f32_ls_sm80.cu

@@ -0,0 +1,175 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide HEMM interface
+
+  
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/blas3.h"
+#include "cutlass/gemm/device/symm.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/symm_complex.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_symm_universal.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Hemm_cf32h_cf32n_ls_l_tensor_op_fast_f32, 32x32x16_16x16x16) {
+
+  using ElementOutput = cutlass::complex<float>;
+  using ElementAccumulator = cutlass::complex<float>;
+
+  using Hemm = cutlass::gemm::device::Symm<
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::ColumnMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3,
+    1,
+    1,
+    false,
+    cutlass::arch::OpMultiplyAddComplexFastF32,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllSymmUniversal<Hemm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Hemm_cf32h_cf32n_ls_u_tensor_op_fast_f32, 32x32x16_16x16x16) {
+
+  using ElementOutput = cutlass::complex<float>;
+  using ElementAccumulator = cutlass::complex<float>;
+
+  using Hemm = cutlass::gemm::device::Symm<
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::ColumnMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3,
+    1,
+    1,
+    false,
+    cutlass::arch::OpMultiplyAddComplexFastF32,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllSymmUniversal<Hemm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Hemm_cf32h_cf32n_ls_u_tensor_op_fast_f32, 64x64x16_32x32x16) {
+
+  using ElementOutput = cutlass::complex<float>;
+  using ElementAccumulator = cutlass::complex<float>;
+
+  using Hemm = cutlass::gemm::device::Symm<
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::complex<float>,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::ColumnMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 64, 16>,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 8, 8>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3,
+    1,
+    1,
+    false,
+    cutlass::arch::OpMultiplyAddComplexFastF32,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllSymmUniversal<Hemm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/herk_cf64h_cf64n_tensor_op_f64_sm80.cu

@@ -0,0 +1,175 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide HERK interface
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/blas3.h"
+#include "cutlass/gemm/device/rank_k.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/rank_k_complex.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_rank_k_universal.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// HERK operator on CUBLAS_OP_N (column-major) input layouts 
+TEST(SM80_Device_Herk_cf64n_cf64n_l_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::ColumnMajor;
+
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using RankK = cutlass::gemm::device::RankK<
+    ElementA,
+    LayoutA,
+    ElementC,
+    LayoutC,
+    cutlass::FillMode::kLower,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementC,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4,     // kStages 
+    1,     // AlignmentA
+    false, // SplitKSerial
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::ComplexTransform::kNone,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllRankKUniversal<RankK>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// HERK operator on CUBLAS_OP_N (column-major) input layouts
+TEST(SM80_Device_Herk_cf64n_cf64n_u_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::ColumnMajor;
+
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using RankK = cutlass::gemm::device::RankK<
+    ElementA,
+    LayoutA,
+    ElementC,
+    LayoutC,
+    cutlass::FillMode::kUpper,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementC,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4,     // kStages 
+    1,     // AlignmentA
+    false, // SplitKSerial
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::ComplexTransform::kNone,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllRankKUniversal<RankK>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// HERK operator on CUBLAS_OP_C (row-major + conj) input layouts
+TEST(SM80_Device_Herk_cf64h_cf64n_l_tensor_op_f64, 64x64x16_32x32x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::RowMajor;
+
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using RankK = cutlass::gemm::device::RankK<
+    ElementA,
+    LayoutA,
+    ElementC,
+    LayoutC,
+    cutlass::FillMode::kLower,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementC,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4,     // kStages 
+    1,     // AlignmentA
+    false, // SplitKSerial
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::ComplexTransform::kConjugate,
+    cutlass::BlasMode::kHermitian
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllRankKUniversal<RankK>());
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_dag.cu

@@ -0,0 +1,170 @@
+/***************************************************************************************************
+ * Copyright (c) 2023 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for Sm90 f16_f16_f16 cooperative DAG epilogue
+    EVTDAG: D = beta * C + Graph(relu(alpha * acc + aux) + aux)
+    DAGEVT: EVT = alpha * acc + C, D = Graph(maximum(EVT + per-row bias, EVT))
+*/
+
+#include <iostream>
+
+#include "cutlass/cutlass.h"
+#include "cute/tensor.hpp"
+#include "cute/atom/mma_atom.hpp"
+
+#include "cutlass/numeric_types.h"
+
+#include "cutlass/gemm/device/gemm_universal_adapter.h"
+#include "cutlass/gemm/kernel/gemm_universal.hpp"
+#include "cutlass/epilogue/collective/collective_builder.hpp"
+#include "cutlass/gemm/collective/collective_builder.hpp"
+#include "cutlass/epilogue/collective/sm70_epilogue_vectorized.hpp"
+#include "cutlass/epilogue/collective/default_epilogue.hpp"
+#include "cutlass/epilogue/thread/linear_combination.h"
+#include "cutlass/epilogue/thread/linear_combination_bias_elementwise.h"
+
+#include "../../common/cutlass_unit_test.h"
+
+#include "gemm_testbed_3x_evt.hpp"
+#include "sm90_evt_operations.hpp"
+
+
+#if defined(CUTLASS_ARCH_MMA_SM90_SUPPORTED)
+
+using namespace cute;
+
+
+TEST(SM90_Device_Gemm_f16t_f16n_f32t_tensor_op_gmma_f32_cooperative_epilogue, 256x128x64_2x2x1_EVTDAG) {
+  using LayoutA = cutlass::layout::RowMajor;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using LayoutC = cutlass::layout::RowMajor;
+  using TileShape_MNK = Shape<_256,_128,_64>;
+  using ClusterShape_MNK = Shape<_2,_2,_1>;
+
+  using EpilogueSchedule = cutlass::epilogue::TmaWarpSpecializedCooperative;
+  using EpilogueTileType = cutlass::epilogue::collective::EpilogueTileAuto;
+
+  using EpilogueDescriptor = cutlass::epilogue::collective::detail::EpilogueDescriptor<
+    TileShape_MNK, EpilogueTileType, cutlass::half_t, cutlass::half_t, EpilogueSchedule>;
+  
+  using AuxLoadDescriptor = cutlass::epilogue::collective::detail::AuxLoadDescriptor<
+    EpilogueDescriptor, cutlass::layout::RowMajor, cutlass::half_t>;
+  
+  using FusionCallbacks = cutlass::epilogue::fusion::Sm90LinCombEVTDAG<
+    EpilogueDescriptor, AuxLoadDescriptor, cutlass::half_t, float, float>;
+
+  using CollectiveEpilogue = typename cutlass::epilogue::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      TileShape_MNK, ClusterShape_MNK,
+      EpilogueTileType,
+      float, float,
+      cutlass::half_t, LayoutC, 8,
+      cutlass::half_t, LayoutC, 8,
+      EpilogueSchedule,
+      FusionCallbacks
+    >::CollectiveOp;
+
+  using CollectiveMainloop = typename cutlass::gemm::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      cutlass::half_t, LayoutA, 8,
+      cutlass::half_t, LayoutB, 8,
+      float,
+      TileShape_MNK, ClusterShape_MNK,
+      cutlass::gemm::collective::StageCountAutoCarveout<static_cast<int>(sizeof(typename CollectiveEpilogue::SharedStorage))>,
+      cutlass::gemm::KernelTmaWarpSpecializedCooperative
+    >::CollectiveOp;
+
+  using GemmKernel = cutlass::gemm::kernel::GemmUniversal<
+      Shape<int,int,int,int>,
+      CollectiveMainloop,
+      CollectiveEpilogue
+  >;
+
+  using Gemm = cutlass::gemm::device::GemmUniversalAdapter<GemmKernel>;
+
+  // Host reference
+  bool passed = test::gemm::device::TestAllEVT<Gemm, test::gemm::device::HostEVTDAG<Gemm>>();
+  EXPECT_TRUE(passed);
+}
+
+TEST(SM90_Device_Gemm_f16t_f16n_f32t_tensor_op_gmma_f32_cooperative_epilogue, 128x128x64_2x2x1_DAGEVT) {
+  using LayoutA = cutlass::layout::RowMajor;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using LayoutC = cutlass::layout::RowMajor;
+  using TileShape_MNK = Shape<_256,_128,_64>;
+  using ClusterShape_MNK = Shape<_2,_2,_1>;
+
+  using EpilogueSchedule = cutlass::epilogue::TmaWarpSpecializedCooperative;
+  using EpilogueTileType = cutlass::epilogue::collective::EpilogueTileAuto;
+
+  using EpilogueDescriptor = cutlass::epilogue::collective::detail::EpilogueDescriptor<
+    TileShape_MNK, EpilogueTileType, cutlass::half_t, cutlass::half_t, EpilogueSchedule>;
+  
+  using AuxStoreDescriptor = cutlass::epilogue::collective::detail::AuxStoreDescriptor<
+    EpilogueDescriptor, cutlass::layout::RowMajor, cutlass::half_t>;
+  
+  using FusionCallbacks = cutlass::epilogue::fusion::Sm90LinCombDAGEVT<
+    EpilogueDescriptor, AuxStoreDescriptor, cutlass::half_t, float, cutlass::half_t, float>;
+
+  using CollectiveEpilogue = typename cutlass::epilogue::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      TileShape_MNK, ClusterShape_MNK,
+      EpilogueTileType,
+      float, float,
+      cutlass::half_t, LayoutC, 8,
+      cutlass::half_t, LayoutC, 8,
+      EpilogueSchedule,
+      FusionCallbacks
+    >::CollectiveOp;
+
+  using CollectiveMainloop = typename cutlass::gemm::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      cutlass::half_t, LayoutA, 8,
+      cutlass::half_t, LayoutB, 8,
+      float,
+      TileShape_MNK, ClusterShape_MNK,
+      cutlass::gemm::collective::StageCountAutoCarveout<static_cast<int>(sizeof(typename CollectiveEpilogue::SharedStorage))>,
+      cutlass::gemm::KernelTmaWarpSpecializedCooperative
+    >::CollectiveOp;
+
+  using GemmKernel = cutlass::gemm::kernel::GemmUniversal<
+      Shape<int,int,int,int>,
+      CollectiveMainloop,
+      CollectiveEpilogue
+  >;
+
+  using Gemm = cutlass::gemm::device::GemmUniversalAdapter<GemmKernel>;
+
+  // Host reference
+  bool passed = test::gemm::device::TestAllEVT<Gemm, test::gemm::device::HostDAGEVT<Gemm>>();
+  EXPECT_TRUE(passed);
+}
+#endif // defined(CUTLASS_ARCH_MMA_SM90_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_tf32_tf32_f32_alignx_tensor_op_f32_warpspecialized.cu

@@ -0,0 +1,167 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide GEMM interface
+*/
+
+#include <iostream>
+
+#include "cutlass/cutlass.h"
+#include "cute/tensor.hpp"
+#include "cute/atom/mma_atom.hpp"
+
+#include "cutlass/numeric_types.h"
+
+#include "cutlass/gemm/device/gemm_universal_adapter.h"
+#include "cutlass/gemm/kernel/gemm_universal.hpp"
+#include "cutlass/gemm/collective/collective_builder.hpp"
+#include "cutlass/epilogue/collective/collective_builder.hpp"
+#include "cutlass/epilogue/collective/default_epilogue.hpp"
+#include "cutlass/epilogue/thread/linear_combination.h"
+
+#include "../../common/cutlass_unit_test.h"
+
+#include "gemm_testbed_3x.hpp"
+
+#if defined(CUTLASS_ARCH_MMA_SM90_SUPPORTED)
+
+using namespace cute;
+
+///////////////////////////////////////////////////////////////////////////////
+
+TEST(SM90_Device_Gemm_tf32t_tf32n_f32n_align4_tensor_op_gmma_f32_warpspecialized, 128x64x32) {
+  using LayoutA = cutlass::layout::RowMajor;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  using CollectiveOp = typename cutlass::gemm::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      tfloat32_t, LayoutA, 4,
+      tfloat32_t, LayoutB, 4,
+      float,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::gemm::collective::StageCountAuto,
+      cutlass::gemm::KernelCpAsyncWarpSpecialized
+    >::CollectiveOp;
+
+  using CollectiveEpilogue = typename cutlass::epilogue::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::epilogue::collective::EpilogueTileAuto,
+      float, float,
+      float, LayoutC, 4,
+      float, LayoutC, 4,
+      cutlass::epilogue::NoSmemWarpSpecialized
+    >::CollectiveOp;
+
+  using GemmKernel = cutlass::gemm::kernel::GemmUniversal<
+      Shape<int,int,int,int>,
+      CollectiveOp,
+      CollectiveEpilogue
+  >;
+
+  using Gemm = cutlass::gemm::device::GemmUniversalAdapter<GemmKernel>;
+  EXPECT_TRUE(test::gemm::device::TestAll<Gemm>());
+}
+
+TEST(SM90_Device_Gemm_tf32t_tf32n_f32n_align2_tensor_op_gmma_f32_warpspecialized, 128x64x32) {
+  using LayoutA = cutlass::layout::RowMajor;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  using CollectiveOp = typename cutlass::gemm::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      cutlass::tfloat32_t, LayoutA, 2,
+      cutlass::tfloat32_t, LayoutB, 2,
+      float,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::gemm::collective::StageCountAuto,
+      cutlass::gemm::KernelCpAsyncWarpSpecialized
+    >::CollectiveOp;
+
+  using CollectiveEpilogue = typename cutlass::epilogue::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::epilogue::collective::EpilogueTileAuto,
+      float, float,
+      float, LayoutC, 2,
+      float, LayoutC, 2,
+      cutlass::epilogue::collective::EpilogueScheduleAuto
+    >::CollectiveOp;
+
+  using GemmKernel = cutlass::gemm::kernel::GemmUniversal<
+      Shape<int,int,int,int>,
+      CollectiveOp,
+      CollectiveEpilogue
+  >;
+
+  using Gemm = cutlass::gemm::device::GemmUniversalAdapter<GemmKernel>;
+  EXPECT_TRUE(test::gemm::device::TestAll<Gemm>());
+}
+
+TEST(SM90_Device_Gemm_tf32t_tf32n_f32n_align1_tensor_op_gmma_f32_warpspecialized, 128x64x32) {
+  using LayoutA = cutlass::layout::RowMajor;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  using CollectiveOp = typename cutlass::gemm::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      cutlass::tfloat32_t, LayoutA, 1,
+      cutlass::tfloat32_t, LayoutB, 1,
+      float,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::gemm::collective::StageCountAuto,
+      cutlass::gemm::KernelCpAsyncWarpSpecialized
+    >::CollectiveOp;
+
+  using CollectiveEpilogue = typename cutlass::epilogue::collective::CollectiveBuilder<
+      cutlass::arch::Sm90, cutlass::arch::OpClassTensorOp,
+      Shape<_128,_64,_32>, Shape<_1,_1,_1>,
+      cutlass::epilogue::collective::EpilogueTileAuto,
+      float, float,
+      float, LayoutC, 1,
+      float, LayoutC, 1,
+      cutlass::epilogue::collective::EpilogueScheduleAuto
+    >::CollectiveOp;
+
+  using GemmKernel = cutlass::gemm::kernel::GemmUniversal<
+      Shape<int,int,int,int>,
+      CollectiveOp,
+      CollectiveEpilogue
+  >;
+
+  using Gemm = cutlass::gemm::device::GemmUniversalAdapter<GemmKernel>;
+  EXPECT_TRUE(test::gemm::device::TestAll<Gemm>());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif // defined(CUTLASS_ARCH_MMA_SM90_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64t_cf64n_tensor_op_f64_grouped_sm80.cu

@@ -0,0 +1,168 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for grouped Rank2K interface
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/cutlass.h"
+
+#include "cutlass/blas3.h"
+#include "cutlass/gemm/gemm.h"
+#include "cutlass/gemm/kernel/rank_2k_grouped.h"
+#include "cutlass/gemm/kernel/default_rank_2k_grouped.h"
+#include "cutlass/gemm/device/rank_2k_grouped.h"
+
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/gemm.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_grouped_rank_2k.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Syr2kGrouped_cf64n_cf64n_l_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::complex<double>;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using Rank2Kkernel = typename cutlass::gemm::kernel::DefaultRank2KGrouped<
+    ElementA, LayoutA, cutlass::ComplexTransform::kNone, 1,
+    ElementB, LayoutB, cutlass::ComplexTransform::kNone, 1,
+    ElementC, LayoutC, cutlass::FillMode::kLower,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<ElementC, 1, ElementAccumulator, ElementAccumulator>,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3, // kStages
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::BlasMode::kSymmetric>::Rank2Kkernel;
+
+  using Rank2K = cutlass::gemm::device::Rank2KGrouped<Rank2Kkernel>;
+
+  test::gemm::device::TestbedGrouped<Rank2K> testbed;
+  bool passed = testbed.run(24);
+  EXPECT_TRUE(passed);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Syr2kGrouped_cf64n_cf64n_l_tensor_op_f64, 64x64x16_32x32x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::complex<double>;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using Rank2Kkernel = typename cutlass::gemm::kernel::DefaultRank2KGrouped<
+    ElementA, LayoutA, cutlass::ComplexTransform::kNone, 1,
+    ElementB, LayoutB, cutlass::ComplexTransform::kNone, 1,
+    ElementC, LayoutC, cutlass::FillMode::kLower,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 64, 16>,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<ElementC, 1, ElementAccumulator, ElementAccumulator>,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3, // kStages
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::BlasMode::kSymmetric>::Rank2Kkernel;
+
+  using Rank2K = cutlass::gemm::device::Rank2KGrouped<Rank2Kkernel>;
+
+  test::gemm::device::TestbedGrouped<Rank2K> testbed;
+  bool passed = testbed.run(24);
+  EXPECT_TRUE(passed);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Syr2kGrouped_cf64n_cf64n_u_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementA = cutlass::complex<double>;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::complex<double>;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = cutlass::complex<double>;
+  using LayoutC = cutlass::layout::ColumnMajor;
+  using ElementAccumulator = cutlass::complex<double>;
+
+  using Rank2Kkernel = typename cutlass::gemm::kernel::DefaultRank2KGrouped<
+    ElementA, LayoutA, cutlass::ComplexTransform::kNone, 1,
+    ElementB, LayoutB, cutlass::ComplexTransform::kNone, 1,
+    ElementC, LayoutC, cutlass::FillMode::kUpper,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<ElementC, 1, ElementAccumulator, ElementAccumulator>,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3, // kStages
+    cutlass::arch::OpMultiplyAddComplex,
+    cutlass::BlasMode::kSymmetric>::Rank2Kkernel;
+
+  using Rank2K = cutlass::gemm::device::Rank2KGrouped<Rank2Kkernel>;
+
+  test::gemm::device::TestbedGrouped<Rank2K> testbed;
+  bool passed = testbed.run(24);
+  EXPECT_TRUE(passed);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/trmm_f64_f64_f64_tensor_op_f64_sm90.cu

@@ -0,0 +1,126 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide TRMM interface
+
+  
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/blas3.h"
+#include "cutlass/gemm/device/trmm.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/trmm.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_trmm_universal.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM90_F64_MMA_ENABLED)
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM90_Device_Trmm_f64n_f64n_f64t_rs_l_nu_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kRight,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm90,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<16, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM90_Device_Trmm_f64t_f64t_f64n_rs_l_nu_tensor_op_f64, 64x64x16_32x32x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::RowMajor,
+    cutlass::SideMode::kRight,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::RowMajor,
+    ElementOutput,
+    cutlass::layout::ColumnMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm90,
+    cutlass::gemm::GemmShape<64, 64, 16>,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM90_F64_MMA_ENABLED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/device/trmm_f64n_f64n_f64t_tensor_op_f64_ls_sm80.cu

@@ -0,0 +1,414 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Tests for device-wide TRMM interface
+
+  
+*/
+
+#include <iostream>
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/blas3.h"
+#include "cutlass/gemm/device/trmm.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/trmm.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_copy.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "testbed_trmm_universal.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_l_nu_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_l_nu_tensor_op_f64, 64x64x16_32x32x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 64, 16>,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_l_nu_tensor_op_f64, 128x64x16_64x32x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<128, 64, 16>,
+    cutlass::gemm::GemmShape<64, 32, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_l_nu_tensor_op_f64, 64x128x16_32x64x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 128, 16>,
+    cutlass::gemm::GemmShape<32, 64, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3
+  >;
+  
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_l_nu_tensor_op_f64, 128x128x16_32x64x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kLower,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<128, 128, 16>,
+    cutlass::gemm::GemmShape<32, 64, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_u_nu_tensor_op_f64, 32x32x16_16x16x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<16, 16, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_u_nu_tensor_op_f64, 64x64x16_32x32x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 64, 16>,
+    cutlass::gemm::GemmShape<32, 32, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_u_nu_tensor_op_f64, 128x64x16_64x32x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<128, 64, 16>,
+    cutlass::gemm::GemmShape<64, 32, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    4
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_u_nu_tensor_op_f64, 64x128x16_32x64x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<64, 128, 16>,
+    cutlass::gemm::GemmShape<32, 64, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3
+  >;
+  
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM80_Device_Trmm_f64n_f64n_f64t_ls_u_nu_tensor_op_f64, 128x128x16_32x64x16) {
+
+  using ElementOutput = double;
+  using ElementAccumulator = double;
+
+  using Trmm = cutlass::gemm::device::Trmm<
+    double,
+    cutlass::layout::ColumnMajor,
+    cutlass::SideMode::kLeft,
+    cutlass::FillMode::kUpper,
+    cutlass::DiagType::kNonUnit,
+    double,
+    cutlass::layout::ColumnMajor,
+    ElementOutput,
+    cutlass::layout::RowMajor,
+    ElementAccumulator,
+    cutlass::arch::OpClassTensorOp,
+    cutlass::arch::Sm80,
+    cutlass::gemm::GemmShape<128, 128, 16>,
+    cutlass::gemm::GemmShape<32, 64, 16>,
+    cutlass::gemm::GemmShape<8, 8, 4>,
+    cutlass::epilogue::thread::LinearCombination<
+      ElementOutput,
+      1,
+      ElementAccumulator,
+      ElementAccumulator
+    >,
+    cutlass::gemm::threadblock::GemmIdentityThreadblockSwizzle<>,
+    3
+  >;
+
+  EXPECT_TRUE(test::gemm::device::TestAllTrmmUniversal<Trmm>());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // #if defined(CUTLASS_ARCH_MMA_SM80_SUPPORTED)

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_sparse_testbed.h

@@ -0,0 +1,435 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Unit testbed for kernel-level GEMM
+*/
+
+#pragma once
+
+#include "../../common/cutlass_unit_test.h"
+#include "cutlass/aligned_buffer.h"
+#include "cutlass/array.h"
+#include "cutlass/core_io.h"
+#include "cutlass/gemm/gemm.h"
+#include "cutlass/gemm/threadblock/default_mma_core_sparse_sm80.h"
+#include "cutlass/layout/matrix.h"
+#include "cutlass/numeric_types.h"
+#include "cutlass/transform/threadblock/predicated_tile_access_iterator.h"
+#include "cutlass/util/distribution.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/reference/host/gemm.h"
+#include "cutlass/util/reference/host/tensor_compare.h"
+#include "cutlass/util/reference/host/tensor_norm.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/tensor_view_io.h"
+#include "cutlass/util/host_reorder.h"
+#include "cutlass/util/host_uncompress.h"
+
+namespace test {
+namespace gemm {
+namespace threadblock {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Mma>
+__global__ void kernel_multistage_mma_sparse(cutlass::gemm::GemmCoord problem_size,
+                                      typename Mma::IteratorA::Params params_A,
+                                      typename Mma::IteratorA::TensorRef ref_A,
+                                      typename Mma::IteratorB::Params params_B,
+                                      typename Mma::IteratorB::TensorRef ref_B,
+                                      typename Mma::ElementC *ptr_C,
+                                      typename Mma::LayoutC::Stride::Index ldc,
+                                      typename Mma::IteratorE::Params params_E,
+                                      typename Mma::IteratorE::TensorRef ref_E) {
+  // Shared storage needed by threadblock-scoped matrix multiply-
+  // Dynamic shared memory base pointer
+  extern __shared__ int GemmSharedStorageBase[];
+
+  // Declare pointer to dynamic shared memory.
+  typename Mma::SharedStorage *shared_storage =
+      reinterpret_cast<typename Mma::SharedStorage *>(GemmSharedStorageBase);
+
+  // Compute threadblock location
+  cutlass::gemm::GemmCoord tb_tile_offset = {int(blockIdx.x), int(blockIdx.y),
+                                             0};
+
+  cutlass::MatrixCoord tb_offset_A{tb_tile_offset.m() * Mma::Shape::kM,
+                                   tb_tile_offset.k() / Mma::kSparse};
+
+  cutlass::MatrixCoord tb_offset_B{tb_tile_offset.k(),
+                                   tb_tile_offset.n() * Mma::Shape::kN};
+
+  cutlass::MatrixCoord tb_offset_E{tb_tile_offset.m() * Mma::Shape::kM,
+                                   tb_tile_offset.k() / Mma::kSparse};
+
+  // Compute position within threadblock
+  int tb_thread_id = threadIdx.y * blockDim.x + threadIdx.x;
+
+  // Construct iterators to A and B operands
+  typename Mma::IteratorA iterator_A(params_A, ref_A.data(),
+                                     {problem_size.m(), problem_size.k() / Mma::kSparse},
+                                     tb_thread_id, tb_offset_A);
+
+  typename Mma::IteratorB iterator_B(params_B, ref_B.data(),
+                                     {problem_size.k(), problem_size.n()},
+                                     tb_thread_id, tb_offset_B);
+
+  typename Mma::IteratorE iterator_E(
+      params_E, ref_E.data(),
+      {problem_size.m(),
+       problem_size.k() / Mma::kSparse / Mma::kElementsPerElementE},
+      tb_thread_id, tb_offset_E);
+
+  int warp_id = __shfl_sync(0xffffffff, threadIdx.y, 0);
+
+  // Construct thread-scoped matrix multiply
+  Mma mma(*shared_storage, tb_thread_id, warp_id, threadIdx.x);
+
+  typename Mma::FragmentC accum;
+
+  accum.clear();
+
+  int gemm_k_iterations = (problem_size.k() + Mma::Shape::kK - 1) / Mma::Shape::kK;
+
+  // Compute threadblock-scoped matrix multiply-add
+  mma(gemm_k_iterations, accum, iterator_A, iterator_B, iterator_E, accum);
+
+  // Output results
+  typename Mma::Operator::IteratorC iterator_C({ptr_C, ldc}, threadIdx.x);
+
+  iterator_C.add_tile_offset(
+      {(tb_tile_offset.m() * Mma::WarpCount::kM) +
+           (warp_id % Mma::WarpCount::kM),
+       (tb_tile_offset.n() * Mma::WarpCount::kN) +
+           (warp_id / Mma::WarpCount::kM)});
+
+  iterator_C.store(accum);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/// Structure to compute the matrix product
+template <
+    /// Threadblock-level matrix multiply-accumulate
+    typename MmaCore_>
+struct SparseTestbed {
+  /// Threadblock-level GEMM implementation
+  using MmaCore = MmaCore_;
+  using ThreadblockShape = typename MmaCore::Shape;
+  using WarpShape = typename MmaCore::WarpShape;
+  using InstructionShape = typename MmaCore::InstructionShape;
+  using ElementA = typename MmaCore::ElementA;
+  using LayoutA = typename MmaCore::LayoutA;
+  using ElementB = typename MmaCore::ElementB;
+  using LayoutB = typename MmaCore::LayoutB;
+  using ElementC = typename MmaCore::ElementC;
+  using LayoutC = typename MmaCore::LayoutC;
+  using ElementE = typename MmaCore::ElementE;
+  using ThreadMapA = typename MmaCore::IteratorThreadMapA;
+  using ThreadMapB = typename MmaCore::IteratorThreadMapB;
+  using ThreadMapE = typename MmaCore::IteratorThreadMapE;
+  using AccessTypeA = cutlass::Array<ElementA, ThreadMapA::kElementsPerAccess>;
+  using AccessTypeB = cutlass::Array<ElementB, ThreadMapB::kElementsPerAccess>;
+  using AccessTypeE = cutlass::Array<ElementE, ThreadMapE::kElementsPerAccess>;
+  static int const Stages = MmaCore::kStages;
+  static cutlass::arch::CacheOperation::Kind const CacheOpA =
+      MmaCore::kCacheOpA;
+  static cutlass::arch::CacheOperation::Kind const CacheOpB =
+      MmaCore::kCacheOpB;
+  static cutlass::arch::CacheOperation::Kind const CacheOpE =
+      MmaCore::kCacheOpE;
+
+  static int const Sparse = MmaCore::kSparse;
+  static int const MetaSizeInBits = MmaCore::kMetaSizeInBits;
+  static int const MaxID2 = MmaCore::kMaxID2;
+
+  using LayoutE = cutlass::layout::RowMajor;
+  using ReorderedLayoutE = typename MmaCore::GmemLayoutE;
+
+  static int const ElementsPerElementE = MmaCore::kElementsPerElementE;
+
+  // Define iterators over tiles from the A operand
+  using IteratorA =
+      cutlass::transform::threadblock::PredicatedTileAccessIterator<
+          cutlass::MatrixShape<ThreadblockShape::kM, ThreadblockShape::kK / Sparse>,
+          ElementA, LayoutA, 1, ThreadMapA, AccessTypeA>;
+
+  // Define iterators over tiles from the B operand
+  using IteratorB =
+      cutlass::transform::threadblock::PredicatedTileAccessIterator<
+          cutlass::MatrixShape<ThreadblockShape::kK, ThreadblockShape::kN>,
+          ElementB, LayoutB, 0, ThreadMapB, AccessTypeB>;
+
+  // Define iterators over tiles from the E operand
+  using IteratorE =
+      cutlass::transform::threadblock::PredicatedTileAccessIterator<
+          cutlass::MatrixShape<ThreadblockShape::kM, ThreadblockShape::kK /
+                                                         Sparse /
+                                                         ElementsPerElementE>,
+          ElementE, ReorderedLayoutE, 1, ThreadMapE, AccessTypeE>;
+
+  // Define the threadblock-scoped pipelined matrix multiply
+  using Mma = cutlass::gemm::threadblock::SparseMmaMultistage<
+      typename MmaCore::Shape, IteratorA, typename MmaCore::SmemIteratorA,
+      CacheOpA, IteratorB, typename MmaCore::SmemIteratorB, CacheOpB, ElementC,
+      LayoutC, IteratorE, typename MmaCore::SmemIteratorE, CacheOpE,
+      typename MmaCore::MmaPolicy, Stages>;
+
+  //
+  // Data members
+  //
+
+  cutlass::HostTensor<ElementA, LayoutA> matrix_A;
+  cutlass::HostTensor<ElementA, LayoutA> matrix_A_uncompressed;
+  cutlass::HostTensor<ElementB, LayoutB> matrix_B;
+  cutlass::HostTensor<ElementC, LayoutC> matrix_C_computed;
+  cutlass::HostTensor<ElementC, LayoutC> matrix_C_reference;
+  cutlass::HostTensor<ElementE, LayoutE> matrix_E;
+  cutlass::HostTensor<ElementE, ReorderedLayoutE> matrix_E_reordered;
+
+  cutlass::gemm::GemmCoord problem_size;
+  float alpha, beta;
+
+  //
+  // Methods
+  //
+
+  /// Allocates workspace in device memory
+  SparseTestbed(int m, int n, int k, float alpha_ = float(1), float beta_ = float(0))
+      : problem_size(m, n, k), alpha(alpha_), beta(beta_) {
+    matrix_A.reset(cutlass::make_Coord(m, k / Sparse));
+    matrix_A_uncompressed.reset(cutlass::make_Coord(m, k));
+    matrix_B.reset(cutlass::make_Coord(k, n));
+    matrix_C_computed.reset(cutlass::make_Coord(m, n));
+    matrix_C_reference.reset(cutlass::make_Coord(m, n), false);
+    matrix_E.reset(cutlass::make_Coord(m, k / Sparse / ElementsPerElementE));
+    matrix_E_reordered.reset(
+        cutlass::make_Coord(m, k / Sparse / ElementsPerElementE));
+  }
+
+  /// Returns true if the CUDA device is sufficient to execute the kernel.
+  bool sufficient() const {
+    //
+    // Determine SMEM requirements and waive if not satisfied
+    //
+
+    cudaDeviceProp properties;
+    int device_idx;
+    cudaError_t result = cudaGetDevice(&device_idx);
+
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaGetDevice() API call failed.");
+    }
+
+    result = cudaGetDeviceProperties(&properties, device_idx);
+
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaGetDeviceProperties() failed");
+    }
+
+    return true;
+  }
+
+  /// Runs the test
+  bool run(
+      dim3 grid, dim3 block,
+      cutlass::Distribution::Kind init_A = cutlass::Distribution::Uniform,
+      cutlass::Distribution::Kind init_B = cutlass::Distribution::Uniform,
+      cutlass::Distribution::Kind init_E = cutlass::Distribution::Uniform) {
+
+    // Waive the test
+    if (!sufficient()) {
+      return true;
+    }
+
+    //
+    // initialize device memory
+    //
+
+    if (init_A == cutlass::Distribution::Uniform) {
+
+      int scope_max = 8;
+      int scope_min = -8;
+
+      if (cutlass::sizeof_bits<ElementA>::value == 4) {
+        scope_max = 2;
+        scope_min = -2;
+      } else if (cutlass::sizeof_bits<ElementA>::value == 1) {
+        scope_max = 2;
+        scope_min = 0;
+      }
+
+      uint64_t seed = 7;
+      cutlass::reference::host::TensorFillRandomUniform(
+          matrix_A.host_view(), seed, scope_max, scope_min, 0);
+    } else if (init_A == cutlass::Distribution::Sequential) {
+      cutlass::reference::host::BlockFillSequential(matrix_A.host_data(),
+                                                    matrix_A.capacity());
+    } else if (init_A == cutlass::Distribution::Identity) {
+      cutlass::reference::host::TensorFillIdentity(matrix_A.host_view());
+    } else {
+      return false;
+    }
+
+    if (init_B == cutlass::Distribution::Uniform) {
+
+      int scope_max = 8;
+      int scope_min = -8;
+
+      if (cutlass::sizeof_bits<ElementB>::value == 4) {
+        scope_max = 2;
+        scope_min = -2;
+      } else if (cutlass::sizeof_bits<ElementB>::value == 1) {
+        scope_max = 2;
+        scope_min = 0;
+      }
+
+      uint64_t seed = 7;
+      cutlass::reference::host::TensorFillRandomUniform(
+          matrix_B.host_view(), seed + 16, scope_max, scope_min, 0);
+    } else if (init_B == cutlass::Distribution::Sequential) {
+      cutlass::reference::host::BlockFillSequential(matrix_B.host_data(),
+                                                    matrix_B.capacity());
+    } else if (init_B == cutlass::Distribution::Identity) {
+      cutlass::reference::host::TensorFillIdentity(matrix_B.host_view());
+    } else {
+      return false;
+    }
+
+    cutlass::reference::host::TensorFill(matrix_C_computed.host_view());
+
+    cutlass::reference::host::TensorFill(matrix_C_reference.host_view());
+
+    if (init_E == cutlass::Distribution::Uniform) {
+      uint64_t seed = 7;
+      cutlass::reference::host::TensorFillRandomSparseMeta(
+          matrix_E.host_view(), seed, MetaSizeInBits);
+    } else if (init_E == cutlass::Distribution::Identity) {
+      uint32_t content = (MaxID2 == 1) ? 0x44444444 : 0x4444;
+      cutlass::reference::host::TensorFill(matrix_E.host_view(),
+                                           (ElementE)(content));
+    } else {
+      return false;
+    }
+
+    cutlass::reorder_meta(matrix_E_reordered.host_ref(), matrix_E.host_ref(),
+                          {problem_size.m(), problem_size.n(),
+                           problem_size.k() / Sparse / ElementsPerElementE});
+
+    matrix_A.sync_device();
+    matrix_B.sync_device();
+    matrix_C_computed.sync_device();
+    matrix_E_reordered.sync_device();
+
+    typename IteratorA::Params params_A(matrix_A.layout());
+    typename IteratorB::Params params_B(matrix_B.layout());
+    typename IteratorE::Params params_E(matrix_E_reordered.layout());
+
+    cudaError_t result;
+
+    int smem_size = int(sizeof(typename Mma::SharedStorage));
+    if (smem_size >= (48 << 10)) {
+      result = cudaFuncSetAttribute(
+          test::gemm::threadblock::kernel_multistage_mma_sparse<Mma>,
+          cudaFuncAttributeMaxDynamicSharedMemorySize, smem_size);
+
+      if (result != cudaSuccess) {
+          return true;
+      }
+
+      result = cudaFuncSetAttribute(
+          test::gemm::threadblock::kernel_multistage_mma_sparse<Mma>,
+          cudaFuncAttributePreferredSharedMemoryCarveout, 100);
+
+      if (result != cudaSuccess) {
+          return true;
+      }
+    }
+
+    test::gemm::threadblock::kernel_multistage_mma_sparse<Mma>
+        <<<grid, block, smem_size, 0>>>(
+            problem_size, params_A, matrix_A.device_ref(), params_B,
+            matrix_B.device_ref(), matrix_C_computed.device_data(),
+            matrix_C_computed.layout().stride(0), params_E,
+            matrix_E_reordered.device_ref());
+
+    //
+    // Check error code
+    //
+
+    result = cudaDeviceSynchronize();
+    EXPECT_EQ(result, cudaSuccess)
+        << " kernel error: " << cudaGetErrorString(result);
+
+    matrix_C_computed.sync_host();
+
+    cutlass::uncompress(matrix_A_uncompressed.host_ref(), matrix_A.host_ref(),
+                        matrix_E.host_ref(), problem_size.m(),
+                        problem_size.k());
+
+    cutlass::reference::host::Gemm<ElementA, LayoutA, ElementB, LayoutB,
+                                   ElementC, LayoutC, ElementC, ElementC>
+        reference_gemm;
+
+    reference_gemm(problem_size, ElementC(alpha),
+                   matrix_A_uncompressed.host_view(), matrix_B.host_view(),
+                   ElementC(beta), matrix_C_reference.host_view());
+
+    bool passed = cutlass::reference::host::TensorEquals(
+        matrix_C_computed.host_view(), matrix_C_reference.host_view());
+
+    EXPECT_TRUE(passed);
+
+    if (!passed && CUTLASS_TEST_UNIT_ENABLE_WARNINGS) {
+
+      std::cout
+        << __FILE__ << ":" << __LINE__ << "  "
+        << "A:\n" << matrix_A.host_view() << "\n"
+        << "B:\n" << matrix_B.host_view() << "\n"
+        << "E:\n" << matrix_E.host_view() << "\n"
+        << "Reference:\n"
+        << matrix_C_reference.host_view() << "\n"
+        << "Computed:\n"
+        << matrix_C_computed.host_view() << "\n";
+    }
+
+    EXPECT_GT(cutlass::reference::host::TensorNorm(matrix_C_reference.host_view()), 0);
+    EXPECT_GT(cutlass::reference::host::TensorNorm(matrix_C_computed.host_view()), 0);
+
+    return passed;
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+}  // namespace threadblock
+}  // namespace gemm
+}  // namespace test

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_sm75.cu

@@ -0,0 +1,2128 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/*! \file
+    \brief Unit tests for threadblock-level GEMM
+*/
+
+#include "mma_pipelined_testbed.h"
+
+#if defined(CUTLASS_ARCH_MMA_SM75_SUPPORTED)
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous, tensor_op_64x64x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 1, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous, tensor_op_128x64x32_64x32x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous, tensor_op_64x128x32_32x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous, tensor_op_128x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous,
+     multicta_256x256x96_128x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = cutlass::half_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 96);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_congruous,
+     multicta_512x256x384_256x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::ColumnMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::RowMajor;
+  using ElementC = cutlass::half_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 384);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<256, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 1, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x32x32_16x16x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<32, 32, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x64x32_16x32x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<32, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x32x32_32x16x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 32, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x32_32x32x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x64x32_64x32x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 64, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x128x32_32x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 128);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<64, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 96);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_256x256x96_128x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 96);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<128, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_512x256x384_256x128x32_64x64x32_16x8x8) {
+  using ElementA = cutlass::half_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::half_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = float;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 384);
+
+  using ThreadblockShape = cutlass::gemm::GemmShape<256, 128, 32>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 32>;
+  using InstructionShape = cutlass::gemm::GemmShape<16, 8, 8>;
+
+  float alpha = 1.f;
+  float beta = 0.0f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadblockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC,
+      cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_32x32x64_16x16x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 32, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x32x64_32x16x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 32, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_32x64x64_16x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x64x64_32x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_128x64x64_64x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore component
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x128x64_32x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_128x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved,
+     multicta_256x256x192_128x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 192);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved,
+     multicta_512x256x768_256x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<32>;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<32>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 768);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<256, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 1, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x32x64_16x16x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 32, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x32x64_32x16x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 32, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x64x64_16x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x64_32x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x64x64_64x32x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 64, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore component
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x128x64_32x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 256);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_256x256x192_128x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 192);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_512x256x768_256x128x64_64x64x64_8x8x16) {
+  using ElementA = uint8_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = uint8_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 768);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<256, 128, 64>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 64>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 16>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 1, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x32x128_16x16x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 32, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x32x128_32x16x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 32, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x64x128_16x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x128_32x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x64x128_64x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore component
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x128x128_32x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_256x256x384_128x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 384);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_512x256x1536_256x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 1536);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<256, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_32x32x128_16x16x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 32, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x32x128_32x16x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 32, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_32x64x128_16x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x64x128_32x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_128x64x128_64x32x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 64, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore component
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_64x128x128_32x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved, tensor_op_128x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 512);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved,
+     multicta_256x256x384_128x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 384);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_interleaved,
+     multicta_512x256x1536_256x128x128_64x64x128_8x8x32) {
+  using ElementA = cutlass::uint4b_t;
+  using LayoutA = cutlass::layout::ColumnMajorInterleaved<64>;
+  using ElementB = cutlass::uint4b_t;
+  using LayoutB = cutlass::layout::RowMajorInterleaved<64>;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 1536);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<256, 128, 128>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 128>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 32>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x512_64x64x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 1, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x32x512_16x16x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 32, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 32, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 16, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x32x512_32x16x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 32, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 32, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 16, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_32x64x512_16x32x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(32, 64, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<32, 64, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<16, 32, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x64x512_32x32x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 64, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 32, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x64x512_64x32x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 64, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 64, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 32, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore component
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_64x128x512_32x64x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(64, 128, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<64, 128, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<32, 64, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise, tensor_op_128x128x512_64x64x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(128, 128, 2048);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(1, 1);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_256x256x1536_128x128x512_64x64x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(256, 256, 1536);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<128, 128, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 4, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(SM75_gemm_threadblock_crosswise,
+     multicta_512x256x6144_256x128x512_64x64x512_8x8x128) {
+  using ElementA = cutlass::uint1b_t;
+  using LayoutA = cutlass::layout::RowMajor;
+  using ElementB = cutlass::uint1b_t;
+  using LayoutB = cutlass::layout::ColumnMajor;
+  using ElementC = int32_t;
+  using LayoutC = cutlass::layout::ColumnMajor;
+
+  cutlass::gemm::GemmCoord problem_size(512, 256, 6144);
+
+  using ThreadBlockShape = cutlass::gemm::GemmShape<256, 128, 512>;
+  using WarpShape = cutlass::gemm::GemmShape<64, 64, 512>;
+  using InstructionShape = cutlass::gemm::GemmShape<8, 8, 128>;
+
+  float alpha = 1.f;
+  float beta = 0.f;
+
+  // Define the MmaCore components
+  using MmaCore = typename cutlass::gemm::threadblock::DefaultMmaCore<
+      ThreadBlockShape, WarpShape, InstructionShape, ElementA, LayoutA,
+      ElementB, LayoutB, ElementC, LayoutC, cutlass::arch::OpClassTensorOp, 2,
+      cutlass::arch::OpXorPopc>;
+
+  dim3 grid(2, 2);
+  dim3 block(32, 8, 1);
+
+  test::gemm::threadblock::Testbed<MmaCore>(problem_size.m(), problem_size.n(),
+                                            problem_size.k(), alpha, beta)
+      .run(grid, block);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/conv3d_operation_profiler.h

@@ -0,0 +1,449 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines profiling functionality for convolution
+
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/handle.h"
+#include "cutlass/library/manifest.h"
+#include "cutlass/library/singleton.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+#include "reduction_operation_profiler.h"
+#if CUTLASS_ENABLE_CUDNN
+#include "cudnn_helpers.h"
+#endif //#if CUTLASS_ENABLE_CUDNN
+#include "debug.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Abstract base class for each math function
+class Conv3dOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct Conv3dProblem {
+
+    int64_t n, d, h, w, c, z, p, q, k, t, r, s;
+    int64_t pad_d, pad_h, pad_w;
+    int64_t stride_d, stride_h, stride_w;
+    int64_t dilation_d, dilation_h, dilation_w;
+
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+
+    library::SplitKMode split_k_mode;
+    int64_t split_k_slices;
+
+    library::ConvModeID conv_mode;
+
+    library::Provider eq_gemm_provider;
+
+    // convolution with parallel interleaved reduction  
+    // convolution epilogue (alpha, beta) = (1.0, 0.0)
+    // reduction epilogue (alpha, beta) = (Conv3dProblem::alpha, Conv3dProblem::beta)
+    std::vector<uint8_t> alpha_one;
+    std::vector<uint8_t> beta_zero;
+
+    //
+    // Methods
+    //
+
+    /// Total number of bytes loaded
+    int64_t bytes(library::ConvDescription const &operation_desc) const;
+
+    /// Total number of flops computed
+    int64_t flops(library::ConvDescription const &operation_desc) const;
+
+    /// Infers output size from the input size, padding, stride, and dilation
+    void set_default_output_size() {
+      z = ((d + pad_d - t * dilation_d) / stride_d) + 1;
+      p = ((h + pad_h - r * dilation_h) / stride_h) + 1;
+      q = ((w + pad_w - s * dilation_w) / stride_w) + 1;
+    }
+
+    // Returns equivalent gemm problem size for convolution
+    cutlass::gemm::GemmCoord eq_gemm_size(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return cutlass::gemm::GemmCoord(int(n * z * p * q), int(k), int(t * r * s * c));
+        case library::ConvKind::kDgrad: return cutlass::gemm::GemmCoord(int(n * d * h * w), int(c), int(t * r * s * k));
+        case library::ConvKind::kWgrad: return cutlass::gemm::GemmCoord(int(k), int(t * r * s * c), int(n * z * p * q));
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns extent for tensor A
+    std::vector<int> extent_a(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return {int(n), int(d), int(h), int(w), int(c)};
+        case library::ConvKind::kDgrad: return {int(n), int(z), int(p), int(q), int(k)};
+        case library::ConvKind::kWgrad: return {int(n), int(z), int(p), int(q), int(k)};
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns extent for tensor B
+    std::vector<int> extent_b(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return {int(k), int(t), int(r), int(s), int(c)};
+        case library::ConvKind::kDgrad: return {int(k), int(t), int(r), int(s), int(c)};
+        case library::ConvKind::kWgrad: return {int(n), int(d), int(h), int(w), int(c)};
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns extent for tensor C
+    std::vector<int> extent_c(library::ConvKind const &conv_kind) const {
+    
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return {int(n), int(z), int(p), int(q), int(k)};
+        case library::ConvKind::kDgrad: return {int(n), int(d), int(h), int(w), int(c)};
+        case library::ConvKind::kWgrad: return {int(k), int(t), int(r), int(s), int(c)};
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns layout for equivalent gemm matrix A
+    library::LayoutTypeID eq_gemm_layout_a(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return library::LayoutTypeID::kRowMajor;    // TN Gemm
+        case library::ConvKind::kDgrad: return library::LayoutTypeID::kRowMajor;    // TT Gemm
+        case library::ConvKind::kWgrad: return library::LayoutTypeID::kColumnMajor; // NT Gemm
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns layout for equivalent gemm matrix B
+    library::LayoutTypeID eq_gemm_layout_b(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return library::LayoutTypeID::kColumnMajor;  // TN Gemm
+        case library::ConvKind::kDgrad: return library::LayoutTypeID::kRowMajor;     // TT Gemm
+        case library::ConvKind::kWgrad: return library::LayoutTypeID::kRowMajor;     // NT Gemm
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns layout for equivalent gemm matrix C
+    library::LayoutTypeID eq_gemm_layout_c(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        // Gemm operator assumes column-major output
+        case library::ConvKind::kFprop:
+        case library::ConvKind::kDgrad: 
+        case library::ConvKind::kWgrad: return library::LayoutTypeID::kColumnMajor;
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns leading dimension for equivalent gemm matrix A
+    int64_t eq_gemm_lda(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return eq_gemm_size(conv_kind).k();
+        case library::ConvKind::kDgrad: return eq_gemm_size(conv_kind).k();
+        case library::ConvKind::kWgrad: return eq_gemm_size(conv_kind).m();
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns leading dimension for equivalent gemm matrix B
+    int64_t eq_gemm_ldb(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: return eq_gemm_size(conv_kind).k();
+        case library::ConvKind::kDgrad: return eq_gemm_size(conv_kind).n();
+        case library::ConvKind::kWgrad: return eq_gemm_size(conv_kind).n();
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+
+    // Returns leading dimension for equivalent gemm matrix C
+    int64_t eq_gemm_ldc(library::ConvKind const &conv_kind) const {
+
+      switch (conv_kind) {
+        case library::ConvKind::kFprop: 
+        case library::ConvKind::kDgrad: 
+        case library::ConvKind::kWgrad: return eq_gemm_size(conv_kind).m();
+        default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+      }
+    }
+  };
+
+  /// Workspace used 
+  struct Conv2dWorkspace {
+
+    /// Conv device allocations
+    DeviceAllocation *A;
+    DeviceAllocation *B;
+    DeviceAllocation *C;
+    DeviceAllocation *Computed;
+    DeviceAllocation *Reference;
+    
+    /// Library configuration and arguments for convolution operator
+    library::Conv3dConfiguration configuration;
+    library::ConvArguments arguments;
+
+    /// Number of copies of the problem workspace which are visited sequentially during
+    /// profiling to avoid camping in the last level cache.
+    int problem_count;
+
+    /// Buffer used for the cutlass conv2d operations' host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the cutlass operations' device workspace
+    DeviceAllocation device_workspace;
+    
+    /// Library configuration and arguments for reduction operator
+    library::ReductionConfiguration reduction_configuration;
+    library::ReductionArguments reduction_arguments;
+
+    /// Buffer used for the cutlass reduction operations' host workspace
+    std::vector<uint8_t> reduction_host_workspace;
+  
+    /// Host data buffers for host reference operation
+    /// host buffer for tensor 
+    std::vector<uint8_t> host_tensor_a;
+
+    /// host buffer for tensor b
+    std::vector<uint8_t> host_tensor_b;
+
+    /// host buffer for tensor c
+    std::vector<uint8_t> host_tensor_c;
+
+
+    //
+    // Methods
+    //
+
+    Conv2dWorkspace(): 
+      A(nullptr), B(nullptr), C(nullptr), Computed(nullptr), Reference(nullptr) { }
+
+      // Returns stride vector for tensor A
+      std::vector<int64_t> stride_a(library::ConvKind const &conv_kind) {
+        return {        
+          configuration.layout_a(conv_kind).stride()[0],
+          configuration.layout_a(conv_kind).stride()[1],
+          configuration.layout_a(conv_kind).stride()[2],
+          configuration.layout_a(conv_kind).stride()[3]
+        };
+      }
+
+      // Returns stride vector for tensor B
+      std::vector<int64_t> stride_b(library::ConvKind const &conv_kind) {
+
+        return {        
+          configuration.layout_b(conv_kind).stride()[0],
+          configuration.layout_b(conv_kind).stride()[1],
+          configuration.layout_b(conv_kind).stride()[2],
+          configuration.layout_b(conv_kind).stride()[3]
+        };
+      }
+
+      // Returns stride vector for tensor C
+      std::vector<int64_t> stride_c(library::ConvKind const &conv_kind) {
+
+        return {        
+          configuration.layout_c(conv_kind).stride()[0],
+          configuration.layout_c(conv_kind).stride()[1],
+          configuration.layout_c(conv_kind).stride()[2],
+          configuration.layout_c(conv_kind).stride()[3]
+        };
+      }
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  /// CONV problem obtained from problem space
+  Conv3dProblem problem_;
+
+  /// Device memory allocations 
+  Conv2dWorkspace conv_workspace_;
+
+  /// CUTLASS parallel reduction operation to follow this* conv2d operation
+  library::Operation const *reduction_op_;
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  Conv3dOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~Conv3dOperationProfiler();
+
+  Conv3dProblem const& problem() const { return problem_; }
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Updates the arguments structure for the CUTLASS operator based on
+  /// the problem index.
+  void set_cutlass_operator_arguments_(int problem_idx = 0);
+
+  /// Method to profile an initialized CUTLASS operation
+  virtual Status profile_cutlass_(
+    double &runtime,
+    Options const &options,
+    library::Operation const *operation,
+    void *arguments,
+    void *host_workspace,
+    void *device_workspace);
+  
+  /// Initialize reduction problem dimensions and library::Operation
+  bool initialize_reduction_configuration_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,  
+    library::ConvDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+
+  /// Verifies CUTLASS against host reference
+  bool verify_with_host_reference_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against device reference
+  bool verify_with_device_reference_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+#if CUTLASS_ENABLE_CUDNN
+
+  /// Verifies CUTLASS against cudnn reference
+  bool verify_with_cudnn_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+#endif //#if CUTLASS_ENABLE_CUDNN
+
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cublas_helpers.h

@@ -0,0 +1,456 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Helper functions for mapping CUTLASS concepts to cuBLAS.
+*/
+
+#pragma once
+
+#if CUTLASS_ENABLE_CUBLAS
+#include <cublas_v2.h>
+#include <cublasLt.h>
+
+#include "cutlass/cutlass.h"
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/blas3.h"
+
+#include "options.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Converts a cuBLAS status to cutlass::Status
+Status get_cutlass_status(cublasStatus_t cublas);
+
+/// Converts a cuBLAS status to cutlass::profiler::Disposition
+Disposition get_cutlass_disposition(cublasStatus_t cublas_status);
+
+/// Maps a CUTLASS tensor layout to a cuBLAS transpose operation
+bool get_cublas_transpose_operation(
+  cublasOperation_t &operation,
+  library::LayoutTypeID layout,
+  library::ComplexTransform transform = library::ComplexTransform::kNone);
+
+/// Maps a CUTLASS numeric type to a cuBLAS data type enumeration
+bool get_cublas_datatype(cublasDataType_t &data_type, library::NumericTypeID element_type);
+
+/// Gets the cublas algorithm given threadblock tile dimensions and math opcode class
+cublasGemmAlgo_t get_cublas_gemm_algo(
+  int cta_m, 
+  int cta_n, 
+  int cta_k, 
+  library::OpcodeClassID opcode_class);
+
+/// Returns a status if cuBLAS can satisfy a particular GEMM description
+Status cublas_satisfies(library::GemmDescription const &desc);
+
+/// Returns a status if cuBLAS can satisfy a particular RankK description
+Status cublas_satisfies(library::RankKDescription const &desc);
+
+/// Returns a status if cuBLAS can satisfy a particular TRMM description
+Status cublas_satisfies(library::TrmmDescription const &desc);
+
+/// Returns a status if cuBLAS can satisfy a particular SYMM/HEMM description
+Status cublas_satisfies(library::SymmDescription const &desc);
+
+/// This is a helper class to create cublasHandle_t automatically on CublasCreate object creation and 
+/// to destroy cublasHandle_t on CublasCreate object destruction. 
+/// Additionally, it provides implicit cast from CublasCreate's object to cublasHandle_t's object
+class CublasCreate {
+private:
+  cublasHandle_t handle;
+  cublasStatus_t status;
+
+public:
+  CublasCreate() {
+    status = cublasCreate(&handle);
+  }
+
+  ~CublasCreate() {
+    cublasDestroy(handle);
+  }
+
+  /// Implicit cast CublasCreate object to cublasHandle_t
+  operator cublasHandle_t() const { return handle; }
+
+  /// returns cublasStatus_t for handle creation
+  cublasStatus_t get_cublas_create_status() { return status; }
+};
+
+/// This is a helper class to create cublasLtHandle_t automatically on CublasLtCreate object creation and 
+/// to destroy cublasLtHandle_t on CublasLtCreate object destruction. 
+/// Additionally, it provides implicit cast from CublasLtCreate's object to cublasLtHandle_t's object
+class CublasLtCreate {
+private:
+  cublasLtHandle_t handle;
+  cublasStatus_t status;
+
+public:
+  CublasLtCreate() {
+    status = cublasLtCreate(&handle);
+  }
+
+  ~CublasLtCreate() {
+    cublasLtDestroy(handle);
+  }
+
+  /// Implicit cast CublasLtCreate object to cublasLtHandle_t
+  operator cublasLtHandle_t() const { return handle; }
+
+  /// returns cublasLtStatus_t for handle creation
+  cublasStatus_t get_cublaslt_create_status() { return status; }
+};
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace detail {
+
+/// Selects one or more cuBLAS algorithms.
+static void select_cublas_algorithms(
+  std::vector<cublasGemmAlgo_t> &algorithms,
+  Options const &options, 
+  library::GemmDescription const &op_desc) {
+
+  library::OpcodeClassID const & opcode_class = 
+    op_desc.tile_description.math_instruction.opcode_class;
+
+  switch (options.library.algorithm_mode) {
+    case AlgorithmMode::kMatching:
+    {
+      algorithms.push_back(get_cublas_gemm_algo(
+        op_desc.tile_description.threadblock_shape.m(), 
+        op_desc.tile_description.threadblock_shape.n(), 
+        op_desc.tile_description.threadblock_shape.k(), 
+        opcode_class));
+      break;
+    }
+
+    case AlgorithmMode::kBest:
+    {
+      // Choose first enumerated mode. If none are enumerated, choose based on opcode class
+      // and evaluate all of them.
+
+      if (options.library.algorithms.empty()) {
+        // Enumerate all algorithms
+        if (opcode_class == library::OpcodeClassID::kSimt) {
+          
+          for (int algo = CUBLAS_GEMM_DEFAULT; 
+            algo <= CUBLAS_GEMM_ALGO23; 
+            ++algo) {
+
+            algorithms.push_back(cublasGemmAlgo_t(algo));
+          }
+        }
+        else {
+          
+          for (int algo = CUBLAS_GEMM_DEFAULT_TENSOR_OP; 
+            algo <= CUBLAS_GEMM_ALGO15_TENSOR_OP; 
+            ++algo) {
+
+            algorithms.push_back(cublasGemmAlgo_t(algo));
+          }
+        }
+      }
+      else {
+        // Use the listed algorithms
+        algorithms.reserve(options.library.algorithms.size());
+
+        for (int algo : options.library.algorithms) {
+          algorithms.push_back(reinterpret_cast<cublasGemmAlgo_t const &>(algo));
+        }
+      }
+
+      break;
+    }
+
+    case AlgorithmMode::kDefault:
+    {
+
+      // Use the library's default algorithm
+      algorithms.push_back((opcode_class == library::OpcodeClassID::kSimt ? 
+        CUBLAS_GEMM_DEFAULT : CUBLAS_GEMM_DEFAULT_TENSOR_OP)); 
+
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+}
+
+/// Dispatcher to cublasGemmEx() 
+struct cublasGemmExDispatcher {
+
+  //
+  // Data members
+  //
+  library::GemmUniversalConfiguration configuration;
+  library::GemmUniversalArguments arguments;
+
+  // cublas-specific data structures to fill cublas API call arguments
+  cublasOperation_t trans_A;
+  cublasOperation_t trans_B;
+  cudaDataType_t data_type_A;
+  cudaDataType_t data_type_B;
+  cudaDataType_t data_type_C;
+  cudaDataType_t compute_data_type;
+
+#if (__CUDACC_VER_MAJOR__ >= 11)
+  cublasComputeType_t compute_type;
+#endif
+
+  cublasGemmAlgo_t algo;
+  Status status;
+  
+  //
+  // Methods
+  //
+
+  cublasGemmExDispatcher( 
+    library::GemmDescription const &op_desc,
+    library::GemmUniversalConfiguration configuration_,
+    library::GemmUniversalArguments arguments_,
+    cublasGemmAlgo_t algorithm = CUBLAS_GEMM_DFALT
+  );
+
+  /// Executes GEMM using these arguments
+  cublasStatus_t operator()(cublasHandle_t handle);
+};
+
+/// Dispatcher to cublaslt kernels 
+//
+struct cublasLtGemmExDispatcher {
+
+  //
+  // Data members
+  //
+  library::GemmDescription const &op_desc;
+  library::GemmUniversalConfiguration configuration;
+  library::GemmUniversalArguments arguments;
+
+  // cublas-specific data structures to fill cublas API call arguments
+  cublasOperation_t trans_A;
+  cublasOperation_t trans_B;
+  cudaDataType_t data_type_A;
+  cudaDataType_t data_type_B;
+  cudaDataType_t data_type_C;
+  cudaDataType_t compute_data_type = CUDA_R_32F;
+
+  //cublasLt-specific data structures
+  cublasLtMatmulDesc_t operationDesc = NULL;
+  cublasLtMatrixLayout_t Adesc = NULL, Bdesc = NULL, Cdesc = NULL, Ddesc = NULL;
+  cublasLtMatmulPreference_t preference = NULL;
+  
+  //is set by call to get_cublaslt_algo()
+  cublasLtMatmulHeuristicResult_t heuristicResult_;
+  void *workspace = nullptr;
+
+  Status status;
+
+#if (__CUDACC_VER_MAJOR__ >= 11)
+  cublasComputeType_t compute_type;
+#endif
+
+  //
+  // Methods
+  //
+
+  cublasLtGemmExDispatcher( 
+    library::GemmDescription const &op_desc,
+    library::GemmUniversalConfiguration configuration_,
+    library::GemmUniversalArguments arguments_
+  );
+
+  /// Initialize the cublasLt variables
+  void initialize_cublaslt();
+  
+
+  /// Runs auto-tuning for the cublas heuristics
+  bool get_cublaslt_algo(cublasLtHandle_t handle,
+    AlgorithmMode algorithm_mode 
+    ); 
+
+  /// Executes GEMM using these arguments
+  cublasStatus_t operator()(cublasLtHandle_t handle);
+
+  ~cublasLtGemmExDispatcher(){
+
+    // descriptors are no longer needed as all GPU work was already enqueued
+    if (preference) cublasLtMatmulPreferenceDestroy(preference);
+    if (Ddesc) cublasLtMatrixLayoutDestroy(Ddesc);
+    if (Cdesc) cublasLtMatrixLayoutDestroy(Cdesc);
+    if (Bdesc) cublasLtMatrixLayoutDestroy(Bdesc);
+    if (Adesc) cublasLtMatrixLayoutDestroy(Adesc);
+    if (operationDesc) cublasLtMatmulDescDestroy(operationDesc);
+
+    if (workspace) {
+      cudaFree(workspace);
+    }
+
+  } 
+
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Dispatcher to cublas rank k update kernels 
+struct cublasRankKDispatcher {
+
+  //
+  // Data members
+  //
+  library::RankKConfiguration configuration;
+  library::RankKArguments arguments;
+
+  // cublas-specific data structures to fill cublas API call arguments
+  cublasOperation_t trans_A;
+  cublasFillMode_t uplo;
+  cudaDataType_t data_type_A;
+  cudaDataType_t data_type_C;
+  cudaDataType_t compute_data_type;
+
+#if (__CUDACC_VER_MAJOR__ >= 11)
+  cublasComputeType_t compute_type;
+#endif
+
+  int num_ranks;       //(rank-k or rank-2k)
+  BlasMode blas_mode; //(symmetric or hermitian)
+  Status status;
+  
+  //
+  // Methods
+  //
+
+  cublasRankKDispatcher( 
+    library::RankKDescription const &op_desc,
+    library::RankKConfiguration configuration_,
+    library::RankKArguments arguments_
+  );
+
+  /// Executes RankK using these arguments
+  cublasStatus_t operator()(cublasHandle_t handle);
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Dispatcher to cublasTrmm() 
+struct cublasTrmmDispatcher {
+
+  //
+  // Data members
+  //
+  library::TrmmConfiguration configuration;
+  library::TrmmArguments arguments;
+
+  // cublas-specific data structures to fill cublas API call arguments
+  cublasOperation_t trans_A;
+  cublasSideMode_t side;
+  cublasFillMode_t uplo;
+  cublasDiagType_t diag;
+  cudaDataType_t data_type_A;
+  cudaDataType_t data_type_B;
+  cudaDataType_t data_type_D;
+  cudaDataType_t compute_data_type;
+
+#if (__CUDACC_VER_MAJOR__ >= 11)
+  cublasComputeType_t compute_type;
+#endif
+
+  Status status;
+  
+  //
+  // Methods
+  //
+
+  cublasTrmmDispatcher( 
+    library::TrmmDescription const &op_desc,
+    library::TrmmConfiguration configuration_,
+    library::TrmmArguments arguments_
+  );
+
+  /// Executes TRMM using these arguments
+  cublasStatus_t operator()(cublasHandle_t handle);
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Dispatcher to cublas symm/hemm update kernels 
+struct cublasSymmDispatcher {
+
+  //
+  // Data members
+  //
+  library::SymmConfiguration configuration;
+  library::SymmArguments arguments;
+
+  // cublas-specific data structures to fill cublas API call arguments
+  cublasSideMode_t side;
+  cublasFillMode_t uplo;
+  cudaDataType_t data_type_A;
+  cudaDataType_t data_type_B;
+  cudaDataType_t data_type_C;
+  cudaDataType_t compute_data_type;
+
+#if (__CUDACC_VER_MAJOR__ >= 11)
+  cublasComputeType_t compute_type;
+#endif
+  
+  BlasMode blas_mode; //(symmetric or hermitian)
+  Status status;
+  
+  //
+  // Methods
+  //
+
+  cublasSymmDispatcher( 
+    library::SymmDescription const &op_desc,
+    library::SymmConfiguration configuration_,
+    library::SymmArguments arguments_
+  );
+
+  /// Executes Symm using these arguments
+  cublasStatus_t operator()(cublasHandle_t handle);
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace detail
+
+} // namespace profiler
+} // namespace cutlass
+
+
+#endif // #if CUTLASS_ENABLE_CUBLAS

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cudnn_helpers.h

@@ -0,0 +1,590 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Helper functions for mapping CUTLASS concepts to cuDNN.
+
+*/
+
+#pragma once
+#if CUTLASS_ENABLE_CUDNN
+#include <cuda_runtime.h>
+#include <cudnn.h>
+#include <iostream>
+#include "cutlass/cutlass.h"
+#include "cutlass/util/device_memory.h"
+#include "cutlass/library/library.h"
+#include "enumerated_types.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+/// Converts a cuDNN status to cutlass::Status
+Status get_cutlass_status(cudnnStatus_t cudnn_status);
+
+/// Converts a cuDNN status to cutlass::profiler::Disposition
+Disposition get_cutlass_disposition(cudnnStatus_t cudnn_status);
+
+/// Checks cudnnStatus_t converts to cutlas status and returns if Status::kSuccess o.w. throws exception
+Status checkCudnnErr(cudnnStatus_t cudnn_status);
+
+/// Maps a CUTLASS conv mode to a cuDNN conv mode enumeration
+bool get_cudnn_conv_mode(cudnnConvolutionMode_t &cudnn_conv_mode, conv::Mode conv_mode);
+
+/// Maps a CUTLASS layout type to a cuDNN data type enumeration
+bool get_cudnn_layout(cudnnTensorFormat_t &cudnn_layout, library::LayoutTypeID layout);
+
+/// Maps a CUTLASS numeric type to a cuDNN data type enumeration
+bool get_cudnn_datatype(cudnnDataType_t &cudnn_element_type, library::NumericTypeID element_type);
+
+/// Maps CUTLASS math OpcodeClassID and MathOperationID to cuDNN math_type
+bool get_cudnn_mathtype(cudnnMathType_t &cudnn_math_type, library::ConvDescription const &conv_desc);
+
+/// Returns a status if cudnn can satisfy a particular Conv2d description
+Status cudnn_satisfies(library::ConvDescription const &desc, library::Conv2dConfiguration const &configuration);
+
+/// Returns a status if cudnn can satisfy a particular Conv3d description
+Status cudnn_satisfies(library::ConvDescription const &desc, library::Conv3dConfiguration const &configuration);
+
+/// Cudnn compute type seems to be hardcoded to float (To handle a possible cudnn issue)
+float cast_cudnn_compute_type_to_float(library::NumericTypeID type, void const * src);
+
+
+/// This is a helper class to create cudnnHandle_t automatically on CudnnCreate object creation and 
+/// to destroy cudnnHandle_t on CudnnCreate object destruction. 
+/// Additionally, it provides implicit cast from CudnnCreate's object to cudnnHandle_t's object
+class CudnnCreate {
+private:
+	cudnnHandle_t handle;
+	cudnnStatus_t status;
+
+public:
+	CudnnCreate() {
+		status = cudnnCreate(&handle);
+	}
+
+	~CudnnCreate() {
+		cudnnDestroy(handle);
+	}
+
+    /// Implicit cast CudnnCreate object to cudnnHandle_t
+    operator cudnnHandle_t() const { return handle; }
+
+    /// returns cudnnStatus_t for handle creation
+    cudnnStatus_t get_cudnn_create_status() { return status; }
+};
+
+
+namespace detail {
+
+/// Dispatcher to cudnn convolution operators
+struct cudnnConvDispatcher {
+
+  //
+  // Data members
+  //
+  //library::Conv2dConfiguration configuration;
+  library::ConvArguments arguments;
+  library::ConvKind conv_kind;
+
+  // cudnn-specific data structures to fill cudnn API call arguments
+  // cudnn activation, filter, and output descriptors
+  cudnnTensorDescriptor_t activation_desc;
+  cudnnFilterDescriptor_t filter_desc;
+  cudnnTensorDescriptor_t output_desc;
+  cudnnConvolutionDescriptor_t conv_desc;
+
+  // cudnn datatypes
+  cudnnDataType_t data_type_activation;
+  cudnnDataType_t data_type_filter;
+  cudnnDataType_t data_type_output;
+
+  // cudnn layouts
+  cudnnTensorFormat_t layout_activation;
+  cudnnTensorFormat_t layout_filter;
+  cudnnTensorFormat_t layout_output;
+
+  // cudnn convolution mode
+  cudnnConvolutionMode_t conv_mode;
+  
+  // cudnn math type (tensorop, tensorop with conversion, simt)
+  cudnnMathType_t math_type;
+
+  // cudnn compute data type
+  cudnnDataType_t compute_type;
+  
+  // cudnn compute type seems to be hardcoded to float (to handle a possible a cudnn issue)
+  float alpha;
+  float beta;
+
+  // cudnn workspace
+  size_t workspace_size_in_bytes = 0;
+  cutlass::device_memory::allocation<char> workspace;
+  
+  // select cudnn's implicit gemm precomputed algorithm with tensor operations
+  static cudnnConvolutionFwdAlgo_t const fprop_algo = CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM;
+  static cudnnConvolutionBwdDataAlgo_t const dgrad_algo = CUDNN_CONVOLUTION_BWD_DATA_ALGO_1;
+  static cudnnConvolutionBwdFilterAlgo_t const wgrad_algo = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1;
+
+  Status status;
+  
+  //
+  // Methods
+  //
+
+  // TODO: unify ctor cudnnConvDispatcher for conv2d and conv3d by unifying Conv2dConfiguration
+  
+  // ctor for conv2d 
+  cudnnConvDispatcher( 
+    library::ConvDescription const &op_desc,
+    library::Conv2dConfiguration configuration,
+    library::ConvArguments arguments_,
+    cudnnHandle_t handle
+  ):
+    //configuration(configuration_), 
+    arguments(arguments_),
+    conv_kind(op_desc.conv_kind), 
+    status(Status::kSuccess) {
+
+    bool good = true;
+
+    // Get cudnn datatype, layout, and convolution mode from library::ConvDescription
+    good = (good && get_cudnn_datatype(data_type_activation, op_desc.A.element));
+    good = (good && get_cudnn_datatype(data_type_filter, op_desc.B.element));
+    good = (good && get_cudnn_datatype(data_type_output, op_desc.C.element));
+    good = (good && get_cudnn_layout(layout_activation, op_desc.A.layout));
+    good = (good && get_cudnn_layout(layout_filter, op_desc.B.layout));
+    good = (good && get_cudnn_layout(layout_output, op_desc.C.layout));
+    good = (good && get_cudnn_conv_mode(conv_mode, configuration.problem_size.mode));
+    // Get cudnn mathtype (cudnnMathType_t)
+    good = (good && get_cudnn_mathtype(math_type, op_desc));
+    good = (good && get_cudnn_datatype(
+      compute_type,
+      op_desc.tile_description.math_instruction.element_accumulator));
+    // Check cutlass Conv2d description has equivalent operator in cudnn
+    if (!good) {
+      status = Status::kErrorNotSupported;
+      return;
+    }
+    // cudnn compute type seems to be hardcoded to float (to handle a possible a cudnn issue)
+    alpha = cast_cudnn_compute_type_to_float(op_desc.element_epilogue, arguments.alpha);
+    beta = cast_cudnn_compute_type_to_float(op_desc.element_epilogue, arguments.beta);
+
+    // Create convolution descriptor object
+    status = get_cutlass_status(cudnnCreateConvolutionDescriptor(&conv_desc));
+
+    // Configure convolution operator
+    std::vector<int> padding {configuration.problem_size.pad_h, configuration.problem_size.pad_w};
+    std::vector<int> stride {configuration.problem_size.stride_h, configuration.problem_size.stride_w};
+    std::vector<int> dilation {configuration.problem_size.dilation_h, configuration.problem_size.dilation_w};
+
+    status = get_cutlass_status(
+      cudnnSetConvolutionNdDescriptor(
+        conv_desc,
+        op_desc.conv_dim,
+        padding.data(),
+        stride.data(),
+        dilation.data(),
+        conv_mode,
+        compute_type
+    ));
+
+    // Set groups
+    status = get_cutlass_status(cudnnSetConvolutionGroupCount(conv_desc, configuration.problem_size.groups));
+
+    // Create activation, filter, and output descriptor objects
+    status = get_cutlass_status(cudnnCreateTensorDescriptor(&activation_desc));
+    status = get_cutlass_status(cudnnCreateFilterDescriptor(&filter_desc));
+    status = get_cutlass_status(cudnnCreateTensorDescriptor(&output_desc));
+
+    // Set activation, filter, and output descriptor 
+    status = get_cutlass_status(
+      cudnnSetTensor4dDescriptor(
+        activation_desc,
+        layout_activation,
+        data_type_activation,
+        configuration.problem_size.N,
+        configuration.problem_size.C,
+        configuration.problem_size.H,
+        configuration.problem_size.W 
+    ));
+
+    status = get_cutlass_status(
+      cudnnSetFilter4dDescriptor(
+        filter_desc,
+        data_type_filter,
+        layout_filter,
+        configuration.problem_size.K,
+        configuration.problem_size.C / configuration.problem_size.groups,
+        configuration.problem_size.R,
+        configuration.problem_size.S
+    ));
+
+    status = get_cutlass_status(
+      cudnnSetTensor4dDescriptor(
+        output_desc,
+        layout_output,
+        data_type_output,
+        configuration.problem_size.N,
+        configuration.problem_size.K,
+        configuration.problem_size.P,
+        configuration.problem_size.Q
+    ));
+
+    // Set math instruction to tensor op
+    status = get_cutlass_status(
+      cudnnSetConvolutionMathType(conv_desc, math_type));
+
+    // Initialize workspace
+    switch (conv_kind) {
+      case library::ConvKind::kFprop:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionForwardWorkspaceSize(
+            handle,
+            activation_desc,
+            filter_desc,
+            conv_desc,
+            output_desc,
+            fprop_algo,
+            &workspace_size_in_bytes
+        )); break;
+      case library::ConvKind::kDgrad:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionBackwardDataWorkspaceSize(
+            handle,
+            filter_desc,
+            output_desc,
+            conv_desc,
+            activation_desc,
+            dgrad_algo,
+            &workspace_size_in_bytes
+        )); break;
+        case library::ConvKind::kWgrad:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionBackwardFilterWorkspaceSize(
+            handle,
+            activation_desc,
+            output_desc,
+            conv_desc,
+            filter_desc,
+            wgrad_algo,
+            &workspace_size_in_bytes
+        )); break;
+
+    }
+
+    workspace = cutlass::device_memory::allocation<char>(workspace_size_in_bytes);
+  }
+
+
+  // ctor for conv3d 
+  cudnnConvDispatcher( 
+    library::ConvDescription const &op_desc,
+    library::Conv3dConfiguration configuration,
+    library::ConvArguments arguments_,
+    cudnnHandle_t handle
+  ):
+    //configuration(configuration_), 
+    arguments(arguments_),
+    conv_kind(op_desc.conv_kind), 
+    status(Status::kSuccess) {
+
+    bool good = true;
+
+    // Get cudnn datatype, layout, and convolution mode from library::ConvDescription
+    good = (good && get_cudnn_datatype(data_type_activation, op_desc.A.element));
+    good = (good && get_cudnn_datatype(data_type_filter, op_desc.B.element));
+    good = (good && get_cudnn_datatype(data_type_output, op_desc.C.element));
+
+    good = (good && get_cudnn_layout(layout_activation, op_desc.A.layout));
+    good = (good && get_cudnn_layout(layout_filter, op_desc.B.layout));
+    good = (good && get_cudnn_layout(layout_output, op_desc.C.layout));
+
+    good = (good && get_cudnn_conv_mode(conv_mode, configuration.problem_size.mode));
+    
+    // cudnn compute type seems to be hardcoded to float (to handle a possible a cudnn issue)
+    alpha = cast_cudnn_compute_type_to_float(op_desc.element_epilogue, arguments.alpha);
+    beta = cast_cudnn_compute_type_to_float(op_desc.element_epilogue, arguments.beta);
+
+    good = (good && get_cudnn_datatype(
+      compute_type, 
+      op_desc.tile_description.math_instruction.element_accumulator));
+
+    // Check cutlass Conv2d description has equivalent operator in cudnn
+    if (!good) {
+      status = Status::kErrorNotSupported;
+    }
+
+    // Create convolution descriptor object
+    status = get_cutlass_status(cudnnCreateConvolutionDescriptor(&conv_desc));
+
+    // Configure convolution operator
+    std::vector<int> padding {configuration.problem_size.pad_d, configuration.problem_size.pad_h, configuration.problem_size.pad_w};
+    std::vector<int> stride {configuration.problem_size.stride_d, configuration.problem_size.stride_h, configuration.problem_size.stride_w};
+    std::vector<int> dilation {configuration.problem_size.dilation_d, configuration.problem_size.dilation_h, configuration.problem_size.dilation_w};
+
+    status = get_cutlass_status(
+      cudnnSetConvolutionNdDescriptor(
+        conv_desc,
+        op_desc.conv_dim,
+        padding.data(),
+        stride.data(),
+        dilation.data(),
+        conv_mode,
+        compute_type
+    ));
+
+    // Set groups
+    status = get_cutlass_status(cudnnSetConvolutionGroupCount(conv_desc, configuration.problem_size.groups));
+
+    // Create activation, filter, and output descriptor objects
+    status = get_cutlass_status(cudnnCreateTensorDescriptor(&activation_desc));
+    status = get_cutlass_status(cudnnCreateFilterDescriptor(&filter_desc));
+    status = get_cutlass_status(cudnnCreateTensorDescriptor(&output_desc));
+
+    // Set activation descriptor 
+    std::vector<int> activation_extent {
+      configuration.problem_size.N,
+      configuration.problem_size.C,
+      configuration.problem_size.D,
+      configuration.problem_size.H,
+      configuration.problem_size.W
+    };
+
+    std::vector<int> activation_stride {
+      configuration.layout_activations.stride()[3],
+      1,
+      configuration.layout_activations.stride()[2],
+      configuration.layout_activations.stride()[1],
+      configuration.layout_activations.stride()[0]
+    };
+
+    status = get_cutlass_status(
+      cudnnSetTensorNdDescriptor(
+        activation_desc,
+        data_type_activation,
+        op_desc.conv_dim + 2,
+        activation_extent.data(),
+        activation_stride.data()        
+    ));
+
+    // Set filter descriptor
+    std::vector<int> filter_extent {
+      configuration.problem_size.K,
+      configuration.problem_size.C,
+      configuration.problem_size.T,
+      configuration.problem_size.R,
+      configuration.problem_size.S
+    };
+
+    std::vector<int> filter_stride {
+      configuration.layout_filters.stride()[3],
+      1,
+      configuration.layout_filters.stride()[2],
+      configuration.layout_filters.stride()[1],
+      configuration.layout_filters.stride()[0]
+    };
+
+    status = get_cutlass_status(
+      cudnnSetFilterNdDescriptor(
+        filter_desc,
+        data_type_filter,
+        layout_filter,
+        op_desc.conv_dim + 2,
+        filter_extent.data() 
+    ));
+
+
+    // Set output descriptor
+    std::vector<int> output_extent {
+      configuration.problem_size.N,
+      configuration.problem_size.K,
+      configuration.problem_size.Z,
+      configuration.problem_size.P,
+      configuration.problem_size.Q
+    };
+
+    std::vector<int> output_stride {
+      configuration.layout_output.stride()[3],
+      1,
+      configuration.layout_output.stride()[2],
+      configuration.layout_output.stride()[1],
+      configuration.layout_output.stride()[0]
+    };
+
+    status = get_cutlass_status(
+      cudnnSetTensorNdDescriptor(
+        output_desc,
+        data_type_output,
+        op_desc.conv_dim + 2,
+        output_extent.data(),
+        output_stride.data() 
+    ));
+
+    // Set math instruction to tensor op
+    status = get_cutlass_status(
+      cudnnSetConvolutionMathType(conv_desc, math_type));
+
+    // Initialize workspace
+    switch (conv_kind) {
+      case library::ConvKind::kFprop:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionForwardWorkspaceSize(
+            handle,
+            activation_desc,
+            filter_desc,
+            conv_desc,
+            output_desc,
+            fprop_algo,
+            &workspace_size_in_bytes
+        )); break;
+      case library::ConvKind::kDgrad:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionBackwardDataWorkspaceSize(
+            handle,
+            filter_desc,
+            output_desc,
+            conv_desc,
+            activation_desc,
+            dgrad_algo,
+            &workspace_size_in_bytes
+        )); break;
+        case library::ConvKind::kWgrad:
+        status =  get_cutlass_status(
+          cudnnGetConvolutionBackwardFilterWorkspaceSize(
+            handle,
+            activation_desc,
+            output_desc,
+            conv_desc,
+            filter_desc,
+            wgrad_algo,
+            &workspace_size_in_bytes
+        )); break;
+
+    }
+
+    workspace = cutlass::device_memory::allocation<char>(workspace_size_in_bytes);
+  }
+
+  /// Executes Conv2d operator from cudnn library
+  cudnnStatus_t operator()(cudnnHandle_t handle) {
+
+    switch (conv_kind) {
+      case library::ConvKind::kFprop:
+        return cudnnConvolutionForward(
+          handle,
+          &alpha,
+          activation_desc,
+          activation(),
+          filter_desc,
+          filter(),
+          conv_desc,
+          fprop_algo,
+          workspace.get(),
+          workspace_size_in_bytes,
+          &beta,
+          output_desc,
+          arguments.D
+        );
+      case library::ConvKind::kDgrad:
+        return cudnnConvolutionBackwardData(
+          handle,
+          &alpha,
+          filter_desc,
+          filter(),
+          output_desc,
+          output(),
+          conv_desc,
+          dgrad_algo,
+          workspace.get(),
+          workspace_size_in_bytes,
+          &beta,
+          activation_desc,
+          arguments.D
+        );
+      case library::ConvKind::kWgrad:
+        return cudnnConvolutionBackwardFilter(
+          handle,
+          &alpha,
+          activation_desc,
+          activation(),
+          output_desc,
+          output(),
+          conv_desc,
+          wgrad_algo,
+          workspace.get(),
+          workspace_size_in_bytes,
+          &beta,
+          filter_desc,
+          arguments.D
+        );
+      default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+    }
+  }
+
+  // Returns Activation Tensor
+  void const * activation() const {
+    switch(conv_kind) {
+      case library::ConvKind::kFprop : return arguments.A;
+      case library::ConvKind::kDgrad : return arguments.C;
+      case library::ConvKind::kWgrad : return arguments.B;
+      default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+    }
+  }
+
+  // Returns Filter Tensor
+  void const *filter() const {
+    switch(conv_kind) {
+      case library::ConvKind::kFprop : return arguments.B;
+      case library::ConvKind::kDgrad : return arguments.B;
+      case library::ConvKind::kWgrad : return arguments.C;
+      default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+    }
+  }
+
+  // Returns Output Tensor
+  void const *output() const {
+    switch(conv_kind) {
+      case library::ConvKind::kFprop : return arguments.C;
+      case library::ConvKind::kDgrad : return arguments.A;
+      case library::ConvKind::kWgrad : return arguments.A;
+      default : throw std::runtime_error("Invalid Conv Operator (fprop, dgrad, wgrad)");
+    }
+  }
+};
+
+} // namespace detail
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#endif //#if CUTLASS_ENABLE_CUDNN
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cutlass_profiler.h

@@ -0,0 +1,93 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+*/
+
+#pragma once
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+#include "cutlass/library/manifest.h"
+#include "cutlass/library/singleton.h"
+
+#include "options.h"
+#include "operation_profiler.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// CUTLASS Profiler application
+class CutlassProfiler {
+private:
+
+  //
+  // Data members
+  //
+
+  /// Performance testbench options
+  Options options_;
+
+  /// Entry points for each operation
+  OperationProfilerVector operation_profilers_;
+
+private:
+
+  /// Prints usage
+  void print_usage_(std::ostream &);
+
+  /// Prints usage
+  void print_options_(std::ostream &);
+
+  /// Enumerates all operations
+  void enumerate_();
+
+  /// Profiles all operations
+  int profile_();
+
+public:
+
+  CutlassProfiler(Options const &options);
+  ~CutlassProfiler();
+
+  /// Invokes profiling operations
+  int operator()();
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/debug.h

@@ -0,0 +1,56 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief
+*/
+
+#pragma once
+
+#include <iostream>
+
+//#define report(x) { std::cout << "\033[31m" << __FILE__ << ":" << __LINE__ << "  " << x << "\033[0m" << std::endl; }
+//#define report(x) {}
+
+// Enable/Disable Profiler debug prints
+//#define DEBUG_PROFILER 
+
+//RED    31m   // profiler prints debug messages in red
+//YELLOW 33m   // ir prints debug messages in yellow
+
+#ifndef DEBUG_PROFILER
+#define debugprof(...)
+#else
+#define debugprof(...) do { \
+          printf("\033[33m[DEBUG PROF]  %s:%d | ", __FILE__, __LINE__); \
+          printf(__VA_ARGS__); \
+          printf("\033[0m\n"); \
+      } while (0)
+#endif 

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/device_context.h

@@ -0,0 +1,136 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief
+*/
+
+#pragma once
+
+#include <map>
+#include <string>
+
+
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+
+#include "options.h"
+#include "device_allocation.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Collection of allocations on the device
+class DeviceContext {
+public:
+
+  //
+  // Type definitions
+  //
+  using AllocationMap = std::map<std::string, DeviceAllocation *>;
+
+private:
+  //
+  // Data members
+  //
+
+  /// Memory allocations that exist (owning)
+  DeviceAllocationList device_memory_;
+
+  /// Non-owning set of named allocations
+  AllocationMap allocations_;
+
+public:
+
+  /// Allocates memory of a given type, capacity (elements), and name
+  DeviceAllocation *allocate_block(
+    Options const &options,
+    std::string const &name,
+    library::NumericTypeID type,
+    size_t capacity,
+    size_t device_index);
+
+  /// Allocates memory of a given type, capacity (elements), and name
+  DeviceAllocation *allocate_tensor(
+    Options const &options,
+    std::string const &name,
+    library::NumericTypeID type,
+    library::LayoutTypeID layout_id,
+    std::vector<int> const &extent,
+    std::vector<int64_t> const &stride,
+    int batch_count,
+    size_t device_index);
+
+  /// Allocates memory of a given type, capacity (elements), and name
+  DeviceAllocation *allocate_and_initialize_tensor(
+    Options const &options,
+    std::string const &name,
+    library::NumericTypeID type,
+    library::LayoutTypeID layout_id,
+    std::vector<int> const &extent,
+    std::vector<int64_t> const &stride,
+    int batch_count,
+    int seed_shift,
+    size_t device_index);
+
+  /// Allocates memory for sparse meta data
+  DeviceAllocation *allocate_and_initialize_sparsemeta_tensor(
+    Options const &options,
+    std::string const &name,
+    library::NumericTypeID type,
+    library::LayoutTypeID layout_id,
+    library::NumericTypeID type_a,
+    std::vector<int> const &extent,
+    std::vector<int64_t> const &stride,
+    int batch_count,
+    int seed_shift,
+    size_t device_index);
+
+  /// Clears named allocations (but does not necessarily free memory)
+  void clear();
+
+  /// Frees all device memory allocations
+  void free();
+
+  /// Gets the allocation by name
+  DeviceAllocation &at(std::string const &name);
+
+  size_t size() const;
+
+  AllocationMap::iterator begin();
+  AllocationMap::iterator end();
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/enumerated_types.h

@@ -0,0 +1,169 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Provides several functions for filling tensors with data.
+*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+#include "cutlass/library/library.h"
+
+#define TRACE(x) { std::cout << __FILE__ << ":" << __LINE__ << "  " << x << std::endl; }
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+T from_string(std::string const &);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Enumerated type describing how the performance testbench evaluates kernels.
+enum class ExecutionMode {
+  kProfile,     ///< regular verification and profiling
+  kDryRun,      ///< no kernels are launched or workspaces allocated; used to assess what operators might be launched
+  kEnumerate,   ///< no kernels launched or workspaces allocated; lists all operation kind and operations
+  kTrace,       ///< executes a single device-side computation with no other kernel launches
+  kInvalid
+};
+
+/// Converts a ExecutionMode enumerant to a string
+char const *to_string(ExecutionMode mode, bool pretty = false);
+
+/// Parses a ExecutionMode enumerant from a string
+template <>
+ExecutionMode from_string<ExecutionMode>(std::string const &str);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Library algorithm mode
+enum class AlgorithmMode {
+  kMatching,            ///< compare against best matching algorithm
+  kBest,                    ///< evaluate all library algorithms and report best
+  kDefault,                 ///< use the library's default algorithm option
+  kInvalid
+};
+
+/// Converts a ExecutionMode enumerant to a string
+char const *to_string(AlgorithmMode mode, bool pretty = false);
+
+/// Parses a ExecutionMode enumerant from a string
+template <>
+AlgorithmMode from_string<AlgorithmMode>(std::string const &str);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Outcome of a performance test
+enum class Disposition {
+  kPassed,
+  kFailed,
+  kNotRun,
+  kIncorrect,
+  kNotVerified,
+  kInvalidProblem,
+  kNotSupported,
+  kInvalid
+};
+
+/// Converts a Disposition enumerant to a string
+char const *to_string(Disposition disposition, bool pretty = false);
+
+/// Parses a Disposition enumerant from a string
+template <>
+Disposition from_string<Disposition>(std::string const &str);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Indicates when to save 
+enum class SaveWorkspace {
+  kNever,
+  kIncorrect,
+  kAlways,
+  kInvalid
+};
+
+/// Converts a SaveWorkspace enumerant to a string
+char const *to_string(SaveWorkspace save_option, bool pretty = false);
+
+/// Parses a SaveWorkspace enumerant from a string
+template <>
+SaveWorkspace from_string<SaveWorkspace>(std::string const &str);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Indicates the type of kernel argument
+// ArgumentType can be both ScalarType or NumericType. Thus, enums kScalar and kNumeric
+// 1) kScalar: e.g. of a Scalar ArgumentType is u32 is a Scalar type.
+// Its c++ equivalent as "type name = initializer" is "u32 m = 32"
+// 2) kNumeric: e.g. of a Numeric ArgumentType is NumericTypeID is a Numeric type.
+// Its c++ equivalent as "type name = initializer" is "NumericTypeID numeric_type = u32"
+enum class ArgumentTypeID {
+  kScalar,
+  kInteger,
+  kTensor,
+  kBatchedTensor,
+  kStructure,
+  kEnumerated,
+  kInvalid
+};
+
+/// Converts a ArgumentTypeID enumerant to a string
+char const *to_string(ArgumentTypeID type, bool pretty = false);
+
+/// Parses a ArgumentTypeID enumerant from a string
+template <>
+ArgumentTypeID from_string<ArgumentTypeID>(std::string const &str);
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Profiler typedefs
+using ProviderVector = std::vector<library::Provider>;
+using DispositionMap = std::map<library::Provider, Disposition>;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Print vector for the report
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
+  for (size_t i = 0; i < v.size(); ++i) {
+    out << to_string(v[i], true) << (i + 1u != v.size() ? "," : "");
+  }
+  return out;
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/gemm_operation_profiler.h

@@ -0,0 +1,268 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Gemm Profiler
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/manifest.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+#include "reduction_operation_profiler.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Abstract base class for each math function
+class GemmOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct GemmProblem {
+
+    cutlass::library::GemmUniversalMode mode{library::GemmUniversalMode::kGemm};
+
+    int64_t m{16};
+    int64_t n{16};
+    int64_t k{16};
+
+    int64_t lda{0};
+    int64_t ldb{0};
+    int64_t ldc{0};
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+
+    cutlass::library::SplitKMode split_k_mode{library::SplitKMode::kNone};
+    int split_k_slices{1};
+    int batch_count{1};
+
+    cutlass::library::RasterOrder raster_order{cutlass::library::RasterOrder::kHeuristic};
+    int swizzle_size{1};
+
+    // gemm with parallel interleaved reduction
+    // gemm epilogue (alpha, beta) = (1.0, 0.0)
+    // reduction epilogue (alpha, beta) = (GemmProblem::alpha, GemmProblem::beta)
+    std::vector<uint8_t> alpha_one;
+    std::vector<uint8_t> beta_zero;
+
+    //
+    // Methods
+    //
+
+    /// Parses the problem
+    Status parse(
+      library::GemmDescription const &operation_desc,
+      ProblemSpace const &problem_space,
+      ProblemSpace::Problem const &problem);
+
+    /// Total number of bytes loaded
+    int64_t bytes(library::GemmDescription const &operation_desc) const;
+
+    /// Total number of flops computed
+    int64_t flops(library::GemmDescription const &operation_desc) const;
+
+    /// Initializes a performance result
+    void initialize_result(
+      PerformanceResult &result,
+      library::GemmDescription const &operation_desc,
+      ProblemSpace const &problem_space);
+  };
+
+  /// Workspace used
+  struct GemmWorkspace {
+
+    DeviceAllocation *A{nullptr};
+    DeviceAllocation *B{nullptr};
+    DeviceAllocation *C{nullptr};
+    DeviceAllocation *Computed{nullptr};
+    DeviceAllocation *Reference{nullptr};
+
+    /// Number of copies of the problem workspace which are visited sequentially during
+    /// profiling to avoid camping in the last level cache.
+    int problem_count{1};
+
+    library::GemmUniversalConfiguration configuration;
+    library::GemmUniversalArguments arguments;
+
+    /// Buffer used for the operation's host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the operations' device workspace
+    DeviceAllocation device_workspace;
+
+    /// Library configuration and arguments for reduction operator
+    library::ReductionConfiguration reduction_configuration;
+    library::ReductionArguments reduction_arguments;
+
+    /// Buffer used for the cutlass reduction operations' host workspace
+    std::vector<uint8_t> reduction_host_workspace;
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  /// GEMM problem obtained from problem space
+  GemmProblem problem_;
+
+  /// Device memory allocations
+  GemmWorkspace gemm_workspace_;
+
+  /// CUTLASS parallel reduction operation to follow this* gemm operation
+  library::Operation const *reduction_op_;
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  GemmOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~GemmOperationProfiler();
+
+  GemmProblem const& problem() const { return problem_; }
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,
+    library::GemmDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+
+  /// Verifies CUTLASS against references
+  bool verify_with_cublas_(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against host and device references
+  bool verify_with_reference_(
+    Options const &options,
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem,
+    cutlass::library::NumericTypeID element_A,
+    cutlass::library::NumericTypeID element_B);
+
+  /// Method to profile a CUTLASS Operation
+  Status profile_cutlass_(
+    double &runtime,
+    Options const &options,
+    library::Operation const *operation,
+    void *arguments,
+    void *host_workspace,
+    void *device_workspace);
+
+  /// Initialize reduction problem dimensions and library::Operation
+  bool initialize_reduction_configuration_(
+    library::Operation const *operation,
+    ProblemSpace::Problem const &problem);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/gpu_timer.h

@@ -0,0 +1,72 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+*/
+
+#pragma once
+
+#include <cuda_runtime.h>
+#include "cutlass/cutlass.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct GpuTimer {
+
+  cudaEvent_t events[2];
+
+  //
+  // Methods
+  //
+  
+  GpuTimer();
+  ~GpuTimer();
+
+  /// Records a start event in the stream
+  void start(cudaStream_t stream = nullptr);
+
+  /// Records a stop event in the stream
+  void stop(cudaStream_t stream = nullptr);
+
+  /// Records a stop event in the stream and synchronizes on the stream
+  void stop_and_wait(cudaStream_t stream = nullptr);
+
+  /// Returns the duration in milliseconds
+  double duration(int iterations = 1) const;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/options.h

@@ -0,0 +1,345 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Command line options for performance test program
+*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <cuda_runtime.h>
+
+#include "cutlass/util/command_line.h"
+#include "cutlass/util/distribution.h"
+#include "cutlass/library/library.h"
+
+#include "enumerated_types.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Global options
+class Options {
+public:
+
+  /// Cublas and cuDNN options
+  struct Library {
+
+    //
+    // Data members
+    //
+
+    /// Algorithm mode
+    AlgorithmMode algorithm_mode;
+
+    /// Algorithm enumerants
+    std::vector<int> algorithms;
+
+    //
+    // Methods
+    //
+
+    explicit Library(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+  };
+
+  /// Options related to the selected device
+  struct Device {
+
+    /// Device ID
+    std::vector<int> devices;
+
+    /// Number of total devices
+    /// This is not set by the user, it is set by automatically
+    int num_devices;
+
+    /// CUDA Device properties
+    std::vector<cudaDeviceProp> properties;
+
+    /// Total memory allocation on each device
+    size_t maximum_capacity;
+
+    //
+    // Methods
+    //
+
+    explicit Device(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+    void print_device_info(std::ostream &out) const;
+
+    /// Returns the device ID from a device index
+    int device_id(size_t device_index) const;
+
+    /// Returns the compute capability of the listed devices (e.g. 61, 60, 70, 75)
+    int compute_capability(int device_index) const;
+  };
+
+  /// Options related to initializing input tensors
+  struct Initialization {
+
+    /// If true, data is initialized randomly. If false, no initialization is performed after
+    /// allocating tensors.
+    bool enabled;
+
+    /// If true, data distribution is set by the user and is not allowed to change
+    /// If false, data distribution is allowed to change based on element_type (library::NumericTypeID)
+    bool fix_data_distribution;
+
+    /// Data distribution for input tensors
+    Distribution data_distribution;
+
+    /// Source of random tensor elements
+    library::Provider provider;
+
+    /// Random number generator seed.
+    int seed;
+
+    //
+    // Methods
+    //
+
+    explicit Initialization(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+
+    /// Helper to parse a Distribution object from the command line parser
+    static void get_distribution(
+      cutlass::CommandLine const &args,
+      std::string const &arg,
+      cutlass::Distribution &dist);
+  };
+
+  /// Options related to verification of the result
+  struct Verification {
+
+    //
+    // Data members
+    //
+
+    /// If true, kernels are verified before they are profiled
+    bool enabled;
+
+    /// If true, causes profiler to return an error code if no reference check is run.
+    /// Only valid when verification is enabled.
+    bool required;
+
+    /// Relative error threshold - zero to require bit-level consistency
+    double epsilon;
+
+    /// Values smaller than this are assumed to be zero
+    double nonzero_floor;
+
+    /// List of providers used to verify each result
+    ProviderVector providers;
+
+    /// Indicates when to save the workspace
+    SaveWorkspace save_workspace;
+
+    //
+    // Methods
+    //
+
+    explicit Verification(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+
+    /// Returns true if a provider is enabled
+    bool provider_enabled(library::Provider provider) const;
+
+    /// Returns the index of a provider if its enabled
+    size_t index(library::Provider provider) const;
+  };
+
+  /// Options related to profiling
+  struct Profiling {
+
+    /// Number of workspaces to rotate through to avoid cache-resident working sets
+    int workspace_count{0};
+
+    /// Number of iterations to warmup each kernel prior to profiling
+    int warmup_iterations{10};
+
+    /// Number of iterations to profile each kernel - if 0, kernels are launched up to the profiling duration
+    int iterations{100};
+
+    /// Number of ms to sleep between profiling periods (ms)
+    int sleep_duration{50};
+
+    /// If true, profiling is actually conducted.
+    bool enabled{true};
+
+    /// If true, profiling returns an error code if no kernels are found to match the filters.
+    bool error_on_no_match{false};
+
+    /// If true, profiling returns an error code if no kernel are profiled
+    // Sometimes the kernel matches but failed to profile (e.g. can_implement() error)
+    bool error_if_nothing_is_profiled{false};
+
+    /// List of providers of each functionality to be profiled
+    ProviderVector providers;
+
+    //
+    // Methods
+    //
+
+    explicit Profiling(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+
+    /// Returns true if a provider is enabled
+    bool provider_enabled(library::Provider provider) const;
+
+    /// Returns the index of a provider if its enabled
+    size_t index(library::Provider provider) const;
+  };
+
+  /// Options related to reporting
+  struct Report {
+
+    /// If true, result is appended to possibly existing file
+    bool append;
+
+    /// Path to a file containing results
+    std::string output_path;
+
+    /// Path to a file containing junit xml results
+    std::string junit_output_path;
+
+    /// Sequence of tags to attach to each result
+    std::vector<std::pair<std::string, std::string>> pivot_tags;
+
+    /// If true, reports status of all kernels including those that were
+    /// not run for the given arguments
+    bool report_not_run;
+
+    /// Prints human-readable text to stdout. If false, nothing is written to stdout
+    bool verbose;
+
+    /// Sort results by (currently by flops-per-byte)
+    bool sort_results;
+
+    /// Prints the name of the kernel being profiled before running the kernel.
+    /// This is useful for determining which kernel is causing a run of the profiler to hang
+    bool print_kernel_before_running;
+
+    //
+    // Methods
+    //
+
+    explicit Report(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+  };
+
+  /// Options related to printing usage and version information
+  struct About {
+
+    /// If true, usage is printed and the program ends.
+    bool help;
+
+    /// Prints version string
+    bool version;
+
+    /// Print information about devices
+    bool device_info;
+
+    //
+    // Methods
+    //
+
+    explicit About(CommandLine const &cmdline);
+
+    void print_usage(std::ostream &out) const;
+    void print_options(std::ostream &out, int indent = 0) const;
+
+    static void print_version(std::ostream &out);
+  };
+
+public:
+
+  //
+  // Data members
+  //
+
+  /// Top-level execution mode
+  ExecutionMode execution_mode;
+
+  /// Name of math function to profile
+  library::OperationKind operation_kind;
+
+  /// Vector of operation name substrings
+  std::vector<std::string> operation_names;
+
+  /// Vector of operation name substrings
+  std::vector<std::string> excluded_operation_names;
+
+
+  //
+  // Detailed configuration options
+  //
+
+  /// Configuration
+  CommandLine cmdline;
+  Device device;
+  Initialization initialization;
+  Library library;
+  Verification verification;
+  Profiling profiling;
+  Report report;
+  About about;
+
+public:
+
+  explicit Options(CommandLine const &cmdline);
+
+  void print_usage(std::ostream &out) const;
+  void print_options(std::ostream &out) const;
+
+  static std::string indent_str(int indent);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/performance_report.h

@@ -0,0 +1,127 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Class performing output during profiling
+*/
+
+#pragma once
+
+#include <vector>
+#include <fstream>
+
+// CUTLASS Profiler includes
+#include "options.h"
+#include "enumerated_types.h"
+#include "performance_result.h"
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+class PerformanceReport {
+private:
+
+  /// Reference to options
+  Options const &options_;
+
+  /// Operation kind
+  library::OperationKind op_kind_;
+
+  /// Operation file name containing performance report of op_kind
+  std::string op_file_name_;
+
+  /// Output file containing results
+  std::ofstream output_file_;
+
+  /// Operation file name containing junit performance report of op_kind
+  std::string op_junit_file_name_;
+
+  /// Output file containing junit results
+  std::ofstream junit_output_file_;
+
+  /// Flag indicating the performance report is valid
+  bool good_;
+
+  /// Vector of argument names
+  std::vector<std::string> argument_names_;
+
+  /// Counter uniquely identifying problem within the report
+  size_t problem_index_;
+
+  /// Collection of all results
+  PerformanceResultVector concatenated_results_;
+
+public:
+
+  PerformanceReport(Options const &options, std::vector<std::string> const &argument_names, library::OperationKind const &op_kind);
+  ~PerformanceReport();
+
+  bool good() const { return good_; }
+
+  void next_problem();
+  void append_result(PerformanceResult result);
+  void sort_results(PerformanceResultVector &results);
+  void append_results(PerformanceResultVector const &results);
+
+public:
+
+  /// Prints the CSV header
+  std::ostream & print_csv_header_(std::ostream &out);
+
+  /// Prints the CSV
+  std::ostream & print_result_csv_(std::ostream &out, PerformanceResult const &result);
+
+  /// @defgroup jUnit Result Generation
+  /// Functions related to generation of the jUnit results
+  /// @{
+
+  std::ostream & print_junit_header_(std::ostream &out);
+  std::ostream & print_junit_result_(std::ostream &out, PerformanceResult const &result);
+  std::ostream & print_junit_footer_(std::ostream &out);
+
+  /// @}
+
+  /// Prints the result in human readable form
+  std::ostream & print_result_pretty_(
+    std::ostream &out, 
+    PerformanceResult const &result,
+    bool use_shell_coloring = true);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/performance_result.h

@@ -0,0 +1,128 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "cutlass/cutlass.h"
+
+// CUTLASS Profiler includes
+#include "enumerated_types.h"
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Performance result object
+struct PerformanceResult {
+
+  /// Index of problem
+  size_t problem_index;
+
+  /// library::Provider
+  library::Provider provider;
+
+  /// Operation kind
+  library::OperationKind op_kind;
+
+  /// CUTLASS status result from kernels (success or failure)
+  // Status does information on verification
+  Status status;
+
+  /// Outcome of verification (worst case verification result)
+  Disposition disposition;
+  
+  /// Outcome of verification (all verification results)
+  DispositionMap verification_map;
+
+  /// Operation name
+  std::string operation_name;
+
+  /// Stringified vector of argument values
+  std::vector<std::pair<std::string, std::string> > arguments;
+
+  /// Number of bytes read or written
+  int64_t bytes;
+
+  /// Number of DL flops performed by the math function
+  int64_t flops;
+
+  /// Average runtime in ms
+  double runtime;
+
+  //
+  // Members
+  //
+
+  /// Ctor
+  PerformanceResult(): 
+    problem_index(0),
+    op_kind(library::OperationKind::kInvalid),
+    provider(library::Provider::kInvalid), 
+    disposition(Disposition::kNotRun),
+    status(Status::kInvalid),
+    bytes(0), 
+    flops(0), 
+    runtime(0)
+  { }
+
+  /// Returns true if the runtime is valid
+  bool good() const {
+    return runtime > 0;
+  }
+
+  /// Math throughput in units of GFLOP/s
+  double gflops_per_sec() const {
+    return double(flops) / runtime / 1.0e6;
+  }
+
+  /// memory bandwidth in units of GiB/s
+  double gbytes_per_sec() const {
+    return double(bytes) / double(1 << 30) / runtime * 1000.0;
+  }
+
+};
+
+using PerformanceResultVector = std::vector<PerformanceResult>;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/rank_2k_operation_profiler.h

@@ -0,0 +1,229 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+
+  
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/blas3.h"
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/manifest.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+/// Abstract base class for each math function
+class Rank2KOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct RankKProblem {
+    int64_t n;
+    int64_t k;
+    int64_t lda;
+    int64_t ldb;
+    int64_t ldc;
+    FillMode fill_mode;
+    BlasMode blas_mode;
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+    int64_t split_k_slices;
+    int64_t batch_count;
+
+    //
+    // Methods
+    //
+
+    RankKProblem(): 
+      n(16), k(16), lda(0), ldc(0), 
+      fill_mode(FillMode::kInvalid), blas_mode(BlasMode::kInvalid), 
+      split_k_slices(1), batch_count(1) { }
+
+    /// Parses the problem
+    Status parse(
+      library::RankKDescription const &operation_desc,
+      ProblemSpace const &problem_space,
+      ProblemSpace::Problem const &problem);
+
+    /// Total number of bytes loaded
+    int64_t bytes(library::RankKDescription const &operation_desc) const;
+
+    /// Total number of flops computed
+    int64_t flops(library::RankKDescription const &operation_desc) const;
+    
+    /// Initializes a performance result
+    void initialize_result(
+      PerformanceResult &result,
+      library::RankKDescription const &operation_desc,
+      ProblemSpace const &problem_space);
+  };
+
+  /// Workspace used 
+  struct RankKWorkspace {
+
+    DeviceAllocation *A;
+    DeviceAllocation *B;
+    DeviceAllocation *C;
+    DeviceAllocation *Computed;
+    DeviceAllocation *Reference;
+
+    library::RankKConfiguration configuration;
+    library::RankKArguments arguments;
+
+    /// Buffer used for the operation's host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the operations' device workspace
+    DeviceAllocation device_workspace;
+
+    //
+    // Methods
+    //
+
+    RankKWorkspace(): 
+      A(nullptr), B(nullptr), C(nullptr), Computed(nullptr), Reference(nullptr) { }
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  /// GEMM problem obtained from problem space
+  RankKProblem problem_;
+
+  /// Device memory allocations 
+  RankKWorkspace rank_k_workspace_;
+
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  Rank2KOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~Rank2KOperationProfiler();
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,  
+    library::RankKDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+
+  /// Verifies CUTLASS against references
+  bool verify_with_cublas_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/rank_k_operation_profiler.h

@@ -0,0 +1,227 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+
+  
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/blas3.h"
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/manifest.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+/// Abstract base class for each math function
+class RankKOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct RankKProblem {
+    int64_t n;
+    int64_t k;
+    int64_t lda;
+    int64_t ldc;
+    FillMode fill_mode;
+    BlasMode blas_mode;
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+    int64_t split_k_slices;
+    int64_t batch_count;
+
+    //
+    // Methods
+    //
+
+    RankKProblem(): 
+      n(16), k(16), lda(0), ldc(0), 
+      fill_mode(FillMode::kInvalid), blas_mode(BlasMode::kInvalid), 
+      split_k_slices(1), batch_count(1) { }
+
+    /// Parses the problem
+    Status parse(
+      library::RankKDescription const &operation_desc,
+      ProblemSpace const &problem_space,
+      ProblemSpace::Problem const &problem);
+
+    /// Total number of bytes loaded
+    int64_t bytes(library::RankKDescription const &operation_desc) const;
+
+    /// Total number of flops computed
+    int64_t flops(library::RankKDescription const &operation_desc) const;
+
+    /// Initializes a performance result
+    void initialize_result(
+      PerformanceResult &result,
+      library::RankKDescription const &operation_desc,
+      ProblemSpace const &problem_space);
+  };
+
+  /// Workspace used 
+  struct RankKWorkspace {
+
+    DeviceAllocation *A;
+    DeviceAllocation *C;
+    DeviceAllocation *Computed;
+    DeviceAllocation *Reference;
+
+    library::RankKConfiguration configuration;
+    library::RankKArguments arguments;
+
+    /// Buffer used for the operation's host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the operations' device workspace
+    DeviceAllocation device_workspace;
+
+    //
+    // Methods
+    //
+
+    RankKWorkspace(): 
+      A(nullptr), C(nullptr), Computed(nullptr), Reference(nullptr) { }
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  /// GEMM problem obtained from problem space
+  RankKProblem problem_;
+
+  /// Device memory allocations 
+  RankKWorkspace rank_k_workspace_;
+
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  RankKOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~RankKOperationProfiler();
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,  
+    library::RankKDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+
+  /// Verifies CUTLASS against references
+  bool verify_with_cublas_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/sparse_gemm_operation_profiler.h

@@ -0,0 +1,214 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief 
+
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/manifest.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+#include "gemm_operation_profiler.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Abstract base class for each math function
+class SparseGemmOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct SparseGemmProblem {
+    int64_t m;
+    int64_t n;
+    int64_t k;
+    int64_t lda;
+    int64_t ldb;
+    int64_t ldc;
+    int64_t lde;
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+    int64_t split_k_slices;
+    int64_t batch_count;
+    static int const sparse = 2;
+    // every 128b ElementA uses one elementE
+    int elements_per_128b;    
+
+    //
+    // Methods
+    //
+
+    SparseGemmProblem(): 
+      m(16), n(16), k(16), lda(0), ldb(0), ldc(0), lde(0), split_k_slices(1), batch_count(1) { }
+
+    /// Parses the problem
+    Status parse(
+      library::SparseGemmDescription const &operation_desc,
+      ProblemSpace const &problem_space,
+      ProblemSpace::Problem const &problem);
+
+    /// Initializes a performance result
+    void initialize_result(
+      PerformanceResult &result,
+      library::SparseGemmDescription const &operation_desc,
+      ProblemSpace const &problem_space);
+  };
+
+  /// Workspace used 
+  struct SparseGemmWorkspace {
+
+    DeviceAllocation *A;
+    DeviceAllocation *B;
+    DeviceAllocation *C;
+    DeviceAllocation *E;
+    DeviceAllocation *Computed;
+    DeviceAllocation *Reference;
+    
+    library::SparseGemmConfiguration configuration;
+    library::SparseGemmArguments arguments;
+
+    /// Buffer used for the operation's host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the operations' device workspace
+    DeviceAllocation device_workspace;
+
+    //
+    // Methods
+    //
+
+    SparseGemmWorkspace(): 
+      A(nullptr), B(nullptr), C(nullptr), E(nullptr), Computed(nullptr), Reference(nullptr) { }
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  // GEMM problem
+  SparseGemmProblem problem_;
+
+  /// Device memory allocations 
+  SparseGemmWorkspace gemm_workspace_;
+
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  SparseGemmOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~SparseGemmOperationProfiler();
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,  
+    library::SparseGemmDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/trmm_operation_profiler.h

@@ -0,0 +1,222 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+
+  
+*/
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <algorithm>
+#include <unordered_map>
+
+// CUTLASS Library includes
+#include "cutlass/blas3.h"
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+#include "cutlass/library/manifest.h"
+
+// Profiler includes
+#include "options.h"
+#include "device_context.h"
+#include "operation_profiler.h"
+#include "performance_result.h"
+#include "problem_space.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Abstract base class for each math function
+class TrmmOperationProfiler : public OperationProfiler {
+public:
+
+  /// Problem structure obtained from problem space
+  struct TrmmProblem {
+    int64_t m;
+    int64_t n;
+    int64_t lda;
+    int64_t ldb;
+    int64_t ldd;
+    SideMode side_mode;
+    FillMode fill_mode;
+    DiagType diag_type;
+    std::vector<uint8_t> alpha;
+    std::vector<uint8_t> beta;
+    int64_t split_k_slices;
+    int64_t batch_count;
+
+    //
+    // Methods
+    //
+
+    TrmmProblem(): 
+      m(16), n(16), lda(0), ldb(0),  ldd(0), split_k_slices(1), batch_count(1) { }
+
+    /// Parses the problem
+    Status parse(
+      library::TrmmDescription const &operation_desc,
+      ProblemSpace const &problem_space,
+      ProblemSpace::Problem const &problem);
+
+    /// Initializes a performance result
+    void initialize_result(
+      PerformanceResult &result,
+      library::TrmmDescription const &operation_desc,
+      ProblemSpace const &problem_space);
+  };
+
+  /// Workspace used 
+  struct TrmmWorkspace {
+
+    DeviceAllocation *A;
+    DeviceAllocation *B;
+    DeviceAllocation *D;
+    DeviceAllocation *Computed;
+    DeviceAllocation *Reference;
+
+    library::TrmmConfiguration configuration;
+    library::TrmmArguments arguments;
+
+    /// Buffer used for the operation's host workspace
+    std::vector<uint8_t> host_workspace;
+
+    /// Buffer used for the operations' device workspace
+    DeviceAllocation device_workspace;
+
+    //
+    // Methods
+    //
+
+    TrmmWorkspace(): 
+      A(nullptr), B(nullptr), D(nullptr), Computed(nullptr), Reference(nullptr) { }
+  };
+
+protected:
+
+  //
+  // Data members
+  //
+
+  /// GEMM problem obtained from problem space
+  TrmmProblem problem_;
+
+  /// Device memory allocations 
+  TrmmWorkspace trmm_workspace_;
+
+
+public:
+  //
+  // Methods
+  //
+
+  /// Ctor
+  TrmmOperationProfiler(Options const &options);
+
+  /// Destructor
+  virtual ~TrmmOperationProfiler();
+
+  /// Prints usage statement for the math function
+  virtual void print_usage(std::ostream &out) const;
+
+  /// Prints examples
+  virtual void print_examples(std::ostream &out) const;
+
+  /// Extracts the problem dimensions
+  virtual Status initialize_configuration(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Initializes workspace
+  virtual Status initialize_workspace(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Verifies CUTLASS against references
+  virtual bool verify_cutlass(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+  /// Measures performance results
+  virtual bool profile(
+    Options const &options, 
+    PerformanceReport &report, 
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+protected:
+
+  /// Initializes the performance result
+  void initialize_result_(
+    PerformanceResult &result,
+    Options const &options,  
+    library::TrmmDescription const &operation_desc,
+    ProblemSpace const &problem_space);
+
+  /// Verifies CUTLASS against references
+  bool verify_with_cublas_(
+    Options const &options,  
+    PerformanceReport &report,
+    DeviceContext &device_context,
+    library::Operation const *operation,
+    ProblemSpace const &problem_space,
+    ProblemSpace::Problem const &problem);
+
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/conv2d_operation_profiler.cu

@@ -0,0 +1,1510 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Convolution 2D profiling
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/core_io.h"
+
+#include "cutlass/profiler/conv2d_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+/////////////////////////////////////////////////////////////////////////////////////////////////
+using namespace cutlass::library;
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+Conv2dOperationProfiler::Conv2dOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kConv2d,
+    {
+      {ArgumentTypeID::kEnumerated, {"conv_kind"}, "Convolutional operator (fprop, dgrad, wgrad)"},
+      {ArgumentTypeID::kInteger, {"n", "input_n"}, "Input N dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"h", "input_h"}, "Input H dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"w", "input_w"}, "Input W dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"c", "input_c"}, "Input C dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"k", "filter_k"}, "Filter K dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"r", "filter_r"}, "Filter R dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"s", "filter_s"}, "Filter S dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"p", "output_p"}, "Output P dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"q", "output_q"}, "Output Q dimension of the Conv2d problem space"},
+      {ArgumentTypeID::kInteger, {"g", "groups"}, "Number of convolution groups"},
+      {ArgumentTypeID::kInteger, {"pad_h"}, "Padding in H direction"},
+      {ArgumentTypeID::kInteger, {"pad_w"}, "Padding in W direction"},
+      {ArgumentTypeID::kInteger, {"stride_h"}, "Stride in H direction"},
+      {ArgumentTypeID::kInteger, {"stride_w"}, "Stride in W direction"},
+      {ArgumentTypeID::kInteger, {"dilation_h"}, "Dilation in H direction"},
+      {ArgumentTypeID::kInteger, {"dilation_w"}, "Dilation in W direction"},
+      {ArgumentTypeID::kTensor, {"Activation"}, "Tensor storing the Activation operand"},
+      {ArgumentTypeID::kTensor, {"Filter"}, "Tensor storing the Filter operand"},
+      {ArgumentTypeID::kTensor, {"Output"}, "Tensor storing the Output operand"},
+      {ArgumentTypeID::kEnumerated, {"conv_mode"}, "Convolution filter mode (conv, cross)"},
+      {ArgumentTypeID::kEnumerated, {"iterator_algorithm", "iterator_algo"}, "Convolution iterator algorithm (analytic, optimized)"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kEnumerated, {"split_k_mode", "split-k-mode"}, "SplitK mode for serial or parallel reduction (serial, parallel)"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kEnumerated, {"eq_gemm_provider", "eq-gemm-provider"}, "Enable profiling equivalent gemm by the following providers (cutlass)"},
+    },
+    { library::Provider::kReferenceDevice, library::Provider::kReferenceHost, library::Provider::kCUDNN }
+  ) {
+
+  description_ = "      Conv2d operation. Output(Tensor4D) = alpha * Input(Tensor4D) * Filter(Tensor4D) + beta * Input(Tensor4D)";
+
+}
+
+/// Destructor
+Conv2dOperationProfiler::~Conv2dOperationProfiler() {
+
+}
+
+
+/// Prints usage statement for the math function
+void Conv2dOperationProfiler::print_usage(std::ostream &out) const {
+  out << "Conv2d" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void Conv2dOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+      << "Profile a particular convolution (specify all the convolution parameters):\n"
+      << " $ cutlass_profiler --operation=Conv2d"
+            " --Activation=f16:nhwc --Filter=f16:nhwc --Output=f16 --accumulator-type=f32"
+            " --n=32 --h=14 --w=14 --c=8 --k=64 --r=3 --s=3"
+            " --pad_h=1 --pad_w=1"
+            " --stride_h=1 --stride_w=1"
+            " --dilation_h=1 --dilation_w=1\n\n";
+}
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Total number of bytes loaded
+int64_t Conv2dOperationProfiler::Conv2dProblem::bytes(
+  library::ConvDescription const &operation_desc) const {
+
+  cutlass::gemm::GemmCoord mnk = eq_gemm_size(operation_desc.conv_kind);
+
+ // Input bytes read and Output bytes written for the gemm problem
+  int64_t bytes_ =
+    int64_t(library::sizeof_bits(operation_desc.A.element) * mnk.m() / 8) * mnk.k() +
+    int64_t(library::sizeof_bits(operation_desc.B.element) * mnk.n() / 8) * mnk.k() +
+    int64_t(library::sizeof_bits(operation_desc.C.element) * mnk.m() / 8) * mnk.n();
+
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(beta.begin(), beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    bytes_ += int64_t(library::sizeof_bits(operation_desc.C.element) * mnk.m() / 8) * mnk.n();
+  }
+
+  return bytes_;
+}
+
+/// Total number of flops computed
+int64_t Conv2dOperationProfiler::Conv2dProblem::flops(
+  library::ConvDescription const &operation_desc) const {
+
+  cutlass::gemm::GemmCoord mnk = eq_gemm_size(operation_desc.conv_kind);
+
+  int64_t flops_mainloop_ = int64_t(mnk.m()) * mnk.n() * mnk.k() * 2;
+  int64_t flops_epilogue_ = int64_t(mnk.m()) * int64_t(mnk.n()) * 2;
+
+  // Adjust mainloop flop for dgrad strided
+  if (operation_desc.conv_kind == library::ConvKind::kDgrad) {
+    flops_mainloop_ = flops_mainloop_ / (stride_h * stride_w);
+  }
+  int64_t flops_total_ = flops_mainloop_ + flops_epilogue_;
+
+  //complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    flops_total_ *=4;
+    break;
+
+  default: break;
+  }
+
+  return flops_total_;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status Conv2dOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::ConvDescription const &operation_desc =
+    static_cast<library::ConvDescription const &>(operation->description());
+
+  if (!arg_as_int(problem_.n, "n", problem_space, problem)) {
+    // default value
+    problem_.n = 1;
+  }
+
+  if (!arg_as_int(problem_.h, "h", problem_space, problem)) {
+    // default value
+    problem_.h = 16;
+  }
+
+  if (!arg_as_int(problem_.w, "w", problem_space, problem)) {
+    // default value
+    problem_.w = 16;
+  }
+
+  if (!arg_as_int(problem_.c, "c", problem_space, problem)) {
+    // default value
+    problem_.c = 64;
+  }
+
+  if (!arg_as_int(problem_.k, "k", problem_space, problem)) {
+    // default value
+    problem_.k = 64;
+  }
+
+  if (!arg_as_int(problem_.r, "r", problem_space, problem)) {
+    // default value
+    problem_.r = 3;
+  }
+
+  if (!arg_as_int(problem_.s, "s", problem_space, problem)) {
+    // default value
+    problem_.s = 3;
+  }
+
+  if (!arg_as_int(problem_.groups, "g", problem_space, problem)) {
+    // default value
+    problem_.groups = 1;
+  }
+
+  if (!arg_as_int(problem_.pad_h, "pad_h", problem_space, problem)) {
+    // default value
+    problem_.pad_h = 1;
+  }
+
+  if (!arg_as_int(problem_.pad_w, "pad_w", problem_space, problem)) {
+    // default value
+    problem_.pad_w = 1;
+  }
+
+  if (!arg_as_int(problem_.stride_h, "stride_h", problem_space, problem)) {
+    // default value
+    problem_.stride_h = 1;
+  }
+
+  if (!arg_as_int(problem_.stride_w, "stride_w", problem_space, problem)) {
+    // default value
+    problem_.stride_w = 1;
+  }
+
+  if (!arg_as_int(problem_.dilation_h, "dilation_h", problem_space, problem)) {
+    // default value
+    problem_.dilation_h = 1;
+  }
+
+  if (!arg_as_int(problem_.dilation_w, "dilation_w", problem_space, problem)) {
+    // default value
+    problem_.dilation_w = 1;
+  }
+
+  ////////////////////////  Convolution output dimensions p and q ////////////////////////
+  // Cutlass convolutions support arbitrary output sizes and not constrained by         //
+  // input, filter, padding, striding, dilation sizes.                                  //
+  // cuDNN sets the output dimensions (p, q)  using following equations:                //
+  //                                                                                    //
+  // output = div_up(input + 2 * pad - ((filter - 1) * dilation + 1) + 1, stride)       //
+  // where; div_up(a, b) : (a - 1)/b + 1                                                //
+  //                                                                                    //
+  // Thus, when output p and q dimensions are unspecified by the user                   //
+  // cutlass profiler sets p and q which are cuDNN compliant.                           //
+  //                                                                                    //
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // set convolution output p
+  if (!arg_as_int(problem_.p, "p", problem_space, problem)) {
+    // default value (set using cudnn formula for output height, when p is not provided)
+    problem_.p = (
+                    problem_.h +
+                    2 * problem_.pad_h -
+                    ((problem_.r - 1) * problem_.dilation_h + 1)
+                 ) / (problem_.stride_h)
+                + 1;
+  }
+
+  // set convolution output q
+  if (!arg_as_int(problem_.q, "q", problem_space, problem)) {
+    // default value (set using cudnn formula for output width, when q is not provided)
+    problem_.q = (
+                    problem_.w +
+                    2 * problem_.pad_w -
+                    ((problem_.s - 1) * problem_.dilation_w + 1)
+                 ) / (problem_.stride_w)
+                + 1;
+  }
+  /////////////////////////////////////////////////////////////////////////////////////////
+
+
+  if (!arg_as_SplitKModeID(problem_.split_k_mode, "split_k_mode", problem_space, problem)) {
+    // default value
+    problem_.split_k_mode = library::SplitKMode::kSerial;
+  }
+
+  if (!arg_as_int(problem_.split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    problem_.split_k_slices = 1;
+  }
+
+  if (!arg_as_ConvModeID(problem_.conv_mode, "conv_mode", problem_space, problem)) {
+    // default value
+    problem_.conv_mode = library::ConvModeID::kCrossCorrelation;
+  }
+
+  if (!arg_as_ProviderID(problem_.eq_gemm_provider, "eq_gemm_provider", problem_space, problem)) {
+    // default value
+    problem_.eq_gemm_provider = library::Provider::kNone;
+  }
+
+  if (!conv_kind_satisfies(operation_desc.conv_kind, "conv_kind", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!iterator_algorithm_satisfies(operation_desc.iterator_algorithm, "iterator_algorithm", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.activation(), "Activation", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.filter(), "Filter", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.output(), "Output", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    problem_.alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(problem_.alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    problem_.beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(problem_.beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  // initialize library::Conv2dConfiguration
+  conv_workspace_.configuration.problem_size = conv::Conv2dProblemSize(
+                                                int(problem_.n),
+                                                int(problem_.h),
+                                                int(problem_.w),
+                                                int(problem_.c),
+                                                int(problem_.k),
+                                                int(problem_.r),
+                                                int(problem_.s),
+                                                int(problem_.p),
+                                                int(problem_.q),
+                                                int(problem_.pad_h),
+                                                int(problem_.pad_w),
+                                                int(problem_.stride_h),
+                                                int(problem_.stride_w),
+                                                int(problem_.dilation_h),
+                                                int(problem_.dilation_w),
+                                                static_cast<conv::Mode>(static_cast<int>(problem_.conv_mode)),
+                                                int(problem_.split_k_slices),
+                                                int(problem_.groups)
+                                              );
+
+  conv_workspace_.configuration.split_k_mode = static_cast<conv::SplitKMode>(static_cast<int>(problem_.split_k_mode));
+
+  conv_workspace_.set_stride_vector(
+      problem_, operation_desc.conv_kind, operation_desc.A.layout,
+      operation_desc.B.layout, operation_desc.C.layout);
+
+  // initialize library::ConvArguments
+  conv_workspace_.arguments.A            = nullptr;
+  conv_workspace_.arguments.B            = nullptr;
+  conv_workspace_.arguments.C            = nullptr;
+  conv_workspace_.arguments.D            = nullptr;
+  conv_workspace_.arguments.alpha        = problem_.alpha.data();
+  conv_workspace_.arguments.beta         = problem_.beta.data();
+  conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  // initialize reduction operation for parallel splitKMode
+  if(conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+    if(!initialize_reduction_configuration_(options, report, device_context, operation, problem_space, problem)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&conv_workspace_.configuration, &conv_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void Conv2dOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::ConvDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "Activation", problem_space,
+    std::string(library::to_string(operation_desc.activation().element))
+    + ":" + library::to_string(operation_desc.activation().layout));
+
+  set_argument(result, "Filter", problem_space,
+    std::string(library::to_string(operation_desc.filter().element))
+    + ":" + library::to_string(operation_desc.filter().layout));
+
+  set_argument(result, "Output", problem_space,
+    std::string(library::to_string(operation_desc.output().element))
+    + ":" + library::to_string(operation_desc.output().layout));
+
+  set_argument(result, "conv_kind", problem_space, library::to_string(operation_desc.conv_kind));
+
+  set_argument(result, "iterator_algorithm", problem_space, std::string(library::to_string(operation_desc.iterator_algorithm)));
+
+  set_argument(result, "n", problem_space, problem_.n);
+  set_argument(result, "h", problem_space, problem_.h);
+  set_argument(result, "w", problem_space, problem_.w);
+  set_argument(result, "c", problem_space, problem_.c);
+
+  set_argument(result, "k", problem_space, problem_.k);
+  set_argument(result, "r", problem_space, problem_.r);
+  set_argument(result, "s", problem_space, problem_.s);
+
+  set_argument(result, "p", problem_space, problem_.p);
+  set_argument(result, "q", problem_space, problem_.q);
+
+  set_argument(result, "g", problem_space, problem_.groups);
+
+  set_argument(result, "pad_h", problem_space, problem_.pad_h);
+  set_argument(result, "pad_w", problem_space, problem_.pad_w);
+
+  set_argument(result, "stride_h", problem_space, problem_.stride_h);
+  set_argument(result, "stride_w", problem_space, problem_.stride_w);
+
+  set_argument(result, "dilation_h", problem_space, problem_.dilation_h);
+  set_argument(result, "dilation_w", problem_space, problem_.dilation_w);
+
+  set_argument(result, "split_k_mode", problem_space,
+    std::string(library::to_string(problem_.split_k_mode)));
+  set_argument(result, "split_k_slices", problem_space, problem_.split_k_slices);
+
+  set_argument(result, "conv_mode", problem_space,
+    std::string(library::to_string(problem_.conv_mode)));
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(problem_.alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(problem_.beta, operation_desc.element_epilogue));
+
+  set_argument(result, "eq_gemm_provider", problem_space,
+    std::string(library::to_string(problem_.eq_gemm_provider)));
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+  // Bytes of activation, filter, and output tensors
+  int64_t activation_bytes = int64_t(library::sizeof_bits(operation_desc.activation().element) / 8) *
+    conv_workspace_.configuration.problem_size.activation_size();
+
+  int64_t filter_bytes = int64_t(library::sizeof_bits(operation_desc.filter().element) / 8) *
+    conv_workspace_.configuration.problem_size.filter_size();
+
+  int64_t output_bytes = int64_t(library::sizeof_bits(operation_desc.output().element) / 8) *
+    conv_workspace_.configuration.problem_size.output_size();
+
+  // Bytes of activation, filter, and output tensors
+  result.bytes = problem_.bytes(operation_desc);
+
+  // Theoretical flops required for the computation
+  result.flops = problem_.flops(operation_desc);
+
+  // Measured runtime
+  result.runtime = 0;
+
+}
+
+/// Initialize reduction problem dimensions and library::Operation
+bool Conv2dOperationProfiler::initialize_reduction_configuration_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::ConvDescription const &conv_desc =
+    static_cast<library::ConvDescription const &>(operation->description());
+
+  library::ConvKind const &conv_kind = conv_desc.conv_kind;
+
+  if (!cast_from_double(problem_.alpha_one, conv_desc.element_epilogue, 1)) {
+   return false;
+  }
+
+  if (!cast_from_double(problem_.beta_zero, conv_desc.element_epilogue, 0)) {
+   return false;
+  }
+
+  /// This chooses the appropriate stride element of the row-major C tensor.
+  int const & tensor_c_stride_idx = (conv_kind == library::ConvKind::kWgrad ? 2 : 0);
+
+  /// initialize library::ReductionConfiguration
+  conv_workspace_.reduction_configuration.problem_size     = problem_.eq_gemm_size(conv_kind).mn();
+  conv_workspace_.reduction_configuration.partitions       = int(problem_.split_k_slices);
+  conv_workspace_.reduction_configuration.partition_stride = problem_.eq_gemm_size(conv_kind).mn().product();
+  conv_workspace_.reduction_configuration.ldw =
+      conv_workspace_.configuration.stride_c[tensor_c_stride_idx];
+  conv_workspace_.reduction_configuration.lds =
+      conv_workspace_.configuration.stride_c[tensor_c_stride_idx];
+  conv_workspace_.reduction_configuration.ldd =
+      conv_workspace_.configuration.stride_c[tensor_c_stride_idx];
+
+  // find reduction operation
+  library::ReductionFunctionalKey reduction_key(
+    library::Provider::kCUTLASS,
+    conv_desc.tile_description.math_instruction.element_accumulator,  // element workspace
+    conv_desc.tile_description.math_instruction.element_accumulator,  // element accumulator
+    conv_desc.C.element,                                              // element output
+    conv_desc.element_epilogue                                        // element compute
+  );
+
+#if 0// debug print to check which reduction instance is selected
+    std::cout << reduction_key << "\n";
+#endif
+  auto reduction_it = Singleton::get().operation_table.reduction_operations.find(reduction_key);
+
+  if(reduction_it == Singleton::get().operation_table.reduction_operations.end()) {
+
+    return false;
+  }
+
+  // initialize reduction operation required for parallel split-k conv2d operator
+  reduction_op_ = reduction_it->second;
+
+  // reduction operation found and initialized
+  return true;
+}
+
+
+/// Initializes workspace
+Status Conv2dOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  // initialize conv2d underlying operation to handle parallel reduction
+  library::Operation const* underlying_operation = operation;
+
+  if(conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_conv_operation_for_parallel_reduction(operation))) {
+      return Status::kErrorNotSupported;
+    }
+  }
+
+  library::ConvDescription const &operation_desc =
+    static_cast<library::ConvDescription const &>(underlying_operation->description());
+
+  // Compute the number of copies of the problem to avoid L2 camping.
+  if (!options.profiling.workspace_count) {
+    int64_t bytes = problem_.bytes(operation_desc);
+    if (bytes < 3 * int64_t(options.device.properties[0].l2CacheSize)) {
+      conv_workspace_.problem_count =
+        1 + int((3 * int64_t(options.device.properties[0].l2CacheSize)) / bytes);
+    }
+    else {
+      conv_workspace_.problem_count = 1;
+    }
+  }
+  else {
+    conv_workspace_.problem_count = options.profiling.workspace_count;
+  }
+
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    conv_workspace_.A = device_context.allocate_and_initialize_tensor(
+      options,
+      "A",
+      operation_desc.A.element,
+      operation_desc.A.layout,
+      problem_.extent_a(operation_desc.conv_kind),
+      conv_workspace_.configuration.stride_a,
+      conv_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    conv_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      problem_.extent_b(operation_desc.conv_kind),
+      conv_workspace_.configuration.stride_b,
+      conv_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    if(problem_.groups == problem_.c && problem_.groups == problem_.k){
+      // Depthwise direct conv kernel needs reorder the filter.
+      conv_workspace_.reordered_B = device_context.allocate_and_initialize_tensor(
+        options,
+        "B",
+        operation_desc.B.element,
+        operation_desc.B.layout,
+        problem_.extent_b(operation_desc.conv_kind),
+        conv_workspace_.configuration.stride_b,
+        conv_workspace_.problem_count,
+        seed_shift++,
+        0 // device_index
+      );
+    }
+
+    conv_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      problem_.extent_c(operation_desc.conv_kind),
+      conv_workspace_.configuration.stride_c,
+      conv_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    conv_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      problem_.extent_c(operation_desc.conv_kind),
+      conv_workspace_.configuration.stride_c,
+      conv_workspace_.problem_count,
+      0 // device_index
+    );
+
+    conv_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      problem_.extent_c(operation_desc.conv_kind),
+      conv_workspace_.configuration.stride_c,
+      conv_workspace_.problem_count,
+      0 // device_index
+    );
+  }
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = underlying_operation->get_host_workspace_size(&conv_workspace_.configuration);
+      conv_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = underlying_operation->get_device_workspace_size(&conv_workspace_.configuration);
+      conv_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = underlying_operation->initialize(
+        &conv_workspace_.configuration,
+        conv_workspace_.host_workspace.data(),
+        conv_workspace_.device_workspace.data());
+
+      if (status != Status::kSuccess) {
+        return status;
+      }
+
+      if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+        workspace_size = reduction_op_->get_host_workspace_size(&conv_workspace_.reduction_configuration);
+        conv_workspace_.reduction_host_workspace.resize(workspace_size, 0);
+
+        status = reduction_op_->initialize(
+          &conv_workspace_.reduction_configuration,
+          conv_workspace_.reduction_host_workspace.data(),
+          nullptr);
+
+        if (status != Status::kSuccess) {
+          return status;
+        }
+      }
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kConv2d;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool Conv2dOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  cudaError_t result;
+
+  // Initialize structure containing Conv2d arguments
+  conv_workspace_.arguments.A = conv_workspace_.A->data();
+  conv_workspace_.arguments.B = conv_workspace_.B->data();
+  conv_workspace_.arguments.C = conv_workspace_.C->data();
+  conv_workspace_.arguments.D = conv_workspace_.Computed->data();
+  conv_workspace_.arguments.alpha = problem_.alpha.data();
+  conv_workspace_.arguments.beta = problem_.beta.data();
+  conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  if (conv_workspace_.reordered_B != nullptr){
+    conv_workspace_.arguments.reordered_B = conv_workspace_.reordered_B->data();
+  }else{
+    conv_workspace_.arguments.reordered_B = nullptr;
+  }
+
+  conv_workspace_.Computed->copy_from_device(conv_workspace_.C->data());
+
+  if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+    // update library::ConvArguments for parallel split-k reduction
+    conv_workspace_.arguments.D = conv_workspace_.device_workspace.data();
+    conv_workspace_.arguments.alpha = problem_.alpha_one.data();
+    conv_workspace_.arguments.beta = problem_.beta_zero.data();
+
+    /// initialize library::ReductionArguments
+    conv_workspace_.reduction_arguments.workspace           = conv_workspace_.device_workspace.data();
+    conv_workspace_.reduction_arguments.source              = conv_workspace_.C->data();
+    conv_workspace_.reduction_arguments.destination         = conv_workspace_.Computed->data();
+    conv_workspace_.reduction_arguments.alpha               = problem_.alpha.data();
+    conv_workspace_.reduction_arguments.beta                = problem_.beta.data();
+    conv_workspace_.reduction_arguments.pointer_mode        = library::ScalarPointerMode::kHost;
+  }
+
+  //
+  // Run the CUTLASS operation
+  //
+  // initialize conv2d underlying operation to handle parallel reduction
+  library::Operation const* underlying_operation = operation;
+
+  if(conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_conv_operation_for_parallel_reduction(operation))) {
+      results_.back().disposition = Disposition::kFailed;
+      return false;
+    }
+  }
+
+#if 0
+  std::cout << "profiling         : " << std::endl
+            << "conv2d            : " << operation->description().name << std::endl
+            << "underlying conv2d : " << underlying_operation->description().name << std::endl
+            << "reduction         : " << reduction_op_->description().name << std::endl;
+#endif
+
+  // run cutlass conv2d operation
+  results_.back().status = underlying_operation->run(
+    &conv_workspace_.arguments,
+    conv_workspace_.host_workspace.data(),
+    conv_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // Run parallel reduction kernel for parallel split_k_mode
+  if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+
+    results_.back().status = reduction_op_->run(
+      &conv_workspace_.reduction_arguments,
+      conv_workspace_.reduction_host_workspace.data(),
+      nullptr);
+
+    if (results_.back().status != Status::kSuccess) {
+      results_.back().disposition = Disposition::kFailed;
+      return false;
+    }
+
+  }
+
+  // Synchronize before running device reference
+  result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUDNN
+    // Run verification cudnn reference
+    if (options.verification.provider_enabled(library::Provider::kCUDNN)) {
+
+      // Guard against unsupported cases
+      auto const & conv_desc = static_cast<library::ConvDescription const &>(operation->description());
+
+      Status status = cudnn_satisfies(conv_desc, conv_workspace_.configuration);
+
+      // Initialize reference data to the source data
+      conv_workspace_.Reference->copy_from_device(conv_workspace_.C->data());
+
+      if (status == Status::kSuccess) {
+        // call cudnn verification if supported
+        verify_with_cudnn_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+      }
+
+      else if (status == Status::kErrorInvalidProblem) {
+        results_.back().verification_map[library::Provider::kCUDNN] = Disposition::kInvalidProblem;
+      }
+
+      else {
+        // set verification map for cudnn to not supported
+        results_.back().verification_map[library::Provider::kCUDNN] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUDNN
+
+    // Run verification device reference
+    if (options.verification.provider_enabled(library::Provider::kReferenceDevice)) {
+
+      // Restore reference data back to initial source data
+      conv_workspace_.Reference->copy_from_device(conv_workspace_.C->data());
+
+      verify_with_device_reference_(
+        options,
+        report,
+        device_context,
+        operation,
+        problem_space,
+        problem);
+    }
+
+    // Run verification host reference
+    if (options.verification.provider_enabled(library::Provider::kReferenceHost)) {
+
+      // Restore reference data back to initial source data
+      conv_workspace_.Reference->copy_from_device(conv_workspace_.C->data());
+
+      verify_with_host_reference_(
+        options,
+        report,
+        device_context,
+        operation,
+        problem_space,
+        problem);
+    }
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+
+/// Verifies CUTLASS against host reference
+bool Conv2dOperationProfiler::verify_with_host_reference_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+    Status status;
+
+    //
+    // Find host reference operation using conv2d functional description key
+    //
+    library::OperationDescription const &desc = operation->description();
+
+    auto &conv_desc = static_cast<library::ConvDescription const &>(desc);
+
+    library::ConvFunctionalKey conv2d_key(
+      library::Provider::kReferenceHost,
+      conv_desc.conv_kind,
+      conv_desc.A.element,
+      conv_desc.A.layout,
+      conv_desc.B.element,
+      conv_desc.B.layout,
+      conv_desc.C.element,
+      conv_desc.C.layout,
+      conv_desc.tile_description.math_instruction.element_accumulator,
+      conv_desc.element_epilogue);
+
+#if 0 // debug print to check which host reference instance is selected
+    std::cout << conv2d_key << "\n";
+#endif
+
+    auto operators_it = Singleton::get().operation_table.conv2d_operations.find(conv2d_key);
+
+    if(operators_it == Singleton::get().operation_table.conv2d_operations.end()) {
+
+      results_.back().verification_map[library::Provider::kReferenceHost] = Disposition::kNotRun;
+      return true;
+    }
+
+    // conv2d host reference minimum cc is 0 (CPU) and no iterator algorithm
+    library::ConvPreferenceKey preference_key(0, library::IteratorAlgorithmID::kNone);
+    auto cc_it = operators_it->second.find(preference_key);
+
+    if(cc_it == operators_it->second.end()) {
+      results_.back().verification_map[library::Provider::kReferenceHost] = Disposition::kNotRun;
+      return true;
+    }
+
+    // host reference has only one instances in Conv2dOperationVectorMap
+    library::Operation const *reference_op = cc_it->second[0];
+
+    //
+    // Copy input tensors A, B, and C from device to host buffers
+    //
+    conv_workspace_.host_tensor_a.resize(conv_workspace_.A->bytes());
+    conv_workspace_.host_tensor_b.resize(conv_workspace_.B->bytes());
+    conv_workspace_.host_tensor_c.resize(conv_workspace_.C->bytes());
+
+    conv_workspace_.A->copy_to_host(conv_workspace_.host_tensor_a.data());
+    conv_workspace_.B->copy_to_host(conv_workspace_.host_tensor_b.data());
+    conv_workspace_.C->copy_to_host(conv_workspace_.host_tensor_c.data());
+
+    //
+    // Initialize structure containing Conv2d arguments
+    //
+    conv_workspace_.arguments.A = conv_workspace_.host_tensor_a.data();
+    conv_workspace_.arguments.B = conv_workspace_.host_tensor_b.data();
+    conv_workspace_.arguments.C = conv_workspace_.host_tensor_c.data();
+    conv_workspace_.arguments.D = conv_workspace_.host_tensor_c.data();
+
+    conv_workspace_.arguments.alpha = problem_.alpha.data();
+    conv_workspace_.arguments.beta = problem_.beta.data();
+    conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    //
+    // Initialize host reference operation
+    //
+    std::vector<uint8_t> host_workspace_reference_op;
+
+    uint64_t workspace_size = reference_op->get_host_workspace_size(&conv_workspace_.configuration);
+    host_workspace_reference_op.resize(workspace_size, 0);
+
+    reference_op->initialize(
+      &conv_workspace_.configuration,
+      host_workspace_reference_op.data());
+
+    //
+    // Run host reference operation
+    //
+    status = reference_op->run(
+      &conv_workspace_.arguments,
+      host_workspace_reference_op.data());
+
+    // Handle errors
+    if (status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kReferenceHost] = Disposition::kNotVerified;
+      return true;
+    }
+
+    //
+    // Copy host reference output to device memory for equality check on device
+    //
+    conv_workspace_.Reference->copy_from_host(conv_workspace_.arguments.D);
+
+    //
+    // Verify results
+    //
+    results_.back().verification_map[library::Provider::kReferenceHost] = compare_tensors(
+      options,
+      *conv_workspace_.Computed,
+      *conv_workspace_.Reference,
+      conv_workspace_.Computed->batch_stride()
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kReferenceHost] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        static_cast<library::ConvDescription const &>(operation->description()),
+        library::Provider::kCUTLASS,
+        library::Provider::kReferenceHost);
+    }
+
+  // Return true means continue profiling
+  return true;
+}
+
+
+/// Verifies CUTLASS against host reference
+bool Conv2dOperationProfiler::verify_with_device_reference_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+    Status status;
+
+    //
+    // Find device reference operation using conv2d functional description key
+    //
+    library::OperationDescription const &desc = operation->description();
+
+    auto &conv_desc = static_cast<library::ConvDescription const &>(desc);
+
+    library::ConvFunctionalKey conv2d_key(
+      library::Provider::kReferenceDevice,
+      conv_desc.conv_kind,
+      conv_desc.A.element,
+      conv_desc.A.layout,
+      conv_desc.B.element,
+      conv_desc.B.layout,
+      conv_desc.C.element,
+      conv_desc.C.layout,
+      conv_desc.tile_description.math_instruction.element_accumulator,
+      conv_desc.element_epilogue);
+
+    auto operators_it = Singleton::get().operation_table.conv2d_operations.find(conv2d_key);
+
+    if(operators_it == Singleton::get().operation_table.conv2d_operations.end()) {
+
+      results_.back().verification_map[library::Provider::kReferenceDevice] = Disposition::kNotRun;
+
+      return true;
+    }
+
+    // conv2d device reference minimum cc is 50 and no iterator algorithm
+    library::ConvPreferenceKey preference_key(50, library::IteratorAlgorithmID::kNone);
+    auto cc_it = operators_it->second.find(preference_key);
+
+    if(cc_it == operators_it->second.end()) {
+      results_.back().verification_map[library::Provider::kReferenceDevice] = Disposition::kNotRun;
+
+      return true;
+    }
+
+    // device reference has only one instances in Conv2dOperationVectorMap
+    library::Operation const *reference_op = cc_it->second[0];
+
+    //
+    // Initialize device reference operation
+    //
+    std::vector<uint8_t> host_workspace_reference_op;
+
+    uint64_t workspace_size = reference_op->get_host_workspace_size(&conv_workspace_.configuration);
+    host_workspace_reference_op.resize(workspace_size, 0);
+
+    reference_op->initialize(
+      &conv_workspace_.configuration,
+      host_workspace_reference_op.data());
+
+    // Initialize structure containing Conv2d arguments
+    conv_workspace_.arguments.A = conv_workspace_.A->data();
+    conv_workspace_.arguments.B = conv_workspace_.B->data();
+    conv_workspace_.arguments.C = conv_workspace_.C->data();
+    conv_workspace_.arguments.D = conv_workspace_.Reference->data();
+    conv_workspace_.arguments.alpha = problem_.alpha.data();
+    conv_workspace_.arguments.beta = problem_.beta.data();
+    conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    //
+    // Run device reference operation
+    //
+    status = reference_op->run(
+      &conv_workspace_.arguments,
+      host_workspace_reference_op.data());
+
+
+    // Handle errors
+    if (status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kReferenceDevice] = Disposition::kNotVerified;
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+    results_.back().verification_map[library::Provider::kReferenceDevice] = compare_tensors(
+      options,
+      *conv_workspace_.Computed,
+      *conv_workspace_.Reference,
+      conv_workspace_.Computed->batch_stride()
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kReferenceDevice] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        static_cast<library::ConvDescription const &>(operation->description()),
+        library::Provider::kCUTLASS,
+        library::Provider::kReferenceDevice);
+    }
+
+  // Return true means continue profiling
+  return true;
+}
+
+/// Measures performance results
+bool Conv2dOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing Conv2d arguments
+    conv_workspace_.arguments.A = conv_workspace_.A->data();
+    conv_workspace_.arguments.B = conv_workspace_.B->data();
+    conv_workspace_.arguments.C = conv_workspace_.C->data();
+    conv_workspace_.arguments.D = conv_workspace_.Computed->data();
+    conv_workspace_.arguments.alpha = problem_.alpha.data();
+    conv_workspace_.arguments.beta = problem_.beta.data();
+    conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+      // update library::ConvArguments for parallel split-k reduction
+      conv_workspace_.arguments.D = conv_workspace_.device_workspace.data();
+      conv_workspace_.arguments.alpha = problem_.alpha_one.data();
+      conv_workspace_.arguments.beta = problem_.beta_zero.data();
+
+      /// initialize library::ReductionArguments
+      conv_workspace_.reduction_arguments.workspace           = conv_workspace_.device_workspace.data();
+      conv_workspace_.reduction_arguments.source              = conv_workspace_.C->data();
+      conv_workspace_.reduction_arguments.destination         = conv_workspace_.Computed->data();
+      conv_workspace_.reduction_arguments.alpha               = problem_.alpha.data();
+      conv_workspace_.reduction_arguments.beta                = problem_.beta.data();
+      conv_workspace_.reduction_arguments.pointer_mode        = library::ScalarPointerMode::kHost;
+    }
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &conv_workspace_.arguments,
+      conv_workspace_.host_workspace.data(),
+      conv_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+
+}
+
+/// Method to profile a CUTLASS Operation
+Status Conv2dOperationProfiler::profile_cutlass_(
+  double &runtime,
+  Options const &options,
+  library::Operation const *operation,
+  void *arguments,
+  void *host_workspace,
+  void *device_workspace) {
+
+  GpuTimer timer;
+
+  // initialize conv2d underlying operation to handle parallel reduction
+  library::Operation const* underlying_operation = operation;
+
+  library::ConvArguments *conv_arguments = static_cast<library::ConvArguments *>(arguments);
+
+  if(conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_conv_operation_for_parallel_reduction(operation))) {
+      return Status::kErrorNotSupported;
+    }
+  }
+
+  //
+  // Optional sleep to limit power consumption and thermals
+  //
+
+  sleep(options.profiling.sleep_duration);
+
+  //
+  // Warmup loop
+  //
+
+  Status status;
+
+  for (int iteration = 0; iteration < options.profiling.warmup_iterations; ++iteration) {
+
+    // Setup rotating workspace
+    int workspace_idx = options.profiling.warmup_iterations + iteration;
+    int problem_idx = (workspace_idx % conv_workspace_.problem_count);
+
+    conv_arguments->A = conv_workspace_.A->batch_data(problem_idx);
+    conv_arguments->B = conv_workspace_.B->batch_data(problem_idx);
+    conv_arguments->C = conv_workspace_.C->batch_data(problem_idx);
+    conv_arguments->D = conv_workspace_.Computed->batch_data(problem_idx);
+
+    if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+      // update library::ConvArguments for parallel split-k reduction
+      conv_arguments->D = conv_workspace_.device_workspace.data();
+
+      /// initialize library::ReductionArguments
+      conv_workspace_.reduction_arguments.workspace           = conv_workspace_.device_workspace.data();
+      conv_workspace_.reduction_arguments.source              = conv_workspace_.C->batch_data(problem_idx);
+      conv_workspace_.reduction_arguments.destination         = conv_workspace_.Computed->batch_data(problem_idx);
+    }
+
+    // Run underlying conv2d operation
+    status = underlying_operation->run(
+      arguments,
+      host_workspace,
+      device_workspace);
+
+    // Run parallel reduction kernel for parallel split_k_mode
+    if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+
+      status = reduction_op_->run(
+        &conv_workspace_.reduction_arguments,
+        conv_workspace_.reduction_host_workspace.data(),
+        nullptr);
+    }
+
+    if (status != Status::kSuccess) {
+      return status;
+    }
+  }
+
+  //
+  // Initialize GPU timer
+  //
+
+  timer.start();
+
+  //
+  // Profiling loop
+  //
+
+  int Iterations = options.profiling.iterations;
+
+  int iteration = 0;
+  for (; iteration < Iterations; ++iteration) {
+
+    // Setup rotating workspace
+    int problem_idx = (iteration % conv_workspace_.problem_count);
+
+    conv_arguments->A = conv_workspace_.A->batch_data(problem_idx);
+    conv_arguments->B = conv_workspace_.B->batch_data(problem_idx);
+    conv_arguments->C = conv_workspace_.C->batch_data(problem_idx);
+    conv_arguments->D = conv_workspace_.Computed->batch_data(problem_idx);
+
+    if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+      // update library::ConvArguments for parallel split-k reduction
+      conv_arguments->D = conv_workspace_.device_workspace.data();
+
+      /// initialize library::ReductionArguments
+      conv_workspace_.reduction_arguments.workspace           = conv_workspace_.device_workspace.data();
+      conv_workspace_.reduction_arguments.source              = conv_workspace_.C->batch_data(problem_idx);
+      conv_workspace_.reduction_arguments.destination         = conv_workspace_.Computed->batch_data(problem_idx);
+    }
+
+    // Run underlying conv2d operation
+    status = underlying_operation->run(
+      arguments,
+      host_workspace,
+      device_workspace);
+
+    // Run parallel reduction kernel for parallel split_k_mode
+    if (conv_workspace_.configuration.split_k_mode == conv::SplitKMode::kParallel) {
+
+      status = reduction_op_->run(
+        &conv_workspace_.reduction_arguments,
+        conv_workspace_.reduction_host_workspace.data(),
+        nullptr);
+    }
+
+    if (status != Status::kSuccess) {
+      return status;
+    }
+  }
+
+  //
+  // Wait for completion
+  //
+
+  timer.stop_and_wait();
+
+  //
+  // Update performance result
+  //
+
+  runtime = timer.duration(iteration);
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#if CUTLASS_ENABLE_CUDNN
+
+/// Verifies CUTLASS against cudnn reference
+bool Conv2dOperationProfiler::verify_with_cudnn_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  auto &conv_desc = static_cast<library::ConvDescription const &>(operation->description());
+
+  //
+  // Construct cudnn operators
+  //
+
+  CudnnCreate handle;
+  cudnnStatus_t status = handle.get_cudnn_create_status();
+
+  if (status != CUDNN_STATUS_SUCCESS) {
+
+    results_.back().verification_map[library::Provider::kCUDNN] = get_cutlass_disposition(status);
+    return true;
+  }
+
+  //
+  // Initialize state
+  //
+
+  // Initialize structure containing Conv2d arguments
+  conv_workspace_.arguments.A = conv_workspace_.A->data();
+  conv_workspace_.arguments.B = conv_workspace_.B->data();
+  conv_workspace_.arguments.D = conv_workspace_.Reference->data();
+  conv_workspace_.arguments.alpha = problem_.alpha.data();
+  conv_workspace_.arguments.beta = problem_.beta.data();
+  conv_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  // cuDNN does not support four tensor arguments, so we copy the tensor C data into
+  // tensor D.
+  conv_workspace_.Reference->copy_from_device(conv_workspace_.C->data());
+  conv_workspace_.arguments.C = conv_workspace_.arguments.D;
+
+  try {
+
+    //
+    // Construct dispatcher to cudnn operator
+    //
+
+    detail::cudnnConvDispatcher conv_op(
+      conv_desc,
+      conv_workspace_.configuration,
+      conv_workspace_.arguments,
+      handle
+    );
+
+    if (conv_op.status != Status::kSuccess) {
+      if (conv_op.status == Status::kErrorNotSupported) {
+        results_.back().verification_map[library::Provider::kCUDNN] = Disposition::kNotSupported;
+
+      } else {
+        results_.back().verification_map[library::Provider::kCUDNN] = Disposition::kFailed;
+      }
+      return true;
+    }
+
+
+    status = conv_op(handle);
+
+    // Handle errors
+    if (status != CUDNN_STATUS_SUCCESS) {
+
+      results_.back().verification_map[library::Provider::kCUDNN] = get_cutlass_disposition(status);
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[library::Provider::kCUDNN] = compare_tensors(
+      options,
+      *conv_workspace_.Computed,
+      *conv_workspace_.Reference,
+      conv_workspace_.Computed->batch_stride()
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUDNN] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        conv_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUDNN);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUDNN] = Disposition::kFailed;
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+#endif // #if CUTLASS_ENABLE_CUDNN
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/cudnn_helpers.cpp

@@ -0,0 +1,496 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Helper functions for mapping CUTLASS concepts to cuDNN.
+*/
+#if CUTLASS_ENABLE_CUDNN
+
+#include <stdexcept>
+
+#include "cutlass/profiler/cudnn_helpers.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+/// Converts a cuDNN status to cutlass::Status
+Status get_cutlass_status(cudnnStatus_t cudnn_status) {
+
+  if (cudnn_status == CUDNN_STATUS_SUCCESS) {
+    return Status::kSuccess;
+  }
+  else if (cudnn_status == CUDNN_STATUS_INVALID_VALUE) {
+    return Status::kErrorInvalidProblem;
+  }
+  if (cudnn_status == CUDNN_STATUS_NOT_SUPPORTED) {
+    return Status::kErrorNotSupported;
+  }
+  return Status::kErrorInternal;
+}
+
+/// Converts a cuDNN status to cutlass::profiler::Disposition
+Disposition get_cutlass_disposition(cudnnStatus_t cudnn_status) {
+
+  if (cudnn_status == CUDNN_STATUS_INVALID_VALUE) {
+    return Disposition::kInvalidProblem;
+  }
+  else if (cudnn_status == CUDNN_STATUS_NOT_SUPPORTED) {
+    return Disposition::kNotSupported;
+  }
+  return Disposition::kFailed;
+}
+
+/// Checks cudnnStatus_t converts to cutlas status and returns if Status::kSuccess o.w. throws exception
+Status checkCudnnErr(cudnnStatus_t cudnn_status) {
+  Status cutlass_status = get_cutlass_status(cudnn_status);
+  if(cutlass_status != Status::kSuccess) {
+    throw std::runtime_error("checkCudnnErr failed");
+  }
+  return cutlass_status;
+}
+
+/// Maps a CUTLASS conv mode to a cuDNN cudnnConvolutionMode_t
+bool get_cudnn_conv_mode(cudnnConvolutionMode_t &cudnn_conv_mode, conv::Mode conv_mode) {
+  switch (conv_mode) {
+    case conv::Mode::kCrossCorrelation:
+      cudnn_conv_mode = CUDNN_CROSS_CORRELATION;
+      return true;
+    case conv::Mode::kConvolution:
+      cudnn_conv_mode = CUDNN_CONVOLUTION;
+      return true;
+    default: break;
+  }
+  return false;
+}
+
+/// Maps a CUTLASS tensor layout to a cuDNN cudnnTensorFormat_t
+bool get_cudnn_layout(cudnnTensorFormat_t &cudnn_layout, library::LayoutTypeID layout) {
+  switch (layout) {
+    // cudnn uses the same enum for TensorNC*HW along nDim (ConvDescription::conv_dim)
+    case library::LayoutTypeID::kTensorNCHW:
+    case library::LayoutTypeID::kTensorNCDHW:
+      cudnn_layout = CUDNN_TENSOR_NCHW;
+      return true;
+    case library::LayoutTypeID::kTensorNHWC:
+    case library::LayoutTypeID::kTensorNDHWC:
+      cudnn_layout = CUDNN_TENSOR_NHWC;
+      return true;
+    default: break;
+  }
+  return false;
+}
+
+/// Maps a CUTLASS numeric type to a cuDNN cudnnDataType_t
+bool get_cudnn_datatype(cudnnDataType_t &cudnn_element_type, library::NumericTypeID element_type) {
+  switch (element_type) {
+    case library::NumericTypeID::kF16:
+      cudnn_element_type = CUDNN_DATA_HALF;
+      return true;
+
+    case library::NumericTypeID::kF32:
+      cudnn_element_type = CUDNN_DATA_FLOAT;
+      return true;
+    
+    case library::NumericTypeID::kF64: 
+      cudnn_element_type = CUDNN_DATA_DOUBLE;
+      return true;
+    
+    case library::NumericTypeID::kS2: 
+      break;
+  
+    case library::NumericTypeID::kS4: 
+      break;
+  
+    case library::NumericTypeID::kS8: 
+      cudnn_element_type = CUDNN_DATA_INT8;
+      return true;
+
+    case library::NumericTypeID::kS16: 
+      break;
+ 
+    case library::NumericTypeID::kS32: 
+      cudnn_element_type = CUDNN_DATA_INT32;
+      return true;
+
+    case library::NumericTypeID::kS64: 
+      break;
+
+    case library::NumericTypeID::kU2: 
+      break;
+  
+    case library::NumericTypeID::kU4: 
+      break;
+  
+    case library::NumericTypeID::kU8: 
+      cudnn_element_type = CUDNN_DATA_UINT8;
+      return true;
+
+    case library::NumericTypeID::kU16: 
+      break;
+    
+    case library::NumericTypeID::kU32: 
+      break;
+    
+    case library::NumericTypeID::kU64: 
+      break;
+
+    case library::NumericTypeID::kB1: 
+      break;
+  
+    case library::NumericTypeID::kInvalid:
+  
+    default: 
+      break;
+  }
+
+  return false;
+}
+
+/// Maps CUTLASS math OpcodeClassID and MathOperationID to cuDNN math_type
+bool get_cudnn_mathtype(cudnnMathType_t &cudnn_math_type, library::ConvDescription const &conv_desc) {
+
+  switch (conv_desc.tile_description.math_instruction.opcode_class) {
+
+    case library::OpcodeClassID::kTensorOp:
+    {
+      cudnn_math_type = CUDNN_TENSOR_OP_MATH;
+
+      library::MathOperationID math_op = conv_desc.tile_description.math_instruction.math_operation;
+      
+      // Allow conversion on input data type for fast math operations
+      if (math_op == library::MathOperationID::kMultiplyAddFastF16 || 
+        math_op == library::MathOperationID::kMultiplyAddFastBF16) 
+      {
+        cudnn_math_type = CUDNN_TENSOR_OP_MATH_ALLOW_CONVERSION;
+      }
+
+      return true;
+    }
+    case library::OpcodeClassID::kSimt:
+      #if (defined(CUDNN_VERSION) && CUDNN_VERSION <= 8000)
+        cudnn_math_type = CUDNN_DEFAULT_MATH;
+      #else
+        cudnn_math_type = CUDNN_FMA_MATH;
+      #endif
+      return true;
+  }
+
+  return false;
+}
+
+/// Cudnn compute type seems to be hardcoded to float (To handle a possible cudnn issue)
+float cast_cudnn_compute_type_to_float(library::NumericTypeID type, void const * src) {
+
+  switch (type) {
+    case library::NumericTypeID::kF16:
+    {
+      return float(*(static_cast<half_t const*>(src)));
+    }
+    case library::NumericTypeID::kF32:
+    {
+      return float(*(static_cast<float const*>(src)));
+    }
+    case library::NumericTypeID::kS32:
+    {
+      return float(*(static_cast<int const*>(src)));
+    }
+    default:
+      throw std::runtime_error("Data type handled in cast_compute_type_to_float");
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+/// Returns a status if cuDNN can satisfy a particular Conv2d description
+Status cudnn_satisfies(
+  library::ConvDescription const &desc, 
+  library::Conv2dConfiguration const &configuration) {
+  
+  auto const &a_tensor = desc.A;
+  auto const &b_tensor = desc.B;
+  auto const &c_tensor = desc.C;
+  auto const &math_instruction = desc.tile_description.math_instruction;
+
+  if(a_tensor.element != b_tensor.element) {
+    return Status::kErrorInvalidDataType;
+  }
+
+  ////////////////////////  Convolution output dimensions p and q ///////////////////////
+  // Cutlass convolutions support arbitrary output dimensions and not constrained by   //
+  // input, filter, padding, striding, dilation sizes.                                 //
+  // cuDNN sets the output dimensions (p, q) using following equations:                //
+  //                                                                                   //
+  // output = div_up(input + 2 * pad - ((filter - 1) * dilation + 1) + 1, stride)      //
+  // where; div_up(a, b) : (a - 1)/b + 1                                               //
+  //                                                                                   //
+  // Before launching cudnn verification or profiling check that output p and q        //
+  // dimensions are cuDNN compliant.                                                   //
+  //                                                                                   //
+  // If user sets output p and q which do not follow above constraints, cutlass conv,  //
+  // host reference, device reference can run. However, cudnn convolution returns      //
+  // "Invalid problem"                                                                 //
+  //                                                                                   //
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  // check conv output dimension p for cudnn
+  int cudnn_output_p = 
+  (
+    (
+      configuration.problem_size.H + 
+      2 * configuration.problem_size.pad_h - 
+      ((configuration.problem_size.R - 1) * 
+      configuration.problem_size.dilation_h + 1)
+    ) / 
+    (configuration.problem_size.stride_h) 
+    + 1
+  );
+
+  if (cudnn_output_p != configuration.problem_size.P) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  // check conv output dimension q for cudnn
+  int cudnn_output_q = 
+  (
+    (
+      configuration.problem_size.W + 
+      2 * configuration.problem_size.pad_w - 
+      ((configuration.problem_size.S - 1) * 
+      configuration.problem_size.dilation_w + 1)
+    ) / 
+    (configuration.problem_size.stride_w) 
+    + 1
+  );
+
+  if (cudnn_output_q != configuration.problem_size.Q) {
+    return Status::kErrorInvalidProblem;
+  }
+  //////////////////////////////////////////////////////////////////////////////////////
+
+  // conv operator with input=FP16, accumulator=FP32, output=FP32 datatype 
+  if (a_tensor.element ==  library::NumericTypeID::kF16 && 
+      b_tensor.element ==  library::NumericTypeID::kF16 &&
+      math_instruction.element_accumulator == library::NumericTypeID::kF32 &&
+      c_tensor.element == library::NumericTypeID::kF32
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kBF16 || 
+      b_tensor.element ==  library::NumericTypeID::kBF16 ||
+      c_tensor.element == library::NumericTypeID::kBF16
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  // TF32 input not supported in cuDNN
+  if (a_tensor.element ==  library::NumericTypeID::kTF32 || 
+      b_tensor.element ==  library::NumericTypeID::kTF32 ||
+      c_tensor.element == library::NumericTypeID::kTF32
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kS8 || 
+      b_tensor.element ==  library::NumericTypeID::kS8 ||
+      c_tensor.element == library::NumericTypeID::kS8
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kU8 || 
+      b_tensor.element ==  library::NumericTypeID::kU8 ||
+      c_tensor.element == library::NumericTypeID::kU8
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kS4 || 
+      b_tensor.element ==  library::NumericTypeID::kS4 ||
+      c_tensor.element == library::NumericTypeID::kS4
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kU4 || 
+      b_tensor.element ==  library::NumericTypeID::kU4 ||
+      c_tensor.element == library::NumericTypeID::kU4
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  return Status::kSuccess;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns a status if cuDNN can satisfy a particular Conv3d description
+Status cudnn_satisfies(
+  library::ConvDescription const &desc, 
+  library::Conv3dConfiguration const &configuration) {
+  
+  auto const &a_tensor = desc.A;
+  auto const &b_tensor = desc.B;
+  auto const &c_tensor = desc.C;
+  auto const &math_instruction = desc.tile_description.math_instruction;
+
+  if(a_tensor.element != b_tensor.element) {
+    return Status::kErrorInvalidDataType;
+  }
+
+  ////////////////////////  Convolution output dimensions p and q ///////////////////////
+  // Cutlass convolutions support arbitrary output dimensions and not constrained by   //
+  // input, filter, padding, striding, dilation sizes.                                 //
+  // cuDNN sets the output dimensions (p, q) using following equations:                //
+  //                                                                                   //
+  // output = div_up(input + 2 * pad - ((filter - 1) * dilation + 1) + 1, stride)      //
+  // where; div_up(a, b) : (a - 1)/b + 1                                               //
+  //                                                                                   //
+  // Before launching cudnn verification or profiling check that output p and q        //
+  // dimensions are cuDNN compliant.                                                   //
+  //                                                                                   //
+  // If user sets output p and q which do not follow above constraints, cutlass conv,  //
+  // host reference, device reference can run. However, cudnn convolution returns      //
+  // "Invalid problem"                                                                 //
+  //                                                                                   //
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  // check conv output dimension z for cudnn
+  int cudnn_output_z = 
+  (
+    (
+      configuration.problem_size.D + 
+      2 * configuration.problem_size.pad_d - 
+      ((configuration.problem_size.T - 1) * 
+      configuration.problem_size.dilation_d + 1)
+    ) / 
+    (configuration.problem_size.stride_d) 
+    + 1
+  );
+
+  if (cudnn_output_z != configuration.problem_size.Z) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  // check conv output dimension p for cudnn
+  int cudnn_output_p = 
+  (
+    (
+      configuration.problem_size.H + 
+      2 * configuration.problem_size.pad_h - 
+      ((configuration.problem_size.R - 1) * 
+      configuration.problem_size.dilation_h + 1)
+    ) / 
+    (configuration.problem_size.stride_h) 
+    + 1
+  );
+
+  if (cudnn_output_p != configuration.problem_size.P) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  // check conv output dimension q for cudnn
+  int cudnn_output_q = 
+  (
+    (
+      configuration.problem_size.W + 
+      2 * configuration.problem_size.pad_w - 
+      ((configuration.problem_size.S - 1) * 
+      configuration.problem_size.dilation_w + 1)
+    ) / 
+    (configuration.problem_size.stride_w) 
+    + 1
+  );
+
+  if (cudnn_output_q != configuration.problem_size.Q) {
+    return Status::kErrorInvalidProblem;
+  }
+  //////////////////////////////////////////////////////////////////////////////////////
+
+  // conv operator with input, accumulator, output datatype of (hss) are not supported 
+  // in cuDNN
+  if (a_tensor.element ==  library::NumericTypeID::kF16 && 
+      b_tensor.element ==  library::NumericTypeID::kF16 &&
+      math_instruction.element_accumulator == library::NumericTypeID::kF32 &&
+      c_tensor.element == library::NumericTypeID::kF32
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kBF16 || 
+      b_tensor.element ==  library::NumericTypeID::kBF16 ||
+      c_tensor.element == library::NumericTypeID::kBF16
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kTF32 || 
+      b_tensor.element ==  library::NumericTypeID::kTF32 ||
+      c_tensor.element == library::NumericTypeID::kTF32
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  if (a_tensor.element ==  library::NumericTypeID::kS8 || 
+      b_tensor.element ==  library::NumericTypeID::kS8 ||
+      c_tensor.element == library::NumericTypeID::kS8
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  // S4 not supported in cuDNN 
+  if (a_tensor.element ==  library::NumericTypeID::kS4 || 
+      b_tensor.element ==  library::NumericTypeID::kS4 ||
+      c_tensor.element == library::NumericTypeID::kS4
+      ) {
+
+    return Status::kErrorNotSupported;
+  }
+
+  return Status::kSuccess;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/cutlass_profiler.cu

@@ -0,0 +1,214 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+*/
+
+#include <iostream>
+#include <stdexcept>
+
+// Profiler includes
+#include "cutlass/profiler/cutlass_profiler.h"
+#include "cutlass/profiler/gemm_operation_profiler.h"
+#include "cutlass/profiler/rank_k_operation_profiler.h"
+#include "cutlass/profiler/rank_2k_operation_profiler.h"
+#include "cutlass/profiler/trmm_operation_profiler.h"
+#include "cutlass/profiler/symm_operation_profiler.h"
+#include "cutlass/profiler/conv2d_operation_profiler.h"
+#include "cutlass/profiler/conv3d_operation_profiler.h"
+#include "cutlass/profiler/sparse_gemm_operation_profiler.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+CutlassProfiler::CutlassProfiler(
+  Options const &options
+):
+  options_(options) {
+
+  operation_profilers_.emplace_back(new GemmOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new SparseGemmOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new Conv2dOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new Conv3dOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new RankKOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new Rank2KOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new TrmmOperationProfiler(options));
+
+  operation_profilers_.emplace_back(new SymmOperationProfiler(options));
+}
+
+CutlassProfiler::~CutlassProfiler() {
+
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Execute the program
+int CutlassProfiler::operator()() {
+
+  if (options_.cmdline.num_naked_args() > 0) {
+    std::cerr << "Unknown args: \n";
+    options_.cmdline.print_naked_args(std::cerr);
+    std::cerr << "\n\n\n";
+
+    print_usage_(std::cout);
+    return 1;
+  }
+
+  if (options_.about.help) {
+    if (options_.operation_kind == library::OperationKind::kInvalid) {
+      print_usage_(std::cout);
+    }
+    else {
+      for (auto & profiler : operation_profilers_) {
+        if (profiler->kind() == options_.operation_kind) {
+          profiler->print_usage(std::cout);
+          profiler->print_examples(std::cout);
+          return 0;
+        }
+      }
+    }
+    return 0;
+  }
+  else if (options_.about.version) {
+    options_.about.print_version(std::cout);
+
+    std::cout << std::endl;
+    return 0;
+  }
+  else if (options_.about.device_info) {
+    options_.device.print_device_info(std::cout);
+    return 0;
+  }
+
+  if (options_.execution_mode == ExecutionMode::kProfile ||
+    options_.execution_mode == ExecutionMode::kDryRun ||
+    options_.execution_mode == ExecutionMode::kTrace) {
+
+    // Profiles all operations
+    return profile_();
+  }
+  else if (options_.execution_mode == ExecutionMode::kEnumerate) {
+    // Enumerates all operations
+    enumerate_();
+  }
+  return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Enumerates all operations
+void CutlassProfiler::enumerate_() {
+
+}
+
+/// Profiles all operations
+int CutlassProfiler::profile_() {
+
+  // Keep track of all device memory tensor in map
+  DeviceContext device_context;
+
+  int result = 0;
+  // For all profilers (e.g. gemm/sparse_gemm/conv2d...)
+  for (auto & profiler : operation_profilers_) {
+
+    if (options_.operation_kind == library::OperationKind::kInvalid ||
+        options_.operation_kind == profiler->kind()) {
+
+      result = profiler->profile_all(options_, library::Singleton::get().manifest, device_context);
+
+      // If some profile failed, terminate immediately
+      if (result) {
+        return result;
+      }
+    }
+  }
+
+  return result;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Prints all options
+void CutlassProfiler::print_usage_(std::ostream &out) {
+  options_.print_usage(out);
+
+  out << "\nOperations:\n\n";
+
+  // For all profilers
+  for (auto & profiler : operation_profilers_) {
+
+
+    std::string kind_str = library::to_string(profiler->kind());
+
+    size_t kAlignment = 40;
+    size_t columns = 0;
+
+    if (kind_str.size() < kAlignment) {
+      columns = kAlignment - kind_str.size();
+    }
+
+    out << "     " << kind_str << std::string(columns, ' ') << profiler->description() << "\n";
+
+  }
+
+  out << "\n\nFor details about a particular function, specify the function name with --help.\n\nExample:\n\n"
+    << "  $ cutlass_profiler --operation=Gemm --help\n\n"
+    << "  $ cutlass_profiler --operation=RankK --help\n\n"
+    << "  $ cutlass_profiler --operation=Trmm --help\n\n"
+    << "  $ cutlass_profiler --operation=Symm --help\n\n"
+    << "  $ cutlass_profiler --operation=Conv3d --help\n\n"
+    << "  $ cutlass_profiler --operation=Conv2d --help\n\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --help\n\n"
+  ;
+}
+
+/// Prints usage
+void CutlassProfiler::print_options_(std::ostream &out) {
+  options_.print_options(out);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/device_allocation.cu

@@ -0,0 +1,2483 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+*/
+
+#include <cstring>
+
+#include "cutlass/numeric_types.h"
+#include "cutlass/layout/matrix.h"
+#include "cutlass/layout/tensor.h"
+
+#include "cutlass/util/reference/device/tensor_compare.h"
+#include "cutlass/util/reference/device/tensor_fill.h"
+#include "cutlass/util/reference/host/tensor_fill.h"
+#include "cutlass/util/host_tensor.h"
+#include "cutlass/util/tensor_view_io.h"
+
+#include "cutlass/library/util.h"
+
+#include "cutlass/profiler/device_allocation.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+size_t DeviceAllocation::bytes(library::NumericTypeID type, size_t capacity) {
+  return size_t(cutlass::library::sizeof_bits(type)) * capacity / 8;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename Layout>
+static std::vector<int64_t> get_packed_layout_stride(std::vector<int> const &extent) {
+
+  typename Layout::TensorCoord extent_coord;
+  typename Layout::Stride stride_coord;
+
+  if (extent.size() != size_t(Layout::kRank)) {
+    throw std::runtime_error("Layout does not have same rank as extent vector.");
+  }
+
+  for (int i = 0; i < Layout::kRank; ++i) {
+    extent_coord[i] = extent.at(i);
+  }
+
+  std::vector<int64_t> stride;
+  stride.resize(Layout::kStrideRank, 0);
+
+  Layout layout = Layout::packed(extent_coord);
+  stride_coord = layout.stride();
+
+  for (int i = 0; i < Layout::kStrideRank; ++i) {
+    stride.at(i) = (int64_t)stride_coord[i];
+  }
+
+  return stride;
+}
+
+/// Returns the stride of a packed layout
+std::vector<int64_t> DeviceAllocation::get_packed_layout(
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent) {
+
+  std::vector<int64_t> stride;
+
+  switch (layout_id) {
+    case library::LayoutTypeID::kColumnMajor:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajor>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajor:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajor>(extent);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK2:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajorInterleaved<2>>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK2:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajorInterleaved<2>>(extent);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK4:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajorInterleaved<4>>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK4:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajorInterleaved<4>>(extent);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK16:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajorInterleaved<16>>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK16:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajorInterleaved<16>>(extent);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK32:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajorInterleaved<32>>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK32:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajorInterleaved<32>>(extent);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK64:
+      stride = get_packed_layout_stride<cutlass::layout::ColumnMajorInterleaved<64>>(extent);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK64:
+      stride = get_packed_layout_stride<cutlass::layout::RowMajorInterleaved<64>>(extent);
+      break;
+    case library::LayoutTypeID::kTensorNCHW:
+      stride = get_packed_layout_stride<cutlass::layout::TensorNCHW>(extent);
+      break;
+    case library::LayoutTypeID::kTensorNHWC:
+      stride = get_packed_layout_stride<cutlass::layout::TensorNHWC>(extent);
+      break;
+    case library::LayoutTypeID::kTensorNDHWC:
+      stride = get_packed_layout_stride<cutlass::layout::TensorNDHWC>(extent);
+      break;
+    case library::LayoutTypeID::kTensorNC32HW32:
+      stride = get_packed_layout_stride<cutlass::layout::TensorNCxHWx<32>>(extent);
+      break;
+    case library::LayoutTypeID::kTensorNC64HW64:
+      stride = get_packed_layout_stride<cutlass::layout::TensorNCxHWx<64>>(extent);
+      break;
+    case library::LayoutTypeID::kTensorC32RSK32:
+      stride = get_packed_layout_stride<cutlass::layout::TensorCxRSKx<32>>(extent);
+      break;
+    case library::LayoutTypeID::kTensorC64RSK64:
+      stride = get_packed_layout_stride<cutlass::layout::TensorCxRSKx<64>>(extent);
+      break;
+    default: break;
+  }
+
+  return stride;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Template to use CUTLASS Layout functions to
+template <typename Layout>
+static size_t construct_layout_(
+  void *bytes,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> &stride) {
+
+  if (extent.size() != Layout::kRank) {
+    throw std::runtime_error(
+      "Layout must have same rank as extent vector.");
+  }
+
+  if (Layout::kStrideRank && stride.empty()) {
+
+    stride = get_packed_layout_stride<Layout>(extent);
+
+    return construct_layout_<Layout>(
+      bytes,
+      layout_id,
+      extent,
+      stride);
+  }
+  else if (Layout::kStrideRank && stride.size() != Layout::kStrideRank) {
+    throw std::runtime_error(
+      "Layout requires either empty stride or stride vector matching Layout::kStrideRank");
+  }
+
+  typename Layout::Stride stride_coord;
+  for (int i = 0; i < Layout::kStrideRank; ++i) {
+    stride_coord[i] = (int)stride.at(i);
+  }
+
+  typename Layout::TensorCoord extent_coord;
+  for (int i = 0; i < Layout::kRank; ++i) {
+    extent_coord[i] = extent.at(i);
+  }
+
+  // Construct the CUTLASS layout object from the stride object
+  Layout layout(stride_coord);
+
+  // Pack it into bytes
+  if (bytes) {
+    *reinterpret_cast<Layout *>(bytes) = layout;
+  }
+
+  // Return capacity
+  size_t capacity_ = layout.capacity(extent_coord);
+
+  return capacity_;
+}
+
+/// returns the capacity needed
+size_t DeviceAllocation::construct_layout(
+  void *bytes,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> &stride) {
+
+  switch (layout_id) {
+    case library::LayoutTypeID::kColumnMajor:
+      return construct_layout_<cutlass::layout::ColumnMajor>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajor:
+      return construct_layout_<cutlass::layout::RowMajor>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kColumnMajorInterleavedK2:
+      return construct_layout_<cutlass::layout::ColumnMajorInterleaved<2>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajorInterleavedK2:
+      return construct_layout_<cutlass::layout::RowMajorInterleaved<2>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kColumnMajorInterleavedK4:
+      return construct_layout_<cutlass::layout::ColumnMajorInterleaved<4>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajorInterleavedK4:
+      return construct_layout_<cutlass::layout::RowMajorInterleaved<4>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kColumnMajorInterleavedK16:
+      return construct_layout_<cutlass::layout::ColumnMajorInterleaved<16>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajorInterleavedK16:
+      return construct_layout_<cutlass::layout::RowMajorInterleaved<16>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kColumnMajorInterleavedK32:
+      return construct_layout_<cutlass::layout::ColumnMajorInterleaved<32>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajorInterleavedK32:
+      return construct_layout_<cutlass::layout::RowMajorInterleaved<32>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kColumnMajorInterleavedK64:
+      return construct_layout_<cutlass::layout::ColumnMajorInterleaved<64>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kRowMajorInterleavedK64:
+      return construct_layout_<cutlass::layout::RowMajorInterleaved<64>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorNCHW:
+      return construct_layout_<cutlass::layout::TensorNHWC>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorNHWC:
+      return construct_layout_<cutlass::layout::TensorNHWC>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorNDHWC:
+      return construct_layout_<cutlass::layout::TensorNDHWC>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorNC32HW32:
+      return construct_layout_<cutlass::layout::TensorNCxHWx<32>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorNC64HW64:
+      return construct_layout_<cutlass::layout::TensorNCxHWx<64>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorC32RSK32:
+      return construct_layout_<cutlass::layout::TensorCxRSKx<32>>(bytes, layout_id, extent, stride);
+
+    case library::LayoutTypeID::kTensorC64RSK64:
+      return construct_layout_<cutlass::layout::TensorCxRSKx<64>>(bytes, layout_id, extent, stride);
+
+    default: break;
+  }
+
+  return 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+DeviceAllocation::DeviceAllocation():
+  type_(library::NumericTypeID::kInvalid),
+  batch_stride_(0),
+  capacity_(0),
+  pointer_(nullptr),
+  layout_(library::LayoutTypeID::kUnknown),
+  batch_count_(1),
+  device_(-1) {
+
+}
+
+DeviceAllocation::DeviceAllocation(
+  library::NumericTypeID type,
+  size_t capacity,
+  int device
+):
+  type_(type), batch_stride_(capacity), capacity_(capacity), pointer_(nullptr),
+  layout_(library::LayoutTypeID::kUnknown), batch_count_(1), device_(device) {
+
+  cudaError_t result = this->malloc((void **)&pointer_, bytes(type, capacity));
+
+  if (result != cudaSuccess) {
+    type_ = library::NumericTypeID::kInvalid;
+    capacity_ = 0;
+    pointer_ = nullptr;
+    throw std::bad_alloc();
+  }
+}
+
+DeviceAllocation::DeviceAllocation(
+  library::NumericTypeID type,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> const &stride,
+  int batch_count,
+  int device
+):
+  type_(type), batch_stride_(size_t(0)), capacity_(size_t(0)),
+  pointer_(nullptr), batch_count_(1), device_(device) {
+
+  reset(type, layout_id, extent, stride, batch_count);
+}
+
+DeviceAllocation::~DeviceAllocation() {
+  if (pointer_) {
+    cudaFree(pointer_);
+  }
+}
+
+DeviceAllocation &DeviceAllocation::reset() {
+  if (pointer_) {
+    cudaFree(pointer_);
+  }
+
+  type_ = library::NumericTypeID::kInvalid;
+  batch_stride_ = 0;
+  capacity_ = 0;
+  pointer_ = nullptr;
+  layout_ = library::LayoutTypeID::kUnknown;
+  stride_.clear();
+  extent_.clear();
+  tensor_ref_buffer_.clear();
+  batch_count_ = 1;
+
+  return *this;
+}
+
+DeviceAllocation &DeviceAllocation::reset(library::NumericTypeID type, size_t capacity) {
+
+  reset();
+
+  type_ = type;
+  batch_stride_ = capacity;
+  capacity_ = capacity;
+
+  cudaError_t result = this->malloc((void **)&pointer_, bytes(type_, capacity_));
+  if (result != cudaSuccess) {
+    throw std::bad_alloc();
+  }
+
+  layout_ = library::LayoutTypeID::kUnknown;
+  stride_.clear();
+  extent_.clear();
+  batch_count_ = 1;
+
+  tensor_ref_buffer_.resize(sizeof(pointer_), 0);
+  std::memcpy(tensor_ref_buffer_.data(), &pointer_, sizeof(pointer_));
+
+  return *this;
+}
+
+/// Allocates memory for a given layout and tensor
+DeviceAllocation &DeviceAllocation::reset(
+  library::NumericTypeID type,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> const &stride,
+  int batch_count) {
+
+  reset();
+
+  tensor_ref_buffer_.resize(sizeof(pointer_) + (sizeof(int64_t) * library::get_layout_stride_rank(layout_id)), 0);
+
+  type_ = type;
+
+  layout_ = layout_id;
+  stride_ = stride;
+  extent_ = extent;
+  batch_count_ = batch_count;
+
+  batch_stride_ = construct_layout(
+    tensor_ref_buffer_.data() + sizeof(pointer_),
+    layout_id,
+    extent,
+    stride_);
+
+  capacity_ = batch_stride_ * batch_count_;
+
+  cudaError_t result = this->malloc((void **)&pointer_, bytes(type, capacity_));
+  if (result != cudaSuccess) {
+    throw std::bad_alloc();
+  }
+
+  std::memcpy(tensor_ref_buffer_.data(), &pointer_, sizeof(pointer_));
+
+  return *this;
+}
+
+bool DeviceAllocation::good() const {
+  return (capacity_ && pointer_);
+}
+
+library::NumericTypeID DeviceAllocation::type() const {
+  return type_;
+}
+
+void *DeviceAllocation::data() const {
+  return pointer_;
+}
+
+void *DeviceAllocation::batch_data(int batch_idx) const {
+    return static_cast<char *>(data()) + batch_stride_bytes() * batch_idx;
+}
+
+library::LayoutTypeID DeviceAllocation::layout() const {
+  return layout_;
+}
+
+std::vector<int64_t> const & DeviceAllocation::stride() const {
+  return stride_;
+}
+
+/// Gets the extent vector
+std::vector<int> const & DeviceAllocation::extent() const {
+  return extent_;
+}
+
+/// Gets the number of adjacent tensors in memory
+int DeviceAllocation::batch_count() const {
+  return batch_count_;
+}
+
+/// Gets the stride (in units of elements) between items
+int64_t DeviceAllocation::batch_stride() const {
+  return batch_stride_;
+}
+
+/// Gets the stride (in units of bytes) between items
+int64_t DeviceAllocation::batch_stride_bytes() const {
+  return bytes(type_, batch_stride_);
+}
+
+size_t DeviceAllocation::capacity() const {
+  return capacity_;
+}
+
+size_t DeviceAllocation::bytes() const {
+  return bytes(type_, capacity_);
+}
+
+/// Copies from an equivalent-sized tensor in device memory
+void DeviceAllocation::copy_from_device(void const *ptr) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping copy of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  cudaError_t result = cudaMemcpy(data(), ptr, bytes(), cudaMemcpyDeviceToDevice);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed device-to-device copy");
+  }
+}
+
+/// Copies from an equivalent-sized tensor in device memory
+void DeviceAllocation::copy_from_host(void const *ptr) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping copy of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  cudaError_t result = cudaMemcpy(data(), ptr, bytes(), cudaMemcpyHostToDevice);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed host-to-device copy");
+  }
+}
+
+/// Copies from an equivalent-sized tensor in device memory
+void DeviceAllocation::copy_to_host(void *ptr) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping copy of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  cudaError_t result = cudaMemcpy(ptr, data(), bytes(), cudaMemcpyDeviceToHost);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed device-to-host copy");
+  }
+}
+
+void DeviceAllocation::initialize_random_device(int seed, Distribution dist) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  // Instantiate calls to CURAND here. This file takes a long time to compile for
+  // this reason.
+
+  switch (type_) {
+  case library::NumericTypeID::kF16:
+    cutlass::reference::device::BlockFillRandom<cutlass::half_t>(
+      reinterpret_cast<cutlass::half_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kBF16:
+    cutlass::reference::device::BlockFillRandom<cutlass::bfloat16_t>(
+      reinterpret_cast<cutlass::bfloat16_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kTF32:
+    cutlass::reference::device::BlockFillRandom<cutlass::tfloat32_t>(
+      reinterpret_cast<cutlass::tfloat32_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kF32:
+    cutlass::reference::device::BlockFillRandom<float>(
+      reinterpret_cast<float *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCBF16:
+    cutlass::reference::device::BlockFillRandom<complex<bfloat16_t>>(
+      reinterpret_cast<complex<bfloat16_t> *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCTF32:
+    cutlass::reference::device::BlockFillRandom<cutlass::complex<cutlass::tfloat32_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::tfloat32_t> *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCF32:
+    cutlass::reference::device::BlockFillRandom<cutlass::complex<float>>(
+      reinterpret_cast<cutlass::complex<float> *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kFE4M3:
+    cutlass::reference::device::BlockFillRandom<cutlass::float_e4m3_t>(
+      reinterpret_cast<cutlass::float_e4m3_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kFE5M2:
+    cutlass::reference::device::BlockFillRandom<cutlass::float_e5m2_t>(
+      reinterpret_cast<cutlass::float_e5m2_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kF64:
+    cutlass::reference::device::BlockFillRandom<double>(
+      reinterpret_cast<double *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCF64:
+    cutlass::reference::device::BlockFillRandom<complex<double>>(
+      reinterpret_cast<complex<double> *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS2:
+    cutlass::reference::device::BlockFillRandom<int2b_t>(
+      reinterpret_cast<int2b_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS4:
+    cutlass::reference::device::BlockFillRandom<int4b_t>(
+      reinterpret_cast<int4b_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS8:
+    cutlass::reference::device::BlockFillRandom<int8_t>(
+      reinterpret_cast<int8_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS16:
+    cutlass::reference::device::BlockFillRandom<int16_t>(
+      reinterpret_cast<int16_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS32:
+    cutlass::reference::device::BlockFillRandom<int32_t>(
+      reinterpret_cast<int32_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS64:
+    cutlass::reference::device::BlockFillRandom<int64_t>(
+      reinterpret_cast<int64_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kB1:
+    cutlass::reference::device::BlockFillRandom<uint1b_t>(
+      reinterpret_cast<uint1b_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU2:
+    cutlass::reference::device::BlockFillRandom<uint2b_t>(
+      reinterpret_cast<uint2b_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU4:
+    cutlass::reference::device::BlockFillRandom<uint4b_t>(
+      reinterpret_cast<uint4b_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU8:
+    cutlass::reference::device::BlockFillRandom<uint8_t>(
+      reinterpret_cast<uint8_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU16:
+    cutlass::reference::device::BlockFillRandom<uint16_t>(
+      reinterpret_cast<uint16_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU32:
+    cutlass::reference::device::BlockFillRandom<uint32_t>(
+      reinterpret_cast<uint32_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU64:
+    cutlass::reference::device::BlockFillRandom<uint64_t>(
+      reinterpret_cast<uint64_t *>(pointer_),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  default: break;
+  }
+}
+
+void DeviceAllocation::initialize_random_host(int seed, Distribution dist) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  std::vector<uint8_t> host_data(bytes());
+
+  switch (type_) {
+  case library::NumericTypeID::kFE4M3:
+    cutlass::reference::host::BlockFillRandom<cutlass::float_e4m3_t>(
+      reinterpret_cast<cutlass::float_e4m3_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kFE5M2:
+    cutlass::reference::host::BlockFillRandom<cutlass::float_e5m2_t>(
+      reinterpret_cast<cutlass::float_e5m2_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kF16:
+    cutlass::reference::host::BlockFillRandom<cutlass::half_t>(
+      reinterpret_cast<cutlass::half_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kBF16:
+    cutlass::reference::host::BlockFillRandom<cutlass::bfloat16_t>(
+      reinterpret_cast<cutlass::bfloat16_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kTF32:
+    cutlass::reference::host::BlockFillRandom<cutlass::tfloat32_t>(
+      reinterpret_cast<cutlass::tfloat32_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kF32:
+    cutlass::reference::host::BlockFillRandom<float>(
+      reinterpret_cast<float *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCF16:
+    cutlass::reference::host::BlockFillRandom<cutlass::complex<cutlass::half_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::half_t> *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCBF16:
+    cutlass::reference::host::BlockFillRandom<cutlass::complex<cutlass::bfloat16_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::bfloat16_t> *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCTF32:
+    cutlass::reference::host::BlockFillRandom<cutlass::complex<cutlass::tfloat32_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::tfloat32_t> *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCF32:
+    cutlass::reference::host::BlockFillRandom<cutlass::complex<float>>(
+      reinterpret_cast<cutlass::complex<float> *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kF64:
+    cutlass::reference::host::BlockFillRandom<double>(
+      reinterpret_cast<double *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kCF64:
+    cutlass::reference::host::BlockFillRandom<cutlass::complex<double>>(
+      reinterpret_cast<cutlass::complex<double> *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS2:
+    cutlass::reference::host::BlockFillRandom<int2b_t>(
+      reinterpret_cast<int2b_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS4:
+    cutlass::reference::host::BlockFillRandom<int4b_t>(
+      reinterpret_cast<int4b_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS8:
+    cutlass::reference::host::BlockFillRandom<int8_t>(
+      reinterpret_cast<int8_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS16:
+    cutlass::reference::host::BlockFillRandom<int16_t>(
+      reinterpret_cast<int16_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS32:
+    cutlass::reference::host::BlockFillRandom<int32_t>(
+      reinterpret_cast<int32_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kS64:
+    cutlass::reference::host::BlockFillRandom<int64_t>(
+      reinterpret_cast<int64_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kB1:
+    cutlass::reference::host::BlockFillRandom<uint1b_t>(
+      reinterpret_cast<uint1b_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU2:
+    cutlass::reference::host::BlockFillRandom<uint2b_t>(
+      reinterpret_cast<uint2b_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU4:
+    cutlass::reference::host::BlockFillRandom<uint4b_t>(
+      reinterpret_cast<uint4b_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU8:
+    cutlass::reference::host::BlockFillRandom<uint8_t>(
+      reinterpret_cast<uint8_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU16:
+    cutlass::reference::host::BlockFillRandom<uint16_t>(
+      reinterpret_cast<uint16_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU32:
+    cutlass::reference::host::BlockFillRandom<uint32_t>(
+      reinterpret_cast<uint32_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  case library::NumericTypeID::kU64:
+    cutlass::reference::host::BlockFillRandom<uint64_t>(
+      reinterpret_cast<uint64_t *>(host_data.data()),
+      capacity_,
+      seed,
+      dist
+    );
+    break;
+  default: break;
+  }
+
+  copy_from_host(host_data.data());
+}
+
+void DeviceAllocation::initialize_sequential_device(Distribution dist) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  switch (type_) {
+  case library::NumericTypeID::kFE4M3:
+    cutlass::reference::device::BlockFillSequential<cutlass::float_e4m3_t>(
+      reinterpret_cast<cutlass::float_e4m3_t *>(pointer_),
+      capacity_,
+      static_cast<cutlass::float_e4m3_t>(dist.sequential.delta),
+      static_cast<cutlass::float_e4m3_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kFE5M2:
+    cutlass::reference::device::BlockFillSequential<cutlass::float_e5m2_t>(
+      reinterpret_cast<cutlass::float_e5m2_t *>(pointer_),
+      capacity_,
+      static_cast<cutlass::float_e5m2_t>(dist.sequential.delta),
+      static_cast<cutlass::float_e5m2_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kF16:
+    cutlass::reference::device::BlockFillSequential<cutlass::half_t>(
+      reinterpret_cast<cutlass::half_t *>(pointer_),
+      capacity_,
+      static_cast<cutlass::half_t>(dist.sequential.delta),
+      static_cast<cutlass::half_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kBF16:
+    cutlass::reference::device::BlockFillSequential<cutlass::bfloat16_t>(
+      reinterpret_cast<cutlass::bfloat16_t *>(pointer_),
+      capacity_,
+      static_cast<cutlass::bfloat16_t>(dist.sequential.delta),
+      static_cast<cutlass::bfloat16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kTF32:
+    cutlass::reference::device::BlockFillSequential<cutlass::tfloat32_t>(
+      reinterpret_cast<cutlass::tfloat32_t *>(pointer_),
+      capacity_,
+      static_cast<cutlass::tfloat32_t>(dist.sequential.delta),
+      static_cast<cutlass::tfloat32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kF32:
+    cutlass::reference::device::BlockFillSequential<float>(
+      reinterpret_cast<float *>(pointer_),
+      capacity_,
+      static_cast<float>(dist.sequential.delta),
+      static_cast<float>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kCF16:
+    cutlass::reference::device::BlockFillSequential<cutlass::complex<cutlass::half_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::half_t> *>(pointer_),
+      capacity_,
+      cutlass::complex<cutlass::half_t>(
+        static_cast<cutlass::half_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::half_t>(
+        static_cast<cutlass::half_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCBF16:
+    cutlass::reference::device::BlockFillSequential<cutlass::complex<cutlass::bfloat16_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::bfloat16_t> *>(pointer_),
+      capacity_,
+      cutlass::complex<cutlass::bfloat16_t>(
+        static_cast<cutlass::bfloat16_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::bfloat16_t>(
+        static_cast<cutlass::bfloat16_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCTF32:
+    cutlass::reference::device::BlockFillSequential<cutlass::complex<cutlass::tfloat32_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::tfloat32_t> *>(pointer_),
+      capacity_,
+      cutlass::complex<cutlass::tfloat32_t>(
+        static_cast<cutlass::tfloat32_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::tfloat32_t>(
+        static_cast<cutlass::tfloat32_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCF32:
+    cutlass::reference::device::BlockFillSequential<cutlass::complex<float>>(
+      reinterpret_cast<cutlass::complex<float> *>(pointer_),
+      capacity_,
+      cutlass::complex<float>(
+        static_cast<float>(dist.sequential.delta)),
+      cutlass::complex<float>(
+        static_cast<float>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kF64:
+    cutlass::reference::device::BlockFillSequential<double>(
+      reinterpret_cast<double *>(pointer_),
+      capacity_,
+      static_cast<double>(dist.sequential.delta),
+      static_cast<double>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kCF64:
+    cutlass::reference::device::BlockFillSequential<cutlass::complex<double>>(
+      reinterpret_cast<cutlass::complex<double> *>(pointer_),
+      capacity_,
+      cutlass::complex<double>(
+        static_cast<double>(dist.sequential.delta)),
+      cutlass::complex<double>(
+        static_cast<double>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kS2:
+    cutlass::reference::device::BlockFillSequential<int2b_t>(
+      reinterpret_cast<int2b_t *>(pointer_),
+      capacity_,
+      static_cast<int2b_t>(dist.sequential.delta),
+      static_cast<int2b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS4:
+    cutlass::reference::device::BlockFillSequential<int4b_t>(
+      reinterpret_cast<int4b_t *>(pointer_),
+      capacity_,
+      static_cast<int4b_t>(dist.sequential.delta),
+      static_cast<int4b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS8:
+    cutlass::reference::device::BlockFillSequential<int8_t>(
+      reinterpret_cast<int8_t *>(pointer_),
+      capacity_,
+      static_cast<int8_t>(dist.sequential.delta),
+      static_cast<int8_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS16:
+    cutlass::reference::device::BlockFillSequential<int16_t>(
+      reinterpret_cast<int16_t *>(pointer_),
+      capacity_,
+      static_cast<int16_t>(dist.sequential.delta),
+      static_cast<int16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS32:
+    cutlass::reference::device::BlockFillSequential<int32_t>(
+      reinterpret_cast<int32_t *>(pointer_),
+      capacity_,
+      static_cast<int32_t>(dist.sequential.delta),
+      static_cast<int32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS64:
+    cutlass::reference::device::BlockFillSequential<int64_t>(
+      reinterpret_cast<int64_t *>(pointer_),
+      capacity_,
+      static_cast<int64_t>(dist.sequential.delta),
+      static_cast<int64_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kB1:
+    cutlass::reference::device::BlockFillSequential<uint1b_t>(
+      reinterpret_cast<uint1b_t *>(pointer_),
+      capacity_,
+      static_cast<uint1b_t>(dist.sequential.delta),
+      static_cast<uint1b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU2:
+    cutlass::reference::device::BlockFillSequential<uint2b_t>(
+      reinterpret_cast<uint2b_t *>(pointer_),
+      capacity_,
+      static_cast<uint2b_t>(dist.sequential.delta),
+      static_cast<uint2b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU4:
+    cutlass::reference::device::BlockFillSequential<uint4b_t>(
+      reinterpret_cast<uint4b_t *>(pointer_),
+      capacity_,
+      static_cast<uint4b_t>(dist.sequential.delta),
+      static_cast<uint4b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU8:
+    cutlass::reference::device::BlockFillSequential<uint8_t>(
+      reinterpret_cast<uint8_t *>(pointer_),
+      capacity_,
+      static_cast<uint8_t>(dist.sequential.delta),
+      static_cast<uint8_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU16:
+    cutlass::reference::device::BlockFillSequential<uint16_t>(
+      reinterpret_cast<uint16_t *>(pointer_),
+      capacity_,
+      static_cast<uint16_t>(dist.sequential.delta),
+      static_cast<uint16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU32:
+    cutlass::reference::device::BlockFillSequential<uint32_t>(
+      reinterpret_cast<uint32_t *>(pointer_),
+      capacity_,
+      static_cast<uint32_t>(dist.sequential.delta),
+      static_cast<uint32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU64:
+    cutlass::reference::device::BlockFillSequential<uint64_t>(
+      reinterpret_cast<uint64_t *>(pointer_),
+      capacity_,
+      static_cast<uint64_t>(dist.sequential.delta),
+      static_cast<uint64_t>(dist.sequential.start)
+    );
+    break;
+  default: break;
+  }
+
+}
+
+void DeviceAllocation::initialize_sequential_host(Distribution dist) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  std::vector<uint8_t> host_data(bytes());
+
+  switch (type_) {
+  case library::NumericTypeID::kFE4M3:
+    cutlass::reference::host::BlockFillSequential<cutlass::float_e4m3_t>(
+      reinterpret_cast<cutlass::float_e4m3_t *>(host_data.data()),
+      capacity_,
+      static_cast<cutlass::float_e4m3_t>(dist.sequential.delta),
+      static_cast<cutlass::float_e4m3_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kFE5M2:
+    cutlass::reference::host::BlockFillSequential<cutlass::float_e5m2_t>(
+      reinterpret_cast<cutlass::float_e5m2_t *>(host_data.data()),
+      capacity_,
+      static_cast<cutlass::float_e5m2_t>(dist.sequential.delta),
+      static_cast<cutlass::float_e5m2_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kF16:
+    cutlass::reference::host::BlockFillSequential<cutlass::half_t>(
+      reinterpret_cast<cutlass::half_t *>(host_data.data()),
+      capacity_,
+      static_cast<cutlass::half_t>(dist.sequential.delta),
+      static_cast<cutlass::half_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kBF16:
+    cutlass::reference::host::BlockFillSequential<cutlass::bfloat16_t>(
+      reinterpret_cast<cutlass::bfloat16_t *>(host_data.data()),
+      capacity_,
+      static_cast<cutlass::bfloat16_t>(dist.sequential.delta),
+      static_cast<cutlass::bfloat16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kTF32:
+    cutlass::reference::host::BlockFillSequential<cutlass::tfloat32_t>(
+      reinterpret_cast<cutlass::tfloat32_t *>(host_data.data()),
+      capacity_,
+      static_cast<cutlass::tfloat32_t>(dist.sequential.delta),
+      static_cast<cutlass::tfloat32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kF32:
+    cutlass::reference::host::BlockFillSequential<float>(
+      reinterpret_cast<float *>(host_data.data()),
+      capacity_,
+      static_cast<float>(dist.sequential.delta),
+      static_cast<float>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kCF16:
+    cutlass::reference::host::BlockFillSequential<cutlass::complex<cutlass::half_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::half_t> *>(host_data.data()),
+      capacity_,
+      cutlass::complex<cutlass::half_t>(
+        static_cast<cutlass::half_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::half_t>(
+        static_cast<cutlass::half_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCBF16:
+    cutlass::reference::host::BlockFillSequential<cutlass::complex<cutlass::bfloat16_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::bfloat16_t> *>(host_data.data()),
+      capacity_,
+      cutlass::complex<cutlass::bfloat16_t>(
+        static_cast<cutlass::bfloat16_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::bfloat16_t>(
+        static_cast<cutlass::bfloat16_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCTF32:
+    cutlass::reference::host::BlockFillSequential<cutlass::complex<cutlass::tfloat32_t>>(
+      reinterpret_cast<cutlass::complex<cutlass::tfloat32_t> *>(host_data.data()),
+      capacity_,
+      cutlass::complex<cutlass::tfloat32_t>(
+        static_cast<cutlass::tfloat32_t>(dist.sequential.delta)),
+      cutlass::complex<cutlass::tfloat32_t>(
+        static_cast<cutlass::tfloat32_t>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kCF32:
+    cutlass::reference::host::BlockFillSequential<cutlass::complex<float>>(
+      reinterpret_cast<cutlass::complex<float> *>(host_data.data()),
+      capacity_,
+      cutlass::complex<float>(
+        static_cast<float>(dist.sequential.delta)),
+      cutlass::complex<float>(
+        static_cast<float>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kF64:
+    cutlass::reference::host::BlockFillSequential<double>(
+      reinterpret_cast<double *>(host_data.data()),
+      capacity_,
+      static_cast<double>(dist.sequential.delta),
+      static_cast<double>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kCF64:
+    cutlass::reference::host::BlockFillSequential<cutlass::complex<double>>(
+      reinterpret_cast<cutlass::complex<double> *>(host_data.data()),
+      capacity_,
+      cutlass::complex<double>(
+        static_cast<double>(dist.sequential.delta)),
+      cutlass::complex<double>(
+        static_cast<double>(dist.sequential.start))
+    );
+    break;
+  case library::NumericTypeID::kS2:
+    cutlass::reference::host::BlockFillSequential<int2b_t>(
+      reinterpret_cast<int2b_t *>(host_data.data()),
+      capacity_,
+      static_cast<int2b_t>(dist.sequential.delta),
+      static_cast<int2b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS4:
+    cutlass::reference::host::BlockFillSequential<int4b_t>(
+      reinterpret_cast<int4b_t *>(host_data.data()),
+      capacity_,
+      static_cast<int4b_t>(dist.sequential.delta),
+      static_cast<int4b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS8:
+    cutlass::reference::host::BlockFillSequential<int8_t>(
+      reinterpret_cast<int8_t *>(host_data.data()),
+      capacity_,
+      static_cast<int8_t>(dist.sequential.delta),
+      static_cast<int8_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS16:
+    cutlass::reference::host::BlockFillSequential<int16_t>(
+      reinterpret_cast<int16_t *>(host_data.data()),
+      capacity_,
+      static_cast<int16_t>(dist.sequential.delta),
+      static_cast<int16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS32:
+    cutlass::reference::host::BlockFillSequential<int32_t>(
+      reinterpret_cast<int32_t *>(host_data.data()),
+      capacity_,
+      static_cast<int32_t>(dist.sequential.delta),
+      static_cast<int32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kS64:
+    cutlass::reference::host::BlockFillSequential<int64_t>(
+      reinterpret_cast<int64_t *>(host_data.data()),
+      capacity_,
+      static_cast<int64_t>(dist.sequential.delta),
+      static_cast<int64_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kB1:
+    cutlass::reference::host::BlockFillSequential<uint1b_t>(
+      reinterpret_cast<uint1b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint1b_t>(dist.sequential.delta),
+      static_cast<uint1b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU2:
+    cutlass::reference::host::BlockFillSequential<uint2b_t>(
+      reinterpret_cast<uint2b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint2b_t>(dist.sequential.delta),
+      static_cast<uint2b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU4:
+    cutlass::reference::host::BlockFillSequential<uint4b_t>(
+      reinterpret_cast<uint4b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint4b_t>(dist.sequential.delta),
+      static_cast<uint4b_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU8:
+    cutlass::reference::host::BlockFillSequential<uint8_t>(
+      reinterpret_cast<uint8_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint8_t>(dist.sequential.delta),
+      static_cast<uint8_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU16:
+    cutlass::reference::host::BlockFillSequential<uint16_t>(
+      reinterpret_cast<uint16_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint16_t>(dist.sequential.delta),
+      static_cast<uint16_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU32:
+    cutlass::reference::host::BlockFillSequential<uint32_t>(
+      reinterpret_cast<uint32_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint32_t>(dist.sequential.delta),
+      static_cast<uint32_t>(dist.sequential.start)
+    );
+    break;
+  case library::NumericTypeID::kU64:
+    cutlass::reference::host::BlockFillSequential<uint64_t>(
+      reinterpret_cast<uint64_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint64_t>(dist.sequential.delta),
+      static_cast<uint64_t>(dist.sequential.start)
+    );
+    break;
+  default: break;
+  }
+
+  copy_from_host(host_data.data());
+}
+
+void DeviceAllocation::initialize_random_sparsemeta_device(int seed, int MetaSizeInBits) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  // Instantiate calls to CURAND here. This file takes a long time to compile for
+  // this reason.
+
+  switch (type_) {
+  case library::NumericTypeID::kU16:
+    cutlass::reference::device::BlockFillRandomSparseMeta<uint16_t>(
+      reinterpret_cast<uint16_t *>(pointer_),
+      capacity_,
+      seed,
+      MetaSizeInBits
+    );
+    break;
+  case library::NumericTypeID::kU32:
+    cutlass::reference::device::BlockFillRandomSparseMeta<uint32_t>(
+      reinterpret_cast<uint32_t *>(pointer_),
+      capacity_,
+      seed,
+      MetaSizeInBits
+    );
+    break;
+  default:
+    break;
+  }
+}
+
+void DeviceAllocation::initialize_random_sparsemeta_host(int seed, int MetaSizeInBits) {
+  if (!bytes()) {
+#ifndef NDEBUG
+    std::cout << "Skipping initialization of size 0 allocation\n";
+#endif
+    return;
+  }
+
+  if (!data()) {
+    throw std::runtime_error("Attempting to initialize invalid allocation.");
+  }
+
+  std::vector<uint8_t> host_data(bytes());
+
+  switch (type_) {
+  case library::NumericTypeID::kS16:
+    cutlass::reference::host::BlockFillRandomSparseMeta<uint16_t>(
+      reinterpret_cast<uint16_t *>(host_data.data()),
+      capacity_,
+      seed,
+      MetaSizeInBits
+    );
+    break;
+  case library::NumericTypeID::kS32:
+    cutlass::reference::host::BlockFillRandomSparseMeta<uint32_t>(
+      reinterpret_cast<uint32_t *>(host_data.data()),
+      capacity_,
+      seed,
+      MetaSizeInBits
+    );
+    break;
+  default:
+    break;
+  }
+
+  copy_from_host(host_data.data());
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns true if two blocks have exactly the same value
+bool DeviceAllocation::block_compare_equal(
+  library::NumericTypeID numeric_type,
+  void const *ptr_A,
+  void const *ptr_B,
+  size_t capacity) {
+
+  switch (numeric_type) {
+  case library::NumericTypeID::kFE4M3:
+    return reference::device::BlockCompareEqual<float_e4m3_t>(
+      reinterpret_cast<float_e4m3_t const *>(ptr_A),
+      reinterpret_cast<float_e4m3_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kFE5M2:
+    return reference::device::BlockCompareEqual<float_e5m2_t>(
+      reinterpret_cast<float_e5m2_t const *>(ptr_A),
+      reinterpret_cast<float_e5m2_t const *>(ptr_B),
+      capacity);
+  case library::NumericTypeID::kF16:
+    return reference::device::BlockCompareEqual<half_t>(
+      reinterpret_cast<half_t const *>(ptr_A),
+      reinterpret_cast<half_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kBF16:
+    return reference::device::BlockCompareEqual<bfloat16_t>(
+      reinterpret_cast<bfloat16_t const *>(ptr_A),
+      reinterpret_cast<bfloat16_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kTF32:
+    return reference::device::BlockCompareEqual<tfloat32_t>(
+      reinterpret_cast<tfloat32_t const *>(ptr_A),
+      reinterpret_cast<tfloat32_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kF32:
+    return reference::device::BlockCompareEqual<float>(
+      reinterpret_cast<float const *>(ptr_A),
+      reinterpret_cast<float const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCF32:
+    return reference::device::BlockCompareEqual<cutlass::complex<float> >(
+      reinterpret_cast<complex<float> const *>(ptr_A),
+      reinterpret_cast<complex<float> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCF16:
+    return reference::device::BlockCompareEqual<complex<half_t>>(
+      reinterpret_cast<complex<half_t> const *>(ptr_A),
+      reinterpret_cast<complex<half_t> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCBF16:
+    return reference::device::BlockCompareEqual<complex<bfloat16_t>>(
+      reinterpret_cast<complex<bfloat16_t> const *>(ptr_A),
+      reinterpret_cast<complex<bfloat16_t> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCTF32:
+    return reference::device::BlockCompareEqual<complex<tfloat32_t>>(
+      reinterpret_cast<complex<tfloat32_t> const *>(ptr_A),
+      reinterpret_cast<complex<tfloat32_t> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kF64:
+    return reference::device::BlockCompareEqual<double>(
+      reinterpret_cast<double const *>(ptr_A),
+      reinterpret_cast<double const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCF64:
+    return reference::device::BlockCompareEqual<complex<double>>(
+      reinterpret_cast<complex<double> const *>(ptr_A),
+      reinterpret_cast<complex<double> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS2:
+    return reference::device::BlockCompareEqual<int2b_t>(
+      reinterpret_cast<int2b_t const *>(ptr_A),
+      reinterpret_cast<int2b_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS4:
+    return reference::device::BlockCompareEqual<int4b_t>(
+      reinterpret_cast<int4b_t const *>(ptr_A),
+      reinterpret_cast<int4b_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS8:
+    return reference::device::BlockCompareEqual<int8_t>(
+      reinterpret_cast<int8_t const *>(ptr_A),
+      reinterpret_cast<int8_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS16:
+    return reference::device::BlockCompareEqual<int16_t>(
+      reinterpret_cast<int16_t const *>(ptr_A),
+      reinterpret_cast<int16_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS32:
+    return reference::device::BlockCompareEqual<int32_t>(
+      reinterpret_cast<int32_t const *>(ptr_A),
+      reinterpret_cast<int32_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kS64:
+    return reference::device::BlockCompareEqual<int64_t>(
+      reinterpret_cast<int64_t const *>(ptr_A),
+      reinterpret_cast<int64_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kB1:
+    return reference::device::BlockCompareEqual<uint1b_t>(
+      reinterpret_cast<uint1b_t const *>(ptr_A),
+      reinterpret_cast<uint1b_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU2:
+    return reference::device::BlockCompareEqual<uint2b_t>(
+      reinterpret_cast<uint2b_t const *>(ptr_A),
+      reinterpret_cast<uint2b_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU4:
+    return reference::device::BlockCompareEqual<uint4b_t>(
+      reinterpret_cast<uint4b_t const *>(ptr_A),
+      reinterpret_cast<uint4b_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU8:
+    return reference::device::BlockCompareEqual<uint8_t>(
+      reinterpret_cast<uint8_t const *>(ptr_A),
+      reinterpret_cast<uint8_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU16:
+    return reference::device::BlockCompareEqual<uint16_t>(
+      reinterpret_cast<uint16_t const *>(ptr_A),
+      reinterpret_cast<uint16_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU32:
+    return reference::device::BlockCompareEqual<uint32_t>(
+      reinterpret_cast<uint32_t const *>(ptr_A),
+      reinterpret_cast<uint32_t const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kU64:
+    return reference::device::BlockCompareEqual<uint64_t>(
+      reinterpret_cast<uint64_t const *>(ptr_A),
+      reinterpret_cast<uint64_t const *>(ptr_B),
+      capacity);
+
+  default:
+    throw std::runtime_error(std::string("Unsupported numeric type: ") + to_string(numeric_type));
+  }
+}
+
+/// Returns true if two blocks have approximately the same value
+bool DeviceAllocation::block_compare_relatively_equal(
+  library::NumericTypeID numeric_type,
+  void const *ptr_A,
+  void const *ptr_B,
+  size_t capacity,
+  double epsilon,
+  double nonzero_floor) {
+
+  switch (numeric_type) {
+  case library::NumericTypeID::kFE4M3:
+    return reference::device::BlockCompareRelativelyEqual<float_e4m3_t>(
+      reinterpret_cast<float_e4m3_t const *>(ptr_A),
+      reinterpret_cast<float_e4m3_t const *>(ptr_B),
+      capacity,
+      static_cast<float_e4m3_t>(epsilon),
+      static_cast<float_e4m3_t>(nonzero_floor));
+
+  case library::NumericTypeID::kFE5M2:
+    return reference::device::BlockCompareRelativelyEqual<float_e5m2_t>(
+      reinterpret_cast<float_e5m2_t const *>(ptr_A),
+      reinterpret_cast<float_e5m2_t const *>(ptr_B),
+      capacity,
+      static_cast<float_e5m2_t>(epsilon),
+      static_cast<float_e5m2_t>(nonzero_floor));
+  case library::NumericTypeID::kF16:
+    return reference::device::BlockCompareRelativelyEqual<half_t>(
+      reinterpret_cast<half_t const *>(ptr_A),
+      reinterpret_cast<half_t const *>(ptr_B),
+      capacity,
+      static_cast<half_t>(epsilon),
+      static_cast<half_t>(nonzero_floor));
+
+  case library::NumericTypeID::kBF16:
+    return reference::device::BlockCompareRelativelyEqual<bfloat16_t>(
+      reinterpret_cast<bfloat16_t const *>(ptr_A),
+      reinterpret_cast<bfloat16_t const *>(ptr_B),
+      capacity,
+      static_cast<bfloat16_t>(epsilon),
+      static_cast<bfloat16_t>(nonzero_floor));
+
+  case library::NumericTypeID::kTF32:
+    return reference::device::BlockCompareRelativelyEqual<tfloat32_t>(
+      reinterpret_cast<tfloat32_t const *>(ptr_A),
+      reinterpret_cast<tfloat32_t const *>(ptr_B),
+      capacity,
+      static_cast<tfloat32_t>(epsilon),
+      static_cast<tfloat32_t>(nonzero_floor));
+
+  case library::NumericTypeID::kF32:
+    return reference::device::BlockCompareRelativelyEqual<float>(
+      reinterpret_cast<float const *>(ptr_A),
+      reinterpret_cast<float const *>(ptr_B),
+      capacity,
+      static_cast<float>(epsilon),
+      static_cast<float>(nonzero_floor));
+
+  case library::NumericTypeID::kF64:
+    return reference::device::BlockCompareRelativelyEqual<double>(
+      reinterpret_cast<double const *>(ptr_A),
+      reinterpret_cast<double const *>(ptr_B),
+      capacity,
+      static_cast<double>(epsilon),
+      static_cast<double>(nonzero_floor));
+
+  case library::NumericTypeID::kS2:
+    return reference::device::BlockCompareRelativelyEqual<int2b_t>(
+      reinterpret_cast<int2b_t const *>(ptr_A),
+      reinterpret_cast<int2b_t const *>(ptr_B),
+      capacity,
+      static_cast<int2b_t>(epsilon),
+      static_cast<int2b_t>(nonzero_floor));
+
+  case library::NumericTypeID::kS4:
+    return reference::device::BlockCompareRelativelyEqual<int4b_t>(
+      reinterpret_cast<int4b_t const *>(ptr_A),
+      reinterpret_cast<int4b_t const *>(ptr_B),
+      capacity,
+      static_cast<int4b_t>(epsilon),
+      static_cast<int4b_t>(nonzero_floor));
+
+  case library::NumericTypeID::kS8:
+    return reference::device::BlockCompareRelativelyEqual<int8_t>(
+      reinterpret_cast<int8_t const *>(ptr_A),
+      reinterpret_cast<int8_t const *>(ptr_B),
+      capacity,
+      static_cast<int8_t>(epsilon),
+      static_cast<int8_t>(nonzero_floor));
+
+  case library::NumericTypeID::kS16:
+    return reference::device::BlockCompareRelativelyEqual<int16_t>(
+      reinterpret_cast<int16_t const *>(ptr_A),
+      reinterpret_cast<int16_t const *>(ptr_B),
+      capacity,
+      static_cast<int16_t>(epsilon),
+      static_cast<int16_t>(nonzero_floor));
+
+  case library::NumericTypeID::kS32:
+    return reference::device::BlockCompareRelativelyEqual<int32_t>(
+      reinterpret_cast<int32_t const *>(ptr_A),
+      reinterpret_cast<int32_t const *>(ptr_B),
+      capacity,
+      static_cast<int32_t>(epsilon),
+      static_cast<int32_t>(nonzero_floor));
+
+  case library::NumericTypeID::kS64:
+    return reference::device::BlockCompareRelativelyEqual<int64_t>(
+      reinterpret_cast<int64_t const *>(ptr_A),
+      reinterpret_cast<int64_t const *>(ptr_B),
+      capacity,
+      static_cast<int64_t>(epsilon),
+      static_cast<int64_t>(nonzero_floor));
+
+  case library::NumericTypeID::kB1:
+    return reference::device::BlockCompareRelativelyEqual<uint1b_t>(
+      reinterpret_cast<uint1b_t const *>(ptr_A),
+      reinterpret_cast<uint1b_t const *>(ptr_B),
+      capacity,
+      static_cast<uint1b_t>(epsilon),
+      static_cast<uint1b_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU2:
+    return reference::device::BlockCompareRelativelyEqual<uint2b_t>(
+      reinterpret_cast<uint2b_t const *>(ptr_A),
+      reinterpret_cast<uint2b_t const *>(ptr_B),
+      capacity,
+      static_cast<uint2b_t>(epsilon),
+      static_cast<uint2b_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU4:
+    return reference::device::BlockCompareRelativelyEqual<uint4b_t>(
+      reinterpret_cast<uint4b_t const *>(ptr_A),
+      reinterpret_cast<uint4b_t const *>(ptr_B),
+      capacity,
+      static_cast<uint4b_t>(epsilon),
+      static_cast<uint4b_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU8:
+    return reference::device::BlockCompareRelativelyEqual<uint8_t>(
+      reinterpret_cast<uint8_t const *>(ptr_A),
+      reinterpret_cast<uint8_t const *>(ptr_B),
+      capacity,
+      static_cast<uint8_t>(epsilon),
+      static_cast<uint8_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU16:
+    return reference::device::BlockCompareRelativelyEqual<uint16_t>(
+      reinterpret_cast<uint16_t const *>(ptr_A),
+      reinterpret_cast<uint16_t const *>(ptr_B),
+      capacity,
+      static_cast<uint16_t>(epsilon),
+      static_cast<uint16_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU32:
+    return reference::device::BlockCompareRelativelyEqual<uint32_t>(
+      reinterpret_cast<uint32_t const *>(ptr_A),
+      reinterpret_cast<uint32_t const *>(ptr_B),
+      capacity,
+      static_cast<uint32_t>(epsilon),
+      static_cast<uint32_t>(nonzero_floor));
+
+  case library::NumericTypeID::kU64:
+    return reference::device::BlockCompareRelativelyEqual<uint64_t>(
+      reinterpret_cast<uint64_t const *>(ptr_A),
+      reinterpret_cast<uint64_t const *>(ptr_B),
+      capacity,
+      static_cast<uint64_t>(epsilon),
+      static_cast<uint64_t>(nonzero_floor));
+
+  // No relatively equal comparison for complex numbers.
+  //
+  // As a simplification, we can require bitwise equality. This avoids false positives.
+  // (i.e. "pass" really means passing. "Fail" may not actually mean failure given appropriate epsilon.)
+  //
+  case library::NumericTypeID::kCF16:
+    return reference::device::BlockCompareEqual<cutlass::complex<half_t> >(
+      reinterpret_cast<complex<half_t> const *>(ptr_A),
+      reinterpret_cast<complex<half_t> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCF32:
+    return reference::device::BlockCompareEqual<cutlass::complex<float> >(
+      reinterpret_cast<complex<float> const *>(ptr_A),
+      reinterpret_cast<complex<float> const *>(ptr_B),
+      capacity);
+
+  case library::NumericTypeID::kCF64:
+    return reference::device::BlockCompareEqual<cutlass::complex<double> >(
+      reinterpret_cast<complex<double> const *>(ptr_A),
+      reinterpret_cast<complex<double> const *>(ptr_B),
+      capacity);
+
+  default:
+    {
+      throw std::runtime_error(std::string("Unsupported numeric type: ") + to_string(numeric_type));
+    }
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Permits copying dynamic vectors into static-length vectors
+template <typename TensorCoord, int Rank>
+struct vector_to_coord {
+
+  vector_to_coord(TensorCoord &coord, std::vector<int> const &vec) {
+
+    coord[Rank - 1] = vec.at(Rank - 1);
+
+    if (Rank > 1) {
+      vector_to_coord<TensorCoord, Rank - 1>(coord, vec);
+    }
+  }
+
+  vector_to_coord(TensorCoord &coord, std::vector<int64_t> const &vec) {
+
+    coord[Rank - 1] = (int)vec.at(Rank - 1);
+
+    if (Rank > 1) {
+      vector_to_coord<TensorCoord, Rank - 1>(coord, vec);
+    }
+  }
+};
+
+/// Permits copying dynamic vectors into static-length vectors
+template <typename TensorCoord>
+struct vector_to_coord<TensorCoord, 1> {
+
+  vector_to_coord(TensorCoord &coord, std::vector<int> const &vec) {
+
+    coord[0] = vec.at(0);
+  }
+
+  vector_to_coord(TensorCoord &coord, std::vector<int64_t> const &vec) {
+
+    coord[0] = (int)vec.at(0);
+  }
+};
+
+/// Permits copying dynamic vectors into static-length vectors
+template <typename TensorCoord>
+struct vector_to_coord<TensorCoord, 0> {
+
+  vector_to_coord(TensorCoord &coord, std::vector<int> const &vec) {
+
+  }
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename Element, typename Layout>
+static void write_tensor_csv_static_tensor_view(
+  std::ostream &out,
+  DeviceAllocation &allocation) {
+
+  Coord<Layout::kRank> extent;
+  Coord<Layout::kStrideRank, typename Layout::Stride::Index> stride;
+
+  if (allocation.extent().size() != Layout::kRank) {
+    throw std::runtime_error("Allocation extent has invalid rank");
+  }
+
+  if (allocation.stride().size() != Layout::kStrideRank) {
+    throw std::runtime_error("Allocation stride has invalid rank");
+  }
+
+  vector_to_coord<Coord<Layout::kRank>, Layout::kRank>(extent, allocation.extent());
+  vector_to_coord<Coord<Layout::kStrideRank, typename Layout::Stride::Index>,
+                        Layout::kStrideRank>(stride, allocation.stride());
+
+  Layout layout(stride);
+  HostTensor<Element, Layout> host_tensor(extent, layout, false);
+
+  if (host_tensor.capacity() != allocation.batch_stride()) {
+    throw std::runtime_error("Unexpected capacity to equal.");
+  }
+
+  host_tensor.copy_in_device_to_host(
+    static_cast<Element const *>(allocation.data()),
+    allocation.batch_stride());
+
+  TensorViewWrite(out, host_tensor.host_view());
+
+  out << "\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+static void write_tensor_csv_static_type(
+  std::ostream &out,
+  DeviceAllocation &allocation) {
+
+  switch (allocation.layout()) {
+    case library::LayoutTypeID::kRowMajor:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajor>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajor:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajor>(out, allocation);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK2:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajorInterleaved<2>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK2:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajorInterleaved<2>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK4:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajorInterleaved<4>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK4:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajorInterleaved<4>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK16:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajorInterleaved<16>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK16:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajorInterleaved<16>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK32:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajorInterleaved<32>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK32:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajorInterleaved<32>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kRowMajorInterleavedK64:
+      write_tensor_csv_static_tensor_view<T, layout::RowMajorInterleaved<64>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kColumnMajorInterleavedK64:
+      write_tensor_csv_static_tensor_view<T, layout::ColumnMajorInterleaved<64>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorNHWC:
+      write_tensor_csv_static_tensor_view<T, layout::TensorNHWC>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorNDHWC:
+      write_tensor_csv_static_tensor_view<T, layout::TensorNDHWC>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorNC32HW32:
+      write_tensor_csv_static_tensor_view<T, layout::TensorNCxHWx<32>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorNC64HW64:
+      write_tensor_csv_static_tensor_view<T, layout::TensorNCxHWx<64>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorC32RSK32:
+      write_tensor_csv_static_tensor_view<T, layout::TensorCxRSKx<32>>(out, allocation);
+      break;
+    case library::LayoutTypeID::kTensorC64RSK64:
+      write_tensor_csv_static_tensor_view<T, layout::TensorCxRSKx<64>>(out, allocation);
+      break;
+    default:
+      throw std::runtime_error("Unhandled layout");
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Writes a tensor to csv
+void DeviceAllocation::write_tensor_csv(
+  std::ostream &out) {
+
+  switch (this->type()) {
+  case library::NumericTypeID::kFE4M3:
+    write_tensor_csv_static_type<float_e4m3_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kFE5M2:
+    write_tensor_csv_static_type<float_e5m2_t>(out, *this);
+    break;
+  case library::NumericTypeID::kF16:
+    write_tensor_csv_static_type<half_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kBF16:
+    write_tensor_csv_static_type<bfloat16_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kTF32:
+    write_tensor_csv_static_type<tfloat32_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kF32:
+    write_tensor_csv_static_type<float>(out, *this);
+    break;
+
+  case library::NumericTypeID::kF64:
+    write_tensor_csv_static_type<double>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS2:
+    write_tensor_csv_static_type<int2b_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS4:
+    write_tensor_csv_static_type<int4b_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS8:
+    write_tensor_csv_static_type<int8_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS16:
+    write_tensor_csv_static_type<int16_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS32:
+    write_tensor_csv_static_type<int32_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kS64:
+    write_tensor_csv_static_type<int64_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kB1:
+    write_tensor_csv_static_type<uint1b_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU2:
+    write_tensor_csv_static_type<uint2b_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU4:
+    write_tensor_csv_static_type<uint4b_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU8:
+    write_tensor_csv_static_type<uint8_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU16:
+    write_tensor_csv_static_type<uint16_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU32:
+    write_tensor_csv_static_type<uint32_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kU64:
+    write_tensor_csv_static_type<uint64_t>(out, *this);
+    break;
+
+  case library::NumericTypeID::kCF16:
+    write_tensor_csv_static_type<cutlass::complex<half_t> >(out, *this);
+    break;
+
+  case library::NumericTypeID::kCF32:
+    write_tensor_csv_static_type<cutlass::complex<float> >(out, *this);
+    break;
+
+  case library::NumericTypeID::kCF64:
+    write_tensor_csv_static_type<cutlass::complex<double> >(out, *this);
+    break;
+
+  case library::NumericTypeID::kVoid:
+    // Not dump anything as it is a empty tensor.
+    break;
+
+  default:
+    throw std::runtime_error(std::string("Unsupported numeric type: ") + to_string(this->type()) ) ;
+  }
+}
+
+template <typename Element, typename Layout>
+static void tensor_fill_tensor_view(DeviceAllocation &allocation, Element val = Element()) {
+  Coord<Layout::kRank> extent;
+  Coord<Layout::kStrideRank, typename Layout::LongIndex> stride;
+
+  if (allocation.extent().size() != Layout::kRank) {
+    throw std::runtime_error("Allocation extent has invalid rank");
+  }
+
+  if (allocation.stride().size() != Layout::kStrideRank) {
+    throw std::runtime_error("Allocation stride has invalid rank");
+  }
+
+  vector_to_coord<Coord<Layout::kRank>, Layout::kRank>(extent, allocation.extent());
+  vector_to_coord<Coord<Layout::kStrideRank, typename Layout::LongIndex>,
+                        Layout::kStrideRank>(stride, allocation.stride());
+
+  TensorView<Element, Layout> view(
+    static_cast<Element *>(allocation.data()),
+    Layout(stride),
+    extent
+  );
+
+
+  cutlass::reference::device::TensorFill<Element, Layout>(
+    view,
+    val
+  );
+}
+
+template <typename Element>
+static void tensor_fill(DeviceAllocation &allocation, Element val = Element()) {
+  switch (allocation.layout()) {
+    case library::LayoutTypeID::kRowMajor:
+      tensor_fill_tensor_view<Element, layout::RowMajor>(allocation, val);
+      break;
+    case library::LayoutTypeID::kColumnMajor:
+      tensor_fill_tensor_view<Element, layout::ColumnMajor>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorNHWC:
+      tensor_fill_tensor_view<Element, layout::TensorNHWC>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorNDHWC:
+      tensor_fill_tensor_view<Element, layout::TensorNDHWC>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorNC32HW32:
+      tensor_fill_tensor_view<Element, layout::TensorNCxHWx<32>>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorNC64HW64:
+      tensor_fill_tensor_view<Element, layout::TensorNCxHWx<64>>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorC32RSK32:
+      tensor_fill_tensor_view<Element, layout::TensorCxRSKx<32>>(allocation, val);
+      break;
+    case library::LayoutTypeID::kTensorC64RSK64:
+      tensor_fill_tensor_view<Element, layout::TensorCxRSKx<64>>(allocation, val);
+      break;
+    default:
+    throw std::runtime_error("Unsupported layout");
+      break;
+  }
+}
+
+/// Fills a tensor uniformly with a value (most frequently used to clear the tensor)
+void DeviceAllocation::fill_device(double val = 0.0) {
+
+  switch (this->type()) {
+  case library::NumericTypeID::kFE4M3:
+    tensor_fill<float_e4m3_t>(*this, static_cast<float_e4m3_t>(val));
+    break;
+
+  case library::NumericTypeID::kFE5M2:
+    tensor_fill<float_e5m2_t>(*this, static_cast<float_e5m2_t>(val));
+    break;
+  case library::NumericTypeID::kF16:
+    tensor_fill<half_t>(*this, static_cast<half_t>(val));
+    break;
+
+  case library::NumericTypeID::kBF16:
+    tensor_fill<bfloat16_t>(*this, static_cast<bfloat16_t>(val));
+    break;
+
+  case library::NumericTypeID::kTF32:
+    tensor_fill<tfloat32_t>(*this, static_cast<tfloat32_t>(val));
+    break;
+
+  case library::NumericTypeID::kF32:
+    tensor_fill<float>(*this, static_cast<float>(val));
+    break;
+
+  case library::NumericTypeID::kF64:
+    tensor_fill<double>(*this, static_cast<double>(val));
+    break;
+
+  case library::NumericTypeID::kS2:
+    tensor_fill<int2b_t>(*this, static_cast<int2b_t>(val));
+    break;
+
+  case library::NumericTypeID::kS4:
+    tensor_fill<int4b_t>(*this, static_cast<int4b_t>(val));
+    break;
+
+  case library::NumericTypeID::kS8:
+    tensor_fill<int8_t>(*this, static_cast<int8_t>(val));
+    break;
+
+  case library::NumericTypeID::kS16:
+    tensor_fill<int16_t>(*this, static_cast<int16_t>(val));
+    break;
+
+  case library::NumericTypeID::kS32:
+    tensor_fill<int32_t>(*this, static_cast<int32_t>(val));
+    break;
+
+  case library::NumericTypeID::kS64:
+    tensor_fill<int64_t>(*this, static_cast<int64_t>(val));
+    break;
+
+  case library::NumericTypeID::kB1:
+    tensor_fill<uint1b_t>(*this, static_cast<uint1b_t>(val));
+    break;
+
+  case library::NumericTypeID::kU2:
+    tensor_fill<uint2b_t>(*this, static_cast<uint2b_t>(val));
+    break;
+
+  case library::NumericTypeID::kU4:
+    tensor_fill<uint4b_t>(*this, static_cast<uint4b_t>(val));
+    break;
+
+  case library::NumericTypeID::kU8:
+    tensor_fill<uint8_t>(*this, static_cast<uint8_t>(val));
+    break;
+
+  case library::NumericTypeID::kU16:
+    tensor_fill<uint16_t>(*this, static_cast<uint16_t>(val));
+    break;
+
+  case library::NumericTypeID::kU32:
+    tensor_fill<uint32_t>(*this, static_cast<uint32_t>(val));
+    break;
+
+  case library::NumericTypeID::kU64:
+    tensor_fill<uint64_t>(*this, static_cast<uint64_t>(val));
+    break;
+
+  case library::NumericTypeID::kCF16:
+    tensor_fill<cutlass::complex<half_t> >(*this, from_real<half_t>(val));
+    break;
+
+  case library::NumericTypeID::kCF32:
+    tensor_fill<cutlass::complex<float> >(*this, from_real<float>(val));
+    break;
+
+  case library::NumericTypeID::kCF64:
+    tensor_fill<cutlass::complex<double> >(*this, from_real<double>(val));
+    break;
+
+  default:
+    throw std::runtime_error(std::string("Unsupported numeric type: ") + to_string(this->type()));
+  }
+}
+
+/// Fills a tensor uniformly with a value (most frequently used to clear the tensor)
+void DeviceAllocation::fill_host(double val = 0.0) {
+
+  std::vector<uint8_t> host_data(bytes());
+
+  switch (this->type()) {
+  case library::NumericTypeID::kFE4M3:
+    cutlass::reference::host::BlockFill<float_e4m3_t>(
+      reinterpret_cast<float_e4m3_t *>(host_data.data()),
+      capacity_,
+      static_cast<float_e4m3_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kFE5M2:
+    cutlass::reference::host::BlockFill<float_e5m2_t>(
+      reinterpret_cast<float_e5m2_t *>(host_data.data()),
+      capacity_,
+      static_cast<float_e5m2_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kF16:
+    cutlass::reference::host::BlockFill<half_t>(
+      reinterpret_cast<half_t *>(host_data.data()),
+      capacity_,
+      static_cast<half_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kBF16:
+    cutlass::reference::host::BlockFill<bfloat16_t>(
+      reinterpret_cast<bfloat16_t *>(host_data.data()),
+      capacity_,
+      static_cast<bfloat16_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kTF32:
+    cutlass::reference::host::BlockFill<tfloat32_t>(
+      reinterpret_cast<tfloat32_t *>(host_data.data()),
+      capacity_,
+      static_cast<tfloat32_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kF32:
+    cutlass::reference::host::BlockFill<float>(
+      reinterpret_cast<float *>(host_data.data()),
+      capacity_,
+      static_cast<float>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kF64:
+    cutlass::reference::host::BlockFill<double>(
+      reinterpret_cast<double *>(host_data.data()),
+      capacity_,
+      static_cast<double>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS2:
+    cutlass::reference::host::BlockFill<int2b_t>(
+      reinterpret_cast<int2b_t *>(host_data.data()),
+      capacity_,
+      static_cast<int2b_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS4:
+    cutlass::reference::host::BlockFill<int4b_t>(
+      reinterpret_cast<int4b_t *>(host_data.data()),
+      capacity_,
+      static_cast<int4b_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS8:
+    cutlass::reference::host::BlockFill<int8_t>(
+      reinterpret_cast<int8_t *>(host_data.data()),
+      capacity_,
+      static_cast<int8_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS16:
+    cutlass::reference::host::BlockFill<int16_t>(
+      reinterpret_cast<int16_t *>(host_data.data()),
+      capacity_,
+      static_cast<int16_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS32:
+    cutlass::reference::host::BlockFill<int32_t>(
+      reinterpret_cast<int32_t *>(host_data.data()),
+      capacity_,
+      static_cast<int32_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kS64:
+    cutlass::reference::host::BlockFill<int64_t>(
+      reinterpret_cast<int64_t *>(host_data.data()),
+      capacity_,
+      static_cast<int64_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kB1:
+    cutlass::reference::host::BlockFill<uint1b_t>(
+      reinterpret_cast<uint1b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint1b_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU2:
+    cutlass::reference::host::BlockFill<uint2b_t>(
+      reinterpret_cast<uint2b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint2b_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU4:
+    cutlass::reference::host::BlockFill<uint4b_t>(
+      reinterpret_cast<uint4b_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint4b_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU8:
+    cutlass::reference::host::BlockFill<uint8_t>(
+      reinterpret_cast<uint8_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint8_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU16:
+    cutlass::reference::host::BlockFill<uint16_t>(
+      reinterpret_cast<uint16_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint16_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU32:
+    cutlass::reference::host::BlockFill<uint32_t>(
+      reinterpret_cast<uint32_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint32_t>(val)
+    );
+    break;
+
+  case library::NumericTypeID::kU64:
+    cutlass::reference::host::BlockFill<uint64_t>(
+      reinterpret_cast<uint64_t *>(host_data.data()),
+      capacity_,
+      static_cast<uint64_t>(val)
+    );
+    break;
+
+  default:
+    throw std::runtime_error(std::string("Unsupported numeric type: ") + to_string(this->type()));
+  }
+
+  copy_from_host(host_data.data());
+}
+
+cudaError_t DeviceAllocation::malloc(void** ptr, size_t size) {
+  cudaError_t result;
+  int set_device_back_to = -1;
+
+  /// When needed this sets the device to the allocation's device remembering
+  /// the current device so that it can be set back after the cudaMalloc is
+  /// performed.
+  if (device_ >= 0) {
+    int current_device;
+    result = cudaGetDevice(&current_device);
+    if (result != cudaSuccess) {
+      return result;
+    }
+
+    if (current_device != device_) {
+      set_device_back_to = current_device;
+      result = cudaSetDevice(device_);
+      if (result != cudaSuccess) {
+        return result;
+      }
+    }
+  }
+
+  // This performs the cudaMalloc
+  result = cudaMalloc(ptr, size);
+  if (result != cudaSuccess) {
+    return result;
+  }
+
+  /// When needed this sets the device back to what it was when the function was
+  /// called.
+  if (set_device_back_to != -1) {
+    result = cudaSetDevice(set_device_back_to);
+    if (result != cudaSuccess) {
+      return result;
+    }
+  }
+
+  return cudaSuccess;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/device_context.cu

@@ -0,0 +1,245 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief
+*/
+
+#include "cutlass/profiler/device_context.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Allocates memory of a given type, capacity (elements), and name
+DeviceAllocation *DeviceContext::allocate_block(
+  Options const &options,
+  std::string const &name,
+  library::NumericTypeID type,
+  size_t capacity,
+  size_t device_index) {
+
+  int device = options.device.device_id(device_index);
+  device_memory_.emplace_back(type, capacity, device);
+  DeviceAllocation *allocation = &device_memory_.back();
+
+  allocations_[name] = allocation;
+  return allocation;
+}
+
+/// Allocates memory of a given type, capacity (elements), and name
+DeviceAllocation *DeviceContext::allocate_tensor(
+  Options const &options,
+  std::string const &name,
+  library::NumericTypeID type,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> const &stride,
+  int batch_count,
+  size_t device_index) {
+
+  int device = options.device.device_id(device_index);
+  device_memory_.emplace_back(type, layout_id, extent, stride, batch_count,
+                              device);
+  DeviceAllocation *allocation = &device_memory_.back();
+
+  allocations_[name] = allocation;
+  return allocation;
+}
+
+/// Allocates memory of a given type, capacity (elements), and name
+DeviceAllocation *DeviceContext::allocate_and_initialize_tensor(
+  Options const &options,
+  std::string const &name,
+  library::NumericTypeID type,
+  library::LayoutTypeID layout_id,
+  std::vector<int> const &extent,
+  std::vector<int64_t> const &stride,
+  int batch_count,
+  int seed_shift,
+  size_t device_index) {
+
+  DeviceAllocation *allocation =
+      allocate_tensor(options, name, type, layout_id, extent, stride,
+                      batch_count, device_index);
+
+  if (options.initialization.enabled) {
+    Distribution data_distribution = options.initialization.data_distribution;
+
+    // check if data distribution is allowed to change
+    if(!options.initialization.fix_data_distribution) {
+      // change data distribution based on bit width
+      switch(type) {
+        case library::NumericTypeID::kFE4M3:
+          data_distribution.set_uniform(-1, 1, 0);
+          break;
+        case library::NumericTypeID::kFE5M2:
+          data_distribution.set_uniform(-1, 1, 0);
+          break;
+        case library::NumericTypeID::kF16:
+          data_distribution.set_uniform(-3, 3, 0);
+          break;
+        case library::NumericTypeID::kB1:
+          data_distribution.set_uniform(0, 1, 0);
+          break;
+        case library::NumericTypeID::kS2:
+          data_distribution.set_uniform(-1, 1, 0);
+          break;
+        case library::NumericTypeID::kS4:
+          data_distribution.set_uniform(-2, 2, 0);
+          break;
+        case library::NumericTypeID::kU2:
+          data_distribution.set_uniform(0, 2, 0);
+          break;
+        case library::NumericTypeID::kU4:
+          data_distribution.set_uniform(0, 2, 0);
+          break;
+        case library::NumericTypeID::kS8:
+          data_distribution.set_uniform(-3, 3, 0);
+          break;
+        case library::NumericTypeID::kU8:
+          data_distribution.set_uniform(0, 4, 0);
+          break;
+        default: break;
+      }
+    }
+
+    // Override pnz for the A/B/C tensors if overridden for Gaussian distributions
+    if (data_distribution.kind == Distribution::Gaussian) {
+      double mean = data_distribution.gaussian.mean;
+      double stddev = data_distribution.gaussian.stddev;
+      int scale = data_distribution.int_scale;
+
+      if (name == "A" && data_distribution.gaussian.pnzA != 1.0) {
+        data_distribution.set_gaussian(mean, stddev, scale, data_distribution.gaussian.pnzA);
+      }
+      else if (name == "B" && data_distribution.gaussian.pnzB != 1.0) {
+        data_distribution.set_gaussian(mean, stddev, scale, data_distribution.gaussian.pnzB);
+      }
+      else if (name == "C" && data_distribution.gaussian.pnzC != 1.0) {
+        data_distribution.set_gaussian(mean, stddev, scale, data_distribution.gaussian.pnzC);
+      }
+    }
+
+    if (options.initialization.provider == library::Provider::kReferenceDevice) {
+      if (data_distribution.kind == Distribution::Sequential) {
+        allocation->initialize_sequential_device(
+          data_distribution);
+      }
+      else {
+        allocation->initialize_random_device(
+          options.initialization.seed + seed_shift,
+          data_distribution);
+      }
+    }
+    else if (options.initialization.provider == library::Provider::kReferenceHost) {
+      if (data_distribution.kind == Distribution::Sequential) {
+        allocation->initialize_sequential_host(
+          data_distribution);
+      }
+      else {
+        allocation->initialize_random_host(
+          options.initialization.seed + seed_shift,
+          data_distribution);
+      }
+    }
+  }
+
+  return allocation;
+}
+
+/// Allocates memory for sparse meta data
+DeviceAllocation *DeviceContext::allocate_and_initialize_sparsemeta_tensor(
+  Options const &options,
+  std::string const &name,
+  library::NumericTypeID type,
+  library::LayoutTypeID layout_id,
+  library::NumericTypeID type_a,
+  std::vector<int> const &extent,
+  std::vector<int64_t> const &stride,
+  int batch_count,
+  int seed_shift,
+  size_t device_index) {
+
+  DeviceAllocation *allocation =
+      allocate_tensor(options, name, type, layout_id, extent, stride,
+                      batch_count, device_index);
+
+  if (options.initialization.enabled) {
+    // TF32 has 4bit meta data.  The rest has 2bit.
+    int MetaSizeInBits = (cutlass::library::sizeof_bits(type_a) == 32) ? 4 : 2;
+
+    if (options.initialization.provider == library::Provider::kReferenceDevice) {
+      allocation->initialize_random_sparsemeta_device(
+        options.initialization.seed + seed_shift,
+        MetaSizeInBits);
+    }
+    else if (options.initialization.provider == library::Provider::kReferenceHost) {
+      allocation->initialize_random_sparsemeta_host(
+        options.initialization.seed + seed_shift,
+        MetaSizeInBits);
+    }
+  }
+
+  return allocation;
+}
+/// Clears named allocations (but does not necessarily free memory)
+void DeviceContext::clear() {
+  allocations_.clear();
+}
+
+/// Frees all device memory allocations
+void DeviceContext::free() {
+  allocations_.clear();
+  device_memory_.clear();
+}
+
+/// Gets the allocation by name
+DeviceAllocation &DeviceContext::at(std::string const &name) {
+  return *allocations_.at(name);
+}
+
+size_t DeviceContext::size() const {
+  return allocations_.size();
+}
+
+DeviceContext::AllocationMap::iterator DeviceContext::begin() {
+  return allocations_.begin();
+}
+
+DeviceContext::AllocationMap::iterator DeviceContext::end() {
+  return allocations_.end();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/enumerated_types.cpp

@@ -0,0 +1,275 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Provides several functions for filling tensors with data.
+*/
+
+#include "cutlass/profiler/enumerated_types.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static struct {
+  char const *text;
+  char const *pretty;
+  ExecutionMode enumerant;
+}
+ExecutionMode_enumerants[] = {
+  {"profile", "Profile", ExecutionMode::kProfile},
+  {"dry_run", "Dry run", ExecutionMode::kDryRun},
+  {"dry", "dry run", ExecutionMode::kDryRun},
+  {"trace", "Trace", ExecutionMode::kTrace},
+  {"enumerate", "Enumerate", ExecutionMode::kEnumerate}
+};
+
+/// Converts a ExecutionMode enumerant to a string
+char const *to_string(ExecutionMode mode, bool pretty) {
+
+  for (auto const & possible : ExecutionMode_enumerants) {
+    if (mode == possible.enumerant) {
+      if (pretty) {
+        return possible.pretty;
+      }
+      else {
+        return possible.text;
+      }
+    }
+  }
+
+  return pretty ? "Invalid" : "invalid";
+}
+
+/// Parses a ExecutionMode enumerant from a string
+template <>
+ExecutionMode from_string<ExecutionMode>(std::string const &str) {
+
+  for (auto const & possible : ExecutionMode_enumerants) {
+    if ((str.compare(possible.text) == 0) ||
+        (str.compare(possible.pretty) == 0)) {
+      return possible.enumerant;
+    }
+  }
+
+  return ExecutionMode::kInvalid;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static struct {
+  char const *text;
+  char const *pretty;
+  AlgorithmMode enumerant;
+}
+AlgorithmMode_enumerants[] = {
+  {"matching", "Matching", AlgorithmMode::kMatching},
+  {"best", "Best", AlgorithmMode::kBest},
+  {"default", "Default", AlgorithmMode::kDefault}
+};
+
+/// Converts a ExecutionMode enumerant to a string
+char const *to_string(AlgorithmMode mode, bool pretty) {
+
+  for (auto const & possible : AlgorithmMode_enumerants) {
+    if (mode == possible.enumerant) {
+      if (pretty) {
+        return possible.pretty;
+      }
+      else {
+        return possible.text;
+      }
+    }
+  }
+
+  return pretty ? "Invalid" : "invalid";
+}
+
+/// Parses a ExecutionMode enumerant from a string
+template <>
+AlgorithmMode from_string<AlgorithmMode>(std::string const &str) {
+
+  for (auto const & possible : AlgorithmMode_enumerants) {
+    if ((str.compare(possible.text) == 0) ||
+        (str.compare(possible.pretty) == 0)) {
+      return possible.enumerant;
+    }
+  }
+
+  return AlgorithmMode::kInvalid;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static struct {
+  char const *text;
+  char const *pretty;
+  Disposition enumerant;
+}
+Disposition_enumerants[] = {
+  {"passed", "Passed", Disposition::kPassed},
+  {"failed", "Failed", Disposition::kFailed},
+  {"not_run", "Not run", Disposition::kNotRun},
+  {"not_verified", "Not verified", Disposition::kNotVerified},
+  {"invalid_problem", "Invalid problem", Disposition::kInvalidProblem},
+  {"not_supported", "Not supported", Disposition::kNotSupported},
+  {"incorrect", "Incorrect", Disposition::kIncorrect}
+};
+
+/// Converts a Disposition enumerant to a string
+char const *to_string(Disposition disposition, bool pretty) {
+
+  for (auto const & possible : Disposition_enumerants) {
+    if (disposition == possible.enumerant) {
+      if (pretty) {
+        return possible.pretty;
+      }
+      else {
+        return possible.text;
+      }
+    }
+  }
+  
+  return pretty ? "Invalid" : "invalid";
+}
+
+/// Parses a Disposition enumerant from a string
+template <>
+Disposition from_string<Disposition>(std::string const &str) {
+
+  for (auto const & possible : Disposition_enumerants) {
+    if ((str.compare(possible.text) == 0) ||
+        (str.compare(possible.pretty) == 0)) {
+      return possible.enumerant;
+    }
+  }
+
+  return Disposition::kInvalid;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static struct {
+  char const *text;
+  char const *pretty;
+  SaveWorkspace enumerant;
+}
+SaveWorkspace_enumerants[] = {
+  {"never", "Never", SaveWorkspace::kNever},
+  {"incorrect", "Incorrect", SaveWorkspace::kIncorrect},
+  {"always", "Always", SaveWorkspace::kAlways}
+};
+
+/// Converts a SaveWorkspace enumerant to a string
+char const *to_string(SaveWorkspace save_option, bool pretty) {
+
+  for (auto const & possible : SaveWorkspace_enumerants) {
+    if (save_option == possible.enumerant) {
+      if (pretty) {
+        return possible.pretty;
+      }
+      else {
+        return possible.text;
+      }
+    }
+  }
+  
+  return pretty ? "Invalid" : "invalid";
+}
+
+/// Parses a SaveWorkspace enumerant from a string
+template <>
+SaveWorkspace from_string<SaveWorkspace>(std::string const &str) {
+
+  for (auto const & possible : SaveWorkspace_enumerants) {
+    if ((str.compare(possible.text) == 0) ||
+        (str.compare(possible.pretty) == 0)) {
+      return possible.enumerant;
+    }
+  }
+
+  return SaveWorkspace::kInvalid;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+static struct {
+  char const *text;
+  char const *pretty;
+  ArgumentTypeID enumerant;
+}
+ArgumentTypeID_enumerants[] = {
+  {"scalar", "Scalar", ArgumentTypeID::kScalar},
+  {"int", "Integer", ArgumentTypeID::kInteger},
+  {"tensor", "Tensor", ArgumentTypeID::kTensor},
+  {"batched_tensor", "BatchedTensor", ArgumentTypeID::kBatchedTensor},
+  {"struct", "Struct", ArgumentTypeID::kStructure},
+  {"enum", "Enumerated type", ArgumentTypeID::kEnumerated}
+};
+
+/// Converts a ArgumentTypeID enumerant to a string
+char const *to_string(ArgumentTypeID type, bool pretty) {
+
+  for (auto const & possible : ArgumentTypeID_enumerants) {
+    if (type == possible.enumerant) {
+      if (pretty) {
+        return possible.pretty;
+      }
+      else {
+        return possible.text;
+      }
+    }
+  }
+
+  return pretty ? "Invalid" : "invalid";
+}
+
+/// Parses a ArgumentTypeID enumerant from a string
+template <>
+ArgumentTypeID from_string<ArgumentTypeID>(std::string const &str) {
+
+  for (auto const & possible : ArgumentTypeID_enumerants) {
+    if ((str.compare(possible.text) == 0) ||
+        (str.compare(possible.pretty) == 0)) {
+      return possible.enumerant;
+    }
+  }
+
+  return ArgumentTypeID::kInvalid;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/gemm_operation_profiler.cu

@@ -0,0 +1,1298 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+#include <vector>
+
+#include "cutlass/core_io.h"
+#include <cuda_runtime_api.h>
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/gemm_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+#include "cutlass/library/singleton.h"
+#include "cutlass/library/library.h"
+#include "cutlass/library/handle.h"
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+GemmOperationProfiler::GemmOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kGemm,
+    {
+      {ArgumentTypeID::kEnumerated, {"gemm_kind"}, "Variant of GEMM (universal, gemm, planar_complex, planar_complex_array)"},
+      {ArgumentTypeID::kInteger, {"m", "problem-size::m"}, "M dimension of the GEMM problem space"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the GEMM problem space"},
+      {ArgumentTypeID::kInteger, {"k", "problem-size::k"}, "K dimension of the GEMM problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kTensor, {"B"}, "Tensor storing the B operand"},
+      {ArgumentTypeID::kTensor, {"C"}, "Tensor storing the C operand"},
+      {ArgumentTypeID::kTensor, {"D"}, "Tensor storing the D output"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kEnumerated, {"split_k_mode", "split-k-mode"}, "Variant of split K mode(serial, parallel)"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count", "batch-count"}, "Number of GEMMs computed in one batch"},
+      {ArgumentTypeID::kEnumerated, {"raster_order", "raster-order"}, "Raster order (heuristic, along_n, along_m)"},
+      {ArgumentTypeID::kInteger, {"swizzle_size", "swizzle-size"}, "Size to swizzle"},
+    },
+    { library::Provider::kCUBLAS}
+  ) {
+
+  description_ = "      General matrix-matrix product. D = alpha * A*B + beta * C";
+}
+
+/// Destructor
+GemmOperationProfiler::~GemmOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void GemmOperationProfiler::print_usage(std::ostream &out) const {
+  out << "GEMM" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void GemmOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size:\n"
+    << "  $ cutlass_profiler --operation=Gemm --m=1024 --n=1024 --k=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=Gemm --m=1024:4096:256 --n=1024:4096:256 --k=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=Gemm --accumulator-type=f16,f32\n\n"
+
+    << "Run when A is f16 with column-major and B is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=Gemm --A=f16:column --B=*:row\n\n"
+
+    << "Profile a particular problem size with split K and parallel reduction:\n"
+    << "  $ cutlass_profiler --operation=Gemm --split_k_mode=parallel --split_k_slices=2 --m=1024 --n=1024 --k=128\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=Gemm --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=Gemm --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=Gemm --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=Gemm --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to gemm kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=Gemm \\ \n"
+    << "   --m=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --n=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --k=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+Status GemmOperationProfiler::GemmProblem::parse(
+  library::GemmDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  this->mode = library::GemmUniversalMode::kGemm;
+
+  if (!arg_as_int(this->m, "m", problem_space, problem)) {
+    // default value
+    this->m = 1024;
+  }
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->k, "k", problem_space, problem)) {
+    // default value
+    this->k = 1024;
+  }
+
+  if (!arg_as_SplitKModeID(this->split_k_mode, "split_k_mode", problem_space, problem)) {
+    // default value
+    this->split_k_mode = library::SplitKMode::kSerial;
+  }
+
+  this->mode = library::GemmUniversalMode::kGemm;
+  if (this->split_k_mode == library::SplitKMode::kParallel) {
+    this->mode = library::GemmUniversalMode::kGemmSplitKParallel;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  } else if (this->batch_count > 1) {
+    this->mode = library::GemmUniversalMode::kBatched;
+  }
+
+  if (!arg_as_int(this->swizzle_size, "swizzle_size", problem_space, problem)) {
+    // default value
+    this->swizzle_size = 1;
+    if (this->swizzle_size <= 0) {
+      return Status::kErrorInvalidProblem;
+    }
+  }
+
+  if (!arg_as_RasterOrder(this->raster_order, "raster_order", problem_space, problem)) {
+    // default value
+    this->raster_order = library::RasterOrder::kHeuristic;
+  }
+
+  if (this->split_k_slices > 1 && this->batch_count > 1) {
+    // At least one of these must be one
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.B, "B", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.C, "C", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.D, "D", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  this->lda = DeviceAllocation::get_packed_layout(
+    operation_desc.A.layout, {int(this->m), int(this->k)}).front();
+
+  this->ldb = DeviceAllocation::get_packed_layout(
+    operation_desc.B.layout, {int(this->k), int(this->n)}).front();
+
+  this->ldc = DeviceAllocation::get_packed_layout(
+    operation_desc.C.layout, {int(this->m), int(this->n)}).front();
+
+  return Status::kSuccess;
+}
+
+/// Total number of bytes loaded
+int64_t GemmOperationProfiler::GemmProblem::bytes(library::GemmDescription const &operation_desc) const {
+  // Input bytes read and Output bytes written for the gemm problem
+  int64_t bytes =
+    int64_t(library::sizeof_bits(operation_desc.A.element) * m / 8) * k +
+    int64_t(library::sizeof_bits(operation_desc.B.element) * n / 8) * k +
+    int64_t(library::sizeof_bits(operation_desc.C.element) * m / 8) * n;
+
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(beta.begin(), beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    bytes += int64_t(library::sizeof_bits(operation_desc.C.element) * m / 8) * n;
+  }
+
+  bytes *= batch_count;
+
+  return bytes;
+}
+
+/// Total number of flops computed
+int64_t GemmOperationProfiler::GemmProblem::flops(library::GemmDescription const &operation_desc) const {
+  int64_t flops_ = (int64_t(m) * n * k + m * n) * 2 * batch_count;
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddGaussianComplex:
+    flops_ *= 3;
+    break;
+
+  default: break;
+  }
+
+  return flops_;
+}
+
+
+/// Initializes a performance result
+void GemmOperationProfiler::GemmProblem::initialize_result(
+  PerformanceResult &result,
+  library::GemmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "gemm_kind", problem_space, library::to_string(operation_desc.gemm_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "B", problem_space,
+    std::string(library::to_string(operation_desc.B.element)) + ":" + library::to_string(operation_desc.B.layout));
+
+  set_argument(result, "C", problem_space,
+    std::string(library::to_string(operation_desc.C.element)) + ":" + library::to_string(operation_desc.C.layout));
+
+  set_argument(result, "D", problem_space,
+    std::string(library::to_string(operation_desc.D.element)) + ":" + library::to_string(operation_desc.D.layout));
+
+  set_argument(result, "m", problem_space, m);
+  set_argument(result, "n", problem_space, n);
+  set_argument(result, "k", problem_space, k);
+
+  set_argument(result, "split_k_mode", problem_space, library::to_string(split_k_mode));
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+  set_argument(result, "raster_order", problem_space, library::to_string(raster_order));
+  set_argument(result, "swizzle_size", problem_space, swizzle_size);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status GemmOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::GemmDescription const &operation_desc =
+    static_cast<library::GemmDescription const &>(operation->description());
+
+  if (operation_desc.gemm_kind != library::GemmKind::kUniversal) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  gemm_workspace_.configuration.mode = problem_.mode;
+  gemm_workspace_.configuration.problem_size.m() = int(problem_.m);
+  gemm_workspace_.configuration.problem_size.n() = int(problem_.n);
+  gemm_workspace_.configuration.problem_size.k() = int(problem_.k);
+  gemm_workspace_.configuration.lda = problem_.lda;
+  gemm_workspace_.configuration.ldb = problem_.ldb;
+  gemm_workspace_.configuration.ldc = problem_.ldc;
+  gemm_workspace_.configuration.ldd = problem_.ldc;
+
+  if (problem_.mode == library::GemmUniversalMode::kBatched) {
+    gemm_workspace_.configuration.batch_count = problem_.batch_count;
+  }
+  else {
+    gemm_workspace_.configuration.batch_count = problem_.split_k_slices;
+  }
+
+  gemm_workspace_.arguments.A = nullptr;
+  gemm_workspace_.arguments.B = nullptr;
+  gemm_workspace_.arguments.C = nullptr;
+  gemm_workspace_.arguments.D = nullptr;
+  gemm_workspace_.arguments.alpha = problem_.alpha.data();
+  gemm_workspace_.arguments.beta = problem_.beta.data();
+  gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+  gemm_workspace_.arguments.swizzle_size = problem_.swizzle_size;
+  gemm_workspace_.arguments.raster_order = problem_.raster_order;
+  // initialize reduction operation for parallel splitKMode
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    if (!initialize_reduction_configuration_(operation, problem)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&gemm_workspace_.configuration, &gemm_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void GemmOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::GemmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+  result.bytes = problem_.bytes(operation_desc);
+  result.flops = problem_.flops(operation_desc);
+  result.runtime = 0;
+
+}
+
+/// Initialize reduction problem dimensions and library::Operation
+bool GemmOperationProfiler::initialize_reduction_configuration_(
+  library::Operation const *operation,
+  ProblemSpace::Problem const &problem) {
+
+  library::GemmDescription const &gemm_desc =
+    static_cast<library::GemmDescription const&>(operation->description());
+
+  if (!cast_from_double(problem_.alpha_one, gemm_desc.element_epilogue, 1)) {
+    return false;
+  }
+
+  if (!cast_from_double(problem_.beta_zero, gemm_desc.element_epilogue, 0)) {
+    return false;
+  }
+
+  /// initialize library::ReductionConfiguration
+  gemm_workspace_.reduction_configuration.problem_size      = gemm::GemmCoord(int(problem_.n), int(problem_.m), int(problem_.k)).mn();
+  gemm_workspace_.reduction_configuration.partitions        = int(problem_.split_k_slices);
+  gemm_workspace_.reduction_configuration.partition_stride  = gemm::GemmCoord(int(problem_.n), int(problem_.m), int(problem_.k)).mn().product();
+  gemm_workspace_.reduction_configuration.ldw               = problem_.ldc;
+  gemm_workspace_.reduction_configuration.lds               = problem_.ldc;
+  gemm_workspace_.reduction_configuration.ldd               = problem_.ldc;
+
+  // find reduction operation
+  library::ReductionFunctionalKey reduction_key(
+    library::Provider::kCUTLASS,
+    gemm_desc.tile_description.math_instruction.element_accumulator,    // element workspace
+    gemm_desc.tile_description.math_instruction.element_accumulator,    // element accumulator
+    gemm_desc.D.element,                                                // element output
+    gemm_desc.element_epilogue                                          // element compute
+  );
+
+  auto reduction_it = library::Singleton::get().operation_table.reduction_operations.find(reduction_key);
+
+  if (reduction_it == library::Singleton::get().operation_table.reduction_operations.end()) {
+    return false;
+  }
+
+  // initialize reduction operation required for parallel split-k operator
+  reduction_op_ = reduction_it->second;
+
+  // reduction operation found and initialized
+  return true;
+}
+
+/// Initializes workspace
+Status GemmOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::Operation const* underlying_operation = operation;
+
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_gemm_operation_for_parallel_reduction(operation))) {
+      return Status::kErrorNotSupported;
+    }
+  }
+
+  library::GemmDescription const &operation_desc =
+    static_cast<library::GemmDescription const &>(operation->description());
+
+  bool is_sparse = operation_desc.tile_description.math_instruction.opcode_class == cutlass::library::OpcodeClassID::kSparseTensorOp;
+
+  // Compute the number of copies of the problem to avoid L2 camping.
+  if (!options.profiling.workspace_count) {
+    int64_t bytes = problem_.bytes(operation_desc);
+    if (bytes < 3 * int64_t(options.device.properties[0].l2CacheSize)) {
+      gemm_workspace_.problem_count =
+        1 + int((3 * int64_t(options.device.properties[0].l2CacheSize)) / bytes);
+    }
+    else {
+      gemm_workspace_.problem_count = 1;
+    }
+  }
+  else {
+    gemm_workspace_.problem_count = options.profiling.workspace_count;
+  }
+
+  bool allocate_device_tensors = options.execution_mode != ExecutionMode::kDryRun;
+  if (allocate_device_tensors) {
+    int seed_shift = 0;
+    gemm_workspace_.A = device_context.allocate_and_initialize_tensor(
+      options,
+      "A",
+      operation_desc.A.element,
+      operation_desc.A.layout,
+      {int(problem_.m), int(problem_.k)},
+      {int(problem_.lda)},
+      problem_.batch_count * gemm_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      {int(problem_.k), int(problem_.n)},
+      {int(problem_.ldb)},
+      problem_.batch_count * gemm_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      problem_.batch_count * gemm_workspace_.problem_count,
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.D.element,
+      operation_desc.D.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      problem_.batch_count * gemm_workspace_.problem_count,
+      0 // device_index
+    );
+
+    gemm_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.D.element,
+      operation_desc.D.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      problem_.batch_count * gemm_workspace_.problem_count,
+      0 // device_index
+    );
+  }
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    // NOTE: the leading non-batch strides are duplicated here for 3.0 API kernels
+    gemm_workspace_.arguments.problem_size = {int(problem_.m), int(problem_.n), int(problem_.k)};
+    gemm_workspace_.arguments.batch_count = problem_.batch_count;
+    gemm_workspace_.arguments.lda = problem_.lda;
+    gemm_workspace_.arguments.ldb = problem_.ldb;
+    gemm_workspace_.arguments.ldc = problem_.ldc;
+    gemm_workspace_.arguments.ldd = problem_.ldc;
+    gemm_workspace_.arguments.batch_stride_A = gemm_workspace_.A->batch_stride();
+    gemm_workspace_.arguments.batch_stride_B = gemm_workspace_.B->batch_stride();
+    gemm_workspace_.arguments.batch_stride_C = gemm_workspace_.C->batch_stride();
+    gemm_workspace_.arguments.batch_stride_D = gemm_workspace_.Computed->batch_stride();
+
+    /* Query device SM count to pass onto the kernel as an argument, where needed */
+    gemm_workspace_.arguments.sm_count = options.device.properties[0].multiProcessorCount;
+  }
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+      uint64_t workspace_size = underlying_operation->get_host_workspace_size(&gemm_workspace_.configuration);
+      gemm_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = underlying_operation->get_device_workspace_size(&gemm_workspace_.configuration,
+                                                            &gemm_workspace_.arguments);
+      if (is_sparse) {
+        // sparse gemm get_device_workspace_size() only return device workspace size per iteration
+        // Needs to multiply it w/ number of iteration
+        workspace_size *= gemm_workspace_.problem_count;
+      }
+      gemm_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      // Convert to structure sparse contents here.
+      if (is_sparse) {
+        uint8_t* profiler_workspaces[1];
+        profiler_workspaces[0] = reinterpret_cast<uint8_t*>(gemm_workspace_.A->data());
+        // Sparse operations have a different initialize interface.
+        // initialize_with_profiler_workspace converts mxk tensorA to compressed mxk/sp tensorA and the tensorE
+        auto modifiable_underlying_op = const_cast<library::Operation*>(underlying_operation);
+        status = modifiable_underlying_op->initialize_with_profiler_workspace(
+          &gemm_workspace_.configuration,
+          gemm_workspace_.host_workspace.data(),
+          gemm_workspace_.device_workspace.data(),
+          profiler_workspaces,
+          gemm_workspace_.problem_count);
+      }
+      else {
+        status = underlying_operation->initialize(
+          &gemm_workspace_.configuration,
+          gemm_workspace_.host_workspace.data(),
+          gemm_workspace_.device_workspace.data());
+      }
+
+      if (status != Status::kSuccess) {
+        return status;
+      }
+
+      if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+        workspace_size = reduction_op_->get_host_workspace_size(&gemm_workspace_.reduction_configuration);
+        gemm_workspace_.reduction_host_workspace.resize(workspace_size, 0);
+
+        status = reduction_op_->initialize(
+          &gemm_workspace_.reduction_configuration,
+          gemm_workspace_.reduction_host_workspace.data(),
+          nullptr);
+
+        if (status != Status::kSuccess) {
+          return status;
+        }
+      }
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kGemm;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for (auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool GemmOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing GEMM arguments
+  gemm_workspace_.arguments.A = gemm_workspace_.A->data();
+  gemm_workspace_.arguments.B = gemm_workspace_.B->data();
+  gemm_workspace_.arguments.C = gemm_workspace_.C->data();
+  gemm_workspace_.arguments.D = gemm_workspace_.Computed->data();
+  gemm_workspace_.arguments.alpha = problem_.alpha.data();
+  gemm_workspace_.arguments.beta = problem_.beta.data();
+  gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+  gemm_workspace_.arguments.batch_stride_A = gemm_workspace_.A->batch_stride();
+  gemm_workspace_.arguments.batch_stride_B = gemm_workspace_.B->batch_stride();
+  gemm_workspace_.arguments.batch_stride_C = gemm_workspace_.C->batch_stride();
+  gemm_workspace_.arguments.batch_stride_D = gemm_workspace_.Computed->batch_stride();
+
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    gemm_workspace_.arguments.D                       = gemm_workspace_.device_workspace.data();
+    gemm_workspace_.arguments.alpha                   = problem_.alpha_one.data();
+    gemm_workspace_.arguments.beta                    = problem_.beta_zero.data();
+
+    gemm_workspace_.reduction_arguments.workspace     = gemm_workspace_.device_workspace.data();
+    gemm_workspace_.reduction_arguments.source        = gemm_workspace_.C->data();
+    gemm_workspace_.reduction_arguments.destination   = gemm_workspace_.Computed->data();
+    gemm_workspace_.reduction_arguments.alpha         = problem_.alpha.data();
+    gemm_workspace_.reduction_arguments.beta          = problem_.beta.data();
+    gemm_workspace_.reduction_arguments.pointer_mode  = library::ScalarPointerMode::kHost;
+  }
+
+  //
+  // Run the CUTLASS operation
+  //
+
+ // initialize gemm underlying operation to handle parallel reduction
+  library::Operation const * underlying_operation = operation;
+
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_gemm_operation_for_parallel_reduction(operation))) {
+      results_.back().disposition = Disposition::kFailed;
+      return false;
+    }
+  }
+
+  results_.back().status = underlying_operation->run(
+    &gemm_workspace_.arguments,
+    gemm_workspace_.host_workspace.data(),
+    gemm_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // Run parallel reduction kernel for parallel split_k_mode
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    results_.back().status = reduction_op_->run(
+      &gemm_workspace_.reduction_arguments,
+      gemm_workspace_.reduction_host_workspace.data(),
+      nullptr);
+
+    if (results_.back().status != Status::kSuccess) {
+      results_.back().disposition = Disposition::kFailed;
+      return false;
+    }
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUBLAS
+    if (options.verification.provider_enabled(library::Provider::kCUBLAS)) {
+
+      // Guard against unsupported cases
+      auto const & gemm_desc = static_cast<library::GemmDescription const &>(operation->description());
+
+      if (cublas_satisfies(gemm_desc) == Status::kSuccess) {
+
+        // call cublas verification if supported
+        verify_with_cublas_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+        }
+
+      else {
+        // set verification map for cublas to not supported
+        results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUBLAS
+
+    library::GemmDescription const &gemm_desc =
+      static_cast<library::GemmDescription const &>(operation->description());
+
+
+    cutlass::library::NumericTypeID element_A = gemm_desc.A.element;
+    cutlass::library::NumericTypeID element_B = gemm_desc.B.element;
+    bool verification_status = verify_with_reference_(options, report, device_context, operation, problem_space, problem, element_A, element_B);
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for (auto &m : results_.back().verification_map) {
+      if (m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if (!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if (is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // if verification.required is set, then return success iff at least one ref-check was run
+  if (options.verification.required) {
+    bool did_any_verification_run = false;
+    for (auto provider : options.verification.providers) {
+      did_any_verification_run |= (Disposition::kNotRun != results_.back().verification_map[provider]);
+    }
+
+    if (not did_any_verification_run) {
+      results_.back().status = Status::kErrorNotSupported;
+      return false;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool GemmOperationProfiler::verify_with_cublas_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+#if CUTLASS_ENABLE_CUBLAS
+
+  library::GemmDescription const &gemm_desc =
+    static_cast<library::GemmDescription const &>(operation->description());
+
+  //
+  // Construct cuBLAS operators
+  //
+
+  CublasLtCreate handle;
+  cublasStatus_t status = handle.get_cublaslt_create_status();
+
+  if (status != CUBLAS_STATUS_SUCCESS) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = get_cutlass_disposition(status);
+    return true;
+  }
+
+
+  //
+  // Initialize state
+  //
+
+  try {
+
+    //
+    // Construct dispatcher to cublasGemmEx()
+    //
+
+    // Initialize structure containing GEMM arguments
+    gemm_workspace_.arguments.A = gemm_workspace_.A->data();
+    gemm_workspace_.arguments.batch_stride_A = gemm_workspace_.A->batch_stride();
+    gemm_workspace_.arguments.B = gemm_workspace_.B->data();
+    gemm_workspace_.arguments.batch_stride_B = gemm_workspace_.B->batch_stride();
+    gemm_workspace_.arguments.C = gemm_workspace_.Reference->data();
+    gemm_workspace_.arguments.batch_stride_C = gemm_workspace_.Reference->batch_stride();
+    gemm_workspace_.arguments.D = gemm_workspace_.Reference->data();
+    gemm_workspace_.arguments.batch_stride_D = gemm_workspace_.Reference->batch_stride();
+    gemm_workspace_.arguments.alpha = problem_.alpha.data();
+    gemm_workspace_.arguments.beta = problem_.beta.data();
+    gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    detail::cublasLtGemmExDispatcher gemm_op(
+      gemm_desc,
+      gemm_workspace_.configuration,
+      gemm_workspace_.arguments
+    );
+
+    gemm_op.initialize_cublaslt();
+
+    if(!gemm_op.get_cublaslt_algo(handle, AlgorithmMode::kDefault)){
+      return true;
+    }
+
+    if (gemm_op.status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotRun;
+      return true;
+    }
+
+    status = gemm_op(handle);
+
+    // Handle errors
+    if (status != CUBLAS_STATUS_SUCCESS) {
+      std::cerr << "cublasLt Verification run failed with status : " << cublasLtGetStatusName(status) << "\n";
+      results_.back().verification_map[library::Provider::kCUBLAS] = get_cutlass_disposition(status);
+      return true;
+    }
+
+    results_.back().status = Status::kSuccess;
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = compare_tensors(
+      options,
+      *gemm_workspace_.Computed,
+      *gemm_workspace_.Reference,
+      gemm_workspace_.Computed->batch_stride()
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUBLAS] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        gemm_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUBLAS);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+  }
+
+#endif
+
+  // Return true means continue profiling
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against host and device references
+bool GemmOperationProfiler::verify_with_reference_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem,
+  cutlass::library::NumericTypeID element_A,
+  cutlass::library::NumericTypeID element_B)
+{
+  library::GemmDescription const &gemm_desc =
+    static_cast<library::GemmDescription const &>(operation->description());
+
+  //
+  // Initialize state
+  //
+
+  for (auto provider : options.verification.providers) {
+
+    // Skip providers that are not enabled
+    if (!options.verification.provider_enabled(provider)) {
+      continue;
+    }
+
+    void *ptr_A = gemm_workspace_.A->data();
+    void *ptr_B = gemm_workspace_.B->data();
+    void *ptr_C = gemm_workspace_.C->data();
+    void *ptr_D = gemm_workspace_.Reference->data();
+
+    // To support the host-side reference, conditionally allocate and
+    // copy tensors to host memory.
+    std::vector<uint8_t> host_data_A;
+    std::vector<uint8_t> host_data_B;
+    std::vector<uint8_t> host_data_C;
+    std::vector<uint8_t> host_data_D;
+
+    if (provider == library::Provider::kReferenceHost) {
+
+      host_data_A.resize(gemm_workspace_.A->bytes());
+      ptr_A = host_data_A.data();
+      gemm_workspace_.A->copy_to_host(ptr_A);
+
+      host_data_B.resize(gemm_workspace_.B->bytes());
+      ptr_B = host_data_B.data();
+      gemm_workspace_.B->copy_to_host(ptr_B);
+
+      host_data_C.resize(gemm_workspace_.C->bytes());
+      ptr_C = host_data_C.data();
+      gemm_workspace_.C->copy_to_host(ptr_C);
+
+      host_data_D.resize(gemm_workspace_.Reference->bytes());
+      ptr_D = host_data_D.data();
+    }
+
+    //
+    // Launch
+    //
+
+    library::Handle handle;
+
+    handle.set_provider(provider);
+
+    Status status = handle.gemm_universal(
+      problem_.mode,
+      gemm_workspace_.configuration.problem_size.m(),
+      gemm_workspace_.configuration.problem_size.n(),
+      gemm_workspace_.configuration.problem_size.k(),
+      gemm_desc.tile_description.math_instruction.element_accumulator,
+      gemm_desc.element_epilogue,
+
+      problem_.alpha.data(),
+
+      element_A,
+      gemm_desc.A.layout,
+      gemm_desc.transform_A,
+      ptr_A,
+      int(gemm_workspace_.configuration.lda),
+
+      element_B,
+      gemm_desc.B.layout,
+      gemm_desc.transform_B,
+      ptr_B,
+      int(gemm_workspace_.configuration.ldb),
+
+      problem_.beta.data(),
+
+      gemm_desc.C.element,
+      gemm_desc.C.layout,
+      ptr_C,
+      int(gemm_workspace_.configuration.ldc),
+
+      gemm_desc.D.element,
+      gemm_desc.D.layout,
+      ptr_D,
+      int(gemm_workspace_.configuration.ldd),
+
+      gemm_workspace_.configuration.batch_count,
+      gemm_workspace_.A->batch_stride(),
+      gemm_workspace_.B->batch_stride(),
+      gemm_workspace_.C->batch_stride(),
+      gemm_workspace_.Reference->batch_stride());
+
+    if (status != Status::kSuccess) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+      continue;
+    }
+    results_.back().status = status;
+
+    if (provider == library::Provider::kReferenceHost) {
+      gemm_workspace_.Reference->copy_from_host(ptr_D);
+    }
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[provider] = compare_tensors(
+      options,
+      *gemm_workspace_.Computed,
+      *gemm_workspace_.Reference,
+      gemm_workspace_.Computed->batch_stride()
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[provider] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        gemm_desc,
+        library::Provider::kCUTLASS,
+        provider);
+    }
+  }
+
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool GemmOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing GEMM arguments
+    gemm_workspace_.arguments.A = gemm_workspace_.A->data();
+    gemm_workspace_.arguments.B = gemm_workspace_.B->data();
+    gemm_workspace_.arguments.C = gemm_workspace_.C->data();
+    gemm_workspace_.arguments.D = gemm_workspace_.Computed->data();
+    gemm_workspace_.arguments.alpha = problem_.alpha.data();
+    gemm_workspace_.arguments.beta = problem_.beta.data();
+    gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+    gemm_workspace_.arguments.batch_stride_A = gemm_workspace_.A->batch_stride();
+    gemm_workspace_.arguments.batch_stride_B = gemm_workspace_.B->batch_stride();
+    gemm_workspace_.arguments.batch_stride_C = gemm_workspace_.C->batch_stride();
+    gemm_workspace_.arguments.batch_stride_D = gemm_workspace_.Computed->batch_stride();
+
+    if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+      gemm_workspace_.arguments.D                       = gemm_workspace_.device_workspace.data();
+      gemm_workspace_.arguments.alpha                   = problem_.alpha_one.data();
+      gemm_workspace_.arguments.beta                    = problem_.beta_zero.data();
+
+      gemm_workspace_.reduction_arguments.workspace     = gemm_workspace_.device_workspace.data();
+      gemm_workspace_.reduction_arguments.source        = gemm_workspace_.C->data();
+      gemm_workspace_.reduction_arguments.destination   = gemm_workspace_.Computed->data();
+      gemm_workspace_.reduction_arguments.alpha         = problem_.alpha.data();
+      gemm_workspace_.reduction_arguments.beta          = problem_.beta.data();
+      gemm_workspace_.reduction_arguments.pointer_mode  = library::ScalarPointerMode::kHost;
+    }
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &gemm_workspace_.arguments,
+      gemm_workspace_.host_workspace.data(),
+      gemm_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Method to profile a CUTLASS Operation
+Status GemmOperationProfiler::profile_cutlass_(
+  double &runtime,
+  Options const &options,
+  library::Operation const *operation,
+  void *arguments,
+  void *host_workspace,
+  void *device_workspace) {
+
+  GpuTimer timer;
+  // initialize gemm underlying operation to handle parallel reduction
+  library::Operation const * underlying_operation = operation;
+
+  if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+    if (!(underlying_operation = library::find_gemm_operation_for_parallel_reduction(operation))) {
+      return Status::kErrorNotSupported;
+    }
+  }
+
+  //
+  // Optional sleep to limit power consumption and thermals
+  //
+
+  sleep(options.profiling.sleep_duration);
+
+  //
+  // Warmup loop
+  //
+
+  Status status;
+
+  for (int iteration = 0; iteration < options.profiling.warmup_iterations; ++iteration) {
+
+    int problem_idx = (iteration % gemm_workspace_.problem_count) * problem_.batch_count;
+
+    gemm_workspace_.arguments.A = gemm_workspace_.A->batch_data(problem_idx);
+    gemm_workspace_.arguments.B = gemm_workspace_.B->batch_data(problem_idx);
+    gemm_workspace_.arguments.C = gemm_workspace_.C->batch_data(problem_idx);
+    gemm_workspace_.arguments.D = gemm_workspace_.Computed->batch_data(problem_idx);
+
+    if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+      gemm_workspace_.arguments.D                     = gemm_workspace_.device_workspace.data();
+
+      gemm_workspace_.reduction_arguments.workspace   = gemm_workspace_.device_workspace.data();
+      gemm_workspace_.reduction_arguments.source      = gemm_workspace_.C->batch_data(problem_idx);
+      gemm_workspace_.reduction_arguments.destination = gemm_workspace_.Computed->batch_data(problem_idx);
+    }
+
+    // Execute the CUTLASS operation
+    status = underlying_operation->run(
+      &gemm_workspace_.arguments,
+      host_workspace,
+      device_workspace);
+
+    if (status != Status::kSuccess) {
+      return status;
+    }
+
+    // Run parallel reduction kernel for parallel split_k_mode
+    if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+      status = reduction_op_->run(
+        &gemm_workspace_.reduction_arguments,
+        gemm_workspace_.reduction_host_workspace.data(),
+        nullptr);
+
+      if (status != Status::kSuccess) {
+        return status;
+      }
+    }
+  }
+
+  //
+  // Initialize GPU timer
+  //
+
+  timer.start();
+
+  //
+  // Profiling loop
+  //
+
+  int Iterations = options.profiling.iterations;
+
+  int iteration = 0;
+  for (; iteration < Iterations; ++iteration) {
+
+    // Iterate over copies of the problem in memory
+    int workspace_idx = options.profiling.warmup_iterations + iteration;
+    int problem_idx = (workspace_idx % gemm_workspace_.problem_count) * problem_.batch_count;
+
+    gemm_workspace_.arguments.A = gemm_workspace_.A->batch_data(problem_idx);
+    gemm_workspace_.arguments.B = gemm_workspace_.B->batch_data(problem_idx);
+    gemm_workspace_.arguments.C = gemm_workspace_.C->batch_data(problem_idx);
+    gemm_workspace_.arguments.D = gemm_workspace_.Computed->batch_data(problem_idx);
+
+    if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+      gemm_workspace_.arguments.D                     = gemm_workspace_.device_workspace.data();
+
+      gemm_workspace_.reduction_arguments.workspace   = gemm_workspace_.device_workspace.data();
+      gemm_workspace_.reduction_arguments.source      = gemm_workspace_.C->batch_data(problem_idx);
+      gemm_workspace_.reduction_arguments.destination = gemm_workspace_.Computed->batch_data(problem_idx);
+    }
+
+    status = underlying_operation->run(
+      arguments,
+      host_workspace,
+      device_workspace);
+
+    if (status != Status::kSuccess) {
+      return status;
+    }
+
+    // Run parallel reduction kernel for parallel split_k_mode
+    if (problem_.split_k_mode == library::SplitKMode::kParallel) {
+      status = reduction_op_->run(
+        &gemm_workspace_.reduction_arguments,
+        gemm_workspace_.reduction_host_workspace.data(),
+        nullptr);
+
+      if (status != Status::kSuccess) {
+        return status;
+      }
+    }
+  }
+
+  //
+  // Wait for completion
+  //
+
+  timer.stop_and_wait();
+  //
+  // Update performance result
+  //
+
+  runtime = timer.duration(iteration);
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/gpu_timer.cpp

@@ -0,0 +1,113 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Defines a math function
+*/
+
+#include <stdexcept>
+
+#include "cutlass/profiler/gpu_timer.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+GpuTimer::GpuTimer() {
+  cudaError_t result;
+
+  for (auto & event : events) {
+    result = cudaEventCreate(&event);
+    if (result != cudaSuccess) {
+      throw std::runtime_error("Failed to create CUDA event");
+    }
+  }
+}
+
+GpuTimer::~GpuTimer() {
+  for (auto & event : events) {
+    cudaEventDestroy(event);
+  }
+}
+
+/// Records a start event in the stream
+void GpuTimer::start(cudaStream_t stream) {
+  cudaError_t result = cudaEventRecord(events[0], stream);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed to record start event.");
+  }
+}
+
+/// Records a stop event in the stream
+void GpuTimer::stop(cudaStream_t stream) {
+cudaError_t result = cudaEventRecord(events[1], stream);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed to record stop event.");
+  }
+}
+
+/// Records a stop event in the stream and synchronizes on the stream
+void GpuTimer::stop_and_wait(cudaStream_t stream) {
+
+  stop(stream);
+
+  cudaError_t result;
+  if (stream) {
+    result = cudaStreamSynchronize(stream);
+    if (result != cudaSuccess) {
+      throw std::runtime_error("Failed to synchronize with non-null CUDA stream.");
+    }
+  }
+  else {
+    result = cudaDeviceSynchronize();
+    if (result != cudaSuccess) {
+      throw std::runtime_error("Failed to synchronize with CUDA device.");
+    }
+  }
+}
+
+/// Returns the duration in milliseconds
+double GpuTimer::duration(int iterations) const {
+
+  float avg_ms;
+
+  cudaError_t result = cudaEventElapsedTime(&avg_ms, events[0], events[1]);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("Failed to query elapsed time from CUDA events.");
+  }
+
+  return double(avg_ms) / double(iterations);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/options.cu

@@ -0,0 +1,899 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Command line options for performance test program
+*/
+
+#include <algorithm>
+#include <set>
+
+#include "cutlass/cutlass.h"
+#include "cutlass/version.h"
+
+#include "cutlass/library/util.h"
+
+#include "cutlass/profiler/options.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Newline and indent for help strings
+static char const *end_of_line = "\n                                             ";
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Device::Device(cutlass::CommandLine const &cmdline) {
+
+  // Gets the number of devices for future validation
+  cudaError_t result;
+  result = cudaGetDeviceCount(&num_devices);
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaGetNumDevices() failed");
+  }
+
+  // Gets the devices specified by the user
+  // This preserves the user specified order and checks for duplicates
+  {
+    std::vector<int> temp_device_list;
+    cmdline.get_cmd_line_arguments("devices", temp_device_list);
+    if (temp_device_list.empty()) {
+      temp_device_list.push_back(0);
+    }
+    {
+      std::set<int> temp_device_set;
+      for (int device : temp_device_list) {
+        auto res = temp_device_set.insert(device);
+        if (!res.second) {
+          throw std::runtime_error("Duplicate device specified: " +
+                                   std::to_string(device));
+        } else if (device > num_devices) {
+          throw std::runtime_error("Bad device ID: " +
+                                   std::to_string(device));
+        } else {
+          devices.push_back(device);
+        }
+      }
+    }
+  }
+
+  properties.resize(devices.size());
+  // Retrieves properties for all specified devices
+  for (size_t device_index = 0; device_index < devices.size(); device_index++) {
+    int device = devices[device_index];
+
+    result = cudaGetDeviceProperties(&properties[device_index], device);
+
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaGetDeviceProperties() failed for given device");
+    }
+
+    // Check that all devices are the same
+    if (device_index > 0) {
+      if ((properties[device_index].major != properties[0].major) ||
+          (properties[device_index].minor != properties[0].minor)) {
+        throw std::runtime_error("All selected devices must have the same "
+                                 "compute capability");
+      }
+      if (properties[device_index].l2CacheSize != properties[0].l2CacheSize) {
+        throw std::runtime_error("All selected devices must have the same "
+                                 "L2 cache size");
+      }
+      if (properties[device_index].multiProcessorCount != properties[0].multiProcessorCount) {
+        throw std::runtime_error("All selected devices must have the same "
+                                 "SM count");
+      }
+    }
+
+    result = cudaSetDevice(device);
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaSetDevice() failed for given device.");
+    }
+
+    // Permit overriding the compute capability
+    if (cmdline.check_cmd_line_flag("compute-capability")) {
+      int cc = compute_capability(device_index);
+      cmdline.get_cmd_line_argument("compute-capability", cc, cc);
+      properties[device_index].major = cc / 10;
+      properties[device_index].minor = cc % 10;
+    }
+
+    // Permit overriding the L2 cache capacity
+    if (cmdline.check_cmd_line_flag("llc-capacity")) {
+      int llc_capacity = 0;
+      cmdline.get_cmd_line_argument("llc-capacity", llc_capacity, 0);
+
+      if (llc_capacity >= 0) {
+        properties[device_index].l2CacheSize = (llc_capacity << 10);
+      }
+    }
+
+  }
+}
+
+void Options::Device::print_usage(std::ostream &out) const {
+
+  out << "Device:\n"
+    << "  --devices=<int>,<int>,...                      "
+    << "    CUDA Device IDs\n\n";
+
+  int device_count = 0;
+  cudaError_t result = cudaGetDeviceCount(&device_count);
+
+  if (result != cudaSuccess) {
+    out << "      <could not query for CUDA devices>\n";
+  }
+  else {
+
+    for (int idx = 0; idx < device_count; ++idx) {
+      cudaDeviceProp prop;
+      result = cudaGetDeviceProperties(&prop, idx);
+      if (result != cudaSuccess) {
+        out << "      <could not obtain device properties for device " << idx << ">" << std::endl;
+        break;
+      }
+      else {
+        out << "    [" << idx << "] - "
+          << prop.name << " - SM " << prop.major << "." << prop.minor << ", "
+          << prop.multiProcessorCount << " SMs @ " << (prop.clockRate / 1000.0) << " MHz, "
+          << "L2 cache: " << (prop.l2CacheSize >> 20) << " MB, Global Memory: " << (prop.totalGlobalMem >> 30) << " GB"
+          << std::endl;
+      }
+    }
+    out << "\n";
+  }
+
+  out
+    << "  --compute-capability=<int>                   "
+    << "    Override the compute capability.\n\n"
+
+    << "  --llc-capacity=<capacity in KiB>             "
+    << "    Capacity of last-level cache in kilobytes. If this is non-zero," << end_of_line
+    << "      profiling phases cycle through different input tensors to induce" << end_of_line
+    << "      capacity misses in the L2.\n\n";
+
+}
+
+void Options::Device::print_device_info(std::ostream &out) const {
+  cudaDeviceProp props;
+  cudaError_t result;
+
+  out << "Device Name,SM,CUDA Device ID,Phy Device ID" << std::endl;
+
+  for (int device = 0; device < num_devices; device++) {
+    result = cudaSetDevice(device);
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaSetDevice() failed for device");
+    }
+
+    result = cudaGetDeviceProperties(&props, device);
+    if (result != cudaSuccess) {
+      throw std::runtime_error("cudaGetDeviceProperties failed for device");
+    }
+
+    out << props.name << "," << props.major << props.minor << ","
+      << device << "," << props.multiGpuBoardGroupID << std::endl;
+
+  }
+}
+
+void Options::Device::print_options(std::ostream &out, int indent) const {
+
+  out
+    << indent_str(indent) << "devices: ";
+  for (int device : devices) {
+    out << device << ',';
+  }
+  out
+    << "\n"
+    << indent_str(indent) << "clock: " << int(double(properties[0].clockRate) / 1000.0) << "\n"
+    << indent_str(indent) << "compute-capability: " << compute_capability(0) << "\n";
+}
+
+/// Returns the device ID from a device index
+int Options::Device::device_id(size_t device_index) const {
+  if (device_index > devices.size()) {
+    throw std::runtime_error("Out of bounds device index: " +
+                             std::to_string(device_index));
+  }
+  return devices.at(device_index);
+}
+
+/// Returns the compute capability of the listed device (e.g. 61, 60, 70, 75)
+int Options::Device::compute_capability(int device_index) const {
+  return properties[device_index].major * 10 + properties[device_index].minor;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Initialization::Initialization(cutlass::CommandLine const &cmdline) {
+
+  cmdline.get_cmd_line_argument("initialization-enabled", enabled, true);
+
+  if (cmdline.check_cmd_line_flag("initialization-provider")) {
+    std::string str;
+    cmdline.get_cmd_line_argument("initialization-provider", str);
+    provider = library::from_string<library::Provider>(str);
+    if (provider == library::Provider::kInvalid) {
+      enabled = false;
+    }
+    else if (provider != library::Provider::kReferenceHost && provider != library::Provider::kReferenceDevice) {
+      throw std::runtime_error("Unsupported initialization provider specified.");
+    }
+  }
+  else {
+    provider = library::Provider::kReferenceDevice;
+  }
+
+  cmdline.get_cmd_line_argument("seed", seed, 2019);
+
+  if (cmdline.check_cmd_line_flag("dist")) {
+    // user has set the data distribution (fix data distribution once set)
+    fix_data_distribution = true;
+    // set user provided data distribution
+    get_distribution(cmdline, "dist", data_distribution);
+  }
+  else {
+    // profiler chosen data distribution (allowed to change based on numeric types)
+    fix_data_distribution = false;
+    // set uniform data distribution with range [-4, 4]
+    data_distribution.set_uniform(-4, 4, 0);
+  }
+
+
+}
+
+/// Gets the initial distribution
+void Options::Initialization::get_distribution(
+  cutlass::CommandLine const &args,
+  std::string const &arg,
+  cutlass::Distribution &dist) {
+
+  struct {
+    const char *label;
+    cutlass::Distribution::Kind kind;
+  } distribution_kinds[] = {
+    {"uniform", cutlass::Distribution::Uniform},
+    {"gaussian", cutlass::Distribution::Gaussian},
+    {"identity", cutlass::Distribution::Identity},
+    {"sequential", cutlass::Distribution::Sequential},
+    {0, cutlass::Distribution::Invalid}
+  };
+
+  struct {
+    char const *label;
+    double *member;
+  } members[] = {
+    {"min", &dist.uniform.min},
+    {"max", &dist.uniform.max},
+    {"mean", &dist.gaussian.mean},
+    {"stddev", &dist.gaussian.stddev},
+    {"pnzA", &dist.gaussian.pnzA},
+    {"pnzB", &dist.gaussian.pnzB},
+    {"pnzC", &dist.gaussian.pnzC},
+    {"start", &dist.sequential.start},
+    {"delta", &dist.sequential.delta},
+    {0, 0}
+  };
+
+  // Initalize pnz values to a default value of 100%
+  dist.gaussian.pnz = 1.0;
+  dist.gaussian.pnzA = 1.0;
+  dist.gaussian.pnzB = 1.0;
+  dist.gaussian.pnzC = 1.0;
+
+  using KeyValueVector = std::vector<std::pair<std::string, std::string> >;
+
+  KeyValueVector values;
+  args.get_cmd_line_argument_pairs(arg.c_str(), values);
+
+  // The parser expects the first token to be a string identifying the distribution type.
+  auto it = values.begin();
+  if (it != values.end()) {
+    for (int i = 0; distribution_kinds[i].label; ++i) {
+      if (it->first == distribution_kinds[i].label) {
+        dist.kind = distribution_kinds[i].kind;
+        break;
+      }
+    }
+    ++it;
+  }
+
+  // Subsequent key-value pairs update the named field of the distribution struct.
+  for (; it != values.end(); ++it) {
+    // Integer scaling factor - if < 0, no integer rounding is performed.
+    if ((it->first.compare("scale") == 0) && !it->second.empty()) {
+      std::stringstream ss;
+      ss << it->second;
+      ss >> dist.int_scale;
+      continue;  // next token
+    }
+
+    // Casts as integer without scaling
+    if (it->first.compare("integer") == 0) {
+      dist.int_scale = 0;
+      continue;  // next token
+    }
+
+    // initialize other members
+    for (int m = 0; members[m].label; ++m) {
+      if (it->first == members[m].label && !it->second.empty()) {
+        std::stringstream ss;
+        ss << it->second;
+        ss >> *(members[m].member);
+      }
+    }
+  }
+}
+
+void Options::Initialization::print_usage(std::ostream &out) const {
+
+  out << "Initialization:\n"
+
+    << "  --initialization=<bool>                      "
+    << "    Enables initialization (default: true). If false, device memory is" << end_of_line
+    << "      not initialized after allocation.\n\n"
+
+    << "  --initialization-provider=<provider>         "
+    << "    Selects initialization provider {host, device*}. (default: '*')\n\n"
+
+    << "  --dist=<distribution>                        "
+    << "    Data distribution of input tensors {uniform*, gaussian, identity, sequential}"  << end_of_line
+    << "       --dist=uniform,min:<double>,max:<double>,scale:<integer>"  << end_of_line
+    << "       --dist=gaussian,mean:<double>,stddev:<double>,scale:<integer>,pnzA:<double>,pnzB:<double>,pnzC:<double>"  << end_of_line
+    << "       --dist=sequential,start:<double>,delta:<double>,scale:<integer>"  << end_of_line
+    << "       --dist=identity\n\n"
+
+    << "  --seed=<int>                                 "
+    << "    Random number generator seed. Used to enforce deterministic" << end_of_line
+    << "      initialization.\n\n";
+
+}
+
+void Options::Initialization::print_options(std::ostream &out, int indent) const {
+
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Library::Library(cutlass::CommandLine const &cmdline) {
+
+  algorithm_mode = AlgorithmMode::kDefault;
+
+  if (cmdline.check_cmd_line_flag("library-algo-mode")) {
+    std::string mode = "default";
+    cmdline.get_cmd_line_argument("library-algo-mode", mode);
+    algorithm_mode = from_string<AlgorithmMode>(mode);
+  }
+
+  if (cmdline.check_cmd_line_flag("library-algos")) {
+
+    // If algorithms are specified, override as kBest.
+    algorithm_mode = AlgorithmMode::kBest;
+
+    std::vector<std::string> tokens;
+    cmdline.get_cmd_line_arguments("library-algos", tokens);
+
+    algorithms.reserve(tokens.size());
+
+    for (auto const & token : tokens) {
+      if (token.find(":")) {
+        // TODO: tokenized range
+      }
+      else {
+        int algo;
+        std::stringstream ss;
+
+        ss << token;
+        ss >> algo;
+
+        algorithms.push_back(algo);
+      }
+    }
+  }
+}
+
+void Options::Library::print_usage(std::ostream &out) const {
+
+  out << "Library:\n"
+
+    << "  --library-algo-mode=<mode>                   "
+    << "    Indicates algorithm mode used to call libraries such as cuBLAS and cuDNN.\n"
+    << "                                               "
+    << "    mode={default*,matching,best}\n\n"
+
+    << "  --library-algos=<range-list>                 "
+    << "    If --algorithm-mode=best, permits specifying a selection of algorithms.\n\n";
+
+}
+
+void Options::Library::print_options(std::ostream &out, int indent) const {
+
+  out
+    << indent_str(indent) << "library-algo-mode: " << to_string(algorithm_mode) << "\n"
+    << indent_str(indent) << "library-algos: ";
+
+  int j = 0;
+  for (int x : algorithms) {
+    out << (j++ ? "," : "") << x;
+  }
+
+  out << "\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Profiling::Profiling(cutlass::CommandLine const &cmdline) {
+
+  cmdline.get_cmd_line_argument("workspace-count", workspace_count, 0);
+  cmdline.get_cmd_line_argument("warmup-iterations", warmup_iterations, 10);
+  cmdline.get_cmd_line_argument("profiling-iterations", iterations, 100);
+  cmdline.get_cmd_line_argument("sleep-duration", sleep_duration, 50);
+  cmdline.get_cmd_line_argument("profiling-enabled", enabled, true);
+
+  if (cmdline.check_cmd_line_flag("providers")) {
+
+    std::vector<std::string> tokens;
+    cmdline.get_cmd_line_arguments("providers", tokens);
+
+    providers.clear();
+
+    for (auto const &token : tokens) {
+      providers.push_back(library::from_string<library::Provider>(token));
+    }
+  }
+  else {
+    providers.push_back(library::Provider::kCUTLASS);
+    providers.push_back(library::Provider::kCUBLAS);
+    providers.push_back(library::Provider::kCUDNN);
+  }
+}
+
+void Options::Profiling::print_usage(std::ostream &out) const {
+
+  out << "Profiling:\n"
+
+    << "  --workspace-count=<workspace count>          "
+    << "    Number of discrete workspaces maintained to avoid cache-resident " << end_of_line
+    << "    If zero (default), the amount is chosen for each workload based on " << end_of_line
+    << "    capacity of the last-level cache.\n\n"
+
+    << "  --profiling-iterations=<iterations>          "
+    << "    Number of iterations to profile each kernel. If zero, kernels" << end_of_line
+    << "      are launched up to the profiling duration.\n\n"
+
+    << "  --warmup-iterations=<iterations>             "
+    << "    Number of iterations to execute each kernel prior to profiling.\n\n"
+
+    << "  --sleep-duration=<duration>                  "
+    << "    Number of ms to sleep between profiling periods (ms).\n\n"
+
+    << "  --profiling-enabled=<bool>                   "
+    << "    If true, profiling is actually conducted.\n\n"
+
+  ;
+}
+
+void Options::Profiling::print_options(std::ostream &out, int indent) const {
+
+  out
+    << indent_str(indent) << "profiling_iterations: " << iterations << "\n"
+    << indent_str(indent) << "sleep_duration: " << sleep_duration << "\n"
+    << indent_str(indent) << "profiling_enabled: " << enabled << "\n"
+    << indent_str(indent) << "providers: [";
+
+  int j = 0;
+  for (auto const & provider : providers) {
+    out << (j++ ? ", " : "") << library::to_string(provider);
+  }
+  out << "]\n";
+}
+
+/// Returns true if a provider is enabled
+bool Options::Profiling::provider_enabled(library::Provider provider) const {
+  return std::find(providers.begin(), providers.end(), provider) != providers.end();
+}
+
+/// Returns the index of a provider if its enabled
+size_t Options::Profiling::index(library::Provider provider) const {
+  size_t idx = 0;
+  for (auto const & x : providers) {
+    if (x == provider) {
+      return idx;
+    }
+    ++idx;
+  }
+  return idx;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Verification::Verification(cutlass::CommandLine const &cmdline) {
+
+  cmdline.get_cmd_line_argument("verification-enabled", enabled, true);
+  if (enabled) {
+    cmdline.get_cmd_line_argument("verification-required", required, false);
+  }
+
+  cmdline.get_cmd_line_argument("epsilon", epsilon, 0.05);
+
+  cmdline.get_cmd_line_argument("nonzero-floor", nonzero_floor, 1.0 / 256.0);
+
+  if (cmdline.check_cmd_line_flag("save-workspace")) {
+    std::string value;
+    cmdline.get_cmd_line_argument("save-workspace", value);
+    save_workspace = from_string<SaveWorkspace>(value);
+  }
+  else {
+    save_workspace = SaveWorkspace::kNever;
+  }
+
+  if (cmdline.check_cmd_line_flag("verification-providers")) {
+
+    std::vector<std::string> tokens;
+    cmdline.get_cmd_line_arguments("verification-providers", tokens);
+
+    providers.clear();
+
+    for (auto const &token : tokens) {
+      library::Provider provider = library::from_string<library::Provider>(token);
+      if (provider != library::Provider::kInvalid) {
+        providers.push_back(provider);
+      }
+    }
+  }
+  else {
+    providers.push_back(library::Provider::kCUBLAS);
+    providers.push_back(library::Provider::kReferenceDevice);
+    providers.push_back(library::Provider::kCUDNN);
+  }
+}
+
+void Options::Verification::print_usage(std::ostream &out) const {
+
+  out << "Verification:\n"
+
+    << "  --verification-enabled=<bool>                "
+    << "    Whether to perform verification checks.\n\n"
+
+    << "  --epsilon=<error>                            "
+    << "    Error threshold. Setting to zero (default) requires" << end_of_line
+    << "      bit-level equivalence.\n\n"
+
+    << "  --nonzero-floor=<floor>                      "
+    << "    Results whose absolute value is less than this quantity" << end_of_line
+    << "      are treated as zero for comparisons.\n\n"
+
+    << "  --save-workspace=<string>                    "
+    << "    Specifies when to save the GEMM inputs and results to the filesystem." << end_of_line
+    << "       --save-workspace=never      never save workspace (default)" << end_of_line
+    << "       --save-workspace=incorrect  save workspace for incorrect results" << end_of_line
+    << "       --save-workspace=always     always save workspace\n\n"
+
+    << "  --verification-providers=<providers>         "
+    << "    List of providers used to verify result. (default: '*')" << end_of_line
+    << "      Gemm verification-providers {cublas*}" << end_of_line
+    << "      Conv2d verification-providers {cudnn*, device*, host}"
+    << "\n\n";
+}
+
+void Options::Verification::print_options(std::ostream &out, int indent) const {
+
+  out
+    << indent_str(indent) << "verification_enabled: " << enabled << "\n"
+    << indent_str(indent) << "epsilon: " << epsilon << "\n"
+    << indent_str(indent) << "save_workspace: " << to_string(save_workspace) << "\n"
+    << indent_str(indent) << "verification_providers: [";
+
+  int j = 0;
+  for (auto const & provider : providers) {
+    out << (j++ ? ", " : "") << library::to_string(provider);
+  }
+  out << "]\n";
+}
+
+/// Returns true if a provider is enabled
+bool Options::Verification::provider_enabled(library::Provider provider) const {
+  return std::find(providers.begin(), providers.end(), provider) != providers.end();
+}
+
+/// Returns the index of a provider if its enabled
+size_t Options::Verification::index(library::Provider provider) const {
+  size_t idx = 0;
+  for (auto const & x : providers) {
+    if (x == provider) {
+      return idx;
+    }
+    ++idx;
+  }
+  return idx;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Report::Report(cutlass::CommandLine const &cmdline) {
+
+  cmdline.get_cmd_line_argument("append", append, false);
+  cmdline.get_cmd_line_argument("output", output_path);
+  cmdline.get_cmd_line_argument("junit-output", junit_output_path);
+
+  if (cmdline.check_cmd_line_flag("tags")) {
+    cmdline.get_cmd_line_argument_pairs("tags", pivot_tags);
+  }
+
+  cmdline.get_cmd_line_argument("report-not-run", report_not_run, false);
+
+  cmdline.get_cmd_line_argument("verbose", verbose, true);
+
+  cmdline.get_cmd_line_argument("sort-results", sort_results, false);
+
+  cmdline.get_cmd_line_argument("print-kernel-before-running", print_kernel_before_running, false);
+}
+
+void Options::Report::print_usage(std::ostream &out) const {
+
+  out << "Report:\n"
+
+    << "  --append=<bool>                              "
+    << "    If true, result is appended to possibly existing file. Otherwise, " << end_of_line
+    << "      any existing file is overwritten.\n\n"
+
+    << "  --output=<path>                              "
+    << "    Path to output file for machine readable results. Operation kind and '.csv' is appended.\n\n"
+
+    << "  --junit-output=<path>                        "
+    << "    Path to junit output file for result reporting. Operation kind and '.junit.xml' is appended.\n\n"
+
+    << "  --print-kernel-before-running=<bool>                "
+    << "    Prints the name of the kernel being profiled before running the kernel." << end_of_line
+    << "      This is useful for determining which kernel is causing a run of the profiler to hang\n\n"
+
+    << "  --report-not-run=<bool>                      "
+    << "    If true, reports the status of all kernels including those that" << end_of_line
+    << "      do not satisfy the given arguments.\n\n"
+
+    << "  --tags=<column:tag,...>                      "
+    << "    Inserts leading columns in output table and uniform values for each" << end_of_line
+    << "      column. Useful for generating pivot tables.\n\n"
+
+    << "  --verbose=<bool>                             "
+    << "    Prints human-readable text to stdout. If false, nothing is written to stdout.\n\n"
+
+    << "  --sort-results=<bool>                        "
+    << "    Sorts results (by flops-per-byte).\n\n";
+}
+
+void Options::Report::print_options(std::ostream &out, int indent) const {
+
+  out
+    << indent_str(indent) << "append: " << append << "\n"
+    << indent_str(indent) << "output: " << output_path << "\n"
+    << indent_str(indent) << "junit-output: " << junit_output_path << "\n"
+    << indent_str(indent) << "print-kernel-before-running: " << print_kernel_before_running << "\n"
+    << indent_str(indent) << "report-not-run: " << report_not_run << "\n"
+    << indent_str(indent) << "tags:\n";
+
+  for (auto const & tag : pivot_tags) {
+    out << indent_str(indent + 1) << tag.first << ": " << tag.second << "\n";
+  }
+
+  out
+    << indent_str(indent) << "verbose: " << verbose << "\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::About::About(cutlass::CommandLine const &cmdline) {
+  help = cmdline.check_cmd_line_flag("help");
+  version = cmdline.check_cmd_line_flag("version");
+  device_info = cmdline.check_cmd_line_flag("device-info");
+}
+
+void Options::About::print_usage(std::ostream &out) const {
+
+  out << "About:\n"
+    << "  --version                                        ";
+
+  print_version(out);
+
+  out << "\n";
+}
+
+void Options::About::print_version(std::ostream &out) {
+  out << "CUTLASS " << cutlass::getVersionString()
+      << " built on " << __DATE__ << " at " << __TIME__;
+  if (!cutlass::getGitRevision().empty()) out << " with commit " << cutlass::getGitRevision() << "";
+}
+
+void Options::About::print_options(std::ostream &out, int indent) const {
+
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Options::Options(cutlass::CommandLine const &cmdline):
+  cmdline(cmdline),
+  device(cmdline),
+  initialization(cmdline),
+  library(cmdline),
+  profiling(cmdline),
+  verification(cmdline),
+  report(cmdline),
+  about(cmdline) {
+
+  if (cmdline.check_cmd_line_flag("mode")) {
+    std::string token;
+    cmdline.get_cmd_line_argument("mode", token);
+    execution_mode = from_string<ExecutionMode>(token);
+  }
+  else {
+    execution_mode = ExecutionMode::kProfile;
+  }
+
+  // Enumerating kernels is equivalent to a dry run.
+  if (execution_mode == ExecutionMode::kEnumerate) {
+    execution_mode = ExecutionMode::kDryRun;
+  }
+
+  if (cmdline.check_cmd_line_flag("operation")) {
+    std::string str;
+    cmdline.get_cmd_line_argument("operation", str);
+    operation_kind = library::from_string<library::OperationKind>(str);
+  }
+  else if (cmdline.check_cmd_line_flag("function")) {
+    std::string str;
+    cmdline.get_cmd_line_argument("function", str);
+    operation_kind = library::from_string<library::OperationKind>(str);
+  }
+  else {
+    operation_kind = library::OperationKind::kInvalid;
+  }
+
+  if (cmdline.check_cmd_line_flag("operation_names")) {
+    cmdline.get_cmd_line_arguments("operation_names", operation_names);
+  }
+  else if (cmdline.check_cmd_line_flag("kernels")) {
+    cmdline.get_cmd_line_arguments("kernels", operation_names);
+    profiling.error_on_no_match = cmdline.check_cmd_line_flag("error-on-no-match");
+    profiling.error_if_nothing_is_profiled = cmdline.check_cmd_line_flag("error-if-nothing-is-profiled");
+  }
+
+  if (cmdline.check_cmd_line_flag("ignore-kernels")) {
+    cmdline.get_cmd_line_arguments("ignore-kernels", excluded_operation_names);
+    profiling.error_on_no_match = cmdline.check_cmd_line_flag("error-on-no-match");
+    profiling.error_if_nothing_is_profiled = cmdline.check_cmd_line_flag("error-if-nothing-is-profiled");
+  }
+
+  // Prevent launches on the device for anything other than CUTLASS operation
+  // Allow verification only on host
+  if (execution_mode == ExecutionMode::kTrace) {
+    initialization.provider = library::Provider::kReferenceHost;
+    verification.providers = {library::Provider::kReferenceHost};
+    profiling.enabled = false;
+  }
+}
+
+void Options::print_usage(std::ostream &out) const {
+
+  out
+    << "CUTLASS Profiler\n"
+    << "usage:\n\n"
+    << "    cutlass_profiler [options]\n\n"
+    << "  --help\n\n"
+
+    << "  --mode=<string>                              "
+    << "    Cutlass profiler execution mode." << end_of_line
+    << "       --mode=profile    regular verification and profiling (default)" << end_of_line
+    << "       --mode=dry_run    no kernels are launched or workspaces allocated" << end_of_line
+    << "       --mode=enumerate  lists all operation kind and operations" << end_of_line
+    << "       --mode=trace      executes a single device-side computation with" << end_of_line
+    << "                          no other kernel launches\n\n"
+
+    << "  --device-info                                "
+    << "    Prints information on all GPUs present in the system\n\n"
+
+    << "  --operation=<operation_kind>                 "
+    << "    CUTLASS operation to profile.\n\n"
+
+    << "  --kernels=<string_list>                      "
+    << "    Filter operations by kernel names. For example, call all kernels with" << end_of_line
+    << "      (\"s1688\" and \"nt\") or (\"s844\" and \"tn\" and \"align8\") in their" << end_of_line
+    << "      operation name using --kernels=\"s1688*nt, s884*tn*align8\"\n\n"
+
+    << "  --ignore-kernels=<string_list>               "
+    << "    Excludes kernels whose names match anything in this list.\n\n"
+    ;
+
+  //
+  // Detailed options
+  //
+
+  device.print_usage(out);
+  out << "\n";
+
+  initialization.print_usage(out);
+  out << "\n";
+
+  library.print_usage(out);
+  out << "\n";
+
+  profiling.print_usage(out);
+  out << "\n";
+
+  verification.print_usage(out);
+  out << "\n";
+
+  report.print_usage(out);
+  out << "\n";
+
+  about.print_usage(out);
+  out << "\n";
+}
+
+void Options::print_options(std::ostream &out) const {
+
+  out
+    << "options:\n"
+    << "  help: " << about.help << "\n"
+    << "  mode: " << to_string(execution_mode) << "\n";
+
+  out
+    << "  device:\n";
+  device.print_options(out, 2);
+
+  out
+    << "  initialization:\n";
+  initialization.print_options(out, 2);
+
+  out
+    << "  profiling:\n";
+  profiling.print_options(out, 2);
+
+  out
+    << "  verification:\n";
+  verification.print_options(out, 2);
+
+  out
+    << "  report:\n";
+  report.print_options(out, 2);
+}
+
+std::string Options::indent_str(int indent) {
+  return std::string(indent * 2, ' ');
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/performance_report.cpp

@@ -0,0 +1,505 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <algorithm>
+#include <cstring>
+
+#include "cutlass/library/util.h"
+
+#include "cutlass/library/util.h"
+
+#include "cutlass/profiler/performance_report.h"
+#include "cutlass/profiler/debug.h"
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__unix__)
+
+#define SHELL_COLOR_BRIGHT()  "\033[1;37m"
+#define SHELL_COLOR_GREEN()   "\033[1;32m"
+#define SHELL_COLOR_RED()     "\033[1;31m"
+#define SHELL_COLOR_END()     "\033[0m"
+
+#else
+
+#define SHELL_COLOR_BRIGHT()  ""
+#define SHELL_COLOR_GREEN()   ""
+#define SHELL_COLOR_RED()     ""
+#define SHELL_COLOR_END()     ""
+
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+PerformanceReport::PerformanceReport(
+  Options const &options,
+  std::vector<std::string> const &argument_names,
+  library::OperationKind const &op_kind
+):
+  options_(options), argument_names_(argument_names), problem_index_(0), good_(true), op_kind_(op_kind) {
+
+  // Strip '.csv' if present
+  std::string base_path = options_.report.output_path;
+  base_path = base_path.substr(0, base_path.rfind(".csv"));
+  op_file_name_ = base_path + "." + to_string(op_kind_) + ".csv";
+
+  base_path = options_.report.junit_output_path;
+  base_path = base_path.substr(0, base_path.rfind(".xml"));
+  base_path = base_path.substr(0, base_path.rfind(".junit"));
+  op_junit_file_name_ = base_path + "." + to_string(op_kind_) + ".junit.xml";
+
+  //
+  // Open output file for operation of PerformanceReport::op_kind
+  //
+  if (!options_.report.output_path.empty()) {
+
+    bool print_header = true;
+
+    if (options_.report.append) {
+
+      std::ifstream test_output_file(op_file_name_);
+
+      if (test_output_file.is_open()) {
+        print_header = false;
+        test_output_file.close();
+      }
+
+      output_file_.open(op_file_name_, std::ios::app);
+    }
+    else {
+      output_file_.open(op_file_name_);
+    }
+
+    if (!output_file_.good()) {
+
+      std::cerr << "Could not open output file at path '"
+         << options_.report.output_path << "'" << std::endl;
+
+      good_ = false;
+    }
+
+    if (print_header) {
+      print_csv_header_(output_file_) << std::endl;
+    }
+  }
+
+  if (!options_.report.junit_output_path.empty()) {
+
+    junit_output_file_.open(op_junit_file_name_);
+
+    if (!junit_output_file_.good()) {
+
+      std::cerr << "Could not open junit output file at path '"
+         << options_.report.junit_output_path << "'" << std::endl;
+
+      good_ = false;
+    }
+
+    print_junit_header_(junit_output_file_);
+  }
+}
+
+void PerformanceReport::next_problem() {
+  ++problem_index_;
+}
+
+void PerformanceReport::append_result(PerformanceResult result) {
+
+  result.problem_index = problem_index_;
+
+  if (options_.report.verbose) {
+    std::cout << "\n";
+    print_result_pretty_(std::cout, result) << std::flush;
+  }
+
+  if (junit_output_file_.is_open()) {
+    print_junit_result_(junit_output_file_, result);
+  }
+
+  if (output_file_.is_open()) {
+    print_result_csv_(output_file_, result) << std::endl;
+  }
+  else {
+    concatenated_results_.push_back(result);
+  }
+}
+
+void PerformanceReport::sort_results(PerformanceResultVector &results) {
+
+  struct FlopsPerByteCompare
+  {
+    bool operator()(const PerformanceResult &a, const PerformanceResult &b)
+    {
+      double a_flops_per_byte = double(a.flops) / double(a.bytes);
+      double b_flops_per_byte = double(b.flops) / double(b.bytes);
+
+      return (a_flops_per_byte < b_flops_per_byte);
+    }
+  };
+
+  std::stable_sort(results.begin(), results.end(), FlopsPerByteCompare());
+}
+
+void PerformanceReport::append_results(PerformanceResultVector const &results) {
+
+  if (options_.report.verbose) {
+    std::cout << "\n\n";
+  }
+
+  // For each result
+  for (auto const & result : results) {
+    append_result(result);
+  }
+}
+
+PerformanceReport::~PerformanceReport() {
+
+  //
+  // Output results to stdout if they were not written to a file already.
+  //
+  if (options_.report.verbose && !concatenated_results_.empty()) {
+
+    if (options_.report.sort_results) {
+      sort_results(concatenated_results_);
+    }
+
+    std::cout << "\n\n";
+    std::cout << "=============================\n\n";
+    std::cout << "CSV Results:\n\n";
+
+    print_csv_header_(std::cout) << std::endl;
+
+    for (auto const &result : concatenated_results_) {
+      print_result_csv_(std::cout, result) << "\n";
+    }
+  }
+  else if (output_file_.is_open() && options_.report.verbose) {
+    std::cout << "\nWrote results to '" << op_file_name_ << "'" << std::endl;
+  }
+
+  if (output_file_.is_open()) {
+    output_file_.close();
+  }
+
+  if (junit_output_file_.is_open()) {
+    print_junit_footer_(junit_output_file_);
+    junit_output_file_.close();
+    std::cout << "\nWrote jUnit results to '" << op_junit_file_name_ << "'" << std::endl;
+  }
+}
+
+static const char *disposition_status_color(Disposition disposition) {
+  switch (disposition) {
+    case Disposition::kPassed: return SHELL_COLOR_GREEN();
+    case Disposition::kIncorrect: return SHELL_COLOR_RED();
+    case Disposition::kFailed: return SHELL_COLOR_RED();
+    default:
+    break;
+  }
+  return SHELL_COLOR_END();
+}
+
+/// Prints the result in human readable form
+std::ostream & PerformanceReport::print_result_pretty_(
+  std::ostream &out,
+  PerformanceResult const &result,
+  bool use_shell_coloring) {
+
+  out << "=============================\n"
+    << "  Problem ID: " << result.problem_index << "\n";
+
+  if (!options_.report.pivot_tags.empty()) {
+
+    out << "        Tags: ";
+
+    int column_idx = 0;
+    for (auto const & tag : options_.report.pivot_tags) {
+      out << (column_idx++ ? "," : "") << tag.first << ":" << tag.second;
+    }
+
+    out << "\n";
+  }
+
+  std::string shell_color_bright = use_shell_coloring ? SHELL_COLOR_BRIGHT() : "";
+  std::string shell_color_end = use_shell_coloring ? SHELL_COLOR_END() : "";
+  auto _disposition_status_color = [&](Disposition d) -> const char * {
+    return use_shell_coloring ? disposition_status_color(d) : "";
+  };
+
+  out
+    << "\n"
+    << "        Provider: " << shell_color_bright << library::to_string(result.provider, true) << shell_color_end << "\n"
+    << "   OperationKind: " << shell_color_bright << library::to_string(result.op_kind) << shell_color_end << "\n"
+    << "       Operation: " << result.operation_name << "\n\n"
+    << "          Status: " << shell_color_bright << library::to_string(result.status, true) << shell_color_end << "\n"
+    << "    Verification: " << shell_color_bright << (options_.verification.enabled ? "ON":"OFF") << shell_color_end << "\n"
+    << "     Disposition: " << _disposition_status_color(result.disposition) << to_string(result.disposition, true) << shell_color_end << "\n\n";
+
+  // Display individual verification results for each verification-provider
+  if (options_.verification.enabled) {
+
+    static int const indent_spaces = 16;
+
+    for(auto & m : result.verification_map) {
+      out  << std::right << std::setw(indent_spaces) << library::to_string(m.first, true) << ": " << to_string(m.second, true) << "\n";
+    }
+  }
+
+  out
+    << "\n       Arguments:";
+
+  int column_idx = 0;
+  for (auto const &arg : result.arguments) {
+    if (!arg.second.empty()) {
+      out << " --" << arg.first << "=" << arg.second;
+      column_idx += int(4 + arg.first.size() + arg.second.size());
+      if (column_idx > 98) {
+        out << "  \\\n                 ";
+        column_idx = 0;
+      }
+    }
+  }
+  out << "\n\n";
+
+  out
+    << "           Bytes: " << result.bytes << "  bytes\n"
+    << "           FLOPs: " << result.flops << "  flops\n"
+    << "           FLOPs/Byte: " << (result.flops / result.bytes) << "\n\n";
+
+  if (result.good()) {
+
+    out
+      << "         Runtime: " << result.runtime << "  ms\n"
+      << "          Memory: " << result.gbytes_per_sec() << " GiB/s\n"
+      << "\n            Math: " << result.gflops_per_sec() << " GFLOP/s\n";
+
+  }
+
+  return out;
+}
+
+/// Prints the CSV header
+std::ostream & PerformanceReport::print_csv_header_(
+  std::ostream &out) {
+
+  int column_idx = 0;
+
+  // Pivot tags
+  for (auto const & tag : options_.report.pivot_tags) {
+    out << (column_idx++ ? "," : "") << tag.first;
+  }
+
+  out
+    << (column_idx ? "," : "") << "Problem,Provider"
+    << ",OperationKind,Operation,Disposition,Status";
+
+  for (auto const &arg_name : argument_names_) {
+    out << "," << arg_name;
+  }
+
+  out
+    << ",Bytes"
+    << ",Flops"
+    << ",Flops/Byte"
+    << ",Runtime"
+    << ",GB/s"
+    << ",GFLOPs"
+    ;
+
+  return out;
+}
+
+/// Print the result in CSV output
+std::ostream & PerformanceReport::print_result_csv_(
+  std::ostream &out,
+  PerformanceResult const &result) {
+
+  int column_idx = 0;
+
+  // Pivot tags
+  for (auto const & tag : options_.report.pivot_tags) {
+    out << (column_idx++ ? "," : "") << tag.second;
+  }
+
+  out
+    << (column_idx ? "," : "")
+    << result.problem_index
+    << "," << to_string(result.provider, true)
+    << "," << to_string(result.op_kind)
+    << "," << result.operation_name
+    << "," << to_string(result.disposition)
+    << "," << library::to_string(result.status);
+
+  for (auto const & arg : result.arguments) {
+    out << "," << arg.second;
+  }
+
+  out
+    << "," << result.bytes
+    << "," << result.flops
+    << "," << result.flops / result.bytes
+    << "," << result.runtime;
+
+  if (result.good()) {
+
+    out
+      << "," << result.gbytes_per_sec()
+      << "," << result.gflops_per_sec()
+      ;
+
+  }
+  else {
+    out << std::string(2
+      , ','
+    );
+  }
+
+  return out;
+}
+
+std::ostream & PerformanceReport::print_junit_header_(std::ostream &out) {
+
+  out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+  out << "<testsuite name=\"cutlass_profiler\">" << std::endl;
+  return out;
+
+}
+
+namespace {
+
+  std::string escape_xml_special_chars(const std::string& src) {
+    std::stringstream dst;
+    for (char ch : src) {
+      switch (ch) {
+      case '&': dst << "&amp;"; break;
+      case '\'': dst << "&apos;"; break;
+      case '"': dst << "&quot;"; break;
+      case '<': dst << "&lt;"; break;
+      case '>': dst << "&gt;"; break;
+      default: dst << ch; break;
+      }
+    }
+    return dst.str();
+  }
+
+  template<typename T>
+  std::ostream & print_junit_result_property_(std::ostream & os, const std::string & name, const T & property) {
+    return os << "    <property name=\"" << name << "\" value=\"" << property << "\" />" << std::endl;
+  }
+}
+
+std::ostream & PerformanceReport::print_junit_result_(std::ostream &out, PerformanceResult const &result) {
+
+  out << "  " << "<testcase name=\"";
+
+  std::string delim = "";
+
+  // Pivot tags
+  for (auto const & tag : options_.report.pivot_tags) {
+    out << delim << tag.second; delim = "_";
+  }
+
+  out << delim << to_string(result.op_kind); delim = "_";
+  out << delim << result.operation_name;
+
+  for (auto const & arg : result.arguments) {
+    out << delim << arg.second;
+  }
+
+  out << "\" ";
+
+  bool skipped = false, failed = false, error = false;
+
+  switch (result.disposition) {
+  case Disposition::kNotRun:
+  case Disposition::kNotSupported:
+    skipped = true;
+    break;
+  case Disposition::kPassed:
+  case Disposition::kNotVerified:
+    break;
+  case Disposition::kFailed:
+  case Disposition::kIncorrect:
+    failed = true;
+    break;
+  case Disposition::kInvalidProblem:
+  case Disposition::kInvalid:
+    error = true;
+    break;
+  };
+
+  if (skipped) {
+    out << "status=\"notrun\"";
+  } else {
+    out << "status=\"run\"";
+  }
+
+  out << ">" << std::endl;
+
+  if (failed) {
+    out << "    <failure message=\"" << to_string(result.disposition) << "\" />" << std::endl;
+  }
+
+  if (error) {
+    out << "    <error message=\"" << to_string(result.disposition) << "\" />" << std::endl;
+  }
+
+  out << "    <system-out><![CDATA[" << std::endl;
+  std::stringstream ss;
+  print_result_pretty_(ss, result, false);
+  out << escape_xml_special_chars(ss.str()) << std::endl;
+  out << "    ]]></system-out>" << std::endl;
+
+  out << "  </testcase>" << std::endl;
+
+  return out;
+
+}
+
+std::ostream & PerformanceReport::print_junit_footer_(std::ostream &out) {
+
+  out << "</testsuite>" << std::endl;
+  return out;
+
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/performance_result.cu

@@ -0,0 +1,61 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "cutlass/cutlass.h"
+
+// CUTLASS Profiler includes
+#include "cutlass/profiler/enumerated_types.h"
+#include "cutlass/profiler/performance_result.h"
+
+// CUTLASS Library includes
+#include "cutlass/library/library.h"
+#include "cutlass/library/util.h"
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/problem_space.cpp

@@ -0,0 +1,1263 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief 
+*/
+
+#include <string>
+#include <stdexcept>
+#include <sstream>
+
+#include "cutlass/library/util.h"
+
+#include "cutlass/profiler/problem_space.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+static T lexical_cast(std::string const &str) {
+  std::stringstream ss;
+  T value;
+  
+  ss << str;
+  ss >> value;
+
+  return value;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::ostream & KernelArgument::ValueIterator::print(std::ostream &out) const {
+  out << "[" << (void *)this << "  " <<  argument->qualified_name() << "] ";
+  if (this->null_argument) {
+    out << "<null>";
+  }
+  else {
+    out << "<not null>";
+  }
+  return out;
+}
+
+KernelArgument::~KernelArgument() {
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+ScalarArgument::ScalarValue::ScalarValue(
+  std::string const &value_,
+  ScalarArgument const *argument_,
+  bool not_null_
+):
+  KernelArgument::Value(argument_, not_null_),
+  value(value_) {
+
+}
+
+std::ostream &ScalarArgument::ScalarValue::print(std::ostream &out) const {
+  out << argument->qualified_name() << ": ";
+  if (not_null) {
+    out << value;
+  }
+  else {
+    out << "<null>";
+  }
+  return out;
+}
+
+ScalarArgument::ScalarValueIterator::ScalarValueIterator(
+  ScalarArgument const *argument_
+): 
+  KernelArgument::ValueIterator(argument_) {
+
+  if (argument_) {
+    value_it = argument_->values.begin(); 
+  }
+}
+
+void ScalarArgument::ScalarValueIterator::operator++() {
+  if (this->null_argument) {
+    this->null_argument = false;
+  }
+  else {
+    ++value_it; 
+  }
+}
+
+bool ScalarArgument::ScalarValueIterator::operator==(ValueIterator const &it) const {
+  if (it.type() != ArgumentTypeID::kScalar) {
+    throw std::runtime_error("Cannot compare ScalarValueIterator with iterator of different type");
+  }
+  auto const & scalar_it = static_cast<ScalarValueIterator const &>(it);
+  return value_it == scalar_it.value_it;
+}
+
+/// Gets the value pointed to
+std::unique_ptr<KernelArgument::Value> ScalarArgument::ScalarValueIterator::at() const {
+  if (this->null_argument) {
+    return std::unique_ptr<KernelArgument::Value>(
+      new ScalarArgument::ScalarValue(
+        std::string(), 
+        static_cast<ScalarArgument const *>(argument),
+        false)); 
+  }
+  else {
+    return std::unique_ptr<KernelArgument::Value>(
+      new ScalarArgument::ScalarValue(
+        *value_it, 
+        static_cast<ScalarArgument const *>(argument))); 
+  }
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> ScalarArgument::begin() const {
+  return std::unique_ptr<KernelArgument::ValueIterator>(new ScalarValueIterator(this));
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> ScalarArgument::end() const {
+  ScalarValueIterator *it = new ScalarValueIterator(this);
+  it->value_it = this->values.end();
+  it->null_argument = false;
+  return std::unique_ptr<ValueIterator>(it);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+IntegerArgument::IntegerValue::IntegerValue(
+  int64_t value_, 
+  IntegerArgument const *argument_, 
+  bool not_null_
+): KernelArgument::Value(argument_, not_null_), value(value_) {
+
+}
+
+
+/// Pretty printer for debugging
+std::ostream &IntegerArgument::IntegerValue::print(std::ostream &out) const {
+  out << argument->qualified_name() << ": ";
+  if (not_null) {
+    out << value;
+  }
+  else {
+    out << "<null>";
+  }
+  return out;
+}
+
+IntegerArgument::IntegerValueIterator::IntegerValueIterator(IntegerArgument const *argument_): 
+  KernelArgument::ValueIterator(argument_) {
+
+  if (argument_) {
+    range_it = argument_->ranges.begin();
+    if (range_it != argument_->ranges.end()) {
+      value_it = range_it->begin();
+    }
+  }
+}
+
+void IntegerArgument::IntegerValueIterator::operator++() {
+
+  if (this->null_argument) {
+    this->null_argument = false;
+  }
+  else {
+    ++value_it;
+    if (value_it == range_it->end()) {
+      ++range_it;
+      if (range_it != static_cast<IntegerArgument const *>(argument)->ranges.end()) {
+        value_it = range_it->begin();
+      }
+    }
+  }
+}
+
+bool IntegerArgument::IntegerValueIterator::operator==(ValueIterator const &it) const {
+  if (it.type() != ArgumentTypeID::kInteger) {
+    throw std::runtime_error("Cannot compare IntegerValueIterator with iterator of different type");
+  }
+  
+  auto const & integer_iterator = static_cast<IntegerValueIterator const &>(it);
+
+  if (this->null_argument) {
+    return it.null_argument;
+  }
+  else {
+    if (range_it != integer_iterator.range_it) {
+      return false;
+    }
+    if (range_it == static_cast<IntegerArgument const *>(argument)->ranges.end() &&
+      range_it == integer_iterator.range_it) {
+      return true;
+    }
+    return value_it == integer_iterator.value_it;
+  }
+}
+
+std::unique_ptr<KernelArgument::Value> IntegerArgument::IntegerValueIterator::at() const {
+  if (this->null_argument) {
+    return std::unique_ptr<KernelArgument::Value>(
+      new IntegerArgument::IntegerValue(
+        0, static_cast<IntegerArgument const *>(argument), false));  
+  }
+  else {
+    return std::unique_ptr<KernelArgument::Value>(
+      new IntegerArgument::IntegerValue(
+        *value_it, static_cast<IntegerArgument const *>(argument)));  
+  }
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> IntegerArgument::begin() const {
+  return std::unique_ptr<KernelArgument::ValueIterator>(new IntegerValueIterator(this));
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> IntegerArgument::end() const {
+  IntegerValueIterator *it = new IntegerValueIterator(this);
+  it->range_it = this->ranges.end();
+  it->null_argument = false;
+  return std::unique_ptr<ValueIterator>(it);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+TensorArgument::TensorValue::TensorValue(
+  TensorDescription const &desc_,
+  TensorArgument const *argument_, 
+  bool not_null_ 
+):
+  KernelArgument::Value(argument_, not_null_),
+  desc(desc_) {
+
+}
+
+/// Pretty printer for debugging
+std::ostream &TensorArgument::TensorValue::print(std::ostream &out) const {
+  out << argument->qualified_name() << ": " << to_string(desc.element) << ": " << to_string(desc.layout);
+  return out;
+}
+
+TensorArgument::TensorValueIterator::TensorValueIterator(
+  TensorArgument const *argument_
+): 
+  KernelArgument::ValueIterator(argument_) {
+
+  if (argument_) {
+    value_it = argument_->values.begin();
+  }
+}
+
+void TensorArgument::TensorValueIterator::operator++() {
+  if (this->null_argument) {
+    this->null_argument = false;
+  }
+  else {
+    ++value_it;
+  }
+}
+
+bool TensorArgument::TensorValueIterator::operator==(ValueIterator const &it) const {
+  if (it.type() != ArgumentTypeID::kTensor) {
+    throw std::runtime_error("Cannot compare TensorValueIterator with iterator of different type");
+  }
+  auto const & tensor_it = static_cast<TensorValueIterator const &>(it);
+  return value_it == tensor_it.value_it;
+}
+
+/// Gets the value pointed to
+std::unique_ptr<KernelArgument::Value> TensorArgument::TensorValueIterator::at() const {
+
+  if (this->null_argument) {
+    return std::unique_ptr<KernelArgument::Value>(
+      new TensorArgument::TensorValue(
+        TensorDescription(), static_cast<TensorArgument const *>(argument), false)); 
+  }
+  else {
+    return std::unique_ptr<KernelArgument::Value>(
+      new TensorArgument::TensorValue(
+        *value_it, static_cast<TensorArgument const *>(argument)));  
+  }
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> TensorArgument::begin() const {
+  return std::unique_ptr<KernelArgument::ValueIterator>(new TensorValueIterator(this));
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> TensorArgument::end() const {
+  TensorValueIterator *it = new TensorValueIterator(this);
+  it->value_it = this->values.end();
+  it->null_argument = false;
+  return std::unique_ptr<ValueIterator>(it);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+EnumeratedTypeArgument::EnumeratedTypeValue::EnumeratedTypeValue(
+  std::string const & element_,
+  EnumeratedTypeArgument const *argument_, 
+  bool not_null_
+):
+  KernelArgument::Value(argument_, not_null_),
+  element(element_) {
+
+}
+
+/// Pretty printer for debugging
+std::ostream &EnumeratedTypeArgument::EnumeratedTypeValue::print(std::ostream &out) const {
+  out << argument->qualified_name() << ": " << element;
+  return out;
+}
+
+EnumeratedTypeArgument::EnumeratedTypeValueIterator::EnumeratedTypeValueIterator(
+  EnumeratedTypeArgument const *argument_
+):
+  KernelArgument::ValueIterator(argument_) {
+
+  if (argument_) {
+    value_it = argument_->values.begin();
+  }
+}
+
+void EnumeratedTypeArgument::EnumeratedTypeValueIterator::operator++() {
+  if (this->null_argument) {
+    this->null_argument = false;
+  }
+  else {
+    ++value_it;
+  }
+}
+
+bool EnumeratedTypeArgument::EnumeratedTypeValueIterator::operator==(ValueIterator const &it) const {
+
+  if (it.type() != ArgumentTypeID::kEnumerated) {
+    throw std::runtime_error("Cannot compare EnumeratedTypeValueIterator with iterator of different type");
+  }
+
+  auto const & enumerated_type_it = static_cast<EnumeratedTypeValueIterator const &>(it);
+  return value_it == enumerated_type_it.value_it;
+}
+
+/// Gets the value pointed to
+std::unique_ptr<KernelArgument::Value> EnumeratedTypeArgument::EnumeratedTypeValueIterator::at() const {
+
+  if (this->null_argument) {
+    return std::unique_ptr<KernelArgument::Value>(
+      new EnumeratedTypeValue(
+        std::string(), static_cast<EnumeratedTypeArgument const *>(argument), false));
+  }
+  else {
+    return std::unique_ptr<KernelArgument::Value>(
+      new EnumeratedTypeValue(
+        *value_it, static_cast<EnumeratedTypeArgument const *>(argument)));  
+  }
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> EnumeratedTypeArgument::begin() const {
+  return std::unique_ptr<KernelArgument::ValueIterator>(new EnumeratedTypeValueIterator(this));
+}
+
+std::unique_ptr<KernelArgument::ValueIterator> EnumeratedTypeArgument::end() const {
+  EnumeratedTypeValueIterator *it = new EnumeratedTypeValueIterator(this);
+  it->value_it = this->values.end();
+  it->null_argument = false;
+  return std::unique_ptr<ValueIterator>(it);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+ProblemSpace::Iterator::Iterator(ProblemSpace const &problem_space) {
+  for (auto const & arg_ptr : problem_space.arguments) {
+    construct_(arg_ptr.get());
+  }
+}
+
+ProblemSpace::Iterator::Iterator(Iterator && it) {
+  iterators = std::move(it.iterators);
+}
+
+/// Helper for recursively constructing iterators
+void ProblemSpace::Iterator::construct_(KernelArgument const *argument) {
+  iterators.emplace_back(argument->begin());
+}
+
+/// Given a set of ranges, iterate over the points within their Cartesian product. No big deal.
+void ProblemSpace::Iterator::operator++() {
+
+  // Define a pair of iterator into the vector of iterators.
+  IteratorVector::iterator iterator_it = iterators.begin(); 
+  IteratorVector::iterator next_iterator = iterator_it;
+  
+  // Advance the first argument.
+  ++(**iterator_it);
+
+  // Maintain a pair of iterators over consecutive arguments.
+  ++next_iterator;
+
+  // Carry logic
+  while (next_iterator != iterators.end() &&
+    **iterator_it == *((*iterator_it)->argument->end())) {   // Did an iterator reach the end of its range?
+
+    (*iterator_it) = (*iterator_it)->argument->begin();      // Reset that iterator,
+  
+    ++(**next_iterator);                                     // and increment the next argument's iterator.
+
+    iterator_it = next_iterator;                             // Advance to the next argument
+    ++next_iterator;
+  }
+}
+
+/// Moves iterator to end
+void ProblemSpace::Iterator::move_to_end() {
+  if (!iterators.empty()) {
+    std::unique_ptr<KernelArgument::ValueIterator> new_iter = iterators.back()->argument->end();
+    std::swap(iterators.back(), new_iter);
+  }
+}
+
+ProblemSpace::Problem ProblemSpace::Iterator::at() const {
+  Problem problem;
+
+  for (std::unique_ptr<KernelArgument::ValueIterator> const & it : iterators) {
+    problem.emplace_back(it->at());
+  }
+
+  return problem;
+}
+
+/// Equality operator
+bool ProblemSpace::Iterator::operator==(Iterator const &it) const {
+
+  // This would be an opportunity for auto, but explicitly denoting references to 
+  // owning smart pointers to dynamic polymorphic objects seems like a kindness to the reader.
+  IteratorVector::const_iterator first_it = iterators.begin();
+  IteratorVector::const_iterator second_it = it.iterators.begin();
+
+  int idx = 0;
+  for (; first_it != iterators.end(); ++first_it, ++second_it, ++idx) {
+
+    KernelArgument::ValueIterator const *my_it = first_it->get();
+    KernelArgument::ValueIterator const *their_it = second_it->get();
+
+    if (*my_it != *their_it) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+std::ostream &ProblemSpace::Iterator::print(std::ostream &out) const {
+
+  for (std::unique_ptr<KernelArgument::ValueIterator> const & iter_ptr : iterators) {
+    out << "  [iter " << (iter_ptr->null_argument ? "null" : "<not null>") 
+      << ", type: " << to_string(iter_ptr->argument->description->type) << "]" << std::endl;
+  }
+
+  return out;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+ProblemSpace::ProblemSpace(ArgumentDescriptionVector const &schema, CommandLine const &cmdline) {
+
+  // Clone the arguments
+  for (ArgumentDescription const & arg_desc : schema) {
+    clone_(arguments, &arg_desc);
+  }
+
+  // Parse values from the command line
+  for (auto & arg : arguments) {
+    parse_(arg.get(), cmdline);
+  }
+}
+
+
+/// Returns the index of an argument by name
+size_t ProblemSpace::argument_index(char const *name) const {
+  return argument_index_map.at(name);
+}
+
+/// Helper for recursively cloning
+void ProblemSpace::clone_(
+  KernelArgumentVector &kernel_args,
+  ArgumentDescription const *arg_desc) {
+
+  KernelArgument *kernel_arg = nullptr;
+
+  switch (arg_desc->type) {
+    case ArgumentTypeID::kScalar:
+      kernel_arg = new ScalarArgument(arg_desc);
+      break;
+    case ArgumentTypeID::kInteger:
+      kernel_arg = new IntegerArgument(arg_desc);
+      break;
+    case ArgumentTypeID::kTensor:
+      kernel_arg = new TensorArgument(arg_desc);
+      break;
+    case ArgumentTypeID::kStructure:
+    {
+      throw std::runtime_error("ArgumentTypeID::kStructure not supported");
+    }
+      break;
+    case ArgumentTypeID::kEnumerated:
+      kernel_arg = new EnumeratedTypeArgument(arg_desc);
+      break;
+      
+    default: break;
+  }
+
+  if (kernel_arg) {
+    size_t idx = kernel_args.size();
+    for (auto const &alias : arg_desc->aliases) {
+      argument_index_map.insert(std::make_pair(alias, idx));
+    }
+    kernel_args.emplace_back(kernel_arg);
+  }
+}
+
+/// Parses a command line
+void ProblemSpace::parse_(KernelArgument *arg, CommandLine const &cmdline) {
+
+  switch (arg->description->type) {
+  case ArgumentTypeID::kScalar:
+  {
+    auto * scalar = static_cast<ScalarArgument *>(arg);
+
+    for (auto const &alias : arg->description->aliases) {
+      if (cmdline.check_cmd_line_flag(alias.c_str())) {
+
+        std::vector<std::vector<std::string>> tokens;
+        cmdline.get_cmd_line_argument_ranges(alias.c_str(), tokens);
+
+        for (auto const & vec : tokens) {
+          if (!vec.empty()) {
+            scalar->values.push_back(vec.front());
+          }
+        }
+        break;
+      }
+    }
+  }
+    break;
+  case ArgumentTypeID::kInteger:
+  {
+    auto *integer = static_cast<IntegerArgument *>(arg);
+
+    for (auto const &alias : arg->description->aliases) {
+      if (cmdline.check_cmd_line_flag(alias.c_str())) {
+   
+        std::vector<std::vector<std::string> > tokens;
+        cmdline.get_cmd_line_argument_ranges(alias.c_str(), tokens);
+
+        for (auto &range_tokens : tokens) {
+
+          if (!range_tokens.empty()) {
+
+            Range range;
+
+            if (range_tokens.front() == "rand") {
+              range.mode = Range::Mode::kRandom;
+            }
+            else if (range_tokens.front() == "randlg2") {
+              range.mode = Range::Mode::kRandomLog2;
+            }
+
+            switch (range.mode) {
+              case Range::Mode::kSequence:
+              {
+                range.first = lexical_cast<int64_t>(range_tokens.front());
+            
+                if (range_tokens.size() > 1) {
+                  range.last = lexical_cast<int64_t>(range_tokens.at(1));
+                }
+                else {
+                  range.last = range.first;
+                }
+
+                if (range_tokens.size() > 2) {
+                  range.increment = lexical_cast<int64_t>(range_tokens.at(2));
+                }
+                else {
+                  range.increment = 1;
+                }
+              }
+              break;
+              case Range::Mode::kRandom: // fall-through
+              case Range::Mode::kRandomLog2:
+              {
+                if (range_tokens.size() < 4) {
+                  throw std::runtime_error(
+                    "Range of mode 'rand' must have four tokens showing "
+                    "the minimum, maximum, and number of iterations. For example, "
+                    "rand:16:128:1000");
+                }
+
+                range.minimum = lexical_cast<int64_t>(range_tokens.at(1));
+                range.maximum = lexical_cast<int64_t>(range_tokens.at(2));
+                range.first = 1;
+                range.last = lexical_cast<int64_t>(range_tokens.at(3));
+                range.increment = 1;
+                
+                if (range_tokens.size() > 4) {
+                  range.divisible = lexical_cast<int64_t>(range_tokens.at(4));
+                }
+              }
+              break;
+              default:
+                throw std::runtime_error("Unsupported range mode.");
+                break;
+            }
+          
+            integer->ranges.push_back(range);
+          }
+        } 
+        break;
+      }
+    } 
+  }
+    break;
+  case ArgumentTypeID::kTensor:
+  {
+    auto *tensor = static_cast<TensorArgument *>(arg);
+    
+    for (auto const &alias : arg->description->aliases) {
+      if (cmdline.check_cmd_line_flag(alias.c_str())) {
+
+        std::vector<std::vector<std::string>> tokens;
+
+        cmdline.get_cmd_line_argument_ranges(alias.c_str(), tokens);
+
+        for (auto const & tensor_tokens : tokens) {
+          if (!tensor_tokens.empty()) {
+            TensorArgument::TensorDescription tensor_desc;
+
+            tensor_desc.element = cutlass::library::from_string<library::NumericTypeID>(tensor_tokens.front());
+
+            // Layout
+            if (tensor_tokens.size() > 1) {
+              tensor_desc.layout = cutlass::library::from_string<library::LayoutTypeID>(tensor_tokens.at(1));
+            }
+
+            // Stride
+            for (size_t i = 2; i < tensor_tokens.size(); ++i) {
+              tensor_desc.stride.push_back(lexical_cast<int>(tensor_tokens.at(i)));
+            }
+
+            tensor->values.push_back(tensor_desc);
+          }
+        }
+        break;
+      }
+    }
+  }
+    break;
+  case ArgumentTypeID::kStructure:
+  {
+    throw std::runtime_error("Structure arguments not supported");
+  }
+    break;
+  case ArgumentTypeID::kEnumerated:
+  {
+    auto *enumerated_type = static_cast<EnumeratedTypeArgument *>(arg);
+
+    for (auto const &alias : arg->description->aliases) {
+      if (cmdline.check_cmd_line_flag(alias.c_str())) {
+      
+        std::vector<std::string> tokens;
+        cmdline.get_cmd_line_arguments(alias.c_str(), tokens);
+
+        for (auto const & token : tokens) {
+          enumerated_type->values.push_back(token); 
+        }
+
+        break;
+      }
+    }    
+  }
+    break;
+  default:
+    break;
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+ProblemSpace::Iterator ProblemSpace::begin() const {
+  return ProblemSpace::Iterator(*this);
+}
+
+ProblemSpace::Iterator ProblemSpace::end() const {
+  ProblemSpace::Iterator it(*this);
+  it.move_to_end();
+  return it;
+}
+
+/// Gets all argument names as an ordered vector
+std::vector<std::string> ProblemSpace::argument_names() const {
+
+  Problem problem = this->begin().at();
+
+  std::vector<std::string> names;
+  names.reserve(problem.size());
+  
+  for (auto const & arg : problem) {
+    names.push_back(arg->argument->description->aliases.front());
+  }
+
+  return names;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_int(int64_t &int_value, KernelArgument::Value const *value_ptr) {
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kInteger) {
+      int_value = static_cast<IntegerArgument::IntegerValue const *>(value_ptr)->value; 
+    }
+    else if (value_ptr->argument->description->type == ArgumentTypeID::kScalar) {
+      std::stringstream ss;
+      ss << static_cast<ScalarArgument::ScalarValue const *>(value_ptr)->value;
+      ss >> int_value; 
+    }
+    else {
+      throw std::runtime_error(
+        "arg_as_int64_t() - illegal cast. Problem space argument must be integer or scalar");
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_int(int &int_value, KernelArgument::Value const *value_ptr) {
+  int64_t value64;
+  bool obtained = arg_as_int(value64, value_ptr);
+  if (obtained) {
+    int_value = int(value64);
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int
+bool arg_as_int(
+  int &int_value,
+  char const *name,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_int(int_value, value_ptr);
+}
+
+/// Lexically casts an argument to an int64
+bool arg_as_int(
+  int64_t &int_value,
+  char const *name,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_int(int_value, value_ptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_NumericTypeID(
+  library::NumericTypeID &numeric_type, 
+  KernelArgument::Value const *value_ptr) {
+  
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      numeric_type = library::from_string<library::NumericTypeID>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (numeric_type == library::NumericTypeID::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_NumericTypeID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_NumericTypeID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_NumericTypeID(
+  library::NumericTypeID &numeric_type,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_NumericTypeID(numeric_type, value_ptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_RasterOrder(
+  library::RasterOrder &raster_order, 
+  KernelArgument::Value const *value_ptr) {
+  
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      raster_order = library::from_string<library::RasterOrder>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (raster_order == library::RasterOrder::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_RasterOrder() - illegal cast.");
+      }
+    }
+    else {
+      throw std::runtime_error(
+        "arg_as_RasterOrder() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_RasterOrder(
+  library::RasterOrder &raster_order,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_RasterOrder(raster_order, value_ptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_LayoutTypeID(
+  library::LayoutTypeID &layout_type, 
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      layout_type = library::from_string<library::LayoutTypeID>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (layout_type == library::LayoutTypeID::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_LayoutTypeID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_LayoutTypeID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_LayoutTypeID(
+  library::LayoutTypeID &layout_type,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_LayoutTypeID(layout_type, value_ptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_OpcodeClassID(
+  library::OpcodeClassID &opcode_class,
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      opcode_class = library::from_string<library::OpcodeClassID>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (opcode_class == library::OpcodeClassID::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_OpcodeClassID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_OpcodeClassID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_OpcodeClassID(
+  library::OpcodeClassID &opcode_class,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_OpcodeClassID(opcode_class, value_ptr);
+}
+
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_SplitKModeID(
+  library::SplitKMode &split_k_mode,
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      split_k_mode = library::from_string<library::SplitKMode>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (split_k_mode == library::SplitKMode::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_SplitKModeID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_SplitKModeID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_SplitKModeID(
+  library::SplitKMode &split_k_mode,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_SplitKModeID(split_k_mode, value_ptr);
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_ConvModeID(
+  library::ConvModeID &conv_mode,
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      conv_mode = library::from_string<library::ConvModeID>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (conv_mode == library::ConvModeID::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_ConvModeID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_ConvModeID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_ConvModeID(
+  library::ConvModeID &conv_mode,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_ConvModeID(conv_mode, value_ptr);
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_ProviderID(
+  library::Provider &provider,
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+
+      provider = library::from_string<library::Provider>(
+        static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr)->element);
+
+      if (provider == library::Provider::kInvalid) {
+        throw std::runtime_error(
+          "arg_as_ProviderID() - illegal cast.");
+      }
+    }
+    else {
+
+      throw std::runtime_error(
+        "arg_as_ProviderID() - illegal cast.");
+    }
+    return true;
+  }
+  return false;
+}
+
+/// Lexically casts an argument to an int64 if it is defined. Returns true if not null.
+bool arg_as_ProviderID(
+  library::Provider &provider,
+  char const *name,
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_ProviderID(provider, value_ptr);
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Lexically casts an argument to a given type stored in a byte array. Returns true if not null.
+bool arg_as_scalar(
+  std::vector<uint8_t> &bytes,
+  library::NumericTypeID numeric_type,
+  KernelArgument::Value const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->argument->description->type == ArgumentTypeID::kInteger) {
+      int64_t int_value = static_cast<IntegerArgument::IntegerValue const *>(value_ptr)->value;
+      
+      // TODO - convert int64_t => destination type
+    }
+    else if (value_ptr->argument->description->type == ArgumentTypeID::kScalar) {
+      std::string const &str_value = static_cast<ScalarArgument::ScalarValue const *>(value_ptr)->value;
+
+      return lexical_cast(bytes, numeric_type, str_value);
+    }
+    else {
+      throw std::runtime_error(
+        "arg_as_int() - illegal cast. Problem space argument must be integer or scalar");
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/// Lexically casts an argument to a given type and returns a byte array
+bool arg_as_scalar(
+  std::vector<uint8_t> &bytes,
+  library::NumericTypeID numeric_type,
+  char const *name,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+  
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  return arg_as_scalar(bytes, numeric_type, value_ptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns true if a tensor description satisfies a `tensor` value
+bool tensor_description_satisfies(
+  library::TensorDescription const &tensor_desc,
+  TensorArgument::TensorValue const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    if (value_ptr->desc.element != library::NumericTypeID::kUnknown && 
+      value_ptr->desc.element != tensor_desc.element) {
+
+      return false;
+    }
+
+    if (value_ptr->desc.layout != library::LayoutTypeID::kUnknown &&
+      value_ptr->desc.layout != tensor_desc.layout) {
+
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Returns true if a tensor description satisfies a `tensor` value
+bool tensor_description_satisfies(
+  library::TensorDescription const &tensor_desc,
+  char const *name, 
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  if (value_ptr->argument->description->type == ArgumentTypeID::kTensor) {
+    return tensor_description_satisfies(
+      tensor_desc, 
+      static_cast<TensorArgument::TensorValue const *>(value_ptr));
+  }
+  else {
+    throw std::runtime_error("Kernel argument mismatch");
+  }
+
+  return false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns true if conv_kind satisfies the value
+bool conv_kind_satisfies(
+  library::ConvKind const &conv_kind,
+  EnumeratedTypeArgument::EnumeratedTypeValue const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    library::ConvKind conv_kind_cmd_line = 
+      library::from_string<library::ConvKind>(value_ptr->element);
+
+    if (conv_kind_cmd_line != library::ConvKind::kUnknown && 
+      conv_kind_cmd_line != conv_kind) {
+
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Returns true if conv_kind satisfies the value
+bool conv_kind_satisfies(
+  library::ConvKind const &conv_kind,
+  char const *name, 
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+    return conv_kind_satisfies(
+      conv_kind, 
+      static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr));
+  }
+  else {
+    throw std::runtime_error("Kernel argument mismatch");
+  }
+
+  return false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns true if a iterator algorithm satisfies the value
+bool iterator_algorithm_satisfies(
+  library::IteratorAlgorithmID const &iterator_algorithm,
+  EnumeratedTypeArgument::EnumeratedTypeValue const *value_ptr) {
+
+  if (value_ptr->not_null) {
+    library::IteratorAlgorithmID iterator_algorithm_cmd_line = 
+      library::from_string<library::IteratorAlgorithmID>(value_ptr->element);
+
+    if (iterator_algorithm_cmd_line != library::IteratorAlgorithmID::kNone && 
+      iterator_algorithm_cmd_line != iterator_algorithm) {
+
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Returns true if a iterator algorithm satisfies the value
+bool iterator_algorithm_satisfies(
+  library::IteratorAlgorithmID const &iterator_algorithm,
+  char const *name, 
+  ProblemSpace const &problem_space, 
+  ProblemSpace::Problem const &problem) {
+
+  size_t idx = problem_space.argument_index(name);
+  KernelArgument::Value const *value_ptr = problem.at(idx).get();
+
+  if (value_ptr->argument->description->type == ArgumentTypeID::kEnumerated) {
+    return iterator_algorithm_satisfies(
+      iterator_algorithm, 
+      static_cast<EnumeratedTypeArgument::EnumeratedTypeValue const *>(value_ptr));
+  }
+  else {
+    throw std::runtime_error("Kernel argument mismatch");
+  }
+
+  return false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/rank_2k_operation_profiler.cu

@@ -0,0 +1,752 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+
+
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/core_io.h"
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/rank_2k_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+Rank2KOperationProfiler::Rank2KOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kRank2K,
+    {
+      {ArgumentTypeID::kEnumerated, {"rank_k_kind"}, "Variant of RankK (universal)"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the RankK problem space"},
+      {ArgumentTypeID::kInteger, {"k", "problem-size::k"}, "K dimension of the RankK problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kTensor, {"B"}, "Tensor storing the B operand"},
+      {ArgumentTypeID::kTensor, {"C"}, "Tensor storing the C operand"},
+      {ArgumentTypeID::kEnumerated, {"fill_mode"}, "Fill Mode for RankK kernel (lower or upper)"},
+      {ArgumentTypeID::kEnumerated, {"blas_mode"}, "Blas Mode for RankK kernel (symmetric or hermitian)"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count", "batch-count"}, "Number of RankK computed in one batch"},
+    },
+    { library::Provider::kCUBLAS}
+  ) {
+  description_ = "      Rank 2k Update. D = alpha * (A*B^T + B*A^T) + beta * C (symmetric) or D = alpha * (A*B^H+B*A^H) + beta * C (hermitian)";
+}
+
+/// Destructor
+Rank2KOperationProfiler::~Rank2KOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void Rank2KOperationProfiler::print_usage(std::ostream &out) const {
+  out << "RankK" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void Rank2KOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size Syrk kernel:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --blas_mode=symmetric --n=1024 --k=128\n\n"
+
+    << "Profile a particular problem size Herk kernel:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --blas_mode=hermitian --n=1024 --k=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --n=1024:4096:256 --k=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --accumulator-type=f16,f32\n\n"
+
+    << "Schmoo over fill modees:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --fill_mode=lower/upper\n\n"
+
+    << "Run when A is f16 with column-major or A is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=rank_2k --A=f16:column or --A=*:row\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=rank_2k --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=rank_2k --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=rank_2k --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=rank_2k --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to rank_2k kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=rank_2k \\ \n"
+    << "   --n=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --k=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+Status Rank2KOperationProfiler::RankKProblem::parse(
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->k, "k", problem_space, problem)) {
+    // default value
+    this->k = 1024;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  }
+
+  if (this->split_k_slices > 1 && this->batch_count > 1) {
+    // At least one of these must be one
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.B, "B", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.C, "C", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  this->lda = DeviceAllocation::get_packed_layout(
+    operation_desc.A.layout, {int(this->n), int(this->k)}).front();
+
+  this->ldb = DeviceAllocation::get_packed_layout(
+    operation_desc.B.layout, {int(this->n), int(this->k)}).front();
+
+  this->ldc = DeviceAllocation::get_packed_layout(
+    operation_desc.C.layout, {int(this->n), int(this->n)}).front();
+
+  return Status::kSuccess;
+}
+
+/// Total number of bytes loaded
+int64_t Rank2KOperationProfiler::RankKProblem::bytes(library::RankKDescription const &operation_desc) const {
+  // Input bytes read and Output bytes written for the gemm problem
+  int64_t bytes =
+    2 * int64_t(library::sizeof_bits(operation_desc.A.element) * n / 8) * k +
+    2 * int64_t(library::sizeof_bits(operation_desc.B.element) * n / 8) * k +
+    // Half matrix including the diagonal will have (N*(N+1))/2 elements
+    int64_t(library::sizeof_bits(operation_desc.C.element) * n / 8) * (n+1) / 2;
+
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(beta.begin(), beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    bytes += int64_t(library::sizeof_bits(operation_desc.C.element) * n / 8) * (n+1) / 2;
+  }
+
+  bytes *= batch_count;
+
+  return bytes;
+}
+
+/// Total number of flops computed
+int64_t Rank2KOperationProfiler::RankKProblem::flops(library::RankKDescription const &operation_desc) const {
+
+  // FLOPs = 2 * n(n+1)k/2 [mma1] + 2 * n(n+1)k/2 [mma2] + 2 * n(n+1)/2 [epilogue]
+  // FLOPs = n(n+1)(2k + 1)
+  int64_t flops_ = n * (n + 1) * (2*k + 1);
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddGaussianComplex:
+    flops_ *= 3;
+    break;
+
+  default: break;
+  }
+
+  return flops_;
+}
+
+/// Initializes a performance result
+void Rank2KOperationProfiler::RankKProblem::initialize_result(
+  PerformanceResult &result,
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "rank_k_kind", problem_space, library::to_string(operation_desc.rank_k_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "B", problem_space,
+    std::string(library::to_string(operation_desc.B.element)) + ":" + library::to_string(operation_desc.B.layout));
+
+  set_argument(result, "C", problem_space,
+    std::string(library::to_string(operation_desc.C.element)) + ":" + library::to_string(operation_desc.C.layout));
+
+  set_argument(result, "fill_mode", problem_space, library::to_string(operation_desc.fill_mode));
+
+  set_argument(result, "blas_mode", problem_space, library::to_string(operation_desc.blas_mode));
+
+  set_argument(result, "n", problem_space, n);
+  set_argument(result, "k", problem_space, k);
+
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status Rank2KOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::RankKDescription const &operation_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  if (operation_desc.rank_k_kind != library::RankKKind::kUniversal) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  rank_k_workspace_.configuration.problem_size.m() = int(problem_.n);
+  rank_k_workspace_.configuration.problem_size.n() = int(problem_.n);
+  rank_k_workspace_.configuration.problem_size.k() = int(problem_.k);
+  rank_k_workspace_.configuration.lda = problem_.lda;
+  rank_k_workspace_.configuration.ldb = problem_.ldb;
+  rank_k_workspace_.configuration.ldc = problem_.ldc;
+  rank_k_workspace_.configuration.ldd = problem_.ldc;
+  //rank_k_workspace_.configuration.split_k_slices = int(problem_.split_k_slices);
+  rank_k_workspace_.configuration.batch_count = int(problem_.split_k_slices);
+
+  rank_k_workspace_.arguments.A = nullptr;
+  rank_k_workspace_.arguments.B = nullptr;
+  rank_k_workspace_.arguments.C = nullptr;
+  rank_k_workspace_.arguments.D = nullptr;
+  rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+  rank_k_workspace_.arguments.beta = problem_.beta.data();
+  rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&rank_k_workspace_.configuration, &rank_k_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void Rank2KOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+
+  result.bytes = problem_.bytes(operation_desc);
+  result.flops = problem_.flops(operation_desc);
+  result.runtime = 0;
+
+
+}
+
+/// Initializes workspace
+Status Rank2KOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::RankKDescription const &operation_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    rank_k_workspace_.A = device_context.allocate_and_initialize_tensor(
+      options,
+      "A",
+      operation_desc.A.element,
+      operation_desc.A.layout,
+      {int(problem_.n), int(problem_.k)},
+      {int(problem_.lda)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    rank_k_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      {int(problem_.n), int(problem_.k)},
+      {int(problem_.ldb)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    rank_k_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    rank_k_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    rank_k_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    rank_k_workspace_.Computed->copy_from_device(rank_k_workspace_.C->data());
+    rank_k_workspace_.Reference->copy_from_device(rank_k_workspace_.C->data());
+  }
+
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = operation->get_host_workspace_size(&rank_k_workspace_.configuration);
+      rank_k_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = operation->get_device_workspace_size(&rank_k_workspace_.configuration);
+      rank_k_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = operation->initialize(
+        &rank_k_workspace_.configuration,
+        rank_k_workspace_.host_workspace.data(),
+        rank_k_workspace_.device_workspace.data());
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kRank2K;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool Rank2KOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing RankK arguments
+  rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+  rank_k_workspace_.arguments.B = rank_k_workspace_.B->data();
+  rank_k_workspace_.arguments.C = rank_k_workspace_.C->data();
+  rank_k_workspace_.arguments.D = rank_k_workspace_.Computed->data();
+  rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+  rank_k_workspace_.arguments.beta = problem_.beta.data();
+  rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  //
+  // Run the CUTLASS operation
+  //
+
+  results_.back().status = operation->run(
+    &rank_k_workspace_.arguments,
+    rank_k_workspace_.host_workspace.data(),
+    rank_k_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUBLAS
+    if (options.verification.provider_enabled(library::Provider::kCUBLAS)) {
+
+      // Guard against unsupported cases
+      auto const & rank_k_desc = static_cast<library::RankKDescription const &>(operation->description());
+
+      if (cublas_satisfies(rank_k_desc) == Status::kSuccess) {
+
+        // call cublas verification if supported
+        verify_with_cublas_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+        }
+
+      else {
+        // set verification map for cublas to not supported
+        results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUBLAS
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool Rank2KOperationProfiler::verify_with_cublas_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+
+#if CUTLASS_ENABLE_CUBLAS
+
+  library::RankKDescription const &rank_k_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  //
+  // Construct cuBLAS operators
+  //
+
+  CublasCreate handle;
+  cublasStatus_t status = handle.get_cublas_create_status();
+
+  if (status != CUBLAS_STATUS_SUCCESS) {
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+    return true;
+  }
+
+  //
+  // Initialize state
+  //
+
+  try {
+
+    //
+    // Construct dispatcher to cublas<t>Syr2k()
+    //
+
+    // Initialize structure containing RankK arguments
+    rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+    rank_k_workspace_.arguments.B = rank_k_workspace_.B->data();
+    rank_k_workspace_.arguments.C = rank_k_workspace_.Reference->data();
+    rank_k_workspace_.arguments.D = rank_k_workspace_.Reference->data();
+    rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+    rank_k_workspace_.arguments.beta = problem_.beta.data();
+    rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    detail::cublasRankKDispatcher rank_k_op(
+      rank_k_desc,
+      rank_k_workspace_.configuration,
+      rank_k_workspace_.arguments
+    );
+
+    if (rank_k_op.status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotRun;
+      return true;
+    }
+
+    results_.back().status = Status::kSuccess;
+
+    status = rank_k_op(handle);
+
+    // Handle errors
+    if (status != CUBLAS_STATUS_SUCCESS) {
+
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = compare_tensors(
+      options,
+      *rank_k_workspace_.Computed,
+      *rank_k_workspace_.Reference
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUBLAS] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        rank_k_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUBLAS);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+  }
+
+#endif
+
+  // Return true means continue profiling
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool Rank2KOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing RankK arguments
+    rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+    rank_k_workspace_.arguments.B = rank_k_workspace_.B->data();
+    rank_k_workspace_.arguments.C = rank_k_workspace_.C->data();
+    rank_k_workspace_.arguments.D = rank_k_workspace_.Computed->data();
+    rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+    rank_k_workspace_.arguments.beta = problem_.beta.data();
+    rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &rank_k_workspace_.arguments,
+      rank_k_workspace_.host_workspace.data(),
+      rank_k_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/rank_k_operation_profiler.cu

@@ -0,0 +1,737 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+
+
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/core_io.h"
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/rank_k_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+RankKOperationProfiler::RankKOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kRankK,
+    {
+      {ArgumentTypeID::kEnumerated, {"rank_k_kind"}, "Variant of RankK (universal)"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the RankK problem space"},
+      {ArgumentTypeID::kInteger, {"k", "problem-size::k"}, "K dimension of the RankK problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kTensor, {"C"}, "Tensor storing the C operand"},
+      {ArgumentTypeID::kEnumerated, {"fill_mode"}, "Fill Mode for RankK kernel (lower or upper)"},
+      {ArgumentTypeID::kEnumerated, {"blas_mode"}, "Blas Mode for RankK kernel (symmetric or hermitian)"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count", "batch-count"}, "Number of RankK computed in one batch"},
+    },
+    { library::Provider::kCUBLAS}
+  ) {
+  description_ = "      Rank-k Update. D = alpha * A*A^T + beta * C (symmetric) or D = alpha * A*A^H + beta * C (hermitian)";
+}
+
+/// Destructor
+RankKOperationProfiler::~RankKOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void RankKOperationProfiler::print_usage(std::ostream &out) const {
+  out << "RankK" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void RankKOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size Syrk kernel:\n"
+    << "  $ cutlass_profiler --operation=rank_k --blas_mode=symmetric --n=1024 --k=128\n\n"
+
+    << "Profile a particular problem size Herk kernel:\n"
+    << "  $ cutlass_profiler --operation=rank_k --blas_mode=hermitian --n=1024 --k=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=rank_k --n=1024:4096:256 --k=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=rank_k --accumulator-type=f16,f32\n\n"
+
+    << "Schmoo over fill modees:\n"
+    << "  $ cutlass_profiler --operation=rank_k --fill_mode=lower/upper\n\n"
+
+    << "Run when A is f16 with column-major or A is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=rank_k --A=f16:column or --A=*:row\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=rank_k --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=rank_k --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=rank_k --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=rank_k --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to rank_k kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=rank_k \\ \n"
+    << "   --n=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --k=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+Status RankKOperationProfiler::RankKProblem::parse(
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->k, "k", problem_space, problem)) {
+    // default value
+    this->k = 1024;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  }
+
+  if (this->split_k_slices > 1 && this->batch_count > 1) {
+    // At least one of these must be one
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.C, "C", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  this->lda = DeviceAllocation::get_packed_layout(
+    operation_desc.A.layout, {int(this->n), int(this->k)}).front();
+
+  this->ldc = DeviceAllocation::get_packed_layout(
+    operation_desc.C.layout, {int(this->n), int(this->n)}).front();
+
+  return Status::kSuccess;
+}
+
+/// Total number of bytes loaded
+int64_t RankKOperationProfiler::RankKProblem::bytes(library::RankKDescription const &operation_desc) const {
+  // Input bytes read and Output bytes written for the gemm problem
+  int64_t bytes =
+    int64_t(library::sizeof_bits(operation_desc.A.element) * n / 8) * k +
+    int64_t(library::sizeof_bits(operation_desc.A.element) * n / 8) * k +
+    // Half matrix including the diagonal will have (N*(N+1))/2 elements
+    int64_t(library::sizeof_bits(operation_desc.C.element) * n / 8) * (n+1) / 2;
+
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(beta.begin(), beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    bytes += int64_t(library::sizeof_bits(operation_desc.C.element) * n / 8) * (n+1) / 2;
+  }
+
+  bytes *= batch_count;
+
+  return bytes;
+}
+
+/// Total number of flops computed
+int64_t RankKOperationProfiler::RankKProblem::flops(library::RankKDescription const &operation_desc) const {
+
+  // FLOPs = 2 * n(n+1)k/2 [mma] + 2 * n(n+1)/2 [epilogue]
+  // FLOPs = n(n+1)(k + 1)
+  int64_t flops_ = n * (n + 1) * (k + 1);
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddGaussianComplex:
+    flops_ *= 3;
+    break;
+
+  default: break;
+  }
+
+  return flops_;
+}
+
+/// Initializes a performance result
+void RankKOperationProfiler::RankKProblem::initialize_result(
+  PerformanceResult &result,
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "rank_k_kind", problem_space, library::to_string(operation_desc.rank_k_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "C", problem_space,
+    std::string(library::to_string(operation_desc.C.element)) + ":" + library::to_string(operation_desc.C.layout));
+
+  set_argument(result, "fill_mode", problem_space, library::to_string(operation_desc.fill_mode));
+
+  set_argument(result, "blas_mode", problem_space, library::to_string(operation_desc.blas_mode));
+
+  set_argument(result, "n", problem_space, n);
+  set_argument(result, "k", problem_space, k);
+
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status RankKOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::RankKDescription const &operation_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  if (operation_desc.rank_k_kind != library::RankKKind::kUniversal) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  rank_k_workspace_.configuration.problem_size.m() = int(problem_.n);
+  rank_k_workspace_.configuration.problem_size.n() = int(problem_.n);
+  rank_k_workspace_.configuration.problem_size.k() = int(problem_.k);
+  rank_k_workspace_.configuration.lda = problem_.lda;
+  rank_k_workspace_.configuration.ldc = problem_.ldc;
+  rank_k_workspace_.configuration.ldd = problem_.ldc;
+  //rank_k_workspace_.configuration.split_k_slices = int(problem_.split_k_slices);
+  rank_k_workspace_.configuration.batch_count = int(problem_.split_k_slices);
+
+  rank_k_workspace_.arguments.A = nullptr;
+  rank_k_workspace_.arguments.C = nullptr;
+  rank_k_workspace_.arguments.D = nullptr;
+  rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+  rank_k_workspace_.arguments.beta = problem_.beta.data();
+  rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&rank_k_workspace_.configuration, &rank_k_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void RankKOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::RankKDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+
+  result.bytes = problem_.bytes(operation_desc);
+  result.flops = problem_.flops(operation_desc);
+
+  result.runtime = 0;
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    result.flops *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    result.flops *= 4;
+    break;
+
+  default: break;
+  }
+
+}
+
+/// Initializes workspace
+Status RankKOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::RankKDescription const &operation_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    rank_k_workspace_.A = device_context.allocate_and_initialize_tensor(
+      options,
+      "A",
+      operation_desc.A.element,
+      operation_desc.A.layout,
+      {int(problem_.n), int(problem_.k)},
+      {int(problem_.lda)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    rank_k_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    rank_k_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, //batch_count
+      0 // device_index
+    );
+
+    rank_k_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.n), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, //batch_count
+      0 // device_index
+    );
+
+    rank_k_workspace_.Computed->copy_from_device(rank_k_workspace_.C->data());
+    rank_k_workspace_.Reference->copy_from_device(rank_k_workspace_.C->data());
+  }
+
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = operation->get_host_workspace_size(&rank_k_workspace_.configuration);
+      rank_k_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = operation->get_device_workspace_size(&rank_k_workspace_.configuration);
+      rank_k_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = operation->initialize(
+        &rank_k_workspace_.configuration,
+        rank_k_workspace_.host_workspace.data(),
+        rank_k_workspace_.device_workspace.data());
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kRankK;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool RankKOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing RankK arguments
+  rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+  rank_k_workspace_.arguments.C = rank_k_workspace_.C->data();
+  rank_k_workspace_.arguments.D = rank_k_workspace_.Computed->data();
+  rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+  rank_k_workspace_.arguments.beta = problem_.beta.data();
+  rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  //
+  // Run the CUTLASS operation
+  //
+
+  results_.back().status = operation->run(
+    &rank_k_workspace_.arguments,
+    rank_k_workspace_.host_workspace.data(),
+    rank_k_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUBLAS
+    if (options.verification.provider_enabled(library::Provider::kCUBLAS)) {
+
+      // Guard against unsupported cases
+      auto const & rank_k_desc = static_cast<library::RankKDescription const &>(operation->description());
+
+      if (cublas_satisfies(rank_k_desc) == Status::kSuccess) {
+
+        // call cublas verification if supported
+        verify_with_cublas_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+        }
+
+      else {
+        // set verification map for cublas to not supported
+        results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUBLAS
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool RankKOperationProfiler::verify_with_cublas_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+
+#if CUTLASS_ENABLE_CUBLAS
+
+  library::RankKDescription const &rank_k_desc =
+    static_cast<library::RankKDescription const &>(operation->description());
+
+  //
+  // Construct cuBLAS operators
+  //
+
+  CublasCreate handle;
+  cublasStatus_t status = handle.get_cublas_create_status();
+
+  if (status != CUBLAS_STATUS_SUCCESS) {
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+    return true;
+  }
+
+  //
+  // Initialize state
+  //
+
+  try {
+
+    //
+    // Construct dispatcher to cublas<t>Syrk()
+    //
+
+    // Initialize structure containing RankK arguments
+    rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+    rank_k_workspace_.arguments.C = rank_k_workspace_.Reference->data();
+    rank_k_workspace_.arguments.D = rank_k_workspace_.Reference->data();
+    rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+    rank_k_workspace_.arguments.beta = problem_.beta.data();
+    rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    detail::cublasRankKDispatcher rank_k_op(
+      rank_k_desc,
+      rank_k_workspace_.configuration,
+      rank_k_workspace_.arguments
+    );
+
+    if (rank_k_op.status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotRun;
+      return true;
+    }
+
+    results_.back().status = Status::kSuccess;
+
+    status = rank_k_op(handle);
+
+    // Handle errors
+    if (status != CUBLAS_STATUS_SUCCESS) {
+
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = compare_tensors(
+      options,
+      *rank_k_workspace_.Computed,
+      *rank_k_workspace_.Reference
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUBLAS] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        rank_k_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUBLAS);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+  }
+
+#endif
+
+  // Return true means continue profiling
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool RankKOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing RankK arguments
+    rank_k_workspace_.arguments.A = rank_k_workspace_.A->data();
+    rank_k_workspace_.arguments.C = rank_k_workspace_.C->data();
+    rank_k_workspace_.arguments.D = rank_k_workspace_.Computed->data();
+    rank_k_workspace_.arguments.alpha = problem_.alpha.data();
+    rank_k_workspace_.arguments.beta = problem_.beta.data();
+    rank_k_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &rank_k_workspace_.arguments,
+      rank_k_workspace_.host_workspace.data(),
+      rank_k_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/sparse_gemm_operation_profiler.cu

@@ -0,0 +1,598 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/sparse_gemm_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+SparseGemmOperationProfiler::SparseGemmOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kSparseGemm,
+    {
+      {ArgumentTypeID::kEnumerated, {"gemm_kind"}, "Variant of GEMM (e.g. sparse, ...)"},
+      {ArgumentTypeID::kInteger, {"m", "problem-size::m"}, "M dimension of the GEMM problem space"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the GEMM problem space"},
+      {ArgumentTypeID::kInteger, {"k", "problem-size::k"}, "K dimension of the GEMM problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kTensor, {"B"}, "Tensor storing the B operand"},
+      {ArgumentTypeID::kTensor, {"C"}, "Tensor storing the C operand"},
+      {ArgumentTypeID::kTensor, {"E"}, "Tensor storing the E operand"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kInteger, {"split_k_slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count"}, "Number of GEMMs computed in one batch"},
+    }
+  ) {
+
+  description_ = "      Structured sparse GEMM. D = alpha * A*B + beta * C";
+}
+
+/// Destructor
+SparseGemmOperationProfiler::~SparseGemmOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void SparseGemmOperationProfiler::print_usage(std::ostream &out) const {
+  out << "Sparse GEMM" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void SparseGemmOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size:\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --m=1024 --n=1024 --k=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --m=1024:4096:256 --n=1024:4096:256 --k=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --accumulator-type=f16,f32\n\n"
+
+    << "Run when A is f16 with column-major and B is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --A=f16:column --B=*:row\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=SparseGemm --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=SparseGemm --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to gemm kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=SparseGemm \\ \n"
+    << "   --m=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --n=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --k=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+Status SparseGemmOperationProfiler::SparseGemmProblem::parse(
+  library::SparseGemmDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!arg_as_int(this->m, "m", problem_space, problem)) {
+    // default value
+    this->m = 1024;
+  }
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->k, "k", problem_space, problem)) {
+    // default value
+    this->k = 1024;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.B, "B", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.C, "C", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.E, "E", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  this->elements_per_128b =
+      128 / library::sizeof_bits(operation_desc.A.element);
+
+  this->lda = DeviceAllocation::get_packed_layout(
+                  operation_desc.A.layout,
+                  {int(this->m), int(this->k) / int(this->sparse)})
+                  .front();
+
+  this->ldb = DeviceAllocation::get_packed_layout(
+    operation_desc.B.layout, {int(this->k), int(this->n)}).front();
+
+  this->ldc = DeviceAllocation::get_packed_layout(
+    operation_desc.C.layout, {int(this->m), int(this->n)}).front();
+
+  this->lde =
+      DeviceAllocation::get_packed_layout(
+          operation_desc.E.layout,
+          {int(this->m), int(this->k / this->sparse / this->elements_per_128b)})
+          .front();
+
+  return Status::kSuccess;
+}
+
+/// Initializes a performance result
+void SparseGemmOperationProfiler::SparseGemmProblem::initialize_result(
+  PerformanceResult &result,
+  library::SparseGemmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "gemm_kind", problem_space, library::to_string(operation_desc.gemm_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "B", problem_space,
+    std::string(library::to_string(operation_desc.B.element)) + ":" + library::to_string(operation_desc.B.layout));
+
+  set_argument(result, "C", problem_space,
+    std::string(library::to_string(operation_desc.C.element)) + ":" + library::to_string(operation_desc.C.layout));
+
+  set_argument(result, "E", problem_space,
+    std::string(library::to_string(operation_desc.E.element)) + ":" + library::to_string(operation_desc.E.layout));
+
+  set_argument(result, "m", problem_space, m);
+  set_argument(result, "n", problem_space, n);
+  set_argument(result, "k", problem_space, k);
+
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/// Extracts the problem dimensions
+Status SparseGemmOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::SparseGemmDescription const &operation_desc =
+    static_cast<library::SparseGemmDescription const &>(operation->description());
+
+  if (operation_desc.gemm_kind != library::GemmKind::kSparse) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  gemm_workspace_.configuration.problem_size.m() = int(problem_.m);
+  gemm_workspace_.configuration.problem_size.n() = int(problem_.n);
+  gemm_workspace_.configuration.problem_size.k() = int(problem_.k);
+  gemm_workspace_.configuration.lda = problem_.lda;
+  gemm_workspace_.configuration.ldb = problem_.ldb;
+  gemm_workspace_.configuration.ldc = problem_.ldc;
+  gemm_workspace_.configuration.ldd = problem_.ldc;
+  gemm_workspace_.configuration.lde = problem_.lde;
+
+  gemm_workspace_.arguments.A = nullptr;
+  gemm_workspace_.arguments.B = nullptr;
+  gemm_workspace_.arguments.C = nullptr;
+  gemm_workspace_.arguments.D = nullptr;
+  gemm_workspace_.arguments.E = nullptr;
+  gemm_workspace_.arguments.alpha = problem_.alpha.data();
+  gemm_workspace_.arguments.beta = problem_.beta.data();
+  gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&gemm_workspace_.configuration, &gemm_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void SparseGemmOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::SparseGemmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+  // Input bytes read and Output bytes written for the gemm problem
+  result.bytes =
+      int64_t(library::sizeof_bits(operation_desc.A.element) * problem_.m / 8) *
+          problem_.k / problem_.sparse +
+      int64_t(library::sizeof_bits(operation_desc.B.element) * problem_.n / 8) *
+          problem_.k +
+      int64_t(library::sizeof_bits(operation_desc.C.element) * problem_.m / 8) *
+          problem_.n +
+      int64_t(library::sizeof_bits(operation_desc.E.element) * problem_.m / 8) *
+          problem_.k / problem_.sparse / problem_.elements_per_128b;
+
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(problem_.beta.begin(), problem_.beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    result.bytes += int64_t(library::sizeof_bits(operation_desc.C.element) * problem_.m / 8) * problem_.n;
+  }
+
+  result.flops = 2 * (problem_.m * problem_.n * problem_.k + problem_.m * problem_.n);
+  result.runtime = 0;
+
+}
+
+/// Initializes workspace
+Status SparseGemmOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::SparseGemmDescription const &operation_desc =
+    static_cast<library::SparseGemmDescription const &>(operation->description());
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    gemm_workspace_.A = device_context.allocate_and_initialize_tensor(
+      options,
+      "A",
+      operation_desc.A.element,
+      operation_desc.A.layout,
+      {int(problem_.m), int(problem_.k) / int(problem_.sparse)},
+      {int(problem_.lda)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      {int(problem_.k), int(problem_.n)},
+      {int(problem_.ldb)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    gemm_workspace_.E = device_context.allocate_and_initialize_sparsemeta_tensor(
+      options,
+      "E",
+      operation_desc.E.element,
+      operation_desc.E.layout,
+      operation_desc.A.element,
+      {int(problem_.m), int(problem_.k) / int(problem_.sparse) / int(problem_.elements_per_128b)},
+      {int(problem_.lde)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    gemm_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    gemm_workspace_.Reference->copy_from_device(gemm_workspace_.C->data());
+  }
+
+  //
+  // Initialize the CUTLASS operation
+  //
+
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = operation->get_host_workspace_size(&gemm_workspace_.configuration);
+      gemm_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = operation->get_device_workspace_size(&gemm_workspace_.configuration);
+      gemm_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = operation->initialize(
+        &gemm_workspace_.configuration,
+        gemm_workspace_.host_workspace.data(),
+        gemm_workspace_.device_workspace.data());
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kSparseGemm;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto &verification_provider : options.verification.providers) {
+      results_.back().verification_map[verification_provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool SparseGemmOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing GEMM arguments
+  gemm_workspace_.arguments.A = gemm_workspace_.A->data();
+  gemm_workspace_.arguments.B = gemm_workspace_.B->data();
+  gemm_workspace_.arguments.C = gemm_workspace_.C->data();
+  gemm_workspace_.arguments.D = gemm_workspace_.Computed->data();
+  gemm_workspace_.arguments.E = gemm_workspace_.E->data();
+  gemm_workspace_.arguments.alpha = problem_.alpha.data();
+  gemm_workspace_.arguments.beta = problem_.beta.data();
+  gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  //
+  // Run the CUTLASS operation
+  //
+
+  results_.back().status = operation->run(
+    &gemm_workspace_.arguments,
+    gemm_workspace_.host_workspace.data(),
+    gemm_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool SparseGemmOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing GEMM arguments
+    gemm_workspace_.arguments.A = gemm_workspace_.A->data();
+    gemm_workspace_.arguments.B = gemm_workspace_.B->data();
+    gemm_workspace_.arguments.C = gemm_workspace_.C->data();
+    gemm_workspace_.arguments.D = gemm_workspace_.Computed->data();
+    gemm_workspace_.arguments.E = gemm_workspace_.E->data();
+    gemm_workspace_.arguments.alpha = problem_.alpha.data();
+    gemm_workspace_.arguments.beta = problem_.beta.data();
+    gemm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &gemm_workspace_.arguments,
+      gemm_workspace_.host_workspace.data(),
+      gemm_workspace_.device_workspace.data()
+    );
+  }
+
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/symm_operation_profiler.cu

@@ -0,0 +1,790 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+
+
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/core_io.h"
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/symm_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+SymmOperationProfiler::SymmOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kSymm,
+    {
+      {ArgumentTypeID::kEnumerated, {"symm_kind"}, "Variant of Symm (universal)"},
+      {ArgumentTypeID::kInteger, {"m", "problem-size::m"}, "M dimension of the Symm problem space"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the Symm problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kTensor, {"B"}, "Tensor storing the B operand"},
+      {ArgumentTypeID::kTensor, {"C"}, "Tensor storing the C operand"},
+      {ArgumentTypeID::kEnumerated, {"side_mode"}, "Side Mode for Symm kernel (left or right)"},
+      {ArgumentTypeID::kEnumerated, {"fill_mode"}, "Fill Mode for Symm kernel (lower or upper)"},
+      {ArgumentTypeID::kEnumerated, {"blas_mode"}, "Blas Mode for Symm kernel (symmetric or hermitian)"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count", "batch-count"}, "Number of Symm computed in one batch"},
+    },
+    { library::Provider::kCUBLAS }
+  ) {
+  description_ = "      Symmetric Matrix-Matrix Multiplication. D = alpha * A * B OR alpha * B * A + beta * C (where A is symmetric/hermitian)";
+}
+
+/// Destructor
+SymmOperationProfiler::~SymmOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void SymmOperationProfiler::print_usage(std::ostream &out) const {
+  out << "Symm" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void SymmOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size SYMM kernel:\n"
+    << "  $ cutlass_profiler --operation=Symm --blas_mode=symmetric --m=1024 --n=128\n\n"
+
+    << "Profile a particular problem size HEMM kernel:\n"
+    << "  $ cutlass_profiler --operation=Symm --blas_mode=hermitian --m=1024 --n=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=Symm --m=1024:4096:256 --n=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=Symm --accumulator-type=f16,f32\n\n"
+
+    << "Schmoo over side modees:\n"
+    << "  $ cutlass_profiler --operation=Symm --side_mode=left/right\n\n"
+
+    << "Schmoo over fill modees:\n"
+    << "  $ cutlass_profiler --operation=Symm --fill_mode=lower/upper\n\n"
+
+    << "Run when A is f16 with column-major or A is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=Symm --A=f16:column or --A=*:row\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=Symm --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=Symm --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=Symm --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=Symm --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to symm kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=Symm \\ \n"
+    << "   --m=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --n=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+Status SymmOperationProfiler::SymmProblem::parse(
+  library::SymmDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!arg_as_int(this->m, "m", problem_space, problem)) {
+    // default value
+    this->m = 1024;
+  }
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  }
+
+  if (this->split_k_slices > 1 && this->batch_count > 1) {
+    // At least one of these must be one
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.B, "B", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.C, "C", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (operation_desc.side_mode == SideMode::kLeft) {
+    this->lda = DeviceAllocation::get_packed_layout(
+      operation_desc.A.layout, {int(this->m), int(this->m)}).front();
+  }
+  else if (operation_desc.side_mode == SideMode::kRight) {
+    this->lda = DeviceAllocation::get_packed_layout(
+      operation_desc.A.layout, {int(this->n), int(this->n)}).front();
+  }
+
+  this->ldb = DeviceAllocation::get_packed_layout(
+    operation_desc.B.layout, {int(this->m), int(this->n)}).front();
+
+  this->ldc = DeviceAllocation::get_packed_layout(
+    operation_desc.C.layout, {int(this->m), int(this->n)}).front();
+
+  return Status::kSuccess;
+}
+
+/// Total number of bytes loaded
+int64_t SymmOperationProfiler::SymmProblem::bytes(library::SymmDescription const &operation_desc) const {
+  int64_t bytes = 0;
+  // Input bytes read and Output bytes written for the gemm problem
+  // Half matrix including the diagonal will have (X*(X+1))/2 elements
+  if (operation_desc.side_mode == SideMode::kLeft) {
+    bytes =
+      int64_t(library::sizeof_bits(operation_desc.A.element) * m / 8) * (m + 1) / 2 +
+      int64_t(library::sizeof_bits(operation_desc.B.element) * m / 8) * n +
+      int64_t(library::sizeof_bits(operation_desc.C.element) * m / 8) * n;
+  } else if (operation_desc.side_mode == SideMode::kRight) {
+    bytes =
+      int64_t(library::sizeof_bits(operation_desc.A.element) * n / 8) * (n + 1) / 2 +
+      int64_t(library::sizeof_bits(operation_desc.B.element) * m / 8) * n +
+      int64_t(library::sizeof_bits(operation_desc.C.element) * m / 8) * n;
+  }
+  // Set is_beta_zero true if beta is zero
+  bool is_beta_zero = std::all_of(beta.begin(), beta.end(), [](uint8_t i) { return i==0; });
+
+  // Output bytes read for the gemm problem for non-zero beta values
+  if (!is_beta_zero) {
+    bytes += int64_t(library::sizeof_bits(operation_desc.C.element) * m / 8) * n;
+  }
+
+  bytes *= batch_count;
+
+  return bytes;
+}
+
+/// Total number of flops computed
+int64_t SymmOperationProfiler::SymmProblem::flops(library::SymmDescription const &operation_desc) const {
+
+  // FLOPs for first TRMM kernel (with diagonal) = 2 * [ ( M * (M+1)/2 * N ) ] // Beta is zero
+  // FLOPs for second TRMM kernel (with diagonal) = 2 * [ ( M * (M-1)/2 * N ) ] // Beta is zero
+  // FLOPs = m*(m+1)*n [mma1] + m*(m-1)*n [mma2] + 2*m*n [epilogue]
+  // FLOPs = 2*m*n(m+1) for left side mode
+  // FLOPs can also be calculated to be same as GEMM with correct value for 'k' as below.
+  int64_t k = (operation_desc.side_mode == SideMode::kLeft) ? int64_t(m) : int64_t(n);
+  int64_t flops_ = (int64_t(m) * n * k + m * n) * 2;
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    flops_ *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddGaussianComplex:
+    flops_ *= 3;
+    break;
+
+  default: break;
+  }
+
+  return flops_;
+}
+
+/// Initializes a performance result
+void SymmOperationProfiler::SymmProblem::initialize_result(
+  PerformanceResult &result,
+  library::SymmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "symm_kind", problem_space, library::to_string(operation_desc.symm_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "B", problem_space,
+    std::string(library::to_string(operation_desc.B.element)) + ":" + library::to_string(operation_desc.B.layout));
+
+  set_argument(result, "C", problem_space,
+    std::string(library::to_string(operation_desc.C.element)) + ":" + library::to_string(operation_desc.C.layout));
+
+  set_argument(result, "side_mode", problem_space, library::to_string(operation_desc.side_mode));
+
+  set_argument(result, "fill_mode", problem_space, library::to_string(operation_desc.fill_mode));
+
+  set_argument(result, "blas_mode", problem_space, library::to_string(operation_desc.blas_mode));
+
+  set_argument(result, "m", problem_space, m);
+  set_argument(result, "n", problem_space, n);
+
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status SymmOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::SymmDescription const &operation_desc =
+    static_cast<library::SymmDescription const &>(operation->description());
+
+  if (operation_desc.symm_kind != library::SymmKind::kUniversal) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  symm_workspace_.configuration.problem_size.m() = int(problem_.m);
+  symm_workspace_.configuration.problem_size.n() = int(problem_.n);
+  symm_workspace_.configuration.problem_size.k() = (operation_desc.side_mode == SideMode::kLeft)
+                                                    ? int(problem_.m) : int(problem_.n);
+  symm_workspace_.configuration.lda = problem_.lda;
+  symm_workspace_.configuration.ldb = problem_.ldb;
+  symm_workspace_.configuration.ldc = problem_.ldc;
+  symm_workspace_.configuration.ldd = problem_.ldc;
+  //symm_workspace_.configuration.split_k_slices = int(problem_.split_k_slices);
+  symm_workspace_.configuration.batch_count = int(problem_.split_k_slices);
+
+  symm_workspace_.arguments.A = nullptr;
+  symm_workspace_.arguments.B = nullptr;
+  symm_workspace_.arguments.C = nullptr;
+  symm_workspace_.arguments.D = nullptr;
+  symm_workspace_.arguments.alpha = problem_.alpha.data();
+  symm_workspace_.arguments.beta = problem_.beta.data();
+  symm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&symm_workspace_.configuration, &symm_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void SymmOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::SymmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+
+  result.bytes = problem_.bytes(operation_desc);
+  result.flops = problem_.flops(operation_desc);
+  result.runtime = 0;
+
+
+}
+
+/// Initializes workspace
+Status SymmOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::SymmDescription const &operation_desc =
+    static_cast<library::SymmDescription const &>(operation->description());
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    if (operation_desc.side_mode == SideMode::kLeft) {
+      symm_workspace_.A = device_context.allocate_and_initialize_tensor(
+        options,
+        "A",
+        operation_desc.A.element,
+        operation_desc.A.layout,
+        {int(problem_.m), int(problem_.m)},
+        {int(problem_.lda)},
+        1, // batch_count
+        seed_shift++,
+        0 // device_index
+      );
+    } else if (operation_desc.side_mode == SideMode::kRight) {
+      symm_workspace_.A = device_context.allocate_and_initialize_tensor(
+        options,
+        "A",
+        operation_desc.A.element,
+        operation_desc.A.layout,
+        {int(problem_.n), int(problem_.n)},
+        {int(problem_.lda)},
+        1, // batch_count
+        seed_shift++,
+        0 // device_index
+      );
+    }
+
+    symm_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldb)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    symm_workspace_.C = device_context.allocate_and_initialize_tensor(
+      options,
+      "C",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    symm_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    symm_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.C.element,
+      operation_desc.C.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldc)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    symm_workspace_.Computed->copy_from_device(symm_workspace_.C->data());
+    symm_workspace_.Reference->copy_from_device(symm_workspace_.C->data());
+  }
+
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = operation->get_host_workspace_size(&symm_workspace_.configuration);
+      symm_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = operation->get_device_workspace_size(&symm_workspace_.configuration);
+      symm_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = operation->initialize(
+        &symm_workspace_.configuration,
+        symm_workspace_.host_workspace.data(),
+        symm_workspace_.device_workspace.data());
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kSymm;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool SymmOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing Symm arguments
+  symm_workspace_.arguments.A = symm_workspace_.A->data();
+  symm_workspace_.arguments.B = symm_workspace_.B->data();
+  symm_workspace_.arguments.C = symm_workspace_.C->data();
+  symm_workspace_.arguments.D = symm_workspace_.Computed->data();
+  symm_workspace_.arguments.alpha = problem_.alpha.data();
+  symm_workspace_.arguments.beta = problem_.beta.data();
+  symm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  //
+  // Run the CUTLASS operation
+  //
+
+  results_.back().status = operation->run(
+    &symm_workspace_.arguments,
+    symm_workspace_.host_workspace.data(),
+    symm_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUBLAS
+    if (options.verification.provider_enabled(library::Provider::kCUBLAS)) {
+
+      // Guard against unsupported cases
+      auto const & symm_desc = static_cast<library::SymmDescription const &>(operation->description());
+
+      if (cublas_satisfies(symm_desc) == Status::kSuccess) {
+
+        // call cublas verification if supported
+        verify_with_cublas_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+        }
+
+      else {
+        // set verification map for cublas to not supported
+        results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUBLAS
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool SymmOperationProfiler::verify_with_cublas_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+
+#if CUTLASS_ENABLE_CUBLAS
+
+  library::SymmDescription const &symm_desc =
+    static_cast<library::SymmDescription const &>(operation->description());
+
+  //
+  // Construct cuBLAS operators
+  //
+
+  CublasCreate handle;
+  cublasStatus_t status = handle.get_cublas_create_status();
+
+  if (status != CUBLAS_STATUS_SUCCESS) {
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+    return true;
+  }
+
+  //
+  // Initialize state
+  //
+
+  try {
+
+    //
+    // Construct dispatcher to cublas<t>Symm()
+    //
+
+    // Initialize structure containing Symm arguments
+    symm_workspace_.arguments.A = symm_workspace_.A->data();
+    symm_workspace_.arguments.B = symm_workspace_.B->data();
+    symm_workspace_.arguments.C = symm_workspace_.Reference->data();
+    symm_workspace_.arguments.D = symm_workspace_.Reference->data();
+    symm_workspace_.arguments.alpha = problem_.alpha.data();
+    symm_workspace_.arguments.beta = problem_.beta.data();
+    symm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    detail::cublasSymmDispatcher symm_op(
+      symm_desc,
+      symm_workspace_.configuration,
+      symm_workspace_.arguments
+    );
+
+    if (symm_op.status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotRun;
+      return true;
+    }
+
+    results_.back().status = Status::kSuccess;
+
+    status = symm_op(handle);
+
+    // Handle errors
+    if (status != CUBLAS_STATUS_SUCCESS) {
+
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = compare_tensors(
+      options,
+      *symm_workspace_.Computed,
+      *symm_workspace_.Reference
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUBLAS] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        symm_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUBLAS);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+  }
+
+#endif
+
+  // Return true means continue profiling
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool SymmOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing Symm arguments
+    symm_workspace_.arguments.A = symm_workspace_.A->data();
+    symm_workspace_.arguments.B = symm_workspace_.B->data();
+    symm_workspace_.arguments.C = symm_workspace_.C->data();
+    symm_workspace_.arguments.D = symm_workspace_.Computed->data();
+    symm_workspace_.arguments.alpha = problem_.alpha.data();
+    symm_workspace_.arguments.beta = problem_.beta.data();
+    symm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &symm_workspace_.arguments,
+      symm_workspace_.host_workspace.data(),
+      symm_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/profiler/src/trmm_operation_profiler.cu

@@ -0,0 +1,728 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+/* \file
+   \brief Execution environment
+
+
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include <iomanip>
+#include <ios>
+
+#include "cutlass/core_io.h"
+
+#include "cutlass/profiler/cublas_helpers.h"
+#include "cutlass/profiler/trmm_operation_profiler.h"
+#include "cutlass/profiler/gpu_timer.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cutlass {
+namespace profiler {
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Ctor
+TrmmOperationProfiler::TrmmOperationProfiler(Options const &options):
+  OperationProfiler(
+    options,
+    library::OperationKind::kTrmm,
+    {
+      {ArgumentTypeID::kEnumerated, {"trmm_kind"}, "Variant of TRMM (universal)"},
+      {ArgumentTypeID::kInteger, {"m", "problem-size::m"}, "M dimension of the TRMM problem space"},
+      {ArgumentTypeID::kInteger, {"n", "problem-size::n"}, "N dimension of the TRMM problem space"},
+      {ArgumentTypeID::kTensor, {"A"}, "Tensor storing the A operand"},
+      {ArgumentTypeID::kEnumerated, {"side_mode"}, "Side Mode for TRMM (left, right)"},
+      {ArgumentTypeID::kEnumerated, {"fill_mode"}, "Fill Mode for TRMM (lower, upper)"},
+      {ArgumentTypeID::kEnumerated, {"diag_type"}, "Diag Type for TRMM (nonunit, unit)"},
+      {ArgumentTypeID::kTensor, {"B"}, "Tensor storing the B operand"},
+      {ArgumentTypeID::kTensor, {"D"}, "Tensor storing the D operand"},
+      {ArgumentTypeID::kScalar, {"alpha", "epilogue::alpha"}, "Epilogue scalar alpha"},
+      {ArgumentTypeID::kScalar, {"beta", "epilogue::beta"}, "Epilogue scalar beta"},
+      {ArgumentTypeID::kInteger, {"split_k_slices", "split-k-slices"}, "Number of partitions of K dimension"},
+      {ArgumentTypeID::kInteger, {"batch_count", "batch-count"}, "Number of TRMMs computed in one batch"},
+    },
+    { library::Provider::kCUBLAS}
+  ) {
+  description_ = "      Triangular Matrix-Multiplication. D = alpha * A * B or alpha * B * A";
+}
+
+/// Destructor
+TrmmOperationProfiler::~TrmmOperationProfiler() {
+
+}
+
+/// Prints usage statement for the math function
+void TrmmOperationProfiler::print_usage(std::ostream &out) const {
+  out << "TRMM" << "\n\n";
+
+  OperationProfiler::print_usage(out);
+}
+
+/// Prints examples
+void TrmmOperationProfiler::print_examples(std::ostream &out) const {
+
+  out << "\nExamples:\n\n"
+    << "Profile a particular problem size:\n"
+    << "  $ cutlass_profiler --operation=Trmm --n=1024 --m=128\n\n"
+
+    << "Schmoo over problem size and beta:\n"
+    << "  $ cutlass_profiler --operation=Trmm --n=1024:4096:256 --m=128:8192:128 --beta=0,1,2.5\n\n"
+
+    << "Schmoo over accumulator types:\n"
+    << "  $ cutlass_profiler --operation=Trmm --accumulator-type=f16,f32\n\n"
+
+    << "Run when A is f16 with column-major or A is any datatype with row-major (For column major, use column, col, or n. For row major use, row or t):\n"
+    << "  $ cutlass_profiler --operation=Trmm --A=f16:column or --A=*:row\n\n"
+
+    << "Using various input value distribution:\n"
+    << "  $ cutlass_profiler --operation=Trmm --dist=uniform,min:0,max:3\n"
+    << "  $ cutlass_profiler --operation=Trmm --dist=gaussian,mean:0,stddev:3\n"
+    << "  $ cutlass_profiler --operation=Trmm --dist=sequential,start:0,delta:1\n\n"
+
+    << "Run a kernel with cta tile size of 256x128x32 and save workspace if results are incorrect (note that --cta-tile::k=32 is default cta-tile size):\n"
+    << " $ cutlass_profiler --operation=Trmm --cta_m=256 --cta_n=128  --cta_k=32 --save-workspace=incorrect\n\n"
+
+    << "Test your changes to trmm kernels with a quick functional test and save results in functional-test.csv:\n"
+    << " $ cutlass_profiler  --operation=Trmm \\ \n"
+    << "   --n=8,56,120,136,256,264,512,520,1024,1032,4096,8192,16384 \\ \n"
+    << "   --k=8,16,32,64,128,256,288,384,504,512,520 \\ \n"
+    << "   --beta=0,1,2 --profiling-iterations=1 \\ \n"
+    << "   --providers=cutlass --output=functional-test.csv\n\n";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0
+// used this for debugging
+static std::string byte_string(std::vector<uint8_t> const &bytes) {
+  std::stringstream ss;
+
+  ss << "0x";
+
+  for (size_t idx = bytes.size(); idx > 0; --idx) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << uint32_t(bytes.at(idx - 1));
+  }
+
+  return ss.str();
+}
+#endif
+
+Status TrmmOperationProfiler::TrmmProblem::parse(
+  library::TrmmDescription const &operation_desc,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!arg_as_int(this->m, "m", problem_space, problem)) {
+    // default value
+    this->m = 1024;
+  }
+
+  if (!arg_as_int(this->n, "n", problem_space, problem)) {
+    // default value
+    this->n = 1024;
+  }
+
+  if (!arg_as_int(this->split_k_slices, "split_k_slices", problem_space, problem)) {
+    // default value
+    this->split_k_slices = 1;
+  }
+
+  if (!arg_as_int(this->batch_count, "batch_count", problem_space, problem)) {
+    // default value
+    this->batch_count = 1;
+  }
+
+  if (this->split_k_slices > 1 && this->batch_count > 1) {
+    // At least one of these must be one
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.A, "A", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.B, "B", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!tensor_description_satisfies(operation_desc.D, "D", problem_space, problem)) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  if (!arg_as_scalar(
+    this->alpha,
+    operation_desc.element_epilogue,
+    "alpha",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->alpha, operation_desc.element_epilogue, 1)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (!arg_as_scalar(
+    this->beta,
+    operation_desc.element_epilogue,
+    "beta",
+    problem_space,
+    problem)) {
+
+    if (!cast_from_double(this->beta, operation_desc.element_epilogue, 0)) {
+      return Status::kErrorInternal;
+    }
+  }
+
+  if (operation_desc.side_mode == SideMode::kLeft) {
+    this->lda = DeviceAllocation::get_packed_layout(
+      operation_desc.A.layout, {int(this->m), int(this->m)}).front();
+  }
+  else if (operation_desc.side_mode == SideMode::kRight) {
+    this->lda = DeviceAllocation::get_packed_layout(
+      operation_desc.A.layout, {int(this->n), int(this->n)}).front();
+  }
+
+  this->ldb = DeviceAllocation::get_packed_layout(
+    operation_desc.B.layout, {int(this->m), int(this->n)}).front();
+
+  this->ldd = DeviceAllocation::get_packed_layout(
+    operation_desc.D.layout, {int(this->m), int(this->n)}).front();
+
+  return Status::kSuccess;
+}
+
+/// Initializes a performance result
+void TrmmOperationProfiler::TrmmProblem::initialize_result(
+  PerformanceResult &result,
+  library::TrmmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.arguments.resize(problem_space.rank());
+
+  set_argument(result, "trmm_kind", problem_space, library::to_string(operation_desc.trmm_kind));
+
+  set_argument(result, "A", problem_space,
+    std::string(library::to_string(operation_desc.A.element)) + ":" + library::to_string(operation_desc.A.layout));
+
+  set_argument(result, "side_mode", problem_space, library::to_string(operation_desc.side_mode));
+
+  set_argument(result, "fill_mode", problem_space, library::to_string(operation_desc.fill_mode));
+
+  set_argument(result, "diag_type", problem_space, library::to_string(operation_desc.diag_type));
+
+  set_argument(result, "B", problem_space,
+    std::string(library::to_string(operation_desc.B.element)) + ":" + library::to_string(operation_desc.B.layout));
+
+  set_argument(result, "D", problem_space,
+    std::string(library::to_string(operation_desc.D.element)) + ":" + library::to_string(operation_desc.D.layout));
+
+  set_argument(result, "m", problem_space, m);
+  set_argument(result, "n", problem_space, n);
+
+  set_argument(result, "split_k_slices", problem_space, split_k_slices);
+  set_argument(result, "batch_count", problem_space, batch_count);
+
+  set_argument(result, "alpha", problem_space,
+    library::lexical_cast(alpha, operation_desc.element_epilogue));
+
+  set_argument(result, "beta", problem_space,
+    library::lexical_cast(beta, operation_desc.element_epilogue));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Extracts the problem dimensions
+Status TrmmOperationProfiler::initialize_configuration(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  library::TrmmDescription const &operation_desc =
+    static_cast<library::TrmmDescription const &>(operation->description());
+
+  if (operation_desc.trmm_kind != library::TrmmKind::kUniversal) {
+    return Status::kErrorInvalidProblem;
+  }
+
+  Status status = problem_.parse(operation_desc, problem_space, problem);
+
+  if (status != Status::kSuccess) {
+    return status;
+  }
+
+  trmm_workspace_.configuration.problem_size.m() = int(problem_.m);
+  trmm_workspace_.configuration.problem_size.n() = int(problem_.n);
+  trmm_workspace_.configuration.problem_size.k() = (operation_desc.side_mode == SideMode::kLeft)
+                                                    ? int(problem_.m) : int(problem_.n);
+  trmm_workspace_.configuration.lda = problem_.lda;
+  trmm_workspace_.configuration.ldb = problem_.ldb;
+  trmm_workspace_.configuration.ldd = problem_.ldd;
+  //trmm_workspace_.configuration.split_k_slices = int(problem_.split_k_slices);
+  trmm_workspace_.configuration.batch_count = int(problem_.split_k_slices);
+
+  trmm_workspace_.arguments.A = nullptr;
+  trmm_workspace_.arguments.B = nullptr;
+  trmm_workspace_.arguments.D = nullptr;
+  trmm_workspace_.arguments.alpha = problem_.alpha.data();
+  trmm_workspace_.arguments.beta = problem_.beta.data();
+  trmm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  initialize_result_(this->model_result_, options, operation_desc, problem_space);
+
+  return operation->can_implement(&trmm_workspace_.configuration, &trmm_workspace_.arguments);
+}
+
+/// Initializes the performance result
+void TrmmOperationProfiler::initialize_result_(
+  PerformanceResult &result,
+  Options const &options,
+  library::TrmmDescription const &operation_desc,
+  ProblemSpace const &problem_space) {
+
+  result.provider = library::Provider::kCUTLASS;
+  result.disposition = Disposition::kNotRun;
+  result.status = Status::kSuccess;
+  result.operation_name = operation_desc.name;
+
+  problem_.initialize_result(result, operation_desc, problem_space);
+
+  OperationProfiler::initialize_result_(result, operation_desc, problem_space);
+
+  if (operation_desc.side_mode == SideMode::kLeft) {
+    // Input bytes read and Output bytes written for the trmm problem
+    result.bytes =
+      // Half matrix including the diagonal will have (M*(M+1))/2 elements
+      int64_t(library::sizeof_bits(operation_desc.A.element) * problem_.m / 8) * (problem_.m + 1) / 2 +
+      int64_t(library::sizeof_bits(operation_desc.B.element) * problem_.m / 8) * problem_.n +
+      int64_t(library::sizeof_bits(operation_desc.D.element) * problem_.m / 8) * problem_.n;
+  } else if (operation_desc.side_mode == SideMode::kRight) {
+    // Input bytes read and Output bytes written for the trmm problem
+    result.bytes =
+      // Half matrix including the diagonal will have (N*(N+1))/2 elements
+      int64_t(library::sizeof_bits(operation_desc.A.element) * problem_.n / 8) * (problem_.n + 1) / 2 +
+      int64_t(library::sizeof_bits(operation_desc.B.element) * problem_.m / 8) * problem_.n +
+      int64_t(library::sizeof_bits(operation_desc.D.element) * problem_.m / 8) * problem_.n;
+  }
+
+  // FLOPs = 2 * [ ( M * (M+1)/2 * N ) ] // Beta is zero
+  result.flops = problem_.m * (problem_.m + 1) * problem_.n;
+
+   result.runtime = 0;
+
+  // complex-valued support
+  switch (operation_desc.tile_description.math_instruction.math_operation) {
+  case library::MathOperationID::kMultiplyAddComplex:
+    result.flops *= 4;
+    break;
+
+  case library::MathOperationID::kMultiplyAddComplexFastF32:
+    result.flops *= 4;
+    break;
+
+  default: break;
+  }
+
+}
+
+/// Initializes workspace
+Status TrmmOperationProfiler::initialize_workspace(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.device.devices.size() != 1) {
+    throw std::runtime_error("This operation profiler only supports a single "
+                             "device.");
+  }
+
+  cudaError_t result;
+  result = cudaSetDevice(options.device.device_id(0));
+  if (result != cudaSuccess) {
+    throw std::runtime_error("cudaSetDevice() failed.");
+  }
+
+  library::TrmmDescription const &operation_desc =
+    static_cast<library::TrmmDescription const &>(operation->description());
+
+  if (options.execution_mode != ExecutionMode::kDryRun) {
+    int seed_shift = 0;
+    if (operation_desc.side_mode == SideMode::kLeft) {
+      trmm_workspace_.A = device_context.allocate_and_initialize_tensor(
+        options,
+        "A",
+        operation_desc.A.element,
+        operation_desc.A.layout,
+        {int(problem_.m), int(problem_.m)},
+        {int(problem_.lda)},
+        1, // batch_count
+        seed_shift++,
+        0 // device_index
+      );
+    } else if (operation_desc.side_mode == SideMode::kRight) {
+      trmm_workspace_.A = device_context.allocate_and_initialize_tensor(
+        options,
+        "A",
+        operation_desc.A.element,
+        operation_desc.A.layout,
+        {int(problem_.n), int(problem_.n)},
+        {int(problem_.lda)},
+        1, // batch_count
+        seed_shift++,
+        0 // device_index
+      );
+    }
+
+    trmm_workspace_.B = device_context.allocate_and_initialize_tensor(
+      options,
+      "B",
+      operation_desc.B.element,
+      operation_desc.B.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldb)},
+      1, // batch_count
+      seed_shift++,
+      0 // device_index
+    );
+
+    trmm_workspace_.Computed = device_context.allocate_tensor(
+      options,
+      "D",
+      operation_desc.D.element,
+      operation_desc.D.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldd)},
+      1, // batch_count
+      0 // device_index
+    );
+
+    trmm_workspace_.Reference = device_context.allocate_tensor(
+      options,
+      "Reference",
+      operation_desc.D.element,
+      operation_desc.D.layout,
+      {int(problem_.m), int(problem_.n)},
+      {int(problem_.ldd)},
+      1, // batch_count
+      0 // device_index
+    );
+
+  }
+
+  //
+  // Initialize the CUTLASS operation
+  //
+  Status status = Status::kSuccess;
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    if (options.execution_mode != ExecutionMode::kDryRun) {
+
+      uint64_t workspace_size = operation->get_host_workspace_size(&trmm_workspace_.configuration);
+      trmm_workspace_.host_workspace.resize(workspace_size, 0);
+
+      workspace_size = operation->get_device_workspace_size(&trmm_workspace_.configuration);
+      trmm_workspace_.device_workspace.reset(library::NumericTypeID::kU8, workspace_size);
+
+      status = operation->initialize(
+        &trmm_workspace_.configuration,
+        trmm_workspace_.host_workspace.data(),
+        trmm_workspace_.device_workspace.data());
+    }
+
+    //
+    // If CUTLASS is enabled, generate a result for it
+    //
+    results_.push_back(model_result_);
+    results_.back().provider = library::Provider::kCUTLASS;
+    results_.back().op_kind = library::OperationKind::kTrmm;
+    results_.back().disposition = Disposition::kNotRun;
+
+    for(auto provider : verification_providers_) {
+      results_.back().verification_map[provider] = Disposition::kNotRun;
+    }
+  }
+
+  return status;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool TrmmOperationProfiler::verify_cutlass(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (!options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+    return true;
+  }
+
+  if (options.execution_mode == ExecutionMode::kDryRun) {
+    return true;
+  }
+
+  // Initialize structure containing TRMM arguments
+  trmm_workspace_.arguments.A = trmm_workspace_.A->data();
+  trmm_workspace_.arguments.B = trmm_workspace_.B->data();
+  trmm_workspace_.arguments.D = trmm_workspace_.Computed->data();
+  trmm_workspace_.arguments.alpha = problem_.alpha.data();
+  trmm_workspace_.arguments.beta = problem_.beta.data();
+  trmm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+  //
+  // Run the CUTLASS operation
+  //
+
+  results_.back().status = operation->run(
+    &trmm_workspace_.arguments,
+    trmm_workspace_.host_workspace.data(),
+    trmm_workspace_.device_workspace.data());
+
+  if (results_.back().status != Status::kSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  cudaError_t result = cudaDeviceSynchronize();
+  if (result != cudaSuccess) {
+    results_.back().disposition = Disposition::kFailed;
+    return false;
+  }
+
+  // CUTLASS op ran the but not yet verified against any verification provider
+  results_.back().disposition = Disposition::kNotVerified;
+
+  //
+  // Run verification providers
+  //
+
+  if (options.verification.enabled) {
+
+#if CUTLASS_ENABLE_CUBLAS
+    if (options.verification.provider_enabled(library::Provider::kCUBLAS)) {
+
+      // Guard against unsupported cases
+      auto const & trmm_desc = static_cast<library::TrmmDescription const &>(operation->description());
+
+      if (cublas_satisfies(trmm_desc) == Status::kSuccess) {
+
+        // call cublas verification if supported
+        verify_with_cublas_(
+          options,
+          report,
+          device_context,
+          operation,
+          problem_space,
+          problem);
+        }
+
+      else {
+        // set verification map for cublas to not supported
+        results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotSupported;
+      }
+    }
+#endif // #if CUTLASS_ENABLE_CUBLAS
+
+    // Update disposition to worst case verification outcome among all
+    // verification providers which are supported
+    bool is_any_verification_run_passed = false;
+    for(auto &m : results_.back().verification_map) {
+      if(m.second == Disposition::kFailed || m.second == Disposition::kIncorrect) {
+        results_.back().disposition = m.second;
+        return true;
+      }
+      if(!is_any_verification_run_passed && m.second == Disposition::kPassed) {
+        is_any_verification_run_passed = true;
+      }
+    }
+
+    if(is_any_verification_run_passed) {
+      results_.back().disposition = Disposition::kPassed;
+    }
+  }
+
+  // Return true means continue profiling
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Verifies CUTLASS against references
+bool TrmmOperationProfiler::verify_with_cublas_(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+
+#if CUTLASS_ENABLE_CUBLAS
+
+  library::TrmmDescription const &trmm_desc =
+    static_cast<library::TrmmDescription const &>(operation->description());
+
+  //
+  // Construct cuBLAS operators
+  //
+
+  CublasCreate handle;
+  cublasStatus_t status = handle.get_cublas_create_status();
+
+  if (status != CUBLAS_STATUS_SUCCESS) {
+
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+    return true;
+  }
+
+  //
+  // Initialize state
+  //
+
+  try {
+
+    //
+    // Construct dispatcher to cublas<t>Trmm()
+    //
+
+    // Initialize structure containing TRMM arguments
+    trmm_workspace_.arguments.A = trmm_workspace_.A->data();
+    trmm_workspace_.arguments.B = trmm_workspace_.B->data();
+    trmm_workspace_.arguments.D = trmm_workspace_.Reference->data();
+    trmm_workspace_.arguments.alpha = problem_.alpha.data();
+    trmm_workspace_.arguments.beta = problem_.beta.data();
+    trmm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    detail::cublasTrmmDispatcher trmm_op(
+      trmm_desc,
+      trmm_workspace_.configuration,
+      trmm_workspace_.arguments
+    );
+
+    if (trmm_op.status != Status::kSuccess) {
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kNotRun;
+      return true;
+    }
+
+    results_.back().status = Status::kSuccess;
+
+    status = trmm_op(handle);
+
+    // Handle errors
+    if (status != CUBLAS_STATUS_SUCCESS) {
+
+      results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+      return true;
+    }
+
+    //
+    // Verify results
+    //
+    results_.back().verification_map[library::Provider::kCUBLAS] = compare_tensors(
+      options,
+      *trmm_workspace_.Computed,
+      *trmm_workspace_.Reference
+    );
+
+    // Save workspace if incorrect
+    if (options.verification.save_workspace == SaveWorkspace::kIncorrect &&
+      results_.back().verification_map[library::Provider::kCUBLAS] == Disposition::kIncorrect) {
+
+      save_workspace(
+        device_context,
+        options,
+        trmm_desc,
+        library::Provider::kCUTLASS,
+        library::Provider::kCUBLAS);
+    }
+  }
+  catch (...) {
+    results_.back().verification_map[library::Provider::kCUBLAS] = Disposition::kFailed;
+  }
+
+#endif
+
+  // Return true means continue profiling
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Measures performance results
+bool TrmmOperationProfiler::profile(
+  Options const &options,
+  PerformanceReport &report,
+  DeviceContext &device_context,
+  library::Operation const *operation,
+  ProblemSpace const &problem_space,
+  ProblemSpace::Problem const &problem) {
+
+  if (options.profiling.provider_enabled(library::Provider::kCUTLASS)) {
+
+    // Initialize structure containing TRMM arguments
+    trmm_workspace_.arguments.A = trmm_workspace_.A->data();
+    trmm_workspace_.arguments.B = trmm_workspace_.B->data();
+    trmm_workspace_.arguments.D = trmm_workspace_.Computed->data();
+    trmm_workspace_.arguments.alpha = problem_.alpha.data();
+    trmm_workspace_.arguments.beta = problem_.beta.data();
+    trmm_workspace_.arguments.pointer_mode = library::ScalarPointerMode::kHost;
+
+    results_.back().status = profile_cutlass_(
+      results_.back().runtime,
+      options,
+      operation,
+      &trmm_workspace_.arguments,
+      trmm_workspace_.host_workspace.data(),
+      trmm_workspace_.device_workspace.data()
+    );
+  }
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+} // namespace profiler
+} // namespace cutlass
+
+/////////////////////////////////////////////////////////////////////////////////////////////////

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/util/include/cutlass/util/GPU_Clock.hpp

@@ -0,0 +1,67 @@
+/***************************************************************************************************
+ * Copyright (c) 2023 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+
+#pragma once
+
+#include <cuda_runtime.h>
+
+struct GPU_Clock
+{
+  GPU_Clock() {
+    cudaEventCreate(&start_);
+    cudaEventCreate(&stop_);
+    cudaEventRecord(start_);
+  }
+
+  ~GPU_Clock() {
+    cudaEventDestroy(start_);
+    cudaEventDestroy(stop_);
+  }
+
+  void start() {
+    cudaEventRecord(start_);
+  }
+
+  float milliseconds() {
+    cudaEventRecord(stop_);
+    cudaEventSynchronize(stop_);
+    float time;
+    cudaEventElapsedTime(&time, start_, stop_);
+    return time;
+  }
+
+  float seconds() {
+    return milliseconds() * float(1e-3);
+  }
+
+ private:
+  cudaEvent_t start_, stop_;
+};

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/util/include/cutlass/util/command_line.h

@@ -0,0 +1,313 @@
+/******************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+/**
+ * \file
+ * Utility for parsing command line arguments
+ */
+
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <cuda_runtime.h>
+
+#include "cutlass/cutlass.h"
+
+namespace cutlass {
+
+/******************************************************************************
+ * command_line
+ ******************************************************************************/
+
+/**
+ * Utility for parsing command line arguments
+ */
+struct CommandLine {
+  std::vector<std::string> keys;
+  std::vector<std::string> values;
+  std::vector<std::string> args;
+
+  /**
+   * Constructor
+   */
+  CommandLine(int argc, const char** argv) {
+    using namespace std;
+
+    for (int i = 1; i < argc; i++) {
+      string arg = argv[i];
+
+      if ((arg[0] != '-') || (arg[1] != '-')) {
+        args.push_back(arg);
+        continue;
+      }
+
+      string::size_type pos;
+      string key, val;
+      if ((pos = arg.find('=')) == string::npos) {
+        key = string(arg, 2, arg.length() - 2);
+        val = "";
+      } else {
+        key = string(arg, 2, pos - 2);
+        val = string(arg, pos + 1, arg.length() - 1);
+      }
+
+      keys.push_back(key);
+      values.push_back(val);
+    }
+  }
+
+  /**
+   * Checks whether a flag "--<flag>" is present in the commandline
+   */
+  bool check_cmd_line_flag(const char* arg_name) const {
+    using namespace std;
+
+    for (int i = 0; i < int(keys.size()); ++i) {
+      if (keys[i] == string(arg_name)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns number of naked (non-flag and non-key-value) commandline parameters
+   */
+  size_t num_naked_args() const {
+    return args.size();
+  }
+
+  /**
+   * Print naked (non-flag and non-key-value) commandline parameters
+   */
+  void print_naked_args(std::ostream &out) const {
+    for (auto arg : args) {
+      out << "   " << arg <<"\n";
+    }
+  }
+
+  /**
+   * Returns the commandline parameter for a given index (not including flags)
+   */
+  template <typename value_t>
+  void get_cmd_line_argument(size_t index, value_t& val) const {
+    using namespace std;
+    if (index < args.size()) {
+      istringstream str_stream(args[index]);
+      str_stream >> val;
+    }
+  }
+
+  /**
+   * Obtains the boolean value specified for a given commandline parameter --<flag>=<bool>
+   */
+  void get_cmd_line_argument(const char* arg_name, bool& val, bool _default) const {
+    val = _default;
+    if (check_cmd_line_flag(arg_name)) {
+      std::string value;
+      get_cmd_line_argument(arg_name, value);
+
+      val = !(value == "0" || value == "false");
+    }
+  }
+  
+  /**
+   * Obtains the value specified for a given commandline parameter --<flag>=<value>
+   */
+  template <typename value_t>
+  void get_cmd_line_argument(const char* arg_name,
+                             value_t& val) const {
+
+    get_cmd_line_argument(arg_name, val, val);
+  }
+
+  /**
+   * Obtains the value specified for a given commandline parameter --<flag>=<value>
+   */
+  template <typename value_t>
+  void get_cmd_line_argument(const char* arg_name,
+                             value_t& val,
+                             value_t const& _default) const {
+    using namespace std;
+
+    val = _default;
+
+    for (int i = 0; i < int(keys.size()); ++i) {
+      if (keys[i] == string(arg_name)) {
+        istringstream str_stream(values[i]);
+        str_stream >> val;
+      }
+    }
+  }
+
+  /**
+   * Returns the values specified for a given commandline parameter --<flag>=<value>,<value>*
+   */
+  template <typename value_t>
+  void get_cmd_line_arguments(const char* arg_name,
+                              std::vector<value_t>& vals,
+                              char sep = ',') const {
+    using namespace std;
+
+    if (check_cmd_line_flag(arg_name)) {
+      // Clear any default values
+      vals.clear();
+
+      // Recover from multi-value string
+      for (size_t i = 0; i < keys.size(); ++i) {
+        if (keys[i] == string(arg_name)) {
+          string val_string(values[i]);
+          separate_string(val_string, vals, sep);
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns the values specified for a given commandline parameter
+   * --<flag>=<value>,<value_start:value_end>*
+   */
+  void get_cmd_line_argument_pairs(const char* arg_name,
+                                   std::vector<std::pair<std::string, std::string> >& tokens,
+                                   char delim = ',',
+                                   char sep = ':') const {
+    if (check_cmd_line_flag(arg_name)) {
+      std::string value;
+      get_cmd_line_argument(arg_name, value);
+
+      tokenize(tokens, value, delim, sep);
+    }
+  }
+
+  /**
+   * Returns a list of ranges specified for a given commandline parameter
+   * --<flag>=<key:value>,<key:value>*
+   */
+  void get_cmd_line_argument_ranges(const char* arg_name,
+                                    std::vector<std::vector<std::string> >& vals,
+                                    char delim = ',',
+                                    char sep = ':') const {
+    std::vector<std::string> ranges;
+    get_cmd_line_arguments(arg_name, ranges, delim);
+
+    for (std::vector<std::string>::const_iterator range = ranges.begin();
+      range != ranges.end(); ++range) {
+
+      std::vector<std::string> range_vals;
+      separate_string(*range, range_vals, sep);
+      vals.push_back(range_vals);
+    }
+  }
+
+  /**
+   * The number of pairs parsed
+   */
+  int parsed_argc() const { return (int)keys.size(); }
+
+  //-------------------------------------------------------------------------
+  // Utility functions
+  //-------------------------------------------------------------------------
+
+  /// Tokenizes a comma-delimited list of string pairs delimited by ':'
+  static void tokenize(std::vector<std::pair<std::string, std::string> >& tokens,
+                       std::string const& str,
+                       char delim = ',',
+                       char sep = ':') {
+    // Home-built to avoid Boost dependency
+    size_t s_idx = 0;
+    size_t d_idx = std::string::npos;
+    while (s_idx < str.size()) {
+      d_idx = str.find_first_of(delim, s_idx);
+
+      size_t end_idx = (d_idx != std::string::npos ? d_idx : str.size());
+      size_t sep_idx = str.find_first_of(sep, s_idx);
+      size_t offset = 1;
+      if (sep_idx == std::string::npos || sep_idx >= end_idx) {
+        sep_idx = end_idx;
+        offset = 0;
+      }
+
+      std::pair<std::string, std::string> item(
+          str.substr(s_idx, sep_idx - s_idx),
+          str.substr(sep_idx + offset, end_idx - sep_idx - offset));
+
+      tokens.push_back(item);
+      s_idx = end_idx + 1;
+    }
+  }
+
+  /// Tokenizes a comma-delimited list of string pairs delimited by ':'
+  static void tokenize(std::vector<std::string>& tokens,
+                       std::string const& str,
+                       char delim = ',',
+                       char sep = ':') {
+    typedef std::vector<std::pair<std::string, std::string> > TokenVector;
+    typedef TokenVector::const_iterator token_iterator;
+
+    std::vector<std::pair<std::string, std::string> > token_pairs;
+    tokenize(token_pairs, str, delim, sep);
+    for (token_iterator tok = token_pairs.begin(); tok != token_pairs.end(); ++tok) {
+      tokens.push_back(tok->first);
+    }
+  }
+
+  template <typename value_t>
+  static void separate_string(std::string const& str,
+                              std::vector<value_t>& vals,
+                              char sep = ',') {
+    std::istringstream str_stream(str);
+    std::string::size_type old_pos = 0;
+    std::string::size_type new_pos = 0;
+
+    // Iterate <sep>-delimited values
+    value_t val;
+    while ((new_pos = str.find(sep, old_pos)) != std::string::npos) {
+      if (new_pos != old_pos) {
+        str_stream.width(new_pos - old_pos);
+        str_stream >> val;
+        vals.push_back(val);
+      }
+
+      // skip over delimiter
+      str_stream.ignore(1);
+      old_pos = new_pos + 1;
+    }
+
+    // Read last value
+    str_stream >> val;
+    vals.push_back(val);
+  }
+};
+
+}  // namespace cutlass

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/util/include/cutlass/util/cublas_wrappers.hpp

@@ -0,0 +1,526 @@
+/***************************************************************************************************
+ * Copyright (c) 2023 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+
+#pragma once
+
+#include <cuda_runtime.h>
+#include <cublas_v2.h>
+
+//-- BLAM_DEBUG_OUT ---------------------------------------------------------
+#ifdef BLAM_DEBUG
+# include <iostream>
+# ifndef BLAM_DEBUG_OUT
+#  define BLAM_DEBUG_OUT(msg)    std::cerr << "BLAM: " << msg << std::endl
+#  define BLAM_DEBUG_OUT_2(msg)  std::cerr << msg << std::endl
+# endif // BLAM_DEBUG_OUT
+#else
+# ifndef BLAM_DEBUG_OUT
+#  define BLAM_DEBUG_OUT(msg)
+#  define BLAM_DEBUG_OUT_2(msg)
+# endif // BLAM_DEBUG_OUT
+#endif // BLAM_DEBUG
+
+// User could potentially define ComplexFloat/ComplexDouble instead of std::
+#ifndef BLAM_COMPLEX_TYPES
+#define BLAM_COMPLEX_TYPES 1
+#include <cuda/std/complex>
+namespace blam {
+template <typename T>
+using Complex       = cuda::std::complex<T>;
+using ComplexFloat  = cuda::std::complex<float>;
+using ComplexDouble = cuda::std::complex<double>;
+}
+#endif // BLAM_COMPLEX_TYPES
+
+// User could potentially define Half instead of cute::
+#ifndef BLAM_HALF_TYPE
+#define BLAM_HALF_TYPE 1
+#include <cute/numeric/numeric_types.hpp>
+namespace blam {
+using Half = cute::half_t;
+}
+#endif // BLAM_HALF_TYPE
+
+namespace blam
+{
+namespace cublas
+{
+
+inline const char*
+cublas_get_error(cublasStatus_t status)
+{
+  switch (status) {
+    case CUBLAS_STATUS_SUCCESS:
+      return "CUBLAS_STATUS_SUCCESS";
+    case CUBLAS_STATUS_NOT_INITIALIZED:
+      return "CUBLAS_STATUS_NOT_INITIALIZED -- The cuBLAS library was not initialized.";
+    case CUBLAS_STATUS_ALLOC_FAILED:
+      return "CUBLAS_STATUS_ALLOC_FAILED -- Resource allocation failed inside the cuBLAS library.";
+    case CUBLAS_STATUS_INVALID_VALUE:
+      return "CUBLAS_STATUS_INVALID_VALUE -- An unsupported value or parameter was passed to the function.";
+    case CUBLAS_STATUS_ARCH_MISMATCH:
+      return "CUBLAS_STATUS_ARCH_MISMATCH -- The function requires a feature absent from the device architecture.";
+    case CUBLAS_STATUS_MAPPING_ERROR:
+      return "CUBLAS_STATUS_MAPPING_ERROR -- An access to GPU memory space failed.";
+    case CUBLAS_STATUS_EXECUTION_FAILED:
+      return "CUBLAS_STATUS_EXECUTION_FAILED -- The GPU program failed to execute.";
+    case CUBLAS_STATUS_INTERNAL_ERROR:
+      return "CUBLAS_STATUS_INTERNAL_ERROR -- An internal cuBLAS operation failed.";
+    case CUBLAS_STATUS_NOT_SUPPORTED:
+      return "CUBLAS_STATUS_NOT_SUPPORTED -- The functionality requested is not supported.";
+    case CUBLAS_STATUS_LICENSE_ERROR:
+      return "CUBLAS_STATUS_LICENSE_ERROR -- An error was detected when checking the current licensing.";
+    default:
+      return "CUBLAS_ERROR -- <unknown>";
+  }
+}
+
+inline bool
+cublas_is_error(cublasStatus_t status)
+{
+  return status != CUBLAS_STATUS_SUCCESS;
+}
+
+
+// hgemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const Half* alpha,
+     const Half* A, int ldA,
+     const Half* B, int ldB,
+     const Half* beta,
+     Half* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasHgemm");
+
+  return cublasGemmEx(handle, transA, transB,
+                      m, n, k,
+                      reinterpret_cast<const __half*>(alpha),
+                      reinterpret_cast<const __half*>(A), CUDA_R_16F, ldA,
+                      reinterpret_cast<const __half*>(B), CUDA_R_16F, ldB,
+                      reinterpret_cast<const __half*>(beta),
+                      reinterpret_cast<      __half*>(C), CUDA_R_16F, ldC,
+                      CUDA_R_16F, CUBLAS_GEMM_DEFAULT_TENSOR_OP);
+}
+
+// mixed hf gemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const float* alpha,
+     const Half* A, int ldA,
+     const Half* B, int ldB,
+     const float* beta,
+     float* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasGemmEx mixed half-float");
+
+  return cublasGemmEx(handle, transA, transB,
+                      m, n, k,
+                      alpha,
+                      reinterpret_cast<const __half*>(A), CUDA_R_16F, ldA,
+                      reinterpret_cast<const __half*>(B), CUDA_R_16F, ldB,
+                      beta,
+                      C, CUDA_R_32F, ldC,
+                      CUDA_R_32F, CUBLAS_GEMM_DEFAULT_TENSOR_OP);
+}
+
+// igemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const int32_t* alpha,
+     const int8_t* A, int ldA,
+     const int8_t* B, int ldB,
+     const int32_t* beta,
+     int32_t* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasIgemm");
+
+  return cublasGemmEx(handle, transA, transB,
+                      m, n, k,
+                      alpha,
+                      A, CUDA_R_8I, ldA,
+                      B, CUDA_R_8I, ldB,
+                      beta,
+                      C, CUDA_R_32I, ldC,
+                      CUDA_R_32I, CUBLAS_GEMM_DEFAULT_TENSOR_OP);
+}
+
+// sgemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const float* alpha,
+     const float* A, int ldA,
+     const float* B, int ldB,
+     const float* beta,
+     float* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasSgemm");
+
+  return cublasSgemm(handle, transA, transB,
+                     m, n, k,
+                     alpha,
+                     A, ldA,
+                     B, ldB,
+                     beta,
+                     C, ldC);
+}
+
+// dgemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const double* alpha,
+     const double* A, int ldA,
+     const double* B, int ldB,
+     const double* beta,
+     double* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasDgemm");
+
+  return cublasDgemm(handle, transA, transB,
+                     m, n, k,
+                     alpha,
+                     A, ldA,
+                     B, ldB,
+                     beta,
+                     C, ldC);
+}
+
+// cgemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const ComplexFloat* alpha,
+     const ComplexFloat* A, int ldA,
+     const ComplexFloat* B, int ldB,
+     const ComplexFloat* beta,
+     ComplexFloat* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasCgemm");
+
+  return cublasCgemm(handle, transA, transB,
+                     m, n, k,
+                     reinterpret_cast<const cuFloatComplex*>(alpha),
+                     reinterpret_cast<const cuFloatComplex*>(A), ldA,
+                     reinterpret_cast<const cuFloatComplex*>(B), ldB,
+                     reinterpret_cast<const cuFloatComplex*>(beta),
+                     reinterpret_cast<cuFloatComplex*>(C), ldC);
+}
+
+// zgemm
+inline cublasStatus_t
+gemm(cublasHandle_t handle,
+     cublasOperation_t transA, cublasOperation_t transB,
+     int m, int n, int k,
+     const ComplexDouble* alpha,
+     const ComplexDouble* A, int ldA,
+     const ComplexDouble* B, int ldB,
+     const ComplexDouble* beta,
+     ComplexDouble* C, int ldC)
+{
+  BLAM_DEBUG_OUT("cublasZgemm");
+
+  return cublasZgemm(handle, transA, transB,
+                     m, n, k,
+                     reinterpret_cast<const cuDoubleComplex*>(alpha),
+                     reinterpret_cast<const cuDoubleComplex*>(A), ldA,
+                     reinterpret_cast<const cuDoubleComplex*>(B), ldB,
+                     reinterpret_cast<const cuDoubleComplex*>(beta),
+                     reinterpret_cast<cuDoubleComplex*>(C), ldC);
+}
+
+// hgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const Half* alpha,
+           const Half* A, int ldA, int loA,
+           const Half* B, int ldB, int loB,
+           const Half* beta,
+           Half* C, int ldC, int loC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasHgemmStridedBatched");
+
+  return cublasHgemmStridedBatched(handle, transA, transB,
+                                   m, n, k,
+                                   reinterpret_cast<const __half*>(alpha),
+                                   reinterpret_cast<const __half*>(A), ldA, loA,
+                                   reinterpret_cast<const __half*>(B), ldB, loB,
+                                   reinterpret_cast<const __half*>(beta),
+                                   reinterpret_cast<__half*>(C), ldC, loC,
+                                   batch_size);
+}
+
+// sgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const float* alpha,
+           const float* A, int ldA, int loA,
+           const float* B, int ldB, int loB,
+           const float* beta,
+           float* C, int ldC, int loC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasSgemmStridedBatched");
+
+  return cublasSgemmStridedBatched(handle, transA, transB,
+                                   m, n, k,
+                                   alpha,
+                                   A, ldA, loA,
+                                   B, ldB, loB,
+                                   beta,
+                                   C, ldC, loC,
+                                   batch_size);
+}
+
+// dgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const double* alpha,
+           const double* A, int ldA, int loA,
+           const double* B, int ldB, int loB,
+           const double* beta,
+           double* C, int ldC, int loC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasDgemmStridedBatched");
+
+  return cublasDgemmStridedBatched(handle, transA, transB,
+                                   m, n, k,
+                                   alpha,
+                                   A, ldA, loA,
+                                   B, ldB, loB,
+                                   beta,
+                                   C, ldC, loC,
+                                   batch_size);
+}
+
+// cgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const ComplexFloat* alpha,
+           const ComplexFloat* A, int ldA, int loA,
+           const ComplexFloat* B, int ldB, int loB,
+           const ComplexFloat* beta,
+           ComplexFloat* C, int ldC, int loC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasCgemmStridedBatched");
+
+  return cublasCgemmStridedBatched(handle, transA, transB,
+                                   m, n, k,
+                                   reinterpret_cast<const cuFloatComplex*>(alpha),
+                                   reinterpret_cast<const cuFloatComplex*>(A), ldA, loA,
+                                   reinterpret_cast<const cuFloatComplex*>(B), ldB, loB,
+                                   reinterpret_cast<const cuFloatComplex*>(beta),
+                                   reinterpret_cast<cuFloatComplex*>(C), ldC, loC,
+                                   batch_size);
+}
+
+// zgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const ComplexDouble* alpha,
+           const ComplexDouble* A, int ldA, int loA,
+           const ComplexDouble* B, int ldB, int loB,
+           const ComplexDouble* beta,
+           ComplexDouble* C, int ldC, int loC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasZgemmStridedBatched");
+
+  return cublasZgemmStridedBatched(handle, transA, transB,
+                                   m, n, k,
+                                   reinterpret_cast<const cuDoubleComplex*>(alpha),
+                                   reinterpret_cast<const cuDoubleComplex*>(A), ldA, loA,
+                                   reinterpret_cast<const cuDoubleComplex*>(B), ldB, loB,
+                                   reinterpret_cast<const cuDoubleComplex*>(beta),
+                                   reinterpret_cast<cuDoubleComplex*>(C), ldC, loC,
+                                   batch_size);
+}
+
+// hgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const Half* alpha,
+           const Half* const A[], int ldA,
+           const Half* const B[], int ldB,
+           const Half* beta,
+           Half* const C[], int ldC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasHgemmBatched");
+
+  return cublasHgemmBatched(handle, transA, transB,
+                            m, n, k,
+                            reinterpret_cast<const __half*>(alpha),
+                            reinterpret_cast<const __half**>(const_cast<const Half**>(A)), ldA,
+                            // A, ldA,   // cuBLAS 9.2
+                            reinterpret_cast<const __half**>(const_cast<const Half**>(B)), ldB,
+                            // B, ldB,   // cuBLAS 9.2
+                            reinterpret_cast<const __half*>(beta),
+                            reinterpret_cast<__half**>(const_cast<Half**>(C)), ldC,
+                            // C, ldC,   // cuBLAS 9.2
+                            batch_size);
+}
+
+// sgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const float* alpha,
+           const float* const A[], int ldA,
+           const float* const B[], int ldB,
+           const float* beta,
+           float* const C[], int ldC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasSgemmBatched");
+
+  return cublasSgemmBatched(handle, transA, transB,
+                            m, n, k,
+                            alpha,
+                            const_cast<const float**>(A), ldA,
+                            // A, ldA,   // cuBLAS 9.2
+                            const_cast<const float**>(B), ldB,
+                            // B, ldB,   // cuBLAS 9.2
+                            beta,
+                            const_cast<float**>(C), ldC,
+                            // C, ldC,   // cuBLAS 9.2
+                            batch_size);
+}
+
+// dgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const double* alpha,
+           const double* const A[], int ldA,
+           const double* const B[], int ldB,
+           const double* beta,
+           double* const C[], int ldC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasDgemmBatched");
+
+  return cublasDgemmBatched(handle, transA, transB,
+                            m, n, k,
+                            alpha,
+                            const_cast<const double**>(A), ldA,
+                            // A, ldA,   // cuBLAS 9.2
+                            const_cast<const double**>(B), ldB,
+                            // B, ldB,   // cuBLAS 9.2
+                            beta,
+                            const_cast<double**>(C), ldC,
+                            // C, ldC,   // cuBLAS 9.2
+                            batch_size);
+}
+
+// cgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const ComplexFloat* alpha,
+           const ComplexFloat* const A[], int ldA,
+           const ComplexFloat* const B[], int ldB,
+           const ComplexFloat* beta,
+           ComplexFloat* const C[], int ldC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasCgemmBatched");
+
+  return cublasCgemmBatched(handle, transA, transB,
+                            m, n, k,
+                            reinterpret_cast<const cuFloatComplex*>(alpha),
+                            const_cast<const cuFloatComplex**>(reinterpret_cast<const cuFloatComplex* const *>(A)), ldA,
+                            //reinterpret_cast<const cuFloatComplex* const *>(A), ldA,  // cuBLAS 9.2
+                            const_cast<const cuFloatComplex**>(reinterpret_cast<const cuFloatComplex* const *>(B)), ldB,
+                            //reinterpret_cast<const cuFloatComplex* const *>(B), ldB,  // cuBLAS 9.2
+                            reinterpret_cast<const cuFloatComplex*>(beta),
+                            const_cast<cuFloatComplex**>(reinterpret_cast<cuFloatComplex* const *>(C)), ldC,
+                            //reinterpret_cast<cuFloatComplex* const *>(C), ldC,        // cuBLAS 9.2
+                            batch_size);
+}
+
+// zgemm
+inline cublasStatus_t
+gemm_batch(cublasHandle_t handle,
+           cublasOperation_t transA, cublasOperation_t transB,
+           int m, int n, int k,
+           const ComplexDouble* alpha,
+           const ComplexDouble* const A[], int ldA,
+           const ComplexDouble* const B[], int ldB,
+           const ComplexDouble* beta,
+           ComplexDouble* const C[], int ldC,
+           int batch_size)
+{
+  BLAM_DEBUG_OUT("cublasZgemmBatched");
+
+  return cublasZgemmBatched(handle, transA, transB,
+                            m, n, k,
+                            reinterpret_cast<const cuDoubleComplex*>(alpha),
+                            const_cast<const cuDoubleComplex**>(reinterpret_cast<const cuDoubleComplex* const *>(A)), ldA,
+                            //reinterpret_cast<const cuDoubleComplex* const *>(A), ldA,  // cuBLAS 9.2
+                            const_cast<const cuDoubleComplex**>(reinterpret_cast<const cuDoubleComplex* const *>(B)), ldB,
+                            //reinterpret_cast<const cuDoubleComplex* const *>(B), ldB,  // cuBLAS 9.2
+                            reinterpret_cast<const cuDoubleComplex*>(beta),
+                            const_cast<cuDoubleComplex**>(reinterpret_cast<cuDoubleComplex* const *>(C)), ldC,
+                            //reinterpret_cast<cuDoubleComplex* const *>(C), ldC,        // cuBLAS 9.2
+                            batch_size);
+}
+
+} // end namespace cublas
+} // end namespace blam

sglang_repo/sgl-kernel/3rdparty/flashinfer/3rdparty/cutlass/tools/util/include/cutlass/util/debug.h

@@ -0,0 +1,143 @@
+/***************************************************************************************************
+ * Copyright (c) 2017 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **************************************************************************************************/
+
+/*! \file
+    \brief Contains code for debugging cutlass code
+*/
+
+#pragma once
+
+#include "device_dump.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/******************************************************************************
+ * Debug and logging macros
+ ******************************************************************************/
+
+/**
+ * Formats and prints the given message to stdout
+ */
+#if !defined(CUDA_LOG)
+#if !defined(__CUDA_ARCH__)
+#define CUDA_LOG(format, ...) printf(format, __VA_ARGS__)
+#else
+#define CUDA_LOG(format, ...)                              \
+  printf("[block (%d,%d,%d), thread (%d,%d,%d)]: " format, \
+         blockIdx.x,                                       \
+         blockIdx.y,                                       \
+         blockIdx.z,                                       \
+         threadIdx.x,                                      \
+         threadIdx.y,                                      \
+         threadIdx.z,                                      \
+         __VA_ARGS__);
+#endif
+#endif
+
+/**
+ * Formats and prints the given message to stdout only if DEBUG is defined
+ */
+#if !defined(CUDA_LOG_DEBUG)
+#ifdef DEBUG
+#define CUDA_LOG_DEBUG(format, ...) CUDA_LOG(format, __VA_ARGS__)
+#else
+#define CUDA_LOG_DEBUG(format, ...)
+#endif
+#endif
+
+/**
+ * \brief The corresponding error message is printed to \p stderr (or \p stdout in device code)
+ * along with the supplied source context.
+ *
+ * \return The CUDA error.
+ */
+__host__ CUTLASS_DEVICE cudaError_t cuda_perror_impl(cudaError_t error,
+                                                     const char* expression,
+                                                     const char* filename,
+                                                     int line) {
+  (void)filename;
+  (void)line;
+  if (error) {
+#if !defined(__CUDA_ARCH__)
+    fprintf(
+        stderr, "CUDA error %d [%s, %d] in expression '%s': %s\n", error, filename, line, expression, cudaGetErrorString(error));
+    fflush(stderr);
+#else
+    printf("CUDA error %d [%s, %d] in expression '%s'\n", error, filename, line, expression);
+#endif
+  }
+  return error;
+}
+
+/**
+ * \brief Perror macro
+ */
+#ifndef CUDA_PERROR
+#define CUDA_PERROR(e) cuda_perror_impl((cudaError_t)(e), #e, __FILE__, __LINE__)
+#endif
+
+/**
+ * \brief Perror macro with exit
+ */
+#ifndef CUDA_PERROR_EXIT
+#define CUDA_PERROR_EXIT(e)                                     \
+  do { if (cuda_perror_impl((cudaError_t)(e), #e, __FILE__, __LINE__)) { \
+    exit(1);                                                    \
+  } } while (0)
+#endif
+
+/**
+ * \brief Perror macro only if DEBUG is defined
+ */
+#ifndef CUDA_PERROR_DEBUG
+#ifdef DEBUG
+#define CUDA_PERROR_DEBUG(e) CUDA_PERROR(e)
+#else
+#define CUDA_PERROR_DEBUG(e) (e)
+#endif
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// A small helper class to dump a type at compile time
+// Usage:: DumpType<Class>::Class
+template <typename T>
+struct DebugType {};
+
+template <typename T>
+void DebugTypeFunc(T const& t) {
+  T::t;
+}
+
+// A small helper class to dump a compile time constant at compile time
+// Usage: DumpValue<Class::kConstant>::kConstant
+template <int Value>
+struct DebugValue {};