Calculating frames per second in a game

Question

What s a good algorithm for calculating frames per second in a game  I want to show it as a number in the corner of the screen  If I just look at how long it took to render the last frame the number changes too fast   Bonus points if your answer updates each frame and doesn t converge differently when the frame rate is increasing vs decreasing

User · Answer

This is based on KPexEA s answer and gives the Simple Moving Average  Tidied and converted to TypeScript for easy copy and paste  Variable declaration  fpsObject       maxSamples  100    tickIndex  0    tickSum  0    tickList        Function  calculateFps currentFps  number   number     this fpsObject tickSum -  this fpsObject tickList this fpsObject tickIndex     0   this fpsObject tickSum    currentFps   this fpsObject tickList this fpsObject tickIndex    currentFps   if    this fpsObject tickIndex     this fpsObject maxSamples  this fpsObject tickIndex   0   const smoothedFps   this fpsObject tickSum   this fpsObject maxSamples   return Math floor smoothedFps     Usage  may vary in your app   this fps   this calculateFps this ticker FPS

User · Answer

You could keep a counter  increment it after each frame is rendered  then reset the counter when you are on a new second  storing the previous value as the last second s   of frames rendered

User · Answer

Set counter to zero  Each time you draw a frame increment the counter  After each second print the counter  lather  rinse  repeat  If yo want extra credit  keep a running counter and divide by the total number of seconds for a running average

User · Answer

You could keep a counter  increment it after each frame is rendered  then reset the counter when you are on a new second  storing the previous value as the last second s   of frames rendered

User · Answer

In Typescript  I use this algorithm to calculate framerate and frametime averages   let getTime        gt        return new Date   getTime        let frames  any         let previousTime   getTime    let framerate number   0  let frametime number   0   let updateStats    samples number 60    gt        samples   Math max samples  1   gt  gt  0       if  frames length     samples            let currentTime  number   getTime   - previousTime           frametime   currentTime   samples          framerate   1000   samples   currentTime           previousTime   getTime             frames                  frames push 1       usage   statsUpdate        Print stats innerHTML   Math round framerate      FPS     frametime toFixed 2      ms     Tip  If samples is 1  the result is real-time framerate and frametime

User · Answer

Set counter to zero  Each time you draw a frame increment the counter  After each second print the counter  lather  rinse  repeat  If yo want extra credit  keep a running counter and divide by the total number of seconds for a running average

User · Answer

qx Class define  FpsCounter         extend  qx core Object       properties                events                construct  function            this base arguments           this restart                statics                members                    restart  function                this   frames                             addFrame  function                this   frames push new Date                           getFps  function averageFrames               debugger              if  averageFrames                   averageFrames   2                            var time   0              var l   this   frames length              var i   averageFrames              while i  gt  0                   if l - i - 1  gt   0                       time    this   frames l - i  - this   frames l - i - 1                                     i--                            var fps   averageFrames   time   1000              return fps

User · Answer

You need a smoothed average  the easiest way is to take the current answer  the time to draw the last frame  and combine it with the previous answer      eg  float smoothing   0 9     larger more smoothing measurement    measurement   smoothing     current    1 0-smoothing     By adjusting the 0 9   0 1 ratio you can change the  time constant  - that is how quickly the number responds to changes  A larger fraction in favour of the old answer gives a slower smoother change  a large fraction in favour of the new answer gives a quicker changing value    Obviously the two factors must add to one

User · Answer

In  c   like  pseudocode these two are what I used in industrial image processing applications that had to process images from a set of externally triggered camera s  Variations in  frame rate  had a different source  slower or faster production on the belt  but the problem is the same   I assume that you have a simple timer peek   call that gives you something like the nr of msec  nsec   since application start or the last call   Solution 1  fast but not updated every frame  do while  1        ProcessImage frame      if  frame framenumber poll interval  0                new time timer peek           framerate poll interval  new time - last time          last time new time           Solution 2  updated every frame  requires more memory and CPU  do while  1       ProcessImage frame     new time timer peek      delta new time - last time    last time   new time    total time    delta    delta history push delta     framerate  delta history length     total time    while  delta history length    gt  avg interval             oldest delta   delta history pop         total time -  oldest delta

User · Answer

Set counter to zero  Each time you draw a frame increment the counter  After each second print the counter  lather  rinse  repeat  If yo want extra credit  keep a running counter and divide by the total number of seconds for a running average

