跟踪结构体

Tracked struct 会用一种特殊方式存储，以降低它们的成本。

Tracked struct 通过 new 操作来创建。

tracked struct ingredient 与 tracked field ingredient

对于单个 tracked struct，我们会生成多个 ingredient。

首先创建的是 tracked struct ingredient。它负责提供创建结构体新实例的方法，因此也独占访问那些用来生成 struct id 的 interner 和 hashmap。它还会共享访问另一个 hashmap，这个 hashmap 存储的是包含字段数据的 ValueStruct。

而对于每个字段，我们都会创建一个 tracked field ingredient，它负责调节对某个具体字段的访问。这些 ingredient 全部共享访问同一个 hashmap，从而能通过某个 id 找到对应的 ValueStruct。 ValueStruct 中不仅保存字段值，也保存这些字段上一次发生变化时对应的修订版本。

每个 tracked struct 都有全局唯一的 id

首先会为这个 tracked struct 生成一个全局唯一的 32 位 id。它是通过 intern 以下信息的组合得到的：

当前正在执行的查询。
#[id] 字段的一个 u64 哈希值。
一个 disambiguator，用于保证这个哈希值在当前查询内部唯一。也就是说，当某个查询开始执行时，它会创建一个空 map；第一次创建某个给定哈希值的 tracked struct 时，它拿到的 disambiguator 是 0；下一次则会拿到 1，以此类推。

每个 tracked struct 都有一个 `ValueStruct` 来存储数据

struct ingredient 和 field ingredient 会共享访问一个 hashmap，它把每个 field id 映射到一个 value struct：

pub struct Value<C>
where
    C: Configuration,
{
    /// The revision when this tracked struct was last updated.
    /// This field also acts as a kind of "lock" over the `value` field. Once it is equal
    /// to `Some(current_revision)`, the fields are locked and
    /// cannot change further. This makes it safe to give out `&`-references
    /// so long as they do not live longer than the current revision
    /// (which is assured by tying their lifetime to the lifetime of an `&`-ref
    /// to the database).
    ///
    /// The struct is updated from an older revision `R0` to the current revision `R1`
    /// when the struct is first accessed in `R1`, whether that be because the original
    /// query re-created the struct (i.e., by user calling `Struct::new`) or because
    /// the struct was read from. (Structs may not be recreated in the new revision if
    /// the inputs to the query have not changed.)
    ///
    /// When re-creating the struct, the field is temporarily set to `None`.
    /// This is signal that there is an active `&mut` modifying the other fields:
    /// even reading from those fields in that situation would create UB.
    /// This `None` value should never be observable by users unless they have
    /// leaked a reference across threads somehow.
    updated_at: OptionalAtomicRevision,

    /// The durability minimum durability of all inputs consumed
    /// by the creator query prior to creating this tracked struct.
    /// If any of those inputs changes, then the creator query may
    /// create this struct with different values.
    durability: Durability,

    /// The revision information for each field: when did this field last change.
    /// When tracked structs are re-created, this revision may be updated to the
    /// current revision if the value is different.
    revisions: C::Revisions,

    /// Fields of this tracked struct. They can change across revisions,
    /// but they do not change within a particular revision.
    ///
    /// TODO: Consider whether we need a more explicit aliasing barrier or whether
    /// this should be restructured (e.g., with a nested struct for `fields` + `memos`)
    /// to make the aliasing guarantees more obvious. See PR #741 for prior discussion.
    fields: C::Fields<'static>,

    /// Memo table storing the results of query functions etc.
    /*unsafe */
    memos: MemoTable,
}

这个 value struct 既保存字段值，也保存字段上次发生变化的修订版本。每当这个结构体在新修订中被重新创建时，都会比较新旧字段值，并据此创建新的修订记录。

宏会生成 tracked struct 的 `Configuration`

tracked struct 的 “configuration” 不仅定义了字段类型，还定义了一些关键操作，例如如何提取可哈希的 id 字段，以及如何更新那些用来记录字段最后一次变化时间的 “revisions”：

