diskann-inmem 0.60.0

DiskANN3 is a composable library for bringing scalable, accurate and cost-effective vector indexing to multiple databases.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT license.
 */

#![expect(
    clippy::expect_used,
    clippy::unwrap_used,
    reason = "integration test tools are not production code"
)]

use std::num::{NonZeroU32, NonZeroUsize};

use crate::{
    num::{Capacity, MaxDegree},
    store::{self, checked},
};

use super::boilerplate;

#[derive(Debug)]
pub struct Config {
    pub capacity: usize,
    pub epoch_guard_slots: usize,
    pub freelist_recycle_capacity: usize,
}

boilerplate!(
    checked::Checked => Store,
    for<'a> checked::Reader<'a> => Reader,
    for<'a> checked::Exclusive<'a> => Writer,
);

impl Store {
    /// Construct a store with `config.capacity` writable slots and no frozen points.
    ///
    /// # Panics
    ///
    /// Panics if the underlying store could not be constructed (e.g. `config.capacity`
    /// exceeds `u32::MAX`) or if other configuration parameters such as the number of
    /// epoch guard slots are invalid (e.g. zero).
    pub fn new(config: Config) -> Self {
        let store_layout = store::Layout::new(Capacity::new(config.capacity), MaxDegree::new(0), 0);

        let store_config = store::Config::__exhaustive(
            NonZeroUsize::new(config.epoch_guard_slots)
                .expect("`epoch_guard_slots` must be non-zero"),
            NonZeroU32::new(
                config
                    .freelist_recycle_capacity
                    .try_into()
                    .expect("`freelist_recycle_capacity` must fit within 32-bits"),
            )
            .expect("`freelist_recycle_capacity` must be non-zero"),
        );

        let slots_config = checked::Checked::config();
        let store = store::Store::new(store_layout, store_config, slots_config)
            .expect("failed to construct store");

        Self { store }
    }
}

#[derive(Debug)]
pub struct Value<'a> {
    value: checked::Value<'a>,
}

impl<'a> Value<'a> {
    fn new(value: checked::Value<'a>) -> Self {
        Self { value }
    }

    pub fn get(&self) -> u64 {
        self.value.get()
    }
}

impl Reader<'_> {
    pub fn read(&self, i: usize) -> Option<Value<'_>> {
        self.reader.read(i.try_into().unwrap()).map(Value::new)
    }
}

impl<'a> Writer<'a> {
    pub fn set(&mut self, v: u64) {
        self.slot.data().set(v)
    }
}