fast-nnt 0.4.0

Rust implementation of the NeighborNet phylogenetic network algorithm.
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

use serde::Serialize;

use crate::weights::cg_weights::CGSolveStats;

#[derive(Serialize)]
pub struct MatrixMeta {
    pub n: usize,
    pub npairs: usize,
    pub delimiter: String,
    pub has_header: bool,
    pub has_index: bool,
    pub symmetry_pairs_fixed: usize,
}

#[derive(Serialize)]
pub struct NNLSMeta {
    pub cutoff: f64,
    pub proj_grad_bound: f64,
    pub cgnr_iterations: usize,
    pub cgnr_tolerance: f64,
    pub active_set_rho: f64,
    pub num_splits: usize,
    pub num_trivial_splits: usize,
    pub num_nontrivial_splits: usize,
    pub sum_weights: f64,
}

#[derive(Serialize)]
pub struct RunTimings {
    pub load_sec: f64,
    pub cycle_sec: f64,
    pub nnls_sec: f64,
    pub fit_sec: f64,
    pub output_sec: f64,
    pub splits_sec: f64,
    pub graph_sec: f64,
    pub total_sec: f64,
}

#[derive(Serialize)]
pub struct SystemStats {
    pub os: String,
    pub arch: String,
    pub num_cpus: usize,
    pub rayon_threads: usize,
    pub peak_rss_bytes: Option<u64>,
    pub current_rss_bytes: u64,
}

#[derive(Serialize)]
pub struct RunLog {
    pub input: String,
    pub out_dir: String,
    pub matrix: MatrixMeta,
    pub nnls: NNLSMeta,
    pub inference: String,
    pub fit_percent: f32,
    pub cg_solve_stats: Option<CGSolveStats>,
    pub timings: RunTimings,
    pub system: SystemStats,
}

pub fn system_stats() -> SystemStats {
    SystemStats {
        os: std::env::consts::OS.to_string(),
        arch: std::env::consts::ARCH.to_string(),
        num_cpus: num_cpus::get(),
        rayon_threads: rayon::current_num_threads(),
        peak_rss_bytes: peak_rss_bytes(),
        current_rss_bytes: current_rss_bytes(),
    }
}

fn current_rss_bytes() -> u64 {
    use sysinfo::System;
    let mut sys = System::new();
    sys.refresh_processes(sysinfo::ProcessesToUpdate::All, true);
    if let Ok(pid) = sysinfo::get_current_pid()
        && let Some(p) = sys.process(pid)
    {
        return p.memory();
    }
    0
}

#[cfg(target_os = "linux")]
fn peak_rss_bytes() -> Option<u64> {
    let s = std::fs::read_to_string("/proc/self/status").ok()?;
    for line in s.lines() {
        if let Some(rest) = line.strip_prefix("VmHWM:") {
            let kb = rest.split_whitespace().next()?.parse::<u64>().ok()?;
            return Some(kb * 1024);
        }
    }
    None
}

#[cfg(not(target_os = "linux"))]
fn peak_rss_bytes() -> Option<u64> {
    None
}