fix: add debug key to provide alternative directory for wddm residency logs

Related-To: NEO-8211

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>

shared/source/debug_settings/debug_variables_base.inl

@@ -93,6 +93,7 @@ DECLARE_DEBUG_VARIABLE(std::string, InjectInternalBuildOptions, std::string("unk
 DECLARE_DEBUG_VARIABLE(std::string, InjectApiBuildOptions, std::string("unk"), "Append provided string to api build options for user modules; ignored when unk")
 DECLARE_DEBUG_VARIABLE(std::string, OverrideDeviceName, std::string("unk"), "Override device name to provided string; ignored when unk")
 DECLARE_DEBUG_VARIABLE(std::string, OverridePlatformName, std::string("unk"), "Override platform name to provided string; ignored when unk")
+DECLARE_DEBUG_VARIABLE(std::string, WddmResidencyLoggerOutputDirectory, std::string("unk"), "Selects non-default output directory for Wddm Residency logger file")
 DECLARE_DEBUG_VARIABLE(int64_t, OverrideMultiStoragePlacement, -1, "Place memory only in selected tiles indicated by bit mask; ignore when -1")
 DECLARE_DEBUG_VARIABLE(int64_t, ForceCompressionDisabledForCompressedBlitCopies, -1, "If compression is required, set AUX_CCS_E, but force CompressionEnable filed; 0 should result in uncompressed read/write; values = -1: default, 0: disabled, 1: enabled")
 DECLARE_DEBUG_VARIABLE(int32_t, ForceL1Caching, -1, "Program L1 cache policy for surface state and stateless accesses; values = -1: default, 0: disable, 1: enable")

shared/source/os_interface/windows/wddm/wddm.cpp

@@ -1236,7 +1236,7 @@ uint32_t Wddm::getRequestedEUCount() const {
 
 void Wddm::createPagingFenceLogger() {
     if (DebugManager.flags.WddmResidencyLogger.get()) {
-        residencyLogger = std::make_unique<WddmResidencyLogger>(device, pagingFenceAddress);
+        residencyLogger = std::make_unique<WddmResidencyLogger>(device, pagingFenceAddress, DebugManager.flags.WddmResidencyLoggerOutputDirectory.get());
     }
 }
 

shared/source/os_interface/windows/wddm/wddm_residency_logger.h

@@ -11,6 +11,7 @@
 #include "shared/source/utilities/io_functions.h"
 
 #include <chrono>
+#include <cstring>
 #include <sstream>
 
 namespace NEO {
@@ -23,13 +24,23 @@ constexpr bool wddmResidencyLoggingAvailable = false;
 
 class WddmResidencyLogger {
   public:
-    WddmResidencyLogger(unsigned int device, void *fenceValueCpuVirtualAddress) {
+    WddmResidencyLogger(unsigned int device, void *fenceValueCpuVirtualAddress, std::string outDirectory) {
+        const char *wddmResidencyLoggerDefaultDirectory = "unk";
+
         std::stringstream id;
         id << std::hex;
         id << "device-0x" << device << "_"
            << "pfencecpu-0x" << fenceValueCpuVirtualAddress;
+
         std::stringstream filename;
+        if (std::strcmp(wddmResidencyLoggerDefaultDirectory, outDirectory.c_str()) != 0) {
+            filename << outDirectory;
+            if (outDirectory.back() != '\\') {
+                filename << "\\";
+            }
+        }
         filename << "pagingfence_" << id.str() << ".log";
+
         pagingLog = IoFunctions::fopenPtr(filename.str().c_str(), "at");
         UNRECOVERABLE_IF(pagingLog == nullptr);
         IoFunctions::fprintf(pagingLog, "%s\n", id.str().c_str());

shared/test/common/mocks/mock_wddm.cpp

@@ -323,7 +323,7 @@ void WddmMock::createPagingFenceLogger() {
         Wddm::createPagingFenceLogger();
     } else {
         if (DebugManager.flags.WddmResidencyLogger.get()) {
-            residencyLogger = std::make_unique<MockWddmResidencyLogger>(device, pagingFenceAddress);
+            residencyLogger = std::make_unique<MockWddmResidencyLogger>(device, pagingFenceAddress, DebugManager.flags.WddmResidencyLoggerOutputDirectory.get());
         }
     }
 }

shared/test/common/test_files/igdrcl.config

@@ -475,6 +475,7 @@ OverrideCmdListCmdBufferSizeInKb = -1
 ForceUncachedGmmUsageType = 0
 OverrideDeviceName = unk
 OverridePlatformName = unk
+WddmResidencyLoggerOutputDirectory = unk
 EnablePrivateBO = 0
 ExperimentalEnableDeviceAllocationCache = -1
 OverrideL1CachePolicyInSurfaceStateAndStateless = -1

shared/test/unit_test/os_interface/windows/wddm20_tests.cpp

@@ -1388,13 +1388,36 @@ TEST(HwDeviceId, whenHwDeviceIdIsDestroyedThenAdapterIsClosed) {
     EXPECT_EQ(adapter, GdiWithMockedCloseFunc::closeAdapterCalledArgPassed);
 }
 
-TEST_F(WddmTest, WhenResidencyLoggingEnabledThenExpectLoggerCreated) {
+namespace MockWddmResidencyLoggerFunctions {
+std::string recordedFileName(256, 0);
+
+FILE *testFopen(const char *filename, const char *mode) {
+    MockWddmResidencyLoggerFunctions::recordedFileName.assign(filename);
+    return NEO::IoFunctions::mockFopen(filename, mode);
+}
+} // namespace MockWddmResidencyLoggerFunctions
+
+struct WddmResidencyLoggerTest : public WddmTest {
+    void SetUp() override {
+        MockWddmResidencyLoggerFunctions::recordedFileName.clear();
+
+        WddmTest::SetUp();
+
         NEO::IoFunctions::mockFopenCalled = 0;
         NEO::IoFunctions::mockVfptrinfCalled = 0;
         NEO::IoFunctions::mockFcloseCalled = 0;
-    DebugManagerStateRestore dbgRestore;
+
         DebugManager.flags.WddmResidencyLogger.set(true);
 
+        mockFopenBackup = std::make_unique<VariableBackup<NEO::IoFunctions::fopenFuncPtr>>(&NEO::IoFunctions::fopenPtr);
+        NEO::IoFunctions::fopenPtr = &MockWddmResidencyLoggerFunctions::testFopen;
+    }
+
+    DebugManagerStateRestore dbgRestore;
+    std::unique_ptr<VariableBackup<NEO::IoFunctions::fopenFuncPtr>> mockFopenBackup;
+};
+
+TEST_F(WddmResidencyLoggerTest, WhenResidencyLoggingEnabledThenExpectLoggerCreated) {
     wddm->createPagingFenceLogger();
     EXPECT_NE(nullptr, wddm->residencyLogger.get());
     wddm->residencyLogger.reset();
@@ -1405,16 +1428,10 @@ TEST_F(WddmTest, WhenResidencyLoggingEnabledThenExpectLoggerCreated) {
     }
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentSuccessThenExpectSizeRapport) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenMakeResidentSuccessThenExpectSizeRapport) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
     wddm->callBaseMakeResident = true;
 
@@ -1432,16 +1449,10 @@ TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentSuccessThenExpectSi
     EXPECT_EQ(MockGdi::pagingFenceReturnValue, logger->makeResidentPagingFence);
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentFailThenExpectTrimReport) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenMakeResidentFailThenExpectTrimReport) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
     wddm->callBaseMakeResident = true;
 
@@ -1470,16 +1481,10 @@ TEST_F(WddmTest, GivenInvalidHandleAndCantTrimFurtherSetToTrueWhenCallingMakeRes
     EXPECT_FALSE(retVal);
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenEnterWaitCalledThenExpectInternalFlagOn) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenEnterWaitCalledThenExpectInternalFlagOn) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
 
     wddm->createPagingFenceLogger();
@@ -1489,16 +1494,10 @@ TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenEnterWaitCalledThenExpectIntern
     EXPECT_TRUE(logger->enterWait);
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingThenExpectFlagsOff) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingThenExpectFlagsOff) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
     wddm->callBaseMakeResident = true;
 
@@ -1523,16 +1522,10 @@ TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingThenEx
     EXPECT_EQ(MockGdi::pagingFenceReturnValue, logger->startWaitPagingFenceSave);
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingOnGpuThenExpectFlagsOff) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingOnGpuThenExpectFlagsOff) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
     wddm->callBaseMakeResident = true;
 
