new best

Author: hmottestad

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

@@ -28,14 +28,14 @@ final class LmdbCachedTrieCursor implements LmdbLftjCursor {
 	}
 
 	@Override
-	public boolean open(String variableName) {
-		LmdbCachedFrontier frontier = provider.frontier(patternPlan, variableName);
+	public boolean open(int bindingSlot) {
+		LmdbCachedFrontier frontier = provider.frontier(patternPlan, bindingSlot);
 		if (frontier.isEmpty()) {
 			return false;
 		}
 
 		Frame frame = stack[stackSize++];
-		frame.variableName = variableName;
+		frame.bindingSlot = bindingSlot;
 		frame.frontier = frontier;
 		frame.position = 0;
 		return true;
@@ -85,12 +85,12 @@ public long value() {
 	}
 
 	@Override
-	public void release(String variableName) {
+	public void release(int bindingSlot) {
 		if (stackSize == 0) {
 			return;
 		}
 		Frame frame = stack[stackSize - 1];
-		if (!frame.matches(variableName)) {
+		if (!frame.matches(bindingSlot)) {
 			return;
 		}
 		stack[--stackSize].reset();
@@ -111,18 +111,18 @@ private Frame currentFrame() {
 	}
 
 	private static final class Frame {
-		private String variableName;
+		private int bindingSlot = -1;
 		private LmdbCachedFrontier frontier;
 		private int position;
 
 		private void reset() {
-			variableName = null;
+			bindingSlot = -1;
 			frontier = null;
 			position = -1;
 		}
 
-		private boolean matches(String variableName) {
-			return this.variableName != null && this.variableName.equals(variableName);
+		private boolean matches(int bindingSlot) {
+			return this.bindingSlot == bindingSlot;
 		}
 	}
 }

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

@@ -25,6 +25,7 @@ final class LmdbLftjBindingState {
 	private final LmdbLftjPlan plan;
 	private final BindingSet inputBindings;
 	private final LmdbQueryAccess queryAccess;
+	private final String[] variableNames;
 	private final Map<String, Integer> variableSlots = new HashMap<>();
 	private final long[] fixedValues;
 	private final boolean[] fixedPresent;
@@ -38,13 +39,14 @@ final class LmdbLftjBindingState {
 		this.plan = plan;
 		this.inputBindings = inputBindings;
 		this.queryAccess = queryAccess;
-		int variableCount = plan.variableOrder().size();
+		this.variableNames = plan.variableOrder().toArray(new String[0]);
+		int variableCount = variableNames.length;
 		this.fixedValues = new long[variableCount];
 		this.fixedPresent = new boolean[variableCount];
 		this.assignedValues = new long[variableCount];
 		this.assignedPresent = new boolean[variableCount];
 		for (int i = 0; i < variableCount; i++) {
-			variableSlots.put(plan.variableOrder().get(i), i);
+			variableSlots.put(variableNames[i], i);
 		}
 	}
 
@@ -63,7 +65,7 @@ boolean initialize() {
 				}
 			}
 		}
-		for (String variableName : plan.variableOrder()) {
+		for (String variableName : variableNames) {
 			if (inputBindings.hasBinding(variableName)) {
 				long id = queryAccess.resolveId(inputBindings.getValue(variableName));
 				if (id == LmdbValue.UNKNOWN_ID) {
@@ -86,26 +88,39 @@ TxnManager.Txn txn() {
 	}
 
 	boolean isBound(String variableName) {
-		int slot = slot(variableName);
+		return isBound(slot(variableName));
+	}
+
+	boolean isBound(int slot) {
 		return assignedPresent[slot] || fixedPresent[slot];
 	}
 
 	long value(String variableName) {
-		int slot = slot(variableName);
+		return value(slot(variableName));
+	}
+
+	long value(int slot) {
 		if (assignedPresent[slot]) {
 			return assignedValues[slot];
 		}
 		return fixedValues[slot];
 	}
 
 	void assign(String variableName, long value) {
-		int slot = slot(variableName);
+		assign(slot(variableName), value);
+	}
+
+	void assign(int slot, long value) {
 		assignedValues[slot] = value;
 		assignedPresent[slot] = true;
 	}
 
 	void clear(String variableName) {
-		assignedPresent[slot(variableName)] = false;
+		clear(slot(variableName));
+	}
+
+	void clear(int slot) {
+		assignedPresent[slot] = false;
 	}
 
 	long fixedId(LmdbLftjPatternPlan.TermRef term) {
@@ -126,14 +141,23 @@ long fixedId(LmdbLftjPatternPlan.TermRef term) {
 
 	BindingSet materialize(QueryEvaluationContext context) {
 		MutableBindingSet result = context.createBindingSet(inputBindings);
-		for (String variableName : plan.variableOrder()) {
-			if (!result.hasBinding(variableName) && isBound(variableName)) {
-				context.setBinding(variableName).accept(queryAccess.resolveValue(value(variableName)), result);
+		for (int slot = 0; slot < variableNames.length; slot++) {
+			String variableName = variableNames[slot];
+			if (!result.hasBinding(variableName) && isBound(slot)) {
+				context.setBinding(variableName).accept(queryAccess.resolveValue(value(slot)), result);
 			}
 		}
 		return result;
 	}
 
+	int variableCount() {
+		return variableNames.length;
+	}
+
+	String variableName(int slot) {
+		return variableNames[slot];
+	}
+
 	void close() {
 		if (txn != null) {
 			queryAccess.releaseReadTxn(txn);

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

@@ -13,15 +13,15 @@
 
 interface LmdbLftjCursor extends AutoCloseable {
 
-	boolean open(String variableName);
+	boolean open(int bindingSlot);
 
 	boolean seek(long target);
 
 	boolean next();
 
 	long value();
 
-	void release(String variableName);
+	void release(int bindingSlot);
 
 	@Override
 	void close();

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

@@ -12,6 +12,7 @@
 package org.eclipse.rdf4j.sail.lmdb;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import org.eclipse.rdf4j.common.iteration.CloseableIteration;
@@ -64,9 +65,9 @@ private final class LmdbLftjIteration extends LookAheadIteration<BindingSet> {
 		private final LmdbQueryAccess queryAccess;
 		private final LmdbLftjMetrics metrics;
 		private final LmdbPrefixFrontierProvider frontierProvider;
-		private final List<String> searchVariables;
-		private final List<LmdbLftjCursor> patternCursors;
-		private final List<List<LmdbLftjCursor>> cursorsByDepth;
+		private final int[] searchSlots;
+		private final LmdbLftjCursor[] patternCursors;
+		private final DepthRuntime[] depthRuntimes;
 		private final boolean[] initializedDepths;
 		private final boolean[] advanceDepths;
 
@@ -82,11 +83,11 @@ private LmdbLftjIteration(LmdbLftjPlan plan, LmdbLftjBindingState state, QueryEv
 			this.queryAccess = queryAccess;
 			this.metrics = metrics;
 			this.frontierProvider = new LmdbPrefixFrontierProvider(queryAccess, state, metrics);
-			this.searchVariables = collectSearchVariables(plan, state);
+			this.searchSlots = collectSearchSlots(plan, state);
 			this.patternCursors = createPatternCursors(plan, frontierProvider);
-			this.cursorsByDepth = createDepthCursors(plan, searchVariables, patternCursors);
-			this.initializedDepths = new boolean[searchVariables.size()];
-			this.advanceDepths = new boolean[searchVariables.size()];
+			this.depthRuntimes = createDepthRuntimes(plan, searchSlots, patternCursors);
+			this.initializedDepths = new boolean[searchSlots.length];
+			this.advanceDepths = new boolean[searchSlots.length];
 			this.depth = 0;
 		}
 
@@ -115,7 +116,7 @@ protected void handleClose() {
 
 		private BindingSet computeNextElement() {
 			while (depth >= 0) {
-				if (depth == searchVariables.size()) {
+				if (depth == searchSlots.length) {
 					long multiplicity = witnessMultiplicity(plan, metrics, frontierProvider);
 					backtrackAfterLeaf();
 					if (multiplicity > 0) {
@@ -155,22 +156,23 @@ private BindingSet computeNextElement() {
 		}
 
 		private boolean positionDepth(int depth, boolean advanceExisting) {
-			String variableName = searchVariables.get(depth);
-			List<LmdbLftjCursor> cursors = cursorsByDepth.get(depth);
-			state.clear(variableName);
+			DepthRuntime depthRuntime = depthRuntimes[depth];
+			int bindingSlot = depthRuntime.bindingSlot;
+			LmdbLftjCursor[] cursors = depthRuntime.cursors;
+			state.clear(bindingSlot);
 
-			if (cursors.isEmpty()) {
+			if (cursors.length == 0) {
 				return false;
 			}
 
 			if (!advanceExisting) {
 				for (LmdbLftjCursor cursor : cursors) {
 					metrics.recordCandidateScan();
-					if (!cursor.open(variableName)) {
+					if (!cursor.open(bindingSlot)) {
 						return false;
 					}
 				}
-			} else if (!cursors.get(0).next()) {
+			} else if (!cursors[0].next()) {
 				return false;
 			}
 
@@ -183,12 +185,12 @@ private boolean positionDepth(int depth, boolean advanceExisting) {
 				return false;
 			}
 
-			state.assign(variableName, current);
+			state.assign(bindingSlot, current);
 			return true;
 		}
 
 		private void backtrackAfterLeaf() {
-			depth = searchVariables.size() - 1;
+			depth = searchSlots.length - 1;
 			if (depth >= 0) {
 				advanceDepths[depth] = true;
 			}
@@ -203,56 +205,58 @@ private void backtrackFromDepth(int failedDepth) {
 		}
 
 		private void releaseDepth(int depth) {
-			if (depth < 0 || depth >= searchVariables.size()) {
+			if (depth < 0 || depth >= searchSlots.length) {
 				return;
 			}
-			String variableName = searchVariables.get(depth);
-			state.clear(variableName);
+			DepthRuntime depthRuntime = depthRuntimes[depth];
+			state.clear(depthRuntime.bindingSlot);
 			initializedDepths[depth] = false;
 			advanceDepths[depth] = false;
-			for (LmdbLftjCursor cursor : cursorsByDepth.get(depth)) {
-				cursor.release(variableName);
+			for (LmdbLftjCursor cursor : depthRuntime.cursors) {
+				cursor.release(depthRuntime.bindingSlot);
 			}
 		}
 	}
 
-	private List<String> collectSearchVariables(LmdbLftjPlan plan, LmdbLftjBindingState state) {
-		List<String> searchVariables = new ArrayList<>(plan.variableOrder().size());
-		for (String variableName : plan.variableOrder()) {
-			if (!state.isBound(variableName)) {
-				searchVariables.add(variableName);
+	private int[] collectSearchSlots(LmdbLftjPlan plan, LmdbLftjBindingState state) {
+		int[] searchSlots = new int[plan.variableOrder().size()];
+		int count = 0;
+		for (int slot = 0; slot < state.variableCount(); slot++) {
+			if (!state.isBound(slot)) {
+				searchSlots[count++] = slot;
 			}
 		}
-		return searchVariables;
+		return Arrays.copyOf(searchSlots, count);
 	}
 
-	private List<LmdbLftjCursor> createPatternCursors(LmdbLftjPlan plan, LmdbPrefixFrontierProvider frontierProvider) {
-		List<LmdbLftjCursor> cursors = new ArrayList<>(plan.patternPlans().size());
-		for (LmdbLftjPatternPlan patternPlan : plan.patternPlans()) {
-			cursors.add(new LmdbCachedTrieCursor(patternPlan, frontierProvider));
+	private LmdbLftjCursor[] createPatternCursors(LmdbLftjPlan plan, LmdbPrefixFrontierProvider frontierProvider) {
+		LmdbLftjCursor[] cursors = new LmdbLftjCursor[plan.patternPlans().size()];
+		List<LmdbLftjPatternPlan> patternPlans = plan.patternPlans();
+		for (int i = 0; i < patternPlans.size(); i++) {
+			cursors[i] = new LmdbCachedTrieCursor(patternPlans.get(i), frontierProvider);
 		}
 		return cursors;
 	}
 
-	private List<List<LmdbLftjCursor>> createDepthCursors(LmdbLftjPlan plan, List<String> searchVariables,
-			List<LmdbLftjCursor> patternCursors) {
-		List<List<LmdbLftjCursor>> cursorsByDepth = new ArrayList<>(searchVariables.size());
+	private DepthRuntime[] createDepthRuntimes(LmdbLftjPlan plan, int[] searchSlots, LmdbLftjCursor[] patternCursors) {
+		DepthRuntime[] depthRuntimes = new DepthRuntime[searchSlots.length];
 		List<LmdbLftjPatternPlan> patternPlans = plan.patternPlans();
-		for (String variableName : searchVariables) {
+		for (int depth = 0; depth < searchSlots.length; depth++) {
+			int bindingSlot = searchSlots[depth];
 			List<LmdbLftjCursor> cursors = new ArrayList<>();
 			for (int i = 0; i < patternPlans.size(); i++) {
 				LmdbLftjPatternPlan patternPlan = patternPlans.get(i);
-				if (!patternPlan.containsVariable(variableName)) {
+				if (!patternPlan.containsBindingSlot(bindingSlot)) {
 					continue;
 				}
-				cursors.add(patternCursors.get(i));
+				cursors.add(patternCursors[i]);
 			}
-			cursorsByDepth.add(cursors);
+			depthRuntimes[depth] = new DepthRuntime(bindingSlot, cursors.toArray(new LmdbLftjCursor[0]));
 		}
-		return cursorsByDepth;
+		return depthRuntimes;
 	}
 
-	private long align(List<LmdbLftjCursor> cursors, long target) {
+	private long align(LmdbLftjCursor[] cursors, long target) {
 		long current = target;
 		while (true) {
 			boolean allMatch = true;
@@ -292,6 +296,16 @@ private long countMatches(LmdbLftjPatternPlan patternPlan, LmdbLftjMetrics metri
 		return frontierProvider.countMatches(patternPlan);
 	}
 
+	private static final class DepthRuntime {
+		private final int bindingSlot;
+		private final LmdbLftjCursor[] cursors;
+
+		private DepthRuntime(int bindingSlot, LmdbLftjCursor[] cursors) {
+			this.bindingSlot = bindingSlot;
+			this.cursors = cursors;
+		}
+	}
+
 	private final class LazyFallbackStep {
 
 		private final TupleExpr fallbackExpr;