Src code analyze frame

collector/src/execute/mod.rs

@@ -93,6 +93,13 @@ impl Stats {
     pub fn insert(&mut self, stat: String, value: f64) {
         self.stats.insert(stat, value);
     }
+
+    pub fn add_or_insert(&mut self, stat: String, value: f64) {
+        match self.stats.get_mut(&stat) {
+            Some(e) => *e += value,
+            None => self.insert(stat, value),
+        }
+    }
 }
 
 impl Add for Stats {

collector/src/main.rs

@@ -5,7 +5,7 @@ use std::{
     process::{self, Command},
 };
 
-use anyhow::{Context, Ok};
+use anyhow::{bail, Context, Ok};
 use benchmark::scenario::Scenario;
 use clap::Parser;
 use compile_time::{
@@ -18,6 +18,7 @@ use compile_time::{
 };
 use mir_analyze::mir_generate::generate_mir;
 use runtime::bench_runtime;
+use src_code_analyze::entry::src_code_analyze;
 use toolchain::{Cli, Commands, ResultWriter};
 
 use crate::{
@@ -35,6 +36,7 @@ mod morpheme_miner;
 mod pca_analysis;
 mod perf_analyze;
 mod runtime;
+mod src_code_analyze;
 mod statistics;
 mod toolchain;
 mod utils;
@@ -307,6 +309,20 @@ fn main_result() -> anyhow::Result<i32> {
 
             Ok(0)
         }
+        Commands::SourceCodeAnalyze {
+            bench_dir,
+            dependency_dir,
+            out_path,
+        } => match src_code_analyze(bench_dir, dependency_dir, out_path) {
+            anyhow::Result::Ok(p) => {
+                println!(
+                    "Write analyze result to {}.",
+                    p.as_os_str().to_str().unwrap()
+                );
+                Ok(0)
+            }
+            Err(e) => bail!("{}", e),
+        },
     }
 }
 

collector/src/src_code_analyze/analyzer.rs

@@ -0,0 +1,70 @@
+use std::collections::HashSet;
+use std::fs::File;
+use std::io::{BufReader, Read};
+use std::path::PathBuf;
+
+use crate::execute::Stats;
+
+use crate::{
+    benchmark::{benchmark::Benchamrk, profile::Profile, scenario::Scenario},
+    statistics::compile_time_stat::CompileTimeResult,
+};
+
+use super::dependancy::read_dependencies;
+
+pub fn analyze_benchmark(
+    benchmark: &Benchamrk,
+    dependency_dir: &PathBuf,
+    ops: &Vec<Box<dyn Fn(&String) -> (String, f64)>>,
+) -> CompileTimeResult {
+    eprintln!(
+        "analyzing benchmark {} {}",
+        benchmark.name,
+        benchmark.path.to_str().unwrap()
+    );
+    let stats = analyze_dir(&benchmark.path, dependency_dir, ops, &mut HashSet::new()).unwrap();
+    CompileTimeResult::new(
+        benchmark.name.clone(),
+        0,
+        Profile::Check,
+        Scenario::Full,
+        stats,
+    )
+}
+
+fn analyze_dir(
+    p: &PathBuf,
+    dependency_dir: &PathBuf,
+    ops: &Vec<Box<dyn Fn(&String) -> (String, f64)>>,
+    analyzed_dependency: &mut HashSet<PathBuf>,
+) -> anyhow::Result<Stats> {
+    let mut stats = Stats::new();
+    for entry in p.read_dir()? {
+        let entry = entry?;
+        if entry.file_type()?.is_dir() {
+            stats += analyze_dir(&entry.path(), dependency_dir, ops, analyzed_dependency)?;
+        } else if entry.file_type()?.is_file() {
+            if entry.file_name().to_str().unwrap().ends_with(".rs") {
+                let mut reader = BufReader::new(File::open(entry.path())?);
+                let mut buf = vec![];
+                reader.read_to_end(&mut buf)?;
+                if let Ok(buf) = String::from_utf8(buf) {
+                    ops.iter().for_each(|op| {
+                        let t = op(&buf);
+                        stats.add_or_insert(t.0, t.1)
+                    });
+                }
+            } else if entry.file_name().to_str().unwrap().eq("Cargo.lock") {
+                for d in read_dependencies(&entry.path())? {
+                    let path = &d.path(dependency_dir);
+                    if path.exists() && !analyzed_dependency.contains(path) {
+                        println!("  |---analyzing {}", d);
+                        analyzed_dependency.insert(path.clone());
+                        stats += analyze_dir(path, dependency_dir, ops, analyzed_dependency)?;
+                    }
+                }
+            }
+        }
+    }
+    Ok(stats)
+}