@@ -1557,16 +1550,10 @@ TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentAndWaitPagingOnGpuT
     EXPECT_EQ(MockGdi::pagingFenceReturnValue, logger->startWaitPagingFenceSave);
 }
 
-TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentRequiresTrimToBudgetAndWaitPagingOnGpuThenExpectProperLoggingCount) {
+TEST_F(WddmResidencyLoggerTest, GivenResidencyLoggingEnabledWhenMakeResidentRequiresTrimToBudgetAndWaitPagingOnGpuThenExpectProperLoggingCount) {
     if (!NEO::wddmResidencyLoggingAvailable) {
         GTEST_SKIP();
     }
-    NEO::IoFunctions::mockFopenCalled = 0;
-    NEO::IoFunctions::mockVfptrinfCalled = 0;
-    NEO::IoFunctions::mockFcloseCalled = 0;
-
-    DebugManagerStateRestore dbgRestore;
-    DebugManager.flags.WddmResidencyLogger.set(true);
     wddm->callBaseCreatePagingLogger = false;
     wddm->callBaseMakeResident = true;
 
@@ -1590,6 +1577,51 @@ TEST_F(WddmTest, GivenResidencyLoggingEnabledWhenMakeResidentRequiresTrimToBudge
     EXPECT_FALSE(logger->enterWait);
 }
 
+TEST_F(WddmResidencyLoggerTest, givenResidencyLoggingEnabledWhenDefaultDirectorySelectedThenDoNotUseDirectoryName) {
+    std::string defaultDirectory("unk");
+    std::string filenameLead("pagingfence_device-0x");
+
+    wddm->createPagingFenceLogger();
+    EXPECT_NE(nullptr, wddm->residencyLogger.get());
+
+    EXPECT_EQ(std::string::npos, MockWddmResidencyLoggerFunctions::recordedFileName.find(defaultDirectory));
+    EXPECT_EQ(0u, MockWddmResidencyLoggerFunctions::recordedFileName.find(filenameLead));
+}
+
+TEST_F(WddmResidencyLoggerTest, givenResidencyLoggingEnabledWhenNonDefaultDirectorySelectedWithoutTrailingBackslashThenUseDirectoryNameWithAddedSlash) {
+    std::string nonDefaultDirectory("c:\\temp\\logs");
+    std::string filenameLead("pagingfence_device-0x");
+
+    DebugManager.flags.WddmResidencyLoggerOutputDirectory.set(nonDefaultDirectory);
+
+    wddm->createPagingFenceLogger();
+    EXPECT_NE(nullptr, wddm->residencyLogger.get());
+
+    EXPECT_EQ(0u, MockWddmResidencyLoggerFunctions::recordedFileName.find(nonDefaultDirectory));
+
+    auto backslashPos = nonDefaultDirectory.length();
+    auto pos = MockWddmResidencyLoggerFunctions::recordedFileName.find('\\', backslashPos);
+    EXPECT_EQ(backslashPos, pos);
+
+    auto filenameLeadPos = backslashPos + 1;
+    EXPECT_EQ(filenameLeadPos, MockWddmResidencyLoggerFunctions::recordedFileName.find(filenameLead));
+}
+
+TEST_F(WddmResidencyLoggerTest, givenResidencyLoggingEnabledWhenNonDefaultDirectorySelectedWithTrailingBackslashThenUseDirectoryNameWithoutAddingSlash) {
+    std::string nonDefaultDirectory("c:\\temp\\logs\\");
+    std::string filenameLead("pagingfence_device-0x");
+
+    DebugManager.flags.WddmResidencyLoggerOutputDirectory.set(nonDefaultDirectory);
+
+    wddm->createPagingFenceLogger();
+    EXPECT_NE(nullptr, wddm->residencyLogger.get());
+
+    EXPECT_EQ(0u, MockWddmResidencyLoggerFunctions::recordedFileName.find(nonDefaultDirectory));
+
+    auto filenameLeadPos = nonDefaultDirectory.length();
+    EXPECT_EQ(filenameLeadPos, MockWddmResidencyLoggerFunctions::recordedFileName.find(filenameLead));
+}
+
 TEST(VerifyAdapterType, whenAdapterDoesntSupportRenderThenDontCreateHwDeviceId) {
     auto gdi = std::make_unique<MockGdi>();
     auto osEnv = std::make_unique<OsEnvironmentWin>();