intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 09:09:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: configure readability-identifier-naming.ClassCase

Browse Source 
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Artur Harasimiuk
2022-06-02 15:10:04 +00:00
committed by Compute-Runtime-Automation
parent 260838430f
commit 6d43e96dee
118 changed files with 1812 additions and 1805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
opencl/test/unit_test/api/cl_create_buffer_tests.cpp
View File

@@ -23,7 +23,7 @@ typedef api_tests clCreateBufferTests;
namespace ClCreateBufferTests {
class clCreateBufferTemplateTests : public ApiFixture<>,
class ClCreateBufferTemplateTests : public ApiFixture<>,
public testing::TestWithParam<uint64_t> {
void SetUp() override {
ApiFixture::SetUp();
@@ -34,7 +34,7 @@ class clCreateBufferTemplateTests : public ApiFixture<>,
}
};
struct clCreateBufferValidFlagsTests : public clCreateBufferTemplateTests {
struct clCreateBufferValidFlagsTests : public ClCreateBufferTemplateTests {
cl_uchar pHostPtr[64];
};
@@ -72,7 +72,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateBufferValidFlagsTests,
testing::ValuesIn(validFlags));
using clCreateBufferInvalidFlagsTests = clCreateBufferTemplateTests;
using clCreateBufferInvalidFlagsTests = ClCreateBufferTemplateTests;
TEST_P(clCreateBufferInvalidFlagsTests, GivenInvalidFlagsWhenCreatingBufferThenBufferIsNotCreated) {
cl_mem_flags flags = GetParam();
@@ -108,7 +108,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateBufferInvalidFlagsTests,
testing::ValuesIn(invalidFlags));
using clCreateBufferValidFlagsIntelTests = clCreateBufferTemplateTests;
using clCreateBufferValidFlagsIntelTests = ClCreateBufferTemplateTests;
TEST_P(clCreateBufferValidFlagsIntelTests, GivenValidFlagsIntelWhenCreatingBufferThenBufferIsCreated) {
cl_mem_properties_intel properties[] = {CL_MEM_FLAGS_INTEL, GetParam(), 0};
@@ -130,7 +130,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateBufferValidFlagsIntelTests,
testing::ValuesIn(validFlagsIntel));
using clCreateBufferInvalidFlagsIntelTests = clCreateBufferTemplateTests;
using clCreateBufferInvalidFlagsIntelTests = ClCreateBufferTemplateTests;
TEST_P(clCreateBufferInvalidFlagsIntelTests, GivenInvalidFlagsIntelWhenCreatingBufferThenBufferIsNotCreated) {
cl_mem_properties_intel properties[] = {CL_MEM_FLAGS_INTEL, GetParam(), 0};
@@ -149,7 +149,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateBufferInvalidFlagsIntelTests,
testing::ValuesIn(invalidFlagsIntel));
using clCreateBufferInvalidProperties = clCreateBufferTemplateTests;
using clCreateBufferInvalidProperties = ClCreateBufferTemplateTests;
TEST_F(clCreateBufferInvalidProperties, GivenInvalidPropertyKeyWhenCreatingBufferThenBufferIsNotCreated) {
cl_mem_properties_intel properties[] = {(cl_mem_properties_intel(1) << 31), 0, 0};
@@ -534,7 +534,7 @@ TEST_F(clCreateBufferTestsWithRestrictions, GivenMemoryManagerRestrictionsWhenMi
EXPECT_EQ(CL_SUCCESS, retVal);
}
using clCreateBufferWithMultiDeviceContextTests = clCreateBufferTemplateTests;
using clCreateBufferWithMultiDeviceContextTests = ClCreateBufferTemplateTests;
TEST_P(clCreateBufferWithMultiDeviceContextTests, GivenBufferCreatedWithContextdWithMultiDeviceThenGraphicsAllocationsAreProperlyFilled) {
UltClDeviceFactory deviceFactory{2, 0};
@@ -584,7 +584,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateBufferWithMultiDeviceContextTests,
testing::ValuesIn(validFlagsForMultiDeviceContextBuffer));
using clCreateBufferWithMultiDeviceContextFaillingAllocationTests = clCreateBufferTemplateTests;
using clCreateBufferWithMultiDeviceContextFaillingAllocationTests = ClCreateBufferTemplateTests;
TEST_F(clCreateBufferWithMultiDeviceContextFaillingAllocationTests, GivenContextdWithMultiDeviceFailingAllocationThenBufferAllocateFails) {
UltClDeviceFactory deviceFactory{3, 0};

12
opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
View File

@@ -477,11 +477,11 @@ std::pair<uint32_t, QueuePriority> priorityParams[3]{
std::make_pair(CL_QUEUE_PRIORITY_MED_KHR, QueuePriority::MEDIUM),
std::make_pair(CL_QUEUE_PRIORITY_HIGH_KHR, QueuePriority::HIGH)};
class clCreateCommandQueueWithPropertiesApiPriority : public clCreateCommandQueueWithPropertiesApi,
class ClCreateCommandQueueWithPropertiesApiPriority : public clCreateCommandQueueWithPropertiesApi,
public ::testing::WithParamInterface<std::pair<uint32_t, QueuePriority>> {
};
TEST_P(clCreateCommandQueueWithPropertiesApiPriority, GivenValidPriorityWhenCreatingCommandQueueWithPropertiesThenCorrectPriorityIsSetInternally) {
TEST_P(ClCreateCommandQueueWithPropertiesApiPriority, GivenValidPriorityWhenCreatingCommandQueueWithPropertiesThenCorrectPriorityIsSetInternally) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_PRIORITY_KHR, GetParam().first, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
@@ -496,7 +496,7 @@ TEST_P(clCreateCommandQueueWithPropertiesApiPriority, GivenValidPriorityWhenCrea
}
INSTANTIATE_TEST_CASE_P(AllValidPriorities,
clCreateCommandQueueWithPropertiesApiPriority,
ClCreateCommandQueueWithPropertiesApiPriority,
::testing::ValuesIn(priorityParams));
std::pair<uint32_t, QueueThrottle> throttleParams[3]{
@@ -504,11 +504,11 @@ std::pair<uint32_t, QueueThrottle> throttleParams[3]{
std::make_pair(CL_QUEUE_THROTTLE_MED_KHR, QueueThrottle::MEDIUM),
std::make_pair(CL_QUEUE_THROTTLE_HIGH_KHR, QueueThrottle::HIGH)};
class clCreateCommandQueueWithPropertiesApiThrottle : public clCreateCommandQueueWithPropertiesApi,
class ClCreateCommandQueueWithPropertiesApiThrottle : public clCreateCommandQueueWithPropertiesApi,
public ::testing::WithParamInterface<std::pair<uint32_t, QueueThrottle>> {
};
TEST_P(clCreateCommandQueueWithPropertiesApiThrottle, GivenThrottlePropertiesWhenCreatingCommandQueueWithPropertiesThenCorrectThrottleIsSetInternally) {
TEST_P(ClCreateCommandQueueWithPropertiesApiThrottle, GivenThrottlePropertiesWhenCreatingCommandQueueWithPropertiesThenCorrectThrottleIsSetInternally) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_THROTTLE_KHR, GetParam().first, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
@@ -523,7 +523,7 @@ TEST_P(clCreateCommandQueueWithPropertiesApiThrottle, GivenThrottlePropertiesWhe
}
INSTANTIATE_TEST_CASE_P(AllValidThrottleValues,
clCreateCommandQueueWithPropertiesApiThrottle,
ClCreateCommandQueueWithPropertiesApiThrottle,
::testing::ValuesIn(throttleParams));
} // namespace ULT

14
opencl/test/unit_test/api/cl_create_pipe_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,7 +23,7 @@ struct clCreatePipeTests : api_tests {
namespace ClCreatePipeTests {
class clCreatePipeWithParamTests : public ApiFixture<>, public testing::TestWithParam<uint64_t> {
class ClCreatePipeWithParamTests : public ApiFixture<>, public testing::TestWithParam<uint64_t> {
void SetUp() override {
ApiFixture::SetUp();
}
@@ -33,7 +33,7 @@ class clCreatePipeWithParamTests : public ApiFixture<>, public testing::TestWith
VariableBackup<bool> supportsPipesBackup{&defaultHwInfo->capabilityTable.supportsPipes, true};
};
class clCreatePipeWithParamNegativeTests : public ApiFixture<>, public testing::TestWithParam<uint64_t> {
class ClCreatePipeWithParamNegativeTests : public ApiFixture<>, public testing::TestWithParam<uint64_t> {
void SetUp() override {
ApiFixture::SetUp();
}
@@ -43,7 +43,7 @@ class clCreatePipeWithParamNegativeTests : public ApiFixture<>, public testing::
VariableBackup<bool> supportsPipesBackup{&defaultHwInfo->capabilityTable.supportsPipes, true};
};
TEST_P(clCreatePipeWithParamTests, GivenValidFlagsWhenCreatingPipeThenPipeIsCreatedAndSuccessIsReturned) {
TEST_P(ClCreatePipeWithParamTests, GivenValidFlagsWhenCreatingPipeThenPipeIsCreatedAndSuccessIsReturned) {
cl_mem_flags flags = GetParam();
auto pipe = clCreatePipe(pContext, flags, 1, 20, nullptr, &retVal);
@@ -53,7 +53,7 @@ TEST_P(clCreatePipeWithParamTests, GivenValidFlagsWhenCreatingPipeThenPipeIsCrea
clReleaseMemObject(pipe);
}
TEST_P(clCreatePipeWithParamNegativeTests, GivenInalidFlagsWhenCreatingPipeThenInvalidValueErrorIsReturned) {
TEST_P(ClCreatePipeWithParamNegativeTests, GivenInalidFlagsWhenCreatingPipeThenInvalidValueErrorIsReturned) {
cl_mem_flags flags = GetParam();
auto pipe = clCreatePipe(pContext, flags, 1, 20, nullptr, &retVal);
@@ -93,12 +93,12 @@ static cl_mem_flags invalidFlags[] = {
INSTANTIATE_TEST_CASE_P(
CreatePipeCheckFlags,
clCreatePipeWithParamTests,
ClCreatePipeWithParamTests,
testing::ValuesIn(validFlags));
INSTANTIATE_TEST_CASE_P(
CreatePipeCheckFlagsNegative,
clCreatePipeWithParamNegativeTests,
ClCreatePipeWithParamNegativeTests,
testing::ValuesIn(invalidFlags));
TEST_F(clCreatePipeTests, GivenValidFlagsAndNullReturnWhenCreatingPipeThenPipeIsCreated) {

24
opencl/test/unit_test/api/cl_create_sub_buffer_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,7 +14,7 @@ using namespace NEO;
namespace ClCreateSubbufferTests {
template <bool hasHostPtr, cl_mem_flags parentFlags>
class clCreateSubBufferTemplateTests : public ApiFixture<>,
class ClCreateSubBufferTemplateTests : public ApiFixture<>,
public testing::TestWithParam<uint64_t /*cl_mem_flags*/> {
void SetUp() override {
ApiFixture::SetUp();
@@ -42,7 +42,7 @@ class clCreateSubBufferTemplateTests : public ApiFixture<>,
};
struct clCreateSubBufferValidFlagsNoHostPtrTests
: public clCreateSubBufferTemplateTests<false, CL_MEM_READ_WRITE> {
: public ClCreateSubBufferTemplateTests<false, CL_MEM_READ_WRITE> {
};
TEST_P(clCreateSubBufferValidFlagsNoHostPtrTests, GivenValidFlagsWhenCreatingSubBufferThenSubBufferIsCreatedAndSuccessIsReturned) {
@@ -72,7 +72,7 @@ INSTANTIATE_TEST_CASE_P(
testing::ValuesIn(validFlags));
struct clCreateSubBufferInvalidFlagsHostPtrTests
: public clCreateSubBufferTemplateTests<true, CL_MEM_HOST_NO_ACCESS | CL_MEM_READ_ONLY> {
: public ClCreateSubBufferTemplateTests<true, CL_MEM_HOST_NO_ACCESS | CL_MEM_READ_ONLY> {
};
TEST_P(clCreateSubBufferInvalidFlagsHostPtrTests, GivenInvalidFlagsWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
@@ -101,7 +101,7 @@ INSTANTIATE_TEST_CASE_P(
clCreateSubBufferInvalidFlagsHostPtrTests,
testing::ValuesIn(invalidFlags));
class clCreateSubBufferTests : public api_tests {
class ClCreateSubBufferTests : public api_tests {
void SetUp() override {
api_tests::SetUp();
cl_mem_flags flg = CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS;
@@ -121,7 +121,7 @@ class clCreateSubBufferTests : public api_tests {
cl_uchar pHostPtr[64];
};
TEST_F(clCreateSubBufferTests, GivenInBoundsRegionWhenCreatingSubBufferThenSubBufferIsCreatedAndSuccessIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenInBoundsRegionWhenCreatingSubBufferThenSubBufferIsCreatedAndSuccessIsReturned) {
cl_buffer_region region = {0, 12};
auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION,
@@ -132,7 +132,7 @@ TEST_F(clCreateSubBufferTests, GivenInBoundsRegionWhenCreatingSubBufferThenSubBu
clReleaseMemObject(subBuffer);
}
TEST_F(clCreateSubBufferTests, GivenOutOfBoundsRegionWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenOutOfBoundsRegionWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
cl_buffer_region region = {4, 68};
auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION,
@@ -141,7 +141,7 @@ TEST_F(clCreateSubBufferTests, GivenOutOfBoundsRegionWhenCreatingSubBufferThenIn
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateSubBufferTests, GivenSubBufferAsBufferWhenCreatingSubBufferThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenSubBufferAsBufferWhenCreatingSubBufferThenInvalidMemObjectErrorIsReturned) {
cl_buffer_region region0 = {0, 60};
cl_buffer_region region1 = {8, 20};
@@ -158,7 +158,7 @@ TEST_F(clCreateSubBufferTests, GivenSubBufferAsBufferWhenCreatingSubBufferThenIn
clReleaseMemObject(subBuffer);
}
TEST_F(clCreateSubBufferTests, GivenInvalidBufferObjectWhenCreatingSubBufferThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenInvalidBufferObjectWhenCreatingSubBufferThenInvalidMemObjectErrorIsReturned) {
cl_buffer_region region = {4, 60};
cl_int trash[] = {0x01, 0x08, 0x88, 0xcc, 0xab, 0x55};
@@ -168,7 +168,7 @@ TEST_F(clCreateSubBufferTests, GivenInvalidBufferObjectWhenCreatingSubBufferThen
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateSubBufferTests, GivenInvalidOffsetWhenCreatingSubBufferThenMisalignedSubBufferOffsetErrorIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenInvalidOffsetWhenCreatingSubBufferThenMisalignedSubBufferOffsetErrorIsReturned) {
cl_buffer_region region = {1, 60};
auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE,
@@ -177,7 +177,7 @@ TEST_F(clCreateSubBufferTests, GivenInvalidOffsetWhenCreatingSubBufferThenMisali
EXPECT_EQ(CL_MISALIGNED_SUB_BUFFER_OFFSET, retVal);
}
TEST_F(clCreateSubBufferTests, GivenNoRegionWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateSubBufferTests, GivenNoRegionWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
cl_buffer_region region = {4, 60};
auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION,
@@ -194,7 +194,7 @@ TEST_F(clCreateSubBufferTests, GivenNoRegionWhenCreatingSubBufferThenInvalidValu
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateSubBufferTests, GivenBufferWithFlagsWhenCreatingSubBufferThenFlagsAreInherited) {
TEST_F(ClCreateSubBufferTests, GivenBufferWithFlagsWhenCreatingSubBufferThenFlagsAreInherited) {
cl_buffer_region region = {0, 60};
auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_ONLY, CL_BUFFER_CREATE_TYPE_REGION,

16
opencl/test/unit_test/api/cl_enqueue_verify_memory.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -26,36 +26,36 @@ struct clEnqueueVerifyMemoryINTELSettings {
void *gpuAddress = expected;
};
class clEnqueueVerifyMemoryINTELTests : public api_tests,
class ClEnqueueVerifyMemoryIntelTests : public api_tests,
public clEnqueueVerifyMemoryINTELSettings {
};
TEST_F(clEnqueueVerifyMemoryINTELTests, givenSizeOfComparisonEqualZeroWhenCallingVerifyMemoryThenErrorIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenSizeOfComparisonEqualZeroWhenCallingVerifyMemoryThenErrorIsReturned) {
cl_int retval = clEnqueueVerifyMemoryINTEL(nullptr, nullptr, nullptr, 0, comparisonMode);
EXPECT_EQ(CL_INVALID_VALUE, retval);
}
TEST_F(clEnqueueVerifyMemoryINTELTests, givenNullExpectedDataWhenCallingVerifyMemoryThenErrorIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenNullExpectedDataWhenCallingVerifyMemoryThenErrorIsReturned) {
cl_int retval = clEnqueueVerifyMemoryINTEL(nullptr, nullptr, nullptr, expectedSize, comparisonMode);
EXPECT_EQ(CL_INVALID_VALUE, retval);
}
TEST_F(clEnqueueVerifyMemoryINTELTests, givenInvalidAllocationPointerWhenCallingVerifyMemoryThenErrorIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenInvalidAllocationPointerWhenCallingVerifyMemoryThenErrorIsReturned) {
cl_int retval = clEnqueueVerifyMemoryINTEL(nullptr, nullptr, expected, expectedSize, comparisonMode);
EXPECT_EQ(CL_INVALID_VALUE, retval);
}
TEST_F(clEnqueueVerifyMemoryINTELTests, givenInvalidCommandQueueWhenCallingVerifyMemoryThenErrorIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenInvalidCommandQueueWhenCallingVerifyMemoryThenErrorIsReturned) {
cl_int retval = clEnqueueVerifyMemoryINTEL(nullptr, gpuAddress, expected, expectedSize, comparisonMode);
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retval);
}
TEST_F(clEnqueueVerifyMemoryINTELTests, givenEqualMemoryWhenCallingVerifyMemoryThenSuccessIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenEqualMemoryWhenCallingVerifyMemoryThenSuccessIsReturned) {
cl_int retval = clEnqueueVerifyMemoryINTEL(pCommandQueue, gpuAddress, expected, expectedSize, comparisonMode);
EXPECT_EQ(CL_SUCCESS, retval);
}
TEST_F(clEnqueueVerifyMemoryINTELTests, givenNotEqualMemoryWhenCallingVerifyMemoryThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenNotEqualMemoryWhenCallingVerifyMemoryThenInvalidValueErrorIsReturned) {
int differentMemory = expected[0] + 1;
cl_int retval = clEnqueueVerifyMemoryINTEL(pCommandQueue, gpuAddress, &differentMemory, sizeof(differentMemory), comparisonMode);
EXPECT_EQ(CL_INVALID_VALUE, retval);

8
opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl
View File

@@ -269,7 +269,7 @@ TEST_F(clEventProfilingTests, GivenPerfCountersEnabledWhenCheckingPerfCountersTh
delete pEvent;
}
class clEventProfilingWithPerfCountersTests : public DeviceInstrumentationFixture,
class ClEventProfilingWithPerfCountersTests : public DeviceInstrumentationFixture,
public PerformanceCountersDeviceFixture,
public ::testing::Test {
public:
@@ -303,7 +303,7 @@ class clEventProfilingWithPerfCountersTests : public DeviceInstrumentationFixtur
size_t param_value_size_ret = 0;
};
TEST_F(clEventProfilingWithPerfCountersTests, GivenDisabledPerfCountersWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
TEST_F(ClEventProfilingWithPerfCountersTests, GivenDisabledPerfCountersWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
event->setPerfCountersEnabled(false);
cl_int retVal = clGetEventProfilingInfo(eventCl,
CL_PROFILING_COMMAND_PERFCOUNTERS_INTEL,
@@ -313,7 +313,7 @@ TEST_F(clEventProfilingWithPerfCountersTests, GivenDisabledPerfCountersWhenGetti
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEventProfilingWithPerfCountersTests, GivenEnabledPerfCountersWhenGettingEventProfilingInfoThenSuccessIsReturned) {
TEST_F(ClEventProfilingWithPerfCountersTests, GivenEnabledPerfCountersWhenGettingEventProfilingInfoThenSuccessIsReturned) {
event->setPerfCountersEnabled(true);
cl_int retVal = clGetEventProfilingInfo(eventCl,
CL_PROFILING_COMMAND_PERFCOUNTERS_INTEL,
@@ -323,7 +323,7 @@ TEST_F(clEventProfilingWithPerfCountersTests, GivenEnabledPerfCountersWhenGettin
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEventProfilingWithPerfCountersTests, GivenEnabledPerfCountersAndIncorrectParamValueSizeWhenGettingEventProfilingInfoThenProfilingInfoNotAvailableErrorIsReturned) {
TEST_F(ClEventProfilingWithPerfCountersTests, GivenEnabledPerfCountersAndIncorrectParamValueSizeWhenGettingEventProfilingInfoThenProfilingInfoNotAvailableErrorIsReturned) {
event->setPerfCountersEnabled(true);
cl_int retVal = clGetEventProfilingInfo(eventCl,
CL_PROFILING_COMMAND_PERFCOUNTERS_INTEL,

8
opencl/test/unit_test/api/cl_get_platform_info_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -47,7 +47,7 @@ TEST_F(clGetPlatformInfoTests, GivenClPlatformProfileWhenGettingPlatformInfoStri
EXPECT_STREQ(paramValue, "FULL_PROFILE");
}
class clGetPlatformInfoParameterizedTests : public clGetPlatformInfoTests,
class ClGetPlatformInfoParameterizedTests : public clGetPlatformInfoTests,
public ::testing::WithParamInterface<uint32_t> {
void SetUp() override {
DebugManager.flags.ForceOCLVersion.set(GetParam());
@@ -60,7 +60,7 @@ class clGetPlatformInfoParameterizedTests : public clGetPlatformInfoTests,
}
};
TEST_P(clGetPlatformInfoParameterizedTests, GivenClPlatformVersionWhenGettingPlatformInfoStringThenCorrectOpenClVersionIsReturned) {
TEST_P(ClGetPlatformInfoParameterizedTests, GivenClPlatformVersionWhenGettingPlatformInfoStringThenCorrectOpenClVersionIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_VERSION);
cl_version platformNumericVersion = 0;
@@ -92,7 +92,7 @@ TEST_P(clGetPlatformInfoParameterizedTests, GivenClPlatformVersionWhenGettingPla
}
INSTANTIATE_TEST_CASE_P(OCLVersions,
clGetPlatformInfoParameterizedTests,
ClGetPlatformInfoParameterizedTests,
::testing::Values(12, 21, 30));
TEST_F(clGetPlatformInfoTests, GivenClPlatformNameWhenGettingPlatformInfoStringThenCorrectStringIsReturned) {

4
opencl/test/unit_test/api/cl_retain_release_command_queue_tests.inl
View File

@@ -14,7 +14,7 @@
using namespace NEO;
namespace ULT {
class clRetainReleaseCommandQueueTests : public ApiFixture<>,
class ClRetainReleaseCommandQueueTests : public ApiFixture<>,
public ::testing::Test {
public:
void SetUp() override {
@@ -32,7 +32,7 @@ class clRetainReleaseCommandQueueTests : public ApiFixture<>,
cl_queue_properties noProperties[5] = {0};
};
TEST_F(clRetainReleaseCommandQueueTests, GivenValidCommandQueueWhenRetainingAndReleasingThenReferenceCountIsUpdatedCorrectly) {
TEST_F(ClRetainReleaseCommandQueueTests, GivenValidCommandQueueWhenRetainingAndReleasingThenReferenceCountIsUpdatedCorrectly) {
auto queue = this->createClQueue();
ASSERT_EQ(CL_SUCCESS, this->retVal);

26
opencl/test/unit_test/api/cl_set_event_callback_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -21,7 +21,7 @@ void CL_CALLBACK eventCallBack(cl_event event, cl_int callbackType, void *userDa
cbData = userData;
}
class clSetEventCallbackTests : public ApiFixture<>,
class ClSetEventCallbackTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -39,7 +39,7 @@ class clSetEventCallbackTests : public ApiFixture<>,
std::unique_ptr<DebugManagerStateRestore> dbgRestore;
};
TEST_F(clSetEventCallbackTests, GivenValidEventWhenSettingEventCallbackThenSuccessIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenValidEventWhenSettingEventCallbackThenSuccessIsReturned) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
@@ -47,14 +47,14 @@ TEST_F(clSetEventCallbackTests, GivenValidEventWhenSettingEventCallbackThenSucce
event->decRefInternal();
}
TEST_F(clSetEventCallbackTests, GivenInvalidEventWhenSettingEventCallbackThenInvalidEventErrorIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenInvalidEventWhenSettingEventCallbackThenInvalidEventErrorIsReturned) {
std::unique_ptr<char> event(new char[sizeof(Event)]);
memset(event.get(), 0, sizeof(Event));
retVal = clSetEventCallback(reinterpret_cast<cl_event>(event.get()), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_INVALID_EVENT, retVal);
}
TEST_F(clSetEventCallbackTests, GivenValidCallbackTypeWhenSettingEventCallbackThenSuccessIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenValidCallbackTypeWhenSettingEventCallbackThenSuccessIsReturned) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -70,19 +70,19 @@ TEST_F(clSetEventCallbackTests, GivenValidCallbackTypeWhenSettingEventCallbackTh
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clSetEventCallbackTests, GivenInvalidCallbackTypeWhenSettingEventCallbackThenInvalidValueErrorIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenInvalidCallbackTypeWhenSettingEventCallbackThenInvalidValueErrorIsReturned) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE + CL_RUNNING + CL_SUBMITTED, eventCallBack, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clSetEventCallbackTests, GivenNullCallbackWhenSettingEventCallbackThenInvalidValueErrorIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenNullCallbackWhenSettingEventCallbackThenInvalidValueErrorIsReturned) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clSetEventCallbackTests, GivenMultipleCallbacksWhenSettingEventCallbackThenSuccessIsReturned) {
TEST_F(ClSetEventCallbackTests, GivenMultipleCallbacksWhenSettingEventCallbackThenSuccessIsReturned) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -94,7 +94,7 @@ TEST_F(clSetEventCallbackTests, GivenMultipleCallbacksWhenSettingEventCallbackTh
event->decRefInternal();
}
TEST_F(clSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteThenCallbackWasInvokedOnce) {
TEST_F(ClSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteThenCallbackWasInvokedOnce) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -102,7 +102,7 @@ TEST_F(clSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteThenC
EXPECT_EQ(cbInvoked, 1);
}
TEST_F(clSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteThenCallbackWasInvokedThreeTimes) {
TEST_F(ClSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteThenCallbackWasInvokedThreeTimes) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -115,7 +115,7 @@ TEST_F(clSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteThen
EXPECT_EQ(cbInvoked, 3);
}
TEST_F(clSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteMultipleTimesThenCallbackWasInvokedOnce) {
TEST_F(ClSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteMultipleTimesThenCallbackWasInvokedOnce) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
event->setStatus(CL_COMPLETE);
@@ -124,7 +124,7 @@ TEST_F(clSetEventCallbackTests, GivenValidCallbackWhenStatusIsSetToCompleteMulti
EXPECT_EQ(cbInvoked, 1);
}
TEST_F(clSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteMultipleTimesThenCallbackWasInvokedThreeTimes) {
TEST_F(ClSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteMultipleTimesThenCallbackWasInvokedThreeTimes) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -139,7 +139,7 @@ TEST_F(clSetEventCallbackTests, GivenThreeCallbacksWhenStatusIsSetToCompleteMult
EXPECT_EQ(cbInvoked, 3);
}
TEST_F(clSetEventCallbackTests, GivenUserDataWhenStatusIsSetToCompleteThenCallbackWasInvokedOnce) {
TEST_F(ClSetEventCallbackTests, GivenUserDataWhenStatusIsSetToCompleteThenCallbackWasInvokedOnce) {
std::unique_ptr<Event> event(new Event(nullptr, 0, 0, 0));
int data = 1;
retVal = clSetEventCallback(event.get(), CL_COMPLETE, eventCallBack, &data);

4
opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl
View File

@@ -18,7 +18,7 @@
using namespace NEO;
class KernelArgSvmFixture : public ApiFixture<> {
class KernelArgSvmApiFixture : public ApiFixture<> {
protected:
void SetUp() override {
ApiFixture::SetUp();
@@ -55,7 +55,7 @@ class KernelArgSvmFixture : public ApiFixture<> {
char pCrossThreadData[64]{};
};
typedef Test<KernelArgSvmFixture> clSetKernelArgSVMPointerTests;
typedef Test<KernelArgSvmApiFixture> clSetKernelArgSVMPointerTests;
namespace ULT {

8
opencl/test/unit_test/api/cl_svm_alloc_tests.inl
View File

@@ -21,7 +21,7 @@ typedef api_tests clSVMAllocTests;
namespace ULT {
class clSVMAllocTemplateTests : public ApiFixture<>,
class ClSvmAllocTemplateTests : public ApiFixture<>,
public testing::TestWithParam<uint64_t /*cl_mem_flags*/> {
public:
void SetUp() override {
@@ -34,7 +34,7 @@ class clSVMAllocTemplateTests : public ApiFixture<>,
}
};
struct clSVMAllocValidFlagsTests : public clSVMAllocTemplateTests {
struct clSVMAllocValidFlagsTests : public ClSvmAllocTemplateTests {
cl_uchar pHostPtr[64];
};
@@ -112,7 +112,7 @@ INSTANTIATE_TEST_CASE_P(
clSVMAllocValidFlagsTests,
testing::ValuesIn(SVMAllocValidFlags));
using clSVMAllocFtrFlagsTests = clSVMAllocTemplateTests;
using clSVMAllocFtrFlagsTests = ClSvmAllocTemplateTests;
INSTANTIATE_TEST_CASE_P(
SVMAllocCheckFlagsFtrFlags,
@@ -151,7 +151,7 @@ TEST_P(clSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAlloc
clSVMFree(pContext, svmPtr);
};
struct clSVMAllocInvalidFlagsTests : public clSVMAllocTemplateTests {
struct clSVMAllocInvalidFlagsTests : public ClSvmAllocTemplateTests {
};
TEST_P(clSVMAllocInvalidFlagsTests, GivenInvalidFlagsWhenAllocatingSvmThenSvmIsNotAllocated) {

12
opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl
View File

@@ -906,7 +906,7 @@ TEST(clUnifiedSharedMemoryTests, whenClEnqueueMemAdviseINTELisCalledWithProperPa
EXPECT_EQ(CL_SUCCESS, retVal);
}
class clUnifiedSharedMemoryEventTests : public CommandQueueHwFixture,
class ClUnifiedSharedMemoryEventTests : public CommandQueueHwFixture,
public ::testing::Test {
public:
void SetUp() override {
@@ -920,7 +920,7 @@ class clUnifiedSharedMemoryEventTests : public CommandQueueHwFixture,
cl_event event = nullptr;
};
TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMigrateMemINTELIsCalledWithEventThenProperCmdTypeIsSet) {
TEST_F(ClUnifiedSharedMemoryEventTests, whenClEnqueueMigrateMemINTELIsCalledWithEventThenProperCmdTypeIsSet) {
void *unifiedMemoryAlloc = reinterpret_cast<void *>(0x1234);
auto retVal = clEnqueueMigrateMemINTEL(this->pCmdQ, unifiedMemoryAlloc, 10, 0, 0, nullptr, &event);
@@ -931,7 +931,7 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMigrateMemINTELIsCalledWith
EXPECT_EQ(expectedCmd, actualCmd);
}
TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemAdviseINTELIsCalledWithEventThenProperCmdTypeIsSet) {
TEST_F(ClUnifiedSharedMemoryEventTests, whenClEnqueueMemAdviseINTELIsCalledWithEventThenProperCmdTypeIsSet) {
void *unifiedMemoryAlloc = reinterpret_cast<void *>(0x1234);
auto retVal = clEnqueueMemAdviseINTEL(this->pCmdQ, unifiedMemoryAlloc, 10, 0, 0, nullptr, &event);
@@ -942,7 +942,7 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemAdviseINTELIsCalledWithE
EXPECT_EQ(expectedCmd, actualCmd);
}
TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemcpyINTELIsCalledWithEventThenProperCmdTypeIsSet) {
TEST_F(ClUnifiedSharedMemoryEventTests, whenClEnqueueMemcpyINTELIsCalledWithEventThenProperCmdTypeIsSet) {
const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo();
if (devInfo.svmCapabilities == 0) {
GTEST_SKIP();
@@ -963,7 +963,7 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemcpyINTELIsCalledWithEven
clMemFreeINTEL(this->context, unifiedMemorySrc);
}
TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemsetINTELIsCalledWithEventThenProperCmdTypeIsSet) {
TEST_F(ClUnifiedSharedMemoryEventTests, whenClEnqueueMemsetINTELIsCalledWithEventThenProperCmdTypeIsSet) {
const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo();
if (devInfo.svmCapabilities == 0) {
GTEST_SKIP();
@@ -982,7 +982,7 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemsetINTELIsCalledWithEven
clMemFreeINTEL(this->context, unifiedMemorySharedAllocation);
}
TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemFillINTELIsCalledWithEventThenProperCmdTypeIsSet) {
TEST_F(ClUnifiedSharedMemoryEventTests, whenClEnqueueMemFillINTELIsCalledWithEventThenProperCmdTypeIsSet) {
const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo();
if (devInfo.svmCapabilities == 0) {
GTEST_SKIP();

6
opencl/test/unit_test/aub_tests/fixtures/multicontext_aub_fixture.cpp
View File

@@ -175,7 +175,7 @@ void MulticontextAubFixture::overridePlatformConfigForAllEnginesSupport(Hardware
#ifdef SUPPORT_XE_HP_SDV
if (localHwInfo.platform.eProductFamily == IGFX_XE_HP_SDV) {
setupCalled = true;
XE_HP_SDV_CONFIG::setupHardwareInfo(&localHwInfo, true);
XehpSdvHwConfig::setupHardwareInfo(&localHwInfo, true);
// Mock values
localHwInfo.gtSystemInfo.SliceCount = 8;
@@ -195,7 +195,7 @@ void MulticontextAubFixture::overridePlatformConfigForAllEnginesSupport(Hardware
ASSERT_TRUE(numberOfEnabledTiles == 1);
setupCalled = true;
DG2_CONFIG::setupHardwareInfo(&localHwInfo, true);
Dg2HwConfig::setupHardwareInfo(&localHwInfo, true);
// Mock values
localHwInfo.gtSystemInfo.SliceCount = 8;
@@ -214,7 +214,7 @@ void MulticontextAubFixture::overridePlatformConfigForAllEnginesSupport(Hardware
if (localHwInfo.platform.eProductFamily == IGFX_PVC) {
setupCalled = true;
PVC_CONFIG::setupHardwareInfo(&localHwInfo, true);
PvcHwConfig::setupHardwareInfo(&localHwInfo, true);
// Mock values
localHwInfo.gtSystemInfo.SliceCount = 8;

24
opencl/test/unit_test/command_queue/enqueue_waitlist_tests.cpp
View File

@@ -9,23 +9,23 @@
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/mocks/mock_buffer.h"
class clEventWrapper {
class ClEventWrapper {
public:
clEventWrapper() { mMem = NULL; }
clEventWrapper(cl_event mem) { mMem = mem; }
clEventWrapper(const clEventWrapper &rhs) : mMem(rhs.mMem) {
ClEventWrapper() { mMem = NULL; }
ClEventWrapper(cl_event mem) { mMem = mem; }
ClEventWrapper(const ClEventWrapper &rhs) : mMem(rhs.mMem) {
if (mMem != NULL)
clRetainEvent(mMem);
}
~clEventWrapper() {
~ClEventWrapper() {
if (mMem != NULL)
clReleaseEvent(mMem);
}
clEventWrapper &operator=(const cl_event &rhs) {
ClEventWrapper &operator=(const cl_event &rhs) {
mMem = rhs;
return *this;
}
clEventWrapper &operator=(clEventWrapper rhs) {
ClEventWrapper &operator=(ClEventWrapper rhs) {
std::swap(mMem, rhs.mMem);
return *this;
}
@@ -168,11 +168,11 @@ struct EnqueueWaitlistTest : public EnqueueWaitlistFixture,
TEST_P(EnqueueWaitlistTest, GivenCompletedUserEventOnWaitlistWhenWaitingForOutputEventThenOutputEventIsCompleted) {
// Set up a user event, which we use as a gate for the second event
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
ClEventWrapper gateEvent = clCreateUserEvent(context, &error);
testError(error, "Unable to set up user gate event");
// Set up the execution of the action with its actual event
clEventWrapper actualEvent;
ClEventWrapper actualEvent;
// call the function to execute
GetParam()(this, 1, &gateEvent, &actualEvent, false);
@@ -190,11 +190,11 @@ typedef EnqueueWaitlistTest EnqueueWaitlistTestTwoMapEnqueues;
TEST_P(EnqueueWaitlistTestTwoMapEnqueues, GivenCompletedUserEventOnWaitlistWhenWaitingForOutputEventThenOutputEventIsCompleted) {
// Set up a user event, which we use as a gate for the second event
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
ClEventWrapper gateEvent = clCreateUserEvent(context, &error);
testError(error, "Unable to set up user gate event");
// Set up the execution of the action with its actual event
clEventWrapper actualEvent;
ClEventWrapper actualEvent;
// call the function to execute
GetParam()(this, 1, &gateEvent, &actualEvent, false);
@@ -210,7 +210,7 @@ TEST_P(EnqueueWaitlistTestTwoMapEnqueues, GivenCompletedUserEventOnWaitlistWhenW
TEST_P(EnqueueWaitlistTest, GivenCompletedUserEventOnWaitlistWhenFinishingCommandQueueThenSuccessIsReturned) {
// Set up a user event, which we use as a gate for the second event
clEventWrapper gateEvent = clCreateUserEvent(context, &error);
ClEventWrapper gateEvent = clCreateUserEvent(context, &error);
testError(error, "Unable to set up user gate event");
// call the function to execute

18
opencl/test/unit_test/gen11/ehl/linux/dll/device_id_tests_ehl.cpp
View File

@@ -11,15 +11,15 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenEhlSpportedDeviceIdWhenCheckingHwSetupThenItIsCorrect) {
std::array<DeviceDescriptor, 9> expectedDescriptors = {{
{0x4500, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4541, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4551, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4571, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4555, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E51, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E61, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E71, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4E55, &EHL_HW_CONFIG::hwInfo, &EHL_HW_CONFIG::setupHardwareInfo},
{0x4500, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4541, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4551, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4571, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4555, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4E51, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4E61, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4E71, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
{0x4E55, &EhlHwConfig::hwInfo, &EhlHwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

16
opencl/test/unit_test/gen11/icllp/linux/dll/device_id_tests_icllp.cpp
View File

@@ -11,16 +11,16 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenIcllpSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0xFF05, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0x8A56, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0x8A58, &ICLLP_1x4x8::hwInfo, &ICLLP_1x4x8::setupHardwareInfo},
{0xFF05, &IcllpHw1x4x8::hwInfo, &IcllpHw1x4x8::setupHardwareInfo},
{0x8A56, &IcllpHw1x4x8::hwInfo, &IcllpHw1x4x8::setupHardwareInfo},
{0x8A58, &IcllpHw1x4x8::hwInfo, &IcllpHw1x4x8::setupHardwareInfo},
{0x8A5C, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo},
{0x8A5A, &ICLLP_1x6x8::hwInfo, &ICLLP_1x6x8::setupHardwareInfo},
{0x8A5C, &IcllpHw1x6x8::hwInfo, &IcllpHw1x6x8::setupHardwareInfo},
{0x8A5A, &IcllpHw1x6x8::hwInfo, &IcllpHw1x6x8::setupHardwareInfo},
{0x8A50, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
{0x8A52, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
{0x8A51, &ICLLP_1x8x8::hwInfo, &ICLLP_1x8x8::setupHardwareInfo},
{0x8A50, &IcllpHw1x8x8::hwInfo, &IcllpHw1x8x8::setupHardwareInfo},
{0x8A52, &IcllpHw1x8x8::hwInfo, &IcllpHw1x8x8::setupHardwareInfo},
{0x8A51, &IcllpHw1x8x8::hwInfo, &IcllpHw1x8x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

2
opencl/test/unit_test/gen11/lkf/linux/dll/device_id_tests_lkf.cpp
View File

@@ -11,7 +11,7 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenLkfSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 1> expectedDescriptors = {{
{0x9840, &LKF_1x8x8::hwInfo, &LKF_1x8x8::setupHardwareInfo},
{0x9840, &LkfHw1x8x8::hwInfo, &LkfHw1x8x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

2
opencl/test/unit_test/gen12lp/adln/linux/dll/device_id_tests_adln.cpp
View File

@@ -15,7 +15,7 @@ using namespace NEO;
TEST(AdlnDeviceIdTest, GivenSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 1> expectedDescriptors = {{
{0x46D0, &ADLN_CONFIG::hwInfo, &ADLN_CONFIG::setupHardwareInfo},
{0x46D0, &AdlnHwConfig::hwInfo, &AdlnHwConfig::setupHardwareInfo},
}};
auto compareStructs = [](const DeviceDescriptor *first, const DeviceDescriptor *second) {

48
opencl/test/unit_test/gen12lp/adlp/linux/dll/device_id_tests_adlp.cpp
View File

@@ -11,30 +11,30 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenAdlpSupportedDeviceIdThenDeviceDescriptorTableExists) {
std::array<DeviceDescriptor, 24> expectedDescriptors = {{
{0x46A0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A6, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A8, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46AA, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x462A, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x4626, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x4628, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46B3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C2, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46C3, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA7A0, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA720, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA7A8, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA7A1, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA721, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0xA7A9, &ADLP_CONFIG::hwInfo, &ADLP_CONFIG::setupHardwareInfo},
{0x46A0, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46B0, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46A1, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46A2, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46A3, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46A6, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46A8, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46AA, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x462A, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x4626, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x4628, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46B1, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46B2, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46B3, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46C0, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46C1, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46C2, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0x46C3, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA7A0, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA720, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA7A8, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA7A1, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA721, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
{0xA7A9, &AdlpHwConfig::hwInfo, &AdlpHwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

26
opencl/test/unit_test/gen12lp/adls/linux/dll/device_id_tests_adls.cpp
View File

@@ -11,19 +11,19 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenAdlsSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 13> expectedDescriptors = {{
{0x4680, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4682, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4688, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x468A, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4690, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4692, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4693, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA780, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA781, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA782, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA783, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA788, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0xA789, &ADLS_HW_CONFIG::hwInfo, &ADLS_HW_CONFIG::setupHardwareInfo},
{0x4680, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x4682, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x4688, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x468A, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x4690, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x4692, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0x4693, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA780, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA781, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA782, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA783, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA788, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
{0xA789, &AdlsHwConfig::hwInfo, &AdlsHwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

2
opencl/test/unit_test/gen12lp/dg1/hw_info_tests_dg1.cpp
View File

@@ -15,7 +15,7 @@ using namespace NEO;
template <typename T>
class Dg1HwInfoTests : public ::testing::Test {};
typedef ::testing::Types<DG1_CONFIG> dg1TestTypes;
typedef ::testing::Types<Dg1HwConfig> dg1TestTypes;
TYPED_TEST_CASE(Dg1HwInfoTests, dg1TestTypes);
TYPED_TEST(Dg1HwInfoTests, WhenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrFalseIsCalledThenFeatureTableHasCorrectValueOfLocalMemoryFeature) {

8
opencl/test/unit_test/gen12lp/dg1/linux/dll/device_id_tests_dg1.cpp
View File

@@ -10,10 +10,10 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenDg1SupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 4> expectedDescriptors = {{
{0x4905, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4906, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4907, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4908, &DG1_CONFIG::hwInfo, &DG1_CONFIG::setupHardwareInfo},
{0x4905, &Dg1HwConfig::hwInfo, &Dg1HwConfig::setupHardwareInfo},
{0x4906, &Dg1HwConfig::hwInfo, &Dg1HwConfig::setupHardwareInfo},
{0x4907, &Dg1HwConfig::hwInfo, &Dg1HwConfig::setupHardwareInfo},
{0x4908, &Dg1HwConfig::hwInfo, &Dg1HwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

12
opencl/test/unit_test/gen12lp/rkl/linux/dll/device_id_tests_rkl.cpp
View File

@@ -10,12 +10,12 @@
using namespace NEO;
TEST_F(DeviceIdTests, GivenRklSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 6> expectedDescriptors = {{{0x4C80, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8B, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C8C, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C90, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo},
{0x4C9A, &RKL_HW_CONFIG::hwInfo, &RKL_HW_CONFIG::setupHardwareInfo}}};
std::array<DeviceDescriptor, 6> expectedDescriptors = {{{0x4C80, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo},
{0x4C8A, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo},
{0x4C8B, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo},
{0x4C8C, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo},
{0x4C90, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo},
{0x4C9A, &RklHwConfig::hwInfo, &RklHwConfig::setupHardwareInfo}}};
testImpl(expectedDescriptors);
}

16
opencl/test/unit_test/gen12lp/tgllp/linux/dll/device_id_tests_tgllp.cpp
View File

@@ -11,14 +11,14 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenTgllpSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0xFF20, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A49, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A40, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A59, &TGLLP_1x6x16::hwInfo, &TGLLP_1x6x16::setupHardwareInfo},
{0x9A60, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A68, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A70, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0x9A78, &TGLLP_1x2x16::hwInfo, &TGLLP_1x2x16::setupHardwareInfo},
{0xFF20, &TgllpHw1x6x16::hwInfo, &TgllpHw1x6x16::setupHardwareInfo},
{0x9A49, &TgllpHw1x6x16::hwInfo, &TgllpHw1x6x16::setupHardwareInfo},
{0x9A40, &TgllpHw1x6x16::hwInfo, &TgllpHw1x6x16::setupHardwareInfo},
{0x9A59, &TgllpHw1x6x16::hwInfo, &TgllpHw1x6x16::setupHardwareInfo},
{0x9A60, &TgllpHw1x2x16::hwInfo, &TgllpHw1x2x16::setupHardwareInfo},
{0x9A68, &TgllpHw1x2x16::hwInfo, &TgllpHw1x2x16::setupHardwareInfo},
{0x9A70, &TgllpHw1x2x16::hwInfo, &TgllpHw1x2x16::setupHardwareInfo},
{0x9A78, &TgllpHw1x2x16::hwInfo, &TgllpHw1x2x16::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

32
opencl/test/unit_test/gen8/bdw/linux/dll/device_id_tests_bdw.cpp
View File

@@ -11,24 +11,24 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenBdwSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 16> expectedDescriptors = {{
{0x1602, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160A, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x1606, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160E, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x160D, &BDW_1x2x6::hwInfo, &BDW_1x2x6::setupHardwareInfo},
{0x1602, &BdwHw1x2x6::hwInfo, &BdwHw1x2x6::setupHardwareInfo},
{0x160A, &BdwHw1x2x6::hwInfo, &BdwHw1x2x6::setupHardwareInfo},
{0x1606, &BdwHw1x2x6::hwInfo, &BdwHw1x2x6::setupHardwareInfo},
{0x160E, &BdwHw1x2x6::hwInfo, &BdwHw1x2x6::setupHardwareInfo},
{0x160D, &BdwHw1x2x6::hwInfo, &BdwHw1x2x6::setupHardwareInfo},
{0x1612, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161A, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x1616, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161E, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x161D, &BDW_1x3x8::hwInfo, &BDW_1x3x8::setupHardwareInfo},
{0x1612, &BdwHw1x3x8::hwInfo, &BdwHw1x3x8::setupHardwareInfo},
{0x161A, &BdwHw1x3x8::hwInfo, &BdwHw1x3x8::setupHardwareInfo},
{0x1616, &BdwHw1x3x8::hwInfo, &BdwHw1x3x8::setupHardwareInfo},
{0x161E, &BdwHw1x3x8::hwInfo, &BdwHw1x3x8::setupHardwareInfo},
{0x161D, &BdwHw1x3x8::hwInfo, &BdwHw1x3x8::setupHardwareInfo},
{0x1622, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162A, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x1626, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162B, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162E, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x162D, &BDW_2x3x8::hwInfo, &BDW_2x3x8::setupHardwareInfo},
{0x1622, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
{0x162A, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
{0x1626, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
{0x162B, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
{0x162E, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
{0x162D, &BdwHw2x3x8::hwInfo, &BdwHw2x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

16
opencl/test/unit_test/gen9/bxt/linux/dll/device_id_tests.cpp
View File

@@ -11,14 +11,14 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenBxtSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0x9906, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x9907, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x0A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x5A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x5A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo},
{0x1A85, &BXT_1x2x6::hwInfo, &BXT_1x2x6::setupHardwareInfo},
{0x1A84, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x9908, &BXT_1x3x6::hwInfo, &BXT_1x3x6::setupHardwareInfo},
{0x9906, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
{0x9907, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
{0x0A84, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
{0x5A84, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
{0x5A85, &BxtHw1x2x6::hwInfo, &BxtHw1x2x6::setupHardwareInfo},
{0x1A85, &BxtHw1x2x6::hwInfo, &BxtHw1x2x6::setupHardwareInfo},
{0x1A84, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
{0x9908, &BxtHw1x3x6::hwInfo, &BxtHw1x3x6::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

84
opencl/test/unit_test/gen9/cfl/linux/dll/device_id_tests_cfl.cpp
View File

@@ -11,51 +11,51 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenCflSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 42> expectedDescriptors = {{
{0x3E90, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E93, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3EA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E99, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3EA1, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x3E90, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x3E93, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x3EA4, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x3E99, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x3EA1, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x3E92, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E9B, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E94, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E91, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E96, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E9A, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA3, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA9, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3EA0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E98, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x3E92, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E9B, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E94, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E91, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E96, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E9A, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3EA3, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3EA9, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3EA0, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E98, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x3E95, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA6, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA7, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA8, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA5, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3EA2, &CFL_2x3x8::hwInfo, &CFL_2x3x8::setupHardwareInfo},
{0x3E95, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x3EA6, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x3EA7, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x3EA8, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x3EA5, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x3EA2, &CflHw2x3x8::hwInfo, &CflHw2x3x8::setupHardwareInfo},
{0x9B21, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAA, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAB, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BAC, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA0, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA5, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA8, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA4, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9BA2, &CFL_1x2x6::hwInfo, &CFL_1x2x6::setupHardwareInfo},
{0x9B41, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCA, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCB, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BCC, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC0, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC5, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC8, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC4, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC2, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BC6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BE6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9BF6, &CFL_1x3x8::hwInfo, &CFL_1x3x8::setupHardwareInfo},
{0x9B21, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BAA, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BAB, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BAC, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BA0, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BA5, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BA8, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BA4, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9BA2, &CflHw1x2x6::hwInfo, &CflHw1x2x6::setupHardwareInfo},
{0x9B41, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BCA, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BCB, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BCC, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC0, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC5, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC8, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC4, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC2, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BC6, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BE6, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
{0x9BF6, &CflHw1x3x8::hwInfo, &CflHw1x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

4
opencl/test/unit_test/gen9/glk/linux/dll/device_id_tests_glk.cpp
View File

@@ -11,8 +11,8 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenGlkSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 2> expectedDescriptors = {{
{0x3184, &GLK_1x3x6::hwInfo, &GLK_1x3x6::setupHardwareInfo},
{0x3185, &GLK_1x2x6::hwInfo, &GLK_1x2x6::setupHardwareInfo},
{0x3184, &GlkHw1x3x6::hwInfo, &GlkHw1x3x6::setupHardwareInfo},
{0x3185, &GlkHw1x2x6::hwInfo, &GlkHw1x2x6::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

52
opencl/test/unit_test/gen9/kbl/linux/dll/device_id_tests_kbl.cpp
View File

@@ -11,36 +11,36 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenKblSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 26> expectedDescriptors = {{
{0x5902, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590B, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590A, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5906, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x590E, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo},
{0x5908, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5902, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x590B, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x590A, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x5906, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x590E, &KblHw1x3x6::hwInfo, &KblHw1x3x6::setupHardwareInfo},
{0x5908, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x5913, &KBL_1x3x6::hwInfo, &KBL_1x3x6::setupHardwareInfo},
{0x5915, &KBL_1x2x6::hwInfo, &KBL_1x2x6::setupHardwareInfo},
{0x5913, &KblHw1x3x6::hwInfo, &KblHw1x3x6::setupHardwareInfo},
{0x5915, &KblHw1x2x6::hwInfo, &KblHw1x2x6::setupHardwareInfo},
{0x5912, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591B, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5917, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591A, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5916, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591E, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591D, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x591C, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5921, &KBL_1x3x8::hwInfo, &KBL_1x3x8::setupHardwareInfo},
{0x5912, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x591B, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x5917, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x591A, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x5916, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x591E, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x591D, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x591C, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x5921, &KblHw1x3x8::hwInfo, &KblHw1x3x8::setupHardwareInfo},
{0x5926, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5927, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x592B, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x592A, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5923, &KBL_2x3x8::hwInfo, &KBL_2x3x8::setupHardwareInfo},
{0x5926, &KblHw2x3x8::hwInfo, &KblHw2x3x8::setupHardwareInfo},
{0x5927, &KblHw2x3x8::hwInfo, &KblHw2x3x8::setupHardwareInfo},
{0x592B, &KblHw2x3x8::hwInfo, &KblHw2x3x8::setupHardwareInfo},
{0x592A, &KblHw2x3x8::hwInfo, &KblHw2x3x8::setupHardwareInfo},
{0x5923, &KblHw2x3x8::hwInfo, &KblHw2x3x8::setupHardwareInfo},
{0x5932, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593B, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593A, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x593D, &KBL_3x3x8::hwInfo, &KBL_3x3x8::setupHardwareInfo},
{0x5932, &KblHw3x3x8::hwInfo, &KblHw3x3x8::setupHardwareInfo},
{0x593B, &KblHw3x3x8::hwInfo, &KblHw3x3x8::setupHardwareInfo},
{0x593A, &KblHw3x3x8::hwInfo, &KblHw3x3x8::setupHardwareInfo},
{0x593D, &KblHw3x3x8::hwInfo, &KblHw3x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

52
opencl/test/unit_test/gen9/skl/linux/dll/device_id_tests_skl.cpp
View File

@@ -11,36 +11,36 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenSklSupportedDeviceIdThenHardwareInfoIsCorrect) {
std::array<DeviceDescriptor, 26> expectedDescriptors = {{
{0x1902, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190B, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190A, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x1906, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x190E, &SKL_1x2x6::hwInfo, &SKL_1x2x6::setupHardwareInfo},
{0x1902, &SklHw1x2x6::hwInfo, &SklHw1x2x6::setupHardwareInfo},
{0x190B, &SklHw1x2x6::hwInfo, &SklHw1x2x6::setupHardwareInfo},
{0x190A, &SklHw1x2x6::hwInfo, &SklHw1x2x6::setupHardwareInfo},
{0x1906, &SklHw1x2x6::hwInfo, &SklHw1x2x6::setupHardwareInfo},
{0x190E, &SklHw1x2x6::hwInfo, &SklHw1x2x6::setupHardwareInfo},
{0x1917, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1913, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1915, &SKL_1x3x6::hwInfo, &SKL_1x3x6::setupHardwareInfo},
{0x1917, &SklHw1x3x6::hwInfo, &SklHw1x3x6::setupHardwareInfo},
{0x1913, &SklHw1x3x6::hwInfo, &SklHw1x3x6::setupHardwareInfo},
{0x1915, &SklHw1x3x6::hwInfo, &SklHw1x3x6::setupHardwareInfo},
{0x1912, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191B, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191A, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x1916, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191E, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x191D, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x1921, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x9905, &SKL_1x3x8::hwInfo, &SKL_1x3x8::setupHardwareInfo},
{0x1912, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x191B, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x191A, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x1916, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x191E, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x191D, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x1921, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x9905, &SklHw1x3x8::hwInfo, &SklHw1x3x8::setupHardwareInfo},
{0x192B, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x192D, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x192A, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1923, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1926, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x1927, &SKL_2x3x8::hwInfo, &SKL_2x3x8::setupHardwareInfo},
{0x192B, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x192D, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x192A, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x1923, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x1926, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x1927, &SklHw2x3x8::hwInfo, &SklHw2x3x8::setupHardwareInfo},
{0x1932, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193B, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193A, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x193D, &SKL_3x3x8::hwInfo, &SKL_3x3x8::setupHardwareInfo},
{0x1932, &SklHw3x3x8::hwInfo, &SklHw3x3x8::setupHardwareInfo},
{0x193B, &SklHw3x3x8::hwInfo, &SklHw3x3x8::setupHardwareInfo},
{0x193A, &SklHw3x3x8::hwInfo, &SklHw3x3x8::setupHardwareInfo},
{0x193D, &SklHw3x3x8::hwInfo, &SklHw3x3x8::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

6
opencl/test/unit_test/helpers/hw_helper_tests.cpp
View File

@@ -102,18 +102,18 @@ HWTEST_F(HwHelperTest, givenForceExtendedKernelIsaSizeSetWhenGettingISAPaddingTh
HWTEST_F(HwHelperTest, WhenSettingRenderSurfaceStateForBufferThenL1CachePolicyIsSet) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
class mockHwHelperHw : public HwHelperHw<FamilyType> {
class MockHwHelperHw : public HwHelperHw<FamilyType> {
public:
bool called = false;
using HwHelperHw<FamilyType>::HwHelperHw;
mockHwHelperHw() {}
MockHwHelperHw() {}
void setL1CachePolicy(bool useL1Cache, typename FamilyType::RENDER_SURFACE_STATE *surfaceState, const HardwareInfo *hwInfo) override {
HwHelperHw<FamilyType>::setL1CachePolicy(useL1Cache, surfaceState, hwInfo);
called = true;
}
};
mockHwHelperHw helper;
MockHwHelperHw helper;
void *stateBuffer = alignedMalloc(sizeof(RENDER_SURFACE_STATE), sizeof(RENDER_SURFACE_STATE));
ASSERT_NE(nullptr, stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));

6
opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp
View File

@@ -23,12 +23,12 @@
using namespace NEO;
class KernelArgSvmFixture_ : public ContextFixture, public ClDeviceFixture {
class KernelArgSvmFixture : public ContextFixture, public ClDeviceFixture {
using ContextFixture::SetUp;
public:
KernelArgSvmFixture_() {
KernelArgSvmFixture() {
}
protected:
@@ -70,7 +70,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public ClDeviceFixture {
char pCrossThreadData[64];
};
typedef Test<KernelArgSvmFixture_> KernelArgSvmTest;
typedef Test<KernelArgSvmFixture> KernelArgSvmTest;
TEST_F(KernelArgSvmTest, GivenValidSvmPtrWhenSettingKernelArgThenSvmPtrIsCorrect) {
char *svmPtr = new char[256];

8
opencl/test/unit_test/xe_hp_core/xehp/hw_info_tests_xehp.inl
View File

@@ -33,7 +33,7 @@ XEHPTEST_F(XeHPHwInfoTest, whenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrF
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_EQ(8u, gtSystemInfo.CsrSizeInMb);
XE_HP_SDV_CONFIG::setupHardwareInfo(&hwInfo, false);
XehpSdvHwConfig::setupHardwareInfo(&hwInfo, false);
EXPECT_FALSE(featureTable.flags.ftrLocalMemory);
EXPECT_FALSE(featureTable.flags.ftrFlatPhysCCS);
EXPECT_FALSE(featureTable.flags.ftrLinearCCS);
@@ -47,7 +47,7 @@ XEHPTEST_F(XeHPHwInfoTest, whenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrF
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_EQ(8u, gtSystemInfo.CsrSizeInMb);
XE_HP_SDV_CONFIG::setupHardwareInfo(&hwInfo, true);
XehpSdvHwConfig::setupHardwareInfo(&hwInfo, true);
EXPECT_TRUE(featureTable.flags.ftrLocalMemory);
EXPECT_TRUE(featureTable.flags.ftrFlatPhysCCS);
EXPECT_TRUE(featureTable.flags.ftrLinearCCS);
@@ -67,13 +67,13 @@ XEHPTEST_F(XeHPHwInfoTest, givenAlreadyInitializedHwInfoWhenSetupCalledThenDontO
hwInfo.gtSystemInfo.SliceCount = 0;
XE_HP_SDV_CONFIG::setupHardwareInfo(&hwInfo, false);
XehpSdvHwConfig::setupHardwareInfo(&hwInfo, false);
EXPECT_NE(0u, hwInfo.gtSystemInfo.SliceCount);
auto expectedValue = ++hwInfo.gtSystemInfo.SliceCount;
XE_HP_SDV_CONFIG::setupHardwareInfo(&hwInfo, false);
XehpSdvHwConfig::setupHardwareInfo(&hwInfo, false);
EXPECT_EQ(expectedValue, hwInfo.gtSystemInfo.SliceCount);
}

32
opencl/test/unit_test/xe_hp_core/xehp/linux/dll/device_id_tests_xehp.cpp
View File

@@ -10,22 +10,22 @@
using namespace NEO;
TEST_F(DeviceIdTests, GivenXeHpSdvSupportedDeviceIdThenConfigIsCorrect) {
std::array<DeviceDescriptor, 16> expectedDescriptors = {{{0x0201, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0202, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0203, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0204, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0205, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0206, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0207, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0208, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0209, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020A, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020B, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020C, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020D, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020E, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x020F, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo},
{0x0210, &XE_HP_SDV_CONFIG::hwInfo, &XE_HP_SDV_CONFIG::setupHardwareInfo}}};
std::array<DeviceDescriptor, 16> expectedDescriptors = {{{0x0201, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0202, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0203, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0204, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0205, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0206, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0207, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0208, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0209, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020A, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020B, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020C, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020D, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020E, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x020F, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo},
{0x0210, &XehpSdvHwConfig::hwInfo, &XehpSdvHwConfig::setupHardwareInfo}}};
testImpl(expectedDescriptors);
}

16
opencl/test/unit_test/xe_hpc_core/pvc/linux/dll/device_id_tests_pvc.cpp
View File

@@ -11,14 +11,14 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenPvcSupportedDeviceIdThenConfigIsCorrect) {
std::array<DeviceDescriptor, 8> expectedDescriptors = {{
{0x0BD0, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD5, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD6, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD7, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD8, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD9, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BDA, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BDB, &PVC_CONFIG::hwInfo, &PVC_CONFIG::setupHardwareInfo},
{0x0BD0, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BD5, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BD6, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BD7, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BD8, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BD9, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BDA, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
{0x0BDB, &PvcHwConfig::hwInfo, &PvcHwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);

40
opencl/test/unit_test/xe_hpg_core/dg2/linux/dll/device_id_tests_dg2.cpp
View File

@@ -11,26 +11,26 @@ using namespace NEO;
TEST_F(DeviceIdTests, GivenDg2SupportedDeviceIdThenDeviceDescriptorTableExists) {
std::array<DeviceDescriptor, 20> expectedDescriptors = {{
{0x4F80, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F81, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F82, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F83, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F84, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F87, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F88, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5690, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5691, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5692, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5693, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5694, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x5695, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A0, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A1, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A2, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A5, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56A6, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56C0, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x56C1, &DG2_CONFIG::hwInfo, &DG2_CONFIG::setupHardwareInfo},
{0x4F80, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F81, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F82, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F83, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F84, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F87, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x4F88, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5690, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5691, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5692, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5693, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5694, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x5695, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56A0, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56A1, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56A2, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56A5, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56A6, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56C0, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
{0x56C1, &Dg2HwConfig::hwInfo, &Dg2HwConfig::setupHardwareInfo},
}};
testImpl(expectedDescriptors);