atomr-accel-cuda 0.10.0

GPU acceleration via the actor model. Wraps NVIDIA CUDA libraries (cuBLAS, cuDNN, cuFFT, cuRAND, cuSOLVER, cuSPARSE, cuTENSOR, cuBLASLt, NVRTC, NCCL) as supervised atomr actors with generation-validated buffers and a uniform async surface.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//! SGEMM op for [`super::super::GraphOp`].
//!
//! Wraps the lower-level [`crate::kernel::record::BlasSgemmOp`] /
//! [`crate::kernel::record::BlasRecorder`] pair into a single
//! `GraphOp`-implementing type.

use crate::error::GpuError;
use crate::gpu_ref::GpuRef;
use crate::graph::{GraphOp, GraphRecordCtx};
use crate::kernel::record::{BlasRecorder, BlasSgemmOp, RecordMode};

/// SGEMM op for graph capture: `C := alpha · A·B + beta · C`,
/// column-major, no transpose.
///
/// The op needs a cuBLAS handle on the captured stream, supplied
/// by `GraphRecordCtx::blas`. If absent the op fails with
/// [`GpuError::Unrecoverable`].
///
/// `record` consumes the held `GpuRef`s on first invocation
/// (matching the pre-trait closed-enum semantics where the boxed
/// op was destructured by-move). A second `record` call on the
/// same op returns [`GpuError::Unrecoverable`].
pub struct SgemmOp {
    inner: Option<BlasSgemmOp>,
}

impl SgemmOp {
    pub fn new(
        a: GpuRef<f32>,
        b: GpuRef<f32>,
        c: GpuRef<f32>,
        m: i32,
        n: i32,
        k: i32,
        alpha: f32,
        beta: f32,
    ) -> Self {
        Self {
            inner: Some(BlasSgemmOp {
                a,
                b,
                c,
                m,
                n,
                k,
                alpha,
                beta,
            }),
        }
    }
}

impl GraphOp for SgemmOp {
    fn record(&mut self, ctx: &mut GraphRecordCtx<'_>) -> Result<(), GpuError> {
        let stream = ctx.require_stream()?;
        let blas = ctx.blas.ok_or_else(|| {
            GpuError::Unrecoverable("SgemmOp::record: cuBLAS handle not available in ctx".into())
        })?;
        let op = self
            .inner
            .take()
            .ok_or_else(|| GpuError::Unrecoverable("SgemmOp::record: already consumed".into()))?;
        let mut recorder = BlasRecorder { handle: blas };
        recorder.enqueue_record(stream, op)
    }

    fn op_name(&self) -> &'static str {
        "graph::sgemm"
    }
}