[dxvk] Open the D3DKMT resource local handle on allocation

Author: rbernon

src/dxvk/dxvk_memory.cpp

@@ -215,6 +215,13 @@ namespace dxvk {
 
 
   DxvkResourceAllocation::~DxvkResourceAllocation() {
+    if (unlikely(m_kmtLocal)) {
+      D3DKMT_DESTROYALLOCATION destroy = { };
+      destroy.hDevice = m_allocator->device()->kmtLocal();
+      destroy.hResource = m_kmtLocal;
+      D3DKMTDestroyAllocation(&destroy);
+    }
+
     if (m_buffer) {
       if (unlikely(m_bufferViews))
         delete m_bufferViews;
@@ -1119,6 +1126,48 @@ namespace dxvk {
       }
     }
 
+#ifdef _WIN32
+    auto sharedExport = (const VkExportMemoryAllocateInfo*)next;
+    if (sharedExport && sharedExport->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO) {
+      VkMemoryGetWin32HandleInfoKHR handleInfo = { VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR };
+      handleInfo.handleType = (VkExternalMemoryHandleTypeFlagBits)sharedExport->handleTypes;
+      handleInfo.memory = allocation->m_memory;
+
+      D3DDDI_OPENALLOCATIONINFO2 alloc = { };
+      HANDLE sharedHandle = INVALID_HANDLE_VALUE;
+
+      if (vk->vkGetMemoryWin32HandleKHR(vk->device(), &handleInfo, &sharedHandle) != VK_SUCCESS) {
+        Logger::warn("DxvkMemoryAllocator::createImageResource: Failed to get shared handle for memory");
+      } else if (handleInfo.handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
+        D3DKMT_OPENRESOURCE open = { };
+        open.hDevice = m_device->kmtLocal();
+        open.hGlobalShare = (uintptr_t)sharedHandle;
+        open.NumAllocations = 1;
+        open.pOpenAllocationInfo2 = &alloc;
+
+        if (D3DKMTOpenResource2(&open)) {
+          Logger::warn("DxvkMemoryAllocator::createImageResource: Failed to open shared D3DKMT handle");
+        } else {
+          allocation->m_kmtLocal = open.hResource;
+          allocation->m_kmtGlobal = open.hGlobalShare;
+        }
+      } else {
+        D3DKMT_OPENRESOURCEFROMNTHANDLE open = { };
+        open.hDevice = m_device->kmtLocal();
+        open.hNtHandle = sharedHandle;
+        open.NumAllocations = 1;
+        open.pOpenAllocationInfo2 = &alloc;
+
+        if (D3DKMTOpenResourceFromNtHandle(&open)) {
+          Logger::warn("DxvkMemoryAllocator::createImageResource: Failed to open shared NT handle");
+        } else {
+          allocation->m_kmtLocal = open.hResource;
+        }
+        CloseHandle(sharedHandle);
+      }
+    }
+#endif
+
     return allocation;
   }
 

src/dxvk/dxvk_memory.h

@@ -550,6 +550,24 @@ namespace dxvk {
       return m_mapPtr;
     }
 
+    /**
+     * \brief D3DKMT resource local handle
+     * \returns The resource D3DKMT local handle
+     * \returns \c 0 if resource is not shared
+     */
+    D3DKMT_HANDLE kmtLocal() const {
+      return m_kmtLocal;
+    }
+
+    /**
+     * \brief D3DKMT resource global handle
+     * \returns The resource D3DKMT global handle
+     * \returns \c 0 if resource is not shared or shared with NT handle
+     */
+    D3DKMT_HANDLE kmtGlobal() const {
+      return m_kmtGlobal;
+    }
+
     /**
      * \brief Queries memory info
      * \returns Memory info
@@ -644,6 +662,8 @@ namespace dxvk {
 
     VkImage                     m_image = VK_NULL_HANDLE;
     DxvkResourceImageViewMap*   m_imageViews = nullptr;
+    D3DKMT_HANDLE               m_kmtLocal = 0;
+    D3DKMT_HANDLE               m_kmtGlobal = 0;
 
     DxvkSparsePageTable*        m_sparsePageTable = nullptr;
 

src/util/util_gdi.cpp

@@ -19,6 +19,11 @@ namespace dxvk {
     return -1;
   }
 
+  NTSTATUS D3DKMTDestroyAllocation(const D3DKMT_DESTROYALLOCATION *desc) {
+    Logger::warn("D3DKMTDestroyAllocation: Not available on this platform.");
+    return -1;
+  }
+
   NTSTATUS D3DKMTDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *desc) {
     Logger::warn("D3DKMTDestroyDCFromMemory: Not available on this platform.");
     return -1;
@@ -33,6 +38,16 @@ namespace dxvk {
     Logger::warn("D3DKMTOpenAdapterFromLuid: Not available on this platform.");
     return -1;
   }
+
+  NTSTATUS D3DKMTOpenResource2(D3DKMT_OPENRESOURCE *desc) {
+    Logger::warn("D3DKMTOpenResource2: Not available on this platform.");
+    return -1;
+  }
+
+  NTSTATUS D3DKMTOpenResourceFromNtHandle(D3DKMT_OPENRESOURCEFROMNTHANDLE *desc) {
+    Logger::warn("D3DKMTOpenResourceFromNtHandle: Not available on this platform.");
+    return -1;
+  }
 #endif
 
 }

src/util/util_gdi.h

@@ -11,6 +11,7 @@ namespace dxvk {
   using NTSTATUS = LONG;
   using D3DDDIFORMAT = D3DFORMAT;
   using D3DKMT_HANDLE = UINT;
+  using D3DGPU_VIRTUAL_ADDRESS = ULONGLONG;
 
   typedef struct _D3DKMT_CLOSEADAPTER
   {
@@ -89,6 +90,14 @@ namespace dxvk {
       UINT PatchLocationListSize;
   } D3DKMT_CREATEDEVICE;
 
+  typedef struct _D3DKMT_DESTROYALLOCATION
+  {
+      D3DKMT_HANDLE hDevice;
+      D3DKMT_HANDLE hResource;
+      const D3DKMT_HANDLE *phAllocationList;
+      UINT AllocationCount;
+  } D3DKMT_DESTROYALLOCATION;
+
   typedef struct _D3DKMT_DESTROYDCFROMMEMORY
   {
       HDC hDc;
@@ -106,10 +115,67 @@ namespace dxvk {
       D3DKMT_HANDLE hAdapter;
   } D3DKMT_OPENADAPTERFROMLUID;
 
+  typedef struct _D3DDDI_OPENALLOCATIONINFO
+  {
+      D3DKMT_HANDLE hAllocation;
+      const void *pPrivateDriverData;
+      UINT PrivateDriverDataSize;
+  } D3DDDI_OPENALLOCATIONINFO;
+
+  typedef struct _D3DDDI_OPENALLOCATIONINFO2
+  {
+      D3DKMT_HANDLE hAllocation;
+      const void *pPrivateDriverData;
+      UINT PrivateDriverDataSize;
+      D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress;
+      ULONG_PTR Reserved[6];
+  } D3DDDI_OPENALLOCATIONINFO2;
+
+  typedef struct _D3DKMT_OPENRESOURCE
+  {
+      D3DKMT_HANDLE hDevice;
+      D3DKMT_HANDLE hGlobalShare;
+      UINT NumAllocations;
+      union
+      {
+          D3DDDI_OPENALLOCATIONINFO *pOpenAllocationInfo;
+          D3DDDI_OPENALLOCATIONINFO2 *pOpenAllocationInfo2;
+      };
+      void *pPrivateRuntimeData;
+      UINT PrivateRuntimeDataSize;
+      void *pResourcePrivateDriverData;
+      UINT ResourcePrivateDriverDataSize;
+      void *pTotalPrivateDriverDataBuffer;
+      UINT TotalPrivateDriverDataBufferSize;
+      D3DKMT_HANDLE hResource;
+  } D3DKMT_OPENRESOURCE;
+
+  typedef struct _D3DKMT_OPENRESOURCEFROMNTHANDLE
+  {
+      D3DKMT_HANDLE hDevice;
+      HANDLE hNtHandle;
+      UINT NumAllocations;
+      D3DDDI_OPENALLOCATIONINFO2 *pOpenAllocationInfo2;
+      UINT PrivateRuntimeDataSize;
+      void *pPrivateRuntimeData;
+      UINT ResourcePrivateDriverDataSize;
+      void *pResourcePrivateDriverData;
+      UINT TotalPrivateDriverDataBufferSize;
+      void *pTotalPrivateDriverDataBuffer;
+      D3DKMT_HANDLE hResource;
+      D3DKMT_HANDLE hKeyedMutex;
+      void *pKeyedMutexPrivateRuntimeData;
+      UINT KeyedMutexPrivateRuntimeDataSize;
+      D3DKMT_HANDLE hSyncObject;
+  } D3DKMT_OPENRESOURCEFROMNTHANDLE;
+
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTCloseAdapter(const D3DKMT_CLOSEADAPTER *desc);
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTCreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *desc);
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTCreateDevice(D3DKMT_CREATEDEVICE *desc);
+  EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTDestroyAllocation(const D3DKMT_DESTROYALLOCATION *desc);
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *desc);
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTDestroyDevice(const D3DKMT_DESTROYDEVICE *desc);
   EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTOpenAdapterFromLuid(D3DKMT_OPENADAPTERFROMLUID *desc);
+  EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTOpenResource2(D3DKMT_OPENRESOURCE *desc);
+  EXTERN_C WINBASEAPI NTSTATUS WINAPI D3DKMTOpenResourceFromNtHandle(D3DKMT_OPENRESOURCEFROMNTHANDLE *desc);
 }