Skip to content

Commit

Permalink
Rename DisambiguationKey to IdentityHash, KeyStruct to Identity
Browse files Browse the repository at this point in the history
  • Loading branch information
puuuuh committed Oct 17, 2024
1 parent acae02d commit 0744fd8
Show file tree
Hide file tree
Showing 3 changed files with 28 additions and 28 deletions.
10 changes: 5 additions & 5 deletions src/active_query.rs
Original file line number Diff line number Diff line change
@@ -1,13 +1,13 @@
use rustc_hash::FxHashMap;

use super::zalsa_local::{EdgeKind, QueryEdges, QueryOrigin, QueryRevisions};
use crate::tracked_struct::DisambiguationKey;
use crate::tracked_struct::IdentityHash;
use crate::{
accumulator::accumulated_map::AccumulatedMap,
durability::Durability,
hash::FxIndexSet,
key::{DatabaseKeyIndex, DependencyIndex},
tracked_struct::{Disambiguator, KeyStruct},
tracked_struct::{Disambiguator, Identity},
zalsa_local::EMPTY_DEPENDENCIES,
Cycle, Id, Revision,
};
Expand Down Expand Up @@ -45,11 +45,11 @@ pub(crate) struct ActiveQuery {
/// This table starts empty as the query begins and is gradually populated.
/// Note that if a query executes in 2 different revisions but creates the same
/// set of tracked structs, they will get the same disambiguator values.
disambiguator_map: FxHashMap<DisambiguationKey, Disambiguator>,
disambiguator_map: FxHashMap<IdentityHash, Disambiguator>,

/// Map from tracked struct keys (which include the hash + disambiguator) to their
/// final id.
pub(crate) tracked_struct_ids: FxHashMap<KeyStruct, Id>,
pub(crate) tracked_struct_ids: FxHashMap<Identity, Id>,

/// Stores the values accumulated to the given ingredient.
/// The type of accumulated value is erased but known to the ingredient.
Expand Down Expand Up @@ -155,7 +155,7 @@ impl ActiveQuery {
self.input_outputs.clone_from(&cycle_query.input_outputs);
}

pub(super) fn disambiguate(&mut self, key: DisambiguationKey) -> Disambiguator {
pub(super) fn disambiguate(&mut self, key: IdentityHash) -> Disambiguator {
let disambiguator = self
.disambiguator_map
.entry(key)
Expand Down
27 changes: 14 additions & 13 deletions src/tracked_struct.rs
Original file line number Diff line number Diff line change
Expand Up @@ -147,18 +147,18 @@ where
/// stored in the [`ActiveQuery`](`crate::active_query::ActiveQuery`)
/// struct and later moved to the [`Memo`](`crate::function::memo::Memo`).
#[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
pub(crate) struct KeyStruct {
/// Tracked struct key
disambiguation_key: DisambiguationKey,
pub(crate) struct Identity {
/// Hash of fields with id attribute
identity_hash: IdentityHash,

/// The unique disambiguator assigned within the active query
/// to distinguish distinct tracked structs with the same key.
/// to distinguish distinct tracked structs with the same identity_hash.
disambiguator: Disambiguator,
}

impl KeyStruct {
impl Identity {
pub(crate) fn ingredient_index(&self) -> IngredientIndex {
self.disambiguation_key.ingredient_index
self.identity_hash.ingredient_index
}
}

Expand All @@ -168,7 +168,7 @@ impl KeyStruct {
/// allowing for multiple tracked structs with the same hash and ingredient_index
/// created within the query to each have a unique id.
#[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
pub struct DisambiguationKey {
pub struct IdentityHash {
/// Index of the tracked struct ingredient.
ingredient_index: IngredientIndex,

Expand Down Expand Up @@ -274,20 +274,21 @@ where
) -> C::Struct<'db> {
let (zalsa, zalsa_local) = db.zalsas();

let disambiguation_key = DisambiguationKey {
let identity_hash = IdentityHash {
ingredient_index: self.ingredient_index,
hash: crate::hash::hash(&C::id_fields(&fields)),
};

let (current_deps, disambiguator) = zalsa_local.disambiguate(disambiguation_key);
let (current_deps, disambiguator) = zalsa_local.disambiguate(identity_hash);

let identity = Identity {
identity_hash,

let key_struct = KeyStruct {
disambiguation_key,
disambiguator,
};

let current_revision = zalsa.current_revision();
match zalsa_local.tracked_struct_id(&key_struct) {
match zalsa_local.tracked_struct_id(&identity) {
Some(id) => {
// The struct already exists in the intern map.
zalsa_local.add_output(self.database_key_index(id).into());
Expand All @@ -300,7 +301,7 @@ where
let id = self.allocate(zalsa, zalsa_local, current_revision, &current_deps, fields);
let key = self.database_key_index(id);
zalsa_local.add_output(key.into());
zalsa_local.store_tracked_struct_id(key_struct, id);
zalsa_local.store_tracked_struct_id(identity, id);
C::struct_from_id(id)
}
}
Expand Down
19 changes: 9 additions & 10 deletions src/zalsa_local.rs
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,7 @@ use crate::runtime::StampedValue;
use crate::table::PageIndex;
use crate::table::Slot;
use crate::table::Table;
use crate::tracked_struct::KeyStruct;
use crate::tracked_struct::{DisambiguationKey, Disambiguator};
use crate::tracked_struct::{Disambiguator, Identity, IdentityHash};
use crate::zalsa::IngredientIndex;
use crate::Accumulator;
use crate::Cancelled;
Expand Down Expand Up @@ -262,7 +261,7 @@ impl ZalsaLocal {
/// * the current dependencies (durability, changed_at) of current query
/// * the disambiguator index
#[track_caller]
pub(crate) fn disambiguate(&self, key: DisambiguationKey) -> (StampedValue<()>, Disambiguator) {
pub(crate) fn disambiguate(&self, key: IdentityHash) -> (StampedValue<()>, Disambiguator) {
assert!(
self.query_in_progress(),
"cannot create a tracked struct disambiguator outside of a tracked function"
Expand All @@ -283,30 +282,30 @@ impl ZalsaLocal {
}

#[track_caller]
pub(crate) fn tracked_struct_id(&self, key_struct: &KeyStruct) -> Option<Id> {
pub(crate) fn tracked_struct_id(&self, identity: &Identity) -> Option<Id> {
debug_assert!(
self.query_in_progress(),
"cannot create a tracked struct disambiguator outside of a tracked function"
);

self.with_query_stack(|stack| {
let top_query = stack.last().unwrap();
top_query.tracked_struct_ids.get(key_struct).copied()
top_query.tracked_struct_ids.get(identity).copied()
})
}

#[track_caller]
pub(crate) fn store_tracked_struct_id(&self, key_struct: KeyStruct, id: Id) {
pub(crate) fn store_tracked_struct_id(&self, identity: Identity, id: Id) {
debug_assert!(
self.query_in_progress(),
"cannot create a tracked struct disambiguator outside of a tracked function"
);
self.with_query_stack(|stack| {
let top_query = stack.last_mut().unwrap();
let old_id = top_query.tracked_struct_ids.insert(key_struct, id);
let old_id = top_query.tracked_struct_ids.insert(identity, id);
assert!(
old_id.is_none(),
"overwrote a previous id for `{key_struct:?}`"
"overwrote a previous id for `{identity:?}`"
);
})
}
Expand Down Expand Up @@ -375,7 +374,7 @@ pub(crate) struct QueryRevisions {
/// previous revision. To handle this, `diff_outputs` compares
/// the structs from the old/new revision and retains
/// only entries that appeared in the new revision.
pub(super) tracked_struct_ids: FxHashMap<KeyStruct, Id>,
pub(super) tracked_struct_ids: FxHashMap<Identity, Id>,

pub(super) accumulated: AccumulatedMap,
}
Expand Down Expand Up @@ -534,7 +533,7 @@ impl ActiveQueryGuard<'_> {
}

/// Initialize the tracked struct ids with the values from the prior execution.
pub(crate) fn seed_tracked_struct_ids(&self, tracked_struct_ids: &FxHashMap<KeyStruct, Id>) {
pub(crate) fn seed_tracked_struct_ids(&self, tracked_struct_ids: &FxHashMap<Identity, Id>) {
self.local_state.with_query_stack(|stack| {
assert_eq!(stack.len(), self.push_len);
let frame = stack.last_mut().unwrap();
Expand Down

0 comments on commit 0744fd8

Please sign in to comment.