lints & refactors

3 files changed, 221 insertions, 204 deletions

diff --git a/src/crates/candelabra/src/profiler.rs b/src/crates/candelabra/src/profiler/info.rs
index 4677bbc..dc9a03c 100644
--- a/src/crates/candelabra/src/profiler.rs
+++ b/src/crates/candelabra/src/profiler/info.rs
@@ -1,33 +1,10 @@
-//! Profiling applications for info about container usage
-
-use anyhow::{anyhow, Context, Result};
-use camino::{Utf8Path, Utf8PathBuf};
-use log::{debug, log_enabled, trace, warn, Level};
-use primrose::ContainerSelector;
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::io::Write;
 use std::str::FromStr;
-use std::{
-    fs::{read_dir, File},
-    io::Read,
-    process::{Command, Stdio},
-};
-use tempfile::tempdir;
-
-use crate::cache::{gen_tree_hash, FileCache};
-use crate::candidates::ConTypeName;
-use crate::cost::benchmark::{tee_output, OpName};
-use crate::cost::{Cost, CostModel, Estimator};
-use crate::project::Project;
-use crate::{Paths, State};
-
-#[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct CacheEntry {
-    proj_hash: u64,
-    proj_location: Utf8PathBuf,
-    info: HashMap<ConTypeName, ProfilerInfo>,
-}
+
+use anyhow::{anyhow, Result};
+use serde::{Deserialize, Serialize};
+
+use crate::cost::{benchmark::OpName, Cost, CostModel, Estimator};
 
 /// The information we get from profiling.
 /// Rather than keeping all results, we split them into 'similar enough' partitions,
