@gridspace/raster-path 1.0.4 → 1.0.5

package/src/shaders/workload-calibrate.wgsl

@@ -0,0 +1,106 @@
+// Workload Calibration Shader
+// Tests GPU watchdog limits by doing configurable amount of work per thread
+
+struct Uniforms {
+    workgroup_size_x: u32,
+    workgroup_size_y: u32,
+    workgroup_size_z: u32,
+    triangle_tests: u32,  // How many intersection tests to run
+}
+
+@group(0) @binding(0) var<storage, read_write> completion_flags: array<u32>;
+@group(0) @binding(1) var<uniform> uniforms: Uniforms;
+
+// Ray-triangle intersection using Möller-Trumbore algorithm
+// This is the actual production code - same ALU/cache characteristics
+fn ray_triangle_intersect(
+    ray_origin: vec3<f32>,
+    ray_dir: vec3<f32>,
+    v0: vec3<f32>,
+    v1: vec3<f32>,
+    v2: vec3<f32>
+) -> vec2<f32> {  // Returns (hit: 0.0 or 1.0, z: intersection_z)
+    let EPSILON = 0.0001;
+
+    // Calculate edges
+    let edge1 = v1 - v0;
+    let edge2 = v2 - v0;
+
+    // Cross product: ray_dir × edge2
+    let h = cross(ray_dir, edge2);
+
+    // Dot product: edge1 · h
+    let a = dot(edge1, h);
+
+    // Check if ray is parallel to triangle
+    if (abs(a) < EPSILON) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let f = 1.0 / a;
+    let s = ray_origin - v0;
+    let u = f * dot(s, h);
+
+    // Check if intersection is outside triangle (u parameter)
+    if (u < 0.0 || u > 1.0) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    let q = cross(s, edge1);
+    let v = f * dot(ray_dir, q);
+
+    // Check if intersection is outside triangle (v parameter)
+    if (v < 0.0 || u + v > 1.0) {
+        return vec2<f32>(0.0, 0.0);
+    }
+
+    // Calculate intersection point along ray
+    let t = f * dot(edge2, q);
+
+    if (t > EPSILON) {
+        // Ray hit triangle
+        let intersection_z = ray_origin.z + t * ray_dir.z;
+        return vec2<f32>(1.0, intersection_z);
+    }
+
+    return vec2<f32>(0.0, 0.0);
+}
+
+@compute @workgroup_size(16, 16, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let thread_index = global_id.z * (uniforms.workgroup_size_x * uniforms.workgroup_size_y) +
+                       global_id.y * uniforms.workgroup_size_x +
+                       global_id.x;
+
+    // Synthetic triangle vertices (deterministic, no memory reads needed)
+    let v0 = vec3<f32>(0.0, 0.0, 0.0);
+    let v1 = vec3<f32>(1.0, 0.0, 0.0);
+    let v2 = vec3<f32>(0.5, 1.0, 0.0);
+
+    // Ray parameters based on thread ID (deterministic)
+    let ray_origin = vec3<f32>(
+        f32(global_id.x) * 0.1,
+        f32(global_id.y) * 0.1,
+        10.0
+    );
+    let ray_dir = vec3<f32>(0.0, 0.0, -1.0);
+
+    // Perform N intersection tests (configurable workload)
+    var hit_count = 0u;
+    for (var i = 0u; i < uniforms.triangle_tests; i++) {
+        // Slightly vary triangle vertices to prevent compiler optimization
+        let offset = f32(i) * 0.001;
+        let v0_offset = v0 + vec3<f32>(offset, 0.0, 0.0);
+        let v1_offset = v1 + vec3<f32>(0.0, offset, 0.0);
+        let v2_offset = v2 + vec3<f32>(offset, offset, 0.0);
+
+        let result = ray_triangle_intersect(ray_origin, ray_dir, v0_offset, v1_offset, v2_offset);
+        if (result.x > 0.5) {
+            hit_count += 1u;
+        }
+    }
+
+    // Write completion flag (1 = thread completed all work)
+    // If this thread was killed by watchdog, this write never happens (stays 0)
+    completion_flags[thread_index] = 1u;
+}

