Change request queue from a heap to a sorted array

Author: lilleyse

Source/Core/RequestQueue.js

@@ -0,0 +1,186 @@
+define([
+        './Check',
+        './defineProperties'
+    ], function(
+        Check,
+        defineProperties) {
+    'use strict';
+
+    /**
+     * Priority queue for the {@link RequestScheduler} implemented as a sorted array.
+     * The request with the highest priority is placed at index 0 and the request
+     * with lowest priority is placed at index <code>length - 1</code>.
+     * <p>
+     * A lower <code>request.priority</code> value indicates that the request has higher priority. See {@link Request#priority}.
+     * </p>
+     *
+     * @alias RequestQueue
+     * @constructor
+     * @private
+     *
+     * @param {Number} maximumLength The maximum length of the queue.
+     */
+    function RequestQueue(maximumLength) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.number('maximumLength', maximumLength);
+        //>>includeEnd('debug');
+
+        this._array = new Array(maximumLength);
+        this._length = 0;
+        this._maximumLength = maximumLength;
+    }
+
+    defineProperties(RequestQueue.prototype, {
+        /**
+         * Gets the length of the queue.
+         *
+         * @memberof RequestQueue.prototype
+         *
+         * @type {Number}
+         * @readonly
+         */
+        length : {
+            get : function() {
+                return this._length;
+            }
+        }
+    });
+
+    /**
+     * Get the request at the given index.
+     *
+     * @param {Number} index The index of the request.
+     *
+     * @return {Request} The request at the given index.
+     */
+    RequestQueue.prototype.get = function(index) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.number.greaterThanOrEquals('index', index, 0);
+        Check.typeOf.number.lessThan('index', index, this._length);
+        //>>includeEnd('debug');
+        return this._array[index];
+    };
+
+    /**
+     * Insert a request into the queue. If the length would grow greater than the maximum length
+     * of the queue, the lowest priority request is removed and returned.
+     *
+     * @param {Request} request The request to insert.
+     *
+     * @return {Request|undefined} The request that was removed from the queue if the queue is at full capacity.
+     */
+    RequestQueue.prototype.insert = function(request) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.defined('request', request);
+        //>>includeEnd('debug');
+
+        var array = this._array;
+        var previousLength = this._length;
+        var length = this._length;
+        var maximumLength = this._maximumLength;
+
+        if (length < maximumLength)
+        {
+            ++this._length;
+        }
+
+        if (previousLength === 0)
+        {
+            array[0] = request;
+            return;
+        }
+
+        var removedRequest;
+        var lastIndex = previousLength - 1;
+
+        if (previousLength === maximumLength) {
+            var lastRequest = array[lastIndex];
+            if (request.priority >= lastRequest.priority) {
+                // The array is full and the priority value of this request is too high to be inserted.
+                return request;
+            }
+            // The array is full and the inserted request pushes off the last request
+            removedRequest = lastRequest;
+            --lastIndex;
+        }
+
+        while (lastIndex >= 0 && request.priority < array[lastIndex].priority) {
+            array[lastIndex + 1] = array[lastIndex]; // Shift element to the right
+            --lastIndex;
+        }
+        array[lastIndex + 1] = request;
+
+        return removedRequest;
+    };
+
+    /**
+     * Call the given function for each request in the queue.
+     *
+     * @type {RequestQueue~ForEachCallback} The function to call.
+     */
+    RequestQueue.prototype.forEach = function(callback) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.func('callback', callback);
+        //>>includeEnd('debug');
+
+        var array = this._array;
+        var length = this._length;
+        for (var i = 0; i < length; ++i) {
+            callback(array[i]);
+        }
+    };
+
+    /**
+     * Sorts the queue.
+     */
+    RequestQueue.prototype.sort = function() {
+        var array = this._array;
+        var length = this._length;
+
+        // Use insertion sort since our array is small and likely to be mostly sorted already.
+        // Additionally length may be smaller than the array's actual length, so calling array.sort will lead to incorrect results for uninitialized values.
+        for (var i = 1; i < length; ++i) {
+            var j = i;
+            while ((j > 0) && (array[j - 1].priority > array[j].priority)) {
+                var temp = array[j - 1];
+                array[j - 1] = array[j];
+                array[j] = temp;
+                --j;
+            }
+        }
+    };
+
+    /**
+     * Remove <code>length</code> number of requests from the top of the queue.
+     *
+     * @param {Number} length The number of requests to remove.
+     */
+    RequestQueue.prototype.remove = function(length) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.number.greaterThanOrEquals('length', length, 0);
+        Check.typeOf.number.lessThanOrEquals('length', length, this._length);
+        //>>includeEnd('debug');
+        if (length === 0) {
+            return;
+        }
+        if (length === this._length) {
+            this._length = 0;
+            return;
+        }
+
+        // Shift remaining requests back to the left
+        var array = this._array;
+        for (var i = length; i < this._length; ++i) {
+            array[i - length] = array[i];
+        }
+        this._length -= length;
+    };
+
+    /**
+     * The callback to use in forEach.
+     * @callback RequestQueue~ForEachCallback
+     * @param {Request} request The request.
+     */
+
+    return RequestQueue;
+});

Source/Core/RequestScheduler.js

