Skip to main content

qualia_core_db/tensor/
resident_snapshot.rs

1//! Bounded immutable semantic source retained by an inference request.
2use super::*;
3use sha2::{Digest, Sha256};
4
5pub struct ResidentSnapshot {
6    nquins: Box<[NQuin]>,
7    metadata: Box<[TensorMetadata]>,
8    subjects: Box<[u64]>,
9    digest: [u8; 32],
10}
11impl ResidentTensorSubstrate {
12    pub fn snapshot_owned(&self, budget: usize) -> Result<ResidentSnapshot, &'static str> {
13        let state = self
14            .state
15            .read()
16            .map_err(|_| "resident substrate poisoned")?;
17        let n = state.node_count as usize;
18        let stride = std::mem::size_of::<NQuin>() + std::mem::size_of::<TensorMetadata>() + 8;
19        let required = n
20            .checked_mul(stride)
21            .and_then(|n| {
22                n.checked_add(
23                    std::mem::size_of::<ResidentSnapshot>() + 2 * std::mem::size_of::<usize>(),
24                )
25            })
26            .ok_or("context budget overflow")?;
27        if required > budget {
28            return Err("context source budget exceeded");
29        }
30        let mut hash = Sha256::new();
31        hash.update(b"qualia:owned-resident-context:v1\0");
32        hash.update((n as u64).to_le_bytes());
33        for i in 0..n {
34            let q = state.nquins[i];
35            for word in [
36                q.subject,
37                q.predicate,
38                q.object,
39                q.context,
40                q.metadata,
41                q.parity,
42                state.subject_hashes[i],
43            ] {
44                hash.update(word.to_le_bytes());
45            }
46            let m = state.metadata[i];
47            hash.update([u8::from(m.has_tensor)]);
48            hash.update(m.tensor_version.to_le_bytes());
49            let t = m.tensor;
50            for f in [t.q, t.v, t.w, t.x, t.y, t.z, t.t, t.alpha, t.mu, t.sigma] {
51                hash.update(f.to_bits().to_le_bytes());
52            }
53        }
54        Ok(ResidentSnapshot {
55            nquins: state.nquins[..n].into(),
56            metadata: state.metadata[..n].into(),
57            subjects: state.subject_hashes[..n].into(),
58            digest: hash.finalize().into(),
59        })
60    }
61}
62impl ResidentSnapshot {
63    pub fn retained_bytes(&self) -> usize {
64        std::mem::size_of::<Self>()
65            + 2 * std::mem::size_of::<usize>()
66            + self.nquins.len() * std::mem::size_of::<NQuin>()
67            + self.metadata.len() * std::mem::size_of::<TensorMetadata>()
68            + self.subjects.len() * 8
69    }
70    pub fn digest(&self) -> [u8; 32] {
71        self.digest
72    }
73    pub fn node_count(&self) -> u32 {
74        self.nquins.len() as u32
75    }
76    pub fn subject_hash_at(&self, index: u32) -> u64 {
77        self.subjects.get(index as usize).copied().unwrap_or(0)
78    }
79    pub fn tensor_at(&self, index: u32) -> Option<Tensor10D> {
80        self.metadata
81            .get(index as usize)
82            .filter(|m| m.has_tensor)
83            .map(|m| m.tensor)
84    }
85    pub fn tensor_search_into(
86        &self,
87        query: &Tensor10D,
88        distance: f32,
89        out: &mut [usize],
90    ) -> Result<usize, TensorVolumeError> {
91        let config = TensorVolumeConfig::default();
92        Q42TensorView::new(&self.nquins, &self.metadata, &config)?
93            .tensor_search_into(query, distance, out)
94    }
95}