Enable setting additional params for gen12lp image compression

DziubanMaciejIntel · Compute-Runtime-Automation · commit 100f888b851d · 2019-10-11T07:25:38.000+02:00
Signed-off-by: Maciej Dziuban &lt;maciej.dziuban@intel.com&gt;
Change-Id: I6228413938930f36c120523818649cde1a717cf2
Related-To: NEO-3564
diff --git a/Jenkinsfile b/Jenkinsfile
@@ -2,4 +2,4 @@
 dependenciesRevision='1b671f56c71786ef356de9b0c1d93ba18104e655-1314'
 strategy='EQUAL'
 allowedCD=263
-allowedF=5
+allowedF=7
diff --git a/core/gen12lp/hw_cmds_generated.inl b/core/gen12lp/hw_cmds_generated.inl
@@ -1762,7 +1762,8 @@ typedef struct tagRENDER_SURFACE_STATE {
             uint64_t QuiltHeight : BITFIELD_RANGE(5, 9);
             uint64_t ClearValueAddressEnable : BITFIELD_RANGE(10, 10);
             uint64_t Reserved_331 : BITFIELD_RANGE(11, 63);
-            uint32_t Reserved_384;
+            uint32_t CompressionFormat : BITFIELD_RANGE(0, 4);
+            uint32_t Reserved_389 : BITFIELD_RANGE(5, 31);
             uint32_t Reserved_416;
             uint32_t Reserved_448;
             uint32_t Reserved_480;
@@ -2749,6 +2750,13 @@ typedef struct tagRENDER_SURFACE_STATE {
         return static_cast<MEMORY_COMPRESSION_MODE>(
             TheStructure.Common.MemoryCompressionMode);
     }
+    inline void setCompressionFormat(uint32_t compressionFormat) {
+        UNRECOVERABLE_IF(compressionFormat > 0x1F);
+        TheStructure.Common.CompressionFormat = compressionFormat;
+    }
+    inline uint32_t getCompressionFormat(void) const {
+        return TheStructure.Common.CompressionFormat;
+    }
     inline void setSurfaceBaseAddress(const uint64_t value) {
         TheStructure.Common.SurfaceBaseAddress = value;
     }
diff --git a/runtime/gen12lp/helpers_gen12lp.cpp b/runtime/gen12lp/helpers_gen12lp.cpp
@@ -42,5 +42,16 @@ void setAdditionalPipelineSelectFields(void *pipelineSelectCmd,
                                        const PipelineSelectArgs &pipelineSelectArgs,
                                        const HardwareInfo &hwInfo) {}
 
+bool isPageTableManagerSupported(const HardwareInfo &hwInfo) {
+    return hwInfo.capabilityTable.ftrRenderCompressedBuffers || hwInfo.capabilityTable.ftrRenderCompressedImages;
+}
+
+bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) {
+    return false;
+}
+
+void setAdditionalSurfaceStateParamsForImageCompression(Image &image, TGLLPFamily::RENDER_SURFACE_STATE *surfaceState) {
+}
+
 } // namespace Gen12LPHelpers
 } // namespace NEO
