primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
// message_passing_f64.wgsl - Message Passing for Graph Neural Networks (f64 canonical)
//
// Generic message passing framework
// h_i' = UPDATE(h_i, AGGREGATE({MESSAGE(h_i, h_j, e_ij) : j ∈ N(i)}))

struct Params {
    num_nodes: u32,
    num_edges: u32,
    node_feat_dim: u32,
    edge_feat_dim: u32,
    message_dim: u32,
    aggr_type: u32,  // 0 = sum, 1 = mean, 2 = max
}

@group(0) @binding(0) var<storage, read> node_features: array<f64>;    // [num_nodes, node_feat_dim]
@group(0) @binding(1) var<storage, read> edge_index: array<u32>;       // [num_edges, 2] - (source, target)
@group(0) @binding(2) var<storage, read> edge_features: array<f64>;    // [num_edges, edge_feat_dim]
@group(0) @binding(3) var<storage, read> message_mlp: array<f64>;      // Message network weights
@group(0) @binding(4) var<storage, read> update_mlp: array<f64>;       // Update network weights
@group(0) @binding(5) var<storage, read_write> output: array<f64>;     // [num_nodes, node_feat_dim]
@group(0) @binding(6) var<uniform> params: Params;

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let target_node = global_id.x;

    if (target_node >= params.num_nodes) {
        return;
    }

    // Initialize aggregation
    var aggregated: array<f64, 256>; // Max 256 features
    for (var f: u32 = 0u; f < params.node_feat_dim && f < 256u; f = f + 1u) {
        aggregated[f] = select(0.0, -1e10, params.aggr_type == 2u); // 0 for sum/mean, -inf for max
    }

    var neighbor_count: u32 = 0u;

    // Collect messages from neighbors
    for (var e: u32 = 0u; e < params.num_edges; e = e + 1u) {
        let source = edge_index[e * 2u];
        let target_data = edge_index[e * 2u + 1u];

        if (target_data == target_node) {
            neighbor_count = neighbor_count + 1u;

            // Simplified message: just copy source features (full version would use MLP)
            for (var f: u32 = 0u; f < params.node_feat_dim && f < 256u; f = f + 1u) {
                let message = node_features[source * params.node_feat_dim + f];

                if (params.aggr_type == 0u || params.aggr_type == 1u) {
                    // Sum/Mean
                    aggregated[f] = aggregated[f] + message;
                } else {
                    // Max
                    aggregated[f] = max(aggregated[f], message);
                }
            }
        }
    }

    // Finalize aggregation (mean requires division)
    if (params.aggr_type == 1u && neighbor_count > 0u) {
        for (var f: u32 = 0u; f < params.node_feat_dim && f < 256u; f = f + 1u) {
            aggregated[f] = aggregated[f] / f64(neighbor_count);
        }
    }

    // Update node features (simplified - just add aggregated messages)
    for (var f: u32 = 0u; f < params.node_feat_dim && f < 256u; f = f + 1u) {
        output[target_node * params.node_feat_dim + f] =
            node_features[target_node * params.node_feat_dim + f] + aggregated[f];
    }
}