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

@@ -814,30 +814,45 @@ impl<'tcx> CtxtInterners<'tcx> {
     fn new(arena: &'tcx WorkerLocal<Arena<'tcx>>) -> CtxtInterners<'tcx> {
         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(),
+            // From some experiments, it looks like there usualy are < 2^20 types.
+            // 2^20 * 24 bytes ~ 25 MB, which is acceptable IMHO.
+            type_: InternedSet::with_capacity(1048576),
+            // Const lists don't seem to be too common, but I still reserver 128 of them, since
+            // it is cheap anyway
+            const_lists: InternedSet::with_capacity(128),
+            // From some experiments, it looks like there usualy are < 2^20 arg lists.
+            // 2^20 * 8 bytes ~ 9 MB, which is acceptable IMHO.
+            args: InternedSet::with_capacity(1048576),
+            // From some experiments, it looks like there usualy are < 2^19 type_lists.
+            type_lists: InternedSet::with_capacity(524288),
+            region: InternedSet::with_capacity(4096),
+            // There are usually very few `poly_existential_predicates` - for cargo, there were 119.
+            // So, 256 ought to be more than enough for all cases.
+            poly_existential_predicates: InternedSet::with_capacity(256),
+            // There is usually very few `canonical_var_infos` - for cargo, there were 379.
+            // So, 512 ought to be more than enough for all cases.
+            canonical_var_infos: InternedSet::with_capacity(512),
+            predicate: InternedSet::with_capacity(1024),
+            clauses: InternedSet::with_capacity(1024),
+            // Projs don't seem to be too common, but I still reserver 128 of them, since
+            // it is cheap anyway
+            projs: InternedSet::with_capacity(128),
+            // There semes to be > 2^16 place_elems.
+            place_elems: InternedSet::with_capacity(65536),
+            const_: InternedSet::with_capacity(4096),
+            pat: InternedSet::with_capacity(1024),
+            const_allocation: InternedSet::with_capacity(1024),
+            // There is usually < 2^13 bound_variable_kinds
+            bound_variable_kinds: InternedSet::with_capacity(8192),
+            layout: InternedSet::with_capacity(4096),
+            adt_def: InternedSet::with_capacity(1024),
+            external_constraints: InternedSet::with_capacity(1024),
+            predefined_opaques_in_body: InternedSet::with_capacity(1024),
+            fields: InternedSet::with_capacity(4096),
+            local_def_ids: InternedSet::with_capacity(1024),
+            captures: InternedSet::with_capacity(1024),
+            offset_of: InternedSet::with_capacity(1024),
+            valtree: InternedSet::with_capacity(1024),
         }
     }
 
@@ -2549,6 +2564,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 {
@@ -2847,6 +2863,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)
     }