package/src/test/calibrate-test.cjs

@@ -0,0 +1,136 @@
+// calibrate-test.cjs
+// Test GPU workload calibration
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== GPU Workload Calibration Test ===');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+                console.log('✓ WebGPU available');
+
+                // Import RasterPath
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Create RasterPath instance (initializes worker)
+                console.log('\\nInitializing worker...');
+                const raster = new RasterPath({ mode: 'planar', resolution: 0.1 });
+                await raster.init();
+                console.log('✓ Worker initialized');
+
+                // Send calibration request
+                console.log('\\nRunning GPU dispatch count calibration...');
+                console.log('This will test how many workgroups can be dispatched simultaneously.');
+
+                const startTime = performance.now();
+
+                // Send calibrate message to worker
+                const calibrationPromise = new Promise((resolve, reject) => {
+                    const handler = raster.worker.onmessage;
+                    raster.worker.onmessage = (e) => {
+                        if (e.data.type === 'calibrate-complete') {
+                            resolve(e.data.data);
+                        } else if (e.data.type === 'error') {
+                            reject(new Error(e.data.message));
+                        } else {
+                            handler(e); // Pass through other messages
+                        }
+                    };
+                });
+
+                raster.worker.postMessage({
+                    type: 'calibrate',
+                    data: {
+                        calibrationType: 'dispatch',
+                        options: {
+                            workgroupSize: [4, 4, 1],    // VERY SMALL workgroup (16 threads)
+                            triangleTests: 1000,
+                            minDispatch: 1,
+                            maxDispatch: 1000,
+                            verbose: true,
+                        }
+                    }
+                });
+
+                const results = await calibrationPromise;
+                const elapsed = performance.now() - startTime;
+
+                console.log('\\n✓ Calibration complete in', elapsed.toFixed(0) + 'ms');
+                console.log('\\n=== Results ===');
+                console.log('Max safe dispatch count:', results.maxSafeDispatchCount.toLocaleString());
+                console.log('Workgroup size:', results.workgroupSize.join('x'));
+                console.log('Triangle tests per thread:', results.triangleTests.toLocaleString());
+
+                const maxThreads = results.maxSafeDispatchCount * results.workgroupSize[0] * results.workgroupSize[1] * results.workgroupSize[2];
+                const maxTests = maxThreads * results.triangleTests;
+                console.log('\\nMax concurrent threads:', maxThreads.toLocaleString());
+                console.log('Max total ray tests:', maxTests.toLocaleString());
+
+                console.log('\\n=== Dispatch Test Results ===');
+                for (const entry of results.results) {
+                    const status = entry.success ? '✓' : '❌';
+                    const threads = entry.totalThreads.toLocaleString();
+                    const time = entry.elapsed.toFixed(1);
+                    const failed = entry.failedThreads > 0 ? \` (\${entry.failedThreads} failed)\` : '';
+                    console.log(\`  \${status} \${entry.dispatchCount.toString().padStart(6)} workgroups: \${threads.padStart(10)} threads in \${time.padStart(7)}ms\${failed}\`);
+                }
+
+                return { success: true, results };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+            } else if (!result.success) {
+                console.error('❌ Test returned unsuccessful result');
+                app.exit(1);
+            } else {
+                console.log('\n✅ Calibration test complete');
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('❌ Test error:', error);
+            app.exit(1);
+        }
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        console.log(message);
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        app.quit();
+    }
+});

package/src/test/extreme-work-test.cjs

@@ -0,0 +1,167 @@
+// extreme-work-test.cjs
+// Test if there's ANY per-thread compute limit by pushing to extreme levels
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Extreme Per-Thread Work Test ===');
+                console.log('Testing if there is ANY limit to work per thread...\\n');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+
+                const { RasterPath } = await import('./raster-path.js');
+
+                const raster = new RasterPath({ mode: 'planar', resolution: 0.1 });
+                await raster.init();
+
+                // Test progressively larger workloads on a SINGLE 16x16x1 workgroup (256 threads)
+                const testLevels = [
+                    { tests: 1_000_000_000, label: '1 billion' },
+                    { tests: 2_000_000_000, label: '2 billion' },
+                    { tests: 5_000_000_000, label: '5 billion' },
+                    { tests: 10_000_000_000, label: '10 billion' },
+                ];
+
+                const results = [];
+
+                for (const level of testLevels) {
+                    console.log(\`Testing \${level.label} tests/thread (\${level.tests.toLocaleString()})...\`);
+
+                    const calibrationPromise = new Promise((resolve, reject) => {
+                        const timeout = setTimeout(() => {
+                            reject(new Error('Test timed out after 30s'));
+                        }, 30000);
+
+                        const handler = raster.worker.onmessage;
+                        raster.worker.onmessage = (e) => {
+                            if (e.data.type === 'calibrate-complete') {
+                                clearTimeout(timeout);
+                                resolve(e.data.data);
+                            } else if (e.data.type === 'error') {
+                                clearTimeout(timeout);
+                                reject(new Error(e.data.message));
+                            } else {
+                                handler(e);
+                            }
+                        };
+                    });
+
+                    const startTime = performance.now();
+
+                    raster.worker.postMessage({
+                        type: 'calibrate',
+                        data: {
+                            calibrationType: 'workgroup',
+                            options: {
+                                workgroupSizes: [[16, 16, 1]],
+                                minWork: level.tests,
+                                maxWork: level.tests,
+                                verbose: false,
+                            }
+                        }
+                    });
+
+                    try {
+                        const result = await calibrationPromise;
+                        const elapsed = performance.now() - startTime;
+                        const success = result.safeWorkloadMatrix[0]?.maxWork === level.tests;
+
+                        const status = success ? '✓' : '❌';
+                        const totalTests = (level.tests * 256).toLocaleString();
+                        console.log(\`  \${status} \${level.label}: \${elapsed.toFixed(0)}ms (\${totalTests} total tests)\\n\`);
+
+                        results.push({
+                            tests: level.tests,
+                            label: level.label,
+                            success,
+                            elapsed,
+                        });
+
+                        if (!success) {
+                            console.log('Found failure point - stopping test.');
+                            break;
+                        }
+                    } catch (error) {
+                        console.log(\`  ❌ \${level.label}: FAILED - \${error.message}\\n\`);
+                        results.push({
+                            tests: level.tests,
+                            label: level.label,
+                            success: false,
+                            error: error.message,
+                        });
+                        break;
+                    }
+                }
+
+                console.log('\\n=== Summary ===');
+                for (const r of results) {
+                    const status = r.success ? '✓' : '❌';
+                    const time = r.elapsed ? \` in \${r.elapsed.toFixed(0)}ms\` : '';
+                    const err = r.error ? \` - \${r.error}\` : '';
+                    console.log(\`\${status} \${r.label}\${time}\${err}\`);
+                }
+
+                const maxSuccess = results.filter(r => r.success).pop();
+                if (maxSuccess) {
+                    console.log(\`\\nMax verified work per thread: \${maxSuccess.label} (\${maxSuccess.tests.toLocaleString()} tests)\`);
+                    console.log('Conclusion: No practical per-thread compute limit detected');
+                } else {
+                    console.log('\\nFound per-thread compute limit');
+                }
+
+                return { success: true, results };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+            } else {
+                console.log('\n✅ Extreme work test complete');
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('❌ Test error:', error);
+            app.exit(1);
+        }
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        console.log(message);
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        app.quit();
+    }
+});

package/src/test/radial-thread-limit-test.cjs

@@ -0,0 +1,152 @@
+// radial-thread-limit-test.cjs
+// Test that radial rasterization respects thread limits and produces correct output
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Radial Thread Limit Test ===\\n');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Read test STL
+                const stlPath = '${path.join(__dirname, '../../benchmark/fixtures/lathe-cylinder.stl')}';
+                const response = await fetch('file://' + stlPath);
+                if (!response.ok) {
+                    return { error: 'Failed to load test STL: ' + stlPath };
+                }
+                const arrayBuffer = await response.arrayBuffer();
+
+                // Test with different thread limits
+                const threadLimits = [
+                    { limit: 256, desc: 'Default limit (256 threads)' },
+                    { limit: 128, desc: 'Reduced limit (128 threads)' },
+                    { limit: 64, desc: 'Very low limit (64 threads)' },
+                ];
+
+                const results = [];
+
+                for (const config of threadLimits) {
+                    console.log(\`Testing: \${config.desc}\`);
+
+                    const raster = new RasterPath({
+                        mode: 'radial',
+                        resolution: 0.5,
+                        rotationStep: 1.0,
+                        toolWidth: 5.0,
+                        maxConcurrentThreads: config.limit
+                    });
+
+                    await raster.init();
+
+                    const startTime = performance.now();
+                    const result = await raster.processSTL(arrayBuffer);
+                    const elapsed = performance.now() - startTime;
+
+                    // Calculate checksum
+                    let checksum = 0;
+                    for (const strip of result.strips) {
+                        for (let i = 0; i < strip.pathData.length; i++) {
+                            checksum = (checksum * 31 + strip.pathData[i]) | 0;
+                        }
+                    }
+
+                    console.log(\`  Time: \${elapsed.toFixed(1)}ms\`);
+                    console.log(\`  Strips: \${result.strips.length}\`);
+                    console.log(\`  Checksum: \${checksum}\`);
+                    console.log('');
+
+                    results.push({
+                        limit: config.limit,
+                        desc: config.desc,
+                        time: elapsed,
+                        strips: result.strips.length,
+                        checksum,
+                    });
+                }
+
+                // Verify all checksums match
+                const referenceChecksum = results[0].checksum;
+                const allMatch = results.every(r => r.checksum === referenceChecksum);
+
+                console.log('=== Results ===');
+                console.log(\`Reference checksum: \${referenceChecksum}\`);
+                console.log(\`All checksums match: \${allMatch ? '✓ YES' : '❌ NO'}\`);
+
+                if (!allMatch) {
+                    console.log('\\nChecksum mismatches:');
+                    for (const r of results) {
+                        if (r.checksum !== referenceChecksum) {
+                            console.log(\`  \${r.desc}: \${r.checksum} (expected \${referenceChecksum})\`);
+                        }
+                    }
+                }
+
+                console.log('\\nTiming comparison:');
+                const baselineTime = results[0].time;
+                for (const r of results) {
+                    const ratio = (r.time / baselineTime).toFixed(2);
+                    console.log(\`  \${r.desc}: \${r.time.toFixed(1)}ms (\${ratio}x)\`);
+                }
+
+                return { success: allMatch, results };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('❌ Test failed:', result.error);
+                app.exit(1);
+            } else if (!result.success) {
+                console.error('❌ Thread limit test failed - checksums do not match');
+                app.exit(1);
+            } else {
+                console.log('\\n✅ Thread limit test passed - all configurations produce identical output');
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('❌ Test error:', error);
+            app.exit(1);
+        }
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        console.log(message);
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        app.quit();
+    }
+});

package/src/web/index.html

@@ -125,6 +125,6 @@
     }
     </script>
     <script type="module" src="app.js"></script>
-    <!-- <script type="module" src="webgpu-worker.js"></script> -->
+    <!-- <script type="module" src="raster-worker.js"></script> -->
 </body>
 </html>