Skip to main content

neco_expr/
storage.rs

1use alloc::vec::Vec;
2use core::mem::size_of;
3
4use crate::{
5    AbsoluteBits, AtomId, CertifiedF64, ConsumerId, EvalError, ExactValue, ExprId, InsertError,
6    ResolveError, StorageError,
7};
8use neco_algnum::IsolatingInterval;
9
10#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
11pub enum StorageResource {
12    GraphNodes,
13    AtomEntries,
14    PrecisionEntries,
15    AssignmentEntries,
16    EvaluationEntries,
17    IsolationEntries,
18    ResolvedEntries,
19    ProductEntries,
20    ProductResolutionEntries,
21}
22
23#[derive(Debug, Eq, PartialEq)]
24pub struct AtomStore {
25    entries: Vec<(AtomId, ExactValue)>,
26}
27
28#[derive(Debug, Eq, PartialEq)]
29pub struct PrecisionRequirements {
30    entries: Vec<(ConsumerId, AbsoluteBits)>,
31}
32
33#[derive(Debug, Eq, PartialEq)]
34pub struct Assignments {
35    entries: Vec<(ConsumerId, ExprId)>,
36}
37
38#[derive(Debug, Eq, PartialEq)]
39pub struct EvaluationCache {
40    entries: Vec<(ExprId, Result<ExactValue, EvalError>)>,
41}
42
43#[derive(Debug, Eq, PartialEq)]
44pub struct IsolationCache {
45    entries: Vec<((ExprId, AbsoluteBits), IsolatingInterval)>,
46}
47
48#[derive(Debug, Eq, PartialEq)]
49pub struct ResolvedValues {
50    entries: Vec<(ConsumerId, Result<CertifiedF64, ResolveError>)>,
51}
52
53#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
54impl AtomStore {
55    pub fn new() -> Self {
56        Self {
57            entries: Vec::new(),
58        }
59    }
60
61    pub fn len(&self) -> usize {
62        self.entries.len()
63    }
64
65    pub fn get(&self, id: AtomId) -> Option<&ExactValue> {
66        get_entry(&self.entries, id)
67    }
68
69    pub fn insert(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
70        insert_entry(
71            &mut self.entries,
72            id,
73            value,
74            StorageResource::AtomEntries,
75            id.get(),
76        )
77    }
78
79    pub fn set(&mut self, id: AtomId, value: ExactValue) -> Result<(), InsertError> {
80        set_entry(
81            &mut self.entries,
82            id,
83            value,
84            StorageResource::AtomEntries,
85            id.get(),
86        )
87    }
88
89    pub fn try_clone(&self) -> Result<Self, InsertError> {
90        let mut entries = Vec::new();
91        reserve_entries(
92            &mut entries,
93            self.entries.len(),
94            StorageResource::AtomEntries,
95        )?;
96        for (id, value) in &self.entries {
97            entries.push((*id, value.try_clone().map_err(atom_value_error)?));
98        }
99        Ok(Self { entries })
100    }
101}
102
103fn atom_value_error(error: EvalError) -> InsertError {
104    InsertError::Value(atom_value_payload(error))
105}
106
107fn atom_value_payload(error: EvalError) -> EvalError {
108    error
109}
110
111#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
112impl PrecisionRequirements {
113    pub fn new() -> Self {
114        Self {
115            entries: Vec::new(),
116        }
117    }
118
119    pub fn len(&self) -> usize {
120        self.entries.len()
121    }
122
123    pub fn get(&self, id: ConsumerId) -> Option<AbsoluteBits> {
124        get_entry(&self.entries, id).copied()
125    }
126
127    pub fn insert(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
128        insert_entry(
129            &mut self.entries,
130            id,
131            bits,
132            StorageResource::PrecisionEntries,
133            id.get(),
134        )
135    }
136
137    pub fn set(&mut self, id: ConsumerId, bits: AbsoluteBits) -> Result<(), InsertError> {
138        set_entry(
139            &mut self.entries,
140            id,
141            bits,
142            StorageResource::PrecisionEntries,
143            id.get(),
144        )
145    }
146
147    pub fn try_clone(&self) -> Result<Self, InsertError> {
148        Ok(Self {
149            entries: try_clone_copy_entries(&self.entries, StorageResource::PrecisionEntries)?,
150        })
151    }
152
153    pub(crate) fn entries(&self) -> &[(ConsumerId, AbsoluteBits)] {
154        &self.entries
155    }
156}
157
158#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
159impl Assignments {
160    pub fn new() -> Self {
161        Self {
162            entries: Vec::new(),
163        }
164    }
165
166    pub fn len(&self) -> usize {
167        self.entries.len()
168    }
169
170    pub fn get(&self, id: ConsumerId) -> Option<ExprId> {
171        get_entry(self.entries(), id).copied()
172    }
173
174    pub fn insert(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
175        insert_entry(
176            &mut self.entries,
177            id,
178            expr,
179            StorageResource::AssignmentEntries,
180            id.get(),
181        )
182    }
183
184    pub fn set(&mut self, id: ConsumerId, expr: ExprId) -> Result<(), InsertError> {
185        set_entry(
186            &mut self.entries,
187            id,
188            expr,
189            StorageResource::AssignmentEntries,
190            id.get(),
191        )
192    }
193
194    pub fn try_clone(&self) -> Result<Self, InsertError> {
195        Ok(Self {
196            entries: try_clone_copy_entries(&self.entries, StorageResource::AssignmentEntries)?,
197        })
198    }
199
200    pub(crate) fn entries(&self) -> &[(ConsumerId, ExprId)] {
201        &self.entries
202    }
203}
204
205#[allow(clippy::len_without_is_empty, clippy::new_without_default)]
206impl EvaluationCache {
207    pub(crate) fn new() -> Self {
208        Self {
209            entries: Vec::new(),
210        }
211    }
212
213    pub fn len(&self) -> usize {
214        self.entries.len()
215    }
216
217    pub fn get(&self, id: ExprId) -> Option<&Result<ExactValue, EvalError>> {
218        get_entry(&self.entries, id)
219    }
220
221    pub(crate) fn get_mut(&mut self, id: ExprId) -> Option<&mut Result<ExactValue, EvalError>> {
222        self.entries
223            .binary_search_by(|(candidate, _)| candidate.cmp(&id))
224            .ok()
225            .map(|index| &mut self.entries[index].1)
226    }
227
228    pub(crate) fn insert(
229        &mut self,
230        id: ExprId,
231        value: Result<ExactValue, EvalError>,
232    ) -> Result<(), StorageError> {
233        let index = match find_key(&self.entries, &id) {
234            Ok(_) => return Ok(()),
235            Err(index) => index,
236        };
237        let required = required_elements(self.entries.len(), StorageResource::EvaluationEntries)?;
238        reserve_entries(
239            &mut self.entries,
240            required,
241            StorageResource::EvaluationEntries,
242        )?;
243        self.entries.insert(index, (id, value));
244        Ok(())
245    }
246}
247
248#[allow(clippy::len_without_is_empty)]
249impl IsolationCache {
250    pub(crate) fn new() -> Self {
251        Self {
252            entries: Vec::new(),
253        }
254    }
255
256    pub fn len(&self) -> usize {
257        self.entries.len()
258    }
259
260    pub fn get(&self, id: ExprId, bits: AbsoluteBits) -> Option<&IsolatingInterval> {
261        get_entry(&self.entries, (id, bits))
262    }
263
264    pub(crate) fn insert(
265        &mut self,
266        id: ExprId,
267        bits: AbsoluteBits,
268        interval: IsolatingInterval,
269    ) -> Result<(), StorageError> {
270        insert_cache_entry(
271            &mut self.entries,
272            (id, bits),
273            interval,
274            StorageResource::IsolationEntries,
275        )
276    }
277}
278
279#[allow(clippy::len_without_is_empty)]
280impl ResolvedValues {
281    pub(crate) fn new() -> Self {
282        Self {
283            entries: Vec::new(),
284        }
285    }
286
287    pub fn len(&self) -> usize {
288        self.entries.len()
289    }
290
291    pub fn get(&self, id: ConsumerId) -> Option<&Result<CertifiedF64, ResolveError>> {
292        get_entry(&self.entries, id)
293    }
294
295    pub(crate) fn insert(
296        &mut self,
297        id: ConsumerId,
298        value: Result<CertifiedF64, ResolveError>,
299    ) -> Result<(), StorageError> {
300        insert_cache_entry(
301            &mut self.entries,
302            id,
303            value,
304            StorageResource::ResolvedEntries,
305        )
306    }
307}
308
309fn insert_cache_entry<K: Ord, V>(
310    entries: &mut Vec<(K, V)>,
311    key: K,
312    value: V,
313    resource: StorageResource,
314) -> Result<(), StorageError> {
315    let index = match find_key(entries, &key) {
316        Ok(_) => return Ok(()),
317        Err(index) => index,
318    };
319    let required = required_elements(entries.len(), resource)?;
320    reserve_entries(entries, required, resource)?;
321    entries.insert(index, (key, value));
322    Ok(())
323}
324
325fn find_key<K: Ord, V>(entries: &[(K, V)], key: &K) -> Result<usize, usize> {
326    entries.binary_search_by(|(candidate, _)| candidate.cmp(key))
327}
328
329fn get_entry<K: Ord, V>(entries: &[(K, V)], key: K) -> Option<&V> {
330    find_key(entries, &key).ok().map(|index| &entries[index].1)
331}
332
333fn insert_entry<K: Ord, V>(
334    entries: &mut Vec<(K, V)>,
335    key: K,
336    value: V,
337    resource: StorageResource,
338    id: u32,
339) -> Result<(), InsertError> {
340    let index = match find_key(entries, &key) {
341        Ok(_) => return Err(InsertError::DuplicateId { resource, id }),
342        Err(index) => index,
343    };
344    let required = required_elements(entries.len(), resource)?;
345    reserve_entries(entries, required, resource)?;
346    entries.insert(index, (key, value));
347    Ok(())
348}
349
350fn set_entry<K: Ord, V>(
351    entries: &mut Vec<(K, V)>,
352    key: K,
353    value: V,
354    resource: StorageResource,
355    id: u32,
356) -> Result<(), InsertError> {
357    match find_key(entries, &key) {
358        Ok(index) => {
359            entries[index].1 = value;
360            Ok(())
361        }
362        Err(_) => insert_entry(entries, key, value, resource, id),
363    }
364}
365
366fn try_clone_copy_entries<K: Copy, V: Copy>(
367    source: &[(K, V)],
368    resource: StorageResource,
369) -> Result<Vec<(K, V)>, InsertError> {
370    let mut entries = Vec::new();
371    reserve_entries(&mut entries, source.len(), resource)?;
372    entries.extend_from_slice(source);
373    Ok(entries)
374}
375
376pub(crate) fn required_elements(
377    current: usize,
378    resource: StorageResource,
379) -> Result<usize, StorageError> {
380    current
381        .checked_add(1)
382        .ok_or(StorageError::CapacityOverflow { resource })
383}
384
385pub(crate) fn reserve_entries<T>(
386    entries: &mut Vec<T>,
387    total_required: usize,
388    resource: StorageResource,
389) -> Result<(), StorageError> {
390    #[cfg(test)]
391    if let Some(error) = injected_failure(resource, total_required) {
392        return Err(error);
393    }
394
395    let maximum = if size_of::<T>() == 0 {
396        usize::MAX
397    } else {
398        (isize::MAX as usize) / size_of::<T>()
399    };
400    if total_required > maximum {
401        return Err(StorageError::CapacityOverflow { resource });
402    }
403    let additional = total_required
404        .checked_sub(entries.len())
405        .ok_or(StorageError::CapacityOverflow { resource })?;
406    entries
407        .try_reserve(additional)
408        .map_err(|_| StorageError::AllocationFailure {
409            resource,
410            requested_elements: total_required,
411        })
412}
413
414#[cfg(test)]
415#[derive(Clone, Copy)]
416pub(crate) enum InjectedFailure {
417    Capacity,
418    Allocation,
419}
420
421#[cfg(test)]
422std::thread_local! {
423    static INJECTED_FAILURE: core::cell::Cell<Option<(StorageResource, InjectedFailure)>> = const { core::cell::Cell::new(None) };
424}
425
426#[cfg(test)]
427fn injected_failure(resource: StorageResource, requested_elements: usize) -> Option<StorageError> {
428    INJECTED_FAILURE.with(|configured| {
429        let error = match configured.get() {
430            Some((expected, InjectedFailure::Capacity)) if expected == resource => {
431                Some(StorageError::CapacityOverflow { resource })
432            }
433            Some((expected, InjectedFailure::Allocation)) if expected == resource => {
434                Some(StorageError::AllocationFailure {
435                    resource,
436                    requested_elements,
437                })
438            }
439            _ => None,
440        };
441        if error.is_some() {
442            configured.set(None);
443        }
444        error
445    })
446}
447
448#[cfg(test)]
449pub(crate) fn with_injected_failure<R>(
450    resource: StorageResource,
451    failure: InjectedFailure,
452    operation: impl FnOnce() -> R,
453) -> R {
454    INJECTED_FAILURE.with(|configured| configured.set(Some((resource, failure))));
455    let result = operation();
456    INJECTED_FAILURE.with(|configured| configured.set(None));
457    result
458}
459
460#[cfg(test)]
461mod tests {
462    use alloc::vec;
463    use alloc::vec::Vec;
464
465    use neco_algnum::RealAlgebraic;
466    use neco_formsum::FormSum;
467    use neco_monomial::{Monomial, MonomialErrorKind};
468
469    use super::{
470        required_elements, reserve_entries, with_injected_failure, InjectedFailure, StorageResource,
471    };
472    use crate::value::{with_clone_failure, CloneContact};
473    use crate::{
474        AbsoluteBits, Assignments, AtomId, AtomStore, ConsumerId, EvalError, ExactValue, ExprGraph,
475        ExprNode, GraphError, InsertError, PrecisionRequirements, ResolveError, Resolver,
476        StorageError,
477    };
478
479    const RESOURCES: [StorageResource; 7] = [
480        StorageResource::GraphNodes,
481        StorageResource::AtomEntries,
482        StorageResource::PrecisionEntries,
483        StorageResource::AssignmentEntries,
484        StorageResource::EvaluationEntries,
485        StorageResource::IsolationEntries,
486        StorageResource::ResolvedEntries,
487    ];
488
489    #[test]
490    fn required_total_rejects_capacity_overflow() {
491        for resource in RESOURCES {
492            assert_eq!(
493                required_elements(usize::MAX, resource),
494                Err(StorageError::CapacityOverflow { resource })
495            );
496        }
497    }
498
499    #[test]
500    fn allocation_failure_reports_total_and_preserves_entries() {
501        let mut entries = vec![10_u32];
502        let result = with_injected_failure(
503            StorageResource::PrecisionEntries,
504            InjectedFailure::Allocation,
505            || reserve_entries(&mut entries, 2, StorageResource::PrecisionEntries),
506        );
507        assert_eq!(
508            result,
509            Err(StorageError::AllocationFailure {
510                resource: StorageResource::PrecisionEntries,
511                requested_elements: 2,
512            })
513        );
514        assert_eq!(entries, [10]);
515    }
516
517    #[test]
518    fn capacity_injection_uses_production_reservation_path() {
519        let mut requirements = PrecisionRequirements::new();
520        let result = with_injected_failure(
521            StorageResource::PrecisionEntries,
522            InjectedFailure::Capacity,
523            || requirements.insert(ConsumerId::new(1), AbsoluteBits::new(20)),
524        );
525        assert_eq!(
526            result,
527            Err(InsertError::Storage(StorageError::CapacityOverflow {
528                resource: StorageResource::PrecisionEntries,
529            }))
530        );
531        assert_eq!(requirements.len(), 0);
532    }
533
534    #[test]
535    fn allocation_injection_identifies_every_resource() {
536        for resource in RESOURCES {
537            let mut entries = Vec::<u32>::new();
538            let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
539                reserve_entries(&mut entries, 1, resource)
540            });
541            assert_eq!(
542                result,
543                Err(StorageError::AllocationFailure {
544                    resource,
545                    requested_elements: 1,
546                })
547            );
548            assert!(entries.is_empty());
549        }
550    }
551
552    #[test]
553    fn map_order_duplicate_and_set_are_deterministic() {
554        let mut left = PrecisionRequirements::new();
555        left.insert(ConsumerId::new(2), AbsoluteBits::new(20))
556            .unwrap();
557        left.insert(ConsumerId::new(1), AbsoluteBits::new(10))
558            .unwrap();
559
560        let mut right = PrecisionRequirements::new();
561        right
562            .insert(ConsumerId::new(1), AbsoluteBits::new(10))
563            .unwrap();
564        right
565            .insert(ConsumerId::new(2), AbsoluteBits::new(20))
566            .unwrap();
567        assert_eq!(left, right);
568
569        assert_eq!(
570            left.insert(ConsumerId::new(1), AbsoluteBits::new(99)),
571            Err(InsertError::DuplicateId {
572                resource: StorageResource::PrecisionEntries,
573                id: 1,
574            })
575        );
576        assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(10)));
577
578        left.set(ConsumerId::new(1), AbsoluteBits::new(30)).unwrap();
579        assert_eq!(left.get(ConsumerId::new(1)), Some(AbsoluteBits::new(30)));
580        assert_eq!(left.len(), 2);
581    }
582
583    #[test]
584    fn graph_storage_failure_is_wrapped_and_preserves_graph() {
585        let mut graph = ExprGraph::new();
586        let result = with_injected_failure(
587            StorageResource::GraphNodes,
588            InjectedFailure::Allocation,
589            || graph.push(ExprNode::Atom(AtomId::new(0))),
590        );
591        assert_eq!(
592            result,
593            Err(GraphError::Storage(StorageError::AllocationFailure {
594                resource: StorageResource::GraphNodes,
595                requested_elements: 1,
596            }))
597        );
598        assert!(graph.is_empty());
599    }
600
601    #[test]
602    fn every_input_map_wraps_allocation_failure_and_preserves_its_value() {
603        let mut atoms = AtomStore::new();
604        let atom_result = with_injected_failure(
605            StorageResource::AtomEntries,
606            InjectedFailure::Allocation,
607            || atoms.insert(AtomId::new(4), ExactValue::Monomial(Monomial::one())),
608        );
609        assert_eq!(
610            atom_result,
611            Err(InsertError::Storage(StorageError::AllocationFailure {
612                resource: StorageResource::AtomEntries,
613                requested_elements: 1,
614            }))
615        );
616        assert_eq!(atoms.len(), 0);
617
618        let mut requirements = PrecisionRequirements::new();
619        let precision_result = with_injected_failure(
620            StorageResource::PrecisionEntries,
621            InjectedFailure::Allocation,
622            || requirements.insert(ConsumerId::new(4), AbsoluteBits::new(20)),
623        );
624        assert_eq!(
625            precision_result,
626            Err(InsertError::Storage(StorageError::AllocationFailure {
627                resource: StorageResource::PrecisionEntries,
628                requested_elements: 1,
629            }))
630        );
631        assert_eq!(requirements.len(), 0);
632
633        let mut assignments = Assignments::new();
634        let assignment_result = with_injected_failure(
635            StorageResource::AssignmentEntries,
636            InjectedFailure::Allocation,
637            || assignments.insert(ConsumerId::new(4), crate::ExprId::new(0)),
638        );
639        assert_eq!(
640            assignment_result,
641            Err(InsertError::Storage(StorageError::AllocationFailure {
642                resource: StorageResource::AssignmentEntries,
643                requested_elements: 1,
644            }))
645        );
646        assert_eq!(assignments.len(), 0);
647    }
648
649    #[test]
650    fn atom_clone_failure_is_value_error_with_the_original_payload() {
651        let mut atoms = AtomStore::new();
652        atoms
653            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
654            .unwrap();
655        assert_eq!(
656            with_clone_failure(CloneContact::Monomial, || atoms.try_clone()),
657            Err(InsertError::Value(EvalError::Monomial(
658                MonomialErrorKind::AllocationFailure {
659                    requested_elements: 19,
660                }
661            )))
662        );
663        assert_eq!(atoms.len(), 1);
664    }
665
666    #[test]
667    fn evaluation_clone_failure_is_local_and_preserves_the_cache_entry() {
668        let mut graph = ExprGraph::new();
669        let failed = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
670        let succeeded = graph.push(ExprNode::Atom(AtomId::new(1))).unwrap();
671        let mut atoms = AtomStore::new();
672        atoms
673            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
674            .unwrap();
675        atoms
676            .insert(AtomId::new(1), ExactValue::FormSum(FormSum::one().unwrap()))
677            .unwrap();
678        let mut requirements = PrecisionRequirements::new();
679        let mut assignments = Assignments::new();
680        for (consumer, expression) in [
681            (ConsumerId::new(0), failed),
682            (ConsumerId::new(1), succeeded),
683        ] {
684            requirements.insert(consumer, AbsoluteBits::new(0)).unwrap();
685            assignments.insert(consumer, expression).unwrap();
686        }
687        let (evaluation, _, resolved) = with_clone_failure(CloneContact::Monomial, || {
688            Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
689        })
690        .unwrap();
691        let expected = EvalError::Monomial(MonomialErrorKind::AllocationFailure {
692            requested_elements: 19,
693        });
694        assert_eq!(evaluation.get(failed), Some(&Err(expected)));
695        assert_eq!(
696            resolved.get(ConsumerId::new(0)),
697            Some(&Err(ResolveError::Evaluation(EvalError::Monomial(
698                MonomialErrorKind::AllocationFailure {
699                    requested_elements: 19,
700                }
701            ))))
702        );
703        assert!(resolved.get(ConsumerId::new(1)).unwrap().as_ref().is_ok());
704    }
705
706    #[test]
707    fn resolver_reports_evaluation_and_result_storage_failures_globally() {
708        let mut graph = ExprGraph::new();
709        let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
710        let mut atoms = AtomStore::new();
711        atoms
712            .insert(AtomId::new(0), ExactValue::Monomial(Monomial::one()))
713            .unwrap();
714        let mut requirements = PrecisionRequirements::new();
715        requirements
716            .insert(ConsumerId::new(0), AbsoluteBits::new(0))
717            .unwrap();
718        let mut assignments = Assignments::new();
719        assignments.insert(ConsumerId::new(0), expr).unwrap();
720
721        for resource in [
722            StorageResource::EvaluationEntries,
723            StorageResource::ResolvedEntries,
724        ] {
725            let result = with_injected_failure(resource, InjectedFailure::Allocation, || {
726                Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments)
727            });
728            assert_eq!(
729                result,
730                Err(ResolveError::Storage(StorageError::AllocationFailure {
731                    resource,
732                    requested_elements: 1,
733                }))
734            );
735        }
736    }
737
738    #[test]
739    fn resolver_reports_isolation_storage_failure_globally() {
740        let form = FormSum::one().unwrap();
741        let mut graph = ExprGraph::new();
742        let expr = graph.push(ExprNode::Atom(AtomId::new(0))).unwrap();
743        let mut atoms = AtomStore::new();
744        atoms
745            .insert(
746                AtomId::new(0),
747                ExactValue::Algebraic(RealAlgebraic::from_form_sum(&form).unwrap()),
748            )
749            .unwrap();
750        let mut requirements = PrecisionRequirements::new();
751        requirements
752            .insert(ConsumerId::new(0), AbsoluteBits::new(0))
753            .unwrap();
754        let mut assignments = Assignments::new();
755        assignments.insert(ConsumerId::new(0), expr).unwrap();
756
757        let result = with_injected_failure(
758            StorageResource::IsolationEntries,
759            InjectedFailure::Allocation,
760            || Resolver::new().resolve_all(&graph, &atoms, &requirements, &assignments),
761        );
762        assert_eq!(
763            result,
764            Err(ResolveError::Storage(StorageError::AllocationFailure {
765                resource: StorageResource::IsolationEntries,
766                requested_elements: 1,
767            }))
768        );
769    }
770}