gpu execution

// Test 823: GPU Shader Execution - End to End!
//
// This test proves the ENTIRE GPU pipeline works:
// 1. Write GLSL shader in |glsl variant
// 2. Compiler extracts GLSL and compiles to SPIR-V
// 3. Compiler generates Vulkan bindings matching event interface
// 4. Shader executes on GPU and modifies data in place
// 5. Verify results on CPU
//
// This is the SIMPLEST possible GPU compute: double all values in an array

const std = @import("std");

// Event interface - pure, platform-agnostic
~pub event double-values { data: []f32 }
| done { }

// GPU implementation using GLSL compute shader
~proc double-values|glsl {
    #version 450
    layout(local_size_x = 256) in;
    layout(binding = 0) buffer Data { float values[]; } data;

    void main() {
        uint idx = gl_GlobalInvocationID.x;
        if (idx < data.values.length()) {
            data.values[idx] *= 2.0;
        }
    }
}

// Custom compiler coordinator that includes GLSL pass
~compiler.coordinate =
    compiler.passes.evaluate_comptime(ast)
    | evaluated ev |> compiler.check.structure(ev.ast)
    | valid v |> compiler.passes.compile_glsl(v.ast)
    | transformed t |> compiler.check.phantom.semantic(t.ast)
    | valid v2 |> compiler.emit.zig(v2.ast)
    | emitted em |> coordinated {
        v2.ast,
        em.code,
        metrics: "GPU test compiled!"
    }

// Test event - verifies GPU execution
~pub event test-gpu-execution { }

~proc test-gpu-execution|zig {
    var values = [_]f32{ 1.0, 2.0, 3.0, 4.0, 5.0 };

    // This should execute on GPU and modify values in place
    double_values(data: &values);

    // Verify results
    std.debug.assert(values[0] == 2.0);
    std.debug.assert(values[1] == 4.0);
    std.debug.assert(values[2] == 6.0);
    std.debug.assert(values[3] == 8.0);
    std.debug.assert(values[4] == 10.0);

    std.debug.print("✅ GPU execution successful! All values doubled.\n", .{});

    return .{ .done = .{ } };
}