fix(performance): improve for loop performance (#14)

ntrotner · web-flow · commit feb929c4caea · 2025-03-12T11:32:40.000+01:00
diff --git a/src/comparators/object.comparator.ts b/src/comparators/object.comparator.ts
@@ -34,11 +34,21 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
    */
   private currentValues: T[] = [];
 
+  /**
+   * Stores the current nodes that have been used in a perfect match.
+   */
+  private readonly usedCurrentValueNodeIds = new Set<number>();
+
   /**
    * Stores the next nodes to compare.
    */
   private nextValues: T[] = [];
 
+  /**
+   * Stores the next nodes that have been used in a perfect match.
+   */
+  private readonly usedNextValueNodeIds = new Set<number>();
+
   /**
    * Threshold for next best match.
    */
@@ -91,17 +101,19 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
     console.log('Starting next best match search for objects');
     currentValuesLength = this.currentValues.length;
     let bestMatches = [];
+    const filteredCurrentValues = this.currentValues.filter(value => !this.usedCurrentValueNodeIds.has(value.nodeId));
+    const filteredNextValues = this.nextValues.filter(value => !this.usedNextValueNodeIds.has(value.nodeId));
     if (this.threads <= 1) {
-      for (const [i, value] of this.currentValues.entries()) {
-        bestMatches.push(...this.findNextBestMatches(value));
+      for (const [i, value] of filteredCurrentValues.entries()) {
+        bestMatches.push(...this.findNextBestMatches(value, filteredNextValues));
 
         if (i % 2500 === 0) {
           this.debug();
           console.log(`Progress: ${(i / currentValuesLength * 100).toFixed(2)}%`);
         }
       }
     } else {
-      const bestMatchesHub = new NextBestFitHub(this.currentValues, this.nextValues, {threads: this.threads, threshold: this.threshold});
+      const bestMatchesHub = new NextBestFitHub(filteredCurrentValues, filteredNextValues, {threads: this.threads, threshold: this.threshold});
       bestMatches = await bestMatchesHub.runComparison();
     }
 
@@ -122,6 +134,10 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
    */
   private findPerfectMatch(currentValue: NodeInput): boolean {
     const perfectMatch = this.nextValues.find(nextValue => {
+      if (this.usedNextValueNodeIds.has(nextValue.nodeId)) {
+        return false;
+      }
+
       try {
         return deepEqual(currentValue.node.obj, nextValue.node.obj);
       } catch {
@@ -139,8 +155,8 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
       aggregatorReference.currentNodeId.add(currentValue.nodeId);
       aggregatorReference.nextNodeId.add(perfectMatch.nodeId);
       this.results.perfectMatchNodes.set(valueHash, aggregatorReference);
-      this.currentValues = this.currentValues.filter(_currentValue => _currentValue.nodeId !== currentValue.nodeId);
-      this.nextValues = this.nextValues.filter(nextValue => nextValue.nodeId !== perfectMatch.nodeId);
+      this.usedCurrentValueNodeIds.add(currentValue.nodeId);
+      this.usedNextValueNodeIds.add(perfectMatch.nodeId);
       return true;
     }
 
@@ -152,8 +168,12 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
    *
    * @param currentValue
    */
-  private findNextBestMatches(currentValue: NodeInput): FuzzyEqualSimilarity[] {
-    return this.nextValues.map(nextValue => {
+  private findNextBestMatches(currentValue: NodeInput, nextValues: NodeInput[]): FuzzyEqualSimilarity[] {
+    return nextValues.map(nextValue => {
+      if (this.usedNextValueNodeIds.has(nextValue.nodeId)) {
+        return {similarity: 0, currentValueNodeId: 0, nextValueNodeId: 0};
+      }
+
       try {
         const totalSimilarity: FuzzyEqualComparison = fuzzyEqual(currentValue.node.obj, nextValue.node.obj);
         if (totalSimilarity.propertyCount === 0) {
@@ -198,10 +218,9 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
       aggregatorReference.nextNodeId.add(nextBestMatch.nextValueNodeId);
       usedCurrentNodes.add(nextBestMatch.currentValueNodeId);
       usedNextNodes.add(nextBestMatch.nextValueNodeId);
+      this.usedCurrentValueNodeIds.add(nextBestMatch.currentValueNodeId);
+      this.usedNextValueNodeIds.add(nextBestMatch.nextValueNodeId);
       similarityAggregatorReference.set(valueHash, aggregatorReference);
-
-      this.currentValues = this.currentValues.filter(_currentValue => _currentValue.nodeId !== nextBestMatch.currentValueNodeId);
-      this.nextValues = this.nextValues.filter(nextValue => nextValue.nodeId !== nextBestMatch.nextValueNodeId);
     }
   }
 
@@ -210,10 +229,18 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
    */
   private fillDisjunctNodes(): void {
     for (const currentValue of this.currentValues) {
+      if (this.usedCurrentValueNodeIds.has(currentValue.nodeId)) {
+        continue;
+      }
+
       this.results.disjunctNodes.currentNodeId.add(currentValue.nodeId);
     }
 
     for (const nextValue of this.nextValues) {
+      if (this.usedNextValueNodeIds.has(nextValue.nodeId)) {
+        continue;
+      }
+
       this.results.disjunctNodes.nextNodeId.add(nextValue.nodeId);
     }
 
@@ -243,6 +270,6 @@ export class ObjectComparator<T extends NodeInput> implements BaseComparator<T,
     console.log('Perfect matches:', perfectMatchCounter);
     console.log('Next best nodes:', nextBestMatchCounter);
     console.log('Disjunct nodes:', {current: this.results.disjunctNodes.currentNodeId.size, next: this.results.disjunctNodes.nextNodeId.size});
-    console.log('Available nodes:', {current: this.currentValues.length, next: this.nextValues.length});
+    console.log('Available nodes:', {current: this.currentValues.length - this.usedCurrentValueNodeIds.size, next: this.nextValues.length - this.usedNextValueNodeIds.size});
   }
 }
diff --git a/src/comparators/primitive-type.comparator.ts b/src/comparators/primitive-type.comparator.ts
@@ -16,11 +16,21 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
    */
   private currentValues: T[] = [];
 
+  /**
+   * Stores the current nodes that have been used in a perfect match.
+   */
+  private readonly usedCurrentValueNodeIds = new Set<number>();
+
   /**
    * Stores the next nodes to compare.
    */
   private nextValues: T[] = [];
 
+  /**
+   * Stores the next nodes that have been used in a perfect match.
+   */
+  private readonly usedNextValueNodeIds = new Set<number>();
+
   /**
    * Stores the comparison results.
    */
@@ -55,6 +65,7 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
 
     console.log('Finished perfect match search for primitive types');
     this.fillDisjunctNodes();
+    console.log('Finished matching for primitive types');
 
     return this.results;
   }
@@ -66,7 +77,9 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
    * @returns indicator whether perfect match was found
    */
   private findPerfectMatch(currentValue: T): boolean {
-    const perfectMatch = this.nextValues.find(nextValue => currentValue.value === nextValue.value);
+    const perfectMatch = this.nextValues.find(nextValue =>
+      !this.usedNextValueNodeIds.has(nextValue.n) && currentValue.value === nextValue.value,
+    );
 
     if (perfectMatch) {
       const valueHash = currentValue.value?.toString() ?? 'undefined';
@@ -78,8 +91,8 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
       aggregatorReference.currentNodeId.add(currentValue.n);
       aggregatorReference.nextNodeId.add(perfectMatch.n);
       this.results.perfectMatchNodes.set(valueHash, aggregatorReference);
-      this.currentValues = this.currentValues.filter(_currentValue => _currentValue.n !== currentValue.n);
-      this.nextValues = this.nextValues.filter(nextValue => nextValue.n !== perfectMatch.n);
+      this.usedCurrentValueNodeIds.add(currentValue.n);
+      this.usedNextValueNodeIds.add(perfectMatch.n);
 
       return true;
     }
@@ -92,10 +105,18 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
    */
   private fillDisjunctNodes(): void {
     for (const currentValue of this.currentValues) {
+      if (this.usedCurrentValueNodeIds.has(currentValue.n)) {
+        continue;
+      }
+
       this.results.disjunctNodes.currentNodeId.add(currentValue.n);
     }
 
     for (const nextValue of this.nextValues) {
+      if (this.usedNextValueNodeIds.has(nextValue.n)) {
+        continue;
+      }
+
       this.results.disjunctNodes.nextNodeId.add(nextValue.n);
     }
 
@@ -116,6 +137,6 @@ export class PrimitiveTypeComparator<T extends PrimitiveRecord> implements BaseC
     console.log('----------');
     console.log('Perfect matches:', perfectMatchCounter);
     console.log('Disjunct nodes:', {current: this.results.disjunctNodes.currentNodeId.size, next: this.results.disjunctNodes.nextNodeId.size});
-    console.log('Available nodes:', {current: this.currentValues.length, next: this.nextValues.length});
+    console.log('Available nodes:', {current: this.currentValues.length - this.usedCurrentValueNodeIds.size, next: this.nextValues.length - this.usedNextValueNodeIds.size});
   }
 }
diff --git a/src/presenters/statistics.presenter.ts b/src/presenters/statistics.presenter.ts
@@ -67,7 +67,7 @@ export class StatisticsPresenter<T extends BaseComparisonNodesInput> implements
     const heapSizeOfNextBestMatch = this.getHeapSizeOfNextBestMatch();
     const heapSizeOfDisjunctNodes = this.getHeapSizeOfDisjunctNodes();
     const totalNumberOfNodes = this.getTotalNumberOfNodes();
-    const totalSizeDifference = this.calculateTotalHeapSizeDifference(heapSizeOfNextBestMatch, heapSizeOfDisjunctNodes);
+    const totalSizeDifference = this.calculateTotalHeapSizeDifference(heapSizeOfPerfectMatch, heapSizeOfNextBestMatch, heapSizeOfDisjunctNodes);
 
     const pathToWrite = path.join(this.options.filePath, this.options.fileName);
     const dataToWrite = JSON.stringify({
@@ -83,16 +83,17 @@ export class StatisticsPresenter<T extends BaseComparisonNodesInput> implements
   /**
    * Calculate the total heap size difference.
    *
+   * @param heapSizeOfPerfectMatch
    * @param heapSizeOfNextBestMatch
    * @param heapSizeOfDisjunctNodes
    * @private
    */
-  private calculateTotalHeapSizeDifference(heapSizeOfNextBestMatch: HeapSizeOfNextBestMatch, heapSizeOfDisjunctNodes: HeapSizeOfDisjunctNodes): TotalHeapSizeDifference {
+  private calculateTotalHeapSizeDifference(heapSizeOfPerfectMatch: HeapSizeOfPerfectMatch, heapSizeOfNextBestMatch: HeapSizeOfNextBestMatch, heapSizeOfDisjunctNodes: HeapSizeOfDisjunctNodes): TotalHeapSizeDifference {
     const {sizeByAccuracy} = heapSizeOfNextBestMatch;
     const {currentShallowHeapSize: currentDisjunctNodesShallowHeapSize, nextShallowHeapSize: nextDisjunctNodesShallowHeapSize} = heapSizeOfDisjunctNodes;
 
-    const currentShallowHeapSize = Object.values(sizeByAccuracy).reduce((accumulator, value) => accumulator + value.currentShallowHeapSize, 0) + currentDisjunctNodesShallowHeapSize;
-    const nextShallowHeapSize = Object.values(sizeByAccuracy).reduce((accumulator, value) => accumulator + value.nextShallowHeapSize, 0) + nextDisjunctNodesShallowHeapSize;
+    const currentShallowHeapSize = Object.values(sizeByAccuracy).reduce((accumulator, value) => accumulator + value.currentShallowHeapSize, 0) + currentDisjunctNodesShallowHeapSize + heapSizeOfPerfectMatch.currentShallowHeapSize;
+    const nextShallowHeapSize = Object.values(sizeByAccuracy).reduce((accumulator, value) => accumulator + value.nextShallowHeapSize, 0) + nextDisjunctNodesShallowHeapSize + heapSizeOfPerfectMatch.nextShallowHeapSize;
     const difference = nextShallowHeapSize - currentShallowHeapSize;
     const percentage = (nextShallowHeapSize - currentShallowHeapSize) / nextShallowHeapSize * 100;
 
