[1/n] Initialize WDDM only once

adamstefanowski · Compute-Runtime-Automation · commit 8a005434f46d · 2018-09-06T14:14:29.000+02:00
- remove Wddm parameter from WddmCommandStreamReceiver
and pass it via ExecutionEnvironment
- remove drm parameter from DrmCommandStreamReceiver
and pass it via ExecutionEnvironment
- remove void parametr from TbxCommandStreamReceiverHw

Change-Id: Ib76332f1341339426e86e0ce2b6ce96919219881
diff --git a/runtime/command_stream/command_stream_receiver_with_aub_dump.inl b/runtime/command_stream/command_stream_receiver_with_aub_dump.inl
@@ -29,7 +29,7 @@ extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[2 * IGFX_MAX
 
 template <typename BaseCSR>
 CommandStreamReceiverWithAUBDump<BaseCSR>::CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)
-    : BaseCSR(hwInfoIn, nullptr, executionEnvironment) {
+    : BaseCSR(hwInfoIn, executionEnvironment) {
     aubCSR = AUBCommandStreamReceiver::create(hwInfoIn, "aubfile", false, executionEnvironment);
 }
 
diff --git a/runtime/command_stream/tbx_command_stream_receiver_hw.h b/runtime/command_stream/tbx_command_stream_receiver_hw.h
@@ -60,7 +60,7 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverHw<GfxFamily> {
 
     static CommandStreamReceiver *create(const HardwareInfo &hwInfoIn, bool withAubDump, ExecutionEnvironment &executionEnvironment);
 
-    TbxCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, void *ptr, ExecutionEnvironment &executionEnvironment);
+    TbxCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment);
     ~TbxCommandStreamReceiverHw() override;
 
     void initializeEngine(EngineType engineType);
diff --git a/runtime/command_stream/tbx_command_stream_receiver_hw.inl b/runtime/command_stream/tbx_command_stream_receiver_hw.inl
@@ -32,7 +32,8 @@
 namespace OCLRT {
 
 template <typename GfxFamily>
-TbxCommandStreamReceiverHw<GfxFamily>::TbxCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, void *ptr, ExecutionEnvironment &executionEnvironment)
+TbxCommandStreamReceiverHw<GfxFamily>::TbxCommandStreamReceiverHw(const HardwareInfo &hwInfoIn,
+                                                                  ExecutionEnvironment &executionEnvironment)
     : BaseClass(hwInfoIn, executionEnvironment) {
     for (auto &engineInfo : engineInfoTable) {
         engineInfo.pLRCA = nullptr;
@@ -175,7 +176,7 @@ CommandStreamReceiver *TbxCommandStreamReceiverHw<GfxFamily>::create(const Hardw
     if (withAubDump) {
         csr = new CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<GfxFamily>>(hwInfoIn, executionEnvironment);
     } else {
-        csr = new TbxCommandStreamReceiverHw<GfxFamily>(hwInfoIn, nullptr, executionEnvironment);
+        csr = new TbxCommandStreamReceiverHw<GfxFamily>(hwInfoIn, executionEnvironment);
     }
 
     // Open our stream
diff --git a/runtime/os_interface/linux/device_command_stream.inl b/runtime/os_interface/linux/device_command_stream.inl
@@ -33,7 +33,7 @@ CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const Hard
     if (withAubDump) {
         return new CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);
     } else {
-        return new DrmCommandStreamReceiver<GfxFamily>(hwInfo, nullptr, executionEnvironment);
+        return new DrmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);
     }
 };
 } // namespace OCLRT
