Intern units for fast hashing

This commit starts to intern `Unit` structures for a few reasons:

* This primarily makes equality and hashing much faster. We have tons of
  hash lookups with units, and they were showing up quite high
  in profiles. It turns out `Unit` hashes a *ton* of data, and most of
  it is always redundant. To handle this they're all only hashed once
  now and hashing/equality are just pointer checks.

* The size of `Unit` is now drastically reduced to just one pointer, so
  movement of units throughout the backend should be much more
  efficient.

Author: alexcrichton

src/cargo/core/compiler/build_context/mod.rs

@@ -9,8 +9,8 @@ use crate::core::{Dependency, Workspace};
 use crate::core::{PackageId, PackageSet, Resolve};
 use crate::util::errors::CargoResult;
 use crate::util::{profile, Cfg, Config, Rustc};
-
-use super::{BuildConfig, BuildOutput, Kind, Unit};
+use crate::core::compiler::{Unit, Kind, BuildConfig, BuildOutput};
+use crate::core::compiler::unit::UnitInterner;
 
 mod target_info;
 pub use self::target_info::{FileFlavor, TargetInfo};
@@ -37,6 +37,7 @@ pub struct BuildContext<'a, 'cfg: 'a> {
     pub target_config: TargetConfig,
     pub target_info: TargetInfo,
     pub host_info: TargetInfo,
+    pub units: &'a UnitInterner<'a>,
 }
 
 impl<'a, 'cfg> BuildContext<'a, 'cfg> {
@@ -47,6 +48,7 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
         config: &'cfg Config,
         build_config: &'a BuildConfig,
         profiles: &'a Profiles,
+        units: &'a UnitInterner<'a>,
         extra_compiler_args: HashMap<Unit<'a>, Vec<String>>,
     ) -> CargoResult<BuildContext<'a, 'cfg>> {
         let mut rustc = config.load_global_rustc(Some(ws))?;
@@ -82,6 +84,7 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
             build_config,
             profiles,
             extra_compiler_args,
+            units,
         })
     }
 

src/cargo/core/compiler/build_context/target_info.rs

@@ -4,7 +4,7 @@ use std::env;
 use std::path::PathBuf;
 use std::str::{self, FromStr};
 
-use super::Kind;
+use crate::core::compiler::Kind;
 use crate::core::TargetKind;
 use crate::util::CfgExpr;
 use crate::util::{CargoResult, CargoResultExt, Cfg, Config, ProcessBuilder, Rustc};

src/cargo/core/compiler/build_plan.rs

@@ -109,7 +109,7 @@ impl BuildPlan {
         }
     }
 
-    pub fn add(&mut self, cx: &Context<'_, '_>, unit: &Unit<'_>) -> CargoResult<()> {
+    pub fn add<'a>(&mut self, cx: &Context<'a, '_>, unit: &Unit<'a>) -> CargoResult<()> {
         let id = self.plan.invocations.len();
         self.invocation_map.insert(unit.buildkey(), id);
         let deps = cx

src/cargo/core/compiler/context/compilation_files.rs

@@ -8,7 +8,8 @@ use std::sync::Arc;
 use lazycell::LazyCell;
 use log::info;
 
-use super::{BuildContext, Context, FileFlavor, Kind, Layout, Unit};
+use super::{BuildContext, Context, FileFlavor, Kind, Layout};
+use crate::core::compiler::Unit;
 use crate::core::{TargetKind, Workspace};
 use crate::util::{self, CargoResult};
 

src/cargo/core/compiler/context/mod.rs

@@ -8,10 +8,10 @@ use std::sync::Arc;
 use jobserver::Client;
 
 use crate::core::compiler::compilation;
-use crate::core::profiles::Profile;
-use crate::core::{Package, PackageId, Resolve, Target};
+use crate::core::compiler::Unit;
+use crate::core::{Package, PackageId, Resolve};
 use crate::util::errors::{CargoResult, CargoResultExt};
-use crate::util::{internal, profile, short_hash, Config};
+use crate::util::{internal, profile, Config};
 
 use super::build_plan::BuildPlan;
 use super::custom_build::{self, BuildDeps, BuildScripts, BuildState};
@@ -27,49 +27,6 @@ mod compilation_files;
 use self::compilation_files::CompilationFiles;
 pub use self::compilation_files::{Metadata, OutputFile};
 
-/// All information needed to define a unit.
-///
-/// A unit is an object that has enough information so that cargo knows how to build it.
-/// For example, if your package has dependencies, then every dependency will be built as a library
-/// unit. If your package is a library, then it will be built as a library unit as well, or if it
-/// is a binary with `main.rs`, then a binary will be output. There are also separate unit types
-/// for `test`ing and `check`ing, amongst others.
-///
-/// The unit also holds information about all possible metadata about the package in `pkg`.
-///
-/// A unit needs to know extra information in addition to the type and root source file. For
-/// example, it needs to know the target architecture (OS, chip arch etc.) and it needs to know
-/// whether you want a debug or release build. There is enough information in this struct to figure
-/// all that out.
-#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, PartialOrd, Ord)]
-pub struct Unit<'a> {
-    /// Information about available targets, which files to include/exclude, etc. Basically stuff in
-    /// `Cargo.toml`.
-    pub pkg: &'a Package,
-    /// Information about the specific target to build, out of the possible targets in `pkg`. Not
-    /// to be confused with *target-triple* (or *target architecture* ...), the target arch for a
-    /// build.
-    pub target: &'a Target,
-    /// The profile contains information about *how* the build should be run, including debug
-    /// level, etc.
-    pub profile: Profile,
-    /// Whether this compilation unit is for the host or target architecture.
-    ///
-    /// For example, when
-    /// cross compiling and using a custom build script, the build script needs to be compiled for
-    /// the host architecture so the host rustc can use it (when compiling to the target
-    /// architecture).
-    pub kind: Kind,
-    /// The "mode" this unit is being compiled for. See [`CompileMode`] for more details.
-    pub mode: CompileMode,
-}
-
-impl<'a> Unit<'a> {
-    pub fn buildkey(&self) -> String {
-        format!("{}-{}", self.pkg.name(), short_hash(self))
-    }
-}
-
 pub struct Context<'a, 'cfg: 'a> {
     pub bcx: &'a BuildContext<'a, 'cfg>,
     pub compilation: Compilation<'cfg>,

