Add SDE into benchmark tool

Author: kaleidawave

benchmarking-tool/Cargo.lock

@@ -8,7 +8,9 @@ name = "benchmark"
 path = "main.rs"
 
 [dependencies]
+json-builder-macro = "0.0.3"
 rustc-demangle = "0.1.26"
+sde-output-parser = { path = "sde-output-parser", version = "*" } 
 
 # [target.unix.dependencies]
 # perf-event-open = "0.4.2"

benchmarking-tool/Cargo.toml

@@ -54,7 +54,7 @@ fn main() {
             run_qbdi(args);
         }
         "sde" => {
-            todo!()
+            run_sde(args);
         }
         "time" => {
             todo!()
@@ -74,20 +74,26 @@ fn run_qbdi(mut args: impl Iterator<Item = String>) {
         let root = std::env::current_exe().unwrap();
         let library = root.parent().unwrap().join(library_name);
         if !library.is_file() {
-            eprintln!("{library_name:?} not adjacent to {root:?}. {library} does not exist", library=library.display());
+            eprintln!(
+                "{library_name:?} not adjacent to {root:?}. {library} does not exist",
+                library = library.display()
+            );
             return;
         }
         command.env("DYLD_BIND_AT_LAUNCH", "1");
         command.env("DYLD_INSERT_LIBRARIES", &library.display().to_string());
     }
-    
+
     #[cfg(target_os = "linux")]
     {
         let library_name = "libqbdi_tracer.so";
         let root = std::env::current_exe().unwrap();
         let library = root.parent().unwrap().join(library_name);
         if !library.is_file() {
-            eprintln!("{library_name:?} not adjacent to {root:?}. {library} does not exist", library=library.display());
+            eprintln!(
+                "{library_name:?} not adjacent to {root:?}. {library} does not exist",
+                library = library.display()
+            );
             return;
         }
         command.env("LD_PRELOAD", &library.display().to_string());
@@ -159,9 +165,7 @@ fn run_qbdi(mut args: impl Iterator<Item = String>) {
                 }
             }
 
-            let item = items
-                .entry(func)
-                .or_default();
+            let item = items.entry(func).or_default();
 
             item.total += count;
             item.instruction_kind.push((kind.to_owned(), count));
@@ -174,11 +178,201 @@ fn run_qbdi(mut args: impl Iterator<Item = String>) {
     items.sort_unstable_by_key(|(_, value)| usize::MAX - value.total);
 
     for (func, mut item) in items {
-        print!("{func} - {total} instructions", total=item.total);
-        item.instruction_kind.sort_unstable_by_key(|(_, value)| usize::MAX - value);
+        print!("{func} - {total} instructions", total = item.total);
+        item.instruction_kind
+            .sort_unstable_by_key(|(_, value)| usize::MAX - value);
         for (kind, count) in &item.instruction_kind {
             print!(" ({kind}={count})");
         }
         println!();
     }
 }
+
+fn run_sde(mut args: impl Iterator<Item = String>) {
+    const TEMP_FILE: &str = "sde-out.txt";
+
+    let mut command_string = None;
+    let mut blocks = 20;
+    let mut keep = None;
+
+    let mut format = None;
+    let mut sort = None;
+    let mut sort_direction = utilities::Direction::Ascending;
+    let mut limit = 25;
+    let mut skip_rust_internals = true;
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "program" => {
+                // command_args.push(arg.value.unwrap());
+                command_string = args.next();
+            }
+            "format" => {
+                format = args.next();
+            }
+            "sort" => {
+                sort = args.next();
+            }
+            "sort-desc" => {
+                sort_direction = utilities::Direction::Descending;
+            }
+            "blocks" => {
+                blocks = args.next().unwrap().parse().expect("invalid top blocks");
+            }
+            "limit" => {
+                limit = args.next().unwrap().parse().expect("invalid limit");
+            }
+            "keep" => {
+                keep = args.next();
+            }
+            "all" => {
+                skip_rust_internals = false;
+            }
+            arg => {
+                eprintln!("unknown {arg:?}");
+            }
+        }
+    }
+
+    let file_path: &str = keep.as_deref().unwrap_or(TEMP_FILE);
+
+    {
+        let mut command = Command::new("sde");
+        command.args([
+            "-omix",
+            file_path,
+            "-mix_filter_no_shared_libs",
+            "-top_blocks",
+            &blocks.to_string(),
+            "--",
+        ]);
+        {
+            // TODO use argument parser instead of split
+            let arguments = command_string.expect("no command!");
+            let arguments = arguments.split(' ').collect::<Vec<_>>();
+            command.args(arguments);
+        }
+        // command.args(command_args);
+        command.stdout(Stdio::piped());
+        command.stderr(Stdio::piped());
+
+        let mut child = command.spawn().unwrap();
+        let _ = child.wait().unwrap();
+    }
+
+    let file = std::fs::File::open(file_path).unwrap();
+
+    let sort = sort.as_deref().map(|field| utilities::Sorting {
+        field,
+        direction: sort_direction,
+    });
+
+    let format = format.as_deref().unwrap_or("plain");
+
+    {
+        fn parse_and_print(
+            out: impl BufRead,
+            skip_rust_internals: bool,
+            sort: Option<utilities::Sorting>,
+            limit: usize,
+            format: &str,
+        ) {
+            const MAX_WIDTH: usize = 100;
+            const WHITESPACE: &str = if let Ok(result) = str::from_utf8(&[b' '; MAX_WIDTH]) {
+                result
+            } else {
+                ""
+            };
+
+            let mut rows = sde_output_parser::parse(out, skip_rust_internals);
+
+            if let Some(sort) = sort {
+                match sort.field {
+                    "name" => {
+                        rows.sort_unstable_by(|lhs, rhs| sort.direction.compare(&lhs.0, &rhs.0));
+                    }
+                    "total" => {
+                        rows.sort_unstable_by(|lhs, rhs| {
+                            sort.direction.compare(&lhs.1.total, &rhs.1.total)
+                        });
+                    }
+                    field => {
+                        eprintln!("unknown field {field:?}");
+                    }
+                }
+            }
+
+            let skip = if let Some(utilities::Sorting {
+                direction: utilities::Direction::Descending,
+                ..
+            }) = sort
+            {
+                rows.len().saturating_sub(limit)
+            } else {
+                0
+            };
+
+            if let "plain" = format {
+                let max_name_width = {
+                    let mut max_name_width = 0;
+                    for (name, _) in rows.iter().skip(skip).take(limit) {
+                        max_name_width = std::cmp::max(max_name_width, name.len());
+                    }
+                    std::cmp::min(max_name_width, MAX_WIDTH)
+                };
+
+                for (section, count) in rows.iter().skip(skip).take(limit) {
+                    use std::borrow::Cow;
+                    use utilities::to_denary;
+
+                    let section: Cow<'_, str> = if section.len() > MAX_WIDTH {
+                        Cow::Owned(format!("{prefix}...", prefix = &section[..MAX_WIDTH - 3]))
+                    } else {
+                        Cow::Borrowed(section)
+                    };
+                    let fill = &WHITESPACE[..max_name_width - section.len()];
+
+                    // TODO wip
+                    print!("{section}:{fill}");
+                    print!(" t:  {}", to_denary(count.total as usize, "\u{00A0}"));
+                    print!(" mr: {}", to_denary(count.mem_read as usize, "\u{00A0}"));
+                    print!(" mw: {}", to_denary(count.mem_write as usize, "\u{00A0}"));
+                    print!(" call: {}", to_denary(count.call as usize, "\u{00A0}"));
+                    println!();
+                }
+            } else if let "json" = format {
+                let mut buf = String::from("[");
+                for (section, count) in rows.iter().skip(skip).take(limit) {
+                    if buf.len() > 1 {
+                        buf.push(',');
+                    }
+                    buf.push_str(&json_builder_macro::json! {
+                        name: section.as_str(),
+                        total: count.total,
+                        mem_read: count.mem_read,
+                        mem_write: count.mem_write,
+                        stack_read: count.stack_read,
+                        stack_write: count.stack_write,
+                        call: count.call,
+                    });
+                }
+                buf.push(']');
+                println!("{buf}");
+            } else {
+                eprintln!("unknown format {format:?}");
+            }
+        }
+
+        parse_and_print(
+            BufReader::new(file),
+            skip_rust_internals,
+            sort,
+            limit,
+            format,
+        );
+    }
+
+    if keep.is_none() {
+        std::fs::remove_file(file_path).unwrap();
+    }
+}

benchmarking-tool/main.rs

@@ -6,4 +6,3 @@ publish = false
 
 [lib]
 path = "lib.rs"
-

benchmarking-tool/sde-output-parser/Cargo.lock

@@ -74,6 +74,44 @@ impl<'a> Iterator for ArgumentIter<'a> {
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Sorting<'a> {
+    pub field: &'a str,
+    pub direction: Direction,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Direction {
+    Ascending,
+    Descending,
+}
+
+impl Direction {
+    pub fn compare<T: std::cmp::Ord>(self, a: &T, b: &T) -> std::cmp::Ordering {
+        let order = a.cmp(b);
+        if let Self::Ascending = self {
+            order.reverse()
+        } else {
+            order
+        }
+    }
+}
+
+pub(crate) fn to_denary(value: usize, seperator: &str) -> String {
+    if value == 0 {
+        return "0".to_owned();
+    }
+    let mut buf = String::new();
+    for i in (0..=value.ilog10()).rev() {
+        let j = (value / 10i32.pow(i) as usize) % 10;
+        buf.push(b"0123456789"[j] as char);
+        if i > 0 && i % 3 == 0 {
+            buf.push_str(seperator);
+        }
+    }
+    buf
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;