Use interned strings to reduce memory usage (rust-lang#617)

Author: danielsn

Cargo.lock

@@ -34,6 +34,17 @@ dependencies = [
  "rustc-std-workspace-core",
 ]
 
+[[package]]
+name = "ahash"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98"
+dependencies = [
+ "getrandom 0.2.0",
+ "once_cell",
+ "version_check",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.18"
@@ -481,6 +492,7 @@ version = "0.0.0"
 dependencies = [
  "bitflags",
  "cstr",
+ "lazy_static",
  "libc",
  "measureme 9.1.2",
  "num",
@@ -505,6 +517,7 @@ dependencies = [
  "serde_test",
  "smallvec",
  "snap",
+ "string-interner",
  "tracing",
  "vector-map",
 ]
@@ -1599,6 +1612,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "362385356d610bd1e5a408ddf8d022041774b683f345a1d2cfcb4f60f8ae2db5"
 dependencies = [
+ "ahash",
  "compiler_builtins",
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
@@ -5199,6 +5213,17 @@ dependencies = [
  "rustc-std-workspace-core",
 ]
 
+[[package]]
+name = "string-interner"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e2531d8525b29b514d25e275a43581320d587b86db302b9a7e464bac579648"
+dependencies = [
+ "cfg-if 1.0.0",
+ "hashbrown",
+ "serde",
+]
+
 [[package]]
 name = "string_cache"
 version = "0.8.0"

compiler/cbmc/Cargo.toml

@@ -12,12 +12,14 @@ doctest = false
 
 [dependencies]
 bitflags = "1.0"
+lazy_static = "1.4.0"
 cstr = "0.2"
 libc = "0.2"
 measureme = "9.1.0"
 num = "0.4.0"
 serde = {version = "1", features = ["derive"]}
 snap = "1"
+string-interner = "0.14.0"
 tracing = "0.1"
 vector-map = "1.0.1"
 rustc_middle = { path = "../rustc_middle" }

compiler/cbmc/src/cbmc_string.rs

@@ -0,0 +1,118 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+use string_interner::symbol::SymbolU32;
+use string_interner::StringInterner;
+
+/// This class implements an interner for Strings.
+/// CBMC objects to have a large number of strings which refer to names: symbols, files, etc.
+/// These tend to be reused many times, which causes signifcant memory usage.
+/// If we intern the strings, each unique string is only allocated once, saving memory.
+/// On the stdlib test, interning led to a 15% savings in peak memory usage.
+/// Since they're referred to by index, InternedStrings become `Copy`, which simplifies APIs.
+/// The downside is that interned strings live the lifetime of the execution.
+/// So you should only intern strings that will be used in long-lived data-structures, not temps.
+///
+/// We use a single global string interner, which is protected by a Mutex (i.e. threadsafe).
+/// To create an interned string, either do
+/// `let i : InternedString = s.into();` or
+/// `let i = s.intern();`
+#[derive(Debug, Clone, Hash, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct InternedString(SymbolU32);
+
+// Use a `Mutex` to make this thread safe.
+lazy_static! {
+    static ref INTERNER: Mutex<StringInterner> = Mutex::new(StringInterner::default());
+}
+
+impl InternedString {
+    pub fn is_empty(&self) -> bool {
+        self.map(|s| s.is_empty())
+    }
+
+    pub fn len(&self) -> usize {
+        self.map(|s| s.len())
+    }
+
+    /// Apply the function `f` to the interned string, represented as an &str.
+    /// Needed because exporting the &str backing the InternedString is blocked by lifetime rules.
+    /// Instead, this allows users to operate on the &str when needed.
+    pub fn map<T, F: FnOnce(&str) -> T>(&self, f: F) -> T {
+        f(INTERNER.lock().unwrap().resolve(self.0).unwrap())
+    }
+
+    pub fn starts_with(&self, pattern: &str) -> bool {
+        self.map(|s| s.starts_with(pattern))
+    }
+}
+
+impl std::fmt::Display for InternedString {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(fmt, "{}", INTERNER.lock().unwrap().resolve(self.0).unwrap())
+    }
+}
+
+impl<T> From<T> for InternedString
+where
+    T: AsRef<str>,
+{
+    fn from(s: T) -> InternedString {
+        InternedString(INTERNER.lock().unwrap().get_or_intern(s))
+    }
+}
+
+impl<T> PartialEq<T> for InternedString
+where
+    T: AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        INTERNER.lock().unwrap().resolve(self.0).unwrap() == other.as_ref()
+    }
+}
+
+pub trait InternString {
+    fn intern(self) -> InternedString;
+}
+
+impl<T> InternString for T
+where
+    T: Into<InternedString>,
+{
+    fn intern(self) -> InternedString {
+        self.into()
+    }
+}
+pub trait InternStringOption {
+    fn intern(self) -> Option<InternedString>;
+}
+
+impl<T> InternStringOption for Option<T>
+where
+    T: Into<InternedString>,
+{
+    fn intern(self) -> Option<InternedString> {
+        self.map(|s| s.into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::cbmc_string::InternedString;
+
+    #[test]
+    fn test_string_interner() {
+        let a: InternedString = "A".into();
+        let b: InternedString = "B".into();
+        let aa: InternedString = "A".into();
+
+        assert_eq!(a, aa);
+        assert_ne!(a, b);
+        assert_ne!(aa, b);
+
+        assert_eq!(a, "A");
+        assert_eq!(b, "B");
+        assert_eq!(aa, "A");
+    }
+}

compiler/cbmc/src/env.rs

@@ -70,8 +70,8 @@ pub fn additional_env_symbols() -> Vec<Symbol> {
         int_constant("__CPROVER_malloc_failure_mode_return_null", 1),
         Symbol::typedef("__CPROVER_size_t", "__CPROVER_size_t", Type::size_t(), Location::none()),
         Symbol::static_variable(
-            "__CPROVER_memory".to_string(),
-            "__CPROVER_memory".to_string(),
+            "__CPROVER_memory",
+            "__CPROVER_memory",
             Type::unsigned_int(8).infinite_array_of(),
             Location::none(),
         )