diff --git a/runtime/gen12lp/helpers_gen12lp.h b/runtime/gen12lp/helpers_gen12lp.h
@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include "runtime/gen12lp/hw_cmds_base.h"
+
 #include "hw_info.h"
 
 namespace AubMemDump {
@@ -18,6 +20,7 @@ namespace NEO {
 class CommandStreamReceiver;
 class GraphicsAllocation;
 struct PipelineSelectArgs;
+class Image;
 
 namespace Gen12LPHelpers {
 bool hdcFlushForPipeControlBeforeStateBaseAddressRequired(PRODUCT_FAMILY productFamily);
@@ -31,5 +34,8 @@ void adjustAubGTTData(const CommandStreamReceiver &commandStreamReceiver, AubGTT
 void setAdditionalPipelineSelectFields(void *pipelineSelectCmd,
                                        const PipelineSelectArgs &pipelineSelectArgs,
                                        const HardwareInfo &hwInfo);
+bool isPageTableManagerSupported(const HardwareInfo &hwInfo);
+bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size);
+void setAdditionalSurfaceStateParamsForImageCompression(Image &image, typename TGLLPFamily::RENDER_SURFACE_STATE *surfaceState);
 } // namespace Gen12LPHelpers
 } // namespace NEO
diff --git a/runtime/gen12lp/hw_helper_gen12lp.cpp b/runtime/gen12lp/hw_helper_gen12lp.cpp
@@ -42,12 +42,12 @@ bool HwHelperHw<Family>::isLocalMemoryEnabled(const HardwareInfo &hwInfo) const
 
 template <>
 bool HwHelperHw<Family>::isPageTableManagerSupported(const HardwareInfo &hwInfo) const {
-    return hwInfo.capabilityTable.ftrRenderCompressedBuffers || hwInfo.capabilityTable.ftrRenderCompressedImages;
+    return Gen12LPHelpers::isPageTableManagerSupported(hwInfo);
 }
 
 template <>
-bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const size_t size) const {
-    return false;
+bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const {
+    return Gen12LPHelpers::obtainRenderBufferCompressionPreference(hwInfo, size);
 }
 
 template <>
diff --git a/runtime/gen12lp/image_gen12lp.cpp b/runtime/gen12lp/image_gen12lp.cpp
@@ -5,6 +5,7 @@
  *
  */
 
+#include "runtime/gen12lp/helpers_gen12lp.h"
 #include "runtime/gen12lp/hw_cmds.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/mem_obj/image.inl"
@@ -35,6 +36,12 @@ void ImageHw<GfxFamily>::setSurfaceMemoryObjectControlStateIndexToMocsTable(void
 
     surfaceState->setSurfaceMemoryObjectControlStateIndexToMocsTables(value);
 }
+
+template <>
+void ImageHw<Family>::appendSurfaceStateParams(Family::RENDER_SURFACE_STATE *surfaceState) {
+    Gen12LPHelpers::setAdditionalSurfaceStateParamsForImageCompression(*this, surfaceState);
+}
+
 // clang-format off
 #include "runtime/mem_obj/image_tgllp_plus.inl"
 #include "runtime/mem_obj/image_factory_init.inl"
diff --git a/runtime/gmm_helper/client_context/gmm_client_context_base.cpp b/runtime/gmm_helper/client_context/gmm_client_context_base.cpp
@@ -34,4 +34,13 @@ void GmmClientContextBase::destroyResInfoObject(GMM_RESOURCE_INFO *pResInfo) {
 GMM_CLIENT_CONTEXT *GmmClientContextBase::getHandle() const {
     return clientContext;
 }
+
+uint8_t GmmClientContextBase::getSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format) {
+    return clientContext->GetSurfaceStateCompressionFormat(format);
+}
+
+uint8_t GmmClientContextBase::getMediaSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format) {
+    return clientContext->GetMediaSurfaceStateCompressionFormat(format);
+}
+
 } // namespace NEO
diff --git a/runtime/gmm_helper/client_context/gmm_client_context_base.h b/runtime/gmm_helper/client_context/gmm_client_context_base.h
@@ -27,6 +27,9 @@ class GmmClientContextBase {
         return std::make_unique<T>(clientType, gmmEntries);
     }
 
+    MOCKABLE_VIRTUAL uint8_t getSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);
+    MOCKABLE_VIRTUAL uint8_t getMediaSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);
+
   protected:
     GMM_CLIENT_CONTEXT *clientContext;
     GmmClientContextBase(GMM_CLIENT clientType, GmmExportEntries &gmmEntries);