diff --git a/runtime/os_interface/linux/drm_command_stream.h b/runtime/os_interface/linux/drm_command_stream.h
@@ -48,7 +48,8 @@ class DrmCommandStreamReceiver : public DeviceCommandStreamReceiver<GfxFamily> {
   public:
     // When drm is null default implementation is used. In this case DrmCommandStreamReceiver is responsible to free drm.
     // When drm is passed, DCSR will not free it at destruction
-    DrmCommandStreamReceiver(const HardwareInfo &hwInfoIn, Drm *drm, ExecutionEnvironment &executionEnvironment, gemCloseWorkerMode mode = gemCloseWorkerMode::gemCloseWorkerActive);
+    DrmCommandStreamReceiver(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment,
+                             gemCloseWorkerMode mode = gemCloseWorkerMode::gemCloseWorkerActive);
 
     FlushStamp flush(BatchBuffer &batchBuffer, EngineType engineType, ResidencyContainer *allocationsForResidency, OsContext &osContext) override;
     void makeResident(GraphicsAllocation &gfxAllocation) override;
diff --git a/runtime/os_interface/linux/drm_command_stream.inl b/runtime/os_interface/linux/drm_command_stream.inl
@@ -41,14 +41,19 @@ namespace OCLRT {
 
 template <typename GfxFamily>
 DrmCommandStreamReceiver<GfxFamily>::DrmCommandStreamReceiver(const HardwareInfo &hwInfoIn,
-                                                              Drm *drm, ExecutionEnvironment &executionEnvironment, gemCloseWorkerMode mode)
+                                                              ExecutionEnvironment &executionEnvironment, gemCloseWorkerMode mode)
     : BaseClass(hwInfoIn, executionEnvironment), gemCloseWorkerOperationMode(mode) {
-    this->drm = drm ? drm : Drm::get(0);
-    residency.reserve(512);
-    execObjectsStorage.reserve(512);
     if (!executionEnvironment.osInterface) {
         executionEnvironment.osInterface = std::make_unique<OSInterface>();
+        this->drm = Drm::get(0);
+    } else {
+        this->drm = executionEnvironment.osInterface->get()->getDrm()
+                        ? executionEnvironment.osInterface->get()->getDrm()
+                        : Drm::get(0);
     }
+    residency.reserve(512);
+    execObjectsStorage.reserve(512);
+
     executionEnvironment.osInterface->get()->setDrm(this->drm);
     CommandStreamReceiver::osInterface = executionEnvironment.osInterface.get();
     auto gmmHelper = platform()->peekExecutionEnvironment()->getGmmHelper();
diff --git a/runtime/os_interface/windows/device_command_stream.inl b/runtime/os_interface/windows/device_command_stream.inl
@@ -37,7 +37,7 @@ CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const Hard
     if (withAubDump) {
         return new CommandStreamReceiverWithAUBDump<WddmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);
     } else {
-        return new WddmCommandStreamReceiver<GfxFamily>(hwInfo, nullptr, executionEnvironment);
+        return new WddmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);
     }
 }
 } // namespace OCLRT
diff --git a/runtime/os_interface/windows/wddm_device_command_stream.h b/runtime/os_interface/windows/wddm_device_command_stream.h
@@ -37,7 +37,7 @@ class WddmCommandStreamReceiver : public DeviceCommandStreamReceiver<GfxFamily>
     using CommandStreamReceiverHw<GfxFamily>::CommandStreamReceiver::memoryManager;
 
   public:
-    WddmCommandStreamReceiver(const HardwareInfo &hwInfoIn, Wddm *wddm, ExecutionEnvironment &executionEnvironment);
+    WddmCommandStreamReceiver(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment);
     virtual ~WddmCommandStreamReceiver();
 
     FlushStamp flush(BatchBuffer &batchBuffer, EngineType engineType, ResidencyContainer *allocationsForResidency, OsContext &osContext) override;
