@gridspace/raster-path 1.0.3 → 1.0.5

package/src/shaders/{radial-raster-v2.wgsl → radial-raster.wgsl}

@@ -17,6 +17,7 @@ struct Uniforms {
     filter_mode: u32,          // 0 = max Z (terrain), 1 = min Z (tool)
     num_buckets: u32,          // Total number of X-buckets
     start_angle: f32,          // Starting angle offset in radians (for batching)
+    bucket_offset: u32,        // Offset for bucket batching (bucket_idx in batch writes to bucket_offset + bucket_idx in output)
 }
 
 struct BucketInfo {
@@ -125,6 +126,10 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
 
         // Step 2: Rotate position (scan_x, scan_y, scan_z) around X-axis by 'angle'
         // X stays the same, rotate YZ plane: y' = y*cos - z*sin, z' = y*sin + z*cos
+        // NOTE: This uses right-handed rotation (positive angle rotates +Y towards +Z)
+        // To reverse rotation direction (left-handed or opposite), flip signs:
+        //   y' = y*cos + z*sin  (flip sign on z term)
+        //   z' = -y*sin + z*cos (flip sign on y term)
         let ray_origin_x = scan_x;
         let ray_origin_y = scan_y * cos(angle) - scan_z * sin(angle);
         let ray_origin_z = scan_y * sin(angle) + scan_z * cos(angle);
@@ -132,6 +137,7 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
 
         // Step 3: Rotate ray direction (0, 0, -1) around X-axis by 'angle'
         // X component stays 0, rotate YZ: dy = 0*cos - (-1)*sin = sin, dz = 0*sin + (-1)*cos = -cos
+        // NOTE: For reversed rotation, use: vec3<f32>(0.0, -sin(angle), -cos(angle))
         let ray_dir = vec3<f32>(0.0, sin(angle), -cos(angle));
 
         // Initialize best distance (closest hit)
@@ -174,11 +180,11 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
         }
 
         // Write output
-        // Layout: bucket_idx * numAngles * bucketWidth * gridHeight
+        // Layout: (bucket_offset + bucket_idx) * numAngles * bucketWidth * gridHeight
         //       + angle_idx * bucketWidth * gridHeight
         //       + grid_y * bucketWidth
         //       + local_x
-        let output_idx = bucket_idx * uniforms.num_angles * uniforms.bucket_grid_width * uniforms.grid_y_height
+        let output_idx = (uniforms.bucket_offset + bucket_idx) * uniforms.num_angles * uniforms.bucket_grid_width * uniforms.grid_y_height
                        + angle_idx * uniforms.bucket_grid_width * uniforms.grid_y_height
                        + grid_y * uniforms.bucket_grid_width
                        + local_x;

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/batch-divisor-benchmark.cjs

