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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Mock-mode tests for the typed-allocate / typed-copy `DeviceMsg`
//! variants. Verifies that:
//! - All typed-allocate variants reply with `Unrecoverable` in mock
//!   mode (since the mock ContextActor doesn't have a stream).
//! - The legacy `Allocate` alias still works.
//! - `Stats` and `SnapshotContext` reply meaningful values.
#![allow(deprecated)]

use std::time::Duration;
use tokio::sync::oneshot;

use atomr_accel_cuda::prelude::*;
use atomr_testkit::TestKit;

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn mock_allocate_typed_variants() {
    let kit = TestKit::new("alloc-test").await;
    let sys = &kit.system;
    let dev = sys
        .actor_of(DeviceActor::props(DeviceConfig::mock(0)), "dev0")
        .unwrap();

    // F32
    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::AllocateF32 { len: 16, reply: tx });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(r, Err(GpuError::Unrecoverable(_))));

    // F64
    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::AllocateF64 { len: 8, reply: tx });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(r, Err(GpuError::Unrecoverable(_))));

    // I32
    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::AllocateI32 { len: 4, reply: tx });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(r, Err(GpuError::Unrecoverable(_))));

    // U8
    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::AllocateU8 {
        len: 1024,
        reply: tx,
    });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(r, Err(GpuError::Unrecoverable(_))));

    kit.shutdown().await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn legacy_allocate_alias_still_works() {
    let kit = TestKit::new("alloc-legacy").await;
    let sys = &kit.system;
    let dev = sys
        .actor_of(DeviceActor::props(DeviceConfig::mock(0)), "dev0")
        .unwrap();

    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::Allocate { len: 16, reply: tx });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    assert!(matches!(r, Err(GpuError::Unrecoverable(_))));

    kit.shutdown().await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn stats_returns_load_snapshot() {
    let kit = TestKit::new("stats-test").await;
    let sys = &kit.system;
    let dev = sys
        .actor_of(DeviceActor::props(DeviceConfig::mock(0)), "dev0")
        .unwrap();

    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::Stats { reply: tx });
    let load = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    // Mock-mode load values are zeros except queue_depth.
    assert_eq!(load.compute_cap, (0, 0));
    assert_eq!(load.active_streams, 0);

    kit.shutdown().await;
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn snapshot_context_returns_none_in_mock_mode() {
    let kit = TestKit::new("snapshot-test").await;
    let sys = &kit.system;
    let dev = sys
        .actor_of(DeviceActor::props(DeviceConfig::mock(0)), "dev0")
        .unwrap();

    let (tx, rx) = oneshot::channel();
    dev.tell(DeviceMsg::SnapshotContext { reply: tx });
    let r = tokio::time::timeout(Duration::from_secs(2), rx)
        .await
        .unwrap()
        .unwrap();
    // Mock mode never installs a real CudaContext; SnapshotContext
    // returns whatever DeviceState has, which is None for mock.
    assert!(r.is_none());

    kit.shutdown().await;
}