src/cargo/core/compiler/context/unit_dependencies.rs

@@ -20,7 +20,8 @@ use std::collections::{HashMap, HashSet};
 
 use log::trace;
 
-use super::{BuildContext, CompileMode, Kind, Unit};
+use super::{BuildContext, CompileMode, Kind};
+use crate::core::compiler::Unit;
 use crate::core::dependency::Kind as DepKind;
 use crate::core::package::Downloads;
 use crate::core::profiles::UnitFor;
@@ -350,7 +351,7 @@ fn compute_deps_doc<'a, 'cfg, 'tmp>(
 
 fn maybe_lib<'a>(
     unit: &Unit<'a>,
-    bcx: &BuildContext<'_, '_>,
+    bcx: &BuildContext<'a, '_>,
     unit_for: UnitFor,
 ) -> Option<(Unit<'a>, UnitFor)> {
     unit.pkg.targets().iter().find(|t| t.linkable()).map(|t| {
@@ -369,7 +370,7 @@ fn maybe_lib<'a>(
 /// build script.
 fn dep_build_script<'a>(
     unit: &Unit<'a>,
-    bcx: &BuildContext<'_, '_>,
+    bcx: &BuildContext<'a, '_>,
 ) -> Option<(Unit<'a>, UnitFor)> {
     unit.pkg
         .targets()
@@ -378,16 +379,15 @@ fn dep_build_script<'a>(
         .map(|t| {
             // The profile stored in the Unit is the profile for the thing
             // the custom build script is running for.
-            (
-                Unit {
-                    pkg: unit.pkg,
-                    target: t,
-                    profile: bcx.profiles.get_profile_run_custom_build(&unit.profile),
-                    kind: unit.kind,
-                    mode: CompileMode::RunCustomBuild,
-                },
-                UnitFor::new_build(),
-            )
+            let unit = bcx.units.intern(
+                unit.pkg,
+                t,
+                bcx.profiles.get_profile_run_custom_build(&unit.profile),
+                unit.kind,
+                CompileMode::RunCustomBuild,
+            );
+
+            (unit, UnitFor::new_build())
         })
 }
 
@@ -410,7 +410,7 @@ fn check_or_build_mode(mode: CompileMode, target: &Target) -> CompileMode {
 }
 
 fn new_unit<'a>(
-    bcx: &BuildContext<'_, '_>,
+    bcx: &BuildContext<'a, '_>,
     pkg: &'a Package,
     target: &'a Target,
     unit_for: UnitFor,
@@ -424,13 +424,8 @@ fn new_unit<'a>(
         mode,
         bcx.build_config.release,
     );
-    Unit {
-        pkg,
-        target,
-        profile,
-        kind,
-        mode,
-    }
+
+    bcx.units.intern(pkg, target, profile, kind, mode)
 }
 
 /// Fill in missing dependencies for units of the `RunCustomBuild`

src/cargo/core/compiler/mod.rs

@@ -9,6 +9,7 @@ mod job;
 mod job_queue;
 mod layout;
 mod output_depinfo;
+mod unit;
 
 use std::env;
 use std::ffi::{OsStr, OsString};
@@ -26,13 +27,14 @@ pub use self::build_config::{BuildConfig, CompileMode, MessageFormat};
 pub use self::build_context::{BuildContext, FileFlavor, TargetConfig, TargetInfo};
 use self::build_plan::BuildPlan;
 pub use self::compilation::{Compilation, Doctest};
-pub use self::context::{Context, Unit};
+pub use self::context::Context;
 pub use self::custom_build::{BuildMap, BuildOutput, BuildScripts};
-use self::job::{Job, Work};
 pub use self::job::Freshness;
