Why does my frames per second function return inconsistent results?

Question

I have a FPS function that:

private static void runGameFPS2() {
    long beginTime; //The time when the cycle begun
    long timeDiff; //The time it took for the cycle to execute
    int sleepTime; //ms to sleep (< 0 if we're behind)
    int fps = 1000 / 40;

    beginTime = System.currentTimeMillis();

    //Update game state
    updateGame();
    //Render state to the screen
    renderScreen();

    //Calculate how long did the cycle take
    timeDiff = System.currentTimeMillis() - beginTime;

    //Calculate sleep time
    sleepTime = fps - (int)(timeDiff);

    if (sleepTime > 0) {//If sleepTime > 0 we're OK
        try { Thread.sleep(sleepTime); }catch(InterruptedException e){}
    }else{
        //suppose will not be
    }
}

public static void main(String[] args){
    while(true){ runGameFPS2(); }
}

  When I run my code, Java works at different speeds on same computer or on different computers.

How can I write a consistent code, that Java will always work "same time" (for example 40 FPS) on mycomputer or any computer?

Note: suppose sleepTime will never be sleepTime < 0

Answer 1

System.currentTimeMillis() isn't a very good method to use for this sort of timing as it only has a resolution of 16ms on Windows based systems.

Try using System.nanoTime() / 1000000 instead, and see if that makes it better.

You could also switch to using nanoseconds entirely, there is a Thread.sleep(long, int) that takes nanoseconds.

Answer 2

Your problem might be that you're calling sleep() on each loop. I don't think sleep() is high precision, meaning it may deal in 16ms increments on Windows also, like System.currentTimeMillis().

Your best bet is not to sleep in the main loop. Try just running it without sleeping and see if the timing is still inconsistent.

EDIT:

You control the speed by calculating how far the box has moved during the frame. The basic formula is distance = speed * time, so the speed of the object multiplied by the time between frames gives you the object's change in position between frames.

For example, if you want the box to move 100 pixels per second, then do a calculation like:

// get time since last frame
currentFrameTime = System.currentTimeMillis();
timeBetweenFrames = currentFrameTime - lastFrameTime;
lastFrameTime = currentFrameTime;

// calculate distance change and new position
distanceX = 100 * (timeBetweenFrames / 1000); 
box.x += distanceX;

Just be sure to get your units the same (that's why we divided timeBetweenFrames by 1000, since it's in milliseconds).

Answer 3

Sleep itself is not a good method to use for anything in a game loop, and is even worse for use as an FPS limiter - the only realistic use case for it is if you have an absolute power-saving requirement that is considered more important than timer accuracy.

Reason why is that Sleep fails on two counts. First it is a low-precision timer itself, using (again) an approx. 16ms resolution. Second it only guarantees a minimum time to sleep for - the actual time it does sleep for can be any arbitrary time-span above this.

If you want to limit frame rate, do so based on accumulated time or on vsync, but never use any Sleep call for this purpose.

Answer 4

Sleeping can't promise a precise come back. That is handled by the scheduler of the JVM as well as the Operative System. It's impossible to accomplish it that way. You must accept the fact you can't control it and compensate for over sleeping as well.

The most complete way to make it work is by this piece of code extracted from the book "Killer Game Programming in Java". It does all this:

• Makes sure that you work at the desired frame rate consistently across any computer.
• Divides updating the game state from actually rendering it
• Releases the current thread if it finished updating and rendering the frame in less than the required time. It also releases the current thread in case it is hogging the CPU because it didn't have extra time.
• Handles the case where it overslept and tries to catch up
• In case it takes longer to make update and render for a given frame it takes note. Then it will skip the rendering but will do an update. If too many renderings are being skipped it will perform a rendering even if it still didn't catch up so the image doesn't freeze.

It's the most solid update/render loop I have come across in several years.

// Desired frames per second
private static int FPS = 60;
// nanoseconds per frame
private long period = 1000000000L / FPS;
private boolean running = true;
// no. of frames that can be skipped in any one animation loop
// i.e the games state is updated but not rendered
private static int MAX_FRAME_SKIPS = 5;
/**
 * Number of frames with a delay of 0 ms before the animation thread yields to other running threads.
 */
private static final int NO_DELAYS_PER_YIELD = 16;

/*
 * Repeatedly update, render, sleep so loop takes close to period nsecs. Sleep inaccuracies are handled.
 *
 * Overruns in update/renders will cause extra updates to be carried out so UPS tild== requested FPS
 */
public void run() {
    long beforeTime, afterTime, timeDiff, sleepTime;
    long overSleepTime = 0L;
    int noDelays = 0;
    long excess = 0L;

    beforeTime = System.nanoTime();

    running = true;
    while (running) {
        gameUpdate();
        gameRender();
        paintScreen();

        afterTime = System.nanoTime();
        timeDiff = afterTime - beforeTime;
        sleepTime = (period - timeDiff) - overSleepTime;

        if (sleepTime > 0) {   // some time left in this cycle
            try {
                Thread.sleep(sleepTime / 1000000L);  // nano -> ms
            } catch (InterruptedException ex) {
            }
            overSleepTime = (System.nanoTime() - afterTime) - sleepTime;
        } else {    // sleepTime <= 0; frame took longer than the period
            excess -= sleepTime;  // store excess time value
            overSleepTime = 0L;

            if (++noDelays >= NO_DELAYS_PER_YIELD) {
                Thread.yield();   // give another thread a chance to run
                noDelays = 0;
            }
        }

        beforeTime = System.nanoTime();

        /*
         * If frame animation is taking too long, update the game state without rendering it, to get the updates/sec
         * nearer to the required FPS.
         */
        int skips = 0;
        while ((excess > period) && (skips < MAX_FRAME_SKIPS)) {
            excess -= period;
            gameUpdate();      // update state but don't render
            skips++;
        }
    }

    System.exit(0);
}