fastest yet, with codegen

Author: hmottestad

core/sail/lmdb/src/main/java/org/eclipse/rdf4j/sail/lmdb/LmdbDerivedBinaryRelation.java

@@ -11,12 +11,17 @@
 // Some portions generated by Codex
 package org.eclipse.rdf4j.sail.lmdb;
 
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 
 public final class LmdbDerivedBinaryRelation {
 
+	private static final ThreadLocal<Deque<RelationScratch>> SCRATCH_POOL = ThreadLocal.withInitial(ArrayDeque::new);
+
 	private final int sourceComponent;
 	private final int targetComponent;
 	private final LmdbCachedFrontier rootFrontier;
@@ -58,6 +63,24 @@ public long count(long sourceValue, long targetValue) {
 		return frontier(sourceValue).countFor(targetValue);
 	}
 
+	public int sourceCount() {
+		return adjacency.size();
+	}
+
+	public int rootFrontierSize() {
+		return rootFrontier.size();
+	}
+
+	public static RelationScratch borrowScratch() {
+		RelationScratch scratch = SCRATCH_POOL.get().pollFirst();
+		return scratch == null ? new RelationScratch() : scratch;
+	}
+
+	public static void releaseScratch(RelationScratch scratch) {
+		scratch.release();
+		SCRATCH_POOL.get().offerFirst(scratch);
+	}
+
 	public static final class Builder {
 
 		private final int sourceComponent;
@@ -190,4 +213,123 @@ void clear() {
 			size = 0;
 		}
 	}
+
+	public static final class RelationScratch {
+		private static final int MIN_CAPACITY = 8;
+
+		private long[] frontierKeys = new long[MIN_CAPACITY];
+		private long[][] frontierValues = new long[MIN_CAPACITY][];
+		private int[] frontierGenerations = new int[MIN_CAPACITY];
+		private int frontierGeneration = 1;
+
+		private long[] countSourceKeys = new long[MIN_CAPACITY];
+		private long[] countTargetKeys = new long[MIN_CAPACITY];
+		private long[] countValues = new long[MIN_CAPACITY];
+		private int[] countGenerations = new int[MIN_CAPACITY];
+		private int countGeneration = 1;
+
+		public void prepare(int sourceCount, int rootFrontierSize) {
+			int expectedEntries = Math.max(sourceCount, rootFrontierSize);
+			ensureFrontierCapacity(tableCapacity(expectedEntries));
+			frontierGeneration = nextGeneration(frontierGeneration, frontierGenerations);
+
+			ensureCountCapacity(tableCapacity(expectedEntries));
+			countGeneration = nextGeneration(countGeneration, countGenerations);
+		}
+
+		public int frontierMask() {
+			return frontierKeys.length - 1;
+		}
+
+		public boolean frontierUsed(int slot) {
+			return frontierGenerations[slot] == frontierGeneration;
+		}
+
+		public long frontierKey(int slot) {
+			return frontierKeys[slot];
+		}
+
+		public long[] frontierValue(int slot) {
+			return frontierValues[slot];
+		}
+
+		public void storeFrontier(int slot, long key, long[] values) {
+			frontierGenerations[slot] = frontierGeneration;
+			frontierKeys[slot] = key;
+			frontierValues[slot] = values;
+		}
+
+		public int countMask() {
+			return countSourceKeys.length - 1;
+		}
+
+		public boolean countUsed(int slot) {
+			return countGenerations[slot] == countGeneration;
+		}
+
+		public long countSourceKey(int slot) {
+			return countSourceKeys[slot];
+		}
+
+		public long countTargetKey(int slot) {
+			return countTargetKeys[slot];
+		}
+
+		public long countValue(int slot) {
+			return countValues[slot];
+		}
+
+		public void storeCount(int slot, long sourceKey, long targetKey, long value) {
+			countGenerations[slot] = countGeneration;
+			countSourceKeys[slot] = sourceKey;
+			countTargetKeys[slot] = targetKey;
+			countValues[slot] = value;
+		}
+
+		void release() {
+			Arrays.fill(frontierValues, null);
+			Arrays.fill(frontierGenerations, 0);
+			Arrays.fill(countGenerations, 0);
+			frontierGeneration = 1;
+			countGeneration = 1;
+		}
+
+		private void ensureFrontierCapacity(int requestedCapacity) {
+			if (frontierKeys.length >= requestedCapacity) {
+				return;
+			}
+			frontierKeys = new long[requestedCapacity];
+			frontierValues = new long[requestedCapacity][];
+			frontierGenerations = new int[requestedCapacity];
+			frontierGeneration = 1;
+		}
+
+		private void ensureCountCapacity(int requestedCapacity) {
+			if (countSourceKeys.length >= requestedCapacity) {
+				return;
+			}
+			countSourceKeys = new long[requestedCapacity];
+			countTargetKeys = new long[requestedCapacity];
+			countValues = new long[requestedCapacity];
+			countGenerations = new int[requestedCapacity];
+			countGeneration = 1;
+		}
+
+		private static int tableCapacity(int expectedEntries) {
+			int requested = Math.max(MIN_CAPACITY, expectedEntries << 1);
+			int capacity = MIN_CAPACITY;
+			while (capacity < requested) {
+				capacity <<= 1;
+			}
+			return capacity;
+		}
+
+		private static int nextGeneration(int generation, int[] slots) {
+			if (generation == Integer.MAX_VALUE) {
+				Arrays.fill(slots, 0);
+				return 1;
+			}
+			return generation + 1;
+		}
+	}
 }

core/sail/lmdb/src/main/java/org/eclipse/rdf4j/sail/lmdb/LmdbLftjExecutionShape.java

@@ -19,7 +19,7 @@
 
 public final class LmdbLftjExecutionShape {
 
-	private static final int FULL_STACK_TEMPLATE_VERSION = 2;
+	private static final int FULL_STACK_TEMPLATE_VERSION = 3;
 
 	private final int variableCount;
 	private final int[][] cursorOrdinalsBySlot;