lamellar 0.8.0

Lamellar is an asynchronous tasking runtime for HPC systems developed in RUST.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

use lamellar::array::prelude::*;

macro_rules! initialize_array_local {
    (UnsafeArray,$array:ident,$init_val:ident) => {
        unsafe {
            $array
                .local_iter_mut()
                .for_each(move |x| *x = $init_val)
                .block();
        }
    };
    (AtomicArray,$array:ident,$init_val:ident) => {
        $array
            .local_iter_mut()
            .for_each(move |x| x.store($init_val))
            .block();
    };
    (LocalLockArray,$array:ident,$init_val:ident) => {
        $array
            .local_iter_mut()
            .for_each(move |x| *x = $init_val)
            .block();
    };
    (GlobalLockArray,$array:ident,$init_val:ident) => {
        $array
            .local_iter_mut()
            .for_each(move |x| *x = $init_val)
            .block();
    };
    (ReadOnlyArray,$array:ident,$init_val:ident) => {
        let temp = $array.into_unsafe().block();
        unsafe {
            temp.local_iter_mut()
                .for_each(move |x| *x = $init_val)
                .block();
        }
        $array = temp.into_read_only().block();
    };
}

macro_rules! get_buffer_pe_test {
    ($array:ident, $t:ty, $len:expr, $dist:ident) => {{
        let world = lamellar::LamellarWorldBuilder::new().build();
        let num_pes = world.num_pes();
        let my_pe = world.my_pe();
        let array_total_len = $len;
        #[allow(unused_mut)]
        let mut success = true;
        #[allow(unused_mut)]
        let mut array: $array<$t> = $array::<$t>::new(world.team(), array_total_len, $dist)
            .block()
            .into();

        let init_val = my_pe as $t;
        initialize_array_local!($array, array, init_val);
        array.wait_all();
        array.barrier();

        let pe_len = array_total_len / num_pes;

        for pe in 0..num_pes {
            for tx_size in 1..=pe_len {
                let num_txs = pe_len / tx_size;
                let mut reqs = vec![];
                for tx in 0..num_txs {
                    #[allow(unused_unsafe)]
                    unsafe {
                        reqs.push(
                            array
                                .get_buffer_pe(
                                    pe,
                                    tx * tx_size,
                                    std::cmp::min(pe_len, (tx + 1) * tx_size) - tx * tx_size,
                                )
                                .spawn(),
                        );
                    }
                }
                array.wait_all();
                array.barrier();
                for req in reqs.drain(..) {
                    let buf = req.block();
                    for elem in buf.as_slice().iter() {
                        if ((pe as $t - elem) as f32).abs() > 0.0001 {
                            eprintln!(
                                "{:?} {:?} {:?}",
                                pe as $t,
                                elem,
                                ((pe as $t - elem) as f32).abs()
                            );
                            success = false;
                        }
                    }
                }
                array.barrier();
            }
        }

        array.barrier();
        world.wait_all();
        world.barrier();
        if !success {
            eprintln!("failed");
        }
    }};
}

