diff options
Diffstat (limited to 'llvm/unittests/Frontend')
-rw-r--r-- | llvm/unittests/Frontend/CMakeLists.txt | 1 | ||||
-rw-r--r-- | llvm/unittests/Frontend/HLSLBindingTest.cpp | 273 | ||||
-rw-r--r-- | llvm/unittests/Frontend/OpenMPDecompositionTest.cpp | 16 |
3 files changed, 282 insertions, 8 deletions
diff --git a/llvm/unittests/Frontend/CMakeLists.txt b/llvm/unittests/Frontend/CMakeLists.txt index 281d509..6e4ba5d 100644 --- a/llvm/unittests/Frontend/CMakeLists.txt +++ b/llvm/unittests/Frontend/CMakeLists.txt @@ -11,6 +11,7 @@ set(LLVM_LINK_COMPONENTS ) add_llvm_unittest(LLVMFrontendTests + HLSLBindingTest.cpp HLSLRootSignatureDumpTest.cpp HLSLRootSignatureRangesTest.cpp OpenACCTest.cpp diff --git a/llvm/unittests/Frontend/HLSLBindingTest.cpp b/llvm/unittests/Frontend/HLSLBindingTest.cpp new file mode 100644 index 0000000..bd6a0ff --- /dev/null +++ b/llvm/unittests/Frontend/HLSLBindingTest.cpp @@ -0,0 +1,273 @@ +//===------ HLSLBindingTest.cpp - Resource binding tests ------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "llvm/Frontend/HLSL/HLSLBinding.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/Support/DXILABI.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" + +using namespace llvm; +using namespace llvm::dxil; + +MATCHER_P(HasSpecificValue, Value, "") { + return arg.has_value() && *arg == Value; +} + +static void +checkExpectedSpaceAndFreeRanges(hlsl::BindingInfo::RegisterSpace &RegSpace, + uint32_t ExpSpace, + ArrayRef<uint32_t> ExpValues) { + EXPECT_EQ(RegSpace.Space, ExpSpace); + EXPECT_EQ(RegSpace.FreeRanges.size() * 2, ExpValues.size()); + unsigned I = 0; + for (auto &R : RegSpace.FreeRanges) { + EXPECT_EQ(R.LowerBound, ExpValues[I]); + EXPECT_EQ(R.UpperBound, ExpValues[I + 1]); + I += 2; + } +} + +TEST(HLSLBindingTest, TestTrivialCase) { + hlsl::BindingInfoBuilder Builder; + + Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/nullptr); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_FALSE(HasOverlap); + + // check that UAV has exactly one gap + hlsl::BindingInfo::BindingSpaces &UAVSpaces = + Info.getBindingSpaces(ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.Spaces.size(), 1u); + checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u}); + + // check that other kinds of register spaces are all available + for (auto RC : + {ResourceClass::SRV, ResourceClass::CBuffer, ResourceClass::Sampler}) { + hlsl::BindingInfo::BindingSpaces &Spaces = Info.getBindingSpaces(RC); + EXPECT_EQ(Spaces.RC, RC); + EXPECT_EQ(Spaces.Spaces.size(), 0u); + } +} + +TEST(HLSLBindingTest, TestManyBindings) { + hlsl::BindingInfoBuilder Builder; + + // cbuffer CB : register(b3) { int a; } + // RWBuffer<float4> A[5] : register(u10, space20); + // StructuredBuffer<int> B : register(t5); + // RWBuffer<float> C : register(u5); + // StructuredBuffer<int> D[5] : register(t0); + // RWBuffer<float> E[2] : register(u2); + // SamplerState S1 : register(s5, space2); + // SamplerState S2 : register(s4, space2); + Builder.trackBinding(ResourceClass::CBuffer, /*Space=*/0, /*LowerBound=*/3, + /*UpperBound=*/3, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/20, /*LowerBound=*/10, + /*UpperBound=*/14, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0, + /*UpperBound=*/4, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/2, + /*UpperBound=*/3, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/4, + /*UpperBound=*/4, /*Cookie=*/nullptr); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_FALSE(HasOverlap); + + hlsl::BindingInfo::BindingSpaces &SRVSpaces = + Info.getBindingSpaces(ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.Spaces.size(), 1u); + // verify that consecutive bindings are merged + // (SRVSpaces has only one free space range {6, ~0u}). + checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {6u, ~0u}); + + hlsl::BindingInfo::BindingSpaces &UAVSpaces = + Info.getBindingSpaces(ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.Spaces.size(), 2u); + checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0, + {0u, 1u, 4u, 4u, 6u, ~0u}); + checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 20, {0u, 9u, 15u, ~0u}); + + hlsl::BindingInfo::BindingSpaces &CBufferSpaces = + Info.getBindingSpaces(ResourceClass::CBuffer); + EXPECT_EQ(CBufferSpaces.RC, ResourceClass::CBuffer); + EXPECT_EQ(CBufferSpaces.Spaces.size(), 1u); + checkExpectedSpaceAndFreeRanges(CBufferSpaces.Spaces[0], 0, + {0u, 2u, 4u, ~0u}); + + hlsl::BindingInfo::BindingSpaces &SamplerSpaces = + Info.getBindingSpaces(ResourceClass::Sampler); + EXPECT_EQ(SamplerSpaces.RC, ResourceClass::Sampler); + EXPECT_EQ(SamplerSpaces.Spaces.size(), 1u); + checkExpectedSpaceAndFreeRanges(SamplerSpaces.Spaces[0], 2, + {0u, 3u, 6u, ~0u}); +} + +TEST(HLSLBindingTest, TestUnboundedAndOverlap) { + hlsl::BindingInfoBuilder Builder; + + // StructuredBuffer<float> A[] : register(t5); + // StructuredBuffer<float> B[3] : register(t0); + // StructuredBuffer<float> C[] : register(t0, space2); + // StructuredBuffer<float> D : register(t4, space2); /* overlapping */ + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/~0u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0, + /*UpperBound=*/2, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/0, + /*UpperBound=*/~0u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/4, + /*UpperBound=*/4, /*Cookie=*/nullptr); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_TRUE(HasOverlap); + + hlsl::BindingInfo::BindingSpaces &SRVSpaces = + Info.getBindingSpaces(ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.Spaces.size(), 2u); + checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {3, 4}); + checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[1], 2, {}); +} + +TEST(HLSLBindingTest, TestExactOverlap) { + hlsl::BindingInfoBuilder Builder; + + // Since the bindings overlap exactly we need sigil values to differentiate + // them. + char ID1; + char ID2; + + // StructuredBuffer<float> A : register(t5); + // StructuredBuffer<float> B : register(t5); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/&ID1); + Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5, + /*UpperBound=*/5, /*Cookie=*/&ID2); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_TRUE(HasOverlap); + + hlsl::BindingInfo::BindingSpaces &SRVSpaces = + Info.getBindingSpaces(ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV); + EXPECT_EQ(SRVSpaces.Spaces.size(), 1u); + checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u}); +} + +TEST(HLSLBindingTest, TestEndOfRange) { + hlsl::BindingInfoBuilder Builder; + + // RWBuffer<float> A : register(u4294967295); /* UINT32_MAX */ + // RWBuffer<float> B[10] : register(u4294967286, space1); + // /* range (UINT32_MAX - 9, UINT32_MAX )*/ + // RWBuffer<float> C[10] : register(u2147483647, space2); + // /* range (INT32_MAX, INT32_MAX + 9) */ + Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/~0u, + /*UpperBound=*/~0u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/~0u - 9u, + /*UpperBound=*/~0u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/2, + /*LowerBound=*/2147483647u, + /*UpperBound=*/2147483647u + 9u, /*Cookie=*/nullptr); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_FALSE(HasOverlap); + + hlsl::BindingInfo::BindingSpaces &UAVSpaces = + Info.getBindingSpaces(ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV); + EXPECT_EQ(UAVSpaces.Spaces.size(), 3u); + checkExpectedSpaceAndFreeRanges( + UAVSpaces.Spaces[0], 0, {0, std::numeric_limits<uint32_t>::max() - 1}); + checkExpectedSpaceAndFreeRanges( + UAVSpaces.Spaces[1], 1, {0, std::numeric_limits<uint32_t>::max() - 10}); + checkExpectedSpaceAndFreeRanges( + UAVSpaces.Spaces[2], 2, + {0, static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1u, + static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) + 10u, + std::numeric_limits<uint32_t>::max()}); +} + +TEST(HLSLBindingTest, TestFindAvailable) { + hlsl::BindingInfoBuilder Builder; + + // RWBuffer<float> A : register(u5); + // RWBuffer<float> B : register(u5, space1); + // RWBuffer<float> C : register(u11, space1); + // RWBuffer<float> D[] : register(u1, space2); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5u, + /*UpperBound=*/5u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/2u, + /*UpperBound=*/2u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/6u, + /*UpperBound=*/6u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/2, /*LowerBound=*/1u, + /*UpperBound=*/~0u, /*Cookie=*/nullptr); + Builder.trackBinding(ResourceClass::UAV, /*Space=*/3, /*LowerBound=*/~0u - 1, + /*UpperBound=*/~0u - 1, /*Cookie=*/nullptr); + bool HasOverlap; + hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap); + + EXPECT_FALSE(HasOverlap); + + // In space 0, we find room for a small binding at the beginning and + // a large binding after `A`'s binding. + std::optional<uint32_t> V = + Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/1); + EXPECT_THAT(V, HasSpecificValue(0u)); + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/100); + EXPECT_THAT(V, HasSpecificValue(6u)); + + // In space 1, we try to fit larger bindings in the fill the gaps. Note that + // we do this largest to smallest and observe that the gaps that are earlier + // still exist. + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/4); + EXPECT_THAT(V, HasSpecificValue(7u)); + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/3); + EXPECT_THAT(V, HasSpecificValue(3u)); + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/2); + EXPECT_THAT(V, HasSpecificValue(0u)); + // At this point, we've used all of the contiguous space up to 11u + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/1); + EXPECT_THAT(V, HasSpecificValue(11u)); + + // Space 2 is mostly full, we can only fit into the room at the beginning. + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/2); + EXPECT_FALSE(V.has_value()); + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/1); + EXPECT_THAT(V, HasSpecificValue(0u)); + + // Finding space for an unbounded array is a bit funnier. it always needs to + // go a the end of the available space. + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/3, + /*Size=*/~0u); + // Note that we end up with a size 1 array here, starting at ~0u. + EXPECT_THAT(V, HasSpecificValue(~0u)); + V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/4, + /*Size=*/~0u); + // In an empty space we find the slot at the beginning. + EXPECT_THAT(V, HasSpecificValue(0u)); +} diff --git a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp index 6189d09..95c26b1 100644 --- a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp +++ b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp @@ -431,8 +431,8 @@ TEST_F(OpenMPDecompositionTest, Firstprivate3) { std::string Dir0 = stringify(Dec.output[0]); std::string Dir1 = stringify(Dec.output[1]); std::string Dir2 = stringify(Dec.output[2]); - ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (12), (27) - ASSERT_EQ(Dir1, "teams shared(x)"); // (6), (17) + ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (12), (27) + ASSERT_EQ(Dir1, "teams shared(x)"); // (6), (17) ASSERT_EQ(Dir2, "distribute firstprivate(x) lastprivate(, (x))"); // (5), (21) } @@ -574,9 +574,9 @@ TEST_F(OpenMPDecompositionTest, Lastprivate3) { std::string Dir0 = stringify(Dec.output[0]); std::string Dir1 = stringify(Dec.output[1]); std::string Dir2 = stringify(Dec.output[2]); - ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (21), (27) - ASSERT_EQ(Dir1, "parallel shared(x)"); // (22) - ASSERT_EQ(Dir2, "do lastprivate(, (x))"); // (21) + ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (21), (27) + ASSERT_EQ(Dir1, "parallel shared(x)"); // (22) + ASSERT_EQ(Dir2, "do lastprivate(, (x))"); // (21) } // SHARED @@ -984,9 +984,9 @@ TEST_F(OpenMPDecompositionTest, Reduction7) { std::string Dir0 = stringify(Dec.output[0]); std::string Dir1 = stringify(Dec.output[1]); std::string Dir2 = stringify(Dec.output[2]); - ASSERT_EQ(Dir0, "target map(2, , , , (x))"); // (36), (10) - ASSERT_EQ(Dir1, "parallel shared(x)"); // (36), (1), (4) - ASSERT_EQ(Dir2, "do reduction(, (3), (x))"); // (36) + ASSERT_EQ(Dir0, "target map(2, , , , , (x))"); // (36), (10) + ASSERT_EQ(Dir1, "parallel shared(x)"); // (36), (1), (4) + ASSERT_EQ(Dir2, "do reduction(, (3), (x))"); // (36) } // IF |