Asynchronous Shaders are something that should have arrived a long time ago, because all we've been doing is throwing more power at the problem, rather than using that power more efficiently.
graphics
cards will support some of those features. For example, there are the so-called "Asynchronous Shaders," which are a different way of handling task queues than was possible in older graphics APIs and is potentially much more
efficient.
In DirectX 11, there are two primary ways of synchronous task scheduling: multi-threaded
graphics and multi-threaded graphics with pre-emption and prioritization, each with their advantages and disadvantages.
Before we continue, we must clarify a couple of terms. The GPU's shaders do the drawing of the image, computing of the game physics, post-processing and more, and they do this by being assigned various tasks. These tasks are delivered through the command stream, which is the main command queue of tasks that the shaders need to execute. The command stream is generated through merging individual command queues, which consist of multiple tasks and break spaces.
These empty parts in the queue exist because tasks in a single queue aren't generated one right after another in multi-threaded graphics; tasks in one queue are sometimes only generated after tasks in another queue. Due to these break spaces, a single queue cannot utilize the shaders to their full potential.
Generally speaking, there are three command queues: the graphics queue, the compute queue, and the copy queue.
The simplest way to describe how synchronous multi-threaded graphics works is that the command queues are merged by switching between one another on time intervals – one queue will go to the main command stream briefly, and then the next queue will go, and so on. Therefore, the gaps mentioned above remain in the central command queue, meaning that the GPU will never run at 100 percent actual load. In addition, if an urgent task comes along, it must merge with the command queue and wait for the rest of the command queues to finish executing. Another way of thinking of this is multiple sources at a traffic light merging into a single lane.
In DirectX 12, however, a new merging method called Asynchronous Shaders is available, which is basically asynchronous multi-threaded graphics with pre-emption and prioritization. What happens here is that the ACEs (Asynchronous Compute Engines) on AMD's GCN-based GPUs will interleave the tasks, filling the gaps in one queue with tasks from another, kind of like merging onto a highway where nobody moves to the side for you. Despite that, it can still move the main command queue to the side to let priority tasks pass by when necessary. It probably goes without saying that this leads to a performance gain.
On AMD's GCN GPUs, each ACE can handle up to eight queues, and each ACE can address its own fair
share of shaders. The most basic GPUs have just two ACEs, while more elaborate GPUs carry eight.
company is working closely with Microsoft to ensure the best support possible. During the briefing, the spokesman mentioned that he had seen no such information regarding support from its competitors, but we know that Nvidia is always very "hush hush" about unannounced products. It should be noted, however, that Asynchronous Shaders isn't something new only to DirectX 12; it will also be a part of the new Vulkan API as well as LiquidVR, and it exists in AMD's Mantle.