diff --git a/runtime/os_interface/windows/wddm_device_command_stream.inl b/runtime/os_interface/windows/wddm_device_command_stream.inl
@@ -49,21 +49,26 @@ namespace OCLRT {
 DECLARE_COMMAND_BUFFER(CommandBufferHeader, UMD_OCL, FALSE, FALSE, PERFTAG_OCL);
 
 template <typename GfxFamily>
-WddmCommandStreamReceiver<GfxFamily>::WddmCommandStreamReceiver(const HardwareInfo &hwInfoIn, Wddm *wddm, ExecutionEnvironment &executionEnvironment)
+WddmCommandStreamReceiver<GfxFamily>::WddmCommandStreamReceiver(const HardwareInfo &hwInfoIn,
+                                                                ExecutionEnvironment &executionEnvironment)
     : BaseClass(hwInfoIn, executionEnvironment) {
-    this->wddm = wddm;
-    if (this->wddm == nullptr) {
+
+    if (!executionEnvironment.osInterface) {
+        executionEnvironment.osInterface = std::make_unique<OSInterface>();
         this->wddm = Wddm::createWddm();
+        this->osInterface = executionEnvironment.osInterface.get();
+        this->osInterface->get()->setWddm(this->wddm);
+    } else {
+        this->wddm = executionEnvironment.osInterface->get()->getWddm();
+        this->osInterface = executionEnvironment.osInterface.get();
     }
+
     GPUNODE_ORDINAL nodeOrdinal = GPUNODE_3D;
     UNRECOVERABLE_IF(!WddmEngineMapper<GfxFamily>::engineNodeMap(hwInfoIn.capabilityTable.defaultEngineType, nodeOrdinal));
     this->wddm->setNode(nodeOrdinal);
     PreemptionMode preemptionMode = PreemptionHelper::getDefaultPreemptionMode(hwInfoIn);
     this->wddm->setPreemptionMode(preemptionMode);
 
-    executionEnvironment.osInterface.reset(new OSInterface());
-    this->osInterface = executionEnvironment.osInterface.get();
-    this->osInterface->get()->setWddm(this->wddm);
     commandBufferHeader = new COMMAND_BUFFER_HEADER;
     *commandBufferHeader = CommandBufferHeader;
 
diff --git a/unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp b/unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
@@ -32,7 +32,8 @@
 using namespace OCLRT;
 
 struct MyMockCsr : UltCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> {
-    MyMockCsr(const HardwareInfo &hwInfoIn, void *ptr, ExecutionEnvironment &executionEnvironment) : UltCommandStreamReceiver(hwInfoIn, executionEnvironment) {
+    MyMockCsr(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)
+        : UltCommandStreamReceiver(hwInfoIn, executionEnvironment) {
     }
 
     FlushStamp flush(BatchBuffer &batchBuffer, EngineType engineOrdinal, ResidencyContainer *allocationsForResidency, OsContext &osContext) override {
@@ -101,7 +102,7 @@ struct MyMockCsrWithAubDump : CommandStreamReceiverWithAUBDump<BaseCSR> {
         }
         if (createAubCSR) {
             // overwrite with mock
-            this->aubCSR = new MyMockCsr(hwInfoIn, nullptr, executionEnvironment);
+            this->aubCSR = new MyMockCsr(hwInfoIn, executionEnvironment);
         }
     }
 
diff --git a/unit_tests/command_stream/tbx_command_stream_tests.cpp b/unit_tests/command_stream/tbx_command_stream_tests.cpp
@@ -58,7 +58,8 @@ template <typename GfxFamily>
 class MockTbxCsr : public TbxCommandStreamReceiverHw<GfxFamily> {
   public:
     using CommandStreamReceiver::latestFlushedTaskCount;
-    MockTbxCsr(const HardwareInfo &hwInfoIn, void *ptr, ExecutionEnvironment &executionEnvironment) : TbxCommandStreamReceiverHw<GfxFamily>(hwInfoIn, ptr, executionEnvironment) {}
+    MockTbxCsr(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)
+        : TbxCommandStreamReceiverHw<GfxFamily>(hwInfoIn, executionEnvironment) {}
 
     void makeCoherent(GraphicsAllocation &gfxAllocation) override {
         auto tagAddress = reinterpret_cast<uint32_t *>(gfxAllocation.getUnderlyingBuffer());
@@ -318,7 +319,7 @@ HWTEST_F(TbxCommandStreamTests, givenDbgDeviceIdFlagIsSetWhenTbxCsrIsCreatedThen
 
 HWTEST_F(TbxCommandSteamSimpleTest, givenTbxCsrWhenWaitBeforeMakeNonResidentWhenRequiredIsCalledWithBlockingFlagTrueThenFunctionStallsUntilMakeCoherentUpdatesTagAddress) {
     uint32_t tag = 0;
-    MockTbxCsr<FamilyType> tbxCsr(*platformDevices[0], &tag, *pDevice->executionEnvironment);
+    MockTbxCsr<FamilyType> tbxCsr(*platformDevices[0], *pDevice->executionEnvironment);
     GraphicsAllocation graphicsAllocation(&tag, sizeof(tag));
     tbxCsr.setTagAllocation(&graphicsAllocation);
 
diff --git a/unit_tests/os_interface/linux/device_command_stream_tests.cpp b/unit_tests/os_interface/linux/device_command_stream_tests.cpp
@@ -28,6 +28,7 @@
 #include "runtime/command_stream/linear_stream.h"
 #include "runtime/os_interface/linux/device_command_stream.inl"
 #include "runtime/os_interface/linux/drm_command_stream.h"
+#include "runtime/os_interface/linux/os_interface.h"
 #include "hw_cmds.h"
 #include "unit_tests/fixtures/device_fixture.h"
 #include "test.h"
@@ -39,21 +40,32 @@ using namespace OCLRT;
 typedef Test<DeviceFixture> DeviceCommandStreamLeaksTest;
 
 HWTEST_F(DeviceCommandStreamLeaksTest, Create) {
+    this->executionEnvironment.osInterface = std::make_unique<OSInterface>();
     std::unique_ptr<CommandStreamReceiver> ptr(DeviceCommandStreamReceiver<FamilyType>::create(*platformDevices[0], false, this->executionEnvironment));
     DrmMockSuccess mockDrm;
     EXPECT_NE(nullptr, ptr);
 }
 
 HWTEST_F(DeviceCommandStreamLeaksTest, givenDefaultDrmCsrWhenItIsCreatedThenGemCloseWorkerInactiveModeIsSelected) {
+    this->executionEnvironment.osInterface = std::make_unique<OSInterface>();
     std::unique_ptr<CommandStreamReceiver> ptr(DeviceCommandStreamReceiver<FamilyType>::create(*platformDevices[0], false, this->executionEnvironment));
     auto drmCsr = (DrmCommandStreamReceiver<FamilyType> *)ptr.get();
     EXPECT_EQ(drmCsr->peekGemCloseWorkerOperationMode(), gemCloseWorkerMode::gemCloseWorkerActive);
 }
 
 HWTEST_F(DeviceCommandStreamLeaksTest, givenDefaultDrmCsrWithAubDumWhenItIsCreatedThenGemCloseWorkerInactiveModeIsSelected) {
+    this->executionEnvironment.osInterface = std::make_unique<OSInterface>();
     std::unique_ptr<CommandStreamReceiver> ptr(DeviceCommandStreamReceiver<FamilyType>::create(*platformDevices[0], true, this->executionEnvironment));
     auto drmCsrWithAubDump = (CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<FamilyType>> *)ptr.get();
     EXPECT_EQ(drmCsrWithAubDump->peekGemCloseWorkerOperationMode(), gemCloseWorkerMode::gemCloseWorkerActive);
     auto aubCSR = static_cast<CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<FamilyType>> *>(ptr.get())->aubCSR;
     EXPECT_NE(nullptr, aubCSR);
 }
+
+HWTEST_F(DeviceCommandStreamLeaksTest, givenDefaultDrmCsrWhenOsInterfaceIsNullptrThenValidateDrm) {
+    std::unique_ptr<CommandStreamReceiver> ptr(DeviceCommandStreamReceiver<FamilyType>::create(*platformDevices[0], false,
+                                                                                               this->executionEnvironment));
+    auto drmCsr = (DrmCommandStreamReceiver<FamilyType> *)ptr.get();
+    EXPECT_NE(nullptr, executionEnvironment.osInterface);
+    EXPECT_EQ(drmCsr->getOSInterface()->get()->getDrm(), executionEnvironment.osInterface->get()->getDrm());
+}
diff --git a/unit_tests/os_interface/linux/drm_command_stream_mm_tests.cpp b/unit_tests/os_interface/linux/drm_command_stream_mm_tests.cpp
@@ -23,6 +23,7 @@
 #include "runtime/execution_environment/execution_environment.h"
 #include "runtime/os_interface/linux/drm_command_stream.h"
 #include "runtime/os_interface/linux/drm_memory_manager.h"
+#include "runtime/os_interface/linux/os_interface.h"
 #include "unit_tests/helpers/debug_manager_state_restore.h"
 #include "unit_tests/os_interface/linux/device_command_stream_fixture.h"
 #include "test.h"
@@ -41,7 +42,11 @@ HWTEST_F(DrmCommandStreamMMTest, MMwithPinBB) {
         std::unique_ptr<DrmMockCustom> mock(new DrmMockCustom());
         ASSERT_NE(nullptr, mock);
 
-        DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], mock.get(), executionEnvironment, gemCloseWorkerMode::gemCloseWorkerInactive);
+        executionEnvironment.osInterface = std::make_unique<OSInterface>();
+        executionEnvironment.osInterface->get()->setDrm(mock.get());
+
+        DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], executionEnvironment,
+                                                 gemCloseWorkerMode::gemCloseWorkerInactive);
 
         auto mm = (DrmMemoryManager *)csr.createMemoryManager(false);
         ASSERT_NE(nullptr, mm);
@@ -61,7 +66,11 @@ HWTEST_F(DrmCommandStreamMMTest, givenForcePinDisabledWhenMemoryManagerIsCreated
         std::unique_ptr<DrmMockCustom> mock(new DrmMockCustom());
         ASSERT_NE(nullptr, mock);
 
-        DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], mock.get(), executionEnvironment, gemCloseWorkerMode::gemCloseWorkerInactive);
+        executionEnvironment.osInterface = std::make_unique<OSInterface>();
+        executionEnvironment.osInterface->get()->setDrm(mock.get());
+
+        DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], executionEnvironment,
+                                                 gemCloseWorkerMode::gemCloseWorkerInactive);
 
         auto mm = (DrmMemoryManager *)csr.createMemoryManager(false);
         csr.setMemoryManager(nullptr);
diff --git a/unit_tests/os_interface/linux/drm_command_stream_tests.cpp b/unit_tests/os_interface/linux/drm_command_stream_tests.cpp
diff --git a/unit_tests/os_interface/windows/device_command_stream_tests.cpp b/unit_tests/os_interface/windows/device_command_stream_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[2 * IGFX_MAX`
`29`	`29`
`30`	`30`	`template <typename BaseCSR>`
`31`	`31`	`CommandStreamReceiverWithAUBDump<BaseCSR>::CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)`
`32`		`- : BaseCSR(hwInfoIn, nullptr, executionEnvironment) {`
	`32`	`+ : BaseCSR(hwInfoIn, executionEnvironment) {`
`33`	`33`	`aubCSR = AUBCommandStreamReceiver::create(hwInfoIn, "aubfile", false, executionEnvironment);`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const Hard`
`33`	`33`	`if (withAubDump) {`
`34`	`34`	`return new CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);`
`35`	`35`	`} else {`
`36`		`- return new DrmCommandStreamReceiver<GfxFamily>(hwInfo, nullptr, executionEnvironment);`
	`36`	`+ return new DrmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);`
`37`	`37`	`}`
`38`	`38`	`};`
`39`	`39`	`} // namespace OCLRT`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const Hard`
`37`	`37`	`if (withAubDump) {`
`38`	`38`	`return new CommandStreamReceiverWithAUBDump<WddmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);`
`39`	`39`	`} else {`
`40`		`- return new WddmCommandStreamReceiver<GfxFamily>(hwInfo, nullptr, executionEnvironment);`
	`40`	`+ return new WddmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`	`} // namespace OCLRT`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,8 @@`
`32`	`32`	`using namespace OCLRT;`
`33`	`33`
`34`	`34`	`struct MyMockCsr : UltCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> {`
`35`		`- MyMockCsr(const HardwareInfo &hwInfoIn, void *ptr, ExecutionEnvironment &executionEnvironment) : UltCommandStreamReceiver(hwInfoIn, executionEnvironment) {`
	`35`	`+ MyMockCsr(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)`
	`36`	`+ : UltCommandStreamReceiver(hwInfoIn, executionEnvironment) {`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`FlushStamp flush(BatchBuffer &batchBuffer, EngineType engineOrdinal, ResidencyContainer *allocationsForResidency, OsContext &osContext) override {`
`@@ -101,7 +102,7 @@ struct MyMockCsrWithAubDump : CommandStreamReceiverWithAUBDump<BaseCSR> {`
`101`	`102`	`}`
`102`	`103`	`if (createAubCSR) {`
`103`	`104`	`// overwrite with mock`
`104`		`- this->aubCSR = new MyMockCsr(hwInfoIn, nullptr, executionEnvironment);`
	`105`	`+ this->aubCSR = new MyMockCsr(hwInfoIn, executionEnvironment);`
`105`	`106`	`}`
`106`	`107`	`}`
`107`	`108`