lamellar 0.3.1

Lamellar is an asynchronous tasking runtime for HPC systems developed in RUST.
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
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::any;

#[cfg(feature = "SocketsBackend")]
use crate::runtime::Arch;
#[cfg(feature = "SocketsBackend")]
use std::env;

#[allow(dead_code)]
pub fn print_type_of<T>(_: &T) {
    println!("{}", any::type_name::<T>());
}

// serialize the trait object F
// #[flame]
#[cfg(feature = "nightly")]
pub(crate) fn ser_closure<
    F: FnOnce() -> T + serde::ser::Serialize + serde::de::DeserializeOwned + 'static,
    T: any::Any + serde::ser::Serialize + serde::de::DeserializeOwned,
>(
    start: F,
) -> Vec<u8> {
    let arg: Vec<u8> = crate::serialize(&start).unwrap();
    let start: serde_closure::FnOnce<(Vec<u8>,), fn((Vec<u8>,), ()) -> _> = FnOnce!([arg]move||{
        let arg: Vec<u8> = arg;
        let closure: F = crate::deserialize(&arg).unwrap();
        closure()
    });
    crate::serialize(&start).unwrap()
}

#[cfg(feature = "SocketsBackend")]
pub(crate) fn parse_slurm() -> Arch {
    //--------------parse slurm environment variables-----------------
    let num_locales = match env::var("SLURM_NNODES") {
        Ok(val) => val.parse::<usize>().unwrap(),
        Err(_e) => {
            println!("[LAMELLAR] WARNING: currently only supports slurm envrionments, falling back to single node");
            1
        }
    };

    let num_pes = match env::var("PMI_SIZE") {
        Ok(val) => val.parse::<usize>().unwrap(),
        Err(_e) => {
            println!("[LAMELLAR] WARNING: currently only supports slurm envrionments, falling back to single node");
            1
        }
    };

    let my_pe = match env::var("PMI_RANK") {
        Ok(val) => val.parse::<usize>().unwrap(),
        Err(_e) => {
            println!("[LAMELLAR] WARNING: currently only supports slurm envrionments, falling back to single node");
            0
        }
    };

    let job_id = match env::var("SLURM_JOBID") {
        Ok(val) => val.parse::<usize>().unwrap(),
        Err(_e) => 1,
    };

    let my_name = match env::var("SLURMD_NODENAME") {
        Ok(val) => val,
        Err(_e) => {
            println!("[LAMELLAR] WARNING: currently only supports slurm envrionments, falling back to single node");
            String::from("localhost")
        }
    };

    let nodes = match env::var("SLURM_NODELIST") {
        Ok(val) => val,
        Err(_e) => {
            println!("[LAMELLAR] WARNING: currently only supports slurm envrionments, falling back to single node");
            String::from("localhost")
        }
    };

    let split = nodes.split(']').collect::<Vec<&str>>()[0]
        .split('[')
        .collect::<Vec<&str>>();

    let base = split[0];
    let mut pe_addrs: Vec<_> = Vec::new();
    let num_pe_node = num_pes / num_locales;

    if split.len() > 1 {
        for node_str in split[1].split(',') {
            let node_range = node_str.split('-').collect::<Vec<&str>>();
            if node_range.len() > 1 {
                for i in node_range[0].parse::<usize>().unwrap()
                    ..=node_range[1].parse::<usize>().unwrap()
                //..= is inclusive range
                {
                    let nn = format!("{:0width$}", i, width = node_range[0].len());
                    let tmp = [base, &nn[..]].concat();
                    if tmp == my_name {
                        // my_pe = pe_cnt;
                    }
                    for _i in 0..num_pe_node {
                        pe_addrs.push(tmp.clone());
                        // pe_cnt += 1;
                    }
                }
            } else {
                let tmp = [base, node_range[0]].concat();
                if tmp == my_name {
                    // my_pe = pe_cnt;
                }
                for _i in 0..num_pe_node {
                    pe_addrs.push(tmp.clone());
                    // pe_cnt += 1;
                }
            }
        }
    } else {
        for _i in 0..num_pe_node {
            pe_addrs.push("localhost".to_string());
        }
    }
    Arch {
        my_pe: my_pe,
        num_pes: num_pes,
        pe_addrs: pe_addrs,
        job_id: job_id,
    }
}

#[cfg(feature = "SocketsBackend")]
pub(crate) fn parse_localhost() -> Arch {
    Arch {
        my_pe: 0,
        num_pes: 1,
        pe_addrs: vec!["localhost".to_string()],
        job_id: 0,
    }
}