nexar 0.1.2

Distributed runtime with QUIC transport, stream-multiplexed messaging, and built-in collectives
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

use crate::client::NexarClient;
use crate::collective::helpers::{CollectiveTag, collective_recv, collective_send};
use crate::error::Result;
use crate::types::{DataType, Rank};
use futures::future::try_join_all;

/// Scatter: root distributes one chunk to each rank.
///
/// Root sends the `i`-th chunk to rank `i`; non-root ranks receive their
/// chunk from root.
///
/// # Safety
/// - `send_ptr`: at least `count * world_size * dtype.size_in_bytes()` bytes on root.
/// - `recv_ptr`: at least `count * dtype.size_in_bytes()` bytes on all ranks.
pub(crate) async unsafe fn scatter(
    client: &NexarClient,
    send_ptr: u64,
    recv_ptr: u64,
    count: usize,
    dtype: DataType,
    root: Rank,
    tag: CollectiveTag,
) -> Result<()> {
    let world = client.world_size();
    let rank = client.rank();
    let elem_size = dtype.size_in_bytes();
    let chunk_bytes = count * elem_size;

    if world <= 1 {
        let data = unsafe { client.adapter().stage_for_send(send_ptr, chunk_bytes)? };
        unsafe { client.adapter().receive_to_device(&data, recv_ptr)? };
        return Ok(());
    }

    if rank == root {
        let total_bytes = chunk_bytes * world as usize;
        let all_data = unsafe { client.adapter().stage_for_send(send_ptr, total_bytes)? };

        let own_start = root as usize * chunk_bytes;
        let own_chunk = &all_data[own_start..own_start + chunk_bytes];
        unsafe { client.adapter().receive_to_device(own_chunk, recv_ptr)? };

        let futs: Vec<_> = (0..world)
            .filter(|&r| r != root)
            .map(|r| {
                let start = r as usize * chunk_bytes;
                let chunk = &all_data[start..start + chunk_bytes];
                collective_send(client, r, chunk, "scatter", tag)
            })
            .collect();

        try_join_all(futs).await?;
    } else {
        let received = collective_recv(client, root, "scatter", tag).await?;
        if received.len() != chunk_bytes {
            return Err(crate::error::NexarError::BufferSizeMismatch {
                expected: chunk_bytes,
                actual: received.len(),
            });
        }
        unsafe { client.adapter().receive_to_device(&received, recv_ptr)? };
    }

    Ok(())
}