diff --git a/runtime/helpers/hw_helper.h b/runtime/helpers/hw_helper.h
@@ -44,7 +44,7 @@ class HwHelper {
     virtual bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const = 0;
     virtual const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const = 0;
     virtual bool hvAlign4Required() const = 0;
-    virtual bool obtainRenderBufferCompressionPreference(const size_t size) const = 0;
+    virtual bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const = 0;
     virtual void checkResourceCompatibility(Buffer *buffer, cl_int &errorCode) = 0;
     static bool renderCompressedBuffersSupported(const HardwareInfo &hwInfo);
     static bool renderCompressedImagesSupported(const HardwareInfo &hwInfo);
@@ -137,7 +137,7 @@ class HwHelperHw : public HwHelper {
 
     bool hvAlign4Required() const override;
 
-    bool obtainRenderBufferCompressionPreference(const size_t size) const override;
+    bool obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const override;
 
     void checkResourceCompatibility(Buffer *buffer, cl_int &errorCode) override;
 
diff --git a/runtime/helpers/hw_helper_base.inl b/runtime/helpers/hw_helper_base.inl
@@ -23,7 +23,7 @@ template <typename Family>
 const aub_stream::EngineType HwHelperHw<Family>::lowPriorityEngineType = aub_stream::EngineType::ENGINE_RCS;
 
 template <typename Family>
-bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const size_t size) const {
+bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const {
     return size > KB;
 }
 
diff --git a/runtime/mem_obj/buffer.cpp b/runtime/mem_obj/buffer.cpp
@@ -156,7 +156,7 @@ Buffer *Buffer::create(Context *context,
         *context,
         HwHelper::renderCompressedBuffersSupported(context->getDevice(0)->getHardwareInfo()),
         memoryManager->isLocalMemorySupported(),
-        HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(size));
+        HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), size));
 
     checkMemory(memoryProperties, size, hostPtr, errcodeRet, alignementSatisfied, copyMemoryFromHostPtr, memoryManager);
 
diff --git a/unit_tests/context/driver_diagnostics_tests.cpp b/unit_tests/context/driver_diagnostics_tests.cpp
@@ -473,7 +473,7 @@ TEST_F(PerformanceHintTest, given64bitCompressedBufferWhenItsCreatedThenProperPe
     context->isSharedContext = false;
     auto buffer = std::unique_ptr<Buffer>(Buffer::create(context.get(), properties, size, static_cast<void *>(NULL), retVal));
     snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[BUFFER_IS_COMPRESSED], buffer.get());
