mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove sharding for VecCache

Browse Source 
This sharding is never used (per the comment in code). If we re-add
sharding at some point in the future this is cheap to restore, but for
now no need for the extra complexity.
This commit is contained in:
Mark Rousskov 2024-04-06 10:49:31 -04:00
parent 01f7f3a1ff
commit 668b3188ab
1 changed files with 6 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
compiler/rustc_query_system/src/query/caches.rs
View File

@ -101,7 +101,7 @@ fn iter(&self, f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex)) {
}
pub struct VecCache<K: Idx, V> {
cache: Sharded<IndexVec<K, Option<(V, DepNodeIndex)>>>,
cache: Lock<IndexVec<K, Option<(V, DepNodeIndex)>>>,
}
impl<K: Idx, V> Default for VecCache<K, V> {
@ -120,28 +120,24 @@ impl<K, V> QueryCache for VecCache<K, V>
#[inline(always)]
fn lookup(&self, key: &K) -> Option<(V, DepNodeIndex)> {
// FIXME: lock_shard_by_hash will use high bits which are usually zero in the index() passed
// here. This makes sharding essentially useless, always selecting the zero'th shard.
let lock = self.cache.lock_shard_by_hash(key.index() as u64);
let lock = self.cache.lock();
if let Some(Some(value)) = lock.get(*key) { Some(*value) } else { None }
}
#[inline]
fn complete(&self, key: K, value: V, index: DepNodeIndex) {
let mut lock = self.cache.lock_shard_by_hash(key.index() as u64);
let mut lock = self.cache.lock();
lock.insert(key, (value, index));
}
fn iter(&self, f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex)) {
for shard in self.cache.lock_shards() {
for (k, v) in shard.iter_enumerated() {
for (k, v) in self.cache.lock().iter_enumerated() {
if let Some(v) = v {
f(&k, &v.0, v.1);
}
}
}
}
}
pub struct DefIdCache<V> {
/// Stores the local DefIds in a dense map. Local queries are much more often dense, so this is
@ -149,9 +145,6 @@ pub struct DefIdCache<V> {
///
/// The second element of the tuple is the set of keys actually present in the IndexVec, used
/// for faster iteration in `iter()`.
// FIXME: This may want to be sharded, like VecCache. However *how* to shard an IndexVec isn't
// super clear; VecCache is effectively not sharded today (see FIXME there). For now just omit
// that complexity here.
local: Lock<(IndexVec<DefIndex, Option<(V, DepNodeIndex)>>, Vec<DefIndex>)>,
foreign: DefaultCache<DefId, V>,
}