Skip to content

Commit ab7707f

Browse files
joaosaffranjoaosaffran
committed
ongoing tests
1 parent c657ded commit ab7707f

File tree

4 files changed

+108
-86
lines changed

4 files changed

+108
-86
lines changed

‎tools/clang/unittests/HLSLExec/LongVectorOps.def‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ INPUT_SET(Positive)
1919
INPUT_SET(Bitwise)
2020
INPUT_SET(SelectCond)
2121
INPUT_SET(FloatSpecial)
22+
INPUT_SET(DynamicIndexes)
2223

2324
#undef INPUT_SET
2425

@@ -62,12 +63,11 @@ OP(Bitwise, FirstBitLow, 1, "firstbitlow", "", "", "LongVectorOp", Bitwise, Defa
6263
OP_DEFAULT_DEFINES(Unary, Initialize, 1, "TestInitialize", "",
6364
" -DFUNC_INITIALIZE=1")
6465

65-
OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_SingleAccess, 1, "TestArrayOperatorSingleAccess", "",
66-
" -DFUNC_ARRAY_OPERATOR_SINGLE_ACCESS=1")
67-
OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Loop, 2, "TestArrayOperatorLoop", "",
68-
" -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=loop")
69-
OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_Unroll, 2, "TestArrayOperatorUnroll", "",
70-
" -DFUNC_ARRAY_OPERATOR=1 -DLOOP_ATTRB=unroll")
66+
OP_DEFAULT_DEFINES(ArrayOperator, ArrayOperator_StaticAccess, 1, "TestArrayOperatorStaticAccess", "",
67+
" -DTEST_ARRAY_OPERATOR_STATIC_ACCESS=1")
68+
69+
OP(ArrayOperator, ArrayOperator_DynamicAccess, 2, "TestArrayOperatorDynamicAccess", "", " -DTEST_ARRAY_OPERATOR_DYNAMIC_ACCESS=1 -DINDEX=1.0", "LongVectorOp", \
70+
Default1, DynamicIndexes, Default3)
7171

7272
#define OP_CAST_DEFAULT(GROUP, SYMBOL) \
7373
OP_DEFAULT_DEFINES(GROUP, SYMBOL, 1, "TestCast", "", "-DFUNC_TEST_CAST=1")

‎tools/clang/unittests/HLSLExec/LongVectorTestData.h‎

Lines changed: 35 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
#include <Verify.h>
55

