Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add choose max row size parameter for local id generation.

Browse Source 
Change-Id: I77185b6c114092859c742236a4dfef01deb9ea21
This commit is contained in:
Michal Mrozek
2020-02-04 17:58:41 +01:00
committed by sys_ocldev
parent 66754c4849
commit 6cc9b9d125
9 changed files with 83 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
runtime/command_queue/local_id_gen.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -26,9 +26,9 @@ const uint16_t initialLocalID[] = {
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
// Lookup table for generating LocalIDs based on the SIMD of the kernel
void (*LocalIDHelper::generateSimd8)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder) = generateLocalIDsSimd<uint16x8_t, 8>;
void (*LocalIDHelper::generateSimd16)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder) = generateLocalIDsSimd<uint16x8_t, 16>;
void (*LocalIDHelper::generateSimd32)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder) = generateLocalIDsSimd<uint16x8_t, 32>;
void (*LocalIDHelper::generateSimd8)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize) = generateLocalIDsSimd<uint16x8_t, 8>;
void (*LocalIDHelper::generateSimd16)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize) = generateLocalIDsSimd<uint16x8_t, 16>;
void (*LocalIDHelper::generateSimd32)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize) = generateLocalIDsSimd<uint16x8_t, 32>;
// Initialize the lookup table based on CPU capabilities
LocalIDHelper::LocalIDHelper() {
@ -49,11 +49,11 @@ void generateLocalIDs(void *buffer, uint16_t simd, const std::array<uint16_t, 3>
if (useLayoutForImages) {
generateLocalIDsWithLayoutForImages(buffer, localWorkgroupSize, simd);
} else if (simd == 32) {
LocalIDHelper::generateSimd32(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder);
LocalIDHelper::generateSimd32(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder, grfSize != 32);
} else if (simd == 16) {
LocalIDHelper::generateSimd16(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder);
LocalIDHelper::generateSimd16(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder, grfSize != 32);
} else if (simd == 8) {
LocalIDHelper::generateSimd8(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder);
LocalIDHelper::generateSimd8(buffer, localWorkgroupSize, threadsPerWorkGroup, dimensionsOrder, grfSize != 32);
} else {
generateLocalIDsForSimdOne(buffer, localWorkgroupSize, dimensionsOrder, grfSize);
}

12
runtime/command_queue/local_id_gen.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -43,9 +43,9 @@ inline uint32_t getPerThreadSizeLocalIDs(uint32_t simd, uint32_t grfSize, uint32
}
struct LocalIDHelper {
static void (*generateSimd8)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
static void (*generateSimd16)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
static void (*generateSimd32)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
static void (*generateSimd8)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
static void (*generateSimd16)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
static void (*generateSimd32)(void *buffer, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
static LocalIDHelper initializer;
@ -57,7 +57,7 @@ extern const uint16_t initialLocalID[];
template <typename Vec, int simd>
void generateLocalIDsSimd(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup,
const std::array<uint8_t, 3> &dimensionsOrder);
const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
void generateLocalIDs(void *buffer, uint16_t simd, const std::array<uint16_t, 3> &localWorkgroupSize,
const std::array<uint8_t, 3> &dimensionsOrder, bool isImageOnlyKernel, uint32_t grfSize);
@ -67,4 +67,4 @@ bool isCompatibleWithLayoutForImages(const std::array<uint16_t, 3> &localWorkgro
void generateLocalIDsForSimdOne(void *b, const std::array<uint16_t, 3> &localWorkgroupSize,
const std::array<uint8_t, 3> &dimensionsOrder, uint32_t grfSize);
} // namespace NEO
} // namespace NEO

6
runtime/command_queue/local_id_gen.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -13,7 +13,7 @@ namespace NEO {
template <typename Vec, int simd>
inline void generateLocalIDsSimd(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup,
const std::array<uint8_t, 3> &dimensionsOrder) {
const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize) {
const int passes = simd / Vec::numChannels;
int pass = 0;
@ -27,7 +27,7 @@ inline void generateLocalIDsSimd(void *b, const std::array<uint16_t, 3> &localWo
auto zero = Vec::zero();
auto one = Vec::one();
const auto threadSkipSize = (simd == 32 ? 32 : 16) * sizeof(uint16_t);
const auto threadSkipSize = ((simd == 32 || chooseMaxRowSize) ? 32 : 16) * sizeof(uint16_t);
Vec vSimdX(simd);
Vec vSimdY = zero;
Vec vSimdZ = zero;

8
runtime/command_queue/local_id_gen_avx2.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -12,7 +12,7 @@
#include <array>
namespace NEO {
template void generateLocalIDsSimd<uint16x16_t, 32>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
template void generateLocalIDsSimd<uint16x16_t, 16>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
template void generateLocalIDsSimd<uint16x16_t, 32>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
template void generateLocalIDsSimd<uint16x16_t, 16>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
} // namespace NEO
#endif
#endif

8
runtime/command_queue/local_id_gen_sse4.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,7 +11,7 @@
#include <array>
namespace NEO {
template void generateLocalIDsSimd<uint16x8_t, 32>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
template void generateLocalIDsSimd<uint16x8_t, 16>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
template void generateLocalIDsSimd<uint16x8_t, 8>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder);
template void generateLocalIDsSimd<uint16x8_t, 32>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
template void generateLocalIDsSimd<uint16x8_t, 16>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
template void generateLocalIDsSimd<uint16x8_t, 8>(void *b, const std::array<uint16_t, 3> &localWorkgroupSize, uint16_t threadsPerWorkGroup, const std::array<uint8_t, 3> &dimensionsOrder, bool chooseMaxRowSize);
} // namespace NEO

25
unit_tests/command_queue/flattened_id_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -7,11 +7,12 @@
#include "core/helpers/basic_math.h"
#include "core/helpers/string.h"
#include "gtest/gtest.h"
#include "test.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include <algorithm>
#include <cstdint>
using namespace NEO;
union GRF {
float fRegs[8];
@ -110,7 +111,7 @@ void generateFlattenedIDs(void *buffer, uint32_t simd, uint32_t lwsX, uint32_t l
memcpy_s(buffer, copySize, pSrc, copySize);
}
struct FlattenedIDFixture : public ::testing::TestWithParam<std::tuple<int, int, int, int>> {
struct FlattenedIDFixture : ::testing::TestWithParam<std::tuple<int, int, int, int>> {
void SetUp() override {
simd = std::get<0>(GetParam());
localWorkSizeX = std::get<1>(GetParam());
@ -127,12 +128,12 @@ struct FlattenedIDFixture : public ::testing::TestWithParam<std::tuple<int, int,
memset(buffer, 0xff, sizeof(buffer));
}
void validateIDWithinLimits(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ) {
void validateIDWithinLimits(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ, bool useFullRow) {
auto numWorkItems = lwsX * lwsY * lwsZ;
auto idsPerThread = simd;
// As per BackEnd HLD, SIMD32 has 32 flattenedIDs per channel. SIMD8/16 has up to 16 flattenedIDs.
auto skipPerThread = simd == 32 ? 32 : 16;
auto skipPerThread = (simd == 32 || useFullRow) ? 32 : 16;
auto pBuffer = buffer;
size_t itemIndex = 0;
@ -148,12 +149,12 @@ struct FlattenedIDFixture : public ::testing::TestWithParam<std::tuple<int, int,
}
}
void validateAllWorkItemsCovered(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ) {
void validateAllWorkItemsCovered(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ, bool useFullRow) {
auto numWorkItems = lwsX * lwsY * lwsZ;
auto idsPerThread = simd;
// As per BackEnd HLD, SIMD32 has 32 localIDs per channel. SIMD8/16 has up to 16 localIDs.
auto skipPerThread = simd == 32 ? 32 : 16;
auto skipPerThread = (simd == 32 || useFullRow) ? 32 : 16;
// Initialize local ID hit table
uint32_t localIDHitTable[8];
@ -204,16 +205,16 @@ struct FlattenedIDFixture : public ::testing::TestWithParam<std::tuple<int, int,
uint16_t buffer[32 * 16];
};
TEST_P(FlattenedIDFixture, checkIDWithinLimits) {
HWTEST_P(FlattenedIDFixture, checkIDWithinLimits) {
generateFlattenedIDs(buffer, simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateIDWithinLimits(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateIDWithinLimits(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
}
TEST_P(FlattenedIDFixture, checkAllWorkItemsCovered) {
HWTEST_P(FlattenedIDFixture, checkAllWorkItemsCovered) {
generateFlattenedIDs(buffer, simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
}
TEST_P(FlattenedIDFixture, sizeCalculationLocalIDs) {

57
unit_tests/command_queue/local_id_tests.cpp
View File

@ -9,8 +9,8 @@
#include "core/helpers/basic_math.h"
#include "core/helpers/ptr_math.h"
#include "runtime/command_queue/local_id_gen.h"
#include "gtest/gtest.h"
#include "test.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include <algorithm>
#include <cstdint>
@ -68,8 +68,31 @@ TEST(LocalID, GivenSimd1WhenGettingPerThreadSizeLocalIdsThenValueIsEqualGrfSize)
EXPECT_EQ(grfSize, getPerThreadSizeLocalIDs(simd, grfSize));
}
TEST(LocalID, givenVariadicGrfSizeWhenLocalSizesAreEmittedTheyUseFullRowSize) {
auto localIdsPtr = allocateAlignedMemory(3 * 64u, MemoryConstants::cacheLineSize);
struct LocalIDFixture : public ::testing::TestWithParam<std::tuple<int, int, int, int, int>> {
uint16_t *localIdsView = reinterpret_cast<uint16_t *>(localIdsPtr.get());
std::array<uint16_t, 3u> localSizes = {2u, 2u, 1u};
std::array<uint8_t, 3u> dimensionsOrder = {0u, 1u, 2u};
generateLocalIDs(localIdsPtr.get(), 16u, localSizes, dimensionsOrder, false, 64u);
EXPECT_EQ(localIdsView[0], 0u);
EXPECT_EQ(localIdsView[1], 1u);
EXPECT_EQ(localIdsView[2], 0u);
EXPECT_EQ(localIdsView[3], 1u);
EXPECT_EQ(localIdsView[32], 0u);
EXPECT_EQ(localIdsView[33], 0u);
EXPECT_EQ(localIdsView[34], 1u);
EXPECT_EQ(localIdsView[35], 1u);
EXPECT_EQ(localIdsView[64], 0u);
EXPECT_EQ(localIdsView[65], 0u);
EXPECT_EQ(localIdsView[66], 0u);
EXPECT_EQ(localIdsView[67], 0u);
}
struct LocalIDFixture : ::testing::TestWithParam<std::tuple<int, int, int, int, int>> {
void SetUp() override {
simd = std::get<0>(GetParam());
grfSize = std::get<1>(GetParam());
@ -93,11 +116,11 @@ struct LocalIDFixture : public ::testing::TestWithParam<std::tuple<int, int, int
alignedFree(buffer);
}
void validateIDWithinLimits(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ) {
void validateIDWithinLimits(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ, bool useFullRowSize) {
auto idsPerThread = simd;
// As per BackEnd HLD, SIMD32 has 32 localIDs per channel. SIMD8/16 has up to 16 localIDs.
auto skipPerThread = simd == 32 ? 32 : 16;
auto skipPerThread = (simd == 32 || useFullRowSize) ? 32 : 16;
auto pBufferX = buffer;
auto pBufferY = pBufferX + skipPerThread;
@ -122,11 +145,11 @@ struct LocalIDFixture : public ::testing::TestWithParam<std::tuple<int, int, int
}
}
void validateAllWorkItemsCovered(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ) {
void validateAllWorkItemsCovered(uint32_t simd, uint32_t lwsX, uint32_t lwsY, uint32_t lwsZ, bool useFullRow) {
auto idsPerThread = simd;
// As per BackEnd HLD, SIMD32 has 32 localIDs per channel. SIMD8/16 has up to 16 localIDs.
auto skipPerThread = simd == 32 ? 32 : 16;
auto skipPerThread = (simd == 32 || useFullRow) ? 32 : 16;
auto pBufferX = buffer;
auto pBufferY = pBufferX + skipPerThread;
@ -246,39 +269,39 @@ struct LocalIDFixture : public ::testing::TestWithParam<std::tuple<int, int, int
uint16_t *buffer;
};
TEST_P(LocalIDFixture, WhenGeneratingLocalIdsThenIdsAreWithinLimits) {
HWTEST_P(LocalIDFixture, WhenGeneratingLocalIdsThenIdsAreWithinLimits) {
generateLocalIDs(buffer, simd, std::array<uint16_t, 3>{{static_cast<uint16_t>(localWorkSizeX), static_cast<uint16_t>(localWorkSizeY), static_cast<uint16_t>(localWorkSizeZ)}},
std::array<uint8_t, 3>{{0, 1, 2}}, false, grfSize);
validateIDWithinLimits(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateIDWithinLimits(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
}
TEST_P(LocalIDFixture, WhenGeneratingLocalIdsThenAllWorkItemsCovered) {
HWTEST_P(LocalIDFixture, WhenGeneratingLocalIdsThenAllWorkItemsCovered) {
generateLocalIDs(buffer, simd, std::array<uint16_t, 3>{{static_cast<uint16_t>(localWorkSizeX), static_cast<uint16_t>(localWorkSizeY), static_cast<uint16_t>(localWorkSizeZ)}},
std::array<uint8_t, 3>{{0, 1, 2}}, false, grfSize);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
}
TEST_P(LocalIDFixture, WhenWalkOrderIsXyzThenProperLocalIdsAreGenerated) {
HWTEST_P(LocalIDFixture, WhenWalkOrderIsXyzThenProperLocalIdsAreGenerated) {
auto dimensionsOrder = std::array<uint8_t, 3>{{0, 1, 2}};
generateLocalIDs(buffer, simd, std::array<uint16_t, 3>{{static_cast<uint16_t>(localWorkSizeX), static_cast<uint16_t>(localWorkSizeY), static_cast<uint16_t>(localWorkSizeZ)}},
dimensionsOrder, false, grfSize);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
validateWalkOrder(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, dimensionsOrder);
}
TEST_P(LocalIDFixture, WhenWalkOrderIsYxzThenProperLocalIdsAreGenerated) {
HWTEST_P(LocalIDFixture, WhenWalkOrderIsYxzThenProperLocalIdsAreGenerated) {
auto dimensionsOrder = std::array<uint8_t, 3>{{1, 0, 2}};
generateLocalIDs(buffer, simd, std::array<uint16_t, 3>{{static_cast<uint16_t>(localWorkSizeX), static_cast<uint16_t>(localWorkSizeY), static_cast<uint16_t>(localWorkSizeZ)}},
dimensionsOrder, false, grfSize);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
validateWalkOrder(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, dimensionsOrder);
}
TEST_P(LocalIDFixture, WhenWalkOrderIsZyxThenProperLocalIdsAreGenerated) {
HWTEST_P(LocalIDFixture, WhenWalkOrderIsZyxThenProperLocalIdsAreGenerated) {
auto dimensionsOrder = std::array<uint8_t, 3>{{2, 1, 0}};
generateLocalIDs(buffer, simd, std::array<uint16_t, 3>{{static_cast<uint16_t>(localWorkSizeX), static_cast<uint16_t>(localWorkSizeY), static_cast<uint16_t>(localWorkSizeZ)}},
dimensionsOrder, false, grfSize);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ);
validateAllWorkItemsCovered(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, UnitTestHelper<FamilyType>::useFullRowForLocalIdsGeneration);
validateWalkOrder(simd, localWorkSizeX, localWorkSizeY, localWorkSizeZ, dimensionsOrder);
}

2
unit_tests/helpers/unit_test_helper.h
View File

@ -42,5 +42,7 @@ struct UnitTestHelper {
static const uint32_t smallestTestableSimdSize;
static const AuxTranslationMode requiredAuxTranslationMode;
static const bool useFullRowForLocalIdsGeneration;
};
} // namespace NEO

5
unit_tests/helpers/unit_test_helper.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2019 Intel Corporation
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -69,4 +69,7 @@ const uint32_t UnitTestHelper<GfxFamily>::smallestTestableSimdSize = 8;
template <typename GfxFamily>
const AuxTranslationMode UnitTestHelper<GfxFamily>::requiredAuxTranslationMode = AuxTranslationMode::Builtin;
template <typename GfxFamily>
const bool UnitTestHelper<GfxFamily>::useFullRowForLocalIdsGeneration = false;
} // namespace NEO