294 lines · cpp
1//===------ HLSLBindingTest.cpp - Resource binding tests ------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/Frontend/HLSL/HLSLBinding.h"10#include "llvm/ADT/ArrayRef.h"11#include "llvm/Support/DXILABI.h"12#include "gmock/gmock.h"13#include "gtest/gtest.h"14 15using namespace llvm;16using namespace llvm::dxil;17 18MATCHER_P(HasSpecificValue, Value, "") {19 return arg.has_value() && *arg == Value;20}21 22static void23checkExpectedSpaceAndFreeRanges(hlsl::BindingInfo::RegisterSpace &RegSpace,24 uint32_t ExpSpace,25 ArrayRef<uint32_t> ExpValues) {26 EXPECT_EQ(RegSpace.Space, ExpSpace);27 EXPECT_EQ(RegSpace.FreeRanges.size() * 2, ExpValues.size());28 unsigned I = 0;29 for (auto &R : RegSpace.FreeRanges) {30 EXPECT_EQ(R.LowerBound, ExpValues[I]);31 EXPECT_EQ(R.UpperBound, ExpValues[I + 1]);32 I += 2;33 }34}35 36TEST(HLSLBindingTest, TestTrivialCase) {37 hlsl::BindingInfoBuilder Builder;38 39 Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5,40 /*UpperBound=*/5, /*Cookie=*/nullptr);41 bool HasOverlap;42 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);43 44 EXPECT_FALSE(HasOverlap);45 46 // check that UAV has exactly one gap47 hlsl::BindingInfo::BindingSpaces &UAVSpaces =48 Info.getBindingSpaces(ResourceClass::UAV);49 EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);50 EXPECT_EQ(UAVSpaces.Spaces.size(), 1u);51 checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u});52 53 // check that other kinds of register spaces are all available54 for (auto RC :55 {ResourceClass::SRV, ResourceClass::CBuffer, ResourceClass::Sampler}) {56 hlsl::BindingInfo::BindingSpaces &Spaces = Info.getBindingSpaces(RC);57 EXPECT_EQ(Spaces.RC, RC);58 EXPECT_EQ(Spaces.Spaces.size(), 0u);59 }60}61 62TEST(HLSLBindingTest, TestManyBindings) {63 hlsl::BindingInfoBuilder Builder;64 65 // cbuffer CB : register(b3) { int a; }66 // RWBuffer<float4> A[5] : register(u10, space20);67 // StructuredBuffer<int> B : register(t5);68 // RWBuffer<float> C : register(u5);69 // StructuredBuffer<int> D[5] : register(t0);70 // RWBuffer<float> E[2] : register(u2);71 // SamplerState S1 : register(s5, space2);72 // SamplerState S2 : register(s4, space2);73 Builder.trackBinding(ResourceClass::CBuffer, /*Space=*/0, /*LowerBound=*/3,74 /*UpperBound=*/3, /*Cookie=*/nullptr);75 Builder.trackBinding(ResourceClass::UAV, /*Space=*/20, /*LowerBound=*/10,76 /*UpperBound=*/14, /*Cookie=*/nullptr);77 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,78 /*UpperBound=*/5, /*Cookie=*/nullptr);79 Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5,80 /*UpperBound=*/5, /*Cookie=*/nullptr);81 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0,82 /*UpperBound=*/4, /*Cookie=*/nullptr);83 Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/2,84 /*UpperBound=*/3, /*Cookie=*/nullptr);85 Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/5,86 /*UpperBound=*/5, /*Cookie=*/nullptr);87 Builder.trackBinding(ResourceClass::Sampler, /*Space=*/2, /*LowerBound=*/4,88 /*UpperBound=*/4, /*Cookie=*/nullptr);89 bool HasOverlap;90 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);91 92 EXPECT_FALSE(HasOverlap);93 94 hlsl::BindingInfo::BindingSpaces &SRVSpaces =95 Info.getBindingSpaces(ResourceClass::SRV);96 EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);97 EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);98 // verify that consecutive bindings are merged99 // (SRVSpaces has only one free space range {6, ~0u}).100 checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {6u, ~0u});101 102 hlsl::BindingInfo::BindingSpaces &UAVSpaces =103 Info.getBindingSpaces(ResourceClass::UAV);104 EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);105 EXPECT_EQ(UAVSpaces.Spaces.size(), 2u);106 checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0,107 {0u, 1u, 4u, 4u, 6u, ~0u});108 checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 20, {0u, 9u, 15u, ~0u});109 110 hlsl::BindingInfo::BindingSpaces &CBufferSpaces =111 Info.getBindingSpaces(ResourceClass::CBuffer);112 EXPECT_EQ(CBufferSpaces.RC, ResourceClass::CBuffer);113 EXPECT_EQ(CBufferSpaces.Spaces.size(), 1u);114 checkExpectedSpaceAndFreeRanges(CBufferSpaces.Spaces[0], 0,115 {0u, 2u, 4u, ~0u});116 117 hlsl::BindingInfo::BindingSpaces &SamplerSpaces =118 Info.getBindingSpaces(ResourceClass::Sampler);119 EXPECT_EQ(SamplerSpaces.RC, ResourceClass::Sampler);120 EXPECT_EQ(SamplerSpaces.Spaces.size(), 1u);121 checkExpectedSpaceAndFreeRanges(SamplerSpaces.Spaces[0], 2,122 {0u, 3u, 6u, ~0u});123}124 125TEST(HLSLBindingTest, TestUnboundedAndOverlap) {126 hlsl::BindingInfoBuilder Builder;127 128 // StructuredBuffer<float> A[] : register(t5);129 // StructuredBuffer<float> B[3] : register(t0);130 // StructuredBuffer<float> C[] : register(t0, space2);131 // StructuredBuffer<float> D : register(t4, space2); /* overlapping */132 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,133 /*UpperBound=*/~0u, /*Cookie=*/nullptr);134 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/0,135 /*UpperBound=*/2, /*Cookie=*/nullptr);136 Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/0,137 /*UpperBound=*/~0u, /*Cookie=*/nullptr);138 Builder.trackBinding(ResourceClass::SRV, /*Space=*/2, /*LowerBound=*/4,139 /*UpperBound=*/4, /*Cookie=*/nullptr);140 bool HasOverlap;141 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);142 143 EXPECT_TRUE(HasOverlap);144 145 hlsl::BindingInfo::BindingSpaces &SRVSpaces =146 Info.getBindingSpaces(ResourceClass::SRV);147 EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);148 EXPECT_EQ(SRVSpaces.Spaces.size(), 2u);149 checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {3, 4});150 checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[1], 2, {});151}152 153TEST(HLSLBindingTest, TestExactOverlap) {154 hlsl::BindingInfoBuilder Builder;155 156 // Since the bindings overlap exactly we need sigil values to differentiate157 // them.158 // Note: We initialize these to 0 to suppress a -Wuninitialized-const-pointer,159 // but we really are just using the stack addresses here.160 char ID1 = 0;161 char ID2 = 0;162 163 // StructuredBuffer<float> A : register(t5);164 // StructuredBuffer<float> B : register(t5);165 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,166 /*UpperBound=*/5, /*Cookie=*/&ID1);167 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,168 /*UpperBound=*/5, /*Cookie=*/&ID2);169 bool HasOverlap;170 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);171 172 EXPECT_TRUE(HasOverlap);173 174 hlsl::BindingInfo::BindingSpaces &SRVSpaces =175 Info.getBindingSpaces(ResourceClass::SRV);176 EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);177 EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);178 checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u});179}180 181TEST(HLSLBindingTest, TestEndOfRange) {182 hlsl::BindingInfoBuilder Builder;183 184 // RWBuffer<float> A : register(u4294967295); /* UINT32_MAX */185 // RWBuffer<float> B[10] : register(u4294967286, space1);186 // /* range (UINT32_MAX - 9, UINT32_MAX )*/187 // RWBuffer<float> C[10] : register(u2147483647, space2);188 // /* range (INT32_MAX, INT32_MAX + 9) */189 Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/~0u,190 /*UpperBound=*/~0u, /*Cookie=*/nullptr);191 Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/~0u - 9u,192 /*UpperBound=*/~0u, /*Cookie=*/nullptr);193 Builder.trackBinding(ResourceClass::UAV, /*Space=*/2,194 /*LowerBound=*/2147483647u,195 /*UpperBound=*/2147483647u + 9u, /*Cookie=*/nullptr);196 bool HasOverlap;197 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);198 199 EXPECT_FALSE(HasOverlap);200 201 hlsl::BindingInfo::BindingSpaces &UAVSpaces =202 Info.getBindingSpaces(ResourceClass::UAV);203 EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);204 EXPECT_EQ(UAVSpaces.Spaces.size(), 3u);205 checkExpectedSpaceAndFreeRanges(206 UAVSpaces.Spaces[0], 0, {0, std::numeric_limits<uint32_t>::max() - 1});207 checkExpectedSpaceAndFreeRanges(208 UAVSpaces.Spaces[1], 1, {0, std::numeric_limits<uint32_t>::max() - 10});209 checkExpectedSpaceAndFreeRanges(210 UAVSpaces.Spaces[2], 2,211 {0, static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1u,212 static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) + 10u,213 std::numeric_limits<uint32_t>::max()});214}215 216TEST(HLSLBindingTest, TestFindAvailable) {217 hlsl::BindingInfoBuilder Builder;218 219 // RWBuffer<float> A : register(u5);220 // RWBuffer<float> B : register(u5, space1);221 // RWBuffer<float> C : register(u11, space1);222 // RWBuffer<float> D[] : register(u1, space2);223 Builder.trackBinding(ResourceClass::UAV, /*Space=*/0, /*LowerBound=*/5u,224 /*UpperBound=*/5u, /*Cookie=*/nullptr);225 Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/2u,226 /*UpperBound=*/2u, /*Cookie=*/nullptr);227 Builder.trackBinding(ResourceClass::UAV, /*Space=*/1, /*LowerBound=*/6u,228 /*UpperBound=*/6u, /*Cookie=*/nullptr);229 Builder.trackBinding(ResourceClass::UAV, /*Space=*/2, /*LowerBound=*/1u,230 /*UpperBound=*/~0u, /*Cookie=*/nullptr);231 Builder.trackBinding(ResourceClass::UAV, /*Space=*/3, /*LowerBound=*/~0u - 1,232 /*UpperBound=*/~0u - 1, /*Cookie=*/nullptr);233 bool HasOverlap;234 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);235 236 EXPECT_FALSE(HasOverlap);237 238 // In space 0, we find room for a small binding at the beginning and239 // a large binding after `A`'s binding.240 std::optional<uint32_t> V =241 Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/1);242 EXPECT_THAT(V, HasSpecificValue(0u));243 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/0, /*Size=*/100);244 EXPECT_THAT(V, HasSpecificValue(6u));245 246 // In space 1, we try to fit larger bindings in the fill the gaps. Note that247 // we do this largest to smallest and observe that the gaps that are earlier248 // still exist.249 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/4);250 EXPECT_THAT(V, HasSpecificValue(7u));251 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/3);252 EXPECT_THAT(V, HasSpecificValue(3u));253 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/2);254 EXPECT_THAT(V, HasSpecificValue(0u));255 // At this point, we've used all of the contiguous space up to 11u256 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/1, /*Size=*/1);257 EXPECT_THAT(V, HasSpecificValue(11u));258 259 // Space 2 is mostly full, we can only fit into the room at the beginning.260 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/2);261 EXPECT_FALSE(V.has_value());262 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/2, /*Size=*/1);263 EXPECT_THAT(V, HasSpecificValue(0u));264 265 // Finding space for an unbounded array is a bit funnier. it always needs to266 // go a the end of the available space.267 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/3,268 /*Size=*/~0u);269 // Note that we end up with a size 1 array here, starting at ~0u.270 EXPECT_THAT(V, HasSpecificValue(~0u));271 V = Info.findAvailableBinding(ResourceClass::UAV, /*Space=*/4,272 /*Size=*/~0u);273 // In an empty space we find the slot at the beginning.274 EXPECT_THAT(V, HasSpecificValue(0u));275}276 277// Test that add duplicate bindings are correctly de-duplicated278TEST(HLSLBindingTest, TestNoOverlapWithDuplicates) {279 hlsl::BindingInfoBuilder Builder;280 281 // We add the same binding three times, and just use `nullptr` for the cookie282 // so that they should all be uniqued away.283 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,284 /*UpperBound=*/5, /*Cookie=*/nullptr);285 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,286 /*UpperBound=*/5, /*Cookie=*/nullptr);287 Builder.trackBinding(ResourceClass::SRV, /*Space=*/0, /*LowerBound=*/5,288 /*UpperBound=*/5, /*Cookie=*/nullptr);289 bool HasOverlap;290 hlsl::BindingInfo Info = Builder.calculateBindingInfo(HasOverlap);291 292 EXPECT_FALSE(HasOverlap);293}294