Merge branch 'main' of https://github.com/ShortestPathLab/winter-proj…

…ect-mapf-tracker

client/src/pages/submission-summary/table/SummaryTable.tsx

@@ -13,6 +13,7 @@ import {
   Button,
   capitalize,
   Chip,
+  CircularProgress,
   Collapse,
   Divider,
   Stack,
@@ -262,10 +263,9 @@ export default function Table({ apiKey }: { apiKey?: string | number }) {
                           />
                         ),
                         queued: (
-                          <HourglassEmptyOutlined
-                            color="primary"
-                            fontSize="small"
-                          />
+                          <Stack sx={{ alignItems: "center" }}>
+                            <CircularProgress size={24} />
+                          </Stack>
                         ),
                       }[submission?.validation?.outcome] ?? (
                         <HourglassEmptyOutlined

packages/validator/src/checks/checkImmediateCollision.ts

@@ -6,23 +6,22 @@ export function checkImmediateCollision({
   next,
   timestep,
 }: CheckParameters): CheckResult {
+  const a = next.map($);
+  const hasCollision = new Set(a).size !== a.length;
+  if (!hasCollision) return {};
   const collision = _(next)
     .map((c, i) => [c, i] as const)
-    .groupBy(([c, i]) => $(c))
+    .groupBy(([c]) => $(c))
     .values()
     .find((agents) => agents.length > 1)
     .value();
-  if (collision) {
-    const [p] = head(collision);
-    return {
-      errorAgents: collision.map(([, i]) => i),
-      errors: [
-        `agent-to-agent direct collision, agents ${collision
-          .map(([, i]) => i)
-          .join(" and ")}, at timestep ${timestep} ${$(p)}`,
-      ],
-    };
-  } else {
-    return {};
-  }
+  const [p] = head(collision);
+  return {
+    errorAgents: collision.map(([, i]) => i),
+    errors: [
+      `agent-to-agent direct collision, agents ${collision
+        .map(([, i]) => i)
+        .join(" and ")}, at timestep ${timestep} ${$(p)}`,
+    ],
+  };
 }

packages/validator/src/encode.ts

@@ -32,3 +32,25 @@ export function encode(input: string): string {
 
   return encoded;
 }
+
+/**
+ * From ChatGPT
+ * Run length decoder
+ */
+export function decode(encoded: string): string {
+  let decoded = "";
+  let count = "";
+
+  for (const char of encoded) {
+    if (isNaN(Number(char))) {
+      // If the character is not a number, append it 'count' times to the result
+      decoded += char.repeat(Number(count) || 1);
+      count = ""; // Reset count for the next sequence
+    } else {
+      // If the character is a number, add it to the count
+      count += char;
+    }
+  }
+
+  return decoded;
+}

packages/validator/src/validate.ts

@@ -12,6 +12,7 @@ import { DoneException } from "./exceptions/DoneException";
 import type { Dictionary } from "lodash";
 import { some, zip } from "lodash";
 import { checkEdgeCollision } from "./checks/checkEdgeCollision";
+import { decode } from "./encode";
 
 type ValidationParameters = {
   paths: string[];
@@ -52,6 +53,18 @@ export function processAgent(agent: string) {
   };
 }
 
+export function processAgentSimple(agent: string) {
+  const decoded = decode(agent);
+  return {
+    seek: (n: number) => {
+      return decoded[n] || "w";
+    },
+    done: (n: number) => {
+      return n >= decoded.length;
+    },
+  };
+}
+
 export const defaultOffsetMap = {
   u: { x: 0, y: -1 },
   d: { x: 0, y: 1 },
@@ -84,12 +97,13 @@ export function validate({
   onFinish = [],
   onError = () => false,
 }: ValidationParameters) {
-  const as = paths.map(processAgent);
+  const as = paths.map(processAgentSimple);
   let i = 0;
   let prev = sources;
   while (some(as, (c) => !c.done(i))) {
     const actions = createActionMap(i, as);
     const next = sumPositions(prev, createOffsetMap(actions));
+    const done = as.map((c) => c.done(i));
     for (const check of onTimestep) {
       const result = check({
         timestep: i,
@@ -99,7 +113,7 @@ export function validate({
         domain,
         sources,
         goals,
-        done: as.map((c) => c.done(i)),
+        done,
       });
       // Stop validation if onError returns true.
       if (result.errors?.length && onError(result)) return false;

server/src/models/OngoingSubmission.ts

@@ -18,6 +18,7 @@ const schema = createSchema(
     solutions: [String],
     options: { skipValidation: Schema.Types.Boolean },
     validation: {
+      timeTaken: Number,
       isValidationRun: Schema.Types.Boolean,
       errors: [String],
       outcome: String,

server/src/validation/submissionRequestValidatorWorker.ts

@@ -133,7 +133,7 @@ const submitOne = async (
     instance: data.instance.id,
     lowerBound: data.lower_cost,
     cost: data.solution_cost,
-    solutions: data.solution_plan,
+    solutions: data.solution_plan.map(encode),
     options: { skipValidation: data.skip_validation },
   }).save();
 

server/src/validation/submissionValidatorWorker.ts

@@ -1,4 +1,4 @@
-import { chain, each, isInteger, isNumber, max, min, once } from "lodash";
+import { chain, each, isInteger, isNumber, max, min, now, once } from "lodash";
 import { context } from "logging";
 import { Infer, Instance, Map, OngoingSubmission, Scenario } from "models";
 import { Document, Types } from "mongoose";
@@ -88,7 +88,8 @@ async function getMeta(instanceId: Types.ObjectId) {
 
 async function saveResults(
   submission: OngoingSubmissionDocument,
-  errors: string[]
+  errors: string[],
+  meta: { timeTaken: number }
 ) {
   log.info("Saving results");
   for (const outdated of await OngoingSubmission.find({
@@ -109,6 +110,7 @@ async function saveResults(
       errors,
       isValidationRun: true,
       outcome: (errors.length ? "invalid" : "valid") satisfies Outcome,
+      ...meta,
     } satisfies OngoingSubmission[typeof validationResultsKey])
     .save();
   log.info("Results saved");
@@ -145,7 +147,7 @@ async function validateGroup({
   const errorAgents: number[][] = [];
 
   const [updateSolutionCost, , realCost] = createSolutionCostChecker();
-
+  const timeStart = now();
   validate({
     domain: { cells, width, height },
     paths: submission.solutions.map((s) => s || "w"),
@@ -166,14 +168,16 @@ async function validateGroup({
     },
   });
 
+  const timeTaken = now() - timeStart;
+
   // Update solution cost based on validation results
   // TODO: Refactor for immutability
   await setSolutionCost(submission, realCost.current, errors);
 
   logOutcome(errors, errorAgents, mode);
 
   // Don't have to wait to save results
-  saveResults(submission, errors);
+  saveResults(submission, errors, { timeTaken });
   return { errors };
 }