@osmix/router 0.0.9 → 0.0.10

package/test/router.bench.ts

@@ -0,0 +1,257 @@
+import { Osm } from "@osmix/core"
+import { getFixtureFile, PBFs } from "@osmix/shared/fixtures"
+import { bench, group, run } from "mitata"
+import { fromPbf } from "osmix"
+import { buildGraph } from "../src"
+import { Router } from "../src/router"
+
+/**
+ * Router Benchmark Suite using mitata
+ *
+ * Run with: bun test/router.bench.ts
+ *
+ * These benchmarks compare the performance of different routing algorithms
+ * using both real-world OSM data (Monaco) and synthetic grid networks.
+ */
+
+// ---------------------------------------------------------------------------
+// Synthetic Grid Helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a synthetic grid network for benchmarking.
+ *
+ * The grid consists of nodes arranged in a square pattern with
+ * horizontal and vertical ways connecting adjacent nodes.
+ *
+ * @param size - Number of nodes in each dimension (size x size total)
+ * @param spacing - Spacing between nodes in degrees (~100m per 0.001)
+ */
+function createSyntheticGrid(size: number, spacing: number): Osm {
+	const osm = new Osm({ id: "synthetic-grid" })
+
+	// Create nodes in a grid pattern
+	for (let row = 0; row < size; row++) {
+		for (let col = 0; col < size; col++) {
+			const nodeId = row * size + col + 1
+			osm.nodes.addNode({
+				id: nodeId,
+				lat: row * spacing,
+				lon: col * spacing,
+			})
+		}
+	}
+
+	osm.nodes.buildIndex()
+	osm.nodes.buildSpatialIndex()
+
+	// Create horizontal ways (connecting nodes in each row)
+	let wayId = 1
+	for (let row = 0; row < size; row++) {
+		const refs: number[] = []
+		for (let col = 0; col < size; col++) {
+			refs.push(row * size + col + 1)
+		}
+		osm.ways.addWay({
+			id: wayId++,
+			refs,
+			tags: { highway: "residential" },
+		})
+	}
+
+	// Create vertical ways (connecting nodes in each column)
+	for (let col = 0; col < size; col++) {
+		const refs: number[] = []
+		for (let row = 0; row < size; row++) {
+			refs.push(row * size + col + 1)
+		}
+		osm.ways.addWay({
+			id: wayId++,
+			refs,
+			tags: { highway: "residential" },
+		})
+	}
+
+	osm.ways.buildIndex()
+	osm.ways.buildSpatialIndex()
+	osm.buildIndexes()
+
+	return osm
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+console.log("Setting up benchmark data...")
+
+// Load Monaco PBF
+const monacoPbf = PBFs["monaco"]!
+const pbfData = await getFixtureFile(monacoPbf.url)
+const monacoOsm = await fromPbf(pbfData, {
+	buildSpatialIndexes: ["node", "way"],
+})
+const monacoGraph = buildGraph(monacoOsm)
+const monacoRouter = new Router(monacoOsm, monacoGraph)
+
+// Create synthetic grid
+const GRID_SIZE = 50
+const GRID_SPACING = 0.001
+const gridOsm = createSyntheticGrid(GRID_SIZE, GRID_SPACING)
+const gridGraph = buildGraph(gridOsm)
+const gridRouter = new Router(gridOsm, gridGraph)
+
+// Pre-snap coordinates to node indexes for benchmarking
+const monacoShortFrom = monacoGraph.findNearestRoutableNode(
+	monacoOsm,
+	[7.42, 43.735],
+	500,
+)!.nodeIndex
+const monacoShortTo = monacoGraph.findNearestRoutableNode(
+	monacoOsm,
+	[7.425, 43.738],
+	500,
+)!.nodeIndex
+const monacoLongFrom = monacoGraph.findNearestRoutableNode(
+	monacoOsm,
+	[7.41, 43.725],
+	500,
+)!.nodeIndex
+const monacoLongTo = monacoGraph.findNearestRoutableNode(
+	monacoOsm,
+	[7.44, 43.745],
+	500,
+)!.nodeIndex
+
+const gridShortFrom = gridGraph.findNearestRoutableNode(
+	gridOsm,
+	[0.01, 0.01],
+	200,
+)!.nodeIndex
+const gridShortTo = gridGraph.findNearestRoutableNode(
+	gridOsm,
+	[0.015, 0.015],
+	200,
+)!.nodeIndex
+const gridLongFrom = gridGraph.findNearestRoutableNode(
+	gridOsm,
+	[0, 0],
+	200,
+)!.nodeIndex
+const gridLongTo = gridGraph.findNearestRoutableNode(
+	gridOsm,
+	[(GRID_SIZE - 1) * GRID_SPACING, (GRID_SIZE - 1) * GRID_SPACING],
+	200,
+)!.nodeIndex
+
+console.log("Setup complete. Running benchmarks...\n")
+
+// ---------------------------------------------------------------------------
+// Monaco PBF Benchmarks
+// ---------------------------------------------------------------------------
+
+group("Monaco - Short Distance (~500m)", () => {
+	bench("Dijkstra", () => {
+		monacoRouter.route(monacoShortFrom, monacoShortTo, {
+			algorithm: "dijkstra",
+		})
+	})
+
+	bench("A*", () => {
+		monacoRouter.route(monacoShortFrom, monacoShortTo, {
+			algorithm: "astar",
+		})
+	})
+
+	bench("Bidirectional", () => {
+		monacoRouter.route(monacoShortFrom, monacoShortTo, {
+			algorithm: "bidirectional",
+		})
+	})
+})
+
+group("Monaco - Long Distance (~2km)", () => {
+	bench("Dijkstra", () => {
+		monacoRouter.route(monacoLongFrom, monacoLongTo, {
+			algorithm: "dijkstra",
+		})
+	})
+
+	bench("A*", () => {
+		monacoRouter.route(monacoLongFrom, monacoLongTo, {
+			algorithm: "astar",
+		})
+	})
+
+	bench("Bidirectional", () => {
+		monacoRouter.route(monacoLongFrom, monacoLongTo, {
+			algorithm: "bidirectional",
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// Synthetic Grid Benchmarks
+// ---------------------------------------------------------------------------
+
+group("Grid 50x50 - Short Path", () => {
+	bench("Dijkstra", () => {
+		gridRouter.route(gridShortFrom, gridShortTo, {
+			algorithm: "dijkstra",
+		})
+	})
+
+	bench("A*", () => {
+		gridRouter.route(gridShortFrom, gridShortTo, {
+			algorithm: "astar",
+		})
+	})
+
+	bench("Bidirectional", () => {
+		gridRouter.route(gridShortFrom, gridShortTo, {
+			algorithm: "bidirectional",
+		})
+	})
+})
+
+group("Grid 50x50 - Long Path (corner to corner)", () => {
+	bench("Dijkstra", () => {
+		gridRouter.route(gridLongFrom, gridLongTo, {
+			algorithm: "dijkstra",
+		})
+	})
+
+	bench("A*", () => {
+		gridRouter.route(gridLongFrom, gridLongTo, {
+			algorithm: "astar",
+		})
+	})
+
+	bench("Bidirectional", () => {
+		gridRouter.route(gridLongFrom, gridLongTo, {
+			algorithm: "bidirectional",
+		})
+	})
+})
+
+// ---------------------------------------------------------------------------
+// Router Initialization Benchmarks
+// ---------------------------------------------------------------------------
+
+group("Router Initialization", () => {
+	bench("Monaco OSM (14k nodes, 3k ways)", () => {
+		new Router(monacoOsm, buildGraph(monacoOsm))
+	})
+
+	bench("Grid 50x50 (2.5k nodes)", () => {
+		new Router(gridOsm, buildGraph(gridOsm))
+	})
+})
+
+// ---------------------------------------------------------------------------
+// Run benchmarks
+// ---------------------------------------------------------------------------
+
+await run({
+	colors: true,
+})