User · Answer

Increment a counter every time you render a screen and clear that counter for some time interval over which you want to measure the frame-rate   Ie  Every 3 seconds  get counter 3 and then clear the counter

User · Answer

Good answers here  Just how you implement it is dependent on what you need it for   I prefer the running average one myself  time   time   0 9   last frame   0 1  by the guy above   however I personally like to weight my average more heavily towards newer data because in a game it is SPIKES that are the hardest to squash and thus of most interest to me  So I would use something more like a  7    3 split will make a spike show up much faster  though it s effect will drop off-screen faster as well   see below   If your focus is on RENDERING time  then the  9 1 split works pretty nicely b c it tend to be more smooth  THough for gameplay AI physics spikes are much more of a concern as THAT will usually what makes your game look choppy  which is often worse than a low frame rate assuming we re not dipping below 20 fps   So  what I would do is also add something like this     define ONE OVER FPS  1 0f 60 0f  static float g SpikeGuardBreakpoint   3 0f   ONE OVER FPS  if time  gt  g SpikeGuardBreakpoint      DoInternalBreakpoint      fill in 3 0f with whatever magnitude you find to be an unacceptable spike  This will let you find and thus solve FPS issues the end of the frame they happen

User · Answer

A much better system than using a large array of old framerates is to just do something like this   new fps   old fps   0 99   new fps   0 01   This method uses far less memory  requires far less code  and places more importance upon recent framerates than old framerates while still smoothing the effects of sudden framerate changes

User · Answer

This might be overkill for most people  that s why I hadn t posted it when I implemented it  But it s very robust and flexible   It stores a Queue with the last frame times  so it can accurately calculate an average FPS value much better than just taking the last frame into consideration   It also allows you to ignore one frame  if you are doing something that you know is going to artificially screw up that frame s time   It also allows you to change the number of frames to store in the Queue as it runs  so you can test it out on the fly what is the best value for you      Number of past frames to use for FPS smooth calculation - because     Unity s smoothedDeltaTime  well - it kinda sucks private int frameTimesSize   60     A Queue is the perfect data structure for the smoothed FPS task     new values in  old values out private Queue lt float gt  frameTimes     Not really needed  but used for faster updating then processing     the entire queue every frame private float   frameTimesSum   0     Flag to ignore the next frame when performing a heavy one-time operation      like changing resolution  private bool  fpsIgnoreNextFrame   false                                                                                      Call this after doing a heavy operation that will screw up with FPS calculation void FPSIgnoreNextFrame         this  fpsIgnoreNextFrame   true                                                                                        Smoothed FPS counter updating void Update         if  this  fpsIgnoreNextFrame            this  fpsIgnoreNextFrame   false          return                While looping here allows the frameTimesSize member to be changed dinamically     while  this frameTimes Count  gt   this frameTimesSize            this   frameTimesSum -  this frameTimes Dequeue              while  this frameTimes Count  lt  this frameTimesSize            this   frameTimesSum    Time deltaTime          this frameTimes Enqueue Time deltaTime                                                                                               Public function to get smoothed FPS values public int GetSmoothedFPS         return  int  this frameTimesSize   this   frameTimesSum   Time timeScale

User · Answer

Increment a counter every time you render a screen and clear that counter for some time interval over which you want to measure the frame-rate   Ie  Every 3 seconds  get counter 3 and then clear the counter

User · Answer

This is based on KPexEA s answer and gives the Simple Moving Average  Tidied and converted to TypeScript for easy copy and paste  Variable declaration  fpsObject       maxSamples  100    tickIndex  0    tickSum  0    tickList        Function  calculateFps currentFps  number   number     this fpsObject tickSum -  this fpsObject tickList this fpsObject tickIndex     0   this fpsObject tickSum    currentFps   this fpsObject tickList this fpsObject tickIndex    currentFps   if    this fpsObject tickIndex     this fpsObject maxSamples  this fpsObject tickIndex   0   const smoothedFps   this fpsObject tickSum   this fpsObject maxSamples   return Math floor smoothedFps     Usage  may vary in your app   this fps   this calculateFps this ticker FPS

User · Answer

You need a smoothed average  the easiest way is to take the current answer  the time to draw the last frame  and combine it with the previous answer      eg  float smoothing   0 9     larger more smoothing measurement    measurement   smoothing     current    1 0-smoothing     By adjusting the 0 9   0 1 ratio you can change the  time constant  - that is how quickly the number responds to changes  A larger fraction in favour of the old answer gives a slower smoother change  a large fraction in favour of the new answer gives a quicker changing value    Obviously the two factors must add to one

