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

Refactor: dont use global gfxCoreHelper getter in ocl files 2/n

Browse Source 
Realated-To: NEO-6853
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>
This commit is contained in:
Kamil Kopryk
2022-12-21 17:08:05 +00:00
committed by Compute-Runtime-Automation
parent 884d286d60
commit 31bb84acd9
11 changed files with 47 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
View File

@@ -707,9 +707,9 @@ HWTEST_F(EnqueueKernelTest, whenEnqueueKernelWithNoStatelessWriteWhenSbaIsBeingP
EXPECT_EQ(csr.recordedDispatchFlags.l3CacheSettings, L3CachingSettings::l3AndL1On); EXPECT_EQ(csr.recordedDispatchFlags.l3CacheSettings, L3CachingSettings::l3AndL1On);
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto gmmHelper = this->pDevice->getGmmHelper(); auto gmmHelper = this->pDevice->getGmmHelper();
auto expectedMocsIndex = helper.getMocsIndex(*gmmHelper, true, true); auto expectedMocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, true);
EXPECT_EQ(expectedMocsIndex, csr.latestSentStatelessMocsConfig); EXPECT_EQ(expectedMocsIndex, csr.latestSentStatelessMocsConfig);
} }
@@ -729,9 +729,10 @@ HWTEST_F(EnqueueKernelTest, whenEnqueueKernelWithNoStatelessWriteOnBlockedCodePa
EXPECT_EQ(csr.recordedDispatchFlags.l3CacheSettings, L3CachingSettings::l3AndL1On); EXPECT_EQ(csr.recordedDispatchFlags.l3CacheSettings, L3CachingSettings::l3AndL1On);
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto gmmHelper = this->pDevice->getGmmHelper(); auto gmmHelper = this->pDevice->getGmmHelper();
auto expectedMocsIndex = helper.getMocsIndex(*gmmHelper, true, true); auto expectedMocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, true);
EXPECT_EQ(expectedMocsIndex, csr.latestSentStatelessMocsConfig); EXPECT_EQ(expectedMocsIndex, csr.latestSentStatelessMocsConfig);
clReleaseEvent(userEvent); clReleaseEvent(userEvent);

2
opencl/test/unit_test/device/device_tests.cpp
View File

@@ -451,7 +451,7 @@ HWTEST_F(DeviceTest, givenDebugFlagWhenCreatingRootDeviceWithoutSubDevicesThenWo
TEST(DeviceCreation, givenDeviceWhenCheckingGpgpuEnginesCountThenNumberGreaterThanZeroIsReturned) { TEST(DeviceCreation, givenDeviceWhenCheckingGpgpuEnginesCountThenNumberGreaterThanZeroIsReturned) {
auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr)); auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = device->getGfxCoreHelper();
EXPECT_GT(gfxCoreHelper.getGpgpuEngineInstances(device->getHardwareInfo()).size(), 0u); EXPECT_GT(gfxCoreHelper.getGpgpuEngineInstances(device->getHardwareInfo()).size(), 0u);
} }

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

