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

Rename ClHwHelper -> ClGfxCoreHelper

Browse Source 
Related-To: NEO-6853
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>
This commit is contained in:
Kamil Kopryk
2022-11-30 17:06:04 +00:00
committed by Compute-Runtime-Automation
parent 73b2104183
commit 91d39ad5bf
52 changed files with 280 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -337,8 +337,8 @@ HWTEST2_F(clGetDeviceInfoTests, givenClDeviceSupportedThreadArbitrationPolicyInt
}
HWTEST_F(clGetDeviceInfoTests, givenClDeviceSupportedThreadArbitrationPolicyIntelWhenThreadArbitrationPolicyChangeNotSupportedAndCallClGetDeviceInfoThenParamRetSizeIsZero) {
auto &clCoreHelper = this->pDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = this->pDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
cl_device_info paramName = 0;

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

@@ -68,8 +68,8 @@ TEST_F(clSetKernelExecInfoTests, GivenNullKernelWhenSettingAdditionalKernelInfoT
}
TEST_F(clSetKernelExecInfoTests, GivenDeviceNotSupportingSvmWhenSettingKernelExecInfoThenErrorIsReturnedOnSvmRelatedParams) {
auto &clCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (!clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (!clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
auto hwInfo = executionEnvironment->rootDeviceEnvironments[ApiFixture::testedRootDeviceIndex]->getMutableHardwareInfo();
@@ -304,8 +304,8 @@ TEST_F(clSetKernelExecInfoTests, givenNonExistingParamNameWithValuesWhenSettingA
}
HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhenSettingAdditionalKernelInfoThenSuccessIsReturned) {
auto &clCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (!clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (!clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
uint32_t newThreadArbitrationPolicy = CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_ROUND_ROBIN_INTEL;
@@ -321,8 +321,8 @@ HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhe
}
HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhenNotSupportedAndSettingAdditionalKernelInfoThenClInvalidDeviceIsReturned) {
auto &clCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
uint32_t newThreadArbitrationPolicy = CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_ROUND_ROBIN_INTEL;
@@ -337,8 +337,8 @@ HWTEST_F(clSetKernelExecInfoTests, givenKernelExecInfoThreadArbitrationPolicyWhe
}
HWTEST_F(clSetKernelExecInfoTests, givenInvalidThreadArbitrationPolicyWhenSettingAdditionalKernelInfoThenClInvalidValueIsReturned) {
auto &clCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (!clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (!clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
uint32_t invalidThreadArbitrationPolicy = 0;

4
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@@ -1817,8 +1817,8 @@ TEST_F(CsrSelectionCommandQueueWithBlitterTests, givenBlitterPresentAndLocalToLo
DebugManagerStateRestore restore{};
DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
auto &clCoreHelper = clDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
const bool hwPreference = clCoreHelper.preferBlitterForLocalToLocalTransfers();
auto &clGfxCoreHelper = clDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
const bool hwPreference = clGfxCoreHelper.preferBlitterForLocalToLocalTransfers();
const auto &hwPreferenceCsr = hwPreference ? *queue->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS) : queue->getGpgpuCommandStreamReceiver();
BuiltinOpParams builtinOpParams{};

8
opencl/test/unit_test/command_queue/enqueue_handler_tests.cpp
View File

@@ -586,8 +586,8 @@ HWTEST_F(EnqueueHandlerTest, givenEnqueueHandlerWhenSubCaptureIsOnThenActivateSu
HWTEST_F(EnqueueHandlerTest, givenEnqueueHandlerWhenClSetKernelExecInfoAlreadySetKernelThreadArbitrationPolicyThenRequiredThreadArbitrationPolicyIsSetProperly) {
REQUIRE_SVM_OR_SKIP(pClDevice);
auto &clCoreHelper = pClDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (!clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pClDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (!clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
DebugManagerStateRestore stateRestore;
@@ -623,8 +623,8 @@ HWTEST_F(EnqueueHandlerTest, givenEnqueueHandlerWhenClSetKernelExecInfoAlreadySe
}
HWTEST_F(EnqueueHandlerTest, givenEnqueueHandlerWhenNotSupportedPolicyChangeThenRequiredThreadArbitrationPolicyNotChangedAndIsSetAsDefault) {
auto &clCoreHelper = pClDevice->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = pClDevice->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}
DebugManagerStateRestore stateRestore;

16
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@@ -1475,7 +1475,7 @@ HWTEST_F(QueueFamilyNameTest, givenInvalidEngineGroupWhenGettingQueueFamilyNameT
}
HWTEST_F(QueueFamilyNameTest, givenTooBigQueueFamilyNameWhenGettingQueueFamilyNameThenExceptionIsThrown) {
struct MockClHwHelper : NEO::ClHwHelperHw<FamilyType> {
struct MockClGfxCoreHelper : NEO::ClGfxCoreHelperHw<FamilyType> {
bool getQueueFamilyName(std::string &name, EngineGroupType type) const override {
name = familyNameOverride;
return true;
@@ -1483,18 +1483,18 @@ HWTEST_F(QueueFamilyNameTest, givenTooBigQueueFamilyNameWhenGettingQueueFamilyNa
std::string familyNameOverride = "";
};
MockClHwHelper clHwHelper{};
VariableBackup<ClHwHelper *> clHwHelperFactoryBackup{
&NEO::clHwHelperFactory[static_cast<size_t>(defaultHwInfo->platform.eRenderCoreFamily)]};
clHwHelperFactoryBackup = &clHwHelper;
MockClGfxCoreHelper clGfxCoreHelper{};
VariableBackup<ClGfxCoreHelper *> clGfxCoreHelperFactoryBackup{
&NEO::clGfxCoreHelperFactory[static_cast<size_t>(defaultHwInfo->platform.eRenderCoreFamily)]};
clGfxCoreHelperFactoryBackup = &clGfxCoreHelper;
char name[CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL] = "";
clHwHelper.familyNameOverride = std::string(CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL - 1, 'a');
clGfxCoreHelper.familyNameOverride = std::string(CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL - 1, 'a');
device->getQueueFamilyName(name, EngineGroupType::MaxEngineGroups);
EXPECT_EQ(0, std::strcmp(name, clHwHelper.familyNameOverride.c_str()));
EXPECT_EQ(0, std::strcmp(name, clGfxCoreHelper.familyNameOverride.c_str()));
clHwHelper.familyNameOverride = std::string(CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL, 'a');
clGfxCoreHelper.familyNameOverride = std::string(CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL, 'a');
EXPECT_ANY_THROW(device->getQueueFamilyName(name, EngineGroupType::MaxEngineGroups));
}

8
opencl/test/unit_test/device/get_device_info_tests.cpp
View File

@@ -1084,8 +1084,8 @@ struct DeviceAttributeQueryTest : public ::testing::TestWithParam<uint32_t /*cl_
case CL_DEVICE_IP_VERSION_INTEL: {
auto pDeviceIpVersion = reinterpret_cast<cl_version *>(object.get());
auto &hwInfo = device.getHardwareInfo();
auto &clCoreHelper = device.getRootDeviceEnvironment().getHelper<ClCoreHelper>();
EXPECT_EQ(clCoreHelper.getDeviceIpVersion(hwInfo), *pDeviceIpVersion);
auto &clGfxCoreHelper = device.getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
EXPECT_EQ(clGfxCoreHelper.getDeviceIpVersion(hwInfo), *pDeviceIpVersion);
EXPECT_EQ(sizeof(cl_version), sizeReturned);
break;
}
@@ -1126,8 +1126,8 @@ struct DeviceAttributeQueryTest : public ::testing::TestWithParam<uint32_t /*cl_
case CL_DEVICE_FEATURE_CAPABILITIES_INTEL: {
auto pCapabilities = reinterpret_cast<cl_device_feature_capabilities_intel *>(object.get());
auto &hwInfo = device.getHardwareInfo();
auto &clCoreHelper = device.getRootDeviceEnvironment().getHelper<ClCoreHelper>();
EXPECT_EQ(clCoreHelper.getSupportedDeviceFeatureCapabilities(hwInfo), *pCapabilities);
auto &clGfxCoreHelper = device.getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
EXPECT_EQ(clGfxCoreHelper.getSupportedDeviceFeatureCapabilities(hwInfo), *pCapabilities);
EXPECT_EQ(sizeof(cl_device_feature_capabilities_intel), sizeReturned);
break;
}

2
opencl/test/unit_test/fixtures/cl_device_fixture.cpp
View File

@@ -56,5 +56,5 @@ HelperType &ClDeviceFixture::getHelper() const {
template ProductHelper &ClDeviceFixture::getHelper() const;
template CoreHelper &ClDeviceFixture::getHelper() const;
template ClCoreHelper &ClDeviceFixture::getHelper() const;
template ClGfxCoreHelper &ClDeviceFixture::getHelper() const;
} // namespace NEO

14
opencl/test/unit_test/gen11/cl_hw_helper_tests_gen11.cpp
View File

@@ -13,14 +13,14 @@
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_hw_helper.h"
using ClHwHelperTestGen11 = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestGen11 = Test<ClDeviceFixture>;
GEN11TEST_F(ClHwHelperTestGen11, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(11, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
GEN11TEST_F(ClGfxCoreHelperTestGen11, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(11, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
GEN11TEST_F(ClHwHelperTestGen11, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(0u, clCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
GEN11TEST_F(ClGfxCoreHelperTestGen11, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(0u, clGfxCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
}

42
opencl/test/unit_test/gen12lp/hw_helper_tests_gen12lp.inl
View File

@@ -20,10 +20,10 @@
#include "aubstream/engine_node.h"
using ClHwHelperTestsGen12Lp = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestsGen12Lp = Test<ClDeviceFixture>;
GEN12LPTEST_F(ClHwHelperTestsGen12Lp, givenTglLpThenAuxTranslationIsRequired) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
GEN12LPTEST_F(ClGfxCoreHelperTestsGen12Lp, givenTglLpThenAuxTranslationIsRequired) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto accessedUsingStatelessAddressingMode : {true, false}) {
KernelInfo kernelInfo{};
@@ -32,38 +32,38 @@ GEN12LPTEST_F(ClHwHelperTestsGen12Lp, givenTglLpThenAuxTranslationIsRequired) {
arg.as<ArgDescPointer>(true).accessedUsingStatelessAddressingMode = accessedUsingStatelessAddressingMode;
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.push_back(std::move(arg));
EXPECT_EQ(accessedUsingStatelessAddressingMode, clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_EQ(accessedUsingStatelessAddressingMode, clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
}
HWTEST2_F(ClHwHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsTGLLP) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
HWTEST2_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsTGLLP) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
HWTEST2_F(ClHwHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsRKL) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
HWTEST2_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsRKL) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
HWTEST2_F(ClHwHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsADLS) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
HWTEST2_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsADLS) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
HWTEST2_F(ClHwHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsADLP) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
HWTEST2_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsADLP) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
HWTEST2_F(ClHwHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsDG1) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 0, 1), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
HWTEST2_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion, IsDG1) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 0, 1), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
GEN12LPTEST_F(ClHwHelperTestsGen12Lp, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
GEN12LPTEST_F(ClGfxCoreHelperTestsGen12Lp, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
cl_device_feature_capabilities_intel expectedCapabilities = CL_DEVICE_FEATURE_FLAG_DP4A_INTEL;
EXPECT_EQ(expectedCapabilities, ClHwHelper::get(renderCoreFamily).getSupportedDeviceFeatureCapabilities(hardwareInfo));
EXPECT_EQ(expectedCapabilities, ClGfxCoreHelper::get(renderCoreFamily).getSupportedDeviceFeatureCapabilities(hardwareInfo));
}
using HwHelperTestGen12Lp = HwHelperTest;

14
opencl/test/unit_test/gen8/cl_hw_helper_tests_gen8.cpp
View File

@@ -16,14 +16,14 @@
#include "opencl/test/unit_test/mocks/mock_cl_hw_helper.h"
using namespace NEO;
using ClHwHelperTestGen8 = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestGen8 = Test<ClDeviceFixture>;
GEN8TEST_F(ClHwHelperTestGen8, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(8, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
GEN8TEST_F(ClGfxCoreHelperTestGen8, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(8, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
GEN8TEST_F(ClHwHelperTestGen8, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(0u, clCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
GEN8TEST_F(ClGfxCoreHelperTestGen8, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(0u, clGfxCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
}

14
opencl/test/unit_test/gen9/cl_hw_helper_tests_gen9.cpp
View File

@@ -12,14 +12,14 @@
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_hw_helper.h"
using ClHwHelperTestGen9 = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestGen9 = Test<ClDeviceFixture>;
GEN9TEST_F(ClHwHelperTestGen9, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(9, 0, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
GEN9TEST_F(ClGfxCoreHelperTestGen9, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(9, 0, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
GEN9TEST_F(ClHwHelperTestGen9, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(0u, clCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
GEN9TEST_F(ClGfxCoreHelperTestGen9, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(0u, clGfxCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
}

22
opencl/test/unit_test/helpers/cl_helper_tests.cpp
View File

@@ -107,33 +107,33 @@ HWTEST_F(HwHelperTest, givenHwHelperWhenIsLinearStoragePreferredThenReturnValidV
}
}
using ClHwHelperTest = Test<ClDeviceFixture>;
HWTEST_F(ClHwHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
using ClGfxCoreHelperTest = Test<ClDeviceFixture>;
HWTEST_F(ClGfxCoreHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
KernelInfo kernelInfo{};
ArgDescriptor argDescriptorValue(ArgDescriptor::ArgType::ArgTValue);
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptorValue);
EXPECT_FALSE(clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
ArgDescriptor argDescriptorPointer(ArgDescriptor::ArgType::ArgTPointer);
argDescriptorPointer.as<ArgDescPointer>().accessedUsingStatelessAddressingMode = true;
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.push_back(argDescriptorPointer);
EXPECT_TRUE(clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_TRUE(clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
TEST_F(ClHwHelperTest, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
TEST_F(ClGfxCoreHelperTest, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : {false, true}) {
ArgDescPointer argAsPtr{};
argAsPtr.accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_EQ(!argAsPtr.isPureStateful(), clCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
EXPECT_EQ(!argAsPtr.isPureStateful(), clGfxCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
}
}
HWCMDTEST_F(IGFX_GEN8_CORE, ClHwHelperTest, givenCLImageFormatsWhenCallingIsFormatRedescribableThenCorrectValueReturned) {
HWCMDTEST_F(IGFX_GEN8_CORE, ClGfxCoreHelperTest, givenCLImageFormatsWhenCallingIsFormatRedescribableThenCorrectValueReturned) {
static const cl_image_format redescribeFormats[] = {
{CL_R, CL_UNSIGNED_INT8},
{CL_R, CL_UNSIGNED_INT16},
@@ -142,7 +142,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ClHwHelperTest, givenCLImageFormatsWhenCallingIsForm
{CL_RGBA, CL_UNSIGNED_INT32},
};
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
auto formats = SurfaceFormats::readWrite();
for (const auto &format : formats) {
const cl_image_format oclFormat = format.OCLImageFormat;
@@ -150,6 +150,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ClHwHelperTest, givenCLImageFormatsWhenCallingIsForm
for (const auto &nonRedescribableFormat : redescribeFormats) {
expectedResult &= (memcmp(&oclFormat, &nonRedescribableFormat, sizeof(cl_image_format)) != 0);
}
EXPECT_EQ(expectedResult, clCoreHelper.isFormatRedescribable(oclFormat));
EXPECT_EQ(expectedResult, clGfxCoreHelper.isFormatRedescribable(oclFormat));
}
}

14
opencl/test/unit_test/helpers/cl_hw_helper_tests_xehp_and_later.cpp
View File

@@ -12,9 +12,9 @@
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
using ClHwHelperTestXeHpAndLater = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestXeHpAndLater = Test<ClDeviceFixture>;
HWCMDTEST_F(IGFX_XE_HP_CORE, ClHwHelperTestXeHpAndLater, givenCLImageFormatsWhenCallingIsFormatRedescribableThenFalseIsReturned) {
HWCMDTEST_F(IGFX_XE_HP_CORE, ClGfxCoreHelperTestXeHpAndLater, givenCLImageFormatsWhenCallingIsFormatRedescribableThenFalseIsReturned) {
static const cl_image_format redescribeFormats[] = {
{CL_R, CL_UNSIGNED_INT8},
{CL_R, CL_UNSIGNED_INT16},
@@ -23,14 +23,14 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ClHwHelperTestXeHpAndLater, givenCLImageFormatsWhen
{CL_RGBA, CL_UNSIGNED_INT32},
};
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (const auto &format : redescribeFormats) {
EXPECT_EQ(false, clCoreHelper.isFormatRedescribable(format));
EXPECT_EQ(false, clGfxCoreHelper.isFormatRedescribable(format));
}
}
HWTEST2_F(ClHwHelperTestXeHpAndLater, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue, IsAtLeastXeHpCore) {
HWTEST2_F(ClGfxCoreHelperTestXeHpAndLater, WhenGettingSupportedDeviceFeatureCapabilitiesThenReturnCorrectValue, IsAtLeastXeHpCore) {
cl_device_feature_capabilities_intel expectedCapabilities = CL_DEVICE_FEATURE_FLAG_DPAS_INTEL | CL_DEVICE_FEATURE_FLAG_DP4A_INTEL;
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(expectedCapabilities, clCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(expectedCapabilities, clGfxCoreHelper.getSupportedDeviceFeatureCapabilities(*defaultHwInfo));
}

18
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@@ -2540,12 +2540,12 @@ TEST(KernelTest, givenFtrRenderCompressedBuffersWhenInitializingArgsWithNonState
kernel.mockKernel->initialize();
auto &rootDeviceEnvironment = device->getRootDeviceEnvironment();
auto &clCoreHelper = rootDeviceEnvironment.getHelper<ClCoreHelper>();
EXPECT_EQ(clCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment), kernel.mockKernel->isAuxTranslationRequired());
auto &clGfxCoreHelper = rootDeviceEnvironment.getHelper<ClGfxCoreHelper>();
EXPECT_EQ(clGfxCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment), kernel.mockKernel->isAuxTranslationRequired());
DebugManager.flags.ForceAuxTranslationEnabled.set(-1);
kernel.mockKernel->initialize();
EXPECT_EQ(clCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment), kernel.mockKernel->isAuxTranslationRequired());
EXPECT_EQ(clGfxCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment), kernel.mockKernel->isAuxTranslationRequired());
DebugManager.flags.ForceAuxTranslationEnabled.set(0);
kernel.mockKernel->initialize();
@@ -2569,9 +2569,9 @@ TEST(KernelTest, WhenAuxTranslationIsRequiredThenKernelSetsRequiredResolvesInCon
kernel.mockKernel->initialize();
auto &rootDeviceEnvironment = device->getRootDeviceEnvironment();
auto &clCoreHelper = rootDeviceEnvironment.getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = rootDeviceEnvironment.getHelper<ClGfxCoreHelper>();
if (clCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment)) {
if (clGfxCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment)) {
EXPECT_TRUE(context->getResolvesRequiredInKernels());
} else {
EXPECT_FALSE(context->getResolvesRequiredInKernels());
@@ -2615,9 +2615,9 @@ TEST(KernelTest, givenDebugVariableSetWhenKernelHasStatefulBufferAccessThenMarkK
kernel.mockKernel->initialize();
auto &rootDeviceEnvironment = device->getRootDeviceEnvironment();
auto &clCoreHelper = rootDeviceEnvironment.getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = rootDeviceEnvironment.getHelper<ClGfxCoreHelper>();
if (clCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment)) {
if (clGfxCoreHelper.requiresAuxResolves(kernel.kernelInfo, rootDeviceEnvironment)) {
EXPECT_TRUE(kernel.mockKernel->isAuxTranslationRequired());
} else {
EXPECT_FALSE(kernel.mockKernel->isAuxTranslationRequired());
@@ -2857,8 +2857,8 @@ TEST(KernelTest, givenDefaultKernelWhenItIsCreatedThenItReportsStatelessWrites)
TEST(KernelTest, givenPolicyWhensetKernelThreadArbitrationPolicyThenExpectedClValueIsReturned) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto &clCoreHelper = device->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
if (!clCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
auto &clGfxCoreHelper = device->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
if (!clGfxCoreHelper.isSupportedKernelThreadArbitrationPolicy()) {
GTEST_SKIP();
}

4
opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp
View File

@@ -1325,8 +1325,8 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenDebugFlagSetToOneWhenEnqueueingCopyLocal
srcGraphicsAllocation.memoryPool = MemoryPool::LocalMemory;
dstGraphicsAllocation.memoryPool = MemoryPool::LocalMemory;
auto &clCoreHelper = this->device->getRootDeviceEnvironment().getHelper<ClCoreHelper>();
const bool preferBlitterHw = clCoreHelper.preferBlitterForLocalToLocalTransfers();
auto &clGfxCoreHelper = this->device->getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
const bool preferBlitterHw = clGfxCoreHelper.preferBlitterForLocalToLocalTransfers();
uint32_t expectedBlitBufferCalled = 0;
DebugManager.flags.PreferCopyEngineForCopyBufferToBuffer.set(-1);

8
opencl/test/unit_test/mem_obj/mem_obj_helper_tests.cpp
View File

@@ -384,7 +384,7 @@ TEST(MemObjHelper, givenDifferentCapabilityAndDebugFlagValuesWhenCheckingBufferC
MockSpecializedContext context;
auto &device = context.getDevice(0)->getDevice();
auto &clCoreHelper = device.getRootDeviceEnvironment().getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = device.getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
MemoryProperties memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(0, 0, 0, &device);
@@ -394,7 +394,7 @@ TEST(MemObjHelper, givenDifferentCapabilityAndDebugFlagValuesWhenCheckingBufferC
memoryProperties, context, compressionEnabled, false);
bool expectBufferCompressed = ftrRenderCompressedBuffers && (enableMultiTileCompressionValue == 1);
if (expectBufferCompressed && clCoreHelper.allowCompressionForContext(*context.getDevice(0), context)) {
if (expectBufferCompressed && clGfxCoreHelper.allowCompressionForContext(*context.getDevice(0), context)) {
EXPECT_TRUE(compressionEnabled);
} else {
EXPECT_FALSE(compressionEnabled);
@@ -446,7 +446,7 @@ TEST(MemObjHelper, givenDifferentValuesWhenCheckingBufferCompressionSupportThenC
for (auto flagsIntel : flagsIntelValues) {
auto &device = context.getDevice(0)->getDevice();
auto &clCoreHelper = device.getRootDeviceEnvironment().getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = device.getRootDeviceEnvironment().getHelper<ClGfxCoreHelper>();
MemoryProperties memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(flags, flagsIntel,
0, &device);
@@ -462,7 +462,7 @@ TEST(MemObjHelper, givenDifferentValuesWhenCheckingBufferCompressionSupportThenC
bool isMultiTile = (numSubDevices > 1);
if (expectBufferCompressed && isMultiTile) {
bool isBufferReadOnly = isValueSet(flags, CL_MEM_READ_ONLY | CL_MEM_HOST_NO_ACCESS);
expectBufferCompressed = clCoreHelper.allowCompressionForContext(*context.getDevice(0), context) &&
expectBufferCompressed = clGfxCoreHelper.allowCompressionForContext(*context.getDevice(0), context) &&
((contextType == ContextType::CONTEXT_TYPE_SPECIALIZED) || isBufferReadOnly);
}

8
opencl/test/unit_test/mocks/mock_cl_hw_helper.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,9 +10,9 @@
namespace NEO {
struct ClHwHelperMock : public ClHwHelper {
using ClHwHelper::makeDeviceIpVersion;
using ClHwHelper::makeDeviceRevision;
struct ClGfxCoreHelperMock : public ClGfxCoreHelper {
using ClGfxCoreHelper::makeDeviceIpVersion;
using ClGfxCoreHelper::makeDeviceRevision;
};
} // namespace NEO

4
opencl/test/unit_test/test_macros/test_checks_ocl.cpp
View File

@@ -36,6 +36,6 @@ bool TestChecks::supportsAuxResolves(const RootDeviceEnvironment &rootDeviceEnvi
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.resize(1);
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescPointer>(true).accessedUsingStatelessAddressingMode = true;
auto &clCoreHelper = rootDeviceEnvironment.getHelper<ClCoreHelper>();
return clCoreHelper.requiresAuxResolves(kernelInfo, rootDeviceEnvironment);
auto &clGfxCoreHelper = rootDeviceEnvironment.getHelper<ClGfxCoreHelper>();
return clGfxCoreHelper.requiresAuxResolves(kernelInfo, rootDeviceEnvironment);
}

32
opencl/test/unit_test/xe_hp_core/hw_helper_tests_xe_hp_core.cpp
View File

@@ -22,56 +22,56 @@
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_hw_helper.h"
using ClHwHelperTestsXeHpCore = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestsXeHpCore = Test<ClDeviceFixture>;
XE_HP_CORE_TEST_F(ClHwHelperTestsXeHpCore, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HP_CORE_TEST_F(ClGfxCoreHelperTestsXeHpCore, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : {false, true}) {
ArgDescPointer argAsPtr{};
argAsPtr.accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_EQ(!argAsPtr.isPureStateful(), clCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
EXPECT_EQ(!argAsPtr.isPureStateful(), clGfxCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
}
}
XE_HP_CORE_TEST_F(ClHwHelperTestsXeHpCore, givenGenHelperWhenEnableStatelessCompressionThenDontRequireNonAuxMode) {
XE_HP_CORE_TEST_F(ClGfxCoreHelperTestsXeHpCore, givenGenHelperWhenEnableStatelessCompressionThenDontRequireNonAuxMode) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : {false, true}) {
ArgDescPointer argAsPtr{};
argAsPtr.accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_FALSE(clCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
}
}
XE_HP_CORE_TEST_F(ClHwHelperTestsXeHpCore, givenXE_HP_COREThenAuxTranslationIsRequired) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HP_CORE_TEST_F(ClGfxCoreHelperTestsXeHpCore, givenXE_HP_COREThenAuxTranslationIsRequired) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : {false, true}) {
KernelInfo kernelInfo{};
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.resize(1);
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescPointer>(true).accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_EQ(!isPureStateful, clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_EQ(!isPureStateful, clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
}
XE_HP_CORE_TEST_F(ClHwHelperTestsXeHpCore, givenXE_HP_COREWhenEnableStatelessCompressionThenAuxTranslationIsNotRequired) {
XE_HP_CORE_TEST_F(ClGfxCoreHelperTestsXeHpCore, givenXE_HP_COREWhenEnableStatelessCompressionThenAuxTranslationIsNotRequired) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
KernelInfo kernelInfo{};
EXPECT_FALSE(clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
XE_HP_CORE_TEST_F(ClHwHelperTestsXeHpCore, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 5, 1), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
XE_HP_CORE_TEST_F(ClGfxCoreHelperTestsXeHpCore, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 5, 1), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
using HwHelperTestXE_HP_CORE = HwHelperTest;

2
opencl/test/unit_test/xe_hpc_core/excludes_ocl_xe_hpc_core.cpp
View File

@@ -31,7 +31,7 @@ HWTEST_EXCLUDE_PRODUCT(HwHelperTestXeHPAndLater, givenBcsDisabledWhenGetGpgpuEng
HWTEST_EXCLUDE_PRODUCT(HwHelperTestXeHPAndLater, givenCcsDisabledAndNumberOfCcsEnabledWhenGetGpgpuEnginesThenReturnRcsAndOneBcsEngine, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(PipeControlHelperTestsXeHPAndLater, WhenGettingSizeForAdditionalSynchronizationThenCorrectValueIsReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(MultiDeviceStorageInfoTest, givenSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoreThemInSystemMemory, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(ClHwHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(ClGfxCoreHelperTest, givenKernelInfoWhenCheckingRequiresAuxResolvesThenCorrectValuesAreReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(BuiltInSharedTest, GivenBuiltinTypeBinaryWhenGettingBuiltinResourceForNotRegisteredRevisionThenBuiltinFromDefaultRevisionIsTaken, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(EnqueueReadBufferRectStatefulTest, WhenReadingBufferRectStatefulThenSuccessIsReturned, IGFX_XE_HPC_CORE);
HWTEST_EXCLUDE_PRODUCT(EnqueueCopyBufferRectStateful, GivenValidParametersWhenCopyingBufferRectStatefulThenSuccessIsReturned, IGFX_XE_HPC_CORE);

18
opencl/test/unit_test/xe_hpc_core/hw_helper_tests_xe_hpc_core.cpp
View File

@@ -24,19 +24,19 @@
#include "hw_cmds_xe_hpc_core_base.h"
using ClHwHelperTestsXeHpcCore = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestsXeHpcCore = Test<ClDeviceFixture>;
;
XE_HPC_CORETEST_F(ClHwHelperTestsXeHpcCore, givenXeHpcThenAuxTranslationIsNotRequired) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HPC_CORETEST_F(ClGfxCoreHelperTestsXeHpcCore, givenXeHpcThenAuxTranslationIsNotRequired) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
KernelInfo kernelInfo{};
EXPECT_FALSE(clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
XE_HPC_CORETEST_F(ClHwHelperTestsXeHpcCore, WhenCheckingPreferenceForBlitterForLocalToLocalTransfersThenReturnFalse) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
EXPECT_FALSE(clCoreHelper.preferBlitterForLocalToLocalTransfers());
XE_HPC_CORETEST_F(ClGfxCoreHelperTestsXeHpcCore, WhenCheckingPreferenceForBlitterForLocalToLocalTransfersThenReturnFalse) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_FALSE(clGfxCoreHelper.preferBlitterForLocalToLocalTransfers());
}
using HwHelperTestsXeHpcCore = Test<ClDeviceFixture>;
@@ -828,7 +828,7 @@ XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, givenCommandBufferAllocationWhenSetExt
}
XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 8, 1), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 8, 1), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}

6
opencl/test/unit_test/xe_hpc_core/pvc/cl_hw_helper_tests_pvc.cpp
View File

@@ -14,9 +14,9 @@
namespace NEO {
using ClHwHelperTestsPvcXt = Test<ClHwHelperXeHpcCoreFixture>;
using ClGfxCoreHelperTestsPvcXt = Test<ClGfxCoreHelperXeHpcCoreFixture>;
PVCTEST_F(ClHwHelperTestsPvcXt, givenSingleTileCsrOnPvcXtWhenAllocatingCsrSpecificAllocationsAndIsNotBaseDieA0ThenStoredInProperMemoryPool) {
PVCTEST_F(ClGfxCoreHelperTestsPvcXt, givenSingleTileCsrOnPvcXtWhenAllocatingCsrSpecificAllocationsAndIsNotBaseDieA0ThenStoredInProperMemoryPool) {
auto hwInfo = *defaultHwInfo;
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
hwInfo.platform.usDeviceID = pvcXtDeviceIds.front();
@@ -24,7 +24,7 @@ PVCTEST_F(ClHwHelperTestsPvcXt, givenSingleTileCsrOnPvcXtWhenAllocatingCsrSpecif
checkIfSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInProperMemoryPool(&hwInfo);
}
PVCTEST_F(ClHwHelperTestsPvcXt, givenMultiTileCsrOnPvcWhenAllocatingCsrSpecificAllocationsAndIsNotBaseDieA0ThenStoredInLocalMemoryPool) {
PVCTEST_F(ClGfxCoreHelperTestsPvcXt, givenMultiTileCsrOnPvcWhenAllocatingCsrSpecificAllocationsAndIsNotBaseDieA0ThenStoredInLocalMemoryPool) {
auto hwInfo = *defaultHwInfo;
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
hwInfo.platform.usDeviceID = pvcXtDeviceIds.front();

6
opencl/test/unit_test/xe_hpc_core/xe_hpc_core_test_ocl_fixtures.cpp
View File

@@ -15,12 +15,12 @@
namespace NEO {
void ClHwHelperXeHpcCoreFixture::setupDeviceIdAndRevision(HardwareInfo *hwInfo, ClDevice &clDevice) {
void ClGfxCoreHelperXeHpcCoreFixture::setupDeviceIdAndRevision(HardwareInfo *hwInfo, ClDevice &clDevice) {
auto deviceHwInfo = clDevice.getExecutionEnvironment()->rootDeviceEnvironments[0]->getMutableHardwareInfo();
deviceHwInfo->platform.usDeviceID = hwInfo->platform.usDeviceID;
deviceHwInfo->platform.usRevId = hwInfo->platform.usRevId;
}
void ClHwHelperXeHpcCoreFixture::checkIfSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInProperMemoryPool(HardwareInfo *hwInfo) {
void ClGfxCoreHelperXeHpcCoreFixture::checkIfSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInProperMemoryPool(HardwareInfo *hwInfo) {
const uint32_t numDevices = 4u;
const uint32_t tileIndex = 2u;
const DeviceBitfield singleTileMask{static_cast<uint32_t>(1u << tileIndex)};
@@ -48,7 +48,7 @@ void ClHwHelperXeHpcCoreFixture::checkIfSingleTileCsrWhenAllocatingCsrSpecificAl
EXPECT_EQ(commandBufferAllocation->getMemoryPool(), MemoryPool::LocalMemory);
}
void ClHwHelperXeHpcCoreFixture::checkIfMultiTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInLocalMemoryPool(HardwareInfo *hwInfo) {
void ClGfxCoreHelperXeHpcCoreFixture::checkIfMultiTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInLocalMemoryPool(HardwareInfo *hwInfo) {
const uint32_t numDevices = 4u;
const DeviceBitfield tile0Mask{0x1};
ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;

2
opencl/test/unit_test/xe_hpc_core/xe_hpc_core_test_ocl_fixtures.h
View File

@@ -13,7 +13,7 @@
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
namespace NEO {
struct ClHwHelperXeHpcCoreFixture : public ClDeviceFixture {
struct ClGfxCoreHelperXeHpcCoreFixture : public ClDeviceFixture {
void checkIfSingleTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInProperMemoryPool(HardwareInfo *hwInfo);
void checkIfMultiTileCsrWhenAllocatingCsrSpecificAllocationsThenStoredInLocalMemoryPool(HardwareInfo *hwInfo);
void setupDeviceIdAndRevision(HardwareInfo *hwInfo, ClDevice &clDevice);

40
opencl/test/unit_test/xe_hpg_core/cl_hw_helper_tests_xe_hpg_core.cpp
View File

@@ -18,66 +18,66 @@
#include "hw_cmds_xe_hpg_core_base.h"
using ClHwHelperTestsXeHpgCore = Test<ClDeviceFixture>;
using ClGfxCoreHelperTestsXeHpgCore = Test<ClDeviceFixture>;
using namespace NEO;
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, WhenGettingDeviceIpVersionThenMakeCorrectDeviceIpVersion) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
if (defaultHwInfo->capabilityTable.isIntegratedDevice) {
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 7, 0), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 7, 0), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
} else {
EXPECT_EQ(ClHwHelperMock::makeDeviceIpVersion(12, 7, 1), clCoreHelper.getDeviceIpVersion(*defaultHwInfo));
EXPECT_EQ(ClGfxCoreHelperMock::makeDeviceIpVersion(12, 7, 1), clGfxCoreHelper.getDeviceIpVersion(*defaultHwInfo));
}
}
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, givenGenHelperWhenKernelArgumentIsNotPureStatefulThenRequireNonAuxMode) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : ::testing::Bool()) {
ArgDescPointer argAsPtr{};
argAsPtr.accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_EQ(!argAsPtr.isPureStateful(), clCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
EXPECT_EQ(!argAsPtr.isPureStateful(), clGfxCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
}
}
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenGenHelperWhenEnableStatelessCompressionThenDontRequireNonAuxMode) {
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, givenGenHelperWhenEnableStatelessCompressionThenDontRequireNonAuxMode) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : ::testing::Bool()) {
ArgDescPointer argAsPtr{};
argAsPtr.accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_FALSE(clCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresNonAuxMode(argAsPtr, getRootDeviceEnvironment()));
}
}
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenGenHelperWhenCheckAuxTranslationThenAuxResolvesIsRequired) {
auto &clCoreHelper = getHelper<ClCoreHelper>();
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, givenGenHelperWhenCheckAuxTranslationThenAuxResolvesIsRequired) {
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (auto isPureStateful : ::testing::Bool()) {
KernelInfo kernelInfo{};
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.resize(1);
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescPointer>(true).accessedUsingStatelessAddressingMode = !isPureStateful;
EXPECT_EQ(!isPureStateful, clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_EQ(!isPureStateful, clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
}
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenGenHelperWhenEnableStatelessCompressionThenAuxTranslationIsNotRequired) {
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, givenGenHelperWhenEnableStatelessCompressionThenAuxTranslationIsNotRequired) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
KernelInfo kernelInfo{};
EXPECT_FALSE(clCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
EXPECT_FALSE(clGfxCoreHelper.requiresAuxResolves(kernelInfo, getRootDeviceEnvironment()));
}
XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenDifferentCLImageFormatsWhenCallingAllowImageCompressionThenCorrectValueReturned) {
XE_HPG_CORETEST_F(ClGfxCoreHelperTestsXeHpgCore, givenDifferentCLImageFormatsWhenCallingAllowImageCompressionThenCorrectValueReturned) {
struct ImageFormatCompression {
cl_image_format imageFormat;
bool isCompressable;
@@ -115,10 +115,10 @@ XE_HPG_CORETEST_F(ClHwHelperTestsXeHpgCore, givenDifferentCLImageFormatsWhenCall
{{CL_R, CL_UNORM_INT16}, true},
};
auto &clCoreHelper = getHelper<ClCoreHelper>();
auto &clGfxCoreHelper = getHelper<ClGfxCoreHelper>();
for (const auto &format : imageFormats) {
bool result = clCoreHelper.allowImageCompression(format.imageFormat);
bool result = clGfxCoreHelper.allowImageCompression(format.imageFormat);
EXPECT_EQ(format.isCompressable, result);
}
}