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

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

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

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

use crate::{
    num::{Bytes, Capacity, MaxDegree},
    store,
};

use super::boilerplate;

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

boilerplate!(
    store::intrusive::Intrusive => Store,
    for<'a> store::intrusive::Reader<'a> => Reader,
    for<'a> store::intrusive::Exclusive<'a> => Writer,
);

impl Store {
    /// Construct a store with `config.capacity` writable slots, each holding
    /// `config.entry_bytes` bytes. No frozen points are created.
    ///
    /// # Panics
    ///
    /// Panics if the underlying store could not be constructed (e.g. `config.capacity` plus
    /// the frozen point 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 = store::intrusive::Intrusive::config(Bytes::new(config.entry_bytes));
        let store = store::Store::new(store_layout, store_config, slots_config)
            .expect("failed to construct store");

        Self { store }
    }
}

impl<'a> Reader<'a> {
    pub fn read(&self, i: usize) -> Option<&[u8]> {
        self.reader.read(i)
    }
}

impl<'a> Writer<'a> {
    pub fn as_mut_slice(&mut self) -> &mut [u8] {
        self.slot.data().as_mut_slice()
    }
}