@@ -93,11 +93,11 @@ GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, WhenAdjustingDefaultEngineTypeThenRcsIsS
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenDifferentSizesOfAllocationWhenCheckingCompressionPreferenceThenReturnCorrectValue) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenDifferentSizesOfAllocationWhenCheckingCompressionPreferenceThenReturnCorrectValue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
const size_t sizesToCheck[] = {128, 256, 512, 1023, 1024, 1025}; const size_t sizesToCheck[] = {128, 256, 512, 1023, 1024, 1025};
for (size_t size : sizesToCheck) { for (size_t size : sizesToCheck) {
EXPECT_FALSE(helper.isBufferSizeSuitableForCompression(size, *defaultHwInfo)); EXPECT_FALSE(gfxCoreHelper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
} }
} }
@@ -215,7 +215,7 @@ GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenFtrCcsNodeSetAndDefaultRcsWhenGetGp
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenTgllpWhenIsFusedEuDispatchEnabledIsCalledThenResultIsCorrect) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenTgllpWhenIsFusedEuDispatchEnabledIsCalledThenResultIsCorrect) {
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto &waTable = hardwareInfo.workaroundTable; auto &waTable = hardwareInfo.workaroundTable;
std::tuple<bool, bool, int32_t> testParams[]{ std::tuple<bool, bool, int32_t> testParams[]{
@@ -229,7 +229,7 @@ GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenTgllpWhenIsFusedEuDispatchEnabledIs
for (auto &[expectedResult, wa, debugKey] : testParams) { for (auto &[expectedResult, wa, debugKey] : testParams) {
waTable.flags.waDisableFusedThreadScheduling = wa; waTable.flags.waDisableFusedThreadScheduling = wa;
DebugManager.flags.CFEFusedEUDispatch.set(debugKey); DebugManager.flags.CFEFusedEUDispatch.set(debugKey);
EXPECT_EQ(expectedResult, helper.isFusedEuDispatchEnabled(hardwareInfo, false)); EXPECT_EQ(expectedResult, gfxCoreHelper.isFusedEuDispatchEnabled(hardwareInfo, false));
} }
} }
@@ -250,23 +250,23 @@ class GfxCoreHelperTestsGen12LpBuffer : public ::testing::Test {
}; };
GEN12LPTEST_F(GfxCoreHelperTestsGen12LpBuffer, givenCompressedBufferThenCheckResourceCompatibilityReturnsFalse) { GEN12LPTEST_F(GfxCoreHelperTestsGen12LpBuffer, givenCompressedBufferThenCheckResourceCompatibilityReturnsFalse) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = device->getGfxCoreHelper();
buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal)); buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal));
MockBuffer::setAllocationType(buffer->getGraphicsAllocation(rootDeviceIndex), context->getDevice(0)->getRootDeviceEnvironment().getGmmHelper(), true); MockBuffer::setAllocationType(buffer->getGraphicsAllocation(rootDeviceIndex), context->getDevice(0)->getRootDeviceEnvironment().getGmmHelper(), true);
EXPECT_FALSE(helper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex))); EXPECT_FALSE(gfxCoreHelper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex)));
} }
GEN12LPTEST_F(GfxCoreHelperTestsGen12LpBuffer, givenBufferThenCheckResourceCompatibilityReturnsTrue) { GEN12LPTEST_F(GfxCoreHelperTestsGen12LpBuffer, givenBufferThenCheckResourceCompatibilityReturnsTrue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = device->getGfxCoreHelper();
buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal)); buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal));
buffer->getGraphicsAllocation(rootDeviceIndex)->setAllocationType(AllocationType::BUFFER); buffer->getGraphicsAllocation(rootDeviceIndex)->setAllocationType(AllocationType::BUFFER);
EXPECT_TRUE(helper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex))); EXPECT_TRUE(gfxCoreHelper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex)));
} }
using LriHelperTestsGen12Lp = ::testing::Test; using LriHelperTestsGen12Lp = ::testing::Test;
@@ -306,54 +306,54 @@ GEN12LPTEST_F(MemorySynchronizatiopCommandsTests, whenSettingCacheFlushExtraFiel
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenGen12WhenCallIsPackedSupportedThenReturnTrue) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenGen12WhenCallIsPackedSupportedThenReturnTrue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(helper.packedFormatsSupported()); EXPECT_TRUE(gfxCoreHelper.packedFormatsSupported());
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, whenRequestingMocsThenProperMocsIndicesAreBeingReturned) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, whenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper(); auto gmmHelper = this->pDevice->getGmmHelper();
const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1; const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1; const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false)); EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, true)); EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceEnabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceEnabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
DebugManagerStateRestore restore{}; DebugManagerStateRestore restore{};
DebugManager.flags.ForceL1Caching.set(1); DebugManager.flags.ForceL1Caching.set(1);
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper(); auto gmmHelper = this->pDevice->getGmmHelper();
const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1; const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1; const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
const auto mocsL1 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST) >> 1; const auto mocsL1 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false)); EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL1, helper.getMocsIndex(*gmmHelper, true, true)); EXPECT_EQ(mocsL1, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceDisabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceDisabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
DebugManagerStateRestore restore{}; DebugManagerStateRestore restore{};
DebugManager.flags.ForceL1Caching.set(0); DebugManager.flags.ForceL1Caching.set(0);
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper(); auto gmmHelper = this->pDevice->getGmmHelper();
const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1; const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1; const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true)); EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false)); EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, true)); EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
} }
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenAllocationTypeWithCpuAccessRequiredWhenCpuAccessIsDisallowedThenSystemMemoryIsRequested) { GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenAllocationTypeWithCpuAccessRequiredWhenCpuAccessIsDisallowedThenSystemMemoryIsRequested) {

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

@@ -79,7 +79,7 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenIsLinearStoragePreferredThenRe
cl_int retVal = CL_SUCCESS; cl_int retVal = CL_SUCCESS;
auto buffer = std::unique_ptr<Buffer>(Buffer::create(&context, 0, 1, nullptr, retVal)); auto buffer = std::unique_ptr<Buffer>(Buffer::create(&context, 0, 1, nullptr, retVal));
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
for (uint32_t i = 0; i < numImageTypes; i++) { for (uint32_t i = 0; i < numImageTypes; i++) {
imgDesc.image_type = imgTypes[i]; imgDesc.image_type = imgTypes[i];
@@ -89,21 +89,21 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenIsLinearStoragePreferredThenRe
(imgTypes[i] == CL_MEM_OBJECT_IMAGE2D_ARRAY); (imgTypes[i] == CL_MEM_OBJECT_IMAGE2D_ARRAY);
// non shared context, dont force linear storage // non shared context, dont force linear storage
EXPECT_EQ((tilingSupported & allowedType), !helper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false)); EXPECT_EQ((tilingSupported & allowedType), !gfxCoreHelper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false));
{ {
DebugManagerStateRestore restore; DebugManagerStateRestore restore;
DebugManager.flags.ForceLinearImages.set(true); DebugManager.flags.ForceLinearImages.set(true);
// non shared context, dont force linear storage + debug flag // non shared context, dont force linear storage + debug flag
EXPECT_TRUE(helper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false)); EXPECT_TRUE(gfxCoreHelper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false));
} }
// shared context, dont force linear storage // shared context, dont force linear storage
EXPECT_TRUE(helper.isLinearStoragePreferred(true, Image::isImage1d(imgDesc), false)); EXPECT_TRUE(gfxCoreHelper.isLinearStoragePreferred(true, Image::isImage1d(imgDesc), false));
// non shared context, force linear storage // non shared context, force linear storage
EXPECT_TRUE(helper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), true)); EXPECT_TRUE(gfxCoreHelper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), true));
// non shared context, dont force linear storage + create from buffer // non shared context, dont force linear storage + create from buffer
imgDesc.buffer = buffer.get(); imgDesc.buffer = buffer.get();
EXPECT_TRUE(helper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false)); EXPECT_TRUE(gfxCoreHelper.isLinearStoragePreferred(false, Image::isImage1d(imgDesc), false));
} }
} }