User · Answer

JavaScript      Set the end and start times var start    new Date  getTime    end  FPS                the loop block your want to watch                end    new Date  getTime       since the times are by millisecond  use 1000  1000ms   1s     then multiply the result by  MaxFPS   1000     FPS    1000 -  end - start      MaxFPS   1000  FPS   Math round  1000 -  end - start      60   1000

User · Answer

This is what I have used in many games    define MAXSAMPLES 100 int tickindex 0  int ticksum 0  int ticklist MAXSAMPLES       need to zero out the ticklist array before starting       average will ramp up until the buffer is full       returns average ticks per frame over the MAXSAMPLES last frames     double CalcAverageTick int newtick        ticksum- ticklist tickindex       subtract value falling off        ticksum  newtick                  add new value        ticklist tickindex  newtick       save new value so it can be subtracted later        if   tickindex  MAXSAMPLES        inc buffer index            tickindex 0          return average        return  double ticksum MAXSAMPLES

User · Answer

A much better system than using a large array of old framerates is to just do something like this   new fps   old fps   0 99   new fps   0 01   This method uses far less memory  requires far less code  and places more importance upon recent framerates than old framerates while still smoothing the effects of sudden framerate changes

User · Answer

JavaScript      Set the end and start times var start    new Date  getTime    end  FPS                the loop block your want to watch                end    new Date  getTime       since the times are by millisecond  use 1000  1000ms   1s     then multiply the result by  MaxFPS   1000     FPS    1000 -  end - start      MaxFPS   1000  FPS   Math round  1000 -  end - start      60   1000

User · Answer

store a start time and increment your framecounter once per loop  every few seconds you could just print framecount  Now - starttime  and then reinitialize them   edit  oops  double-ninja ed

User · Answer

Good answers here  Just how you implement it is dependent on what you need it for   I prefer the running average one myself  time   time   0 9   last frame   0 1  by the guy above   however I personally like to weight my average more heavily towards newer data because in a game it is SPIKES that are the hardest to squash and thus of most interest to me  So I would use something more like a  7    3 split will make a spike show up much faster  though it s effect will drop off-screen faster as well   see below   If your focus is on RENDERING time  then the  9 1 split works pretty nicely b c it tend to be more smooth  THough for gameplay AI physics spikes are much more of a concern as THAT will usually what makes your game look choppy  which is often worse than a low frame rate assuming we re not dipping below 20 fps   So  what I would do is also add something like this     define ONE OVER FPS  1 0f 60 0f  static float g SpikeGuardBreakpoint   3 0f   ONE OVER FPS  if time  gt  g SpikeGuardBreakpoint      DoInternalBreakpoint      fill in 3 0f with whatever magnitude you find to be an unacceptable spike  This will let you find and thus solve FPS issues the end of the frame they happen

User · Answer

In Typescript  I use this algorithm to calculate framerate and frametime averages   let getTime        gt        return new Date   getTime        let frames  any         let previousTime   getTime    let framerate number   0  let frametime number   0   let updateStats    samples number 60    gt        samples   Math max samples  1   gt  gt  0       if  frames length     samples            let currentTime  number   getTime   - previousTime           frametime   currentTime   samples          framerate   1000   samples   currentTime           previousTime   getTime             frames                  frames push 1       usage   statsUpdate        Print stats innerHTML   Math round framerate      FPS     frametime toFixed 2      ms     Tip  If samples is 1  the result is real-time framerate and frametime

User · Answer

You need a smoothed average  the easiest way is to take the current answer  the time to draw the last frame  and combine it with the previous answer      eg  float smoothing   0 9     larger more smoothing measurement    measurement   smoothing     current    1 0-smoothing     By adjusting the 0 9   0 1 ratio you can change the  time constant  - that is how quickly the number responds to changes  A larger fraction in favour of the old answer gives a slower smoother change  a large fraction in favour of the new answer gives a quicker changing value    Obviously the two factors must add to one

User · Answer

You could keep a counter  increment it after each frame is rendered  then reset the counter when you are on a new second  storing the previous value as the last second s   of frames rendered

User · Answer

