Nav 126 re improve performance of raptor

src/main/java/ch/naviqore/app/service/ServiceConfigParser.java

@@ -20,7 +20,8 @@ public ServiceConfigParser(@Value("${gtfs.static.uri}") String gtfsStaticUri,
                                @Value("${walking.calculator.type}") String walkingCalculatorType,
                                @Value("${walking.speed}") double walkingSpeed,
                                @Value("${walking.duration.minimum}") int walkingDurationMinimum,
-                               @Value("${cache.size}") int cacheSize,
+                               @Value("${raptor.days.to.scan}") int raptorDaysToScan,
+                               @Value("${cache.service.day.size}") int cacheServiceDaySize,
                                @Value("${cache.eviction.strategy}") String cacheEvictionStrategy) {
 
         ServiceConfig.WalkCalculatorType walkCalculatorTypeEnum = ServiceConfig.WalkCalculatorType.valueOf(
@@ -30,7 +31,7 @@ public ServiceConfigParser(@Value("${gtfs.static.uri}") String gtfsStaticUri,
 
         this.serviceConfig = new ServiceConfig(gtfsStaticUri, gtfsStaticUpdateCron, transferTimeSameStopDefault,
                 transferTimeBetweenStopsMinimum, transferTimeAccessEgress, walkingSearchRadius, walkCalculatorTypeEnum,
-                walkingSpeed, walkingDurationMinimum, cacheSize, cacheEvictionStrategyEnum);
+                walkingSpeed, walkingDurationMinimum, raptorDaysToScan, cacheServiceDaySize, cacheEvictionStrategyEnum);
     }
 
 }

src/main/java/ch/naviqore/raptor/RaptorAlgorithm.java

@@ -1,15 +1,17 @@
 package ch.naviqore.raptor;
 
