you can do it in the way Nvidia is doing here by preempting it, which basically just means that it gets inserted into the rendering pipeline at the most opportune time (instead of having to wait for another draw call to finish first.
Which wasn't possible on Maxwell and older, because it has to wait for graphics to finish first before being able to context switch the pipeline to handle compute.
With Pascal, that's an instantaneous change very much like GCN.
It works best if the compute timewarp can run in parallel, as Async Compute.
It works okay if the timewarp can go on a priority context and there's no delay for context switching. This is Pascal's uarch change, based on that article.
It works the least well the current way.
This is why NV say Maxwell at the BEST is only capable of 25ms motion to photon latency via async timewarp. Still above the 20ms recommended.
http://www.geforce.com/whats-new/ar...us-the-only-choice-for-virtual-reality-gaming
The standard VR pipeline from input in (when you move your head) to photons out (when you see the action occur in-game) is about 57 milliseconds (ms). However, for a good VR experience, this latency should be under 20ms.
Combined, and with the addition of further NVIDIA-developer tweaks, the VR pipeline is now only 25ms.
With this change in Pascal, they will get below that 20ms mark and there will be a lot of hoorah!
Why do I say this is "basic" Async Compute?
Because currently NV GPUs actually take a performance hit when AC is run. This is again because of their slow context switch. It causes stalls in the pipeline, wasting time where no work can be done.
The change in Pascal means even if they cannot run graphics + compute in parallel, devs calling for Async Compute, or even general games that use a lot of compute, won't cause stalls. In theory, it should behave like GCN where the graphics/compute context switch is fast.
Aside from actually having multi-engine like ACEs, this is a good fix by NV to add into Pascal as it resolves their weakness with performance regression with AC, and poor VR preemption due to stalls from slow context switches.
^ In the first instance, preemption, think of the slow context switch as adding idle time where the shaders cannot run as they are switching to handle graphics or compute. This is the problem with NV's current uarch, as pointed out by AMD's Robert Hallock when the Async Compute debacle started. This leads to NV losing performance when AC is used.
Basically with Pascal, it's much faster, what they call "fine-grained preemption", more flexible, anytime. And compute on priority can even override the current graphics task if that is needed.