// Copyright © Advanced Micro Devices, Inc., or its affiliates. // SPDX-License-Identifier: MIT #include "GpuConvWgradRefTestFixture.hpp" #include "ConvShapeCatalog.hpp" #include #include #include #include using namespace gpu_conv_wgrad_ref_test; using namespace gpu_conv_ref_test; // One-liner subclasses — each creates a distinct GTest-visible type so that // INSTANTIATE_TEST_SUITE_P can use clean tier-only prefixes (Smoke, Standard, Comprehensive, Full) // while the suite name itself carries dimensionality and layout information. // Default layout (NCL / NCHW / NCDHW) class TestGpuConvWrwRef1dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef2dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef3dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef1dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef2dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef3dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef1dBfp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef2dBfp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRef3dBfp16 : public ConvWgradShapeSuite { }; // Channel-last layout (NLC / NHWC / NDHWC) class TestGpuConvWrwRefNlc1dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNhwc2dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNdhwc3dFp32 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNlc1dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNhwc2dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNdhwc3dFp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNlc1dBfp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNhwc2dBfp16 : public ConvWgradShapeSuite { }; class TestGpuConvWrwRefNdhwc3dBfp16 : public ConvWgradShapeSuite { }; // Alias to avoid verbose braced-init-list issues inside EXPECT_THROW macros using Vec = std::vector; // ============================================================================ // TestGpuConvWrwRefValidation — validateInput throw paths (via wgrad) // ============================================================================ TEST(TestGpuConvWrwRefValidation, ThrowsOnInvalidDimCount) { SKIP_IF_NO_DEVICES(); Tensor x({8, 8}); Tensor dw({8, 8}); Tensor dy({8, 8}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad(x, dw, dy, Vec{1}, Vec{1}, Vec{0}, Vec{0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnWeightDimMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnOutputDimMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnStridesSizeMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW( GpuFpReferenceConvolution::wgrad(x, dw, dy, Vec{1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnDilationsSizeMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnPrePaddingSizeMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW( GpuFpReferenceConvolution::wgrad(x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnPostPaddingSizeMismatch) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnZeroStride) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{0, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnNegativeDilation) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, -1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnNegativePrePadding) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{-1, 0}, Vec{0, 0}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnNegativePostPadding) { SKIP_IF_NO_DEVICES(); Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 2, 2}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, -1}), std::invalid_argument); } TEST(TestGpuConvWrwRefValidation, ThrowsOnOutputDimValueMismatch) { SKIP_IF_NO_DEVICES(); // Input [1,1,4,4], kernel [1,1,3,3], no padding, stride 1 -> expected dy [1,1,2,2] // Provide wrong dy dims [1,1,3,3] Tensor x({1, 1, 4, 4}); Tensor dw({1, 1, 3, 3}); Tensor dy({1, 1, 3, 3}); EXPECT_THROW(GpuFpReferenceConvolution::wgrad( x, dw, dy, Vec{1, 1}, Vec{1, 1}, Vec{0, 0}, Vec{0, 0}), std::invalid_argument); } // ============================================================================ // TestGpuConvWrwRefAsymPad — asymmetric (pre != post) padding tests // ============================================================================ TEST(TestGpuConvWrwRefAsymPadFp32, MatchesCpuRef) { SKIP_IF_NO_DEVICES(); runGpuVsCpuConvWrw( {1, 1, 3, 3}, {1, 1, 3, 3}, {1, 1, 2, 2}, {1, 1}, {1, 1}, {1, 0}, {0, 1}, 1e-5f); } TEST(TestGpuConvWrwRefAsymPadFp16, MatchesCpuRef) { SKIP_IF_NO_DEVICES(); runGpuVsCpuConvWrw( {1, 1, 3, 3}, {1, 1, 3, 3}, {1, 1, 2, 2}, {1, 1}, {1, 1}, {1, 0}, {0, 1}, 5e-2f); } TEST(TestGpuConvWrwRefAsymPadBfp16, MatchesCpuRef) { SKIP_IF_NO_DEVICES(); runGpuVsCpuConvWrw( {1, 1, 3, 3}, {1, 1, 3, 3}, {1, 1, 2, 2}, {1, 1}, {1, 1}, {1, 0}, {0, 1}, 0.1f); } // ============================================================================ // TestGpuConvWrwRefAlphaBeta — alpha/beta scaling tests // ============================================================================ TEST(TestGpuConvWrwRefAlphaBeta, AlphaOnly) { SKIP_IF_NO_DEVICES(); Tensor xTensor({1, 1, 4, 4}); Tensor dyTensor({1, 1, 2, 2}); Tensor dwRef({1, 1, 3, 3}); Tensor dwScaled({1, 1, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); // Compute with alpha=1.0 GpuFpReferenceConvolution::wgrad(xTensor, dwRef, dyTensor, {1, 1}, {1, 1}, {0, 0}); // Compute with alpha=2.0 GpuFpReferenceConvolution::wgrad( xTensor, dwScaled, dyTensor, {1, 1}, {1, 1}, {0, 0}, 2.0); const auto* refData = dwRef.memory().hostData(); const auto* scaledData = dwScaled.memory().hostData(); for(size_t i = 0; i < 9; ++i) { ASSERT_NEAR(scaledData[i], 2.0f * refData[i], 1e-5f) << "Alpha scaling failed at " << i; } } TEST(TestGpuConvWrwRefAlphaBeta, BetaAccumulate) { SKIP_IF_NO_DEVICES(); Tensor xTensor({1, 1, 4, 4}); Tensor dyTensor({1, 1, 2, 2}); Tensor dwTensor({1, 1, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); dwTensor.fillWithValue(1.0f); // Pre-fill dw with 1.0, then compute with alpha=1.0, beta=1.0 // Result should be wgrad(x, dy) + 1.0 Tensor dwNoAccum({1, 1, 3, 3}); GpuFpReferenceConvolution::wgrad(xTensor, dwNoAccum, dyTensor, {1, 1}, {1, 1}, {0, 0}); GpuFpReferenceConvolution::wgrad( xTensor, dwTensor, dyTensor, {1, 1}, {1, 1}, {0, 0}, 1.0, 1.0); const auto* noAccumData = dwNoAccum.memory().hostData(); const auto* accumData = dwTensor.memory().hostData(); for(size_t i = 0; i < 9; ++i) { ASSERT_NEAR(accumData[i], noAccumData[i] + 1.0f, 1e-5f) << "Beta accumulation failed at " << i; } } TEST(TestGpuConvWrwRefAlphaBeta, BetaZeroSkipsRead) { SKIP_IF_NO_DEVICES(); Tensor xTensor({1, 1, 4, 4}); Tensor dyTensor({1, 1, 2, 2}); Tensor dwBetaZero({1, 1, 3, 3}); Tensor dwDefault({1, 1, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); // Pre-fill with garbage — should be ignored when beta=0 dwBetaZero.fillWithValue(999.0f); GpuFpReferenceConvolution::wgrad(xTensor, dwDefault, dyTensor, {1, 1}, {1, 1}, {0, 0}); GpuFpReferenceConvolution::wgrad( xTensor, dwBetaZero, dyTensor, {1, 1}, {1, 1}, {0, 0}, 1.0, 0.0); const auto* defaultData = dwDefault.memory().hostData(); const auto* betaZeroData = dwBetaZero.memory().hostData(); for(size_t i = 0; i < 9; ++i) { ASSERT_NEAR(betaZeroData[i], defaultData[i], 1e-5f) << "Beta=0 should ignore pre-filled data at " << i; } } // ============================================================================ // TestGpuConvWrwRefStridedFp32 — non-packed (strided) tensor tests // ============================================================================ TEST(TestGpuConvWrwRefStridedFp32, NonPackedInput) { SKIP_IF_NO_DEVICES(); // x: [1, 2, 4, 4] with inter-channel gap (stride[1]=32 vs packed 16) const std::vector xDims = {1, 2, 4, 4}; const std::vector xStrides = {64, 32, 4, 1}; // packed would be {32, 16, 4, 1} Tensor xTensor(xDims, xStrides); Tensor dyTensor({1, 1, 2, 2}); Tensor dwCpu({1, 2, 3, 3}); Tensor dwGpu({1, 2, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); CpuFpReferenceConvolution::wgrad( xTensor, dwCpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); GpuFpReferenceConvolution::wgrad( xTensor, dwGpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); assertAllClose(dwCpu, dwGpu, 1e-5f); } TEST(TestGpuConvWrwRefStridedFp32, NonPackedDy) { SKIP_IF_NO_DEVICES(); // dy: [1, 1, 4, 4] with inter-row gap (stride[2]=8 vs packed 4) const std::vector dyDims = {1, 1, 4, 4}; const std::vector dyStrides = {32, 32, 8, 1}; // packed would be {16, 16, 4, 1} Tensor xTensor({1, 1, 6, 6}); Tensor dyTensor(dyDims, dyStrides); Tensor dwCpu({1, 1, 3, 3}); Tensor dwGpu({1, 1, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); CpuFpReferenceConvolution::wgrad( xTensor, dwCpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); GpuFpReferenceConvolution::wgrad( xTensor, dwGpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); assertAllClose(dwCpu, dwGpu, 1e-5f); } TEST(TestGpuConvWrwRefStridedFp32, NonPackedInputAndDy) { SKIP_IF_NO_DEVICES(); // Both x and dy have non-packed strides with inter-row gaps const std::vector xDims = {1, 2, 4, 4}; const std::vector xStrides = {64, 32, 6, 1}; // packed would be {32, 16, 4, 1} const std::vector dyDims = {1, 1, 2, 2}; const std::vector dyStrides = {8, 8, 4, 1}; // packed would be {4, 4, 2, 1} Tensor xTensor(xDims, xStrides); Tensor dyTensor(dyDims, dyStrides); Tensor dwCpu({1, 2, 3, 3}); Tensor dwGpu({1, 2, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); CpuFpReferenceConvolution::wgrad( xTensor, dwCpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); GpuFpReferenceConvolution::wgrad( xTensor, dwGpu, dyTensor, {1, 1}, {1, 1}, {0, 0}); assertAllClose(dwCpu, dwGpu, 1e-5f); } TEST(TestGpuConvWrwRefStridedFp32, NonPackedWithPadding) { SKIP_IF_NO_DEVICES(); // Non-packed input with padding to exercise both features together const std::vector xDims = {1, 2, 3, 3}; const std::vector xStrides = {36, 18, 3, 1}; // packed would be {18, 9, 3, 1} Tensor xTensor(xDims, xStrides); Tensor dyTensor({1, 1, 3, 3}); Tensor dwCpu({1, 2, 3, 3}); Tensor dwGpu({1, 2, 3, 3}); const unsigned int seed = 42; xTensor.fillWithRandomValues(-1.0f, 1.0f, seed); dyTensor.fillWithRandomValues(-1.0f, 1.0f, seed + 1); CpuFpReferenceConvolution::wgrad( xTensor, dwCpu, dyTensor, {1, 1}, {1, 1}, {1, 1}); GpuFpReferenceConvolution::wgrad( xTensor, dwGpu, dyTensor, {1, 1}, {1, 1}, {1, 1}); assertAllClose(dwCpu, dwGpu, 1e-5f); } // ============================================================================ // TestGpuConvWrwRefShapes — parameterized shape coverage across types // TEST_P definitions for the fixture classes from the shared header. // ============================================================================ // Default layout (NCL / NCHW / NCDHW) TEST_P(TestGpuConvWrwRef1dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef2dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef3dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef1dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef2dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef3dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef1dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef2dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRef3dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } // Channel-last layout (NLC / NHWC / NDHWC) TEST_P(TestGpuConvWrwRefNlc1dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNhwc2dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNdhwc3dFp32, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNlc1dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNhwc2dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNdhwc3dFp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNlc1dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNhwc2dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } TEST_P(TestGpuConvWrwRefNdhwc3dBfp16, MatchesCpuRef) { this->runConvWgradShapeTest(); } // ============================================================================ // Default layout (NCHW/NCDHW/NCL) instantiations. // Smoke shapes run on every commit; Standard/Full shapes filtered via --gtest_filter. // ============================================================================ // fp32 NCHW/NCDHW INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef2dFp32, ::testing::ValuesIn(getSmall2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef3dFp32, ::testing::ValuesIn(getSmall3dConvCases()), byTag()); // fp32 NCL: 1D shapes INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef1dFp32, ::testing::ValuesIn(getSmall1dConvCases()), byTag()); // fp16 NCHW/NCDHW/NCL INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef2dFp16, ::testing::ValuesIn(getSmall2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef1dFp16, ::testing::ValuesIn(getSmall1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef3dFp16, ::testing::ValuesIn(getSmall3dConvCases()), byTag()); // bfp16 NCHW/NCDHW/NCL INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef2dBfp16, ::testing::ValuesIn(getSmall2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef1dBfp16, ::testing::ValuesIn(getSmall1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRef3dBfp16, ::testing::ValuesIn(getSmall3dConvCases()), byTag()); // ============================================================================ // Channel-last (NHWC/NDHWC/NLC) instantiations — small shapes. // ============================================================================ // fp32 NHWC/NDHWC/NLC INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNhwc2dFp32, ::testing::ValuesIn(withChannelLastLayout(getSmall2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNdhwc3dFp32, ::testing::ValuesIn(withChannelLastLayout(getSmall3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNlc1dFp32, ::testing::ValuesIn(withChannelLastLayout(getSmall1dConvCases())), byTag()); // fp16 NHWC/NDHWC/NLC INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNhwc2dFp16, ::testing::ValuesIn(withChannelLastLayout(getSmall2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNdhwc3dFp16, ::testing::ValuesIn(withChannelLastLayout(getSmall3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNlc1dFp16, ::testing::ValuesIn(withChannelLastLayout(getSmall1dConvCases())), byTag()); // bfp16 NHWC/NDHWC/NLC INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNhwc2dBfp16, ::testing::ValuesIn(withChannelLastLayout(getSmall2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNdhwc3dBfp16, ::testing::ValuesIn(withChannelLastLayout(getSmall3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Smoke, TestGpuConvWrwRefNlc1dBfp16, ::testing::ValuesIn(withChannelLastLayout(getSmall1dConvCases())), byTag()); // ============================================================================ // Default layout (NCL/NCHW/NCDHW) — standard/comprehensive/full shapes. // Filter with --gtest_filter="-Standard*:Comprehensive*:Full*" for quick runs. // ============================================================================ // fp32 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef1dFp32, ::testing::ValuesIn(getMedium1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef2dFp32, ::testing::ValuesIn(getMedium2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef3dFp32, ::testing::ValuesIn(getMedium3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef1dFp32, ::testing::ValuesIn(getLargeEdge1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef2dFp32, ::testing::ValuesIn(getLargeEdge2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef3dFp32, ::testing::ValuesIn(getLargeEdge3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef1dFp32, ::testing::ValuesIn(getLargeStress1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef2dFp32, ::testing::ValuesIn(getLargeStress2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef3dFp32, ::testing::ValuesIn(getLargeStress3dConvCases()), byTag()); // fp16 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef1dFp16, ::testing::ValuesIn(getMedium1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef2dFp16, ::testing::ValuesIn(getMedium2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef3dFp16, ::testing::ValuesIn(getMedium3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef1dFp16, ::testing::ValuesIn(getLargeEdge1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef2dFp16, ::testing::ValuesIn(getLargeEdge2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef3dFp16, ::testing::ValuesIn(getLargeEdge3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef1dFp16, ::testing::ValuesIn(getLargeStress1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef2dFp16, ::testing::ValuesIn(getLargeStress2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef3dFp16, ::testing::ValuesIn(getLargeStress3dConvCases()), byTag()); // bfp16 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef1dBfp16, ::testing::ValuesIn(getMedium1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef2dBfp16, ::testing::ValuesIn(getMedium2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRef3dBfp16, ::testing::ValuesIn(getMedium3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef1dBfp16, ::testing::ValuesIn(getLargeEdge1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef2dBfp16, ::testing::ValuesIn(getLargeEdge2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRef3dBfp16, ::testing::ValuesIn(getLargeEdge3dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef1dBfp16, ::testing::ValuesIn(getLargeStress1dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef2dBfp16, ::testing::ValuesIn(getLargeStress2dConvCases()), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRef3dBfp16, ::testing::ValuesIn(getLargeStress3dConvCases()), byTag()); // ============================================================================ // Channel-last (NLC/NHWC/NDHWC) — standard/comprehensive/full shapes. // ============================================================================ // fp32 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNlc1dFp32, ::testing::ValuesIn(withChannelLastLayout(getMedium1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNhwc2dFp32, ::testing::ValuesIn(withChannelLastLayout(getMedium2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNdhwc3dFp32, ::testing::ValuesIn(withChannelLastLayout(getMedium3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNlc1dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNhwc2dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNdhwc3dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNlc1dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeStress1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNhwc2dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeStress2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNdhwc3dFp32, ::testing::ValuesIn(withChannelLastLayout(getLargeStress3dConvCases())), byTag()); // fp16 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNlc1dFp16, ::testing::ValuesIn(withChannelLastLayout(getMedium1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNhwc2dFp16, ::testing::ValuesIn(withChannelLastLayout(getMedium2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNdhwc3dFp16, ::testing::ValuesIn(withChannelLastLayout(getMedium3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNlc1dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNhwc2dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNdhwc3dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNlc1dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNhwc2dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNdhwc3dFp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress3dConvCases())), byTag()); // bfp16 INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNlc1dBfp16, ::testing::ValuesIn(withChannelLastLayout(getMedium1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNhwc2dBfp16, ::testing::ValuesIn(withChannelLastLayout(getMedium2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Standard, TestGpuConvWrwRefNdhwc3dBfp16, ::testing::ValuesIn(withChannelLastLayout(getMedium3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNlc1dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNhwc2dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Comprehensive, TestGpuConvWrwRefNdhwc3dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeEdge3dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNlc1dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress1dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNhwc2dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress2dConvCases())), byTag()); INSTANTIATE_TEST_SUITE_P(Full, TestGpuConvWrwRefNdhwc3dBfp16, ::testing::ValuesIn(withChannelLastLayout(getLargeStress3dConvCases())), byTag());