Ashes of Singularity: DirectX 12 Benchmark II review - So what’s new?

1. Parallel rendering. Every core on your CPU can communicate with the GPU in parallel.
2. Explicit Multi-GPU support. Multiple GPUs can be combined together to improve performance.
3. Asynchronous compute. GPUs can now multitask within themselves resulting in significant performance gains.

Parallel rendering
Because Nitrous is a 4th generation engine, the current API model as used in DX11 can be a severe limiting factor. There are many ways to implement DX11, but most implementations of DX11 use what is known as a client/server model. The application is the client, and the driver is the server. The application fills out commands, often single threaded, and then a server thread processes them. There are severe problems with this approach. First, though in theory D3D11 can build commands on multiple threads, in practice the mechanisms for doing so ended up serializing such that it had minimal if any real benefit. Additionally, Oxide has consistently encountered bugs in multi-threading attempts at D3D11 on drivers from all vendors. The second problem is that this model assumes that the total amount of work needed to build commands for the GPU will never exceed a single core (i.e. the server thread), or the client thread can’t assemble them on a single CPU core. Thus, you will often see the behavior where scaling and performance is completely fine until one core becomes saturated. Then the entire performance of the system is determined by the performance of a single CPU core.
The third problem is that this approach assumes that the driver has available cores that the game is not using. This is simply not true with Nitrous. Nitrous will use all available cores so any driver thread will fight with game threads. We have spent considerable effort trying to cooperate with driver threads in DX11, but this ends up being a difficult task. However, Oxide has made significant optimizations and tuning for the DX11 path. Nitrous is one of the most efficient D3D11 engines ever built.

Explicit Multi-GPU
Oxide is excited to release the first-ever game which uses the explicit multi-GPU abilities of D3D12. In previous APIs, the existence of multi-GPUs was largely hidden to the application. Thus, there was no ability for the application to drive multiple GPUs. D3D12 enables us explicit control over all GPUs in the system. Thus, integrated directly into Ashes of the Singularity is the ability to do arbitrary AFR (alternate frame rendering) on multiple GPUs. The really exciting thing about this feature is that this can occur even if the GPUs are from different vendors! D3D12 has 2 modes of operation, Linked Display Adapter (LDA) and Multiple Display Adapter (MDA). Ashes of the Singularity is capable of using either mode. The first mode is essentially similar to Crossfire/SLI. In this mode some resources of the GPUs can be directly accessed by each other and some additional features can be used. For example, this mode would allow the use of the SLI bridge. The second mode is Multi Display Adapter. In this mode, any 2 cards can be used regardless of manufacture. D3D12 has several new exciting feature such as the ability to synchronize commands between the GPUs (aka Shared Fences), and can allow the sharing of resources via shared memory pools which may reside in system memory. There is even a specification for textures to be stored in a cross-vendor standard swizzle pattern to allow sharing to be more efficient. Any 2 cards which can operate in LDA mode can always operate in MDA mode. The wonderful thing is that we are able to do the seemingly impossible – use cards from different hardware vendors simultaneously with solid results. We are a firm believer in giving the consumer as much freedom as possible with regards to graphics hardware.

Asynchronous Compute
One of the new and exciting features of the D3D12 is the ability to use multiple command queues on a single GPU. This feature is very similar to explicit Multi-GPUs. The idea here is that a GPU could have multiple graphics, compute and copy queues. This allows work to act parallel to each other, and for completed work to signal other work. All of this is possible because Windows 10 has a sophisticated GPU scheduler which allows the OS to schedule commands to the GPU. Oxide is taking advantage of this advanced feature to allow us to enable not only the multi-GPU support, but to also even in single GPU schedule some of the work of the scene to be in parallel with other work in the scene. We’ve seen significant performance increases on some hardware by using the advanced scheduling capabilities of D3D12.