What?
Vulkan has a API for this, it isn't AMD specific.
That is the whole point in using Vulkan, it is a standard API, this isn't a example of using custom libs (like gameworks), so, what exactly is Doom supposed to change?
Does DOOM support asynchronous compute when running on the Vulkan API?
Asynchronous compute is a feature that provides additional performance gains on top of the baseline id Tech 6 Vulkan feature set.
Currently asynchronous compute is only supported on AMD GPUs and requires DOOM Vulkan supported drivers to run. We are working with NVIDIA to enable asynchronous compute in Vulkan on NVIDIA GPUs. We hope to have an update soon.
Click here for additional information on asynchronous compute.
Has anyone else noticed how much longer a Doom level takes to load with Vulcan compared to OpenGL? Even reloading after death.
I think that is the wrong conclusion.So as you can see, they need to enable asynchronous compute for NVidia GPUs in Vulkan. To support concurrent asynchronous compute, you need three things:
1) Hardware support
2) Driver support
3) API and program support
So what's apparently missing is the API support for concurrent asynchronous compute for NVidia GPUs.. This kind of goes in line with what I was saying earlier about Vulkan inheriting the Mantle codebase, which gave AMD a head start on NVidia when it came to low level support for AMD hardware.
I think that is the wrong conclusion.
The API *already* supports async, it is not vendor specific.
The hardware does have some level/form of it (for some nvidia cards), so, that leaves drivers.
I suppose they could be querying the drivers to see which vendor, then doing different code paths, but the original point still stands, if they are using pure Vulkan API calls, then it shouldn't matter which vendor the API is being run on, they should be following the specs of the API (via drivers).
I posted a quote directly from their FAQ page on the developer's website, and you're still challenging me on this
Asynchronous compute isn't vendor specific I agree, but the application/API has to be made aware that the capability exists on hardware before it can submit the work queues appropriately, and the code itself has to be written to take proper advantage. .. For example, when the first DX12 update came out for Rise of the Tomb Raider, asynchronous compute was not supported on either Radeons or NVidia GPUs. Only on the second DX12 update did this occur. Now this is despite the fact that DX12 supports asynchronous compute..
The truth is, Vulkan is very much a work in progress. AMD got a head start due to their Mantle donation, but that's it.
void D3D12nBodyGravity::OnRender()
{
// Wait for graphics fence to finish
if (AsynchronousComputeEnabled) {
PIXBeginEvent (m_computeCommandQueue.Get (), 0, L"Simulate");
m_computeCommandQueue->Wait (m_graphicsCopyFences [m_lastFrameIndex].Get (), m_graphicsCopyFenceValues [m_lastFrameIndex]);
} else {
PIXBeginEvent (m_graphicsCommandQueue.Get (), 0, L"Simulate");
}
RecordComputeCommandList ();
// Close and execute the command list.
ID3D12CommandList* ppCommandLists[] = { m_computeCommandLists[m_frameIndex].Get () };
if (AsynchronousComputeEnabled) {
m_computeCommandQueue->ExecuteCommandLists (1, ppCommandLists);
m_computeFenceValues [m_frameIndex] = m_computeFenceValue;
m_computeCommandQueue->Signal (m_computeFences [m_frameIndex].Get (), m_computeFenceValue);
PIXEndEvent (m_computeCommandQueue.Get ());
} else {
m_graphicsCommandQueue->ExecuteCommandLists (1, ppCommandLists);
PIXEndEvent (m_graphicsCommandQueue.Get ());
}
++m_computeFenceValue;
RecordCopyCommandList ();
ppCommandLists[0] = { m_graphicsCopyCommandLists[m_frameIndex].Get () };
// Wait for compute fence to finish
if (AsynchronousComputeEnabled) {
m_graphicsCommandQueue->Wait (m_computeFences [m_frameIndex].Get (), m_computeFenceValues [m_frameIndex]);
}
// Execute copy
m_graphicsCommandQueue->ExecuteCommandLists (1, ppCommandLists);
if (AsynchronousComputeEnabled) {
m_graphicsCommandQueue->Signal (m_graphicsCopyFences [m_frameIndex].Get (), m_graphicsCopyFenceValue);
}
PIXBeginEvent (m_graphicsCommandQueue.Get (), 0, L"Render");
++m_graphicsCopyFenceValue;
RecordRenderCommandList ();
// Execute the rendering
ppCommandLists[0] = { m_graphicsCommandLists[m_frameIndex].Get() };
m_graphicsCommandQueue->ExecuteCommandLists(1, ppCommandLists);
if (AsynchronousComputeEnabled) {
m_graphicsCommandQueue->Signal (m_graphicsFences [m_frameIndex].Get (), m_graphicsFenceValue);
}
PIXEndEvent (m_graphicsCommandQueue.Get ());
++m_graphicsFenceValue;
// Present the frame.
ThrowIfFailed(m_swapChain->Present(0, 0));
MoveToNextFrame();
}
The part that tells the code to enable / disable that is either an option in settings, or the driver saying "Yes use it or no I can't so disable it". It is up to Nvidia to provide working drivers. We heard the exact same quote from Oxide regarding Async Compute in Ashes of the Singularity for Maxwell. Will Nvidia actually deliver this time?
I'm not a graphics programmer, but I doubt asynchronous compute is that simple. According to I/O interactive, the developer behind Hitman, Asynchronous compute is super hard to tune..
The reason that Maxwell is slower is if you don't do the checks I was doing above (or the driver tells it it CAN handle async compute) is the fences will slightly slow down the pipeline and you don't have the benefit from rendering faster, so you get lower performance overall.
I think you are missing the point.I posted a quote directly from their FAQ page on the developer's website, and you're still challenging me on this .
You take that to mean an API issue, and I am saying it can't be a API issue, it is a driver (or hardware) issue that they must work around.We are working with NVIDIA to enable asynchronous compute in Vulkan on NVIDIA GPUs. We hope to have an update soon.
Maxwell is a special case scenario. While it's capable of asynchronous compute, it's not capable of using asynchronous compute dynamically, unlike Pascal.. Or that's the explanation Ryan gave in his 1080 review. With Maxwell, the driver needs to know beforehand what the asynchronous workload is going to be so it can allocate resources as required. But of course this isn't the way that games are being programmed. Perhaps with a special Maxwell optimized title this could work, but not with most games at all..
And that's why the performance hit was so large for Maxwell when Async compute was turned on..
Well, Maxwell is able of "async-compute", but it applies only for CUDA (Compute). It's not compatible with DX12 Multi-engine/Vulkan Async-Compute.Maxwell is a special case scenario. While it's capable of asynchronous compute, it's not capable of using asynchronous compute dynamically, unlike Pascal.
Well, Maxwell is able of "async-compute", but it applies only for CUDA (Compute). It's not compatible with DX12 Multi-engine/Vulkan Async-Compute.
The reason why Nvidia probably can't do async compute in Doom is because the implementation is locked behind AMD shader intrinsic extensions
The reason why Nvidia probably can't do async compute in Doom is because the implementation is locked behind AMD shader intrinsic extensions ...
If your async compute code path requires an IHV specific extension then no other IHVs will be able to access that very same path UNTIL they support the said implementation of that extension in their drivers ...
Source?
lol if this is true why is it not being talked about? All the talk about more "free" performance kinda goes out the window if the loading times increase.Has anyone else noticed how much longer a Doom level takes to load with Vulcan compared to OpenGL? Even reloading after death.
Has anyone else noticed how much longer a Doom level takes to load with Vulcan compared to OpenGL? Even reloading after death.
lol if this is true why is it not being talked about? All the talk about more "free" performance kinda goes out the window if the loading times increase.
Sent from my HTC One M9
How so? If the loading times are longer then Vulkan mode is inferior no 2 ways about it.That's an absurd conclusion.
How so? If the loading times are longer then Vulkan mode is inferior no 2 ways about it.
Sent from my HTC One M9
Sure but it only matters for those who get poor performance in OpenGL.No, not really. The free performance doesn't just go "out the window", it still has smoother gameplay than OpenGL mode.