Internally the Time class has been updated to split out the RAF and SetTimeout implementations. This cuts down the update loop workload significantly, which was causing a performance optimization bottleneck in V8.

Author: photonstorm

README.md

@@ -253,6 +253,7 @@ Version 2.4 - "Katar" - in dev
 * Phaser.DeviceButton.ctrlKey is a boolean that holds if the control key was held down or not during the last button event.
 * Phaser.GamepadButton has been removed and now uses DeviceButton instead. Three internal API changes took place: `processButtonDown` is renamed to `start`, `processButtonUp` is renamed to `stop` and `processButtonFloat` is renamed to `padFloat`. If you extended GamepadButton in your own code you need to replace it with DeviceButton.
 * MSPointer now checks the `pointerType` property of the DOM event and if it matches 'mouse' it will update `Input.mousePointer`, rather than `Input.pointer1` (or whatever the next free Pointer was).
+* Time.suggestedFps is now only populated if `Time.advancedTiming` is enabled.
 
 ### p2.js Upgraded to version 0.7.0
 
@@ -405,6 +406,7 @@ For the full list of p2 additions please read [their change log](https://github.
 * LoaderParser.bitmapFont, xmlBitmapFont and jsonBitmapFont all now return the font data rather than write it to the now deprecated PIXI.BitmapText.fonts global array.
 * PIXI.BitmapText has been removed as a global array, as it is no longer used.
 * PIXI has been made available for Phaser when using requireJS (thanks @mkristo #1923)
+* Internally the Time class has been updated to split out the RAF and SetTimeout implementations. This cuts down the update loop workload significantly, which was causing a performance optimization bottleneck in V8.
 
 ### Bug Fixes
 

src/time/Time.js

@@ -111,6 +111,7 @@ Phaser.Time = function (game) {
 
     /**
     * The suggested frame rate for your game, based on an averaged real frame rate.
+    * This value is only populated if `Time.advancedTiming` is enabled.
     *
     * _Note:_ This is not available until after a few frames have passed; use it after a few seconds (eg. after the menus)
     *
@@ -129,7 +130,7 @@ Phaser.Time = function (game) {
     this.slowMotion = 1.0;
 
     /**
-    * If true then advanced profiling, including the fps rate, fps min/max and msMin/msMax are updated.
+    * If true then advanced profiling, including the fps rate, fps min/max, suggestedFps and msMin/msMax are updated.
     * @property {boolean} advancedTiming
     * @default
     */
@@ -336,11 +337,49 @@ Phaser.Time.prototype = {
     */
     update: function (time) {
 
+        if (this.game.raf._isSetTimeOut)
+        {
+            this.updateSetTimeout(time);
+        }
+        else
+        {
+            this.updateRAF(time);
+        }
+
+        if (this.advancedTiming)
+        {
+            this.updateAdvancedTiming();
+        }
+
+        //  Paused but still running?
+        if (!this.game.paused)
+        {
+            //  Our internal Phaser.Timer
+            this.events.update(this.time);
+
+            if (this._timers.length)
+            {
+                this.updateTimers();
+            }
+        }
+
+    },
+
+    /**
+    * setTimeOut specific time update handler.
+    * Called automatically by Time.update.
+    *
+    * @method Phaser.Time#updateSetTimeout
+    * @private
+    * @param {number} time - The current relative timestamp; see {@link Phaser.Time#now now}.
+    */
+    updateSetTimeout: function (time) {
+
         //  Set to the old Date.now value
         var previousDateNow = this.time;
 
-        // this.time always holds Date.now, this.now may hold the RAF high resolution time value if RAF is available (otherwise it also holds Date.now)
-        this.time = Date.now();
+        //  With SetTimeout the time value is always the same as Date.now, so no need to get it again
+        this.time = time;
 
         //  Adjust accordingly.
         this.elapsedMS = this.time - previousDateNow;
@@ -360,64 +399,111 @@ Phaser.Time.prototype = {
         // time when the next call is expected if using timers
         this.timeCallExpected = time + this.timeToCall;
 
-        // count the number of time.update calls
-        this._frameCount++;
-        this._elapsedAccumulator += this.elapsed;
+        //  Set the physics elapsed time... this will always be 1 / this.desiredFps because we're using fixed time steps in game.update now
+        this.physicsElapsed = 1 / this.desiredFps;
 
-        // occasionally recalculate the suggestedFps based on the accumulated elapsed time
-        if (this._frameCount >= this.desiredFps * 2)
-        {
-            // this formula calculates suggestedFps in multiples of 5 fps
-            this.suggestedFps = Math.floor(200 / (this._elapsedAccumulator / this._frameCount)) * 5;
-            this._frameCount = 0;
-            this._elapsedAccumulator = 0;
-        }
+        this.physicsElapsedMS = this.physicsElapsed * 1000;
+
+    },
+
+    /**
+    * raf specific time update handler.
+    * Called automatically by Time.update.
+    *
+    * @method Phaser.Time#updateRAF
+    * @private
+    * @param {number} time - The current relative timestamp; see {@link Phaser.Time#now now}.
+    */
+    updateRAF: function (time) {
+
+        //  Set to the old Date.now value
+        var previousDateNow = this.time;
+
+        // this.time always holds Date.now, this.now may hold the RAF high resolution time value if RAF is available (otherwise it also holds Date.now)
+        this.time = Date.now();
+
+        //  Adjust accordingly.
+        this.elapsedMS = this.time - previousDateNow;
+
+        // 'now' is currently still holding the time of the last call, move it into prevTime
+        this.prevTime = this.now;
+
+        // update 'now' to hold the current time
+        this.now = time;
+
+        // elapsed time between previous call and now
+        this.elapsed = this.now - this.prevTime;
 
         //  Set the physics elapsed time... this will always be 1 / this.desiredFps because we're using fixed time steps in game.update now
         this.physicsElapsed = 1 / this.desiredFps;
 
         this.physicsElapsedMS = this.physicsElapsed * 1000;
 
-        if (this.advancedTiming)
-        {
-            this.msMin = Math.min(this.msMin, this.elapsed);
-            this.msMax = Math.max(this.msMax, this.elapsed);
+    },
 
-            this.frames++;
+    /**
+    * Handles the updating of the Phaser.Timers (if any)
+    * Called automatically by Time.update.
+    *
+    * @method Phaser.Time#updateTimers
+    * @private
+    */
+    updateTimers: function () {
+
+        //  Any game level timers
+        var i = 0;
+        var len = this._timers.length;
 
-            if (this.now > this._timeLastSecond + 1000)
+        while (i < len)
+        {
+            if (this._timers[i].update(this.time))
+            {
+                i++;
+            }
+            else
             {
-                this.fps = Math.round((this.frames * 1000) / (this.now - this._timeLastSecond));
-                this.fpsMin = Math.min(this.fpsMin, this.fps);
-                this.fpsMax = Math.max(this.fpsMax, this.fps);
-                this._timeLastSecond = this.now;
-                this.frames = 0;
+                //  Timer requests to be removed
+                this._timers.splice(i, 1);
+                len--;
             }
         }
 
-        //  Paused but still running?
-        if (!this.game.paused)
+    },
+
+    /**
+    * Handles the updating of the advanced timing values (if enabled)
+    * Called automatically by Time.update.
+    *
+    * @method Phaser.Time#updateAdvancedTiming
+    * @private
+    */
+    updateAdvancedTiming: function () {
+
+        // count the number of time.update calls
+        this._frameCount++;
+        this._elapsedAccumulator += this.elapsed;
+
+        // occasionally recalculate the suggestedFps based on the accumulated elapsed time
+        if (this._frameCount >= this.desiredFps * 2)
         {
-            //  Our internal Phaser.Timer
-            this.events.update(this.time);
+            // this formula calculates suggestedFps in multiples of 5 fps
+            this.suggestedFps = Math.floor(200 / (this._elapsedAccumulator / this._frameCount)) * 5;
+            this._frameCount = 0;
+            this._elapsedAccumulator = 0;
+        }
 
-            //  Any game level timers
-            var i = 0;
-            var len = this._timers.length;
+        this.msMin = Math.min(this.msMin, this.elapsed);
+        this.msMax = Math.max(this.msMax, this.elapsed);
 
-            while (i < len)
-            {
-                if (this._timers[i].update(this.time))
-                {
-                    i++;
-                }
-                else
-                {
-                    //  Timer requests to be removed
-                    this._timers.splice(i, 1);
-                    len--;
-                }
-            }
+        this.frames++;
+
+        if (this.now > this._timeLastSecond + 1000)
+        {
+            this.fps = Math.round((this.frames * 1000) / (this.now - this._timeLastSecond));
+            this.fpsMin = Math.min(this.fpsMin, this.fps);
+            this.fpsMax = Math.max(this.fpsMax, this.fps);
+            this._timeLastSecond = this.now;
+            this.frames = 0;
         }
 
     },