drone 0.14.0

CLI utility for Drone, an Embedded Operating System. 
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

//! `drone heap` command.

use crate::{
    cli::{HeapCmd, HeapGenerateCmd, HeapSubCmd},
    color::Color,
    heap,
    heap::TraceMap,
};
use ansi_term::Color::{Cyan, Yellow};
use anyhow::{anyhow, Result};
use drone_config::{self as config, format_size};
use prettytable::{cell, format, row, Table};
use std::{
    fs::File,
    io::{stderr, stdout},
};

/// Runs `drone heap` command.
pub fn run(cmd: HeapCmd, color: Color) -> Result<()> {
    let HeapCmd { trace_file, config: heap_config, size, heap_sub_cmd } = cmd;
    let size = size.map_or_else(
        || {
            config::Config::read_from_current_dir().and_then(|config| {
                if heap_config == "main" {
                    Ok(config.heap.main.size)
                } else {
                    config
                        .heap
                        .extra
                        .get(&heap_config)
                        .map(|heap| heap.block.size)
                        .ok_or_else(|| anyhow!("Unknown `{}` heap configuration", heap_config))
                }
            })
        },
        Ok,
    )?;
    let mut trace = TraceMap::new();
    if let Ok(file) = File::open(&trace_file) {
        heap::read_trace(&mut trace, file, size)?;
        if trace.is_empty() {
            eprintln!(
                "{}: file `{}` is empty.",
                color.bold_fg("warning", Yellow),
                trace_file.display()
            );
        } else {
            print_table(&trace, size, color)?;
        }
    } else {
        eprintln!(
            "{}: file `{}` not exists.",
            color.bold_fg("warning", Yellow),
            trace_file.display()
        );
    }
    match heap_sub_cmd {
        Some(HeapSubCmd::Generate(cmd)) => generate(cmd, &heap_config, &trace, size, color),
        None => Ok(()),
    }
}

/// Runs `drone heap generate` command.
pub fn generate(
    cmd: HeapGenerateCmd,
    config: &str,
    trace: &TraceMap,
    size: u32,
    color: Color,
) -> Result<()> {
    let HeapGenerateCmd { pools } = cmd;
    if trace.is_empty() {
        let layout = heap::layout::empty(size, pools);
        heap::layout::render(&mut stdout(), config, &layout)?;
    } else {
        let (layout, frag) = heap::layout::optimize(&trace, size, pools)?;
        eprintln!();
        eprintln!("{}", color.bold_fg(&format!("{:=^80}", " OPTIMIZED LAYOUT "), Cyan));
        heap::layout::render(&mut stdout(), config, &layout)?;
        eprintln!(
            "# fragmentation: {}",
            color.bold(&format!("{} / {:.2}%", frag, f64::from(frag) / f64::from(size) * 100.0))
        );
        eprintln!(
            "# {}: replace the existing [heap.{}] section in Drone.toml",
            color.bold_fg("hint", Cyan),
            config
        );
    }
    Ok(())
}

fn print_table(trace: &TraceMap, size: u32, color: Color) -> Result<()> {
    let mut table = Table::new();
    table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
    table.set_titles(row![
        r->color.bold("Block Size"),
        r->color.bold("Max Load"),
        r->color.bold("Total Allocations"),
    ]);
    let mut used = 0;
    for (size, entry) in trace {
        table.add_row(row![
            r->format_size(*size),
            r->entry.max,
            r->entry.total,
        ]);
        used += size * entry.max;
    }
    table.print(&mut stderr())?;
    eprintln!();
    eprintln!(
        "Maximum heap load: {}",
        color.bold(&format!("{} / {:.2}%", used, f64::from(used) / f64::from(size) * 100.0))
    );
    Ok(())
}