fix: make immortal interned values cheaper

benches/creation.rs

@@ -42,6 +42,22 @@ fn intern_distinct_many(bencher: divan::Bencher) {
         });
 }
 
+/// Interns many distinct values with garbage collection disabled.
+#[divan::bench]
+fn intern_immortal_distinct_many(bencher: divan::Bencher) {
+    bencher
+        .with_inputs(|| {
+            let db = salsa::DatabaseImpl::default();
+            warm_db(&db);
+            let input = InternInput::new(black_box(&db), black_box(MANY), black_box(1));
+            (db, input)
+        })
+        .bench_local_refs(|(db, input)| {
+            let sum = intern_immortal_distinct_values(black_box(db), black_box(*input));
+            assert_eq!(black_box(sum), MANY);
+        });
+}
+
 /// Interns the same value many times inside a query.
 #[divan::bench]
 fn intern_same_many(bencher: divan::Bencher) {
@@ -63,6 +79,26 @@ fn intern_same_many(bencher: divan::Bencher) {
         });
 }
 
+/// Interns the same value many times with garbage collection disabled.
+#[divan::bench]
+fn intern_immortal_same_many(bencher: divan::Bencher) {
+    bencher
+        .with_inputs(|| {
+            let db = salsa::DatabaseImpl::default();
+            warm_db(&db);
+            let warm_input = InternInput::new(black_box(&db), black_box(MANY), black_box(1));
+            let sum = intern_immortal_same_value(black_box(&db), black_box(warm_input));
+
+            assert_eq!(black_box(sum), MANY);
+            let input = InternInput::new(black_box(&db), black_box(MANY), black_box(1));
+            (db, input)
+        })
+        .bench_local_refs(|(db, input)| {
+            let sum = intern_immortal_same_value(black_box(db), black_box(*input));
+            assert_eq!(black_box(sum), MANY);
+        });
+}
+
 /// Creates many tracked structs inside a query.
 #[divan::bench]
 fn tracked_create_many(bencher: divan::Bencher) {
@@ -157,6 +193,12 @@ struct InternedValue<'db> {
     value: usize,
 }
 
+#[salsa::interned(revisions = usize::MAX)]
+struct ImmortalInternedValue<'db> {
+    #[returns(copy)]
+    value: usize,
+}
+
 #[salsa::input]
 struct TrackedInput {
     #[returns(copy)]
@@ -221,3 +263,35 @@ fn intern_same_value(db: &dyn salsa::Database, input: InternInput) -> usize {
 
     sum
 }
+
+#[salsa::tracked(returns(copy))]
+#[inline(never)]
+fn intern_immortal_distinct_values(db: &dyn salsa::Database, input: InternInput) -> usize {
+    let count = input.count(db);
+    let value = input.value(db);
+    let mut sum = 0;
+
+    for offset in 0..count {
+        let interned = ImmortalInternedValue::new(db, value + offset);
+        black_box(interned);
+        sum += value;
+    }
+
+    sum
+}
+
+#[salsa::tracked(returns(copy))]
+#[inline(never)]
+fn intern_immortal_same_value(db: &dyn salsa::Database, input: InternInput) -> usize {
+    let count = input.count(db);
+    let value = input.value(db);
+    let mut sum = 0;
+
+    for _ in 0..count {
+        let interned = ImmortalInternedValue::new(db, value);
+        black_box(interned);
+        sum += value;
+    }
+
+    sum
+}

components/salsa-macro-rules/src/setup_interned_struct.rs

@@ -31,6 +31,9 @@ macro_rules! setup_interned_struct {
         // The minimum number of revisions to keep the value interned.
         revisions: $($revisions:expr)?,
 
+        // The eviction policy selected from the revision configuration.
+        eviction: $Eviction:ty,
+
         // the lifetime used in the desugared interned struct.
         // if the `db_lt_arg`, is present, this is `db_lt_arg`, but otherwise,
         // it is `'static`.
@@ -173,6 +176,7 @@ macro_rules! setup_interned_struct {
 
                 type Fields<'a> = $StructDataIdent<'a>;
                 type Struct<'db> = $Struct< $($db_lt_arg)? >;
+                type Eviction = $Eviction;
 
                 $(
                     fn heap_size(value: &Self::Fields<'_>) -> Option<usize> {

components/salsa-macro-rules/src/setup_tracked_fn.rs

@@ -223,6 +223,8 @@ macro_rules! setup_tracked_fn {
 
                         type Struct<$db_lt> = $InternedData<$db_lt>;
 
+                        type Eviction = $zalsa::interned::Lru;
+
                         fn serialize<S: $zalsa::serde::Serializer>(
                             fields: &Self::Fields<'_>,
                             serializer: S,

components/salsa-macros/src/interned.rs

@@ -116,7 +116,17 @@ impl Macro {
         let generate_debug_impl = salsa_struct.generate_debug_impl();
         let has_lifetime = salsa_struct.generate_lifetime();
         let id = salsa_struct.id();
-        let revisions = salsa_struct.revisions();
+        let revisions = salsa_struct.revisions().next();
+        let eviction = revisions.map_or_else(
+            || quote!(::salsa::plumbing::interned::Lru),
+            |revisions| {
+                quote!(
+                    <::salsa::plumbing::interned::EvictionSelector<
+                        { #revisions == ::core::usize::MAX }
+                    > as ::salsa::plumbing::interned::SelectEviction>::Eviction
+                )
+            },
+        );
 
         let (db_lt_arg, cfg, interior_lt) = if has_lifetime {
             (
@@ -177,7 +187,8 @@ impl Macro {
                     db_lt: #db_lt,
                     db_lt_arg: #db_lt_arg,
                     id: #id,
-                    revisions: #(#revisions)*,
+                    revisions: #revisions,
+                    eviction: #eviction,
                     interior_lt: #interior_lt,
                     new_fn: #new_fn,
                     field_options: [#(#field_options),*],