6+
#include <cstdint>
67
#include <limits>
78
#include <map>
89
#include <ostream>
@@ -24,6 +25,7 @@ struct HLSLBool_t {
2425
HLSLBool_t() : Val(0) {}
2526
HLSLBool_t(int32_t Val) : Val(Val) {}
2627
HLSLBool_t(bool Val) : Val(Val) {}
28+
explicit HLSLBool_t(float Val) : Val(Val) {}
2729

2830
bool operator==(const HLSLBool_t &Other) const {
2931
return static_cast<bool>(Val) == static_cast<bool>(Other.Val);
@@ -238,12 +240,15 @@ enum class InputSet {
238240
#include "LongVectorOps.def"
239241
};
240242

241-
template <typename T> const std::vector<T> &getInputSet(InputSet InputSet) {
243+
template <typename T>
244+
const std::vector<T> &getInputSet(InputSet InputSet, size_t SizeToTest) {
242245
static_assert(false, "No InputSet for this type");
243246
}
244247

245248
#define BEGIN_INPUT_SETS(TYPE) \
246-
template <> const std::vector<TYPE> &getInputSet<TYPE>(InputSet InputSet) { \
249+
template <> \
250+
const std::vector<TYPE> &getInputSet<TYPE>(InputSet InputSet, \
251+
size_t SizeToTest) { \
247252
using T = TYPE; \
248253
switch (InputSet) {
249254

@@ -285,6 +290,9 @@ INPUT_SET(InputSet::Bitwise, std::numeric_limits<int16_t>::min(), -1, 0, 1, 3,
285290
6, 9, 0x5555, static_cast<int16_t>(0xAAAA),
286291
std::numeric_limits<int16_t>::max());
287292
INPUT_SET(InputSet::SelectCond, 0, 1);
293+
INPUT_SET(InputSet::DynamicIndexes, 0, (int16_t)(SizeToTest - 1), 1,
294+
(int16_t)(SizeToTest - 2), (int16_t)(SizeToTest / 2),
295+
(int16_t)(SizeToTest / 2 + 1));
288296
END_INPUT_SETS()
289297

290298
BEGIN_INPUT_SETS(int32_t)
@@ -298,6 +306,10 @@ INPUT_SET(InputSet::Bitwise, std::numeric_limits<int32_t>::min(), -1, 0, 1, 3,
298306
6, 9, 0x55555555, static_cast<int32_t>(0xAAAAAAAA),
299307
std::numeric_limits<int32_t>::max());
300308
INPUT_SET(InputSet::SelectCond, 0, 1);
309+
// {0, VectorSize - 1, 1, VectorSize - 2, VectorSize / 2, VectorSize / 2 + 1};
310+
INPUT_SET(InputSet::DynamicIndexes, 0, (int32_t)(SizeToTest - 1), 1,
311+
(int32_t)(SizeToTest - 2), (int32_t)(SizeToTest / 2),
312+
(int32_t)(SizeToTest / 2 + 1));
301313
END_INPUT_SETS()
302314

303315
BEGIN_INPUT_SETS(int64_t)
@@ -311,6 +323,9 @@ INPUT_SET(InputSet::Bitwise, std::numeric_limits<int64_t>::min(), -1, 0, 1, 3,
311323
6, 9, 0x5555555555555555LL, 0xAAAAAAAAAAAAAAAALL,
312324
std::numeric_limits<int64_t>::max());
313325
INPUT_SET(InputSet::SelectCond, 0, 1);
326+
INPUT_SET(InputSet::DynamicIndexes, 0, (int64_t)(SizeToTest - 1), 1,
327+
(int64_t)(SizeToTest - 2), (int64_t)(SizeToTest / 2),
328+
(int64_t)(SizeToTest / 2 + 1));
314329
END_INPUT_SETS()
315330

316331
BEGIN_INPUT_SETS(uint16_t)
@@ -321,6 +336,9 @@ INPUT_SET(InputSet::BitShiftRhs, 1, 6, 3, 0, 9, 3, 12, 13, 14, 15);
321336
INPUT_SET(InputSet::Bitwise, 0, 1, 3, 6, 9, 0x5555, 0xAAAA, 0x8000, 127,
322337
std::numeric_limits<uint16_t>::max());
323338
INPUT_SET(InputSet::SelectCond, 0, 1);
339+
INPUT_SET(InputSet::DynamicIndexes, 0, (uint16_t)(SizeToTest - 1), 1,
340+
(uint16_t)(SizeToTest - 2), (uint16_t)(SizeToTest / 2),
341+
(uint16_t)(SizeToTest / 2 + 1));
324342
END_INPUT_SETS()
325343

326344
BEGIN_INPUT_SETS(uint32_t)
@@ -331,6 +349,9 @@ INPUT_SET(InputSet::BitShiftRhs, 1, 6, 3, 0, 9, 3, 30, 31, 32);
331349
INPUT_SET(InputSet::Bitwise, 0, 1, 3, 6, 9, 0x55555555, 0xAAAAAAAA, 0x80000000,
332350
127, std::numeric_limits<uint32_t>::max());
333351
INPUT_SET(InputSet::SelectCond, 0, 1);
352+
INPUT_SET(InputSet::DynamicIndexes, 0, (uint32_t)(SizeToTest - 1), 1,
353+
(uint32_t)(SizeToTest - 2), (uint32_t)(SizeToTest / 2),
354+
(uint32_t)(SizeToTest / 2 + 1));
334355
END_INPUT_SETS()
335356

336357
BEGIN_INPUT_SETS(uint64_t)
@@ -342,6 +363,9 @@ INPUT_SET(InputSet::Bitwise, 0, 1, 3, 6, 9, 0x5555555555555555,
342363
0xAAAAAAAAAAAAAAAA, 0x8000000000000000, 127,
343364
std::numeric_limits<uint64_t>::max());
344365
INPUT_SET(InputSet::SelectCond, 0, 1);
366+
INPUT_SET(InputSet::DynamicIndexes, 0, (uint64_t)(SizeToTest - 1), 1,
367+
(uint64_t)(SizeToTest - 2), (uint64_t)(SizeToTest / 2),
368+
(uint64_t)(SizeToTest / 2 + 1));
345369
END_INPUT_SETS()
346370

347371
BEGIN_INPUT_SETS(HLSLHalf_t)
@@ -372,6 +396,9 @@ INPUT_SET(InputSet::FloatSpecial, std::numeric_limits<float>::infinity(),
372396
-std::numeric_limits<float>::max(),
373397
std::numeric_limits<float>::denorm_min(),
374398
std::numeric_limits<float>::denorm_min() * 10.0, 1.0 / 3.0);
399+
INPUT_SET(InputSet::DynamicIndexes, 0.0, (float)(SizeToTest - 1), 1.0,
400+
(float)(SizeToTest - 2), (float)(SizeToTest / 2),
401+
(float)(SizeToTest / 2 + 1));
375402
END_INPUT_SETS()
376403

377404
BEGIN_INPUT_SETS(float)
@@ -399,6 +426,9 @@ INPUT_SET(InputSet::FloatSpecial, std::numeric_limits<float>::infinity(),
399426
-std::numeric_limits<float>::max(),
400427
std::numeric_limits<float>::denorm_min(),
401428
std::numeric_limits<float>::denorm_min() * 10.0f, 1.0f / 3.0f);
429+
INPUT_SET(InputSet::DynamicIndexes, 0.0, (float)(SizeToTest - 1), 1.0,
430+
(float)(SizeToTest - 2), (float)(SizeToTest / 2),
431+
(float)(SizeToTest / 2 + 1));
402432
END_INPUT_SETS()
403433

404434
BEGIN_INPUT_SETS(double)
@@ -417,6 +447,9 @@ INPUT_SET(InputSet::SplitDouble, 0.0, -1.0, 1.0, -1.0, 12345678.87654321, -1.0,
417447
INPUT_SET(InputSet::Positive, 1.0, 1.0, 65535.0, 0.01, 5531.0, 0.01, 1.0, 0.01,
418448
331.2330, 3250.01);
419449
INPUT_SET(InputSet::SelectCond, 0.0, 1.0);
450+
INPUT_SET(InputSet::DynamicIndexes, 0.0, (double)(SizeToTest - 1), 1.0,
451+
(double)(SizeToTest - 2), (double)(SizeToTest / 2),
452+
(double)(SizeToTest / 2 + 1));
420453
END_INPUT_SETS()
421454

422455
#undef BEGIN_INPUT_SETS

‎tools/clang/unittests/HLSLExec/LongVectors.cpp‎

Lines changed: 51 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -535,7 +535,7 @@ void configureLoadAndStoreShaderOp(const Operation &Operation,
535535

536536
template <typename T>
537537
std::vector<T> buildTestInput(InputSet InputSet, size_t SizeToTest) {
538-
const std::vector<T> &RawValueSet = getInputSet<T>(InputSet);
538+
const std::vector<T> &RawValueSet = getInputSet<T>(InputSet, SizeToTest);
539539

540540
std::vector<T> ValueSet;
541541
ValueSet.reserve(SizeToTest);
@@ -769,56 +769,51 @@ BITWISE_OP(OpType::FirstBitLow, (FirstBitLow(A)));
769769
DEFAULT_OP_1(OpType::Initialize, (A));
770770

771771
template <typename T>
772-
struct Op<OpType::ArrayOperator_SingleAccess, T, 1> : DefaultValidation<T> {};
772+
struct Op<OpType::ArrayOperator_StaticAccess, T, 1> : DefaultValidation<T> {};
773773

774774
template <typename T>
775-
struct ExpectedBuilder<OpType::ArrayOperator_SingleAccess, T> {
775+
struct ExpectedBuilder<OpType::ArrayOperator_StaticAccess, T> {
776776
static std::vector<T>
777-
buildExpected(Op<OpType::ArrayOperator_SingleAccess, T, 1>,
777+
buildExpected(Op<OpType::ArrayOperator_StaticAccess, T, 1>,
778778
const InputSets<T> &Inputs) {
779779
DXASSERT_NOMSG(Inputs.size() == 1);
780780
const size_t VectorSize = Inputs[0].size();
781-
std::vector<T> Expected = Inputs[0];
782-
Expected[0] = Inputs[0][VectorSize - 1];
783-
Expected[VectorSize - 1] = Expected[0];
781+
std::vector<T> Expected;
782+
Expected.resize(VectorSize);
783+
784+
size_t IndexList[6] = {0,
785+
VectorSize - 1,
786+
1,
787+
VectorSize - 2,
788+
VectorSize / 2,
789+
VectorSize / 2 + 1};
790+
for (size_t i = 0; i < 6; ++i)
791+
Expected[IndexList[i]] = Inputs[0][IndexList[i]] + static_cast<T>(1.0);
792+
784793
return Expected;
785794
}
786795
};
787796

788797
template <typename T>
789-
static std::vector<T>
790-
buildExpectedArrayAccessOutput(const InputSets<T> &Inputs) {
791-
DXASSERT_NOMSG(Inputs.size() == 2);
792-
const size_t VectorSize = Inputs[0].size();
793-
std::vector<T> Expected;
794-
Expected.resize(VectorSize * 2);
795-
796-
for (size_t i = 0; i < VectorSize; i++)
797-
Expected[i] = Inputs[0][i] + Inputs[1][i];
798-
799-
for (size_t i = 0; i < VectorSize; i++)
800-
Expected[i + VectorSize] = Expected[i];
801-
802-
return Expected;
803-
}
798+
struct Op<OpType::ArrayOperator_DynamicAccess, T, 2> : DefaultValidation<T> {};
804799

805800
template <typename T>
806-
struct Op<OpType::ArrayOperator_Loop, T, 2> : DefaultValidation<T> {};
807-
808-
template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Loop, T> {
809-
static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Loop, T, 2>,
810-
const InputSets<T> &Inputs) {
811-
return buildExpectedArrayAccessOutput(Inputs);
812-
}
813-
};
801+
struct ExpectedBuilder<OpType::ArrayOperator_DynamicAccess, T> {
802+
static std::vector<T>
803+
buildExpected(Op<OpType::ArrayOperator_DynamicAccess, T, 2>,
804+
const InputSets<T> &Inputs) {
805+
DXASSERT_NOMSG(Inputs.size() == 2);
806+
const size_t IndexVectorSize = Inputs[1].size();
814807

815-
template <typename T>
816-
struct Op<OpType::ArrayOperator_Unroll, T, 2> : DefaultValidation<T> {};
808+
std::vector<T> Expected;
809+
Expected.resize(IndexVectorSize);
810+
size_t End = std::min(IndexVectorSize, static_cast<size_t>(6));
811+
for (size_t i = 0; i < End; ++i) {
812+
const size_t Index = static_cast<size_t>(Inputs[1][i]);
813+
Expected[Index] = Inputs[0][Index] + static_cast<T>(1.0);
814+
}
817815

818-
template <typename T> struct ExpectedBuilder<OpType::ArrayOperator_Unroll, T> {
819-
static std::vector<T> buildExpected(Op<OpType::ArrayOperator_Unroll, T, 2>,
820-
const InputSets<T> &Inputs) {
821-
return buildExpectedArrayAccessOutput(Inputs);
816+
return Expected;
822817
}
823818
};
824819

@@ -1640,45 +1635,35 @@ class DxilConf_SM69_Vectorized {
16401635
// Unary
16411636

16421637
HLK_TEST(Initialize, HLSLBool_t);
1643-
HLK_TEST(ArrayOperator_SingleAccess, HLSLBool_t);
1644-
HLK_TEST(ArrayOperator_Unroll, HLSLBool_t);
1645-
HLK_TEST(ArrayOperator_Loop, HLSLBool_t);
1638+
// HLK_TEST(ArrayOperator_StaticAccess, HLSLBool_t);
1639+
// HLK_TEST(ArrayOperator_DynamicAccess, HLSLBool_t);
16461640
HLK_TEST(Initialize, int16_t);
1647-
HLK_TEST(ArrayOperator_SingleAccess, int16_t);
1648-
HLK_TEST(ArrayOperator_Unroll, int16_t);
1649-
HLK_TEST(ArrayOperator_Loop, int16_t);
1641+
HLK_TEST(ArrayOperator_StaticAccess, int16_t);
1642+
HLK_TEST(ArrayOperator_DynamicAccess, int16_t);
16501643
HLK_TEST(Initialize, int32_t);
1651-
HLK_TEST(ArrayOperator_SingleAccess, int32_t);
1652-
HLK_TEST(ArrayOperator_Unroll, int32_t);
1653-
HLK_TEST(ArrayOperator_Loop, int32_t);
1644+
HLK_TEST(ArrayOperator_StaticAccess, int32_t);
1645+
HLK_TEST(ArrayOperator_DynamicAccess, int32_t);
16541646
HLK_TEST(Initialize, int64_t);
1655-
HLK_TEST(ArrayOperator_SingleAccess, int64_t);
1656-
HLK_TEST(ArrayOperator_Unroll, int64_t);
1657-
HLK_TEST(ArrayOperator_Loop, int64_t);
1647+
HLK_TEST(ArrayOperator_StaticAccess, int64_t);
1648+
HLK_TEST(ArrayOperator_DynamicAccess, int64_t);
16581649
HLK_TEST(Initialize, uint16_t);
1659-
HLK_TEST(ArrayOperator_SingleAccess, uint16_t);
1660-
HLK_TEST(ArrayOperator_Unroll, uint16_t);
1661-
HLK_TEST(ArrayOperator_Loop, uint16_t);
1650+
HLK_TEST(ArrayOperator_StaticAccess, uint16_t);
1651+
HLK_TEST(ArrayOperator_DynamicAccess, uint16_t);
16621652
HLK_TEST(Initialize, uint32_t);
1663-
HLK_TEST(ArrayOperator_SingleAccess, uint32_t);
1664-
HLK_TEST(ArrayOperator_Unroll, uint32_t);
1665-
HLK_TEST(ArrayOperator_Loop, uint32_t);
1653+
HLK_TEST(ArrayOperator_StaticAccess, uint32_t);
1654+
HLK_TEST(ArrayOperator_DynamicAccess, uint32_t);
16661655
HLK_TEST(Initialize, uint64_t);
1667-
HLK_TEST(ArrayOperator_SingleAccess, uint64_t);
1668-
HLK_TEST(ArrayOperator_Unroll, uint64_t);
1669-
HLK_TEST(ArrayOperator_Loop, uint64_t);
1656+
HLK_TEST(ArrayOperator_StaticAccess, uint64_t);
1657+
HLK_TEST(ArrayOperator_DynamicAccess, uint64_t);
16701658
HLK_TEST(Initialize, HLSLHalf_t);
1671-
HLK_TEST(ArrayOperator_SingleAccess, HLSLHalf_t);
1672-
HLK_TEST(ArrayOperator_Unroll, HLSLHalf_t);
1673-
HLK_TEST(ArrayOperator_Loop, HLSLHalf_t);
1659+
HLK_TEST(ArrayOperator_StaticAccess, HLSLHalf_t);
1660+
HLK_TEST(ArrayOperator_DynamicAccess, HLSLHalf_t);
16741661
HLK_TEST(Initialize, float);
1675-
HLK_TEST(ArrayOperator_SingleAccess, float);
1676-
HLK_TEST(ArrayOperator_Unroll, float);
1677-
HLK_TEST(ArrayOperator_Loop, float);
1662+
HLK_TEST(ArrayOperator_StaticAccess, float);
1663+
HLK_TEST(ArrayOperator_DynamicAccess, float);
16781664
HLK_TEST(Initialize, double);
1679-
HLK_TEST(ArrayOperator_SingleAccess, double);
1680-
HLK_TEST(ArrayOperator_Unroll, double);
1681-
HLK_TEST(ArrayOperator_Loop, double);
1665+
HLK_TEST(ArrayOperator_StaticAccess, double);
1666+
HLK_TEST(ArrayOperator_DynamicAccess, double);
16821667

16831668
HLK_TEST(ShuffleVector, HLSLBool_t);
16841669
HLK_TEST(ShuffleVector, int16_t);

‎tools/clang/unittests/HLSLExec/ShaderOpArith.xml‎

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -4129,19 +4129,23 @@ void MSMain(uint GID : SV_GroupIndex,
41294129
const uint32_t OutNum = NUM;
41304130
#endif
41314131
4132-
#if FUNC_ARRAY_OPERATOR_SINGLE_ACCESS
4133-
vector<OUT_TYPE, OutNum> OutputVector = g_InputVector1.Load< vector<TYPE,
4134-
NUM> >(0);
4135-
OutputVector[0] = Input1[OutNum - 1];
4136-
OutputVector[OutNum - 1] = OutputVector[0];
4137-
#elif FUNC_ARRAY_OPERATOR
4132+
#if TEST_ARRAY_OPERATOR_STATIC_ACCESS
4133+
uint IndexList[6] = {0, OutNum - 1, 1, OutNum - 2, OutNum / 2, OutNum / 2 + 1};
41384134
vector<OUT_TYPE, OutNum> OutputVector;
4139-
4140-
[LOOP_ATTRB] for(uint i = 0; i < OutNum; i++)
4141-
OutputVector[i] = Input1[i] + Input2[i];
4142-
4143-
[LOOP_ATTRB] for(uint i = 0; i < OutNum; i++)
4144-
g_OutputVector.Store<OUT_TYPE>(sizeof(OUT_TYPE) * (OutNum + i), OutputVector[i]);
4135+
[unroll]for(uint i = 0; i < 6; ++i)
4136+
OutputVector[IndexList[i]] = (OUT_TYPE)Input1[IndexList[i]] + (OUT_TYPE)1;
4137+
#elif TEST_ARRAY_OPERATOR_DYNAMIC_ACCESS
4138+
vector<OUT_TYPE, OutNum> OutputVector = 0;
4139+
uint End = min(OutNum, 6);
4140+
[unroll]for(uint i = 0; i < End; ++i){
4141+
uint index = (uint)(Input2[i]);
4142+
// this doesn't work
4143+
// OutputVector[index] = Input1[i] + (OUT_TYPE)1;
4144+
// this also doesn't work
4145+
OutputVector[index] = Input1[index] + (OUT_TYPE)1;
4146+
// this works
4147+
// OutputVector[i] = Input1[index] + (OUT_TYPE)1;
4148+
}
41454149
#elif IS_UNARY_OP
41464150
vector<OUT_TYPE, OutNum> OutputVector = FUNC(Input1);
41474151
#elif IS_BINARY_OP

0 commit comments

Comments
 (0)