Draw and update order in 3d graphics

Question

In all of the code samples that I have looked at, the game loop looks something like this:

while(true)
{
   InputAndUpdate();
   Draw();

   SwapBuffers();
}

However doesn't this destroy parallelism between the CPU and the GPU? After the swap buffers call, the GPU will be sitting there idly while the CPU is handling input and updating. Then when the CPU has finished issuing draw commands, it waits until the GPU is finished rendering. Why isn't it done like this? :

while(true)
{
   Draw(); //First issue the draw commands
   InputAndUpdate(); //Update while the GPU is busy rendering

   SwapBuffers(); //Now block and wait for the GPU to finish
}

Answer 1

This would be true unless you have an extra back buffer to render into (double-buffering). That allows the CPU to carry on and do stuff without having to wait for the actual buffer swap to occur (which would normally be the case as you couldn't start modifying the back buffer until it had been copied to the front buffer without risk of corrupting what you just rendered). When a draw call or swap is made, the request goes into a buffer of commands that the GPU can process, allowing the CPU to get on with doing other things while the GPU runs behind. This is how modern hardware gets parallelism. I believe D3D has a limit on just how many frames you can render ahead before a "Swap" will block (you'd need multiple back buffers to achieve this - also the more you buffer up the more latency you can potentially introduce between the input method and what is appearing on screen).

The concept of a game loop like either example above is quite dated. With the introduction of multiple processing units on the CPU you could potentially be doing rendering on one thread while doing some "update" work on one or more others. You might want to look into the concept of job queues to help maximise all the CPU processing power available.

Answer 2

the solution you sied doesn't accualy make CPU and GPU to work parrarel, it just changes the order they are waiting for each other, since as the other answer implys draw always put it's results into a backbuffer and using swapbuffers you only change what is monitor shoing with the latest thing drawn, to take full potential of both CPU and GPU you have to call draw and update in two diffrent threads and use another second buffer for what CPU is doing (so that when CPu is generating update results in buffer 2 GPU read from Buffer 1 and when CPU is working with Buffer 1 GPu use Buffer 2 just like swap buffers GPU uses to prevent changes in frame already drawn)