OpenGL和CPU / GPU计时器同步

Question

I'm trying to make a CPU and GPU profiler to use in a video game. The goal is to have on-screen 2 graphs that give the time taken by the different tasks of a frame. This is a very crude illustration of what it looks like:

I'm using QueryPerformanceCounter (on Windows) to get the CPU time and glQueryCounter(GL_TIMESTAMP) to get GPU times.

The problem is that the times I get for CPU and GPU are not relative to the same origin. My first attempt to fix this was to make a blocking call to a GPU timestamp (with glGetInteger64v(GL_TIMESTAMP)) during the initizalization of the app, closely followed by a get of the CPU time. The difference between the two times allowed me to basically convert GPU times to CPU times and have both graphs synchronized. But after a few seconds (or minutes) the times are drifting and my graphs are not correctly synchronized anymore.

I can't make another blocking call to get a GPU time after the game has started because I don't want to loose a frame and make the game stutter.

Did anyone try to do something like this or have any advice on how to synchronize the CPU and GPU times without hurting the performance ?

I have another idea but I don't know if it's going to work well: have a separate thread make the blocking call to get the GPU time, also get the CPU time and send back the difference to the main thread somehow. Then the thread would sleep for a few seconds and start again. I'll try this and update the post if this seem to work well.

Edit: I tried the idea above on both an AMD and an NV card and it seems to work fine. Even when calling glGetInteger64v(GL_TIMESTAMP) lots of times (with a sleep of only 1ms between each call), it seems to have no impact on the performance. I still need to make more in depth tests but so far, this looks like a good solution.

Answer 1

I made a separate thread that make a blocking call to glGetInteger64v(GL_TIMESTAMP). It made no visible difference in performance even when waiting something stupidly small like 1ms between each call. Although it should be noted that I already had several OpenGL contexts before this modification.

In the final code, I wait 30 seconds between each call to glGetInteger64v(GL_TIMESTAMP). It seems to be often enough to avoid any visible drifting on all the PCs I tested.

I tested on Nvidia cards (GTX 460, GTX 660, GTX 780ti, GTX 780M) and AMD (Radeon HD 7950), all with Intel CPUs.