Add caching to sampleTerrain

Source/Core/DoublyLinkedList.js

@@ -1,6 +1,6 @@
 define([
-        '../Core/defined',
-        '../Core/defineProperties'
+        './defined',
+        './defineProperties'
     ], function(
         defined,
         defineProperties) {
@@ -29,14 +29,18 @@ define([
         this.next = next;
     }
 
+    /**
+     * Adds the item to the end of the list
+     * @param {Object} [item]
+     * @return {DoublyLinkedListNode}
+     */
     DoublyLinkedList.prototype.add = function(item) {
         var node = new DoublyLinkedListNode(item, this.tail, undefined);
 
         if (defined(this.tail)) {
             this.tail.next = node;
             this.tail = node;
         } else {
-            // Insert into empty linked list
             this.head = node;
             this.tail = node;
         }
@@ -46,6 +50,43 @@ define([
         return node;
     };
 
+    /**
+     * Adds the item to the front of the list
+     * @param {Object} [item]
+     * @return {DoublyLinkedListNode}
+     */
+    DoublyLinkedList.prototype.addFront = function(item) {
+        var node = new DoublyLinkedListNode(item, undefined, this.head);
+
+        if (defined(this.head)) {
+            this.head.previous = node;
+            this.head = node;
+        } else {
+            this.head = node;
+            this.tail = node;
+        }
+
+        ++this._length;
+
+        return node;
+    };
+
+    /**
+     * Moves the given node to the front of the list
+     * @param {DoublyLinkedListNode} node
+     */
+    DoublyLinkedList.prototype.moveToFront = function(node) {
+        if (!defined(node) || this.head === node) {
+            return;
+        }
+
+        remove(this, node);
+        node.next = this.head;
+        node.previous = undefined;
+        this.head.previous = node;
+        this.head = node;
+    };
+
     function remove(list, node) {
         if (defined(node.previous) && defined(node.next)) {
             node.previous.next = node.next;
@@ -68,6 +109,10 @@ define([
         node.previous = undefined;
     }
 
+    /**
+     * Removes the given node from the list
+     * @param {DoublyLinkedListNode} node
+     */
     DoublyLinkedList.prototype.remove = function(node) {
         if (!defined(node)) {
             return;
@@ -78,6 +123,43 @@ define([
         --this._length;
     };
 
+    /**
+     * Removes all nodes after the start index (inclusive)
+     * @param {Number} startIndex The index of the first node to remove
+     */
+    DoublyLinkedList.prototype.removeAfter = function(startIndex) {
+        var currentLength = this._length;
+        if (!defined(startIndex) || startIndex >= currentLength) {
+            return;
+        }
+
+        if (startIndex === 0) {
+            this.head = undefined;
+            this.tail = undefined;
+            this._length = 0;
+            return;
+        }
+
+        if (startIndex === currentLength - 1) {
+            this.remove(this.tail);
+            return;
+        }
+
+        var node = this.head;
+        for (var i = 0; i < startIndex; ++i) {
+            node = node.next;
+        }
+
+        node.previous.next = undefined;
+        this.tail = node.previous;
+        this._length = startIndex;
+    };
+
+    /**
+     * Moves nextNode after node
+     * @param {DoublyLinkedListNode} node
+     * @param {DoublyLinkedListNode} nextNode
+     */
     DoublyLinkedList.prototype.splice = function(node, nextNode) {
         if (node === nextNode) {
             return;

Source/Core/LRUCache.js

@@ -0,0 +1,174 @@
+define([
+        './defined',
+        './defineProperties',
+        './getTimestamp',
+        './DeveloperError',
+        './DoublyLinkedList'
+    ], function(
+        defined,
+        defineProperties,
+        getTimestamp,
+        DeveloperError,
+        DoublyLinkedList) {
+    'use strict';
+
+    /**
+     * A cache for storing key-value pairs
+     * @param {Number} [capacity] The capacity of the cache.  If undefined, the size will be unlimited.
+     * @param {Number} [expiration] The number of milliseconds before an item in the cache expires and will be discarded when LRUCache.prune is called.  If undefined, items do not expire.
+     * @alias LRUCache
+     * @constructor
+     * @private
+     */
+    function LRUCache(capacity, expiration) {
+        this._list = new DoublyLinkedList();
+        this._hash = {};
+        this._hasCapacity = defined(capacity);
+        this._capacity = capacity;
+
+        this._hasExpiration = defined(expiration);
+        this._expiration = expiration;
+        this._interval = undefined;
+    }
+
+    defineProperties(LRUCache.prototype, {
+        /**
+         * Gets the cache length
+         * @memberof LRUCache.prototype
+         * @type {Number}
+         * @readonly
+         */
+        length : {
+            get : function() {
+                return this._list.length;
+            }
+        }
+    });
+
+    /**
+     * Retrieves the value associated with the provided key.
+     *
+     * @param {String|Number} key The key whose value is to be retrieved.
+     * @returns {Object} The associated value, or undefined if the key does not exist in the collection.
+     */
+    LRUCache.prototype.get = function(key) {
+        //>>includeStart('debug', pragmas.debug);
+        if (typeof key !== 'string' && typeof key !== 'number') {
+            throw new DeveloperError('key is required to be a string or number.');
+        }
+        //>>includeEnd('debug');
+        var list = this._list;
+        var node = this._hash[key];
+        if (defined(node)) {
+            list.moveToFront(node);
+            var item = node.item;
+            item.touch();
+            return item.value;
+        }
+    };
+
+    /**
+     * Associates the provided key with the provided value.  If the key already
+     * exists, it is overwritten with the new value.
+     *
+     * @param {String|Number} key A unique identifier.
+     * @param {Object} value The value to associate with the provided key.
+     */
+    LRUCache.prototype.set = function(key, value) {
+        //>>includeStart('debug', pragmas.debug);
+        if (typeof key !== 'string' && typeof key !== 'number') {
+            throw new DeveloperError('key is required to be a string or number.');
+        }
+        //>>includeEnd('debug');
+        var hash = this._hash;
+        var list = this._list;
+
+        var node = hash[key];
+        var item;
+        if (!defined(node)) {
+            item = new Item(key, value);
+            node = list.addFront(item);
+            hash[key] = node;
+            if (this._hasExpiration) {
+                LRUCache._checkExpiration(this);
+            }
+            if (this._hasCapacity && list.length > this._capacity) {
+                var tail = list.tail;
+                delete this._hash[tail.item.key];
+                list.remove(tail);
+            }
+        } else {
+            item = node.item;
+            item.value = value;
+            item.touch();
+            list.moveToFront(node);
+        }
+    };
+
+    function prune(cache) {
+        var currentTime = getTimestamp();
+        var pruneAfter = currentTime - cache._expiration;
+
+        var list = cache._list;
+        var node = list.tail;
+        var index = list.length;
+        while (defined(node) && node.item.timestamp < pruneAfter) {
+            node = node.previous;
+            index--;
+        }
+
+        if (node === list.tail) {
+            return;
+        }
+
+        if (!defined(node)) {
+            node = list.head;
+        } else {
+            node = node.next;
+        }
+
+        while (defined(node)) {
+            delete cache._hash[node.item.key];
+            node = node.next;
+        }
+
+        list.removeAfter(index);
+    }
+
+    function checkExpiration(cache) {
+        if (defined(cache._interval)) {
+            return;
+        }
+        function loop() {
+            if (!cache._hasExpiration || cache.length === 0) {
+                clearInterval(cache._interval);
+                cache._interval = undefined;
+                return;
+            }
+
+            prune(cache);
+
+            if (cache.length === 0) {
+                clearInterval(cache._interval);
+                cache._interval = undefined;
+            }
+        }
+        cache._interval = setInterval(loop, 1000);
+    }
+
+    function Item(key, value) {
+        this.key = key;
+        this.value = value;
+        this.timestamp = getTimestamp();
+    }
+
+    Item.prototype.touch = function() {
+        this.timestamp = getTimestamp();
+    };
+
+    //exposed for testing
+    LRUCache._checkExpiration = checkExpiration;
+    LRUCache._prune = prune;
+
+    return LRUCache;
+});

Source/Core/sampleTerrain.js

@@ -1,11 +1,17 @@
 define([
         '../ThirdParty/when',
-        './Check'
+        './defined',
+        './Check',
+        './LRUCache'
     ], function(
         when,
-        Check) {
+        defined,
+        Check,
+        LRUCache) {
     'use strict';
 
+    var cache = new LRUCache(256, 10000);
+
     /**
      * Initiates a terrain height query for an array of {@link Cartographic} positions by
      * requesting tiles from a terrain provider, sampling, and interpolating.  The interpolation
@@ -86,8 +92,18 @@ define([
         var tilePromises = [];
         for (i = 0; i < tileRequests.length; ++i) {
             var tileRequest = tileRequests[i];
-            var requestPromise = tileRequest.terrainProvider.requestTileGeometry(tileRequest.x, tileRequest.y, tileRequest.level);
-            var tilePromise = when(requestPromise, createInterpolateFunction(tileRequest), createMarkFailedFunction(tileRequest));
+            var cacheKey = tileRequest.x + '-' + tileRequest.y + '-' + tileRequest.level;
+            var requestPromise;
+            var cachedTilePromise = cache.get(cacheKey);
+            if (defined(cachedTilePromise)) {
+                requestPromise = cachedTilePromise;
+            } else {
+                requestPromise = tileRequest.terrainProvider.requestTileGeometry(tileRequest.x, tileRequest.y, tileRequest.level);
+                cache.set(cacheKey, requestPromise);
+            }
+            var tilePromise = requestPromise
+                .then(createInterpolateFunction(tileRequest))
+                .otherwise(createMarkFailedFunction(tileRequest));
             tilePromises.push(tilePromise);
         }