Framelimiter | Why are there extra milliseconds? - c++

Question

After a lot of testing with this thing, I still can't figure out why there are extra milliseconds appended to the millisecond limit.
In this case, the whole running loop should last 4000ms, and then print 4000 followed by some other data, however it is always around 4013ms.
I currently know that the problem isn't the stress testing, since without it, it's still at around 4013ms. Besides, there's is a limit for how long the stress testing can take, and the time is justified by how much rendering is able to be done in the remaining time. I also know that it isn't "SDL_GetTicks" including the time I'm initialising variables, since it only starts timing when it is first called. It's not the time it takes to call the function either, because I tested this with a very lightweight nanosecond timer as well, and the result is the same.
Here's some of my results, that are printed at the end:
4013 100 993 40
4013 100 1000 40
4014 100 1000 40
4012 100 992 40
4015 100 985 40
4013 100 1000 40
4022 100 986 40
4014 100 1000 40
4017 100 993 40
Unlike the third column (the amount of frames rendered), the first column shouldn't vary by much more than the few nanoseconds it took to exit the loops and such. Meaning it shouldn't even show a difference since the scope of the timer is milliseconds in this case.
I recompiled between all of them, and the list is pretty much continues the same.
Here's the code:
#include <iostream>
#include <SDL/SDL.h>
void stress(int n) {
n = n + n - n * n + n * n;
}
int main(int argc, char **argv) {
int running = 100,
timestart = 0, timestep = 0,
rendering = 0, logic = 0,
SDL_Init(SDL_INIT_EVERYTHING);
while(running--) { // - Running loop
timestart = SDL_GetTicks();
std::cout << "logic " << logic++ << std::endl;
for(int i = 0; i < 9779998; i++) { // - Stress testing
if(SDL_GetTicks() - timestart >= 30) { // - Maximum of 30 milliseconds spent running logic
break;
}
stress(i);
}
while(SDL_GetTicks() - timestart < 1) { // - Minimum of one millisecond to run through logic
;
}
timestep = SDL_GetTicks() - timestart;
while(40 > timestep) {
timestart = SDL_GetTicks();
std::cout << "rendering " << rendering++ << std::endl;
while(SDL_GetTicks() - timestart < 1) { // - Maximum of one rendering frame per millisecond
;
}
timestep += SDL_GetTicks() - timestart;
}
}
std::cout << SDL_GetTicks() << " " << logic << " " << rendering << " " << timestep << std::endl;
SDL_Quit();
return 0;
}

Answer 1

Elaborating on crowders comment - if your OS decides to switch tasks you will end up with a random error between 0 and 1 ms(or -.5 and .5 if SDL_GetTicks would be rounding it's internal timer, but your results always greater than expected suggest it is actually truncating). These will 'even out' within your next busy wait, but not near the end of the loop - since there is none 'next busy wait' there. To counteract it you need a reference point from before you start your game loop and compare it with GetTicks to measure how much time have "leaked". Also your approach of X miliseconds per frame and busy waits/breaks in the middle of computation isn't the cleanest i've seen. You should probably google about game loops and read a bit.