#[lamellar::main]
fn main() {
    let args: Vec<String> = std::env::args().collect();
    let array = args[1].clone();
    let dist = args[2].clone();
    let elem = args[3].clone();
    let len = args[4].parse::<usize>().unwrap();

    let dist_type = match dist.as_str() {
        "Block" => Distribution::Block,
        "Cyclic" => Distribution::Cyclic,
        _ => panic!("unsupported dist type"),
    };

    match array.as_str() {
        "UnsafeArray" => match elem.as_str() {
            "u8" => get_buffer_pe_test!(UnsafeArray, u8, len, dist_type),
            "u16" => get_buffer_pe_test!(UnsafeArray, u16, len, dist_type),
            "u32" => get_buffer_pe_test!(UnsafeArray, u32, len, dist_type),
            "u64" => get_buffer_pe_test!(UnsafeArray, u64, len, dist_type),
            "u128" => get_buffer_pe_test!(UnsafeArray, u128, len, dist_type),
            "usize" => get_buffer_pe_test!(UnsafeArray, usize, len, dist_type),
            "i8" => get_buffer_pe_test!(UnsafeArray, i8, len, dist_type),
            "i16" => get_buffer_pe_test!(UnsafeArray, i16, len, dist_type),
            "i32" => get_buffer_pe_test!(UnsafeArray, i32, len, dist_type),
            "i64" => get_buffer_pe_test!(UnsafeArray, i64, len, dist_type),
            "i128" => get_buffer_pe_test!(UnsafeArray, i128, len, dist_type),
            "isize" => get_buffer_pe_test!(UnsafeArray, isize, len, dist_type),
            "f32" => get_buffer_pe_test!(UnsafeArray, f32, len, dist_type),
            "f64" => get_buffer_pe_test!(UnsafeArray, f64, len, dist_type),
            _ => eprintln!("unsupported element type"),
        },
        "AtomicArray" => match elem.as_str() {
            "u8" => get_buffer_pe_test!(AtomicArray, u8, len, dist_type),
            "u16" => get_buffer_pe_test!(AtomicArray, u16, len, dist_type),
            "u32" => get_buffer_pe_test!(AtomicArray, u32, len, dist_type),
            "u64" => get_buffer_pe_test!(AtomicArray, u64, len, dist_type),
            "u128" => get_buffer_pe_test!(AtomicArray, u128, len, dist_type),
            "usize" => get_buffer_pe_test!(AtomicArray, usize, len, dist_type),
            "i8" => get_buffer_pe_test!(AtomicArray, i8, len, dist_type),
            "i16" => get_buffer_pe_test!(AtomicArray, i16, len, dist_type),
            "i32" => get_buffer_pe_test!(AtomicArray, i32, len, dist_type),
            "i64" => get_buffer_pe_test!(AtomicArray, i64, len, dist_type),
            "i128" => get_buffer_pe_test!(AtomicArray, i128, len, dist_type),
            "isize" => get_buffer_pe_test!(AtomicArray, isize, len, dist_type),
            "f32" => get_buffer_pe_test!(AtomicArray, f32, len, dist_type),
            "f64" => get_buffer_pe_test!(AtomicArray, f64, len, dist_type),
            _ => eprintln!("unsupported element type"),
        },
        "LocalLockArray" => match elem.as_str() {
            "u8" => get_buffer_pe_test!(LocalLockArray, u8, len, dist_type),
            "u16" => get_buffer_pe_test!(LocalLockArray, u16, len, dist_type),
            "u32" => get_buffer_pe_test!(LocalLockArray, u32, len, dist_type),
            "u64" => get_buffer_pe_test!(LocalLockArray, u64, len, dist_type),
            "u128" => get_buffer_pe_test!(LocalLockArray, u128, len, dist_type),
            "usize" => get_buffer_pe_test!(LocalLockArray, usize, len, dist_type),
            "i8" => get_buffer_pe_test!(LocalLockArray, i8, len, dist_type),
            "i16" => get_buffer_pe_test!(LocalLockArray, i16, len, dist_type),
            "i32" => get_buffer_pe_test!(LocalLockArray, i32, len, dist_type),
            "i64" => get_buffer_pe_test!(LocalLockArray, i64, len, dist_type),
            "i128" => get_buffer_pe_test!(LocalLockArray, i128, len, dist_type),
            "isize" => get_buffer_pe_test!(LocalLockArray, isize, len, dist_type),
            "f32" => get_buffer_pe_test!(LocalLockArray, f32, len, dist_type),
            "f64" => get_buffer_pe_test!(LocalLockArray, f64, len, dist_type),
            _ => eprintln!("unsupported element type"),
        },
        "GlobalLockArray" => match elem.as_str() {
            "u8" => get_buffer_pe_test!(GlobalLockArray, u8, len, dist_type),
            "u16" => get_buffer_pe_test!(GlobalLockArray, u16, len, dist_type),
            "u32" => get_buffer_pe_test!(GlobalLockArray, u32, len, dist_type),
            "u64" => get_buffer_pe_test!(GlobalLockArray, u64, len, dist_type),
            "u128" => get_buffer_pe_test!(GlobalLockArray, u128, len, dist_type),
            "usize" => get_buffer_pe_test!(GlobalLockArray, usize, len, dist_type),
            "i8" => get_buffer_pe_test!(GlobalLockArray, i8, len, dist_type),
            "i16" => get_buffer_pe_test!(GlobalLockArray, i16, len, dist_type),
            "i32" => get_buffer_pe_test!(GlobalLockArray, i32, len, dist_type),
            "i64" => get_buffer_pe_test!(GlobalLockArray, i64, len, dist_type),
            "i128" => get_buffer_pe_test!(GlobalLockArray, i128, len, dist_type),
            "isize" => get_buffer_pe_test!(GlobalLockArray, isize, len, dist_type),
            "f32" => get_buffer_pe_test!(GlobalLockArray, f32, len, dist_type),
            "f64" => get_buffer_pe_test!(GlobalLockArray, f64, len, dist_type),
            _ => {} //eprintln!("unsupported element type"),
        },
        "ReadOnlyArray" => match elem.as_str() {
            "u8" => get_buffer_pe_test!(ReadOnlyArray, u8, len, dist_type),
            "u16" => get_buffer_pe_test!(ReadOnlyArray, u16, len, dist_type),
            "u32" => get_buffer_pe_test!(ReadOnlyArray, u32, len, dist_type),
            "u64" => get_buffer_pe_test!(ReadOnlyArray, u64, len, dist_type),
            "u128" => get_buffer_pe_test!(ReadOnlyArray, u128, len, dist_type),
            "usize" => get_buffer_pe_test!(ReadOnlyArray, usize, len, dist_type),
            "i8" => get_buffer_pe_test!(ReadOnlyArray, i8, len, dist_type),
            "i16" => get_buffer_pe_test!(ReadOnlyArray, i16, len, dist_type),
            "i32" => get_buffer_pe_test!(ReadOnlyArray, i32, len, dist_type),
            "i64" => get_buffer_pe_test!(ReadOnlyArray, i64, len, dist_type),
            "i128" => get_buffer_pe_test!(ReadOnlyArray, i128, len, dist_type),
            "isize" => get_buffer_pe_test!(ReadOnlyArray, isize, len, dist_type),
            "f32" => get_buffer_pe_test!(ReadOnlyArray, f32, len, dist_type),
            "f64" => get_buffer_pe_test!(ReadOnlyArray, f64, len, dist_type),
            _ => eprintln!("unsupported element type"),
        },
        _ => eprintln!("unsupported array type"),
    }
}