vyre-runtime 0.6.3

Persistent megakernel + io_uring zero-copy streaming runtime for vyre - GPU as VIR0 bytecode interpreter
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

use super::*;

#[test]
fn readback_borrowed_into_decodes_into_caller_storage() {
    let backend = Arc::new(EchoBackend);
    let kernel = Megakernel::bootstrap_sharded(backend, 1, 1, Vec::new())
        .expect("Fix: echo backend must compile megakernel");
    let control = Megakernel::try_encode_control(false, 1, 0).unwrap();
    let ring = Megakernel::try_encode_empty_ring(1).unwrap();
    let debug = Megakernel::try_encode_empty_debug_log(protocol::debug::RECORD_CAPACITY).unwrap();
    let io_queue = io::try_encode_empty_io_queue(io::IO_SLOT_COUNT).unwrap();
    let mut readback = MegakernelReadback::default();
    let mut outputs = Vec::with_capacity(4);

    let stats = kernel
        .dispatch_with_io_queue_readback_borrowed_into(
            &control,
            &ring,
            &debug,
            &io_queue,
            &mut readback,
            &mut outputs,
        )
        .expect("Fix: readback into caller storage must decode echoed ABI buffers");

    assert_eq!(outputs.len(), 4);
    assert!(
        outputs.iter().all(Vec::is_empty),
        "Fix: readback decode must leave reusable output slots empty after swapping bytes into MegakernelReadback."
    );
    assert!(
        outputs.capacity() >= 4,
        "Fix: readback decode must preserve caller output-vector capacity across dispatches."
    );
    assert_eq!(stats.output_buffers, 4);
    assert_eq!(stats.readback_bytes, stats.output_bytes);
    assert_eq!(
        stats.bytes_moved,
        stats.input_bytes.saturating_add(stats.readback_bytes)
    );
    assert_eq!(
        stats.device_allocation_bytes,
        stats.input_bytes.saturating_add(stats.output_bytes)
    );
    assert_eq!(stats.device_allocation_events, 8);
    assert_eq!(stats.kernel_launches, 1);
    assert_eq!(stats.sync_points, 1);
    assert_eq!(readback.control_bytes, control);
    assert_eq!(readback.ring_bytes, ring);
    assert_eq!(readback.debug_log_bytes, debug);
    assert_eq!(readback.io_queue_bytes, io_queue);
}

#[test]
fn readback_owned_into_uses_caller_storage() {
    let backend = Arc::new(EchoBackend);
    let kernel = Megakernel::bootstrap_sharded(backend, 1, 1, Vec::new())
        .expect("Fix: echo backend must compile megakernel");
    let control = Megakernel::try_encode_control(false, 1, 0).unwrap();
    let ring = Megakernel::try_encode_empty_ring(1).unwrap();
    let debug = Megakernel::try_encode_empty_debug_log(protocol::debug::RECORD_CAPACITY).unwrap();
    let io_queue = io::try_encode_empty_io_queue(io::IO_SLOT_COUNT).unwrap();
    let mut readback = MegakernelReadback::default();
    let mut outputs = Vec::with_capacity(4);

    let stats = kernel
        .dispatch_with_io_queue_readback_into(
            control.clone(),
            ring.clone(),
            debug.clone(),
            io_queue.clone(),
            &mut readback,
            &mut outputs,
        )
        .expect("Fix: owned readback-into dispatch must decode echoed ABI buffers");

    assert_eq!(outputs.len(), 4);
    assert!(
        outputs.iter().all(Vec::is_empty),
        "Fix: owned readback-into dispatch must leave caller output slots reusable after decode."
    );
    assert!(
        outputs.capacity() >= 4,
        "Fix: owned readback-into dispatch must preserve caller output-vector capacity."
    );
    assert_eq!(stats.output_buffers, 4);
    assert_eq!(stats.kernel_launches, 1);
    assert_eq!(stats.sync_points, 1);
    assert_eq!(readback.control_bytes, control);
    assert_eq!(readback.ring_bytes, ring);
    assert_eq!(readback.debug_log_bytes, debug);
    assert_eq!(readback.io_queue_bytes, io_queue);
}