Well  certainly   frames   sec   1    sec   frame    But  as you point out  there s a lot of variation in the time it takes to render a single frame  and from a UI perspective updating the fps value at the frame rate is not usable at all  unless the number is very stable    What you want is probably a moving average or some sort of binning   resetting counter   For example  you could maintain a queue data structure which held the rendering times for each of the last 30  60  100  or what-have-you frames  you could even design it so the limit was adjustable at run-time   To determine a decent fps approximation you can determine the average fps from all the rendering times in the queue   fps     of rendering times in queue   total rendering time   When you finish rendering a new frame you enqueue a new rendering time and dequeue an old rendering time  Alternately  you could dequeue only when the total of the rendering times exceeded some preset value  e g  1 sec   You can maintain the  last fps value  and a last updated timestamp so you can trigger when to update the fps figure  if you so desire  Though with a moving average if you have consistent formatting  printing the  instantaneous average  fps on each frame would probably be ok   Another method would be to have a resetting counter  Maintain a precise  millisecond  timestamp  a frame counter  and an fps value  When you finish rendering a frame  increment the counter  When the counter hits a pre-set limit  e g  100 frames  or when the time since the timestamp has passed some pre-set value  e g  1 sec   calculate the fps   fps     frames    current time - start time    Then reset the counter to 0 and set the timestamp to the current time

User · Answer

Well  certainly   frames   sec   1    sec   frame    But  as you point out  there s a lot of variation in the time it takes to render a single frame  and from a UI perspective updating the fps value at the frame rate is not usable at all  unless the number is very stable    What you want is probably a moving average or some sort of binning   resetting counter   For example  you could maintain a queue data structure which held the rendering times for each of the last 30  60  100  or what-have-you frames  you could even design it so the limit was adjustable at run-time   To determine a decent fps approximation you can determine the average fps from all the rendering times in the queue   fps     of rendering times in queue   total rendering time   When you finish rendering a new frame you enqueue a new rendering time and dequeue an old rendering time  Alternately  you could dequeue only when the total of the rendering times exceeded some preset value  e g  1 sec   You can maintain the  last fps value  and a last updated timestamp so you can trigger when to update the fps figure  if you so desire  Though with a moving average if you have consistent formatting  printing the  instantaneous average  fps on each frame would probably be ok   Another method would be to have a resetting counter  Maintain a precise  millisecond  timestamp  a frame counter  and an fps value  When you finish rendering a frame  increment the counter  When the counter hits a pre-set limit  e g  100 frames  or when the time since the timestamp has passed some pre-set value  e g  1 sec   calculate the fps   fps     frames    current time - start time    Then reset the counter to 0 and set the timestamp to the current time

User · Answer

Good answers here  Just how you implement it is dependent on what you need it for   I prefer the running average one myself  time   time   0 9   last frame   0 1  by the guy above   however I personally like to weight my average more heavily towards newer data because in a game it is SPIKES that are the hardest to squash and thus of most interest to me  So I would use something more like a  7    3 split will make a spike show up much faster  though it s effect will drop off-screen faster as well   see below   If your focus is on RENDERING time  then the  9 1 split works pretty nicely b c it tend to be more smooth  THough for gameplay AI physics spikes are much more of a concern as THAT will usually what makes your game look choppy  which is often worse than a low frame rate assuming we re not dipping below 20 fps   So  what I would do is also add something like this     define ONE OVER FPS  1 0f 60 0f  static float g SpikeGuardBreakpoint   3 0f   ONE OVER FPS  if time  gt  g SpikeGuardBreakpoint      DoInternalBreakpoint      fill in 3 0f with whatever magnitude you find to be an unacceptable spike  This will let you find and thus solve FPS issues the end of the frame they happen

User · Answer

qx Class define  FpsCounter         extend  qx core Object       properties                events                construct  function            this base arguments           this restart                statics                members                    restart  function                this   frames                             addFrame  function                this   frames push new Date                           getFps  function averageFrames               debugger              if  averageFrames                   averageFrames   2                            var time   0              var l   this   frames length              var i   averageFrames              while i  gt  0                   if l - i - 1  gt   0                       time    this   frames l - i  - this   frames l - i - 1                                     i--                            var fps   averageFrames   time   1000              return fps

User · Answer

