Speed up index() using a cache

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -463,15 +463,17 @@ class SymbolTree {
         /**
          * Find the index of the given object (the number of preceding siblings).
          *
-         * `O(n)`
+         * `O(n)`<br>
+         * `O(1)` (cached)
          *
          * @method index
          * @memberOf module:symbol-tree#
          * @param {Object} child
          * @return {Number} The number of preceding siblings, or -1 if the object has no parent
          */
         index(child) {
-                const parentNode = this._node(this._node(child).parent);
+                const childNode = this._node(child);
+                const parentNode = this._node(childNode.parent);
 
                 if (!parentNode) {
                         // In principal, you could also find out the number of preceding siblings
@@ -480,15 +482,25 @@ class SymbolTree {
                         return -1;
                 }
 
-                let index = 0;
+                let index = childNode.getCachedIndex(parentNode);
+
+                if (index >= 0) {
+                        return index;
+                }
+
+                index = 0;
                 let object = parentNode.first;
 
                 while (object) {
+                        const node = this._node(object);
+                        node.setCachedIndex(parentNode, index);
+
                         if (object === child) {
                                 break;
                         }
+
                         ++index;
-                        object = this._node(object).next;
+                        object = node.next;
                 }
 
                 return index;
@@ -533,6 +545,10 @@ class SymbolTree {
                 removeNode.prev = null;
                 removeNode.next = null;
 
+                if (parentNode) {
+                        parentNode.childrenChanged();
+                }
+
                 return removeObject;
         }
 
@@ -572,6 +588,10 @@ class SymbolTree {
                         parentNode.first = newObject;
                 }
 
+                if (parentNode) {
+                        parentNode.childrenChanged();
+                }
+
                 return newObject;
         }
 
@@ -611,6 +631,10 @@ class SymbolTree {
                         parentNode.last = newObject;
                 }
 
+                if (parentNode) {
+                        parentNode.childrenChanged();
+                }
+
                 return newObject;
         }
 
@@ -639,6 +663,7 @@ class SymbolTree {
                         newNode.parent = referenceObject;
                         referenceNode.first = newObject;
                         referenceNode.last = newObject;
+                        referenceNode.childrenChanged();
                 }
                 else {
                         this.insertBefore(newObject, referenceNode.first);
@@ -672,6 +697,7 @@ class SymbolTree {
                         newNode.parent = referenceObject;
                         referenceNode.first = newObject;
                         referenceNode.last = newObject;
+                        referenceNode.childrenChanged();
                 }
                 else {
                         this.insertAfter(newObject, referenceNode.last);

lib/SymbolTreeNode.js

@@ -8,6 +8,14 @@ module.exports = class SymbolTreeNode {
 
                 this.first = null;
                 this.last = null;
+
+                /** This value is incremented anytime a children is added or removed */
+                this.childrenVersion = 0;
+
+                /** This value represents the cached node index, as long as
+                 * cachedIndexVersion matches with the childrenVersion of the parent */
+                this.cachedIndex = -1;
+                this.cachedIndexVersion = NaN; // NaN is never equal to anything
         }
 
         get isAttached() {
@@ -17,4 +25,27 @@ module.exports = class SymbolTreeNode {
         get isEmpty() {
                 return !this.first;
         }
+
+        childrenChanged() {
+                /* jshint -W016 */
+                // integer wrap around
+                this.childrenVersion = (this.childrenVersion + 1) & 0xFFFFFFFF;
+        }
+
+        getCachedIndex(parentNode) {
+                // (assumes parentNode is actually the parent)
+                if (this.cachedIndexVersion !== parentNode.childrenVersion) {
+                        this.cachedIndexVersion = NaN;
+                        // cachedIndex is no longer valid
+                        return -1;
+                }
+
+                return this.cachedIndex; // -1 if not cached
+        }
+
+        setCachedIndex(parentNode, index) {
+                // (assumes parentNode is actually the parent)
+                this.cachedIndexVersion = parentNode.childrenVersion;
+                this.cachedIndex = index;
+        }
 };

test/SymbolTree.js

@@ -918,3 +918,45 @@ test('look up the index of an object', function(t) {
 
         t.end();
 });
+
+test('cached index', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const ac = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(ac, a);
+        tree.insertAfter(b, a);
+
+        // looking up ac, will also set the cached index for aa and ab, so check that those are valid
+        t.equal(2, tree.index(ac));
+        t.equal(1, tree.index(ab));
+        t.equal(0, tree.index(aa));
+
+        // removing something should invalidate the cache
+        tree.remove(ab);
+        t.equal(1, tree.index(ac));
+        t.equal(-1, tree.index(ab));
+        t.equal(0, tree.index(aa));
+
+        // insertAfter should invalidate
+        tree.insertAfter(ab, aa);
+        t.equal(0, tree.index(aa));
+        t.equal(1, tree.index(ab));
+        t.equal(2, tree.index(ac));
+
+        // insertBefore should invalidate
+        const foo = {};
+        tree.insertBefore(foo, ab);
+        t.equal(0, tree.index(aa));
+        t.equal(2, tree.index(ab));
+        t.equal(3, tree.index(ac));
+
+        t.end();
+});