+import ch.naviqore.raptor.router.RaptorConfig;
 import ch.naviqore.raptor.router.RaptorRouterBuilder;
 
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
 
 public interface RaptorAlgorithm {
 
-    static RaptorRouterBuilder builder(int sameStopTransferTime) {
-        return new RaptorRouterBuilder(sameStopTransferTime);
+    static RaptorRouterBuilder builder(RaptorConfig config) {
+        return new RaptorRouterBuilder(config);
     }
 
     /**
@@ -48,4 +50,7 @@ List<Connection> routeLatestDeparture(Map<String, Integer> departureStops, Map<S
     Map<String, Connection> routeIsolines(Map<String, LocalDateTime> sourceStops, TimeType timeType,
                                           QueryConfig config);
 
+    // TODO: Discuss if this should be added to the interface (for now added for benchmark test)
+    void prepareStopTimesForDate(LocalDate date);
+
 }

src/main/java/ch/naviqore/raptor/router/DateTimeUtils.java

@@ -11,21 +11,13 @@
 
 class DateTimeUtils {
 
-    static LocalDate getReferenceDate(Map<?, LocalDateTime> sourceStops, TimeType timeType) {
+    static LocalDateTime getReferenceDate(Map<?, LocalDateTime> sourceStops, TimeType timeType) {
         if (timeType == TimeType.DEPARTURE) {
             // get minimum departure time
-            return sourceStops.values()
-                    .stream()
-                    .min(Comparator.naturalOrder())
-                    .map(LocalDateTime::toLocalDate)
-                    .orElseThrow();
+            return sourceStops.values().stream().min(Comparator.naturalOrder()).orElseThrow();
         } else {
             // get maximum arrival time
-            return sourceStops.values()
-                    .stream()
-                    .max(Comparator.naturalOrder())
-                    .map(LocalDateTime::toLocalDate)
-                    .orElseThrow();
+            return sourceStops.values().stream().max(Comparator.naturalOrder()).orElseThrow();
         }
     }
 

src/main/java/ch/naviqore/raptor/router/LabelPostprocessor.java

@@ -20,7 +20,7 @@
 class LabelPostprocessor {
 
     private final Stop[] stops;
-    private final StopTime[] stopTimes;
+    private final int[] stopTimes;
     private final Route[] routes;
     private final RouteStop[] routeStops;
 
@@ -375,7 +375,8 @@ private boolean canStopTimeBeTarget(StopTime stopTime, int routeSourceTime, Time
             return null;
         }
 
-        return stopTimes[firstStopTimeIdx + tripOffset * numberOfStops + stopOffset];
+        int stopTimeIndex = firstStopTimeIdx + 2 * (tripOffset * numberOfStops + stopOffset) + 2;
+        return new StopTime(stopTimes[stopTimeIndex], stopTimes[stopTimeIndex + 1]);
     }
 
     private @Nullable StopLabelsAndTimes.Label getBestLabelForStop(List<StopLabelsAndTimes.Label[]> bestLabelsPerRound,

src/main/java/ch/naviqore/raptor/router/Lookup.java

@@ -2,5 +2,5 @@
 
 import java.util.Map;
 
-record Lookup(Map<String, Integer> stops, Map<String, Integer> routes) {
+record Lookup(Map<String, Integer> stops, Map<String, Integer> routes, Map<String, String[]> routeTripIds) {
 }

src/main/java/ch/naviqore/raptor/router/Query.java

@@ -4,6 +4,7 @@
 import ch.naviqore.raptor.TimeType;
 import lombok.extern.slf4j.Slf4j;
 
+import java.time.LocalDateTime;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
@@ -31,6 +32,9 @@ class Query {
     private final int cutoffTime;
     private final StopLabelsAndTimes stopLabelsAndTimes;
 
+    private final LocalDateTime referenceDate;
+    private final int maxDaysToScan;
+
     /**
      * @param raptorData               the current raptor data structures.
      * @param sourceStopIndices        the indices of the source stops.
@@ -39,9 +43,12 @@ class Query {
      * @param walkingDurationsToTarget the walking durations to the target stops.
      * @param timeType                 the time type (arrival or departure) of the query.
      * @param config                   the query configuration.
+     * @param referenceDate            the reference date for the query.
+     * @param raptorConfig             the raptor configuration.
      */
     Query(RaptorData raptorData, int[] sourceStopIndices, int[] targetStopIndices, int[] sourceTimes,
-          int[] walkingDurationsToTarget, QueryConfig config, TimeType timeType) {
+          int[] walkingDurationsToTarget, QueryConfig config, TimeType timeType, LocalDateTime referenceDate,
+          RaptorConfig raptorConfig) {
 
         if (sourceStopIndices.length != sourceTimes.length) {
             throw new IllegalArgumentException("Source stops and departure/arrival times must have the same size.");
@@ -58,6 +65,8 @@ class Query {
         this.walkingDurationsToTarget = walkingDurationsToTarget;
         this.config = config;
         this.timeType = timeType;
+        this.referenceDate = referenceDate;
+        this.maxDaysToScan = raptorConfig.getDaysToScan();
 
         targetStops = new int[targetStopIndices.length * 2];
         cutoffTime = determineCutoffTime();
@@ -85,7 +94,7 @@ List<StopLabelsAndTimes.Label[]> run() {
         FootpathRelaxer footpathRelaxer = new FootpathRelaxer(stopLabelsAndTimes, raptorData,
                 config.getMinimumTransferDuration(), config.getMaximumWalkingDuration(), timeType);
         RouteScanner routeScanner = new RouteScanner(stopLabelsAndTimes, raptorData,
-                config.getMinimumTransferDuration(), timeType);
+                config.getMinimumTransferDuration(), timeType, referenceDate, maxDaysToScan);
 
         // initially relax all source stops and add the newly improved stops by relaxation to the marked stops
         Set<Integer> markedStops = initialize();
@@ -118,7 +127,7 @@ List<StopLabelsAndTimes.Label[]> run() {
      * @return the initially marked stops.
      */
     Set<Integer> initialize() {
-        log.info("Initializing global best times per stop and best labels per round");
+        log.debug("Initializing global best times per stop and best labels per round");
 
         // fill target stops
         for (int i = 0; i < targetStops.length; i += 2) {

src/main/java/ch/naviqore/raptor/router/RaptorConfig.java

@@ -0,0 +1,89 @@
+package ch.naviqore.raptor.router;
+
+import ch.naviqore.utils.cache.EvictionCache;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.Map;
+
+@Getter
+@NoArgsConstructor
+@ToString
+public class RaptorConfig {
+
+    @Setter
+    private RaptorTripMaskProvider maskProvider = new NoMaskProvider();
+
+    private int daysToScan = 1;
+    private int defaultSameStopTransferTime = 120;
+
+    private int stopTimeCacheSize = 5;
+    @Setter
+    private EvictionCache.Strategy stopTimeCacheStrategy = EvictionCache.Strategy.LRU;
+
+    public RaptorConfig(int daysToScan, int defaultSameStopTransferTime, int stopTimeCacheSize,
+                        EvictionCache.Strategy stopTimeCacheStrategy, RaptorTripMaskProvider maskProvider) {
+        setDaysToScan(daysToScan);
+        setDefaultSameStopTransferTime(defaultSameStopTransferTime);
+        setStopTimeCacheSize(stopTimeCacheSize);
+        setStopTimeCacheStrategy(stopTimeCacheStrategy);
+        setMaskProvider(maskProvider);
+    }
+
+    public void setDaysToScan(int daysToScan) {
+        if (daysToScan <= 0) {
+            throw new IllegalArgumentException("Days to scan must be greater than 0.");
+        }
+        this.daysToScan = daysToScan;
+    }
+
+    public void setDefaultSameStopTransferTime(int defaultSameStopTransferTime) {
+        if (defaultSameStopTransferTime < 0) {
+            throw new IllegalArgumentException("Default same stop transfer time must be greater than or equal to 0.");
+        }
+        this.defaultSameStopTransferTime = defaultSameStopTransferTime;
+    }
+
+    public void setStopTimeCacheSize(int stopTimeCacheSize) {
+        if (stopTimeCacheSize <= 0) {
+            throw new IllegalArgumentException("Stop time cache size must be greater than 0.");
+        }
+        this.stopTimeCacheSize = stopTimeCacheSize;
+    }
+
+    /**
+     * No mask provider as default mask provider (no masking of trips).
+     */
+    @Setter
+    @NoArgsConstructor
+    static class NoMaskProvider implements RaptorTripMaskProvider {
+
+        Map<String, String[]> tripIds = null;
+
+        @Override
+        public String getServiceIdForDate(LocalDate date) {
+            return "NoMask";
+        }
+
+        @Override
+        public DayTripMask getDayTripMask(LocalDate date) {
+            Map<String, RouteTripMask> tripMasks = new HashMap<>();
+            for (Map.Entry<String, String[]> entry : tripIds.entrySet()) {
+                String routeId = entry.getKey();
+                String[] tripIds = entry.getValue();
+                boolean[] tripMask = new boolean[tripIds.length];
+                for (int i = 0; i < tripIds.length; i++) {
+                    tripMask[i] = true;
+                }
+                tripMasks.put(routeId, new RouteTripMask(tripMask));
+            }
+
+            return new DayTripMask(getServiceIdForDate(date), date, tripMasks);
+        }
+    }
+
+}

src/main/java/ch/naviqore/raptor/router/RaptorData.java

@@ -11,4 +11,6 @@ interface RaptorData {
 
     RouteTraversal getRouteTraversal();
 
+    StopTimeProvider getStopTimeProvider();
+
 }

src/main/java/ch/naviqore/raptor/router/RaptorRouter.java

@@ -28,15 +28,29 @@ class RaptorRouter implements RaptorAlgorithm, RaptorData {
     @Getter
     private final RouteTraversal routeTraversal;
 
+    @Getter
+    private final StopTimeProvider stopTimeProvider;
+
+    private final RaptorConfig config;
+
     private final InputValidator validator;
 
-    RaptorRouter(Lookup lookup, StopContext stopContext, RouteTraversal routeTraversal) {
+    RaptorRouter(Lookup lookup, StopContext stopContext, RouteTraversal routeTraversal, RaptorConfig config) {
         this.lookup = lookup;
         this.stopContext = stopContext;
         this.routeTraversal = routeTraversal;
+        this.config = config;
+        config.getMaskProvider().setTripIds(lookup.routeTripIds());
+        this.stopTimeProvider = new StopTimeProvider(this, config.getMaskProvider(), config.getStopTimeCacheSize(),
+                config.getStopTimeCacheStrategy());
         validator = new InputValidator(lookup.stops());
     }
 
+    @Override
+    public void prepareStopTimesForDate(LocalDate date) {
+        stopTimeProvider.getStopTimesForDate(date);
+    }
+
     @Override
     public List<Connection> routeEarliestArrival(Map<String, LocalDateTime> departureStops,
                                                  Map<String, Integer> arrivalStops, QueryConfig config) {
@@ -68,14 +82,15 @@ public Map<String, Connection> routeIsolines(Map<String, LocalDateTime> sourceSt
         InputValidator.validateSourceStopTimes(sourceStops);
 
         log.info("Routing isolines from {} with {}", sourceStops.keySet(), timeType);
-        LocalDate referenceDate = DateTimeUtils.getReferenceDate(sourceStops, timeType);
+        LocalDateTime referenceDateTime = DateTimeUtils.getReferenceDate(sourceStops, timeType);
+        LocalDate referenceDate = referenceDateTime.toLocalDate();
         Map<Integer, Integer> validatedSourceStopIdx = validator.validateStopsAndGetIndices(
                 DateTimeUtils.mapLocalDateTimeToTimestamp(sourceStops, referenceDate));
 
         int[] sourceStopIndices = validatedSourceStopIdx.keySet().stream().mapToInt(Integer::intValue).toArray();
         int[] refStopTimes = validatedSourceStopIdx.values().stream().mapToInt(Integer::intValue).toArray();
         List<StopLabelsAndTimes.Label[]> bestLabelsPerRound = new Query(this, sourceStopIndices, new int[]{},
-                refStopTimes, new int[]{}, config, timeType).run();
+                refStopTimes, new int[]{}, config, timeType, referenceDateTime, this.config).run();
 
         return new LabelPostprocessor(this, timeType).reconstructIsolines(bestLabelsPerRound, referenceDate);
     }
@@ -98,7 +113,8 @@ public Map<String, Connection> routeIsolines(Map<String, LocalDateTime> sourceSt
     private List<Connection> getConnections(Map<String, LocalDateTime> sourceStops, Map<String, Integer> targetStops,
                                             TimeType timeType, QueryConfig config) {
         InputValidator.validateSourceStopTimes(sourceStops);
-        LocalDate referenceDate = DateTimeUtils.getReferenceDate(sourceStops, timeType);
+        LocalDateTime referenceDateTime = DateTimeUtils.getReferenceDate(sourceStops, timeType);
+        LocalDate referenceDate = referenceDateTime.toLocalDate();
         Map<String, Integer> sourceStopsSecondsOfDay = DateTimeUtils.mapLocalDateTimeToTimestamp(sourceStops,
                 referenceDate);
         Map<Integer, Integer> validatedSourceStops = validator.validateStopsAndGetIndices(sourceStopsSecondsOfDay);
@@ -111,7 +127,7 @@ private List<Connection> getConnections(Map<String, LocalDateTime> sourceStops,
         int[] walkingDurationsToTarget = validatedTargetStops.values().stream().mapToInt(Integer::intValue).toArray();
 
         List<StopLabelsAndTimes.Label[]> bestLabelsPerRound = new Query(this, sourceStopIndices, targetStopIndices,
-                sourceTimes, walkingDurationsToTarget, config, timeType).run();
+                sourceTimes, walkingDurationsToTarget, config, timeType, referenceDateTime, this.config).run();
 
         return new LabelPostprocessor(this, timeType).reconstructParetoOptimalSolutions(bestLabelsPerRound,
                 validatedTargetStops, referenceDate);
@@ -190,7 +206,7 @@ private Map<Integer, Integer> validateStopsAndGetIndices(Map<String, Integer> st
                 if (stopsToIdx.containsKey(stopId)) {
                     validStopIds.put(stopsToIdx.get(stopId), time);
                 } else {
-                    log.warn("Stop ID {} not found in lookup removing from query.", entry.getKey());
+                    log.debug("Stop ID {} not found in lookup removing from query.", entry.getKey());
                 }
             }