-    auto compressionSupported = HwHelper::get(hwInfo.platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(size) &&
+    auto compressionSupported = HwHelper::get(hwInfo.platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(hwInfo, size) &&
                                 HwHelper::renderCompressedBuffersSupported(hwInfo);
     if (!is32bit && compressionSupported) {
         EXPECT_TRUE(containsHint(expectedHint, userData));
@@ -502,7 +502,7 @@ TEST_F(PerformanceHintTest, givenUncompressedBufferWhenItsCreatedThenProperPerfo
         isCompressed = MemObjHelper::isSuitableForRenderCompression(
                            HwHelper::renderCompressedBuffersSupported(hwInfo),
                            memoryProperties, *context,
-                           HwHelper::get(hwInfo.platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(size)) &&
+                           HwHelper::get(hwInfo.platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(hwInfo, size)) &&
                        !is32bit && !context->isSharedContext &&
                        (!isValueSet(properties.flags, CL_MEM_USE_HOST_PTR) || context->getMemoryManager()->isLocalMemorySupported()) &&
                        !isValueSet(properties.flags, CL_MEM_FORCE_SHARED_PHYSICAL_MEMORY_INTEL);
diff --git a/unit_tests/gen12lp/hw_helper_tests_gen12lp.cpp b/unit_tests/gen12lp/hw_helper_tests_gen12lp.cpp
@@ -84,24 +84,38 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, whenGetConfigureAddressSpaceModeThenReturnOne
     EXPECT_EQ(1u, helper.getConfigureAddressSpaceMode());
 }
 
-GEN12LPTEST_F(HwHelperTestGen12Lp, givenCompressionFtrEnabledWhenAskingForPageTableManagerThenReturnTrue) {
+GEN12LPTEST_F(HwHelperTestGen12Lp, givenCompressionFtrEnabledWhenAskingForPageTableManagerThenReturnCorrectValue) {
     auto &helper = HwHelper::get(renderCoreFamily);
 
     hardwareInfo.capabilityTable.ftrRenderCompressedBuffers = false;
     hardwareInfo.capabilityTable.ftrRenderCompressedImages = false;
-    EXPECT_FALSE(helper.isPageTableManagerSupported(hardwareInfo));
+    bool expectedPageTableManagerSupport = SpecialUltHelperGen12lp::isPageTableManagerSupported(hardwareInfo);
+    EXPECT_EQ(expectedPageTableManagerSupport, helper.isPageTableManagerSupported(hardwareInfo));
 
     hardwareInfo.capabilityTable.ftrRenderCompressedBuffers = true;
     hardwareInfo.capabilityTable.ftrRenderCompressedImages = false;
-    EXPECT_TRUE(helper.isPageTableManagerSupported(hardwareInfo));
+    expectedPageTableManagerSupport = SpecialUltHelperGen12lp::isPageTableManagerSupported(hardwareInfo);
+    EXPECT_EQ(expectedPageTableManagerSupport, helper.isPageTableManagerSupported(hardwareInfo));
 
     hardwareInfo.capabilityTable.ftrRenderCompressedBuffers = false;
     hardwareInfo.capabilityTable.ftrRenderCompressedImages = true;
-    EXPECT_TRUE(helper.isPageTableManagerSupported(hardwareInfo));
+    expectedPageTableManagerSupport = SpecialUltHelperGen12lp::isPageTableManagerSupported(hardwareInfo);
+    EXPECT_EQ(expectedPageTableManagerSupport, helper.isPageTableManagerSupported(hardwareInfo));
 
     hardwareInfo.capabilityTable.ftrRenderCompressedBuffers = true;
     hardwareInfo.capabilityTable.ftrRenderCompressedImages = true;
-    EXPECT_TRUE(helper.isPageTableManagerSupported(hardwareInfo));
+    expectedPageTableManagerSupport = SpecialUltHelperGen12lp::isPageTableManagerSupported(hardwareInfo);
+    EXPECT_EQ(expectedPageTableManagerSupport, helper.isPageTableManagerSupported(hardwareInfo));
+}
+
+GEN12LPTEST_F(HwHelperTestGen12Lp, givenDifferentSizesOfAllocationWhenCheckingCompressionPreferenceThenReturnCorrectValue) {
+    auto &helper = HwHelper::get(renderCoreFamily);
+
+    const size_t sizesToCheck[] = {128, 256, 512, 1023, 1024, 1025};
+    for (size_t size : sizesToCheck) {
+        EXPECT_EQ(SpecialUltHelperGen12lp::isRenderBufferCompressionPreferred(hardwareInfo, size),
+                  helper.obtainRenderBufferCompressionPreference(hardwareInfo, size));
+    }
 }
 
 GEN12LPTEST_F(HwHelperTestGen12Lp, whenGetGpgpuEnginesThenReturnTwoRcsEnginesAndOneCcsEngine) {
diff --git a/unit_tests/gen12lp/image_tests_gen12lp.cpp b/unit_tests/gen12lp/image_tests_gen12lp.cpp
@@ -9,11 +9,14 @@
 #include "runtime/memory_manager/memory_manager.h"
 #include "test.h"
 #include "unit_tests/fixtures/image_fixture.h"
+#include "unit_tests/gen12lp/special_ult_helper_gen12lp.h"
 #include "unit_tests/helpers/variable_backup.h"
 #include "unit_tests/mocks/mock_allocation_properties.h"
 #include "unit_tests/mocks/mock_context.h"
 #include "unit_tests/mocks/mock_gmm.h"
 
+#include "mock_gmm_client_context.h"
+
 #include <functional>
 
 using namespace NEO;
@@ -135,3 +138,24 @@ GEN12LPTEST_F(gen12LpImageTests, givenMediaCompressionSurfaceStateParamsAreSetFo
     EXPECT_TRUE(surfaceState.getMemoryCompressionEnable());
     EXPECT_EQ(surfaceState.getAuxiliarySurfaceMode(), RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
 }
+
+GEN12LPTEST_F(gen12LpImageTests, givenCompressionEnabledWhenAppendingSurfaceStateParamsForImageCompressionThenSetCompressionFormat) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+    using ImageHwTgllp = ImageHw<FamilyType>;
+    constexpr static uint8_t mockCompressionFormat = 13u;
+
+    RENDER_SURFACE_STATE rss{};
+    rss.setMemoryCompressionEnable(true);
+    MockContext context{};
+    std::unique_ptr<ImageHwTgllp> image{static_cast<ImageHwTgllp *>(ImageHelper<Image2dDefaults>::create(&context))};
+    MockGmmClientContext *gmmClientContext = static_cast<MockGmmClientContext *>(GmmHelper::getClientContext());
+
+    uint8_t expectedCompressionFormat = rss.getCompressionFormat();
+    if (SpecialUltHelperGen12lp::isAdditionalSurfaceStateParamForCompressionRequired(context.getDevice(0)->getHardwareInfo())) {
+        expectedCompressionFormat = mockCompressionFormat;
+    }
+
+    gmmClientContext->compressionFormatToReturn = mockCompressionFormat;
+    image->appendSurfaceStateParams(&rss);
+    EXPECT_EQ(expectedCompressionFormat, rss.getCompressionFormat());
+}
diff --git a/unit_tests/gen12lp/special_ult_helper_gen12lp.cpp b/unit_tests/gen12lp/special_ult_helper_gen12lp.cpp
@@ -31,4 +31,16 @@ bool SpecialUltHelperGen12lp::isPipeControlWArequired(PRODUCT_FAMILY productFami
     return true;
 }
 
+bool SpecialUltHelperGen12lp::isPageTableManagerSupported(const HardwareInfo &hwInfo) {
+    return hwInfo.capabilityTable.ftrRenderCompressedBuffers || hwInfo.capabilityTable.ftrRenderCompressedImages;
+}
+
+bool SpecialUltHelperGen12lp::isRenderBufferCompressionPreferred(const HardwareInfo &hwInfo, const std::size_t size) {
+    return false;
+}
+
+bool SpecialUltHelperGen12lp::isAdditionalSurfaceStateParamForCompressionRequired(const HardwareInfo &hwInfo) {
+    return false;
+}
+
 } // namespace NEO
diff --git a/unit_tests/gen12lp/special_ult_helper_gen12lp.h b/unit_tests/gen12lp/special_ult_helper_gen12lp.h
@@ -9,6 +9,8 @@
 
 #include "igfxfmid.h"
 
+#include <cstddef>
+
 namespace NEO {
 struct HardwareInfo;
 
@@ -18,5 +20,8 @@ struct SpecialUltHelperGen12lp {
     static bool shouldPerformimagePitchAlignment(PRODUCT_FAMILY productFamily);
     static bool shouldTestDefaultImplementationOfSetupHardwareCapabilities(PRODUCT_FAMILY productFamily);
     static bool isPipeControlWArequired(PRODUCT_FAMILY productFamily);
+    static bool isPageTableManagerSupported(const HardwareInfo &hwInfo);
+    static bool isRenderBufferCompressionPreferred(const HardwareInfo &hwInfo, const std::size_t size);
+    static bool isAdditionalSurfaceStateParamForCompressionRequired(const HardwareInfo &hwInfo);
 };
 } // namespace NEO
diff --git a/unit_tests/gen12lp/unit_test_helper_gen12lp.cpp b/unit_tests/gen12lp/unit_test_helper_gen12lp.cpp
@@ -21,7 +21,7 @@ bool UnitTestHelper<Family>::isL3ConfigProgrammable() {
 
 template <>
 bool UnitTestHelper<Family>::isPageTableManagerSupported(const HardwareInfo &hwInfo) {
-    return hwInfo.capabilityTable.ftrRenderCompressedBuffers || hwInfo.capabilityTable.ftrRenderCompressedImages;
+    return SpecialUltHelperGen12lp::isPageTableManagerSupported(hwInfo);
 }
 
 template <>
diff --git a/unit_tests/mem_obj/buffer_tests.cpp b/unit_tests/mem_obj/buffer_tests.cpp
@@ -587,7 +587,7 @@ TEST_F(RenderCompressedBuffersTests, givenBufferNotCompressedAllocationAndNoHost
         EXPECT_TRUE(buffer->isMemObjZeroCopy());
         EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
     } else {
-        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(bufferSize)) {
+        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), bufferSize)) {
             EXPECT_FALSE(buffer->isMemObjZeroCopy());
             EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
         } else {
@@ -605,7 +605,7 @@ TEST_F(RenderCompressedBuffersTests, givenBufferCompressedAllocationWhenSharedCo
     if (is32bit) {
         EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
     } else {
-        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(bufferSize)) {
+        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), bufferSize)) {
             EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
         } else {
             EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
@@ -626,7 +626,7 @@ TEST_F(RenderCompressedBuffersTests, givenDebugVariableSetWhenHwFlagIsNotSetThen
     if (is32bit) {
         EXPECT_NE(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
     } else {
-        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(bufferSize)) {
+        if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), bufferSize)) {
             EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
         } else {
             EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
@@ -677,7 +677,7 @@ TEST_F(RenderCompressedBuffersCopyHostMemoryTests, givenRenderCompressedBufferWh
     hwInfo->capabilityTable.ftrRenderCompressedBuffers = true;
 
     buffer.reset(Buffer::create(context.get(), CL_MEM_COPY_HOST_PTR, bufferSize, hostPtr, retVal));
-    if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(bufferSize)) {
+    if (HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), bufferSize)) {
         EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
         EXPECT_EQ(1u, mockCmdQ->writeBufferCounter);
         EXPECT_TRUE(mockCmdQ->writeBufferBlocking);
@@ -1175,7 +1175,7 @@ TEST_F(RenderCompressedBuffersCopyHostMemoryTests, givenNonRenderCompressedBuffe
 }
 
 TEST_F(RenderCompressedBuffersCopyHostMemoryTests, givenRenderCompressedBufferWhenWriteBufferFailsThenReturnErrorCode) {
-    if (is32bit || !HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(bufferSize)) {
+    if (is32bit || !HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), bufferSize)) {
         return;
     }
     hwInfo->capabilityTable.ftrRenderCompressedBuffers = true;
diff --git a/unit_tests/mocks/mock_gmm_client_context_base.cpp b/unit_tests/mocks/mock_gmm_client_context_base.cpp
diff --git a/unit_tests/mocks/mock_gmm_client_context_base.h b/unit_tests/mocks/mock_gmm_client_context_base.h

Original file line number	Diff line number	Diff line change
`@@ -42,12 +42,12 @@ bool HwHelperHw<Family>::isLocalMemoryEnabled(const HardwareInfo &hwInfo) const`
`42`	`42`
`43`	`43`	`template <>`
`44`	`44`	`bool HwHelperHw<Family>::isPageTableManagerSupported(const HardwareInfo &hwInfo) const {`
`45`		`- return hwInfo.capabilityTable.ftrRenderCompressedBuffers \|\| hwInfo.capabilityTable.ftrRenderCompressedImages;`
	`45`	`+ return Gen12LPHelpers::isPageTableManagerSupported(hwInfo);`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`template <>`
`49`		`-bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const size_t size) const {`
`50`		`- return false;`
	`49`	`+bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const {`
	`50`	`+ return Gen12LPHelpers::obtainRenderBufferCompressionPreference(hwInfo, size);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`template <>`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,9 @@ class GmmClientContextBase {`
`27`	`27`	`return std::make_unique<T>(clientType, gmmEntries);`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ MOCKABLE_VIRTUAL uint8_t getSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);`
	`31`	`+ MOCKABLE_VIRTUAL uint8_t getMediaSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);`
	`32`	`+`
`30`	`33`	`protected:`
`31`	`34`	`GMM_CLIENT_CONTEXT *clientContext;`
`32`	`35`	`GmmClientContextBase(GMM_CLIENT clientType, GmmExportEntries &gmmEntries);`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ template <typename Family>`
`23`	`23`	`const aub_stream::EngineType HwHelperHw<Family>::lowPriorityEngineType = aub_stream::EngineType::ENGINE_RCS;`
`24`	`24`
`25`	`25`	`template <typename Family>`
`26`		`-bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const size_t size) const {`
	`26`	`+bool HwHelperHw<Family>::obtainRenderBufferCompressionPreference(const HardwareInfo &hwInfo, const size_t size) const {`
`27`	`27`	`return size > KB;`
`28`	`28`	`}`
`29`	`29`