fused_gpu 0.1.0-beta.1

GPU graph compilation to fuse linear tensor operations
Documentation
use crate::{
    dispatch::backend::{
        Axis, DType, Graph, Metadata, Op, Param, ParamTy, ValueState,
        kernel::{Kernel, RawKernel},
    },
    errors::Error,
};
use std::{vec, vec::Vec};

#[inline]
pub fn lower_loss(graph: &Graph, meta: Metadata) -> Result<Kernel, Error> {
    let root = graph.nodes.len() - 1;
    let root_node = &graph.nodes[root];
    let dtype = root_node.dtype;

    let mut kernel = Kernel {
        raw: RawKernel {
            meta,
            shared: Vec::new(),
            values: Vec::new(),
            ops: Vec::new(),
            block: [0; 3],
            root,
            iter_space: root_node.shape.clone(),
        },
        params: Vec::with_capacity(5),
        meta: vec![false; meta.fields],
    };

    if graph
        .nodes
        .iter()
        .all(|x| x.op.is_elementwise() || x.op.is_leaf())
    {
        kernel.raw.block = [256, 1, 1];
    } else {
        kernel.raw.block = [16, 16, 1];
    }

    kernel.params.push(Param {
        dtype: DType::U32,
        ty: ParamTy::Uniform,
        pid: 0,
    });

    let loss_param = kernel.params.len();
    kernel.params.push(Param {
        dtype,
        ty: ParamTy::ReadWrite,
        pid: 1,
    });

    let grad_param = kernel.params.len();
    kernel.params.push(Param {
        dtype,
        ty: ParamTy::ReadWrite,
        pid: 2,
    });

    let pred_param = kernel.params.len();
    kernel.params.push(Param {
        dtype,
        ty: ParamTy::ReadOnly,
        pid: 3,
    });

    let target_param = kernel.params.len();
    kernel.params.push(Param {
        dtype,
        ty: ParamTy::ReadOnly,
        pid: 4,
    });

    let mut dims = Vec::new();

    for &meta_index in &root_node.shape {
        let dim_val = kernel.raw.def_var(
            DType::U32,
            ValueState::Immut,
            Some(Op::ReadMeta {
                param: 0,
                field: meta_index,
            }),
        );

        kernel.register_meta(meta_index);

        dims.push(dim_val);
    }

    let gid = kernel.raw.def_var(
        DType::U32,
        ValueState::Mut,
        Some(Op::GlobalId { axis: Axis::X }),
    );

    let total = dims[0];
    kernel.raw.update_var_state(total, ValueState::Mut);

    if dims.len() > 1 {
        let gid2 = kernel.raw.def_var(DType::U32, ValueState::Mut, None);

        for (i, &d) in dims.iter().enumerate().skip(1) {
            kernel.raw.overwrite_var(
                gid2,
                Op::GlobalId {
                    axis: (i as u8).try_into().unwrap_or(Axis::Z),
                },
            );

            kernel.raw.overwrite_var(gid2, Op::Mul { a: gid2, b: d });

            kernel.raw.overwrite_var(gid, Op::Add { a: gid, b: gid2 });

            kernel.raw.overwrite_var(total, Op::Mul { a: total, b: d });
        }
    }

    let row = kernel.raw.def_var(
        DType::U32,
        ValueState::Immut,
        Some(Op::GlobalId { axis: Axis::Y }),
    );
    let col = kernel.raw.def_var(
        DType::U32,
        ValueState::Immut,
        Some(Op::GlobalId { axis: Axis::X }),
    );

    let pred = kernel.raw.def_var(
        dtype,
        ValueState::Immut,
        Some(Op::ParamLoad {
            param: pred_param,
            index: gid,
        }),
    );
    let target = kernel.raw.def_var(
        dtype,
        ValueState::Immut,
        Some(Op::ParamLoad {
            param: target_param,
            index: gid,
        }),
    );

    let (loss_val, grad_val) = (graph.loss.lower)(
        &mut kernel,
        dtype,
        pred,
        target,
        pred_param,
        target_param,
        row,
        col,
    )?;

    kernel.raw.param_store(loss_param, gid, loss_val);
    kernel.raw.param_store(grad_param, gid, grad_val);

    Ok(kernel)
}