qdrant-edge 0.7.1

A lightweight, in-process vector search engine designed for embedded devices, autonomous systems, and mobile agents.
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::conditioned_counter::ConditionedCounter;
use super::counter_cell::{CounterCell, OptionalCounterCell};
use super::hardware_accumulator::HwMeasurementAcc;
use super::hardware_counter::HardwareCounterCell;
use crate::common::iterator_ext::on_final_count::OnFinalCount;

pub trait HwMeasurementIteratorExt: Iterator {
    /// Measures the hardware usage of an iterator.
    ///
    /// # Arguments
    /// - `hw_acc`: accumulator holding a counter cell
    /// - `multiplier`: multiplies the number of iterations by this factor.
    /// - `f`: Closure to get the specific counter to increase from the cell inside the accumulator.
    fn measure_hw_with_acc<R>(
        self,
        hw_acc: HwMeasurementAcc,
        multiplier: usize,
        mut f: R,
    ) -> OnFinalCount<Self, impl FnMut(usize)>
    where
        Self: Sized,
        R: FnMut(&HardwareCounterCell) -> &CounterCell,
    {
        OnFinalCount::new(self, move |total_count| {
            let hw_counter = hw_acc.get_counter_cell();
            f(&hw_counter).incr_delta(total_count * multiplier);
        })
    }

    /// Measures the hardware usage of an iterator.
    ///
    /// # Arguments
    /// - `cc`: Condition counter to write the measurements into.
    /// - `multiplier`: multiplies the number of iterations by this factor.
    /// - `f`: Closure to get the specific counter to increase from the cell inside the accumulator.
    fn measure_hw_with_condition_cell<R>(
        self,
        cc: ConditionedCounter,
        multiplier: usize,
        mut f: R,
    ) -> OnFinalCount<Self, impl FnMut(usize)>
    where
        Self: Sized,
        R: for<'a> FnMut(&'a ConditionedCounter<'a>) -> OptionalCounterCell<'a>,
    {
        OnFinalCount::new(self, move |total_count| {
            f(&cc).incr_delta(total_count * multiplier);
        })
    }

    /// Measures the hardware usage of an iterator.
    ///
    /// # Arguments
    /// - `hw_cell`: counter cell
    /// - `multiplier`: multiplies the number of iterations by this factor.
    /// - `f`: Closure to get the specific counter to increase from `hw_cell`.
    fn measure_hw_with_cell<R>(
        self,
        hw_cell: &HardwareCounterCell,
        multiplier: usize,
        mut f: R,
    ) -> OnFinalCount<Self, impl FnMut(usize)>
    where
        Self: Sized,
        R: FnMut(&HardwareCounterCell) -> &CounterCell,
    {
        OnFinalCount::new(self, move |total_count| {
            f(hw_cell).incr_delta(total_count * multiplier);
        })
    }

    /// Measures the hardware usage of an iterator with the size of a single value being represented as a fraction.
    fn measure_hw_with_acc_and_fraction<R>(
        self,
        hw_acc: HwMeasurementAcc,
        fraction: usize,
        mut f: R,
    ) -> OnFinalCount<Self, impl FnMut(usize)>
    where
        Self: Sized,
        R: FnMut(&HardwareCounterCell) -> &CounterCell,
    {
        OnFinalCount::new(self, move |total_count| {
            let hw_counter = hw_acc.get_counter_cell();
            f(&hw_counter).incr_delta(total_count / fraction);
        })
    }

    /// Measures the hardware usage of an iterator with the size of a single value being represented as a fraction.
    fn measure_hw_with_cell_and_fraction<R>(
        self,
        hw_cell: &HardwareCounterCell,
        fraction: usize,
        mut f: R,
    ) -> OnFinalCount<Self, impl FnMut(usize)>
    where
        Self: Sized,
        R: FnMut(&HardwareCounterCell) -> &CounterCell,
    {
        OnFinalCount::new(self, move |total_count| {
            f(hw_cell).incr_delta(total_count / fraction);
        })
    }
}

impl<I: Iterator> HwMeasurementIteratorExt for I {}