Extract Os Context from Wddm and WddmInterface

Change-Id: I13a52fc466a14f4bd28876d3c47884dc596f2b58
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

runtime/os_interface/windows/CMakeLists.txt

@@ -41,6 +41,8 @@ set(RUNTIME_SRCS_OS_INTERFACE_WINDOWS
   ${CMAKE_CURRENT_SOURCE_DIR}/gdi_interface.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kmdaf_listener${KMDAF_FILE_SUFFIX}.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kmdaf_listener.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_context_win.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/os_context_win.h
   ${CMAKE_CURRENT_SOURCE_DIR}/os_inc.h
   ${CMAKE_CURRENT_SOURCE_DIR}/os_interface.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/os_interface.h

runtime/os_interface/windows/os_context_win.cpp

@@ -0,0 +1,50 @@
+/*
+* Copyright (c) 2018, Intel Corporation
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "runtime/os_interface/windows/os_context_win.h"
+#include "runtime/os_interface/windows/wddm/wddm.h"
+#include "runtime/os_interface/windows/wddm/wddm_interface.h"
+
+namespace OCLRT {
+OsContextWin::OsContextWin(Wddm &wddm) : wddm(wddm) {
+    auto wddmInterface = wddm.getWddmInterface();
+    if (!wddm.createContext(context))
+        return;
+    if (wddmInterface->hwQueuesSupported()) {
+        if (!wddmInterface->createHwQueue(wddm.getPreemptionMode(), *this))
+            return;
+    }
+    initialized = wddmInterface->createMonitoredFence(*this);
+};
+OsContextWin::~OsContextWin() {
+    wddm.getWddmInterface()->destroyHwQueue(hwQueueHandle);
+    wddm.destroyContext(context);
+}
+
+void OsContextWin::resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress) {
+    monitoredFence.lastSubmittedFence = 0;
+    monitoredFence.currentFenceValue = 1;
+    monitoredFence.fenceHandle = handle;
+    monitoredFence.cpuAddress = cpuAddress;
+    monitoredFence.gpuAddress = gpuAddress;
+}
+} // namespace OCLRT

runtime/os_interface/windows/os_context_win.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+#include "runtime/os_interface/windows/windows_wrapper.h"
+#include "runtime/os_interface/windows/windows_defs.h"
+#include <d3dkmthk.h>
+
+namespace OCLRT {
+class Wddm;
+
+class OsContextWin {
+  public:
+    OsContextWin() = delete;
+    OsContextWin(Wddm &wddm);
+    ~OsContextWin();
+    D3DKMT_HANDLE getContext() const {
+        return context;
+    }
+    D3DKMT_HANDLE getHwQueue() const {
+        return hwQueueHandle;
+    }
+    void setHwQueue(D3DKMT_HANDLE hwQueue) {
+        hwQueueHandle = hwQueue;
+    }
+    bool isInitialized() const {
+        return initialized;
+    }
+    MonitoredFence &getMonitoredFence() { return monitoredFence; }
+    void resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress);
+
+  protected:
+    bool initialized = false;
+    D3DKMT_HANDLE context = 0;
+    D3DKMT_HANDLE hwQueueHandle = 0;
+    Wddm &wddm;
+    MonitoredFence monitoredFence = {};
+};
+} // namespace OCLRT

runtime/os_interface/windows/wddm/wddm.cpp

@@ -30,6 +30,7 @@
 #include "runtime/gmm_helper/page_table_mngr.h"
 #include "runtime/os_interface/windows/wddm/wddm.h"
 #include "runtime/os_interface/hw_info_config.h"
+#include "runtime/os_interface/windows/os_context_win.h"
 #include "runtime/os_interface/windows/wddm_allocation.h"
 #include "runtime/os_interface/windows/registry_reader.h"
 #include "runtime/helpers/debug_helpers.h"
@@ -54,16 +55,7 @@ Wddm::GetSystemInfoFcn Wddm::getSystemInfo = getGetSystemInfo();
 Wddm::VirtualAllocFcn Wddm::virtualAllocFnc = getVirtualAlloc();
 Wddm::VirtualFreeFcn Wddm::virtualFreeFnc = getVirtualFree();
 
-Wddm::Wddm() : initialized(false),
-               adapter(0),
-               context(0),
-               device(0),
-               pagingQueue(0),
-               pagingQueueSyncObject(0),
-               pagingFenceAddress(nullptr),
-               currentPagingFenceValue(0),
-               hwContextId(0),
-               trimCallbackHandle(nullptr) {
+Wddm::Wddm() {
     featureTable.reset(new FeatureTable());
     waTable.reset(new WorkaroundTable());
     gtSystemInfo.reset(new GT_SYSTEM_INFO);
@@ -74,17 +66,12 @@ Wddm::Wddm() : initialized(false),
     registryReader.reset(new RegistryReader("System\\CurrentControlSet\\Control\\GraphicsDrivers\\Scheduler"));
     adapterLuid.HighPart = 0;
     adapterLuid.LowPart = 0;
-    maximumApplicationAddress = 0;
-    node = GPUNODE_3D;
-    preemptionMode = PreemptionMode::Disabled;
-    minAddress = 0;
     kmDafListener = std::unique_ptr<KmDafListener>(new KmDafListener);
     gdi = std::unique_ptr<Gdi>(new Gdi());
 }
 
 Wddm::~Wddm() {
     resetPageTableManager(nullptr);
-    destroyContext(context);
     destroyPagingQueue();
     destroyDevice();
     closeAdapter();
@@ -684,7 +671,7 @@ void Wddm::kmDafLock(WddmAllocation *wddmAllocation) {
     kmDafListener->notifyLock(featureTable->ftrKmdDaf, adapter, device, wddmAllocation->handle, 0, gdi->escape);
 }
 
-bool Wddm::createContext() {
+bool Wddm::createContext(D3DKMT_HANDLE &context) {
     NTSTATUS status = STATUS_UNSUCCESSFUL;
     D3DKMT_CREATECONTEXTVIRTUAL CreateContext = {0};
     CREATECONTEXT_PVTDATA PrivateData = {{0}};
@@ -730,15 +717,15 @@ bool Wddm::destroyContext(D3DKMT_HANDLE context) {
 
 bool Wddm::submit(uint64_t commandBuffer, size_t size, void *commandHeader) {
     bool status = false;
-    if (currentPagingFenceValue > *pagingFenceAddress && !waitOnGPU()) {
+    if (currentPagingFenceValue > *pagingFenceAddress && !waitOnGPU(osContext->getContext())) {
         return false;
     }
-    DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "currentFenceValue =", monitoredFence.currentFenceValue);
+    DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "currentFenceValue =", osContext->getMonitoredFence().currentFenceValue);
 
-    status = wddmInterface->submit(commandBuffer, size, commandHeader);
+    status = wddmInterface->submit(commandBuffer, size, commandHeader, *osContext);
     if (status) {
-        monitoredFence.lastSubmittedFence = monitoredFence.currentFenceValue;
-        monitoredFence.currentFenceValue++;
+        osContext->getMonitoredFence().lastSubmittedFence = osContext->getMonitoredFence().currentFenceValue;
+        osContext->getMonitoredFence().currentFenceValue++;
     }
     getDeviceState();
     UNRECOVERABLE_IF(!status);
@@ -764,9 +751,9 @@ void Wddm::getDeviceState() {
 }
 
 void Wddm::handleCompletion() {
-    if (monitoredFence.cpuAddress) {
-        auto *currentTag = monitoredFence.cpuAddress;
-        while (*currentTag < monitoredFence.currentFenceValue - 1)
+    if (osContext->getMonitoredFence().cpuAddress) {
+        auto *currentTag = osContext->getMonitoredFence().cpuAddress;
+        while (*currentTag < osContext->getMonitoredFence().currentFenceValue - 1)
             ;
     }
 }
@@ -775,7 +762,7 @@ unsigned int Wddm::readEnablePreemptionRegKey() {
     return static_cast<unsigned int>(registryReader->getSetting("EnablePreemption", 1));
 }
 
-bool Wddm::waitOnGPU() {
+bool Wddm::waitOnGPU(D3DKMT_HANDLE context) {
     D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU WaitOnGPU = {0};
 
     WaitOnGPU.hContext = context;
@@ -792,10 +779,10 @@ bool Wddm::waitOnGPU() {
 bool Wddm::waitFromCpu(uint64_t lastFenceValue) {
     NTSTATUS status = STATUS_SUCCESS;
 
-    if (lastFenceValue > *monitoredFence.cpuAddress) {
+    if (lastFenceValue > *osContext->getMonitoredFence().cpuAddress) {
         D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU waitFromCpu = {0};
         waitFromCpu.ObjectCount = 1;
-        waitFromCpu.ObjectHandleArray = &monitoredFence.fenceHandle;
+        waitFromCpu.ObjectHandleArray = &osContext->getMonitoredFence().fenceHandle;
         waitFromCpu.FenceValueArray = &lastFenceValue;
         waitFromCpu.hDevice = device;
         waitFromCpu.hAsyncEvent = NULL;
@@ -901,12 +888,9 @@ void *Wddm::virtualAlloc(void *inPtr, size_t size, unsigned long flags, unsigned
 int Wddm::virtualFree(void *ptr, size_t size, unsigned long flags) {
     return virtualFreeFnc(ptr, size, flags);
 }
+MonitoredFence &Wddm::getMonitoredFence() { return osContext->getMonitoredFence(); }
 
-void Wddm::resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress) {
-    monitoredFence.lastSubmittedFence = 0;
-    monitoredFence.currentFenceValue = 1;
-    monitoredFence.fenceHandle = handle;
-    monitoredFence.cpuAddress = cpuAddress;
-    monitoredFence.gpuAddress = gpuAddress;
+D3DKMT_HANDLE Wddm::getOsDeviceContext() const {
+    return osContext->getContext();
 }
 } // namespace OCLRT

runtime/os_interface/windows/wddm/wddm.h

@@ -45,6 +45,7 @@ class Gdi;
 class Gmm;
 class LinearStream;
 class GmmPageTableMngr;
+class OsContextWin;
 struct FeatureTable;
 struct WorkaroundTable;
 struct KmDafListener;
@@ -70,7 +71,7 @@ class Wddm {
     MOCKABLE_VIRTUAL bool makeResident(D3DKMT_HANDLE *handles, uint32_t count, bool cantTrimFurther, uint64_t *numberOfBytesToTrim);
     bool mapGpuVirtualAddress(WddmAllocation *allocation, void *cpuPtr, bool allocation32bit, bool use64kbPages, bool useHeap1);
     bool mapGpuVirtualAddress(AllocationStorageData *allocationStorageData, bool allocation32bit, bool use64kbPages);
-    MOCKABLE_VIRTUAL bool createContext();
+    MOCKABLE_VIRTUAL bool createContext(D3DKMT_HANDLE &context);
     MOCKABLE_VIRTUAL bool freeGpuVirtualAddres(D3DGPU_VIRTUAL_ADDRESS &gpuPtr, uint64_t size);
     MOCKABLE_VIRTUAL NTSTATUS createAllocation(WddmAllocation *alloc);
     MOCKABLE_VIRTUAL bool createAllocation64k(WddmAllocation *alloc);
@@ -86,8 +87,7 @@ class Wddm {
     MOCKABLE_VIRTUAL bool destroyContext(D3DKMT_HANDLE context);
     MOCKABLE_VIRTUAL bool queryAdapterInfo();
 
-    virtual bool submit(uint64_t commandBuffer, size_t size, void *commandHeader);
-    MOCKABLE_VIRTUAL bool waitOnGPU();
+    MOCKABLE_VIRTUAL bool submit(uint64_t commandBuffer, size_t size, void *commandHeader);
     MOCKABLE_VIRTUAL bool waitFromCpu(uint64_t lastFenceValue);
 
     NTSTATUS escape(D3DKMT_ESCAPE &escapeCommand);
@@ -121,7 +121,7 @@ class Wddm {
         return deviceRegistryPath;
     }
 
-    MonitoredFence &getMonitoredFence() { return monitoredFence; }
+    MonitoredFence &getMonitoredFence();
 
     uint64_t getSystemSharedMemory() const;
 
@@ -159,27 +159,26 @@ class Wddm {
     uintptr_t getWddmMinAddress() const {
         return this->minAddress;
     }
-
-    D3DKMT_HANDLE getOsDeviceContext() {
-        return context;
+    WddmInterface *getWddmInterface() const {
+        return wddmInterface.get();
+    }
+    PreemptionMode getPreemptionMode() const {
+        return preemptionMode;
     }
+    D3DKMT_HANDLE getOsDeviceContext() const;
 
     unsigned int readEnablePreemptionRegKey();
-    void resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress);
 
   protected:
-    bool initialized;
+    bool initialized = false;
     std::unique_ptr<Gdi> gdi;
-    D3DKMT_HANDLE adapter;
-    D3DKMT_HANDLE context;
-    D3DKMT_HANDLE device;
-    D3DKMT_HANDLE pagingQueue;
-    D3DKMT_HANDLE pagingQueueSyncObject;
-
-    uint64_t *pagingFenceAddress;
-    std::atomic<std::uint64_t> currentPagingFenceValue;
+    D3DKMT_HANDLE adapter = 0;
+    D3DKMT_HANDLE device = 0;
+    D3DKMT_HANDLE pagingQueue = 0;
+    D3DKMT_HANDLE pagingQueueSyncObject = 0;
 
-    MonitoredFence monitoredFence;
+    uint64_t *pagingFenceAddress = nullptr;
+    std::atomic<std::uint64_t> currentPagingFenceValue{0};
 
     // Adapter information
     std::unique_ptr<PLATFORM> gfxPlatform;
@@ -192,18 +191,19 @@ class Wddm {
     bool instrumentationEnabled = false;
     std::string deviceRegistryPath;
 
-    unsigned long hwContextId;
+    unsigned long hwContextId = 0;
     LUID adapterLuid;
-    void *trimCallbackHandle;
-    uintptr_t maximumApplicationAddress;
-    GPUNODE_ORDINAL node;
-    PreemptionMode preemptionMode;
+    void *trimCallbackHandle = nullptr;
+    uintptr_t maximumApplicationAddress = 0;
+    GPUNODE_ORDINAL node = GPUNODE_3D;
+    PreemptionMode preemptionMode = PreemptionMode::Disabled;
     std::unique_ptr<GmmMemory> gmmMemory;
-    uintptr_t minAddress;
+    uintptr_t minAddress = 0;
 
     Wddm();
     MOCKABLE_VIRTUAL bool mapGpuVirtualAddressImpl(Gmm *gmm, D3DKMT_HANDLE handle, void *cpuPtr, D3DGPU_VIRTUAL_ADDRESS &gpuPtr, bool allocation32bit, bool use64kbPages, bool useHeap1);
     MOCKABLE_VIRTUAL bool openAdapter();
+    MOCKABLE_VIRTUAL bool waitOnGPU(D3DKMT_HANDLE context);
     bool createDevice();
     bool createPagingQueue();
     bool destroyPagingQueue();
@@ -221,5 +221,6 @@ class Wddm {
 
     std::unique_ptr<KmDafListener> kmDafListener;
     std::unique_ptr<WddmInterface> wddmInterface;
+    std::unique_ptr<OsContextWin> osContext;
 };
 } // namespace OCLRT

runtime/os_interface/windows/wddm/wddm.inl

@@ -22,6 +22,7 @@
 
 #include "runtime/os_interface/windows/gdi_interface.h"
 #include "runtime/os_interface/windows/wddm/wddm.h"
+#include "runtime/os_interface/windows/os_context_win.h"
 
 namespace OCLRT {
 
@@ -67,16 +68,8 @@ bool Wddm::init() {
         if (!configureDeviceAddressSpace<GfxFamily>()) {
             return false;
         }
-        if (!createContext()) {
-            return false;
-        }
-        if (wddmInterface->hwQueuesSupported() && !wddmInterface->createHwQueue(preemptionMode)) {
-            return false;
-        }
-        if (!wddmInterface->createMonitoredFence()) {
-            return false;
-        }
-        initialized = true;
+        osContext = std::make_unique<OsContextWin>(*this);
+        initialized = osContext->isInitialized();
     }
     return initialized;
 }