remove cache key and use present fields to generate hash

Author: Shourya742

src/bootstrap/src/utils/exec.rs

@@ -7,7 +7,7 @@
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fmt::{Debug, Formatter};
-use std::hash::{Hash, Hasher};
+use std::hash::{DefaultHasher, Hash, Hasher};
 use std::path::Path;
 use std::process::{Command, CommandArgs, CommandEnvs, ExitStatus, Output, Stdio};
 use std::sync::Mutex;
@@ -55,14 +55,6 @@ impl OutputMode {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
-pub struct CommandCacheKey {
-    program: String,
-    args: Vec<String>,
-    envs: Vec<(String, String)>,
-    cwd: Option<PathBuf>,
-}
-
 /// Wrapper around `std::process::Command`.
 ///
 /// By default, the command will exit bootstrap if it fails.
@@ -234,13 +226,13 @@ impl<'a> BootstrapCommand {
         }
     }
 
-    pub fn cache_key(&self) -> CommandCacheKey {
-        CommandCacheKey {
-            program: self.program.clone(),
-            args: self.args.clone(),
-            envs: self.envs.clone(),
-            cwd: self.cwd.clone(),
-        }
+    pub fn compute_cache_hash(&self) -> u64 {
+        let mut hasher = DefaultHasher::new();
+        self.program.hash(&mut hasher);
+        self.args.hash(&mut hasher);
+        self.envs.hash(&mut hasher);
+        self.cwd.hash(&mut hasher);
+        hasher.finish()
     }
 }
 
@@ -387,6 +379,26 @@ impl Default for CommandOutput {
     }
 }
 
+impl Hash for BootstrapCommand {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.program.hash(state);
+        self.args.hash(state);
+        self.envs.hash(state);
+        self.cwd.hash(state);
+    }
+}
+
+impl PartialEq for BootstrapCommand {
+    fn eq(&self, other: &Self) -> bool {
+        self.program == other.program
+            && self.args == other.args
+            && self.envs == other.envs
+            && self.cwd == other.cwd
+    }
+}
+
+impl Eq for BootstrapCommand {}
+
 /// Helper trait to format both Command and BootstrapCommand as a short execution line,
 /// without all the other details (e.g. environment variables).
 #[cfg(feature = "tracing")]

src/bootstrap/src/utils/execution_context.rs

@@ -12,7 +12,6 @@ use std::sync::{Arc, Mutex};
 use crate::core::config::DryRun;
 #[cfg(feature = "tracing")]
 use crate::trace_cmd;
-use crate::utils::exec::CommandCacheKey;
 use crate::{BehaviorOnFailure, BootstrapCommand, CommandOutput, OutputMode, exit};
 
 #[derive(Clone, Default)]
@@ -26,19 +25,19 @@ pub struct ExecutionContext {
 
 #[derive(Default)]
 pub struct CommandCache {
-    cache: Mutex<HashMap<CommandCacheKey, CommandOutput>>,
+    cache: Mutex<HashMap<u64, CommandOutput>>,
 }
 
 impl CommandCache {
     pub fn new() -> Self {
         Self { cache: Mutex::new(HashMap::new()) }
     }
 
-    pub fn get(&self, key: &CommandCacheKey) -> Option<CommandOutput> {
-        self.cache.lock().unwrap().get(key).cloned()
+    pub fn get(&self, key: u64) -> Option<CommandOutput> {
+        self.cache.lock().unwrap().get(&key).cloned()
     }
 
-    pub fn insert(&self, key: CommandCacheKey, output: CommandOutput) {
+    pub fn insert(&self, key: u64, output: CommandOutput) {
         self.cache.lock().unwrap().insert(key, output);
     }
 }
@@ -146,9 +145,9 @@ impl ExecutionContext {
         stdout: OutputMode,
         stderr: OutputMode,
     ) -> CommandOutput {
-        let cache_key = command.cache_key();
+        let cache_key = command.compute_cache_hash();
 
-        if let Some(cached_output) = self.command_cache.get(&cache_key) {
+        if let Some(cached_output) = self.command_cache.get(cache_key) {
             command.mark_as_executed();
             if self.dry_run() && !command.run_always {
                 return CommandOutput::default();
@@ -159,9 +158,11 @@ impl ExecutionContext {
 
         let output = self.start(command, stdout, stderr).wait_for_output(self);
 
-        if output != CommandOutput::default() {
-            self.command_cache.insert(cache_key, output.clone());
-        }
+        self.command_cache.insert(cache_key, output.clone());
+
+        // if output != CommandOutput::default() {
+        //     self.command_cache.insert(cache_key, output.clone());
+        // }
 
         output
     }