weld 0.4.0

Weld is a language and runtime for improving the performance of data-intensive applications.
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

//! Utility struct for measuring compilation time.

use time;

use self::time::Duration;

/// Tracks various compile-time statistics throughout the compiler.
pub struct CompilationStats {
    /// Running times for various Weld compiler components.
    pub weld_times: Vec<(String, Duration)>,
    /// Running times for Weld optimization passes.
    pub pass_times: Vec<(String, Duration)>,
    /// Running times for various LLVM components.
    pub llvm_times: Vec<(String, Duration)>,
}

impl CompilationStats {
    pub fn new() -> CompilationStats {
        CompilationStats {
            weld_times: Vec::new(),
            pass_times: Vec::new(),
            llvm_times: Vec::new(),
        }
    }

    /// Formats a duration for printing the statistics, in terms of milliseconds and microseconds.
    fn format_time(duration: &Duration) -> f64 {
        if duration.num_milliseconds() == 0 {
            if let Some(v) = duration.num_microseconds() {
                (v as f64) / 1000.0
            } else {
                0.0
            }
        } else {
            duration.num_milliseconds() as f64
        }
    }

    /// Returns pretty-printed statistics stored in `self`.
    pub fn pretty_print(&self) -> String {
        let mut result = String::new();
        result.push_str("Weld Compiler:\n");
        let mut total = Duration::milliseconds(0);
        for &(ref name, ref dur) in self.weld_times.iter() {
            result.push_str(&format!(
                "\t{}: {:.3} ms\n",
                name,
                CompilationStats::format_time(dur)
            ));
            total = total + *dur;
        }
        result.push_str(&format!(
            "\t\x1b[0;32mWeld Compiler Total\x1b[0m {} ms\n",
            CompilationStats::format_time(&total)
        ));

        let mut total = Duration::milliseconds(0);
        result.push_str("Weld Optimization Passes:\n");
        for &(ref name, ref dur) in self.pass_times.iter() {
            result.push_str(&format!(
                "\t{}: {:.3} ms\n",
                name,
                CompilationStats::format_time(dur)
            ));
            total = total + *dur;
        }
        result.push_str(&format!(
            "\t\x1b[0;32mWeld Optimization Passes Total\x1b[0m {} ms\n",
            CompilationStats::format_time(&total)
        ));

        let mut total = Duration::milliseconds(0);
        result.push_str("LLVM:\n");
        for &(ref name, ref dur) in self.llvm_times.iter() {
            result.push_str(&format!(
                "\t{}: {:.3} ms\n",
                name,
                CompilationStats::format_time(dur)
            ));
            total = total + *dur;
        }
        result.push_str(&format!(
            "\t\x1b[0;32mLLVM Total\x1b[0m {} ms\n",
            CompilationStats::format_time(&total)
        ));

        result
    }
}