2
opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp
View File

@@ -67,7 +67,7 @@ struct MultiDeviceKernelArgBufferTest : public ::testing::Test {
kernelInfos[1] = pKernelInfosStorage[0].get(); kernelInfos[1] = pKernelInfosStorage[0].get();
kernelInfos[2] = pKernelInfosStorage[1].get(); kernelInfos[2] = pKernelInfosStorage[1].get();
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = pContext->getDevice(0)->getGfxCoreHelper();
for (auto i = 0u; i < 2; i++) { for (auto i = 0u; i < 2; i++) {
pKernelInfosStorage[i]->heapInfo.pSsh = pSshLocal[i]; pKernelInfosStorage[i]->heapInfo.pSsh = pSshLocal[i];

2
opencl/test/unit_test/mem_obj/image2d_from_buffer_tests.cpp
View File

@@ -335,7 +335,7 @@ TEST_F(Image2dFromBufferTest, givenBufferWhenImageFromBufferThenIsImageFromBuffe
HWTEST_F(Image2dFromBufferTest, givenBufferWhenImageFromBufferThenIsImageFromBufferSetAndAllocationTypeIsBufferNullptr) { HWTEST_F(Image2dFromBufferTest, givenBufferWhenImageFromBufferThenIsImageFromBufferSetAndAllocationTypeIsBufferNullptr) {
class MockGfxCoreHelperHw : public GfxCoreHelperHw<FamilyType> { class MockGfxCoreHelperHw : public GfxCoreHelperHw<FamilyType> {
public: public:
bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) override { bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const override {
return false; return false;
} }
}; };

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

@@ -80,11 +80,11 @@ XE_HP_CORE_TEST_F(GfxCoreHelperTestXE_HP_CORE, givenDifferentBufferSizesWhenEnab
DebugManagerStateRestore restore; DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1); DebugManager.flags.EnableStatelessCompression.set(1);
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
const size_t sizesToCheck[] = {1, 128, 256, 1024, 2048}; const size_t sizesToCheck[] = {1, 128, 256, 1024, 2048};
for (size_t size : sizesToCheck) { for (size_t size : sizesToCheck) {
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(size, *defaultHwInfo)); EXPECT_TRUE(gfxCoreHelper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
} }
} }

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

@@ -92,8 +92,8 @@ XE_HPC_CORETEST_F(GfxCoreHelperTestsXeHpcCore, givenSingleTileBdA0CsrWhenAllocat
} }
XE_HPC_CORETEST_F(GfxCoreHelperTestsXeHpcCore, givenXeHpcWhenAskedForMinimialSimdThen16IsReturned) { XE_HPC_CORETEST_F(GfxCoreHelperTestsXeHpcCore, givenXeHpcWhenAskedForMinimialSimdThen16IsReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily); auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(16u, helper.getMinimalSIMDSize()); EXPECT_EQ(16u, gfxCoreHelper.getMinimalSIMDSize());
} }
XE_HPC_CORETEST_F(GfxCoreHelperTestsXeHpcCore, whenQueryingMaxNumSamplersThenReturnZero) { XE_HPC_CORETEST_F(GfxCoreHelperTestsXeHpcCore, whenQueryingMaxNumSamplersThenReturnZero) {

2
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@@ -76,7 +76,7 @@ bool GfxCoreHelperHw<Family>::isBufferSizeSuitableForCompression(const size_t si
} }
template <> template <>
bool GfxCoreHelperHw<Family>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) { bool GfxCoreHelperHw<Family>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const {
return !graphicsAllocation.isCompressionEnabled(); return !graphicsAllocation.isCompressionEnabled();
} }

4
shared/source/helpers/hw_helper.h
View File

@@ -59,7 +59,7 @@ class GfxCoreHelper {
virtual bool hvAlign4Required() const = 0; virtual bool hvAlign4Required() const = 0;
virtual bool preferSmallWorkgroupSizeForKernel(const size_t size, const HardwareInfo &hwInfo) const = 0; virtual bool preferSmallWorkgroupSizeForKernel(const size_t size, const HardwareInfo &hwInfo) const = 0;
virtual bool isBufferSizeSuitableForCompression(const size_t size, const HardwareInfo &hwInfo) const = 0; virtual bool isBufferSizeSuitableForCompression(const size_t size, const HardwareInfo &hwInfo) const = 0;
virtual bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) = 0; virtual bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const = 0;
static bool compressedBuffersSupported(const HardwareInfo &hwInfo); static bool compressedBuffersSupported(const HardwareInfo &hwInfo);
static bool compressedImagesSupported(const HardwareInfo &hwInfo); static bool compressedImagesSupported(const HardwareInfo &hwInfo);
static bool cacheFlushAfterWalkerSupported(const HardwareInfo &hwInfo); static bool cacheFlushAfterWalkerSupported(const HardwareInfo &hwInfo);
@@ -223,7 +223,7 @@ class GfxCoreHelperHw : public GfxCoreHelper {
bool isBufferSizeSuitableForCompression(const size_t size, const HardwareInfo &hwInfo) const override; bool isBufferSizeSuitableForCompression(const size_t size, const HardwareInfo &hwInfo) const override;
bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) override; bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const override;
bool timestampPacketWriteSupported() const override; bool timestampPacketWriteSupported() const override;

2
shared/source/helpers/hw_helper_base.inl
View File

@@ -96,7 +96,7 @@ bool GfxCoreHelperHw<Family>::isFenceAllocationRequired(const HardwareInfo &hwIn
} }
template <typename GfxFamily> template <typename GfxFamily>
inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) { inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const {
return true; return true;
} }