@@ -0,0 +1,286 @@
+// batch-divisor-benchmark.cjs
+// Benchmark test to measure batching overhead with different batch divisors
+// Usage: node batch-divisor-benchmark.cjs [divisor1,divisor2,...]
+// Example: node batch-divisor-benchmark.cjs 1,2,4,8,16,32
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+const RESULTS_FILE = path.join(OUTPUT_DIR, 'batch-divisor-results.json');
+
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+// Parse batch divisors from command line args or use defaults
+const args = process.argv.slice(2);
+const BATCH_DIVISORS = args.length > 0
+    ? args[0].split(',').map(n => parseInt(n.trim()))
+    : [1, 2, 4, 8, 16, 32];
+
+console.log('=== Batch Divisor Benchmark ===');
+console.log('Testing with divisors:', BATCH_DIVISORS.join(', '));
+console.log('');
+
+let mainWindow;
+let currentDivisorIndex = 0;
+const results = [];
+
+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');
+        await runNextTest();
+    });
+
+    // Capture console output from renderer process
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        // Filter for our timing logs
+        if (message.includes('Batch') && message.includes('timing:')) {
+            console.log('[TIMING]', message);
+        }
+    });
+}
+
+async function runNextTest() {
+    if (currentDivisorIndex >= BATCH_DIVISORS.length) {
+        // All tests complete - analyze and report
+        await analyzeResults();
+        return;
+    }
+
+    const divisor = BATCH_DIVISORS[currentDivisorIndex];
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`Testing with BATCH_DIVISOR = ${divisor}`);
+    console.log('='.repeat(60));
+
+    const testScript = `
+        (async function() {
+            const divisor = ${divisor};
+
+            if (!navigator.gpu) {
+                return { error: 'WebGPU not available' };
+            }
+
+            // Import RasterPath
+            const { RasterPath } = await import('./raster-path.js');
+
+            // Load STL files (same as radial-test.cjs - large enough to require batching)
+            const terrainResponse = await fetch('../benchmark/fixtures/terrain.stl');
+            const terrainBuffer = await terrainResponse.arrayBuffer();
+
+            const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+            const toolBuffer = await toolResponse.arrayBuffer();
+
+            // Parse STL files
+            function parseBinarySTL(buffer) {
+                const dataView = new DataView(buffer);
+                const numTriangles = dataView.getUint32(80, true);
+                const positions = new Float32Array(numTriangles * 9);
+                let offset = 84;
+
+                for (let i = 0; i < numTriangles; i++) {
+                    offset += 12; // Skip normal
+                    for (let j = 0; j < 9; j++) {
+                        positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                        offset += 4;
+                    }
+                    offset += 2; // Skip attribute byte count
+                }
+                return positions;
+            }
+
+            const terrainTriangles = parseBinarySTL(terrainBuffer);
+            const toolTriangles = parseBinarySTL(toolBuffer);
+
+            // Test parameters - configured to require batching
+            const resolution = 0.05; // 0.05mm - finer resolution to force batching
+            const rotationStep = 1.0; // 1 degree between rays = 360 angles
+            const xStep = 1;
+            const yStep = 1;
+            const zFloor = 0;
+            const radiusOffset = 20;
+
+            console.log('Test parameters:');
+            console.log('  Resolution:', resolution, 'mm');
+            console.log('  Rotation step:', rotationStep, '°');
+            console.log('  Batch divisor:', divisor);
+
+            // Create RasterPath instance with specific batch divisor
+            const raster = new RasterPath({
+                mode: 'radial',
+                resolution: resolution,
+                rotationStep: rotationStep,
+                batchDivisor: divisor
+            });
+            await raster.init();
+
+            // Load tool
+            const t0 = performance.now();
+            await raster.loadTool({ triangles: toolTriangles });
+            const toolTime = performance.now() - t0;
+
+            // Load terrain
+            const t1 = performance.now();
+            await raster.loadTerrain({ triangles: terrainTriangles, zFloor: zFloor });
+            const terrainTime = performance.now() - t1;
+
+            // Generate toolpaths (this is where batching happens)
+            const t2 = performance.now();
+            const toolpathData = await raster.generateToolpaths({
+                xStep: xStep,
+                yStep: yStep,
+                zFloor: zFloor,
+                radiusOffset: radiusOffset
+            });
+            const toolpathTime = performance.now() - t2;
+
+            // Cleanup
+            raster.terminate();
+
+            return {
+                success: true,
+                divisor: divisor,
+                timing: {
+                    tool: toolTime,
+                    terrain: terrainTime,
+                    toolpath: toolpathTime,
+                    total: toolTime + terrainTime + toolpathTime
+                },
+                result: {
+                    numStrips: toolpathData.numStrips,
+                    totalPoints: toolpathData.totalPoints
+                }
+            };
+        })();
+    `;
+
+    try {
+        const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+        if (result.error) {
+            console.error('❌ Test failed:', result.error);
+            app.exit(1);
+            return;
+        }
+
+        results.push(result);
+
+        console.log(`\nResults for BATCH_DIVISOR = ${divisor}:`);
+        console.log(`  Tool load time:      ${result.timing.tool.toFixed(1)}ms`);
+        console.log(`  Terrain load time:   ${result.timing.terrain.toFixed(1)}ms`);
+        console.log(`  Toolpath time:       ${result.timing.toolpath.toFixed(1)}ms`);
+        console.log(`  Total time:          ${result.timing.total.toFixed(1)}ms`);
+        console.log(`  Strips generated:    ${result.result.numStrips}`);
+        console.log(`  Total points:        ${result.result.totalPoints}`);
+
+        // Move to next test
+        currentDivisorIndex++;
+
+        // Small delay before next test to ensure clean state
+        setTimeout(() => runNextTest(), 1000);
+
+    } catch (error) {
+        console.error('Error running test:', error);
+        app.exit(1);
+    }
+}
+
+async function analyzeResults() {
+    console.log('\n' + '='.repeat(60));
+    console.log('ANALYSIS');
+    console.log('='.repeat(60));
+
+    // Save raw results
+    const resultsData = {
+        timestamp: new Date().toISOString(),
+        divisors: BATCH_DIVISORS,
+        results: results
+    };
+    fs.writeFileSync(RESULTS_FILE, JSON.stringify(resultsData, null, 2));
+    console.log(`\n✓ Raw results saved to: ${RESULTS_FILE}`);
+
+    // Analyze overhead
+    console.log('\n--- Timing Comparison ---');
+    const baseline = results[0]; // Divisor = 1
+    console.log(`\nBaseline (divisor=1): ${baseline.timing.total.toFixed(1)}ms total`);
+    console.log(`  Breakdown: ${baseline.timing.tool.toFixed(1)}ms tool + ${baseline.timing.terrain.toFixed(1)}ms terrain + ${baseline.timing.toolpath.toFixed(1)}ms toolpath`);
+
+    console.log('\nOverhead Analysis:');
+    console.log('┌──────────┬───────────┬────────────┬──────────────┬──────────────┐');
+    console.log('│ Divisor  │ Total (ms)│ vs Baseline│ Overhead (ms)│ Overhead (%) │');
+    console.log('├──────────┼───────────┼────────────┼──────────────┼──────────────┤');
+
+    for (const result of results) {
+        const overhead = result.timing.total - baseline.timing.total;
+        const overheadPercent = ((overhead / baseline.timing.total) * 100);
+        const comparison = result.divisor === 1 ? 'baseline' : `+${overhead.toFixed(0)}ms`;
+
+        console.log(
+            `│ ${String(result.divisor).padEnd(8)} │ ` +
+            `${result.timing.total.toFixed(1).padStart(9)} │ ` +
+            `${comparison.padStart(10)} │ ` +
+            `${overhead.toFixed(1).padStart(12)} │ ` +
+            `${overheadPercent.toFixed(1).padStart(12)}% │`
+        );
+    }
+    console.log('└──────────┴───────────┴────────────┴──────────────┴──────────────┘');
+
+    // Calculate per-batch overhead
+    if (results.length > 1) {
+        console.log('\n--- Per-Batch Overhead Estimation ---');
+        // Assume divisor creates divisor times more batches
+        // So divisor=2 creates 2x batches, divisor=4 creates 4x batches, etc.
+        for (let i = 1; i < results.length; i++) {
+            const result = results[i];
+            const extraBatches = result.divisor - 1; // Assuming baseline has 1 effective batch unit
+            const overhead = result.timing.total - baseline.timing.total;
+            const perBatchOverhead = overhead / (result.divisor - 1);
+
+            console.log(`Divisor ${result.divisor}: ${overhead.toFixed(1)}ms overhead / ${extraBatches} extra batch(es) ≈ ${perBatchOverhead.toFixed(1)}ms per batch boundary`);
+        }
+    }
+
+    // Recommendations
+    console.log('\n--- Recommendations ---');
+    const maxResult = results[results.length - 1];
+    const maxOverheadPercent = ((maxResult.timing.total - baseline.timing.total) / baseline.timing.total) * 100;
+
+    if (maxOverheadPercent < 15) {
+        console.log('✓ LOW OVERHEAD (<15%): Batching overhead is acceptable.');
+        console.log('  Focus on other optimizations (shader efficiency, toolpath generation).');
+    } else if (maxOverheadPercent < 30) {
+        console.log('⚠ MEDIUM OVERHEAD (15-30%): Consider batch size tuning.');
+        console.log('  Investigate buffer creation/destruction costs.');
+        console.log('  Consider reusing buffers across batches.');
+    } else {
+        console.log('⚠ HIGH OVERHEAD (>30%): Priority optimization needed!');
+        console.log('  Critical to reduce batch overhead before increasing batch count.');
+        console.log('  Primary suspects:');
+        console.log('    - createReusableToolpathBuffers() per batch');
+        console.log('    - destroyReusableToolpathBuffers() per batch');
+        console.log('    - GPU context switching between batches');
+        console.log('  Recommendation: Implement buffer pooling or batch-level buffer reuse.');
+    }
+
+    console.log('\n✅ Benchmark complete!');
+    app.exit(0);
+}
+
+app.whenReady().then(createWindow);
+app.on('window-all-closed', () => app.quit());

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();
+    }
+});