@@ -5,9 +5,9 @@ define([
         './defined',
         './defineProperties',
         './Event',
-        './Heap',
         './isBlobUri',
         './isDataUri',
+        './RequestQueue',
         './RequestState'
     ], function(
         Uri,
@@ -16,16 +16,12 @@ define([
         defined,
         defineProperties,
         Event,
-        Heap,
         isBlobUri,
         isDataUri,
+        RequestQueue,
         RequestState) {
     'use strict';
 
-    function sortRequests(a, b) {
-        return a.priority - b.priority;
-    }
-
     var statistics = {
         numberOfAttemptedRequests : 0,
         numberOfActiveRequests : 0,
@@ -35,12 +31,8 @@ define([
         numberOfActiveRequestsEver : 0
     };
 
-    var priorityHeapLength = 20;
-    var requestHeap = new Heap({
-        comparator : sortRequests
-    });
-    requestHeap.maximumLength = priorityHeapLength;
-    requestHeap.reserve(priorityHeapLength);
+    var requestQueueLength = 20;
+    var requestQueue = new RequestQueue(requestQueueLength);
 
     var activeRequests = [];
     var numberOfActiveRequestsByServer = {};
@@ -112,29 +104,28 @@ define([
         },
 
         /**
-         * The maximum size of the priority heap. This limits the number of requests that are sorted by priority. Only applies to requests that are not yet active.
+         * The maximum length of the priority queue. This limits the number of requests that are sorted by priority. Only applies to requests that are not yet active.
          *
          * @memberof RequestScheduler
          *
          * @type {Number}
          * @default 20
+         *
+         * @private
          */
-        priorityHeapLength : {
+        requestQueueLength : {
             get : function() {
-                return priorityHeapLength;
+                return requestQueueLength;
             },
             set : function(value) {
-                // If the new length shrinks the heap, need to cancel some of the requests.
-                // Since this value is not intended to be tweaked regularly it is fine to just cancel the high priority requests.
-                if (value < priorityHeapLength) {
-                    while (requestHeap.length > value) {
-                        var request = requestHeap.pop();
-                        cancelRequest(request);
-                    }
+                // Cancel all requests and resize the queue
+                var length = requestQueue.length;
+                for (var i = 0; i < length; ++i) {
+                    var request = requestQueue.get(i);
+                    cancelRequest(request);
                 }
-                priorityHeapLength = value;
-                requestHeap.maximumLength = value;
-                requestHeap.reserve(value);
+                requestQueue = new RequestQueue(value);
+                RequestScheduler.requestQueue = requestQueue;
             }
         }
     });
@@ -242,21 +233,19 @@ define([
         }
         activeRequests.length -= removeCount;
 
-        // Update priority of issued requests and resort the heap
-        var issuedRequests = requestHeap.internalArray;
-        var issuedLength = requestHeap.length;
-        for (i = 0; i < issuedLength; ++i) {
-            updatePriority(issuedRequests[i]);
-        }
-        requestHeap.resort();
+        // Update priority of issued requests and resort the queue
+        requestQueue.forEach(updatePriority);
+        requestQueue.sort();
 
         // Get the number of open slots and fill with the highest priority requests.
         // Un-throttled requests are automatically added to activeRequests, so activeRequests.length may exceed maximumRequests
         var openSlots = Math.max(RequestScheduler.maximumRequests - activeRequests.length, 0);
         var filledSlots = 0;
-        while (filledSlots < openSlots && requestHeap.length > 0) {
-            // Loop until all open slots are filled or the heap becomes empty
-            request = requestHeap.pop();
+        var processedRequests = 0;
+        var totalRequests = requestQueue.length;
+        while (filledSlots < openSlots && processedRequests < totalRequests) {
+            // Loop until all open slots are filled or the queue becomes empty
+            request = requestQueue.get(processedRequests++);
             if (request.cancelled) {
                 // Request was explicitly cancelled
                 cancelRequest(request);
@@ -272,6 +261,7 @@ define([
             startRequest(request);
             ++filledSlots;
         }
+        requestQueue.remove(processedRequests);
 
         updateStatistics();
     };
@@ -344,10 +334,9 @@ define([
             return undefined;
         }
 
-        // Insert into the priority heap and see if a request was bumped off. If this request is the lowest
-        // priority it will be returned.
+        // Insert into the priority queue and see if a request was bumped off. If this request is the lowest priority it will be returned.
         updatePriority(request);
-        var removedRequest = requestHeap.insert(request);
+        var removedRequest = requestQueue.insert(request);
 
         if (defined(removedRequest)) {
             if (removedRequest === request) {
@@ -397,12 +386,19 @@ define([
      * @private
      */
     RequestScheduler.clearForSpecs = function() {
-        while (requestHeap.length > 0) {
-            var request = requestHeap.pop();
+        var request;
+        var length;
+        var i;
+
+        length = requestQueue.length;
+        for (i = 0; i < length; ++i) {
+            request = requestQueue.get(i);
             cancelRequest(request);
         }
-        var length = activeRequests.length;
-        for (var i = 0; i < length; ++i) {
+        requestQueue.remove(length);
+
+        length = activeRequests.length;
+        for (i = 0; i < length; ++i) {
             cancelRequest(activeRequests[i]);
         }
         activeRequests.length = 0;
@@ -431,7 +427,7 @@ define([
      *
      * @private
      */
-    RequestScheduler.requestHeap = requestHeap;
+    RequestScheduler.requestQueue = requestQueue;
 
     return RequestScheduler;
 });