merge misc commits i had done locally

README.md

@@ -34,6 +34,8 @@ A huge thank-you to the following contributors for their invaluable help:
 - [Device Filter](#device-filter)
 - [State Cache](#state-cache)
 - [Shader Compilation (dyasync)](#shader-compilation-dyasync)
+- [Frame Pacing (low-latency mode)](#frame-pacing-low-latency-mode)
+- [Debugging](#debugging)
 - [Debugging](#debugging)
 - [Troubleshooting](#troubleshooting)
 
@@ -178,6 +180,21 @@ Dyasync can be disabled by setting `dxvk.enableDyasync = False` in `dxvk.conf`,
 
 `DXVK_ALL_CORES=1` overrides the default way cores are assigned for shader compilation. By default, DXVK-Sarek uses roughly half the available CPU cores for background compilation, leaving the rest free for the game. On CPUs with weak per-core performance that rely on all cores for good throughput, this may cause longer loading times. With `DXVK_ALL_CORES=1`, all available cores are used for both the game and shader compilation. This may cause brief unresponsiveness while compiling shaders but can improve the overall experience on such hardware.
 
+## Frame Pacing (low-latency mode)
+
+DXVK-Sarek includes an optional frame pacing mode adapted from and inspired by [netborg-afps/dxvk-low-latency](https://github.com/netborg-afps/dxvk-low-latency). It is not a direct port: that project relies on per submission GPU timing and an asynchronous presenter that upstream DXVK has but Sarek Vulkan 1.1/1.2-targeted presenter does not, so the mechanism here has been adapted to what Sarek can actually observe.
+
+The `dxvk.framePace` option in `dxvk.conf` (or the `DXVK_FRAME_PACE` environment variable) controls it:
+
+- `"max-frame-latency"` (default) is Sarek's existing, unchanged behaviour. Frame `i` wont start until frame `(i-1)-x` has finished, where `x` is `dxgi.maxFrameLatency` / `d3d9.maxFrameLatency`.
+- `"low-latency"` forces the effective frame latency down to the minimum needed for forward progress, and makes a best-effort prediction of when the previous frame will finish (based on a rolling average of recent frame durations) to reduce unnecessary CPU wake-up jitter. The prediction is never load-bearing for correctness; a wrong guess costs microseconds, not a broken frame.
+- `"min-latency"` forces the same minimal frame latency without the predictive sleep. Lowest possible latency, usually at a noticeable fps cost.
+
+`dxvk.lowLatencyOffset` fine-tunes `"low-latency"` mode: positive values (in microseconds) delay a frame's predicted start slightly, negative values start it earlier. Clamped to `-10000`..`10000`, defaults to `0`.
+
+> [!NOTE]
+> Because Sarek presenter has no per-submission GPU progress telemetry the way upstream DXVK's does, `"low-latency"` and `"min-latency"` currently share the same underlying latency-reduction mechanism rather than being two fully distinct algorithms. There's also no VRR-aware pacing mode and no HUD latency display yet, both of which the upstream project has.
+
 ## Debugging
 
 The following environment variables can be used for debugging:

src/d3d11/d3d11_buffer.cpp

@@ -5,7 +5,7 @@
 #include "../dxvk/dxvk_data.h"
 
 namespace dxvk {
-  
+
   D3D11Buffer::D3D11Buffer(
           D3D11Device*                pDevice,
     const D3D11_BUFFER_DESC*          pDesc)
@@ -20,19 +20,19 @@ namespace dxvk {
     info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
     info.access = VK_ACCESS_TRANSFER_READ_BIT
                 | VK_ACCESS_TRANSFER_WRITE_BIT;
-    
+
     if (pDesc->BindFlags & D3D11_BIND_VERTEX_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
       info.access |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_INDEX_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
       info.access |= VK_ACCESS_INDEX_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
@@ -41,28 +41,28 @@ namespace dxvk {
       if (m_parent->GetOptions()->constantBufferRangeCheck)
         info.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_SHADER_RESOURCE) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT) {
       info.usage  |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
       info.stages |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
       info.access |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
     }
-    
+
     if (pDesc->BindFlags & D3D11_BIND_UNORDERED_ACCESS) {
       info.usage  |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
       info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT
                   |  VK_ACCESS_SHADER_WRITE_BIT;
     }
-    
+
     if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS) {
       info.usage  |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
       info.stages |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
@@ -80,27 +80,27 @@ namespace dxvk {
     if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT)
       m_soCounter = CreateSoCounterBuffer();
   }
-  
-  
+
+
   D3D11Buffer::~D3D11Buffer() {
 
   }
-  
-  
+
+
   HRESULT STDMETHODCALLTYPE D3D11Buffer::QueryInterface(REFIID riid, void** ppvObject) {
     if (ppvObject == nullptr)
       return E_POINTER;
 
     *ppvObject = nullptr;
-    
+
     if (riid == __uuidof(IUnknown)
      || riid == __uuidof(ID3D11DeviceChild)
      || riid == __uuidof(ID3D11Resource)
      || riid == __uuidof(ID3D11Buffer)) {
       *ppvObject = ref(this);
       return S_OK;
     }
-    
+
     if (riid == __uuidof(ID3D10DeviceChild)
      || riid == __uuidof(ID3D10Resource)
      || riid == __uuidof(ID3D10Buffer)) {
@@ -115,36 +115,36 @@ namespace dxvk {
        *ppvObject = ref(&m_resource);
        return S_OK;
     }
-    
+
     Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query");
     Logger::warn(str::format(riid));
     return E_NOINTERFACE;
   }
-  
-  
+
+
   UINT STDMETHODCALLTYPE D3D11Buffer::GetEvictionPriority() {
     return DXGI_RESOURCE_PRIORITY_NORMAL;
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::SetEvictionPriority(UINT EvictionPriority) {
     static bool s_errorShown = false;
 
     if (!std::exchange(s_errorShown, true))
       Logger::warn("D3D11Buffer::SetEvictionPriority: Stub");
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension) {
     *pResourceDimension = D3D11_RESOURCE_DIMENSION_BUFFER;
   }
-  
-  
+
+
   void STDMETHODCALLTYPE D3D11Buffer::GetDesc(D3D11_BUFFER_DESC* pDesc) {
     *pDesc = m_desc;
   }
-  
-  
+
+
   bool D3D11Buffer::CheckViewCompatibility(
           UINT                BindFlags,
           DXGI_FORMAT         Format) const {
@@ -173,7 +173,7 @@ namespace dxvk {
     // We don't support tiled resources
     if (pDesc->MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED))
       return E_INVALIDARG;
-    
+
     // Constant buffer size must be a multiple of 16
     if ((pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER)
      && (pDesc->ByteWidth & 0xF))
@@ -185,7 +185,7 @@ namespace dxvk {
       || (pDesc->StructureByteStride == 0)
       || (pDesc->StructureByteStride & 0x3)))
       return E_INVALIDARG;
-    
+
     // Basic validation for raw buffers
     if ((pDesc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS)
      && (!(pDesc->BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS))))
@@ -194,10 +194,10 @@ namespace dxvk {
     // Mip generation obviously doesn't work for buffers
     if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
       return E_INVALIDARG;
-    
+
     if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED))
       pDesc->StructureByteStride = 0;
-    
+
     return S_OK;
   }
 
@@ -212,7 +212,7 @@ namespace dxvk {
 
   VkMemoryPropertyFlags D3D11Buffer::GetMemoryFlags() const {
     VkMemoryPropertyFlags memoryFlags = 0;
-    
+
     switch (m_desc.Usage) {
       case D3D11_USAGE_IMMUTABLE:
         memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -231,26 +231,27 @@ namespace dxvk {
           memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         }
         break;
-      
+
       case D3D11_USAGE_DYNAMIC:
         memoryFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
                     |  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
 
         if (m_desc.BindFlags)
           memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         break;
-      
+
       case D3D11_USAGE_STAGING:
         memoryFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
                     |  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                     |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
         break;
     }
-    
+
     bool useCached = (m_parent->GetOptions()->cachedDynamicResources == ~0u)
                   || (m_parent->GetOptions()->cachedDynamicResources & m_desc.BindFlags);
 
     if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && useCached) {
+      memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
       memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                   |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
     }
@@ -276,6 +277,7 @@ namespace dxvk {
                 | VK_ACCESS_INDIRECT_COMMAND_READ_BIT
                 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
                 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
+
     return device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
   }
 
@@ -285,7 +287,7 @@ namespace dxvk {
       ? D3D11_COMMON_BUFFER_MAP_MODE_DIRECT
       : D3D11_COMMON_BUFFER_MAP_MODE_NONE;
   }
-  
+
 
   D3D11Buffer* GetCommonBuffer(ID3D11Resource* pResource) {
     D3D11_RESOURCE_DIMENSION dimension = D3D11_RESOURCE_DIMENSION_UNKNOWN;

src/d3d11/d3d11_context_def.cpp

@@ -201,7 +201,7 @@ namespace dxvk {
         : MapImage (pResource, Subresource, &mapInfo);
 
       if (unlikely(FAILED(status))) {
-        pMappedResource->pData = nullptr;
+        *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
         return status;
       }
 
@@ -214,7 +214,7 @@ namespace dxvk {
       auto entry = FindMapEntry(pResource, Subresource);
 
       if (unlikely(!entry)) {
-        pMappedResource->pData = nullptr;
+        *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
         return D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD;
       }
 
@@ -223,7 +223,7 @@ namespace dxvk {
       return S_OK;
     } else {
       // Not allowed on deferred contexts
-      pMappedResource->pData = nullptr;
+      *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
       return E_INVALIDARG;
     }
   }

src/d3d11/d3d11_device.cpp

@@ -816,6 +816,8 @@ namespace dxvk {
     InitReturnPtr(ppGeometryShader);
     D3D11CommonShader module;
 
+    if (!m_dxvkDevice->features().extTransformFeedback.transformFeedback)
+      return DXGI_ERROR_INVALID_CALL;
 
     // Zero-init some counterss so that we can increment
     // them while walking over the stream output entries

src/d3d11/d3d11_gdi.cpp

@@ -5,7 +5,7 @@
 #include "../util/util_gdi.h"
 
 namespace dxvk {
-  
+
   D3D11GDISurface::D3D11GDISurface(
           ID3D11Resource*     pResource,
           UINT                Subresource)
@@ -33,7 +33,7 @@ namespace dxvk {
 
     if (D3DKMTCreateDCFromMemory(&desc))
       Logger::err(str::format("D3D11: Failed to create GDI DC"));
-    
+
     m_hdc     = desc.hDc;
     m_hbitmap = desc.hBitmap;
   }
@@ -49,16 +49,16 @@ namespace dxvk {
     D3DKMTDestroyDCFromMemory(&desc);
   }
 
-  
+
   HRESULT D3D11GDISurface::Acquire(BOOL Discard, HDC* phdc) {
     if (!phdc)
       return E_INVALIDARG;
-    
+
     *phdc = nullptr;
 
     if (m_acquired)
       return DXGI_ERROR_INVALID_CALL;
-    
+
     if (!Discard) {
       // Create a staging resource that we can map
       if (!m_readback && FAILED(CreateReadbackResource())) {
@@ -92,13 +92,13 @@ namespace dxvk {
 
       context->Unmap(m_readback, 0);
     }
-    
+
     m_acquired = true;
     *phdc      = m_hdc;
     return S_OK;
   }
 
-  
+
   HRESULT D3D11GDISurface::Release(const RECT* pDirtyRect) {
     if (!m_acquired)
       return DXGI_ERROR_INVALID_CALL;
@@ -140,7 +140,7 @@ namespace dxvk {
         sizeof(uint32_t) * tex->Width,
         sizeof(uint32_t) * tex->Width * tex->Height);
     }
-    
+
     m_acquired = false;
     return S_OK;
   }
@@ -149,11 +149,8 @@ namespace dxvk {
   HRESULT D3D11GDISurface::CreateReadbackResource() {
     auto tex = GetCommonTexture(m_resource);
 
-    Com<ID3D11Device>         device;
-    Com<ID3D11DeviceContext>  context;
-
+    Com<ID3D11Device> device;
     m_resource->GetDevice(&device);
-    device->GetImmediateContext(&context);
 
     D3D11_RESOURCE_DIMENSION dim = { };
     m_resource->GetType(&dim);
@@ -172,7 +169,7 @@ namespace dxvk {
         desc.BindFlags = 0;
         desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
         desc.MiscFlags = 0;
-        
+
         ID3D11Texture1D* tex1D = nullptr;
         HRESULT hr = device->CreateTexture1D(&desc, nullptr, &tex1D);
         m_readback = tex1D;
@@ -191,7 +188,7 @@ namespace dxvk {
         desc.BindFlags = 0;
         desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
         desc.MiscFlags = 0;
-        
+
         ID3D11Texture2D* tex2D = nullptr;
         HRESULT hr = device->CreateTexture2D(&desc, nullptr, &tex2D);
         m_readback = tex2D;