Well  certainly   frames   sec   1    sec   frame    But  as you point out  there s a lot of variation in the time it takes to render a single frame  and from a UI perspective updating the fps value at the frame rate is not usable at all  unless the number is very stable    What you want is probably a moving average or some sort of binning   resetting counter   For example  you could maintain a queue data structure which held the rendering times for each of the last 30  60  100  or what-have-you frames  you could even design it so the limit was adjustable at run-time   To determine a decent fps approximation you can determine the average fps from all the rendering times in the queue   fps     of rendering times in queue   total rendering time   When you finish rendering a new frame you enqueue a new rendering time and dequeue an old rendering time  Alternately  you could dequeue only when the total of the rendering times exceeded some preset value  e g  1 sec   You can maintain the  last fps value  and a last updated timestamp so you can trigger when to update the fps figure  if you so desire  Though with a moving average if you have consistent formatting  printing the  instantaneous average  fps on each frame would probably be ok   Another method would be to have a resetting counter  Maintain a precise  millisecond  timestamp  a frame counter  and an fps value  When you finish rendering a frame  increment the counter  When the counter hits a pre-set limit  e g  100 frames  or when the time since the timestamp has passed some pre-set value  e g  1 sec   calculate the fps   fps     frames    current time - start time    Then reset the counter to 0 and set the timestamp to the current time

User · Answer

In  c   like  pseudocode these two are what I used in industrial image processing applications that had to process images from a set of externally triggered camera s  Variations in  frame rate  had a different source  slower or faster production on the belt  but the problem is the same   I assume that you have a simple timer peek   call that gives you something like the nr of msec  nsec   since application start or the last call   Solution 1  fast but not updated every frame  do while  1        ProcessImage frame      if  frame framenumber poll interval  0                new time timer peek           framerate poll interval  new time - last time          last time new time           Solution 2  updated every frame  requires more memory and CPU  do while  1       ProcessImage frame     new time timer peek      delta new time - last time    last time   new time    total time    delta    delta history push delta     framerate  delta history length     total time    while  delta history length    gt  avg interval             oldest delta   delta history pop         total time -  oldest delta

User · Answer

In  c   like  pseudocode these two are what I used in industrial image processing applications that had to process images from a set of externally triggered camera s  Variations in  frame rate  had a different source  slower or faster production on the belt  but the problem is the same   I assume that you have a simple timer peek   call that gives you something like the nr of msec  nsec   since application start or the last call   Solution 1  fast but not updated every frame  do while  1        ProcessImage frame      if  frame framenumber poll interval  0                new time timer peek           framerate poll interval  new time - last time          last time new time           Solution 2  updated every frame  requires more memory and CPU  do while  1       ProcessImage frame     new time timer peek      delta new time - last time    last time   new time    total time    delta    delta history push delta     framerate  delta history length     total time    while  delta history length    gt  avg interval             oldest delta   delta history pop         total time -  oldest delta

User · Answer

Increment a counter every time you render a screen and clear that counter for some time interval over which you want to measure the frame-rate   Ie  Every 3 seconds  get counter 3 and then clear the counter

User · Answer

store a start time and increment your framecounter once per loop  every few seconds you could just print framecount  Now - starttime  and then reinitialize them   edit  oops  double-ninja ed

User · Answer

You could keep a counter  increment it after each frame is rendered  then reset the counter when you are on a new second  storing the previous value as the last second s   of frames rendered

User · Answer

Here s a complete example  using Python  but easily adapted to any language   It uses the smoothing equation in Martin s answer  so almost no memory overhead  and I chose values that worked for me  feel free to play around with the constants to adapt to your use case    import time  SMOOTHING FACTOR   0 99 MAX FPS   10000 avg fps   -1 last tick   time time    while True         lt Do your rendering work here    gt       current tick   time time         Ensure we don t get crazy large frame rates  by capping to MAX FPS     current fps   1 0   max current tick - last tick  1 0 MAX FPS      last tick   current tick     if avg fps  lt  0          avg fps   current fps     else          avg fps    avg fps   SMOOTHING FACTOR     current fps    1-SMOOTHING FACTOR       print avg fps

User · Answer

How i do it   boolean run   false   int ticks   0   long tickstart   int fps   public void loop     if this ticks  0    this tickstart   System currentTimeMillis      this ticks    this fps    int this ticks    System currentTimeMillis  -this tickstart       In words  a tick clock tracks ticks  If it is the first time  it takes the current time and puts it in  tickstart   After the first tick  it makes the variable  fps  equal how many ticks of the tick clock divided by the time minus the time of the first tick   Fps is an integer  hence   int

User · Answer

