Work on cache

Author: Aaron1011

compiler/rustc_middle/src/query/mod.rs

@@ -23,6 +23,7 @@ rustc_queries! {
     query hir_crate(key: ()) -> &'tcx Crate<'tcx> {
         eval_always
         no_hash
+        storage(CellCacheSelector<'tcx>)
         desc { "get the crate HIR" }
     }
 
@@ -31,6 +32,7 @@ rustc_queries! {
     query index_hir(_: ()) -> &'tcx crate::hir::IndexedHir<'tcx> {
         eval_always
         no_hash
+        storage(CellCacheSelector<'tcx>)
         desc { "index HIR" }
     }
 
@@ -116,6 +118,7 @@ rustc_queries! {
 
     query analysis(key: ()) -> Result<(), ErrorReported> {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "running analysis passes on this crate" }
     }
 
@@ -701,6 +704,7 @@ rustc_queries! {
         }
 
     query typeck_item_bodies(_: ()) -> () {
+        storage(CellCacheSelector<'tcx>)
         desc { "type-checking all item bodies" }
     }
 
@@ -770,6 +774,7 @@ rustc_queries! {
     query crate_inherent_impls_overlap_check(_: ())
         -> () {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "check for overlap between inherent impls defined in this crate" }
     }
 
@@ -863,10 +868,12 @@ rustc_queries! {
     /// Performs part of the privacy check and computes "access levels".
     query privacy_access_levels(_: ()) -> &'tcx AccessLevels {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "privacy access levels" }
     }
     query check_private_in_public(_: ()) -> () {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "checking for private elements in public interfaces" }
     }
 
@@ -981,6 +988,7 @@ rustc_queries! {
     ///
     /// [`LOCAL_CRATE`]: rustc_hir::def_id::LOCAL_CRATE
     query all_local_trait_impls(_: ()) -> &'tcx BTreeMap<DefId, Vec<LocalDefId>> {
+        storage(CellCacheSelector<'tcx>)
         desc { "local trait impls" }
     }
 
@@ -1229,12 +1237,15 @@ rustc_queries! {
     /// Identifies the entry-point (e.g., the `main` function) for a given
     /// crate, returning `None` if there is no entry point (such as for library crates).
     query entry_fn(_: ()) -> Option<(DefId, EntryFnType)> {
+        storage(CellCacheSelector<'tcx>)
         desc { "looking up the entry function of a crate" }
     }
     query plugin_registrar_fn(_: ()) -> Option<LocalDefId> {
+        storage(CellCacheSelector<'tcx>)
         desc { "looking up the plugin registrar for a crate" }
     }
     query proc_macro_decls_static(_: ()) -> Option<LocalDefId> {
+        storage(CellCacheSelector<'tcx>)
         desc { "looking up the derive registrar for a crate" }
     }
     query crate_disambiguator(_: CrateNum) -> CrateDisambiguator {
@@ -1412,6 +1423,7 @@ rustc_queries! {
     }
     query postorder_cnums(_: ()) -> &'tcx [CrateNum] {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "generating a postorder list of CrateNums" }
     }
     /// Returns whether or not the crate with CrateNum 'cnum'
@@ -1431,6 +1443,7 @@ rustc_queries! {
     }
     query maybe_unused_extern_crates(_: ()) -> &'tcx [(LocalDefId, Span)] {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "looking up all possibly unused extern crates" }
     }
     query names_imported_by_glob_use(def_id: LocalDefId)
@@ -1446,13 +1459,15 @@ rustc_queries! {
     }
     query all_crate_nums(_: ()) -> &'tcx [CrateNum] {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "fetching all foreign CrateNum instances" }
     }
 
     /// A vector of every trait accessible in the whole crate
     /// (i.e., including those from subcrates). This is used only for
     /// error reporting.
     query all_traits(_: ()) -> &'tcx [DefId] {
+        storage(CellCacheSelector<'tcx>)
         desc { "fetching all foreign and local traits" }
     }
 
@@ -1468,6 +1483,7 @@ rustc_queries! {
 
     query collect_and_partition_mono_items(_: ()) -> (&'tcx DefIdSet, &'tcx [CodegenUnit<'tcx>]) {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "collect_and_partition_mono_items" }
     }
     query is_codegened_item(def_id: DefId) -> bool {
@@ -1477,7 +1493,8 @@ rustc_queries! {
     /// All items participating in code generation together with items inlined into them.
     query codegened_and_inlined_items(_: ()) -> &'tcx DefIdSet {
         eval_always
-       desc { "codegened_and_inlined_items" }
+        storage(CellCacheSelector<'tcx>)
+        desc { "codegened_and_inlined_items" }
     }
 
     query codegen_unit(_: Symbol) -> &'tcx CodegenUnit<'tcx> {
@@ -1491,6 +1508,7 @@ rustc_queries! {
         }
     }
     query backend_optimization_level(_: ()) -> OptLevel {
+        storage(CellCacheSelector<'tcx>)
         desc { "optimization level used by backend" }
     }
 
@@ -1672,6 +1690,7 @@ rustc_queries! {
 
     query features_query(_: ()) -> &'tcx rustc_feature::Features {
         eval_always
+        storage(CellCacheSelector<'tcx>)
         desc { "looking up enabled feature gates" }
     }
 

compiler/rustc_query_system/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(bool_to_option)]
+#![feature(const_panic)]
 #![feature(core_intrinsics)]
 #![feature(hash_raw_entry)]
 #![feature(iter_zip)]

compiler/rustc_query_system/src/query/caches.rs

@@ -8,6 +8,7 @@ use rustc_data_structures::sync::WorkerLocal;
 use std::default::Default;
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::cell::Cell;
 use std::marker::PhantomData;
 
 pub trait CacheSelector<K, V> {
@@ -221,3 +222,91 @@ where
         }
     }
 }
+
+pub struct CellCacheSelector<'tcx>(PhantomData<&'tcx ()>);
+
+impl<'tcx, K: Eq + Hash, V: Clone> CacheSelector<K, V> for CellCacheSelector<'tcx> {
+    type Cache = CellCache<K, V>;
+}
+
+pub struct CellCache<K, V>(PhantomData<(K, V)>);
+
+impl<K, V> Default for CellCache<K, V> {
+    fn default() -> Self {
+        CellCache(PhantomData)
+    }
+}
+
+impl<K, V> CellCache<K, V> {
+    const KEY_IS_ZST: () = {
+        if std::mem::size_of::<K>() != 0 {
+            panic!("Key must be a ZST");
+        }
+    };
+}
+
+impl<K: Eq + Hash, V: Clone + Debug> QueryStorage for CellCache<K, V> {
+    type Value = V;
+    type Stored = V;
+
+    #[inline]
+    fn store_nocache(&self, value: Self::Value) -> Self::Stored {
+        // We have no dedicated storage
+        value
+    }
+}
+
+impl<K, V> QueryCache for CellCache<K, V>
+where
+    K: Eq + Hash + Copy + Clone + Debug,
+    V: Copy + Clone + Debug,
+{
+    type Key = K;
+    type Sharded = Cell<Option<(K, V, DepNodeIndex)>>;
+
+    #[inline(always)]
+    fn lookup<'s, R, OnHit>(
+        &self,
+        state: &'s QueryCacheStore<Self>,
+        _key: &K,
+        on_hit: OnHit,
+    ) -> Result<R, QueryLookup>
+    where
+        OnHit: FnOnce(&V, DepNodeIndex) -> R,
+    {
+        let _ = Self::KEY_IS_ZST;
+
+        let lock = state.shards.get_shard_by_index(0).lock();
+        if let Some((_key, val, dep_node)) = lock.get() {
+            Ok(on_hit(&val, dep_node))
+        } else {
+            Err(QueryLookup {
+                key_hash: 0,
+                shard: 0
+            })
+        }
+    }
+
+    #[inline]
+    fn complete(
+        &self,
+        lock_sharded_storage: &mut Self::Sharded,
+        key: K,
+        value: V,
+        index: DepNodeIndex,
+    ) -> Self::Stored {
+        lock_sharded_storage.set(Some((key, value, index)));
+        value
+    }
+
+    fn iter(
+        &self,
+        shards: &Sharded<Self::Sharded>,
+        f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex),
+    ) {
+        let lock = shards.get_shard_by_index(0).lock();
+        if let Some((key, val, dep_node)) = lock.get() {
+            f(&key, &val, dep_node);
+        }
+    }
+}

compiler/rustc_query_system/src/query/mod.rs

@@ -8,7 +8,7 @@ pub use self::job::{print_query_stack, QueryInfo, QueryJob, QueryJobId, QueryJob
 
 mod caches;
 pub use self::caches::{
-    ArenaCacheSelector, CacheSelector, DefaultCacheSelector, QueryCache, QueryStorage,
+    ArenaCacheSelector, CacheSelector, CellCacheSelector, DefaultCacheSelector, QueryCache, QueryStorage,
 };
 
 mod config;

compiler/rustc_query_system/src/query/plumbing.rs

@@ -31,7 +31,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 
 pub struct QueryCacheStore<C: QueryCache> {
     cache: C,
-    shards: Sharded<C::Sharded>,
+    pub(super) shards: Sharded<C::Sharded>,
     #[cfg(debug_assertions)]
     pub cache_hits: AtomicUsize,
 }
@@ -50,7 +50,7 @@ impl<C: QueryCache + Default> Default for QueryCacheStore<C> {
 /// Values used when checking a query cache which can be reused on a cache-miss to execute the query.
 pub struct QueryLookup {
     pub(super) key_hash: u64,
-    shard: usize,
+    pub(super) shard: usize,
 }
 
 // We compute the key's hash once and then use it for both the