Auto merge of rust-lang#137354 - FractalFir:intern_with_cap, r=<try>

[perf experiment] Changed interners to start preallocated with an increased capacity

Inspired by rust-lang#137005.

*Not meant to be merged in its current form*

Added a `with_capacity` function to `InternedSet`. Changed the `CtxtInterners` to start with `InternedSets` preallocated with a capacity.

This *does* increase memory usage at very slightly(by 1 MB at the start), altough that increase quickly disaperars for larger crates(since they require such capacity anyway).

A local perf run indicates this improves compiletimes for small crates(like `ripgrep`), without a negative effect on larger ones:
![image](https://github.com/user-attachments/assets/4a7f3317-7e61-4b28-a651-cc79ee990689)

The current default capacities are choosen somewhat arbitrarily, and are relatively low.

Depending on what kind of memory usage is acceptable, it may be beneficial to increase that capacity for some interners.

From a second local perf run(with capacity of `_type` increased to `131072`), it looks like increasing the size of the preallocated type interner has the biggest impact:
![image](https://github.com/user-attachments/assets/08ac324a-b03c-4fe9-b779-4dd35e7970d9)

What would be the maximum acceptable memory usage increase? I think most people would not mind sacrificing 1-2MB  for an improvement in compile speed, but I am curious what is the general opinion here.

Author: bors

compiler/rustc_data_structures/src/sharded.rs

@@ -143,6 +143,9 @@ pub fn shards() -> usize {
 pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
 
 impl<K: Eq, V> ShardedHashMap<K, V> {
+    pub fn with_capacity(cap: usize) -> Self {
+        Self::new(|| FxHashMap::with_capacity_and_hasher(cap, rustc_hash::FxBuildHasher::default()))
+    }
     pub fn len(&self) -> usize {
         self.lock_shards().map(|shard| shard.len()).sum()
     }

compiler/rustc_middle/src/ty/context.rs

@@ -812,32 +812,35 @@ pub struct CtxtInterners<'tcx> {
 
 impl<'tcx> CtxtInterners<'tcx> {
     fn new(arena: &'tcx WorkerLocal<Arena<'tcx>>) -> CtxtInterners<'tcx> {
+        // Default interner size - this value has been chosen empirically, and may need to be adjusted
+        // as the compiler evolves.  
+        const DEF_INTERN_SIZE:usize = 2048;
         CtxtInterners {
             arena,
-            type_: Default::default(),
-            const_lists: Default::default(),
-            args: Default::default(),
-            type_lists: Default::default(),
-            region: Default::default(),
-            poly_existential_predicates: Default::default(),
-            canonical_var_infos: Default::default(),
-            predicate: Default::default(),
-            clauses: Default::default(),
-            projs: Default::default(),
-            place_elems: Default::default(),
-            const_: Default::default(),
-            pat: Default::default(),
-            const_allocation: Default::default(),
-            bound_variable_kinds: Default::default(),
-            layout: Default::default(),
-            adt_def: Default::default(),
-            external_constraints: Default::default(),
-            predefined_opaques_in_body: Default::default(),
-            fields: Default::default(),
-            local_def_ids: Default::default(),
-            captures: Default::default(),
-            offset_of: Default::default(),
-            valtree: Default::default(),
+            type_: InternedSet::with_capacity(DEF_INTERN_SIZE * 16),
+            const_lists: InternedSet::with_capacity(DEF_INTERN_SIZE * 4),
+            args: InternedSet::with_capacity(DEF_INTERN_SIZE * 4),
+            type_lists: InternedSet::with_capacity(DEF_INTERN_SIZE * 4),
+            region: InternedSet::with_capacity(DEF_INTERN_SIZE * 4),
+            poly_existential_predicates: InternedSet::with_capacity(DEF_INTERN_SIZE/4),
+            canonical_var_infos: InternedSet::with_capacity(DEF_INTERN_SIZE/2),
+            predicate: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            clauses: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            projs: InternedSet::with_capacity(DEF_INTERN_SIZE*4),
+            place_elems: InternedSet::with_capacity(DEF_INTERN_SIZE*2),
+            const_: InternedSet::with_capacity(DEF_INTERN_SIZE*2),
+            pat: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            const_allocation: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            bound_variable_kinds: InternedSet::with_capacity(DEF_INTERN_SIZE*2),
+            layout: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            adt_def: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            external_constraints: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            predefined_opaques_in_body: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            fields: InternedSet::with_capacity(DEF_INTERN_SIZE*4),
+            local_def_ids: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            captures: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            offset_of: InternedSet::with_capacity(DEF_INTERN_SIZE),
+            valtree: InternedSet::with_capacity(DEF_INTERN_SIZE),
         }
     }
 
@@ -2547,6 +2550,7 @@ macro_rules! slice_interners {
     ($($field:ident: $vis:vis $method:ident($ty:ty)),+ $(,)?) => (
         impl<'tcx> TyCtxt<'tcx> {
             $($vis fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
+                //eprintln!("{} len:{}",stringify!($field), self.interners.$field.len());
                 if v.is_empty() {
                     List::empty()
                 } else {
@@ -2845,6 +2849,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // FIXME consider asking the input slice to be sorted to avoid
         // re-interning permutations, in which case that would be asserted
         // here.
+
         self.intern_local_def_ids(clauses)
     }