Increment a counter every time you render a screen and clear that counter for some time interval over which you want to measure the frame-rate   Ie  Every 3 seconds  get counter 3 and then clear the counter

User · Answer

There are at least two ways to do it     The first is the one others have mentioned here before me  I think it s the simplest and preferred way  You just to keep track of    cn  counter of how many frames you ve rendered time start  the time since you ve started counting time now  the current time   Calculating the fps in this case is as simple as evaluating this formula    FPS   cn    time now - time start       Then there is the uber cool way you might like to use some day   Let s say you have  i  frames to consider  I ll use this notation  f 0   f 1       f i-1  to  describe how long it took to render frame 0  frame 1       frame  i-1  respectively   Example where i   3   f 0        f 1           f 2       ---------- ------------- ------- ------ gt  time   Then  mathematical definition of fps after i frames would be   1  fps i      i        f 0          f i-1     And the same formula but only considering i-1 frames    2  fps i-1     i-1     f 0          f i-2      Now the trick here is to modify the right side of formula  1  in such a way that it will contain the right side of formula  2  and substitute it for it s left side   Like so  you should see it more clearly if you write it on a paper    fps i    i    f 0          f i-1            i     f 0          f i-2     f i-1             i  i-1       f 0          f i-2    i-1    f i-1   i-1             i  i-1      1 fps i-1    f i-1   i-1                          i fps i-1      f i-1    fps i-1    i - 1    So according to this formula  my math deriving skill are a bit rusty though   to calculate the new fps you need to know the fps from the previous frame  the duration it took to render the last frame and the number of frames you ve rendered

User · Answer

This is what I have used in many games    define MAXSAMPLES 100 int tickindex 0  int ticksum 0  int ticklist MAXSAMPLES       need to zero out the ticklist array before starting       average will ramp up until the buffer is full       returns average ticks per frame over the MAXSAMPLES last frames     double CalcAverageTick int newtick        ticksum- ticklist tickindex       subtract value falling off        ticksum  newtick                  add new value        ticklist tickindex  newtick       save new value so it can be subtracted later        if   tickindex  MAXSAMPLES        inc buffer index            tickindex 0          return average        return  double ticksum MAXSAMPLES

User · Answer

There are at least two ways to do it     The first is the one others have mentioned here before me  I think it s the simplest and preferred way  You just to keep track of    cn  counter of how many frames you ve rendered time start  the time since you ve started counting time now  the current time   Calculating the fps in this case is as simple as evaluating this formula    FPS   cn    time now - time start       Then there is the uber cool way you might like to use some day   Let s say you have  i  frames to consider  I ll use this notation  f 0   f 1       f i-1  to  describe how long it took to render frame 0  frame 1       frame  i-1  respectively   Example where i   3   f 0        f 1           f 2       ---------- ------------- ------- ------ gt  time   Then  mathematical definition of fps after i frames would be   1  fps i      i        f 0          f i-1     And the same formula but only considering i-1 frames    2  fps i-1     i-1     f 0          f i-2      Now the trick here is to modify the right side of formula  1  in such a way that it will contain the right side of formula  2  and substitute it for it s left side   Like so  you should see it more clearly if you write it on a paper    fps i    i    f 0          f i-1            i     f 0          f i-2     f i-1             i  i-1       f 0          f i-2    i-1    f i-1   i-1             i  i-1      1 fps i-1    f i-1   i-1                          i fps i-1      f i-1    fps i-1    i - 1    So according to this formula  my math deriving skill are a bit rusty though   to calculate the new fps you need to know the fps from the previous frame  the duration it took to render the last frame and the number of frames you ve rendered

User · Answer

Well  certainly   frames   sec   1    sec   frame    But  as you point out  there s a lot of variation in the time it takes to render a single frame  and from a UI perspective updating the fps value at the frame rate is not usable at all  unless the number is very stable    What you want is probably a moving average or some sort of binning   resetting counter   For example  you could maintain a queue data structure which held the rendering times for each of the last 30  60  100  or what-have-you frames  you could even design it so the limit was adjustable at run-time   To determine a decent fps approximation you can determine the average fps from all the rendering times in the queue   fps     of rendering times in queue   total rendering time   When you finish rendering a new frame you enqueue a new rendering time and dequeue an old rendering time  Alternately  you could dequeue only when the total of the rendering times exceeded some preset value  e g  1 sec   You can maintain the  last fps value  and a last updated timestamp so you can trigger when to update the fps figure  if you so desire  Though with a moving average if you have consistent formatting  printing the  instantaneous average  fps on each frame would probably be ok   Another method would be to have a resetting counter  Maintain a precise  millisecond  timestamp  a frame counter  and an fps value  When you finish rendering a frame  increment the counter  When the counter hits a pre-set limit  e g  100 frames  or when the time since the timestamp has passed some pre-set value  e g  1 sec   calculate the fps   fps     frames    current time - start time    Then reset the counter to 0 and set the timestamp to the current time

