Add debug flag to control RenderCompressed value in HardwareInfo

Change-Id: I733125fbd8596f24cdeb636b69a9198c44bd899b
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>

Author: BartoszDunajski

runtime/helpers/hw_helper.cpp

@@ -6,11 +6,27 @@
  */
 
 #include "runtime/helpers/hw_helper.h"
+#include "runtime/os_interface/debug_settings_manager.h"
 
 namespace OCLRT {
 HwHelper *hwHelperFactory[IGFX_MAX_CORE] = {};
 
 HwHelper &HwHelper::get(GFXCORE_FAMILY gfxCore) {
     return *hwHelperFactory[gfxCore];
 }
+
+bool HwHelper::renderCompressedBuffersSupported(const HardwareInfo &hwInfo) {
+    if (DebugManager.flags.RenderCompressedBuffersEnabled.get() != -1) {
+        return !!DebugManager.flags.RenderCompressedBuffersEnabled.get();
+    }
+    return hwInfo.capabilityTable.ftrRenderCompressedBuffers;
+}
+
+bool HwHelper::renderCompressedImagesSupported(const HardwareInfo &hwInfo) {
+    if (DebugManager.flags.RenderCompressedImagesEnabled.get() != -1) {
+        return !!DebugManager.flags.RenderCompressedImagesEnabled.get();
+    }
+    return hwInfo.capabilityTable.ftrRenderCompressedImages;
+}
+
 } // namespace OCLRT

runtime/helpers/hw_helper.h

