improvements

Author: hmottestad

core/sail/base/src/main/java/org/eclipse/rdf4j/sail/base/ParetoJoinMemoPlanner.java

@@ -115,28 +115,32 @@ Result<T> planMemo() {
 	Result<T> planBeam() {
 		StatsBuilder stats = new StatsBuilder();
 		ParetoFrontier<T> beam = new ParetoFrontier<>(beamWidth, tieBreaker);
+		ParetoFrontier<T> finalBeam = new ParetoFrontier<>(beamWidth, tieBreaker);
 		for (int i = 0; i < factorCount; i++) {
 			T seed = seedFactory.apply(i);
 			if (seed != null) {
-				add(beam, seed, stats);
+				add(finalPlan.test(seed) ? finalBeam : beam, seed, stats);
 			}
 		}
 		for (int depth = 1; depth < maxPlanStepCount && !beam.isEmpty(); depth++) {
 			ParetoFrontier<T> nextBeam = new ParetoFrontier<>(beamWidth, tieBreaker);
 			beam.forEach((prefix, ignored) -> {
+				if (finalPlan.test(prefix)) {
+					finalBeam.add(prefix, costVector.apply(prefix));
+					return;
+				}
 				long candidates = candidateMask.applyAsLong(prefix);
 				while (candidates != 0L) {
 					int candidate = Long.numberOfTrailingZeros(candidates);
 					candidates &= candidates - 1L;
 					T transition = transitionFactory.apply(prefix, candidate);
 					if (transition != null) {
-						add(nextBeam, transition, stats);
+						add(finalPlan.test(transition) ? finalBeam : nextBeam, transition, stats);
 					}
 				}
 			});
 			beam = nextBeam;
 		}
-		ParetoFrontier<T> finalBeam = new ParetoFrontier<>(beamWidth, tieBreaker);
 		beam.forEach((plan, cost) -> {
 			if (finalPlan.test(plan)) {
 				finalBeam.add(plan, cost);

core/sail/base/src/main/java/org/eclipse/rdf4j/sail/base/SketchBasedJoinEstimator.java

@@ -1291,6 +1291,9 @@ private void applyTo(SketchBasedJoinEstimator estimator, State state, byte slot)
 	/** True when persisted index metadata changed and index rewrite is pending. */
 	private final AtomicBoolean indexDirty = new AtomicBoolean(false);
 	private final Map<EstimateCacheKey, EstimateCacheEntry> estimateCache = new ConcurrentHashMap<>();
+	private static final PositiveReadinessCache NO_POSITIVE_READINESS_CACHE = new PositiveReadinessCache(
+			Long.MIN_VALUE, null, (byte) -1, -1L);
+	private volatile PositiveReadinessCache positiveReadinessCache = NO_POSITIVE_READINESS_CACHE;
 
 	private volatile BooleanSupplier rebuildAllowedSupplier;
 	private final Object persistLock = new Object();
@@ -1523,27 +1526,57 @@ public void close() {
 
 	public boolean isReady() {
 		OptimizationScopeState scope = optimizationScope.get();
-		if (scope == null) {
-			return isReadyUnscoped(null);
-		}
 		long epoch = rebuildEpoch.get();
 		boolean rebuildRequiredNow = rebuildRequired.get();
 		boolean sketchesLoadedNow = sketchesLoaded;
-		if (scope.readyKnown && scope.readyEpoch == epoch && scope.readyRebuildRequired == rebuildRequiredNow
+		if (scope != null && scope.readyKnown && scope.readyEpoch == epoch
+				&& scope.readyRebuildRequired == rebuildRequiredNow
 				&& scope.readySketchesLoaded == sketchesLoadedNow) {
 			return scope.ready;
 		}
+		State readyState = current;
+		byte readySlot = slotByte(slotOf(readyState));
+		PositiveReadinessCache cache = positiveReadinessCache;
+		if (cache.matches(epoch, rebuildRequiredNow, sketchesLoadedNow, readyState, readySlot,
+				slotGenerations[readySlot])) {
+			if (scope != null) {
+				cacheScopeReadiness(scope, epoch, true);
+			}
+			return true;
+		}
 		boolean ready = isReadyUnscoped(scope);
 		if (rebuildEpoch.get() == epoch) {
-			scope.readyEpoch = epoch;
-			scope.readyRebuildRequired = rebuildRequired.get();
-			scope.readySketchesLoaded = sketchesLoaded;
-			scope.ready = ready;
-			scope.readyKnown = true;
+			if (scope != null) {
+				cacheScopeReadiness(scope, epoch, ready);
+			}
+			if (ready) {
+				rememberPositiveReadiness(epoch);
+			}
 		}
 		return ready;
 	}
 
+	private void cacheScopeReadiness(OptimizationScopeState scope, long epoch, boolean ready) {
+		scope.readyEpoch = epoch;
+		scope.readyRebuildRequired = rebuildRequired.get();
+		scope.readySketchesLoaded = sketchesLoaded;
+		scope.ready = ready;
+		scope.readyKnown = true;
+	}
+
+	private void rememberPositiveReadiness(long epoch) {
+		if ((epoch & 1L) != 0L || rebuildRequired.get() || !sketchesLoaded) {
+			return;
+		}
+		State readyState = current;
+		byte readySlot = slotByte(slotOf(readyState));
+		positiveReadinessCache = new PositiveReadinessCache(epoch, readyState, readySlot, slotGenerations[readySlot]);
+	}
+
+	private void clearPositiveReadinessCache() {
+		positiveReadinessCache = NO_POSITIVE_READINESS_CACHE;
+	}
+
 	int scopedReadinessScansForTesting() {
 		OptimizationScopeState scope = optimizationScope.get();
 		return scope == null ? 0 : scope.readinessScans;
@@ -1899,6 +1932,7 @@ private void shutdownAsyncIncrementalIngest() {
 	public synchronized long rebuild() {
 		flushPendingIncremental();
 		clearEstimateCacheIfPopulated();
+		clearPositiveReadinessCache();
 
 		boolean rebuildIntoA = !usingA; // remember before toggling
 
@@ -2570,13 +2604,12 @@ public JoinEstimate estimate(Component joinVar, String s, String p, String o, St
 			synchronized (snap) {
 				PatternStats st = statsOf(snap, joinVar, s, p, o, c);
 				ArrayOfDoublesSketch bindings = st.sketch == null ? EMPTY : st.sketch;
-				return new JoinEstimate(snap, joinVar, bindings, TupleSketchOps.estimatePositiveDistinct(bindings),
-						st.card);
+				return new JoinEstimate(snap, joinVar, bindings, st.distinct, st.card);
 			}
 		}
 		PatternStats st = patternStats(snap, joinVar, s, p, o, c);
 		ArrayOfDoublesSketch bindings = st.sketch == null ? EMPTY : st.sketch;
-		return new JoinEstimate(snap, joinVar, bindings, TupleSketchOps.estimatePositiveDistinct(bindings), st.card);
+		return new JoinEstimate(snap, joinVar, bindings, st.distinct, st.card);
 	}
 
 	public double estimateCount(Component joinVar, String s, String p, String o, String c) {
@@ -2657,7 +2690,7 @@ private static final class PatternStats {
 
 		PatternStats(ArrayOfDoublesSketch s, double card) {
 			this.sketch = s;
-			this.distinct = TupleSketchOps.estimatePositiveDistinct(s);
+			this.distinct = TupleSketchOps.estimateDistinct(s);
 			this.card = card;
 		}
 	}
@@ -2985,7 +3018,7 @@ private BindingSketchResult bindingsSketch(State st, Component j, EnumMap<Compon
 					if (candidate == null) {
 						continue;
 					}
-					double candidateDistinct = TupleSketchOps.estimatePositiveDistinct(candidate);
+					double candidateDistinct = TupleSketchOps.estimateDistinct(candidate);
 					if (candidateDistinct < best) {
 						best = candidateDistinct;
 						candidateForBest = BindingSketchResult.of(candidate, pr);
@@ -3775,7 +3808,7 @@ private Map<String, VarPlanStats> estimateAllUnboundPatternVarStats(StatementPat
 			Component component = getComponent(pattern, var);
 			ArrayOfDoublesSketch sketch = getSketchForRead(snap,
 					new SketchAddress(REC_GLOBAL_COMPONENT, false, (byte) component.ordinal(), (byte) 0, 0, 0));
-			double distinct = clampDistinct(TupleSketchOps.estimatePositiveDistinct(sketch), rows);
+			double distinct = clampDistinct(TupleSketchOps.estimateDistinct(sketch), rows);
 			if (!(Double.isFinite(distinct) && distinct > 0.0d)) {
 				distinct = clampDistinct(rows, rows);
 				sketch = null;
@@ -3786,6 +3819,21 @@ private Map<String, VarPlanStats> estimateAllUnboundPatternVarStats(StatementPat
 	}
 
 	private TuplePlanEstimate estimateBindingSetAssignment(BindingSetAssignment assignment) {
+		OptimizationScopeState scope = optimizationScope.get();
+		if (scope != null) {
+			BindingSetAssignmentEstimateCacheKey key = new BindingSetAssignmentEstimateCacheKey(assignment);
+			Optional<TuplePlanEstimate> cached = scope.bindingSetAssignmentEstimateCache.get(key);
+			if (cached != null) {
+				return cached.orElse(null);
+			}
+			TuplePlanEstimate estimate = computeBindingSetAssignmentEstimate(assignment);
+			scope.bindingSetAssignmentEstimateCache.put(key, Optional.ofNullable(estimate));
+			return estimate;
+		}
+		return computeBindingSetAssignmentEstimate(assignment);
+	}
+
+	private TuplePlanEstimate computeBindingSetAssignmentEstimate(BindingSetAssignment assignment) {
 		Iterable<BindingSet> bindingSets = assignment.getBindingSets();
 		double rows = 0.0d;
 		Map<String, Set<Value>> valueSets = new HashMap<>();
@@ -4999,9 +5047,34 @@ private static final class OptimizationScopeState {
 		private final VariableDictionary variableDictionary = new VariableDictionary();
 		private final JoinOrderingSketchIntersectionCache sketchIntersectionCache = new JoinOrderingSketchIntersectionCache();
 		private final Map<TuplePlanEstimateCacheKey, Optional<TuplePlanEstimate>> tupleEstimateCache = new HashMap<>();
+		private final Map<BindingSetAssignmentEstimateCacheKey, Optional<TuplePlanEstimate>> bindingSetAssignmentEstimateCache = new HashMap<>();
 		private final Map<AccessShapeCacheKey, AccessShape> accessShapeCache = new HashMap<>();
 	}
 
+	private static final class PositiveReadinessCache {
+		private final long epoch;
+		private final State state;
+		private final byte slot;
+		private final long slotGeneration;
+
+		private PositiveReadinessCache(long epoch, State state, byte slot, long slotGeneration) {
+			this.epoch = epoch;
+			this.state = state;
+			this.slot = slot;
+			this.slotGeneration = slotGeneration;
+		}
+
+		private boolean matches(long currentEpoch, boolean rebuildRequired, boolean sketchesLoaded, State currentState,
+				byte currentSlot, long currentSlotGeneration) {
+			return !rebuildRequired
+					&& sketchesLoaded
+					&& epoch == currentEpoch
+					&& state == currentState
+					&& slot == currentSlot
+					&& slotGeneration == currentSlotGeneration;
+		}
+	}
+
 	private static final class TuplePlanEstimateCacheKey {
 		private final TupleExpr tupleExpr;
 		private final long boundVarMask;
@@ -5031,6 +5104,35 @@ public int hashCode() {
 		}
 	}
 
+	private static final class BindingSetAssignmentEstimateCacheKey {
+		private final Iterable<BindingSet> bindingSets;
+		private final Set<String> bindingNames;
+		private final int hashCode;
+
+		private BindingSetAssignmentEstimateCacheKey(BindingSetAssignment assignment) {
+			this.bindingSets = assignment.getBindingSets();
+			this.bindingNames = Set.copyOf(assignment.getBindingNames());
+			this.hashCode = 31 * System.identityHashCode(bindingSets) + bindingNames.hashCode();
+		}
+
+		@Override
+		public boolean equals(Object other) {
+			if (this == other) {
+				return true;
+			}
+			if (!(other instanceof BindingSetAssignmentEstimateCacheKey)) {
+				return false;
+			}
+			BindingSetAssignmentEstimateCacheKey that = (BindingSetAssignmentEstimateCacheKey) other;
+			return bindingSets == that.bindingSets && bindingNames.equals(that.bindingNames);
+		}
+
+		@Override
+		public int hashCode() {
+			return hashCode;
+		}
+	}
+
 	private static final class AccessShapeCacheKey {
 		private final TupleExpr tupleExpr;
 		private final long boundVarMask;
@@ -5328,16 +5430,30 @@ private TuplePlanEstimate estimateTupleExprPlan(TupleExpr tupleExpr, long initia
 
 	private TuplePlanEstimate estimateTupleExprPlan(TupleExpr tupleExpr, OptimizationScopeState scope,
 			long initiallyBoundVarMask) {
-		TuplePlanEstimateCacheKey key = new TuplePlanEstimateCacheKey(tupleExpr, initiallyBoundVarMask);
+		long cacheBoundVarMask = canonicalTupleEstimateBoundMask(tupleExpr, scope, initiallyBoundVarMask);
+		TuplePlanEstimateCacheKey key = new TuplePlanEstimateCacheKey(tupleExpr, cacheBoundVarMask);
 		Optional<TuplePlanEstimate> cached = scope.tupleEstimateCache.get(key);
 		if (cached != null) {
 			return cached.orElse(null);
 		}
-		TuplePlanEstimate estimate = computeTupleExprPlan(tupleExpr, scope, initiallyBoundVarMask);
+		TuplePlanEstimate estimate = computeTupleExprPlan(tupleExpr, scope, cacheBoundVarMask);
 		scope.tupleEstimateCache.put(key, Optional.ofNullable(estimate));
 		return estimate;
 	}
 
+	private long canonicalTupleEstimateBoundMask(TupleExpr tupleExpr, OptimizationScopeState scope,
+			long initiallyBoundVarMask) {
+		if (initiallyBoundVarMask == 0L || initiallyBoundVarMask == BOUND_VAR_MASK_OVERFLOW
+				|| !(tupleExpr instanceof BindingSetAssignment)) {
+			return initiallyBoundVarMask;
+		}
+		long assignmentMask = scope.variableDictionary.maskOf(((BindingSetAssignment) tupleExpr).getBindingNames());
+		if (assignmentMask == BOUND_VAR_MASK_OVERFLOW) {
+			return initiallyBoundVarMask;
+		}
+		return initiallyBoundVarMask & assignmentMask;
+	}
+
 	private TuplePlanEstimate computeTupleExprPlan(TupleExpr tupleExpr, Set<String> initiallyBoundVars) {
 		if (tupleExpr == null) {
 			return null;
@@ -7912,6 +8028,7 @@ public void discardAndMarkForRebuild() {
 
 	private void unloadInternal(boolean markRebuildRequired) {
 		clearEstimateCache();
+		clearPositiveReadinessCache();
 		if (persistenceEnabled && persistenceStore != null) {
 			if ((dirty.get() || indexDirty.get()) && !persistIfDirty()) {
 				return;
@@ -8001,6 +8118,7 @@ private void loadDirectoryStore(boolean markLoaded) throws IOException {
 		if (store == null || !store.hasMetadata()) {
 			return;
 		}
+		clearPositiveReadinessCache();
 		SketchEstimatorMetadata metadata = store.readMetadata();
 		if (metadata.subjectBucketCount != subjectBucketCount || metadata.predicateBucketCount != predicateBucketCount
 				|| metadata.objectBucketCount != objectBucketCount
@@ -8101,6 +8219,7 @@ private void clearPersistedSketchDirectory() {
 
 			indexDirty.set(false);
 		}
+		clearPositiveReadinessCache();
 	}
 
 	private boolean isRebuildAllowed() {

core/sail/base/src/main/java/org/eclipse/rdf4j/sail/base/SketchJoinOrderPlanner.java

@@ -18,6 +18,7 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -138,6 +139,7 @@ final class SketchJoinOrderPlanner {
 	private final Map<LocalFilterPassRatioKey, Double> localFilterPassRatioMemo = new HashMap<>();
 	private final Map<Long, Double> finiteBindingAssignmentPrefixRowsMemo = new HashMap<>();
 	private final Map<FiniteBindingVariableValuesKey, Set<Value>> finiteBindingVariableValuesMemo = new HashMap<>();
+	private final Map<ValueExpr, Map<Long, Double>> finiteDomainConditionPassRatioMemo = new IdentityHashMap<>();
 	private final SketchBasedJoinEstimator.SketchPlannerPath factorRejectionPath;
 	private final TupleExpr rejectedFactor;
 	private final List<JoinOrderPlanner.FilterConstraint> deferredFilters;
@@ -1349,6 +1351,18 @@ private double finiteDomainFilterPassRatio(JoinOrderPlanner.FilterConstraint fil
 	}
 
 	private double finiteDomainConditionPassRatio(ValueExpr condition, long factorMask) {
+		Map<Long, Double> ratiosByMask = finiteDomainConditionPassRatioMemo.computeIfAbsent(condition,
+				ignored -> new HashMap<>());
+		Double ratio = ratiosByMask.get(factorMask);
+		if (ratio != null) {
+			return ratio.doubleValue();
+		}
+		ratio = computeFiniteDomainConditionPassRatio(condition, factorMask);
+		ratiosByMask.put(factorMask, ratio);
+		return ratio.doubleValue();
+	}
+
+	private double computeFiniteDomainConditionPassRatio(ValueExpr condition, long factorMask) {
 		double enumeratedRatio = finiteDomainConditionPassRatioByEnumeration(condition, factorMask);
 		if (isValidPassRatio(enumeratedRatio)) {
 			return enumeratedRatio;

core/sail/base/src/main/java/org/eclipse/rdf4j/sail/base/TupleSketchOps.java

@@ -110,6 +110,13 @@ static double estimatePositiveDistinct(ArrayOfDoublesSketch sketch) {
 		return scaleByTheta(count, sketch);
 	}
 
+	static double estimateDistinct(ArrayOfDoublesSketch sketch) {
+		if (sketch == null || sketch.getRetainedEntries() == 0) {
+			return 0.0d;
+		}
+		return sketch.getEstimate();
+	}
+
 	static double estimateIntersectionProductSum(ArrayOfDoublesSketch left, ArrayOfDoublesSketch right, int k) {
 		return intersectProductStats(left, right, k).positiveSum();
 	}