User · Answer

Good answers here  Just how you implement it is dependent on what you need it for   I prefer the running average one myself  time   time   0 9   last frame   0 1  by the guy above   however I personally like to weight my average more heavily towards newer data because in a game it is SPIKES that are the hardest to squash and thus of most interest to me  So I would use something more like a  7    3 split will make a spike show up much faster  though it s effect will drop off-screen faster as well   see below   If your focus is on RENDERING time  then the  9 1 split works pretty nicely b c it tend to be more smooth  THough for gameplay AI physics spikes are much more of a concern as THAT will usually what makes your game look choppy  which is often worse than a low frame rate assuming we re not dipping below 20 fps   So  what I would do is also add something like this     define ONE OVER FPS  1 0f 60 0f  static float g SpikeGuardBreakpoint   3 0f   ONE OVER FPS  if time  gt  g SpikeGuardBreakpoint      DoInternalBreakpoint      fill in 3 0f with whatever magnitude you find to be an unacceptable spike  This will let you find and thus solve FPS issues the end of the frame they happen

User · Answer

Set counter to zero  Each time you draw a frame increment the counter  After each second print the counter  lather  rinse  repeat  If yo want extra credit  keep a running counter and divide by the total number of seconds for a running average

User · Answer

store a start time and increment your framecounter once per loop  every few seconds you could just print framecount  Now - starttime  and then reinitialize them   edit  oops  double-ninja ed

User · Answer

This is what I have used in many games    define MAXSAMPLES 100 int tickindex 0  int ticksum 0  int ticklist MAXSAMPLES       need to zero out the ticklist array before starting       average will ramp up until the buffer is full       returns average ticks per frame over the MAXSAMPLES last frames     double CalcAverageTick int newtick        ticksum- ticklist tickindex       subtract value falling off        ticksum  newtick                  add new value        ticklist tickindex  newtick       save new value so it can be subtracted later        if   tickindex  MAXSAMPLES        inc buffer index            tickindex 0          return average        return  double ticksum MAXSAMPLES

User · Answer

This might be overkill for most people  that s why I hadn t posted it when I implemented it  But it s very robust and flexible   It stores a Queue with the last frame times  so it can accurately calculate an average FPS value much better than just taking the last frame into consideration   It also allows you to ignore one frame  if you are doing something that you know is going to artificially screw up that frame s time   It also allows you to change the number of frames to store in the Queue as it runs  so you can test it out on the fly what is the best value for you      Number of past frames to use for FPS smooth calculation - because     Unity s smoothedDeltaTime  well - it kinda sucks private int frameTimesSize   60     A Queue is the perfect data structure for the smoothed FPS task     new values in  old values out private Queue lt float gt  frameTimes     Not really needed  but used for faster updating then processing     the entire queue every frame private float   frameTimesSum   0     Flag to ignore the next frame when performing a heavy one-time operation      like changing resolution  private bool  fpsIgnoreNextFrame   false                                                                                      Call this after doing a heavy operation that will screw up with FPS calculation void FPSIgnoreNextFrame         this  fpsIgnoreNextFrame   true                                                                                        Smoothed FPS counter updating void Update         if  this  fpsIgnoreNextFrame            this  fpsIgnoreNextFrame   false          return                While looping here allows the frameTimesSize member to be changed dinamically     while  this frameTimes Count  gt   this frameTimesSize            this   frameTimesSum -  this frameTimes Dequeue              while  this frameTimes Count  lt  this frameTimesSize            this   frameTimesSum    Time deltaTime          this frameTimes Enqueue Time deltaTime                                                                                               Public function to get smoothed FPS values public int GetSmoothedFPS         return  int  this frameTimesSize   this   frameTimesSum   Time timeScale

User · Answer