@@ -39,6 +39,8 @@ class HwHelper {
     virtual bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const = 0;
     virtual const AubMemDump::LrcaHelper &getCsTraits(EngineInstanceT engineInstance) const = 0;
     virtual bool supportsYTiling() const = 0;
+    static bool renderCompressedBuffersSupported(const HardwareInfo &hwInfo);
+    static bool renderCompressedImagesSupported(const HardwareInfo &hwInfo);
     virtual bool timestampPacketWriteSupported() const = 0;
     virtual size_t getRenderSurfaceStateSize() const = 0;
     virtual void setRenderSurfaceStateForBuffer(ExecutionEnvironment &executionEnvironment,

runtime/kernel/kernel.cpp

@@ -328,7 +328,7 @@ cl_int Kernel::initialize() {
                 kernelArguments[i].type = BUFFER_OBJ;
                 usingBuffers = true;
                 this->auxTranslationRequired |= !kernelInfo.kernelArgInfo[i].pureStatefulBufferAccess &&
-                                                getDevice().getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers;
+                                                HwHelper::renderCompressedBuffersSupported(getDevice().getHardwareInfo());
             } else if (argInfo.isImage) {
                 kernelArgHandlers[i] = &Kernel::setArgImage;
                 kernelArguments[i].type = IMAGE_OBJ;

runtime/mem_obj/buffer.cpp

@@ -13,6 +13,7 @@
 #include "runtime/gmm_helper/gmm.h"
 #include "runtime/gmm_helper/gmm_helper.h"
 #include "runtime/helpers/aligned_memory.h"
+#include "runtime/helpers/hw_helper.h"
 #include "runtime/helpers/hw_info.h"
 #include "runtime/helpers/ptr_math.h"
 #include "runtime/helpers/string.h"
@@ -129,7 +130,7 @@ Buffer *Buffer::create(Context *context,
     GraphicsAllocation::AllocationType allocationType = getGraphicsAllocationType(
         properties.flags,
         context->isSharedContext,
-        context->getDevice(0)->getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers);
+        HwHelper::renderCompressedBuffersSupported(context->getDevice(0)->getHardwareInfo()));
 
     MemoryManager *memoryManager = context->getMemoryManager();
     UNRECOVERABLE_IF(!memoryManager);

runtime/os_interface/debug_variables_base.inl

@@ -104,6 +104,8 @@ DECLARE_DEBUG_VARIABLE(int32_t, OverrideDelayQuickKmdSleepForSporadicWaitsMicros
 DECLARE_DEBUG_VARIABLE(int32_t, PowerSavingMode, 0, "0: default 1: enable. Whenever driver waits on GPU and its not ready, put waiting thread to sleep and wait for notification.")
 DECLARE_DEBUG_VARIABLE(int32_t, CsrDispatchMode, 0, "Chooses DispatchMode for Csr")
 DECLARE_DEBUG_VARIABLE(int32_t, OverrideDefaultFP64Settings, -1, "-1: dont override, 0: disable, 1: enable.")
+DECLARE_DEBUG_VARIABLE(int32_t, RenderCompressedImagesEnabled, -1, "-1: default, 0: disabled, 1: enabled")
+DECLARE_DEBUG_VARIABLE(int32_t, RenderCompressedBuffersEnabled, -1, "-1: default, 0: disabled, 1: enabled")
 
 /*DRIVER TOGGLES*/
 DECLARE_DEBUG_VARIABLE(int32_t, ForceOCLVersion, 0, "Force specific OpenCL API version")

unit_tests/helpers/hw_helper_tests.cpp

@@ -28,6 +28,37 @@ void HwHelperFixture::TearDown() {
     DeviceFixture::TearDown();
 }
 
+TEST(HwHelperSimpleTest, givenDebugVariableWhenAskingForRenderCompressionThenReturnCorrectValue) {
+    DebugManagerStateRestore restore;
+    HardwareInfo localHwInfo = **platformDevices;
+
+    // debug variable not set
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = false;
+    localHwInfo.capabilityTable.ftrRenderCompressedImages = false;
+    EXPECT_FALSE(HwHelper::renderCompressedBuffersSupported(localHwInfo));
+    EXPECT_FALSE(HwHelper::renderCompressedImagesSupported(localHwInfo));
+
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = true;
+    localHwInfo.capabilityTable.ftrRenderCompressedImages = true;
+    EXPECT_TRUE(HwHelper::renderCompressedBuffersSupported(localHwInfo));
+    EXPECT_TRUE(HwHelper::renderCompressedImagesSupported(localHwInfo));
+
+    // debug variable set
+    DebugManager.flags.RenderCompressedBuffersEnabled.set(1);
+    DebugManager.flags.RenderCompressedImagesEnabled.set(1);
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = false;
+    localHwInfo.capabilityTable.ftrRenderCompressedImages = false;
+    EXPECT_TRUE(HwHelper::renderCompressedBuffersSupported(localHwInfo));
+    EXPECT_TRUE(HwHelper::renderCompressedImagesSupported(localHwInfo));
+
+    DebugManager.flags.RenderCompressedBuffersEnabled.set(0);
+    DebugManager.flags.RenderCompressedImagesEnabled.set(0);
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = true;
+    localHwInfo.capabilityTable.ftrRenderCompressedImages = true;
+    EXPECT_FALSE(HwHelper::renderCompressedBuffersSupported(localHwInfo));
+    EXPECT_FALSE(HwHelper::renderCompressedImagesSupported(localHwInfo));
+}
+
 TEST_F(HwHelperTest, getReturnsValidHwHelperHw) {
     auto &helper = HwHelper::get(renderCoreFamily);
     EXPECT_NE(nullptr, &helper);

unit_tests/kernel/kernel_tests.cpp

@@ -2337,3 +2337,21 @@ TEST(KernelTest, givenFtrRenderCompressedBuffersWhenInitializingArgsWithNonState
     kernel.mockKernel->initialize();
     EXPECT_TRUE(kernel.mockKernel->isAuxTranslationRequired());
 }
+
+TEST(KernelTest, givenDebugVariableSetWhenKernelHasStatefulBufferAccessThenMarkKernelForAuxTranslation) {
+    DebugManagerStateRestore restore;
+    HardwareInfo localHwInfo = *platformDevices[0];
+
+    DebugManager.flags.RenderCompressedBuffersEnabled.set(1);
+
+    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&localHwInfo));
+    MockKernelWithInternals kernel(*device);
+    kernel.kernelInfo.kernelArgInfo.resize(1);
+    kernel.kernelInfo.kernelArgInfo.at(0).typeStr = "char *";
+
+    kernel.kernelInfo.kernelArgInfo.at(0).pureStatefulBufferAccess = false;
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = false;
+
+    kernel.mockKernel->initialize();
+    EXPECT_TRUE(kernel.mockKernel->isAuxTranslationRequired());
+}

unit_tests/mem_obj/buffer_tests.cpp

@@ -473,6 +473,24 @@ TEST_F(RenderCompressedBuffersTests, givenBufferCompressedAllocationWhenSharedCo
     EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
 }
 
+TEST_F(RenderCompressedBuffersTests, givenDebugVariableSetWhenHwFlagIsNotSetThenSelectOptionFromDebugFlag) {
+    DebugManagerStateRestore restore;
+
+    localHwInfo.capabilityTable.ftrRenderCompressedBuffers = false;
+
+    DebugManager.flags.RenderCompressedBuffersEnabled.set(1);
+    buffer.reset(Buffer::create(context.get(), 0, sizeof(uint32_t), nullptr, retVal));
+    if (is32bit) {
+        EXPECT_NE(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
+    } else {
+        EXPECT_EQ(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
+    }
+
+    DebugManager.flags.RenderCompressedBuffersEnabled.set(0);
+    buffer.reset(Buffer::create(context.get(), 0, sizeof(uint32_t), nullptr, retVal));
+    EXPECT_NE(buffer->getGraphicsAllocation()->getAllocationType(), GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
+}
+
 TEST_F(RenderCompressedBuffersTests, givenSvmAllocationWhenCreatingBufferThenForceDisableCompression) {
     localHwInfo.capabilityTable.ftrRenderCompressedBuffers = true;
 

unit_tests/test_files/igdrcl.config

@@ -98,3 +98,5 @@ PowerSavingMode = 0
 AubDumpAddMmioRegistersList = unk
 ForceResourceLockOnTransferCalls = 0
 EnableMakeResidentOnMapGpuVa = 0
+RenderCompressedImagesEnabled = -1
+RenderCompressedBuffersEnabled = -1