One feature that I would like to see in OpenGL is the ability to have synchronouse and asynchronous execution.
For example, instead of the CPU waiting on the GPU after it had issued a glDrawElements/Arrays, this DrawElements/Arrays function would return control to the CPU immediately after it has been called. This way the CPU can work on other things, like fetching/processing other data in pereparation for sending it to the GPU. And A GPU would be responsible for sending a signal back or updating an OpenGL state indicating that it had finished rendering operation or that it is idle. Then the CPU would send another draw command, then maybe do some AI while the GPU is working.
It would be beneficial if GPUs can pull an interrupt that can be hooked to a function when they enter idle mode. this way we can use it for something like flipping the screen (the CPU recieves the interrupt, stops AI processing, heads to interrupt function and flips screen or does something else there. the return from the interupt function resumes the AI processing or whatever the CPU was doing before it was interrupted).
Only by having such capability (especially the interrupt) could be alleviate some of the problems of CPU/GPU stall. this stall wastes application performance.
And it is very easy to implement, provided the HW supports it.
Also, it should be scalable to allow multiple GPUs to work using this mechanizm.
It already does this. There is nothing in the GL spec that requires that rendering has finished when a glDraw* call completes.
However, there are things that glDraw* needs to do. If you’re not using VBO’s, it needs to copy your vertex data out of your array memory and into its own memory. VBO’s, usually, alieviate the need for this copy, so the time spent in glDraw* is far less.
And there is the GL_NV_fence extension with which you can track the execution progress of the GPU command queue…