In  c   like  pseudocode these two are what I used in industrial image processing applications that had to process images from a set of externally triggered camera s  Variations in  frame rate  had a different source  slower or faster production on the belt  but the problem is the same   I assume that you have a simple timer peek   call that gives you something like the nr of msec  nsec   since application start or the last call   Solution 1  fast but not updated every frame  do while  1        ProcessImage frame      if  frame framenumber poll interval  0                new time timer peek           framerate poll interval  new time - last time          last time new time           Solution 2  updated every frame  requires more memory and CPU  do while  1       ProcessImage frame     new time timer peek      delta new time - last time    last time   new time    total time    delta    delta history push delta     framerate  delta history length     total time    while  delta history length    gt  avg interval             oldest delta   delta history pop         total time -  oldest delta

User · Answer

store a start time and increment your framecounter once per loop  every few seconds you could just print framecount  Now - starttime  and then reinitialize them   edit  oops  double-ninja ed

User · Answer

How i do it   boolean run   false   int ticks   0   long tickstart   int fps   public void loop     if this ticks  0    this tickstart   System currentTimeMillis      this ticks    this fps    int this ticks    System currentTimeMillis  -this tickstart       In words  a tick clock tracks ticks  If it is the first time  it takes the current time and puts it in  tickstart   After the first tick  it makes the variable  fps  equal how many ticks of the tick clock divided by the time minus the time of the first tick   Fps is an integer  hence   int

User · Answer

Here s a complete example  using Python  but easily adapted to any language   It uses the smoothing equation in Martin s answer  so almost no memory overhead  and I chose values that worked for me  feel free to play around with the constants to adapt to your use case    import time  SMOOTHING FACTOR   0 99 MAX FPS   10000 avg fps   -1 last tick   time time    while True         lt Do your rendering work here    gt       current tick   time time         Ensure we don t get crazy large frame rates  by capping to MAX FPS     current fps   1 0   max current tick - last tick  1 0 MAX FPS      last tick   current tick     if avg fps  lt  0          avg fps   current fps     else          avg fps    avg fps   SMOOTHING FACTOR     current fps    1-SMOOTHING FACTOR       print avg fps

User · Answer

This is what I have used in many games    define MAXSAMPLES 100 int tickindex 0  int ticksum 0  int ticklist MAXSAMPLES       need to zero out the ticklist array before starting       average will ramp up until the buffer is full       returns average ticks per frame over the MAXSAMPLES last frames     double CalcAverageTick int newtick        ticksum- ticklist tickindex       subtract value falling off        ticksum  newtick                  add new value        ticklist tickindex  newtick       save new value so it can be subtracted later        if   tickindex  MAXSAMPLES        inc buffer index            tickindex 0          return average        return  double ticksum MAXSAMPLES

User · Answer

Here s how I do it  in Java    private static long ONE SECOND   1000000L   1000L    1 second is 1000ms which is 1000000ns  LinkedList lt Long gt  frames   new LinkedList lt  gt       List of frames within 1 second  public int calcFPS        long time   System nanoTime      Current time in nano seconds     frames add time     Add this frame to the list     while true           long f   frames getFirst      Look at the first element in frames         if time - f  gt  ONE SECOND     If it was more than 1 second ago             frames remove      Remove it from the list of frames           else break            If it was within 1 second we know that all other frames in the list            are also within 1 second                      return frames size      Return the size of the list

User · Answer

You need a smoothed average  the easiest way is to take the current answer  the time to draw the last frame  and combine it with the previous answer      eg  float smoothing   0 9     larger more smoothing measurement    measurement   smoothing     current    1 0-smoothing     By adjusting the 0 9   0 1 ratio you can change the  time constant  - that is how quickly the number responds to changes  A larger fraction in favour of the old answer gives a slower smoother change  a large fraction in favour of the new answer gives a quicker changing value    Obviously the two factors must add to one

User · Answer

Here s how I do it  in Java    private static long ONE SECOND   1000000L   1000L    1 second is 1000ms which is 1000000ns  LinkedList lt Long gt  frames   new LinkedList lt  gt       List of frames within 1 second  public int calcFPS        long time   System nanoTime      Current time in nano seconds     frames add time     Add this frame to the list     while true           long f   frames getFirst      Look at the first element in frames         if time - f  gt  ONE SECOND     If it was more than 1 second ago             frames remove      Remove it from the list of frames           else break            If it was within 1 second we know that all other frames in the list            are also within 1 second                      return frames size      Return the size of the list

[algorithm] Calculating frames per second in a game

Examples related to algorithm