stuff

Author: YannicEl

packages/app/src/routes/app/(canvas)/+page.svelte

@@ -10,6 +10,7 @@
 	import { EdgePathBundlingGPUFloydWarshall } from '@bachelor/core/edge-path-bundling/floyd-warshall/gpu';
 	import { onMount } from 'svelte';
 	import { ThetaSpanner } from '@bachelor/core/spanner/theta/gpu';
+	import { GreedySpanner } from '@bachelor/core/spanner/greedy/gpu';
 
 	const { device } = getWebGPUState();
 	const { canvas, context } = getCanvasState();
@@ -52,9 +53,9 @@
 		epb = new EdgePathBundlingGPUFloydWarshall({
 			device,
 			graph,
-			maxDistortion: 128,
+			maxDistortion,
 			edgeWeightFactor,
-			spannerAlgorithm: ThetaSpanner,
+			spannerAlgorithm: GreedySpanner,
 		});
 
 		runGPU();

packages/app/src/routes/app/(canvas)/spanner/+page.svelte

@@ -37,17 +37,21 @@
 		const graph = await loadGraph(selectedGraph);
 
 		greedy = new GreedySpanner({ graph, device, maxDistortion: 2 });
-		theta = new ThetaSpanner({ graph, device, maxDistortion: 128 });
+		theta = new ThetaSpanner({ graph, device, maxDistortion: 2 });
 
 		runGPU();
 	});
 
 	async function runGPU() {
 		if (!greedy || !theta) return;
 
-		// console.time('greedy');
-		// const greedySpanner = await greedy.compute();
-		// console.timeEnd('greedy');
+		const graph = await loadGraph(selectedGraph);
+
+		greedy = new GreedySpanner({ graph, device, maxDistortion: 2 });
+
+		console.time('greedy');
+		const greedySpanner = await greedy.compute();
+		console.timeEnd('greedy');
 
 		console.time('theta');
 		const thetaSpanner = await theta.compute();
@@ -64,8 +68,8 @@
 		// const isSame = JSON.stringify(spannerControl.toJSON()) === JSON.stringify(lol.toJSON());
 		// console.log({ isSame });
 
-		console.log(thetaSpanner);
-		drawGraph({ ctx: context, graph: thetaSpanner, drawLabels: false });
+		console.log({ spannerControl });
+		drawGraph({ ctx: context, graph: greedySpanner, drawLabels: false });
 	}
 </script>
 

packages/core/src/edge-path-bundling/floyd-warshall/gpu.ts

@@ -36,9 +36,7 @@ export class EdgePathBundlingGPUFloydWarshall implements EdgePathBundling {
 	}
 
 	async bundle() {
-		if (!this.#spanner?.graph) {
-			await this.#spanner.compute();
-		}
+		await this.#spanner.compute();
 
 		if (this.#maxDistortion !== this.#spanner.maxDistortion) {
 			console.log('Max distortion changed. Recomputing Spanner');

packages/core/src/shortest-path/floyd-warshall/FloydWarshall.ts

@@ -9,13 +9,16 @@ import shader from './shader.wgsl?raw';
 export type FloydWarshallParams = {
 	graph: Graph;
 	device: GPUDevice;
-	edgeWeightFactor?: number;
+	edgeWeightFactor: number;
 };
 
 export class FloydWarshall {
 	#device: GPUDevice;
+
 	#graph: Graph;
 
+	#edgeWeightFactor: number;
+
 	#shaderModule: GPUShaderModule;
 	#pipeline: GPUComputePipeline;
 	#bindGroup: GPUBindGroup;
@@ -34,11 +37,13 @@ export class FloydWarshall {
 
 	#pathsBufferCache: Map<number, GPUBuffer>;
 
-	constructor({ graph, device, edgeWeightFactor = 1 }: FloydWarshallParams) {
+	constructor({ graph, device, edgeWeightFactor }: FloydWarshallParams) {
 		this.#device = device;
 
 		this.#graph = graph;
 
+		this.#edgeWeightFactor = edgeWeightFactor;
+
 		this.#pathsBufferCache = new Map();
 
 		this.distanceMatrix = new AdjacencyMatrix(graph.nodes.size, Float32Array);
@@ -341,4 +346,8 @@ export class FloydWarshall {
 			data: this.#uniformsBufferData,
 		});
 	}
+
+	get edgeWeightFactor() {
+		return this.#edgeWeightFactor;
+	}
 }

packages/core/src/spanner/greedy/_shader.wgsl

@@ -0,0 +1,61 @@
+struct Edge {
+  start: u32,
+  end: u32,
+  weight: f32,
+}
+
+struct Uniforms {
+  k: u32,
+  max_distortion: f32,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var<storage, read_write> distance_matrix: array<f32>;
+@group(0) @binding(2) var<storage, read_write> distance_matrix_a: array<f32>;
+@group(0) @binding(3) var<storage, read> graph_edges: array<Edge>;
+@group(0) @binding(4) var<storage, read_write> spanner_edges: array<u32>;
+
+override node_count: u32;
+
+@compute @workgroup_size(8, 8)
+fn compute(
+  @builtin(global_invocation_id) global_id : vec3<u32>,
+) {
+  let x = global_id.x;
+  let y = global_id.y;
+  let n = node_count;
+
+  if (x >= n || y >= n) {
+    let lol = spanner_edges[uniforms.k];
+    let lol2 = distance_matrix_a[0];
+    return;
+  }
+
+  let edge = graph_edges[uniforms.k];
+
+  var value = min(
+    distance_matrix_get(x, y), 
+    distance_matrix_get(x, edge.start) + edge.weight + distance_matrix_get(edge.end, y)
+  );
+
+  value = min(
+    value, 
+    distance_matrix_get(x, edge.end) + edge.weight + distance_matrix_get(edge.start, y)
+  );
+
+  distance_matrix_set(x, y, value);
+}
+
+// Matrix getters and setters
+
+fn distance_matrix_get(x: u32, y: u32) -> f32 {
+  return distance_matrix[get_matrix_index(x, y)];
+}
+
+fn distance_matrix_set(x: u32, y: u32, value: f32) {
+  distance_matrix[get_matrix_index(x, y)] = value;
+}
+
+fn get_matrix_index(x: u32, y: u32) -> u32 {
+  return x * node_count + y;
+}