stuff

Author: YannicEl

packages/app/src/routes/app/spanner/+page.svelte

@@ -9,6 +9,7 @@
 	import { goto } from '$app/navigation';
 	import { GreedySpanner } from '@bachelor/core/spanner/gpu';
 	import { onMount } from 'svelte';
+	import { drawGraph } from '$lib/_canvas';
 
 	const { device } = getWebGPUState();
 	const { canvas, context } = getCanvasState();
@@ -26,7 +27,7 @@
 	onMount(async () => {
 		const graph = await loadGraph(selectedGraph);
 
-		spanner = new GreedySpanner({ graph, device, maxDistortion });
+		spanner = new GreedySpanner({ graph, device });
 
 		runGPU();
 	});
@@ -35,20 +36,21 @@
 		if (!spanner) return;
 
 		console.time('Spanner');
-		const lol = await spanner.compute();
+		const graph = await spanner.compute();
 		console.timeEnd('Spanner');
 
+		const graphControl = await loadGraph(selectedGraph);
 		const spannerControl = await loadSpanner(selectedGraph);
-		console.log(spannerControl);
-		console.log(JSON.stringify(spannerControl.toJSON()));
+		// console.log(spannerControl);
+		// console.log(JSON.stringify(spannerControl.toJSON()));
 
-		console.log(lol);
-		console.log(JSON.stringify(lol.toJSON()));
+		// console.log(lol);
+		// console.log(JSON.stringify(lol.toJSON()));
 
-		const isSame = JSON.stringify(spannerControl.toJSON()) === JSON.stringify(lol.toJSON());
-		console.log({ isSame });
+		// const isSame = JSON.stringify(spannerControl.toJSON()) === JSON.stringify(lol.toJSON());
+		// console.log({ isSame });
 
-		drawGraphAndBundledEdges({ ctx: context, graph: lol, bundeledEdges: [] });
+		drawGraph({ ctx: context, graph: spannerControl, drawLabels: false });
 	}
 </script>
 

packages/core/src/GPUBuffer.ts

@@ -2,18 +2,21 @@ import type { BufferData } from './BufferData';
 
 export type CreateGPUBufferParams = {
 	device: GPUDevice;
+	label?: string;
 	data: BufferData;
 	usage: GPUBufferUsageFlags;
 	write?: boolean;
 };
 
 export function createGPUBuffer({
 	device,
+	label,
 	data,
 	usage,
 	write = true,
 }: CreateGPUBufferParams): GPUBuffer {
 	const buffer = device.createBuffer({
+		label,
 		size: data.buffer.byteLength,
 		usage,
 	});

packages/core/src/spanner/_gpu.ts

@@ -0,0 +1,85 @@
+import { Graph } from '../AdjacencyList';
+import { AdjacencyMatrix } from '../AdjacencyMatrix';
+import { FloydWarshall } from '../shortest-path/floyd-warshall/FloydWarshall';
+
+export type GreedySpannerParams = {
+	device: GPUDevice;
+	graph: Graph;
+	maxDistortion: number;
+};
+
+export class GreedySpanner {
+	graph: Graph;
+	maxDistortion: number;
+	#device: GPUDevice;
+	#floydWarshall: FloydWarshall;
+
+	constructor({ device, graph, maxDistortion }: GreedySpannerParams) {
+		this.graph = graph;
+		this.maxDistortion = maxDistortion;
+		this.#device = device;
+
+		this.#floydWarshall = new FloydWarshall({
+			device,
+			graph: this.graph,
+		});
+	}
+
+	async compute() {
+		await this.#floydWarshall.init();
+		console.time('Floyd Warshall');
+		await this.#floydWarshall.compute(true);
+		console.timeEnd('Floyd Warshall');
+
+		const spanner = new Graph();
+		this.graph.nodes.forEach((node) => {
+			spanner.addNode(node);
+		});
+
+		console.log(this.maxDistortion);
+		const distanceMatrix = new AdjacencyMatrix(
+			this.#floydWarshall.distanceMatrix.size,
+			Float32Array
+		);
+
+		for (let x = 0; x < distanceMatrix.size; x++) {
+			for (let y = 0; y < distanceMatrix.size; y++) {
+				distanceMatrix.set(x, y, x === y ? 0 : Infinity);
+			}
+		}
+		const sortedEdges = Array.from(this.graph.edges)
+			.map(([_, edge]) => edge)
+			.sort((a, b) => a.weight - b.weight);
+
+		let skipped = 0;
+		for (const edge of sortedEdges) {
+			console.log(
+				edge.weight.toFixed(3) ===
+					this.#floydWarshall.distanceMatrix.get(edge.start, edge.end).toFixed(3)
+			);
+			if (
+				distanceMatrix.get(edge.start, edge.end) >
+				this.maxDistortion * this.#floydWarshall.distanceMatrix.get(edge.start, edge.end)
+			) {
+				spanner.addEdge(edge);
+
+				for (let x = 0; x < distanceMatrix.size; x++) {
+					for (let y = 0; y < distanceMatrix.size; y++) {
+						const weight = Math.min(
+							distanceMatrix.get(x, y),
+							distanceMatrix.get(x, edge.start) + edge.weight + distanceMatrix.get(edge.end, y),
+							distanceMatrix.get(x, edge.end) + edge.weight + distanceMatrix.get(edge.start, y)
+						);
+						distanceMatrix.set(x, y, weight);
+					}
+				}
+			} else {
+				skipped++;
+			}
+		}
+
+		console.log({ skipped });
+		console.log({ skippedPercentage: (skipped / sortedEdges.length) * 100 });
+		return spanner;
+	}
+}

packages/core/src/spanner/_greedy.ts

@@ -0,0 +1,28 @@
+import { Edge } from '../Edge';
+import { Graph } from '../Graph';
+import { dijkstra } from '../shortest-path/dijkstra/cpu';
+
+export function greedySpanner(graph: Graph, stretchFactor = 2): Graph {
+	console.time('Greedy Spanner');
+	const spanner = new Graph(graph.nodes, []).clone();
+
+	const edges = Array.from(graph.edges).sort(([_1, a], [_2, b]) => a.weight - b.weight);
+
+	let i = 0;
+	for (const [id, edge] of edges) {
+		console.log(`Processing spanner edge ${i} of ${edges.length} edges`);
+		const shortestPath = dijkstra(spanner, edge.start, edge.end);
+
+		if (shortestPath === null || shortestPath.length > edge.weight * stretchFactor) {
+			const start = spanner.nodes.get(edge.start.id)!;
+			const end = spanner.nodes.get(edge.end.id)!;
+			const newEdge = new Edge(start, end);
+			spanner.edges.set(id, newEdge);
+		}
+
+		i++;
+	}
+
+	console.timeEnd('Greedy Spanner');
+	return spanner;
+}