qualia_core_db/query/
graph_index.rs1#[cfg(not(target_arch = "wasm32"))]
13use crate::indexing::QuinIndex;
14use std::sync::{Mutex, RwLock};
15
16pub struct RevisionCache<T> {
26 inner: RwLock<Option<(u64, T)>>,
27 build_lock: Mutex<()>,
28}
29
30impl<T> RevisionCache<T> {
31 pub const fn new() -> Self {
33 Self {
34 inner: RwLock::new(None),
35 build_lock: Mutex::new(()),
36 }
37 }
38
39 pub fn current_revision(&self) -> Option<u64> {
41 let guard = self.inner.read().unwrap_or_else(|e| e.into_inner());
42 guard.as_ref().map(|(rev, _)| *rev)
43 }
44
45 pub fn invalidate(&self) {
47 let _build_guard = self.build_lock.lock().unwrap_or_else(|e| e.into_inner());
48 let mut w = self.inner.write().unwrap_or_else(|e| e.into_inner());
49 *w = None;
50 }
51
52 pub fn with<R>(&self, revision: u64, build: impl FnOnce() -> T, f: impl FnOnce(&T) -> R) -> R {
56 {
58 let guard = self.inner.read().unwrap_or_else(|e| e.into_inner());
59 if let Some((rev, value)) = guard.as_ref() {
60 if *rev >= revision {
61 return f(value);
62 }
63 }
64 }
65 {
67 let _build_guard = self.build_lock.lock().unwrap_or_else(|e| e.into_inner());
68 let needs_build = {
69 let guard = self.inner.read().unwrap_or_else(|e| e.into_inner());
70 guard.as_ref().map_or(true, |(rev, _)| *rev < revision)
71 };
72 if needs_build {
73 let value = build();
74 let mut w = self.inner.write().unwrap_or_else(|e| e.into_inner());
75 if w.as_ref().map_or(true, |(cur_rev, _)| revision >= *cur_rev) {
76 *w = Some((revision, value));
77 }
78 }
79 }
80 let guard = self.inner.read().unwrap_or_else(|e| e.into_inner());
81 let (_, value) = guard.as_ref().expect("cache just populated");
82 f(value)
83 }
84}
85
86impl<T> Default for RevisionCache<T> {
87 fn default() -> Self {
88 Self::new()
89 }
90}
91
92#[cfg(not(target_arch = "wasm32"))]
93static GRAPH_INDEX: RevisionCache<QuinIndex> = RevisionCache::new();
94
95#[cfg(not(target_arch = "wasm32"))]
102pub fn with_graph_index<R>(f: impl FnOnce(&QuinIndex) -> R) -> R {
104 let revision = crate::daemon_graph::graph_revision();
105 GRAPH_INDEX.with(
106 revision,
107 || {
108 let guard = crate::daemon_graph::graph_read_guard();
109 QuinIndex::from_slice(guard.as_slice())
110 },
111 f,
112 )
113}
114
115#[cfg(test)]
116mod tests {
117 use super::*;
118 use std::sync::atomic::{AtomicUsize, Ordering};
119 use std::sync::{Arc, Barrier};
120
121 #[test]
122 fn rebuilds_only_on_revision_change() {
123 let cache: RevisionCache<usize> = RevisionCache::new();
124 let builds = AtomicUsize::new(0);
125 assert_eq!(cache.current_revision(), None);
126
127 let v = cache.with(
129 1,
130 || {
131 builds.fetch_add(1, Ordering::SeqCst);
132 42
133 },
134 |v| *v,
135 );
136 assert_eq!(v, 42);
137 assert_eq!(cache.current_revision(), Some(1));
138 cache.with(
140 1,
141 || {
142 builds.fetch_add(1, Ordering::SeqCst);
143 0
144 },
145 |_| (),
146 );
147 assert_eq!(
148 builds.load(Ordering::SeqCst),
149 1,
150 "same revision must not rebuild"
151 );
152
153 cache.with(
155 2,
156 || {
157 builds.fetch_add(1, Ordering::SeqCst);
158 99
159 },
160 |_| (),
161 );
162 assert_eq!(
163 builds.load(Ordering::SeqCst),
164 2,
165 "changed revision must rebuild"
166 );
167 assert_eq!(cache.current_revision(), Some(2));
168 cache.with(
170 2,
171 || {
172 builds.fetch_add(1, Ordering::SeqCst);
173 0
174 },
175 |_| (),
176 );
177 assert_eq!(builds.load(Ordering::SeqCst), 2);
178 }
179
180 #[test]
181 fn monotonic_revision_prevents_stale_overwrite() {
182 let cache: RevisionCache<usize> = RevisionCache::new();
183 let builds = AtomicUsize::new(0);
184
185 let v2 = cache.with(
186 2,
187 || {
188 builds.fetch_add(1, Ordering::SeqCst);
189 200
190 },
191 |v| *v,
192 );
193 assert_eq!(v2, 200);
194 assert_eq!(cache.current_revision(), Some(2));
195
196 let v_stale = cache.with(
198 1,
199 || {
200 builds.fetch_add(1, Ordering::SeqCst);
201 100
202 },
203 |v| *v,
204 );
205 assert_eq!(v_stale, 200);
206 assert_eq!(builds.load(Ordering::SeqCst), 1);
207 assert_eq!(cache.current_revision(), Some(2));
208
209 cache.invalidate();
211 assert_eq!(cache.current_revision(), None);
212 let v1 = cache.with(
213 1,
214 || {
215 builds.fetch_add(1, Ordering::SeqCst);
216 100
217 },
218 |v| *v,
219 );
220 assert_eq!(v1, 100);
221 assert_eq!(cache.current_revision(), Some(1));
222 }
223
224 #[test]
225 fn single_flight_deduplicates_concurrent_rebuilds() {
226 let cache = Arc::new(RevisionCache::<usize>::new());
227 let builds = Arc::new(AtomicUsize::new(0));
228 let barrier = Arc::new(Barrier::new(8));
229
230 let mut handles = Vec::with_capacity(8);
231 for _ in 0..8 {
232 let cache = Arc::clone(&cache);
233 let builds = Arc::clone(&builds);
234 let barrier = Arc::clone(&barrier);
235 handles.push(std::thread::spawn(move || {
236 barrier.wait();
237 cache.with(
238 5,
239 || {
240 builds.fetch_add(1, Ordering::SeqCst);
241 555
242 },
243 |v| *v,
244 )
245 }));
246 }
247
248 for h in handles {
249 assert_eq!(h.join().unwrap(), 555);
250 }
251 assert_eq!(
252 builds.load(Ordering::SeqCst),
253 1,
254 "8 concurrent threads requesting revision 5 must invoke build() exactly once"
255 );
256 assert_eq!(cache.current_revision(), Some(5));
257 }
258
259 #[test]
260 fn reentrant_with_inside_callback_does_not_deadlock() {
261 let cache: RevisionCache<usize> = RevisionCache::new();
262 let outer = cache.with(
263 3,
264 || 30,
265 |v| {
266 let inner = cache.with(3, || 999, |inner_v| *inner_v + 7);
267 *v + inner
268 },
269 );
270 assert_eq!(outer, 67);
271 }
272}