Merge pull request #24 from thakugan/master

Add benchmarks and some optimizations for diffAgainst

Author: taylorsw04

b+tree.js

@@ -640,14 +640,13 @@ var BTree = /** @class */ (function () {
      * @returns true if the step was completed and false if the step would have caused the cursor to move beyond the end of the tree.
      */
     BTree.step = function (cursor, stepToNode) {
-        if (stepToNode === void 0) { stepToNode = false; }
         var internalSpine = cursor.internalSpine, levelIndices = cursor.levelIndices, leaf = cursor.leaf;
-        if (stepToNode || leaf) {
+        if (stepToNode === true || leaf) {
             var levelsLength = levelIndices.length;
             // Step to the next node only if:
             // - We are explicitly directed to via stepToNode, or
             // - There are no key/value pairs left to step to in this leaf
-            if (stepToNode || levelIndices[levelsLength - 1] === 0) {
+            if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
                 var spineLength = internalSpine.length;
                 // Root is leaf
                 if (spineLength === 0)
@@ -656,19 +655,17 @@ var BTree = /** @class */ (function () {
                 var nodeLevelIndex = spineLength - 1;
                 var levelIndexWalkBack = nodeLevelIndex;
                 while (levelIndexWalkBack >= 0) {
-                    var childIndex = levelIndices[levelIndexWalkBack];
-                    if (childIndex > 0) {
+                    if (levelIndices[levelIndexWalkBack] > 0) {
                         if (levelIndexWalkBack < levelsLength - 1) {
                             // Remove leaf state from cursor
                             cursor.leaf = undefined;
-                            levelIndices.splice(levelIndexWalkBack + 1, levelsLength - levelIndexWalkBack);
+                            levelIndices.pop();
                         }
-                        // If we walked upwards past any internal node, splice them out
+                        // If we walked upwards past any internal node, slice them out
                         if (levelIndexWalkBack < nodeLevelIndex)
-                            internalSpine.splice(levelIndexWalkBack + 1, spineLength - levelIndexWalkBack);
+                            cursor.internalSpine = internalSpine.slice(0, levelIndexWalkBack + 1);
                         // Move to new internal node
-                        var nodeIndex = --levelIndices[levelIndexWalkBack];
-                        cursor.currentKey = internalSpine[levelIndexWalkBack][nodeIndex].maxKey();
+                        cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
                         return true;
                     }
                     levelIndexWalkBack--;

b+tree.ts

@@ -739,14 +739,14 @@ export default class BTree<K=any, V=any> implements ISortedMapF<K,V>, ISortedMap
    * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
    * @returns true if the step was completed and false if the step would have caused the cursor to move beyond the end of the tree.
    */ 
-  private static step<K, V>(cursor: DiffCursor<K, V>, stepToNode: boolean = false): boolean {
+  private static step<K, V>(cursor: DiffCursor<K, V>, stepToNode?: boolean): boolean {
     const { internalSpine, levelIndices, leaf } = cursor;
-    if (stepToNode || leaf) {
+    if (stepToNode === true || leaf) {
       const levelsLength = levelIndices.length;
       // Step to the next node only if:
       // - We are explicitly directed to via stepToNode, or
       // - There are no key/value pairs left to step to in this leaf
-      if (stepToNode || levelIndices[levelsLength - 1] === 0) {
+      if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
         const spineLength = internalSpine.length;
         // Root is leaf
         if (spineLength === 0)
@@ -755,19 +755,17 @@ export default class BTree<K=any, V=any> implements ISortedMapF<K,V>, ISortedMap
         const nodeLevelIndex = spineLength - 1;
         let levelIndexWalkBack = nodeLevelIndex;
         while (levelIndexWalkBack >= 0) {
-          const childIndex = levelIndices[levelIndexWalkBack]
-          if (childIndex > 0) {
+          if (levelIndices[levelIndexWalkBack] > 0) {
             if (levelIndexWalkBack < levelsLength - 1) {
               // Remove leaf state from cursor
               cursor.leaf = undefined;
-              levelIndices.splice(levelIndexWalkBack + 1, levelsLength - levelIndexWalkBack);
+              levelIndices.pop();
             }
-            // If we walked upwards past any internal node, splice them out
+            // If we walked upwards past any internal node, slice them out
             if (levelIndexWalkBack < nodeLevelIndex)
-              internalSpine.splice(levelIndexWalkBack + 1, spineLength - levelIndexWalkBack);
+              cursor.internalSpine = internalSpine.slice(0, levelIndexWalkBack + 1);
             // Move to new internal node
-            const nodeIndex = --levelIndices[levelIndexWalkBack];
-            cursor.currentKey = internalSpine[levelIndexWalkBack][nodeIndex].maxKey();
+            cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
             return true;
           }
           levelIndexWalkBack--;

benchmarks.ts

@@ -310,4 +310,47 @@ console.log("### Measure effect of max node size ###");
       tree.set(keys[i], undefined);
     console.log(`${timer.restart()}\tInsert ${tree.size} keys in B+tree with node size ${tree.maxNodeSize}`);
   }
+}
+
+console.log();
+console.log("### Delta between B+ trees");
+{
+  console.log();
+  const sizes = [100, 1000, 10000, 100000, 1000000];
+
+  sizes.forEach((size, i) => {
+    for (let j = i; j < sizes.length; j++) {
+      const tree = new BTree();
+      for (let k of makeArray(size, true))
+        tree.set(k, k * 10);
+
+      const otherSize = sizes[j];
+      const otherTree = new BTree();
+      for (let k of makeArray(otherSize, true))
+        otherTree.set(k, k * 10);
+
+      measure(() => `Delta between B+ trees with ${size} nodes and B+tree with ${otherSize} nodes`, () => {
+        tree.diffAgainst(otherTree);
+      });
+    }
+  })
+
+  console.log();
+  sizes.forEach((size, i) => {
+    for (let j = 0; j < sizes.length; j++) {
+      const otherSize = sizes[j];
+      const keys = makeArray(size + otherSize, true);
+      const tree = new BTree();
+      for (let k of keys.slice(0, size))
+        tree.set(k, k * 10);
+      
+      const otherTree = tree.clone();
+      for (let k of keys.slice(size))
+        tree.set(k, k * 10);
+
+      measure(() => `Delta between B+ trees with ${size} nodes and cheap cloned B+tree with ${otherSize} additional nodes`, () => {
+        tree.diffAgainst(otherTree);
+      });
+    }
+  })
 }