/// Trait that defines the key properties of a tracked struct.
///
/// Implemented by the `#[salsa::tracked]` macro when applied
/// to a struct.
pub trait Configuration: Sized + 'static {
    const LOCATION: crate::ingredient::Location;

    /// The debug name of the tracked struct.
    const DEBUG_NAME: &'static str;

    /// The debug names of any tracked fields.
    const TRACKED_FIELD_NAMES: &'static [&'static str];

    /// The relative indices of any tracked fields.
    const TRACKED_FIELD_INDICES: &'static [usize];

    /// Whether this struct should be persisted with the database.
    const PERSIST: bool;

    /// A (possibly empty) tuple of the fields for this struct.
    type Fields<'db>: Send + Sync;

    /// A array of [`AtomicRevision`][] values, one per each of the tracked value fields.
    /// When a struct is re-recreated in a new revision, the corresponding
    /// entries for each field are updated to the new revision if their
    /// values have changed (or if the field is marked as `#[no_eq]`).
    #[cfg(feature = "persistence")]
    type Revisions: Send
        + Sync
        + Index<usize, Output = AtomicRevision>
        + plumbing::serde::Serialize
        + for<'de> plumbing::serde::Deserialize<'de>;

    #[cfg(not(feature = "persistence"))]
    type Revisions: Send + Sync + Index<usize, Output = AtomicRevision>;

    type Struct<'db>: Copy + FromId + AsId;

    fn untracked_fields(fields: &Self::Fields<'_>) -> impl Hash;

    /// Create a new value revision array where each element is set to `current_revision`.
    fn new_revisions(current_revision: Revision) -> Self::Revisions;

    /// Update the field data and, if the value has changed,
    /// the appropriate entry in the `revisions` array (tracked fields only).
    ///
    /// Returns `true` if any untracked field was updated and
    /// the struct should be considered re-created.
    ///
    /// # Safety
    ///
    /// Requires the same conditions as the `maybe_update`
    /// method on [the `Update` trait](`crate::update::Update`).
    ///
    /// In short, requires that `old_fields` be a pointer into
    /// storage from a previous revision.
    /// It must meet its validity invariant.
    /// Owned content must meet safety invariant.
    /// `*mut` here is not strictly needed;
    /// it is used to signal that the content
    /// is not guaranteed to recursively meet
    /// its safety invariant and
    /// hence this must be dereferenced with caution.
    ///
    /// Ensures that `old_fields` is fully updated and valid
    /// after it returns and that `revisions` has been updated
    /// for any field that changed.
    unsafe fn update_fields<'db>(
        current_revision: Revision,
        revisions: &Self::Revisions,
        old_fields: *mut Self::Fields<'db>,
        new_fields: Self::Fields<'db>,
    ) -> bool;

    /// Returns the size of any heap allocations in the output value, in bytes.
    fn heap_size(_value: &Self::Fields<'_>) -> Option<usize> {
        None
    }

    /// Serialize the fields using `serde`.
    ///
    /// Panics if the value is not persistable, i.e. `Configuration::PERSIST` is `false`.
    fn serialize<S>(value: &Self::Fields<'_>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: plumbing::serde::Serializer;

    /// Deserialize the fields using `serde`.
    ///
    /// Panics if the value is not persistable, i.e. `Configuration::PERSIST` is `false`.
    fn deserialize<'de, D>(deserializer: D) -> Result<Self::Fields<'static>, D::Error>
    where
        D: plumbing::serde::Deserializer<'de>;
}

Salsa（中文）

跟踪结构体

tracked struct ingredient 与 tracked field ingredient

每个 tracked struct 都有全局唯一的 id

每个 tracked struct 都有一个 ValueStruct 来存储数据

宏会生成 tracked struct 的 Configuration

每个 tracked struct 都有一个 `ValueStruct` 来存储数据

宏会生成 tracked struct 的 `Configuration`