perf: big optimization reducing GC pressure with specialized maps

Author: lvca

engine/src/main/java/com/arcadedb/query/opencypher/executor/steps/PartitionedTriangleOp.java

@@ -26,15 +26,14 @@
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.schema.DocumentType;
 import com.arcadedb.schema.VertexType;
+import com.arcadedb.utility.RidHashSet;
 
 import com.arcadedb.query.QueryEngineManager;
 
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
@@ -255,7 +254,7 @@ public long executeOLTP(final Database db) {
         if (vCountry == null || !vCountry.equals(uCountry))
           continue;
 
-        final Set<RID> uNeighborSet = new HashSet<>();
+        final RidHashSet uNeighborSet = new RidHashSet();
         for (final RID nRid : uNeighbors) {
           final RID nCountry = personToPartition.get(nRid);
           if (nCountry != null && nCountry.equals(uCountry))

engine/src/main/java/com/arcadedb/query/opencypher/executor/steps/PropagateChainOp.java

@@ -25,11 +25,11 @@
 import com.arcadedb.graph.NeighborView;
 import com.arcadedb.graph.Vertex;
 
+import com.arcadedb.utility.RidLongHashMap;
+
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -408,7 +408,7 @@ public long executeOLTP(final Database db) {
     // with its count capturing path multiplicity. This reduces O(paths) traversals
     // to O(unique edges), which is dramatically faster for high-fanout chains.
     // E.g., Q5 with 13.8M paths but only ~3.5M unique edges: ~4x fewer OLTP scans.
-    HashMap<RID, Long> current = new HashMap<>();
+    RidLongHashMap current = new RidLongHashMap();
     for (final Iterator<? extends Identifiable> it = db.iterateType(anchorLabel, true); it.hasNext(); )
       current.put(it.next().getIdentity(), 1L);
 
@@ -420,24 +420,24 @@ public long executeOLTP(final Database db) {
       else
         targetBuckets = null;
 
-      final HashMap<RID, Long> next = new HashMap<>();
-      for (final Map.Entry<RID, Long> entry : current.entrySet()) {
-        final long pathCount = entry.getValue();
-        expandNeighbors(db, provider, entry.getKey(), directions[hop], edgeTypes[hop], targetBuckets,
-            (neighborRid) -> next.merge(neighborRid, pathCount, Long::sum));
-      }
+      final RidLongHashMap next = new RidLongHashMap();
+      final int h = hop;
+      current.forEach((bucketId, offset, pathCount) -> {
+        final RID rid = new RID(db, bucketId, offset);
+        expandNeighbors(db, provider, rid, directions[h], edgeTypes[h], targetBuckets,
+            (neighborRid) -> next.add(neighborRid, pathCount));
+      });
       current = next;
     }
 
-    long total = 0;
-    for (final long c : current.values())
-      total += c;
+    final long[] total = {0};
+    current.forEach((bucketId, offset, value) -> total[0] += value);
 
     // Subtract self-loop paths for inequality
     if (inequalityIdxA >= 0 && inequalityIdxB >= 0)
-      total -= countSelfLoopPathsOLTP(db, provider);
+      total[0] -= countSelfLoopPathsOLTP(db, provider);
 
-    return total;
+    return total[0];
   }
 
   /**
@@ -487,7 +487,7 @@ private long countSelfLoopPathsOLTP(final Database db, final GraphTraversalProvi
 
       // Sparse BFS from anchor through sub-chain [idxA, idxB)
       // using per-source map to deduplicate within this source's expansion
-      HashMap<RID, Long> cur = new HashMap<>();
+      RidLongHashMap cur = new RidLongHashMap();
       cur.put(anchorRid, 1L);
 
       for (int h = 0; h < subLength; h++) {
@@ -499,16 +499,16 @@ private long countSelfLoopPathsOLTP(final Database db, final GraphTraversalProvi
         else
           targetBuckets = null;
 
-        final HashMap<RID, Long> next = new HashMap<>();
-        for (final Map.Entry<RID, Long> entry : cur.entrySet()) {
-          final long pathCount = entry.getValue();
-          expandNeighbors(db, provider, entry.getKey(), directions[hopIdx], edgeTypes[hopIdx], targetBuckets,
-              (neighborRid) -> next.merge(neighborRid, pathCount, Long::sum));
-        }
+        final RidLongHashMap next = new RidLongHashMap();
+        cur.forEach((bucketId, offset, pathCount) -> {
+          final RID rid = new RID(db, bucketId, offset);
+          expandNeighbors(db, provider, rid, directions[hopIdx], edgeTypes[hopIdx], targetBuckets,
+              (neighborRid) -> next.add(neighborRid, pathCount));
+        });
         cur = next;
       }
 
-      long loopCount = cur.getOrDefault(anchorRid, 0L);
+      long loopCount = cur.get(anchorRid, 0);
 
       // Multiply by tail after idxB
       if (loopCount > 0 && idxB < edgeTypes.length) {

engine/src/main/java/com/arcadedb/query/opencypher/traversal/BreadthFirstTraverser.java

@@ -23,16 +23,15 @@
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.opencypher.ast.Direction;
 import com.arcadedb.query.opencypher.ast.PathMode;
+import com.arcadedb.utility.RidHashSet;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Queue;
-import java.util.Set;
 
 /**
  * Breadth-first graph traverser.
@@ -73,12 +72,12 @@ public Iterator<TraversalPath> traversePaths(final Vertex startVertex) {
    */
   private class BFSVertexIterator implements Iterator<Vertex> {
     private final Queue<VertexWithDepth> queue = new LinkedList<>();
-    private final Set<RID> visited;
+    private final RidHashSet visited;
     private final List<Vertex> results = new ArrayList<>();
     private int currentIndex = 0;
 
     BFSVertexIterator(final Vertex startVertex) {
-      this.visited = detectCycles ? createVisitedSet() : new HashSet<>();
+      this.visited = createVisitedSet();
       queue.add(new VertexWithDepth(startVertex, 0));
 
       // Perform full BFS traversal

engine/src/main/java/com/arcadedb/query/opencypher/traversal/DepthFirstTraverser.java

@@ -23,14 +23,13 @@
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.opencypher.ast.Direction;
 import com.arcadedb.query.opencypher.ast.PathMode;
+import com.arcadedb.utility.RidHashSet;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
-import java.util.Set;
 
 /**
  * Depth-first graph traverser.
@@ -74,11 +73,11 @@ private class DFSVertexIterator implements Iterator<Vertex> {
     private int currentIndex = 0;
 
     DFSVertexIterator(final Vertex startVertex) {
-      final Set<RID> visited = detectCycles ? createVisitedSet() : new HashSet<>();
+      final RidHashSet visited = createVisitedSet();
       performDFS(startVertex, 0, visited);
     }
 
-    private void performDFS(final Vertex vertex, final int depth, final Set<RID> visited) {
+    private void performDFS(final Vertex vertex, final int depth, final RidHashSet visited) {
       // Skip if already visited
       if (detectCycles && isVisited(vertex, visited)) {
         return;

engine/src/main/java/com/arcadedb/query/opencypher/traversal/GraphTraverser.java

@@ -18,17 +18,15 @@
  */
 package com.arcadedb.query.opencypher.traversal;
 
-import com.arcadedb.database.RID;
 import com.arcadedb.graph.Edge;
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.opencypher.ast.Direction;
 import com.arcadedb.query.opencypher.ast.PathMode;
+import com.arcadedb.utility.RidHashSet;
 
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
-import java.util.Set;
 
 /**
  * Base class for graph traversal implementations.
@@ -193,40 +191,34 @@ protected boolean matchesPropertyFilter(final Edge edge) {
 
   /**
    * Creates a visited set for cycle detection.
-   * Uses RIDs instead of Vertex objects for efficient O(1) hash lookups.
+   * Uses RidHashSet for zero-boxing O(1) lookups with ~8.7x memory savings over HashSet<RID>.
    *
-   * @return new hash set for tracking visited vertex RIDs
+   * @return new RidHashSet for tracking visited vertex RIDs
    */
-  protected Set<RID> createVisitedSet() {
-    return new HashSet<>();
+  protected RidHashSet createVisitedSet() {
+    return new RidHashSet();
   }
 
   /**
    * Checks if a vertex has been visited.
-   * O(1) hash lookup using RID.
-   * Creates a database-independent RID to ensure proper equality/hashCode.
+   * O(1) hash lookup using primitive bucketId + offset — no temporary RID allocation.
    *
    * @param vertex  vertex to check
    * @param visited set of visited vertex RIDs
    * @return true if visited
    */
-  protected boolean isVisited(final Vertex vertex, final Set<RID> visited) {
-    final RID rid = vertex.getIdentity();
-    // Create database-independent RID for consistent equals/hashCode
-    return visited.contains(new RID(rid.getBucketId(), rid.getPosition()));
+  protected boolean isVisited(final Vertex vertex, final RidHashSet visited) {
+    return visited.contains(vertex.getIdentity());
   }
 
   /**
    * Marks a vertex as visited.
-   * Stores only the RID for memory efficiency and O(1) lookups.
-   * Creates a database-independent RID to ensure proper equality/hashCode.
+   * Stores only primitive bucketId + offset for memory efficiency and O(1) lookups.
    *
    * @param vertex  vertex to mark
    * @param visited set of visited vertex RIDs
    */
-  protected void markVisited(final Vertex vertex, final Set<RID> visited) {
-    final RID rid = vertex.getIdentity();
-    // Create database-independent RID for consistent equals/hashCode
-    visited.add(new RID(rid.getBucketId(), rid.getPosition()));
+  protected void markVisited(final Vertex vertex, final RidHashSet visited) {
+    visited.add(vertex.getIdentity());
   }
 }