Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

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

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

@ -451,7 +451,7 @@ HWTEST_F(DeviceTest, givenDebugFlagWhenCreatingRootDeviceWithoutSubDevicesThenWo
TEST(DeviceCreation, givenDeviceWhenCheckingGpgpuEnginesCountThenNumberGreaterThanZeroIsReturned) {
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);
}

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) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
const size_t sizesToCheck[] = {128, 256, 512, 1023, 1024, 1025};
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) {
DebugManagerStateRestore restorer;
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto &waTable = hardwareInfo.workaroundTable;
std::tuple<bool, bool, int32_t> testParams[]{
@ -229,7 +229,7 @@ GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenTgllpWhenIsFusedEuDispatchEnabledIs
for (auto &[expectedResult, wa, debugKey] : testParams) {
waTable.flags.waDisableFusedThreadScheduling = wa;
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) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = device->getGfxCoreHelper();
buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal));
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) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = device->getGfxCoreHelper();
buffer.reset(Buffer::create(context.get(), 0, MemoryConstants::cacheLineSize, nullptr, retVal));
buffer->getGraphicsAllocation(rootDeviceIndex)->setAllocationType(AllocationType::BUFFER);
EXPECT_TRUE(helper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex)));
EXPECT_TRUE(gfxCoreHelper.checkResourceCompatibility(*buffer->getGraphicsAllocation(rootDeviceIndex)));
}
using LriHelperTestsGen12Lp = ::testing::Test;
@ -306,54 +306,54 @@ GEN12LPTEST_F(MemorySynchronizatiopCommandsTests, whenSettingCacheFlushExtraFiel
}
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenGen12WhenCallIsPackedSupportedThenReturnTrue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_TRUE(helper.packedFormatsSupported());
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.packedFormatsSupported());
}
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, whenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper();
const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, true));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
}
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceEnabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
DebugManagerStateRestore restore{};
DebugManager.flags.ForceL1Caching.set(1);
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper();
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 mocsL1 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL1, helper.getMocsIndex(*gmmHelper, true, true));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL1, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
}
GEN12LPTEST_F(GfxCoreHelperTestGen12Lp, givenL1ForceDisabledWhenRequestingMocsThenProperMocsIndicesAreBeingReturned) {
DebugManagerStateRestore restore{};
DebugManager.flags.ForceL1Caching.set(0);
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper();
const auto mocsNoCache = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
const auto mocsL3 = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, helper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, helper.getMocsIndex(*gmmHelper, true, true));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, false));
EXPECT_EQ(mocsNoCache, gfxCoreHelper.getMocsIndex(*gmmHelper, false, true));
EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, false));
EXPECT_EQ(mocsL3, gfxCoreHelper.getMocsIndex(*gmmHelper, true, true));
}
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;
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++) {
imgDesc.image_type = imgTypes[i];
@ -89,21 +89,21 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenIsLinearStoragePreferredThenRe
(imgTypes[i] == CL_MEM_OBJECT_IMAGE2D_ARRAY);
// 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;
DebugManager.flags.ForceLinearImages.set(true);
// 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
EXPECT_TRUE(helper.isLinearStoragePreferred(true, Image::isImage1d(imgDesc), false));
EXPECT_TRUE(gfxCoreHelper.isLinearStoragePreferred(true, Image::isImage1d(imgDesc), false));
// 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
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[2] = pKernelInfosStorage[1].get();
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = pContext->getDevice(0)->getGfxCoreHelper();
for (auto i = 0u; i < 2; 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) {
class MockGfxCoreHelperHw : public GfxCoreHelperHw<FamilyType> {
public:
bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) override {
bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const override {
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;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
const size_t sizesToCheck[] = {1, 128, 256, 1024, 2048};
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) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_EQ(16u, helper.getMinimalSIMDSize());
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(16u, gfxCoreHelper.getMinimalSIMDSize());
}
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 <>
bool GfxCoreHelperHw<Family>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) {
bool GfxCoreHelperHw<Family>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const {
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 preferSmallWorkgroupSizeForKernel(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 compressedImagesSupported(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 checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) override;
bool checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) 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>
inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) {
inline bool GfxCoreHelperHw<GfxFamily>::checkResourceCompatibility(GraphicsAllocation &graphicsAllocation) const {
return true;
}