@@ -35,7 +12,7 @@ pub(crate) struct CacheEntry {
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct ProfilerInfo(pub Vec<ProfilerPartition>);
 
-/// A vector of container lifetimes which have similar characteristics
+/// A vector of container lifetimes which have similar usage characteristics
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct ProfilerPartition {
     pub occurences: f64,
@@ -43,10 +20,21 @@ pub struct ProfilerPartition {
     pub avg_op_counts: HashMap<OpName, f64>,
 }
 
-/// Breakdown of a cost value
+/// Lifetime of a single allocated collection.
+type CollectionLifetime = (f64, HashMap<OpName, usize>);
+
+/// Breakdown of a cost value by operation
 pub type CostBreakdown<'a> = HashMap<&'a OpName, Cost>;
 
 impl ProfilerInfo {
+    pub fn from(iter: impl Iterator<Item = Result<String>>) -> Result<Self> {
+        Ok(Self(
+            iter.map(|contents| parse_output(&contents?))
+                .fold(Ok(vec![]), partition_costs)?,
+        ))
+    }
+
+    /// Estimate the cost of using the implementation with the given cost model
     pub fn estimate_cost(&self, cost_model: &CostModel) -> f64 {
         self.0
             .iter()
@@ -54,6 +42,7 @@ impl ProfilerInfo {
             .sum::<f64>()
     }
 
+    /// Get a breakdown of the cost by operation
     pub fn cost_breakdown<'a>(&self, cost_model: &'a CostModel) -> CostBreakdown<'a> {
         cost_model
             .by_op
@@ -104,178 +93,6 @@ impl ProfilerPartition {
     }
 }
 
-impl State {
-    pub(crate) fn profiler_info_cache(paths: &Paths) -> Result<FileCache<String, CacheEntry>> {
-        FileCache::new(
-            paths.target_dir.join("candelabra").join("profiler_info"),
-            |_, v: &CacheEntry| {
-                let proj_hash = gen_tree_hash(&v.proj_location).unwrap_or(0);
-                v.proj_hash == proj_hash
-            },
-        )
-    }
-
-    /// Get or calculate profiler info for the given project.
-    /// Results are cached by the modification time of the project's source tree
-    pub fn profiler_info(&self, project: &Project) -> Result<HashMap<ConTypeName, ProfilerInfo>> {
-        match self.profiler_info_cache.find(&project.name)? {
-            Some(x) => Ok(x.info),
-            None => {
-                let info = self.calc_profiler_info(project)?;
-
-                let proj_hash = gen_tree_hash(&project.source_dir)
-                    .context("Error generating project directory hash")?;
-                if let Err(e) = self.profiler_info_cache.put(
-                    &project.name,
-                    &CacheEntry {
-                        proj_hash,
-                        proj_location: project.source_dir.clone(),
-                        info: info.clone(),
-                    },
-                ) {
-                    warn!("Error caching profiler info for {}: {}", &project.name, e);
-                }
-
-                Ok(info)
-            }
-        }
-    }
-
-    /// Calculate profiler info for the given project.
-    fn calc_profiler_info(&self, project: &Project) -> Result<HashMap<ConTypeName, ProfilerInfo>> {
-        let candidate_list = self.project_candidate_list(project)?;
-        let con_types = candidate_list
-            .iter()
-            .flat_map(|(_, con_types)| con_types.iter())
-            .map(|(id, _)| id)
-            .collect::<Vec<_>>();
-
-        self.project_profiling_prep(project, &con_types)?;
-        let mut acc = HashMap::new();
-        for name in project.benchmarks.iter() {
-            for (con_type, new_results) in self
-                .profile_benchmark(project, name, &con_types)
-                .with_context(|| format!("Error profiling benchmark {}", name))?
-            {
-                acc.entry(con_type)
-                    .and_modify(|pi: &mut ProfilerInfo| pi.0.extend(new_results.0.iter().cloned()))
-                    .or_insert(new_results);
-            }
-        }
-
-        Ok(acc)
-    }
-
-    /// Prepare the given project to be profiled, by replacing all candidate types with the profiler wrapper.
-    fn project_profiling_prep(&self, project: &Project, con_types: &[&String]) -> Result<()> {
-        for (file, candidates) in self.project_candidate_list(project)? {
-            self.file_profiling_prep(&file, &candidates, con_types)
-                .with_context(|| format!("error preparing {} for profiling", file))?;
-        }
-
-        Ok(())
-    }
-
-    /// Prepare the given file to be profiled, by replacing all candidate types with the profiler wrapper.
-    fn file_profiling_prep(
-        &self,
-        file: &Utf8Path,
-        candidates: &[(String, Vec<String>)],
-        con_types: &[&String],
-    ) -> Result<()> {
-        debug!("Setting up {} for profiling", file);
-
-        let selector = ContainerSelector::from_path(
-            file.as_std_path(),
-            self.paths.library_src.as_std_path(),
-            self.model_size,
-        )
-        .context("error creating container selector")?;
-
-        let chosen = candidates
-            .iter()
-            .map(|(dest_name, impls)| (dest_name, &impls[0]))
-            .collect::<Vec<_>>();
-
-        let new_code = selector.gen_profiling_file(chosen.iter().map(|(d, c)| {
-            (
-                *d,
-                con_types.iter().position(|id| id == d).unwrap(),
-                c.as_str(),
-            )
-        }));
-
-        let new_path = file.to_string().replace(".pr", "");
-
-        trace!("New code: {}", new_code);
-        trace!("New path: {}", new_path);
-
-        let mut f = File::create(new_path).context("error creating new source file")?;
-        f.write_all(new_code.as_bytes())
-            .context("error writing new code")?;
-
-        Ok(())
-    }
-
-    /// Run the given benchmark on the project, and parse the resulting profiling information.
-    fn profile_benchmark(
-        &self,
-        project: &Project,
-        name: &str,
-        con_types: &[&String],
-    ) -> Result<HashMap<String, ProfilerInfo>> {
-        let profiler_out_dir = tempdir()?;
-        debug!(
-            "Running benchmark {} with out dir {:?}",
-            name, profiler_out_dir
-        );
-
-        let child = Command::new("cargo")
-            .current_dir(&project.source_dir)
-            .args(["bench", "--bench", name])
-            .env("PROFILER_OUT_DIR", profiler_out_dir.as_ref()) // Where profiler info gets outputted
-            .stdout(Stdio::piped())
-            .stderr(if log_enabled!(Level::Debug) {
-                Stdio::inherit()
-            } else {
-                Stdio::null()
-            })
-            .spawn()
-            .context("Error running bench command")?;
-
-        tee_output(child)?;
-
-        let mut con_type_results = HashMap::new();
-        for dir in read_dir(&profiler_out_dir)? {
-            // each directory has an index, corresponding to the container type name
-            let dir = dir?;
-            let con_type: String = con_types[dir
-                .file_name()
-                .into_string()
-                .unwrap()
-                .parse::<usize>()
-                .unwrap()]
-            .to_string();
-
-            let partitions = read_dir(dir.path())?
-                .map(|f| -> Result<String> {
-                    // read file contents
-                    let mut contents = String::new();
-                    File::open(f?.path())?.read_to_string(&mut contents)?;
-                    Ok(contents)
-                })
-                .map(|contents| parse_output(&contents?))
-                .fold(Ok(vec![]), partition_costs)?;
-
-            con_type_results.insert(con_type, ProfilerInfo(partitions));
-        }
-
-        Ok(con_type_results)
-    }
-}
-
-type CollectionLifetime = (f64, HashMap<OpName, usize>);
-
 /// Attempt to compress an iterator of collection lifetimes into as few partitions as possible
 fn partition_costs(
     acc: Result<Vec<ProfilerPartition>>,
@@ -367,7 +184,7 @@ mod tests {
 
     use crate::{
         cost::{CostModel, Estimator},
-        profiler::partition_costs,
+        profiler::info::partition_costs,
     };
 
     use super::{ProfilerInfo, ProfilerPartition};
diff --git a/src/crates/candelabra/src/profiler/mod.rs b/src/crates/candelabra/src/profiler/mod.rs
new file mode 100644
index 0000000..568929b
--- /dev/null
+++ b/src/crates/candelabra/src/profiler/mod.rs
@@ -0,0 +1,200 @@
+//! Profiling applications for info about container usage
+
+mod info;
+
+use anyhow::{Context, Result};
+use camino::{Utf8Path, Utf8PathBuf};
+use log::{debug, log_enabled, trace, warn, Level};
+use primrose::ContainerSelector;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::io::Write;
+use std::{
+    fs::{read_dir, File},
+    io::Read,
+    process::{Command, Stdio},
+};
+use tempfile::tempdir;
+
+use crate::cache::{gen_tree_hash, FileCache};
+use crate::candidates::ConTypeName;
+use crate::cost::benchmark::tee_output;
+use crate::project::Project;
+use crate::{Paths, State};
+
+pub use self::info::{ProfilerInfo, ProfilerPartition};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct CacheEntry {
+    proj_hash: u64,
+    proj_location: Utf8PathBuf,
+    info: HashMap<ConTypeName, ProfilerInfo>,
+}
+
+impl State {
+    pub(crate) fn profiler_info_cache(paths: &Paths) -> Result<FileCache<String, CacheEntry>> {
+        FileCache::new(
+            paths.target_dir.join("candelabra").join("profiler_info"),
+            |_, v: &CacheEntry| {
+                let proj_hash = gen_tree_hash(&v.proj_location).unwrap_or(0);
+                v.proj_hash == proj_hash
+            },
+        )
+    }
+
+    /// Get or calculate profiler info for the given project.
+    /// Results are cached by the modification time of the project's source tree
+    pub fn profiler_info(&self, project: &Project) -> Result<HashMap<ConTypeName, ProfilerInfo>> {
+        match self.profiler_info_cache.find(&project.name)? {
+            Some(x) => Ok(x.info),
+            None => {
+                let info = self.calc_profiler_info(project)?;
+
+                let proj_hash = gen_tree_hash(&project.source_dir)
+                    .context("Error generating project directory hash")?;
+                if let Err(e) = self.profiler_info_cache.put(
+                    &project.name,
+                    &CacheEntry {
+                        proj_hash,
+                        proj_location: project.source_dir.clone(),
+                        info: info.clone(),
+                    },
+                ) {
+                    warn!("Error caching profiler info for {}: {}", &project.name, e);
+                }
+
+                Ok(info)
+            }
+        }
+    }
+
+    /// Calculate profiler info for the given project.
+    fn calc_profiler_info(&self, project: &Project) -> Result<HashMap<ConTypeName, ProfilerInfo>> {
+        let candidate_list = self.project_candidate_list(project)?;
+        let con_types = candidate_list
+            .iter()
+            .flat_map(|(_, con_types)| con_types.iter())
+            .map(|(id, _)| id)
+            .collect::<Vec<_>>();
+
+        self.project_profiling_prep(project, &con_types)?;
+        let mut acc = HashMap::new();
+        for name in project.benchmarks.iter() {
+            for (con_type, new_results) in self
+                .profile_benchmark(project, name, &con_types)
+                .with_context(|| format!("Error profiling benchmark {}", name))?
+            {
+                acc.entry(con_type)
+                    .and_modify(|pi: &mut ProfilerInfo| pi.0.extend(new_results.0.iter().cloned()))
+                    .or_insert(new_results);
+            }
+        }
+
+        Ok(acc)
+    }
+
+    /// Prepare the given project to be profiled, by replacing all candidate types with the profiler wrapper.
+    fn project_profiling_prep(&self, project: &Project, con_types: &[&String]) -> Result<()> {
+        for (file, candidates) in self.project_candidate_list(project)? {
+            self.file_profiling_prep(&file, &candidates, con_types)
+                .with_context(|| format!("error preparing {} for profiling", file))?;
+        }
+
+        Ok(())
+    }
+
+    /// Prepare the given file to be profiled, by replacing all candidate types with the profiler wrapper.
+    fn file_profiling_prep(
+        &self,
+        file: &Utf8Path,
+        candidates: &[(String, Vec<String>)],
+        con_types: &[&String],
+    ) -> Result<()> {
+        debug!("Setting up {} for profiling", file);
+
+        let selector = ContainerSelector::from_path(
+            file.as_std_path(),
+            self.paths.library_src.as_std_path(),
+            self.model_size,
+        )
+        .context("error creating container selector")?;
+
+        let chosen = candidates
+            .iter()
+            .map(|(dest_name, impls)| (dest_name, &impls[0]))
+            .collect::<Vec<_>>();
+
+        let new_code = selector.gen_profiling_file(chosen.iter().map(|(d, c)| {
+            (
+                *d,
+                con_types.iter().position(|id| id == d).unwrap(),
+                c.as_str(),
+            )
+        }));
+
+        let new_path = file.to_string().replace(".pr", "");
+
+        trace!("New code: {}", new_code);
+        trace!("New path: {}", new_path);
+
+        let mut f = File::create(new_path).context("error creating new source file")?;
+        f.write_all(new_code.as_bytes())
+            .context("error writing new code")?;
+
+        Ok(())
+    }
+
+    /// Run the given benchmark on the project, and parse the resulting profiling information.
+    fn profile_benchmark(
+        &self,
+        project: &Project,
+        name: &str,
+        con_types: &[&String],
+    ) -> Result<HashMap<String, ProfilerInfo>> {
+        let profiler_out_dir = tempdir()?;
+        debug!(
+            "Running benchmark {} with out dir {:?}",
+            name, profiler_out_dir
+        );
+
+        let child = Command::new("cargo")
+            .current_dir(&project.source_dir)
+            .args(["bench", "--bench", name])
+            .env("PROFILER_OUT_DIR", profiler_out_dir.as_ref()) // Where profiler info gets outputted
+            .stdout(Stdio::piped())
+            .stderr(if log_enabled!(Level::Debug) {
+                Stdio::inherit()
+            } else {
+                Stdio::null()
+            })
+            .spawn()
+            .context("Error running bench command")?;
+
+        tee_output(child)?;
+
+        let mut con_type_results = HashMap::new();
+        for dir in read_dir(&profiler_out_dir)? {
+            // each directory has an index, corresponding to the container type name
+            let dir = dir?;
+            let con_type: String = con_types[dir
+                .file_name()
+                .into_string()
+                .unwrap()
+                .parse::<usize>()
+                .unwrap()]
+            .to_string();
+
+            con_type_results.insert(
+                con_type,
+                ProfilerInfo::from(read_dir(dir.path())?.map(|f| -> Result<String> {
+                    // read file contents
+                    let mut contents = String::new();
+                    File::open(f?.path())?.read_to_string(&mut contents)?;
+                    Ok(contents)
+                }))?,
+            );
+        }
+
+        Ok(con_type_results)
+    }
+}
diff --git a/src/crates/cli/src/display.rs b/src/crates/cli/src/display.rs
index 2ce9039..2debede 100644
--- a/src/crates/cli/src/display.rs
+++ b/src/crates/cli/src/display.rs
@@ -51,7 +51,7 @@ pub fn display_profiler_info(profile_info: ProfilerInfo) {
                 ("occurences".to_string(), p.occurences),
             ]
             .into_iter()
-            .chain(p.avg_op_counts.into_iter()),
+            .chain(p.avg_op_counts),
         )
     }))
 }