Add caching to namespace lookup to drastically improve speed during resolveAll (30x in benchmarks)

Author: mkruskal-google

src/namespace.js

@@ -108,10 +108,27 @@ function Namespace(name, options) {
      * @private
      */
     this._nestedArray = null;
+
+    /**
+     * Cache lookup calls for any objects contains anywhere under this namespace.
+     * This drastically speeds up resolve for large cross-linked protos where the same
+     * types are looked up repeatedly.
+     * @type {Object.<string,ReflectionObject|null>}
+     * @private
+     */
+    this._lookupCache = {};
 }
 
 function clearCache(namespace) {
     namespace._nestedArray = null;
+    namespace._lookupCache = {};
+
+    // Also clear parent caches, since they include nested lookups.
+    var parent = namespace.parent;
+    while(parent) {
+        parent._lookupCache = {};
+        parent = parent.parent;
+    }
     return namespace;
 }
 
@@ -341,7 +358,6 @@ Namespace.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursi
  * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
  */
 Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChecked) {
-
     /* istanbul ignore next */
     if (typeof filterTypes === "boolean") {
         parentAlreadyChecked = filterTypes;
@@ -360,25 +376,48 @@ Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChe
     if (path[0] === "")
         return this.root.lookup(path.slice(1), filterTypes);
 
-    // Test if the first part matches any nested object, and if so, traverse if path contains more
-    var found = this.get(path[0]);
-    if (found) {
-        if (path.length === 1) {
-            if (!filterTypes || filterTypes.indexOf(found.constructor) > -1)
-                return found;
-        } else if (found instanceof Namespace && (found = found.lookup(path.slice(1), filterTypes, true)))
-            return found;
-
-    // Otherwise try each nested namespace
-    } else
-        for (var i = 0; i < this.nestedArray.length; ++i)
-            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i].lookup(path, filterTypes, true)))
-                return found;
+    var found = this._lookupImpl(path);
+    if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
+        return found;
+    }
 
     // If there hasn't been a match, try again at the parent
     if (this.parent === null || parentAlreadyChecked)
         return null;
     return this.parent.lookup(path, filterTypes);
+}
+
+/**
+ * Internal helper for lookup that handles searching just at this namespace and below along with caching.
+ * @param {string[]} path Path to look up
+ * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
+ * @private
+ */
+Namespace.prototype._lookupImpl = function lookup(path) {
+    var flatPath = path.join(".");
+    if(this._lookupCache.hasOwnProperty(flatPath)) {
+        return this._lookupCache[flatPath];
+    } else {
+        // Test if the first part matches any nested object, and if so, traverse if path contains more
+        var found = this.get(path[0]);
+        var exact = null;
+        if (found) {
+            if (path.length === 1) {
+                exact = found;
+            } else if (found instanceof Namespace && (found = found._lookupImpl(path.slice(1))))
+                exact = found;
+
+        // Otherwise try each nested namespace
+        } else {
+            for (var i = 0; i < this.nestedArray.length; ++i)
+                if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path)))
+                    exact = found;
+        }
+
+        // Set this even when null, so that when we walk up the tree we can quickly bail on repeated checks back down.
+        this._lookupCache[flatPath] = exact;
+        return exact;
+    }
 };
 
 /**