+use self::job::{Job, Work};
 use self::job_queue::JobQueue;
 pub use self::layout::is_bad_artifact_name;
 use self::output_depinfo::output_depinfo;
+pub use crate::core::compiler::unit::{Unit, UnitInterner};
 use crate::core::manifest::TargetSourcePath;
 use crate::core::profiles::{Lto, PanicStrategy, Profile};
 use crate::core::{PackageId, Target};

src/cargo/core/compiler/unit.rs

@@ -0,0 +1,139 @@
+use crate::core::compiler::{CompileMode, Kind};
+use crate::core::{profiles::Profile, Package, Target};
+use crate::util::hex::short_hash;
+use std::cell::RefCell;
+use std::collections::HashSet;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+
+/// All information needed to define a unit.
+///
+/// A unit is an object that has enough information so that cargo knows how to build it.
+/// For example, if your package has dependencies, then every dependency will be built as a library
+/// unit. If your package is a library, then it will be built as a library unit as well, or if it
+/// is a binary with `main.rs`, then a binary will be output. There are also separate unit types
+/// for `test`ing and `check`ing, amongst others.
+///
+/// The unit also holds information about all possible metadata about the package in `pkg`.
+///
+/// A unit needs to know extra information in addition to the type and root source file. For
+/// example, it needs to know the target architecture (OS, chip arch etc.) and it needs to know
+/// whether you want a debug or release build. There is enough information in this struct to figure
+/// all that out.
+#[derive(Clone, Copy, PartialOrd, Ord)]
+pub struct Unit<'a> {
+    inner: &'a UnitInner<'a>,
+}
+
+/// Internal fields of `Unit` which `Unit` will dereference to.
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct UnitInner<'a> {
+    /// Information about available targets, which files to include/exclude, etc. Basically stuff in
+    /// `Cargo.toml`.
+    pub pkg: &'a Package,
+    /// Information about the specific target to build, out of the possible targets in `pkg`. Not
+    /// to be confused with *target-triple* (or *target architecture* ...), the target arch for a
+    /// build.
+    pub target: &'a Target,
+    /// The profile contains information about *how* the build should be run, including debug
+    /// level, etc.
+    pub profile: Profile,
+    /// Whether this compilation unit is for the host or target architecture.
+    ///
+    /// For example, when
+    /// cross compiling and using a custom build script, the build script needs to be compiled for
+    /// the host architecture so the host rustc can use it (when compiling to the target
+    /// architecture).
+    pub kind: Kind,
+    /// The "mode" this unit is being compiled for. See [`CompileMode`] for more details.
+    pub mode: CompileMode,
+}
+
+impl<'a> Unit<'a> {
+    pub fn buildkey(&self) -> String {
+        format!("{}-{}", self.pkg.name(), short_hash(self))
+    }
+}
+
+// Just hash the pointer for fast hashing
+impl<'a> Hash for Unit<'a> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        (self.inner as *const UnitInner<'a>).hash(hasher)
+    }
+}
+
+// Just equate the pointer since these are interned
+impl<'a> PartialEq for Unit<'a> {
+    fn eq(&self, other: &Unit<'a>) -> bool {
+        self.inner as *const UnitInner<'a> == other.inner as *const UnitInner<'a>
+    }
+}
+
+impl<'a> Eq for Unit<'a> {}
+
+impl<'a> Deref for Unit<'a> {
+    type Target = UnitInner<'a>;
+
+    fn deref(&self) -> &UnitInner<'a> {
+        self.inner
+    }
+}
+
+impl<'a> fmt::Debug for Unit<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Unit")
+            .field("pkg", &self.pkg)
+            .field("target", &self.target)
+            .field("profile", &self.profile)
+            .field("kind", &self.kind)
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+
+pub struct UnitInterner<'a> {
+    state: RefCell<InternerState<'a>>,
+}
+
+struct InternerState<'a> {
+    cache: HashSet<Box<UnitInner<'a>>>,
+}
+
+impl<'a> UnitInterner<'a> {
+    pub fn new() -> UnitInterner<'a> {
+        UnitInterner {
+            state: RefCell::new(InternerState {
+                cache: HashSet::new(),
+            }),
+        }
+    }
+
+    pub fn intern(
+        &'a self,
+        pkg: &'a Package,
+        target: &'a Target,
+        profile: Profile,
+        kind: Kind,
+        mode: CompileMode,
+    ) -> Unit<'a> {
+        let inner = self.intern_inner(&UnitInner {
+            pkg,
+            target,
+            profile,
+            kind,
+            mode,
+        });
+        Unit { inner }
+    }
+
+    fn intern_inner(&'a self, item: &UnitInner<'a>) -> &'a UnitInner<'a> {
+        let mut me = self.state.borrow_mut();
+        if let Some(item) = me.cache.get(item) {
+            return unsafe { &*(&**item as *const UnitInner<'a>) };
+        }
+        me.cache.insert(Box::new(item.clone()));
+        let item = me.cache.get(item).unwrap();
+        return unsafe { &*(&**item as *const UnitInner<'a>) };
+    }
+}