Improve year 2022 day12

Author: linl33

lib/src/main/java/dev/linl33/adventofcode/lib/graph/GraphUtil.java

@@ -2,6 +2,9 @@
 
 import dev.linl33.adventofcode.lib.function.BiIntConsumer;
 import dev.linl33.adventofcode.lib.point.Point;
+import jdk.incubator.vector.IntVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
@@ -10,6 +13,8 @@
 import java.util.function.*;
 
 public final class GraphUtil {
+  private static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_PREFERRED;
+
   private static final Logger LOGGER = LogManager.getLogger(GraphUtil.class);
 
   public static <T> Optional<GraphPath<T>> aStar(T start, T end, Function<T, ? extends Collection<T>> neighborsFunc) {
@@ -158,7 +163,8 @@ private static <R> R aStarIntInternal(int start,
     Arrays.fill(gScore, Integer.MAX_VALUE);
     gScore[start] = 0;
 
-    var openSetFScore = new int[size];
+    var alignedSize = Math.ceilDiv(size, SPECIES.length()) * SPECIES.length();
+    var openSetFScore = new int[alignedSize];
     Arrays.fill(openSetFScore, Integer.MAX_VALUE);
     openSetFScore[start] = heuristic.applyAsInt(start);
 
@@ -172,12 +178,22 @@ private static <R> R aStarIntInternal(int start,
 
     while (openSetCounter > 0) {
       if (!hasMin) {
-        minFScore = Integer.MAX_VALUE;
+        var minVector = (IntVector) SPECIES.fromArray(openSetFScore, 0);
+        for (int i = SPECIES.length(); i < alignedSize; i += SPECIES.length()) {
+          var next = SPECIES.fromArray(openSetFScore, i);
+          minVector = minVector.min(next);
+        }
+
+        minFScore = minVector.reduceLanes(VectorOperators.MIN);
+        minVector = (IntVector) SPECIES.broadcast(minFScore);
 
-        for (int i = 0; i < openSetFScore.length; i++) {
-          if (openSetFScore[i] < minFScore) {
-            minFScore = openSetFScore[i];
-            minNode = i;
+        for (int i = 0; i < alignedSize; i += SPECIES.length()) {
+          var next = SPECIES.fromArray(openSetFScore, i);
+          var eqMask = next.compare(VectorOperators.EQ, minVector);
+          var eqIdx = eqMask.firstTrue();
+          if (eqIdx != SPECIES.length()) {
+            minNode = i + eqIdx;
+            break;
           }
         }
       }

lib/src/main/java/module-info.java

@@ -2,6 +2,8 @@
   requires static org.jetbrains.annotations;
   requires org.apache.logging.log4j;
 
+  requires jdk.incubator.vector;
+
   exports dev.linl33.adventofcode.lib;
   exports dev.linl33.adventofcode.lib.benchmark;
   exports dev.linl33.adventofcode.lib.function;

year2022/src/main/java/dev/linl33/adventofcode/year2022/Day12.java

@@ -2,6 +2,9 @@
 
 import dev.linl33.adventofcode.lib.graph.GraphUtil;
 import dev.linl33.adventofcode.lib.grid.RowArrayGrid;
+import jdk.incubator.vector.ShortVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.BufferedReader;
@@ -10,6 +13,8 @@
 import java.util.function.IntUnaryOperator;
 
 public class Day12 extends AdventSolution2022<Integer, Integer> {
+  private static final VectorSpecies<Short> SPECIES = ShortVector.SPECIES_PREFERRED;
+
   private static final int POTENTIAL_ENDPOINTS_MAX = 100;
 
   public static void main(String[] args) {
@@ -32,13 +37,23 @@ private static int calculatePathLength(@NotNull BufferedReader reader, boolean f
 
     var start = 0;
     var end = 0;
+    var startFound = false;
+    var endFound = false;
     for (int i = 0; i < gridBackingArray.length; i++) {
       if (gridBackingArray[i] == 'E') {
         gridBackingArray[i] = 'z';
         end = i + 1;
+
+        if ((endFound = true) && startFound) {
+          break;
+        }
       } else if (gridBackingArray[i] == 'S') {
         gridBackingArray[i] = 'a';
         start = i + 1;
+
+        if ((startFound = true) && endFound) {
+          break;
+        }
       }
     }
 
@@ -63,7 +78,7 @@ private static int calculatePathLength(@NotNull BufferedReader reader, boolean f
         return (heuristicCache[p + 1] = Math.abs(pathEndX - x) + Math.abs(pathEndY - y));
       };
     } else {
-      var potentialEndpoints = new int[POTENTIAL_ENDPOINTS_MAX * 2];
+      var potentialEndpoints = new short[POTENTIAL_ENDPOINTS_MAX * 2];
       var potentialEndpointsCount = 0;
 
       gridLoop:
@@ -92,14 +107,21 @@ private static int calculatePathLength(@NotNull BufferedReader reader, boolean f
             // if its lowest elevation is 'c' then it's inaccessible
             // if its highest elevation is 'a' then it has a neighbor with a shorter path
             if (grid.get(x2, y2) == 'b') {
-              potentialEndpoints[potentialEndpointsCount++] = x;
-              potentialEndpoints[potentialEndpointsCount++] = y;
+              potentialEndpoints[potentialEndpointsCount] = (short) x;
+              potentialEndpoints[potentialEndpointsCount + POTENTIAL_ENDPOINTS_MAX] = (short) y;
+              potentialEndpointsCount++;
               continue gridLoop;
             }
           }
         }
       }
 
+      var alignedLength = Math.ceilDiv(potentialEndpointsCount, SPECIES.length()) * SPECIES.length();
+      if (potentialEndpointsCount % SPECIES.length() != 0) {
+        Arrays.fill(potentialEndpoints, potentialEndpointsCount, alignedLength, (short) (grid.width() * 2));
+        Arrays.fill(potentialEndpoints, potentialEndpointsCount + POTENTIAL_ENDPOINTS_MAX, alignedLength + POTENTIAL_ENDPOINTS_MAX, (short) (grid.height() * 2));
+      }
+
       var finalPotentialEndpointsCount = potentialEndpointsCount;
       heuristic = p -> {
         if (heuristicCache[p] != 0) {
@@ -110,15 +132,20 @@ private static int calculatePathLength(@NotNull BufferedReader reader, boolean f
         var x = p % grid.width();
         var y = p / grid.width();
 
-        var min = Integer.MAX_VALUE;
-        for (int i = 0; i < finalPotentialEndpointsCount; i += 2) {
-          var pathEndX = potentialEndpoints[i];
-          var pathEndY = potentialEndpoints[i + 1];
+        var xVector = (ShortVector) SPECIES.broadcast(x);
+        var yVector = (ShortVector) SPECIES.broadcast(y);
+        var minVector = (ShortVector) SPECIES.broadcast(Short.MAX_VALUE);
+
+        for (int i = 0; i < alignedLength; i += SPECIES.length()) {
+          var pathX = (ShortVector) SPECIES.fromArray(potentialEndpoints, i);
+          var pathY = (ShortVector) SPECIES.fromArray(potentialEndpoints, i + finalPotentialEndpointsCount);
 
-          var manhattanDistance = Math.abs(pathEndX - x) + Math.abs(pathEndY - y);
-          min = Math.min(min, manhattanDistance);
+          pathX = xVector.sub(pathX).abs();
+          pathY = yVector.sub(pathY).abs();
+          minVector = minVector.min(pathX.add(pathY));
         }
 
+        var min = minVector.reduceLanes(VectorOperators.MIN);
         return (heuristicCache[p + 1] = min);
       };
     }

year2022/src/main/java/module-info.java

@@ -6,6 +6,8 @@
   requires static org.apache.logging.log4j.core;
   requires static org.jetbrains.annotations;
 
+  requires jdk.incubator.vector;
+
   exports dev.linl33.adventofcode.year2022 to dev.linl33.adventofcode.year2022.test;
 
   opens dev.linl33.adventofcode.year2022 to dev.linl33.adventofcode.lib, dev.linl33.adventofcode.jmh;