From fcd0b2415244c9eae40ffe2e771cab1ac193ff01 Mon Sep 17 00:00:00 2001 From: Mark Hildebrand Date: Wed, 11 Feb 2026 18:15:16 -0800 Subject: [PATCH 1/3] Bump diskann-quantization to edition 2024. --- diskann-quantization/Cargo.toml | 2 +- diskann-quantization/src/algorithms/heap.rs | 4 +++- .../src/algorithms/kmeans/common.rs | 4 ++-- diskann-quantization/src/alloc/aligned.rs | 6 +++++- diskann-quantization/src/alloc/mod.rs | 3 ++- diskann-quantization/src/bits/slice.rs | 4 +++- diskann-quantization/src/flatbuffers.rs | 1 + diskann-quantization/src/minmax/multi/meta.rs | 5 ++++- .../src/multi_vector/matrix.rs | 19 +++++++++++++++---- diskann-quantization/src/test_util.rs | 3 ++- 10 files changed, 38 insertions(+), 13 deletions(-) diff --git a/diskann-quantization/Cargo.toml b/diskann-quantization/Cargo.toml index 9e6f09436..624289de3 100644 --- a/diskann-quantization/Cargo.toml +++ b/diskann-quantization/Cargo.toml @@ -5,7 +5,7 @@ description.workspace = true authors.workspace = true documentation.workspace = true license.workspace = true -edition.workspace = true +edition = "2024" [dependencies] bytemuck = { workspace = true, features = ["derive"] } diff --git a/diskann-quantization/src/algorithms/heap.rs b/diskann-quantization/src/algorithms/heap.rs index b3d1093fe..4f9ae4fef 100644 --- a/diskann-quantization/src/algorithms/heap.rs +++ b/diskann-quantization/src/algorithms/heap.rs @@ -101,7 +101,9 @@ impl<'a, T: Ord + Copy> SliceHeap<'a, T> { /// `pos < self.len()` (checked in debug mode). unsafe fn get_unchecked(&self, pos: usize) -> &T { debug_assert!(pos < self.len()); - self.data.get_unchecked(pos) + + // SAFETY: Inherited from caller. + unsafe { self.data.get_unchecked(pos) } } /// Swap the two elements as positions `a` and `b`. diff --git a/diskann-quantization/src/algorithms/kmeans/common.rs b/diskann-quantization/src/algorithms/kmeans/common.rs index 3c095de0d..74145b407 100644 --- a/diskann-quantization/src/algorithms/kmeans/common.rs +++ b/diskann-quantization/src/algorithms/kmeans/common.rs @@ -221,13 +221,13 @@ impl BlockTranspose { /// Block must be in-bounds (i.e., `block < self.num_blocks()`). pub unsafe fn block_ptr_unchecked(&self, block: usize) -> *const f32 { debug_assert!(block < self.num_blocks()); - // SAFETY: If we assume `block < self.num_blocks()`, then + // SAFETY: If we assume `block < self.num_blocks()`, (which the caller attests) then // // 1. Our base pointer was allocated in the first place, so this computed offset // must fit within an `isize`. // 2. This pointer (and an offset `self.block_stride()`) higher all live within // a single allocated object. - self.data.as_ptr().add(self.block_offset(block)) + unsafe { self.data.as_ptr().add(self.block_offset(block)) } } /// Return a pointer to the start of data segment. diff --git a/diskann-quantization/src/alloc/aligned.rs b/diskann-quantization/src/alloc/aligned.rs index 9fd8f7d59..3a3d3f6fd 100644 --- a/diskann-quantization/src/alloc/aligned.rs +++ b/diskann-quantization/src/alloc/aligned.rs @@ -60,7 +60,11 @@ unsafe impl AllocatorCore for AlignedAllocator { let layout = layout .align_to(self.alignment()) .expect("invalid layout provided"); - GlobalAllocator.deallocate(ptr, layout) + + // SAFETY: If the caller upheld the safety contract of `deallocate`, then this + // pointer is safe to deallocate and the layout is compatible with the layout + // created with `allocate`. + unsafe { GlobalAllocator.deallocate(ptr, layout) } } } diff --git a/diskann-quantization/src/alloc/mod.rs b/diskann-quantization/src/alloc/mod.rs index c58408837..5f0857fbe 100644 --- a/diskann-quantization/src/alloc/mod.rs +++ b/diskann-quantization/src/alloc/mod.rs @@ -86,7 +86,8 @@ unsafe impl AllocatorCore for ScopedAllocator<'_> { } unsafe fn deallocate(&self, ptr: NonNull<[u8]>, layout: std::alloc::Layout) { - self.allocator.deallocate(ptr, layout) + // SAFETY: Inherited from caller. + unsafe { self.allocator.deallocate(ptr, layout) } } } diff --git a/diskann-quantization/src/bits/slice.rs b/diskann-quantization/src/bits/slice.rs index fb77cefff..3f28c8e72 100644 --- a/diskann-quantization/src/bits/slice.rs +++ b/diskann-quantization/src/bits/slice.rs @@ -574,7 +574,9 @@ where { let count: Len = count.into(); debug_assert_eq!(precursor.precursor_len(), Self::bytes_for(count.value())); - Self::new_unchecked_internal(precursor.precursor_into(), count) + + // SAFETY: Inherited from the caller. + unsafe { Self::new_unchecked_internal(precursor.precursor_into(), count) } } /// Construct a new `BitSlice` from the `precursor` capable of holding `count` encoded diff --git a/diskann-quantization/src/flatbuffers.rs b/diskann-quantization/src/flatbuffers.rs index d1fd7685c..0c57e2213 100644 --- a/diskann-quantization/src/flatbuffers.rs +++ b/diskann-quantization/src/flatbuffers.rs @@ -19,6 +19,7 @@ macro_rules! import_schema { ($module:ident, $path:literal) => { // The generated files don't compile cleanly - so we need to suppress some lints. #[allow( + unsafe_op_in_unsafe_fn, dead_code, unused_imports, clippy::extra_unused_lifetimes, diff --git a/diskann-quantization/src/minmax/multi/meta.rs b/diskann-quantization/src/minmax/multi/meta.rs index 3f6e8ce77..5293de504 100644 --- a/diskann-quantization/src/minmax/multi/meta.rs +++ b/diskann-quantization/src/minmax/multi/meta.rs @@ -155,7 +155,10 @@ where /// - The caller guarantees that `ptr` was allocated with the correct layout. unsafe fn drop(self, ptr: NonNull) { let slice_ptr = std::ptr::slice_from_raw_parts_mut(ptr.as_ptr(), self.bytes()); - let _ = Box::from_raw(slice_ptr); + + // Safety: inherited from caller. All implementations that create a new owned + // `Mat` are compatible with `Box` deallocation. + let _ = unsafe { Box::from_raw(slice_ptr) }; } } diff --git a/diskann-quantization/src/multi_vector/matrix.rs b/diskann-quantization/src/multi_vector/matrix.rs index e8789b2c8..465ca42f7 100644 --- a/diskann-quantization/src/multi_vector/matrix.rs +++ b/diskann-quantization/src/multi_vector/matrix.rs @@ -420,8 +420,13 @@ unsafe impl Repr for Standard { debug_assert!(ptr.cast::().is_aligned()); debug_assert!(i < self.nrows); - let row_ptr = ptr.as_ptr().cast::().add(i * self.ncols); - std::slice::from_raw_parts(row_ptr, self.ncols) + // SAFETY: The caller asserts that `i` is less than `self.nrows()`. Since this type + // audits the constructors for `Mat` and friends, we know that there is room for at + // least `self.num_elements()` elements from the base pointer, so this access is safe. + let row_ptr = unsafe { ptr.as_ptr().cast::().add(i * self.ncols) }; + + // SAFETY: The logic is the same to the previous `unsafe` block. + unsafe { std::slice::from_raw_parts(row_ptr, self.ncols) } } } @@ -437,8 +442,14 @@ unsafe impl ReprMut for Standard { debug_assert!(ptr.cast::().is_aligned()); debug_assert!(i < self.nrows); - let row_ptr = ptr.as_ptr().cast::().add(i * self.ncols); - std::slice::from_raw_parts_mut(row_ptr, self.ncols) + // SAFETY: The caller asserts that `i` is less than `self.nrows()`. Since this type + // audits the constructors for `Mat` and friends, we know that there is room for at + // least `self.num_elements()` elements from the base pointer, so this access is safe. + let row_ptr = unsafe { ptr.as_ptr().cast::().add(i * self.ncols) }; + + // SAFETY: The logic is the same to the previous `unsafe` block. Further, the caller + // attests that creating a mutable reference is safe. + unsafe { std::slice::from_raw_parts_mut(row_ptr, self.ncols) } } } diff --git a/diskann-quantization/src/test_util.rs b/diskann-quantization/src/test_util.rs index a258dd12a..82371d32a 100644 --- a/diskann-quantization/src/test_util.rs +++ b/diskann-quantization/src/test_util.rs @@ -77,7 +77,8 @@ unsafe impl AllocatorCore for LimitedAllocator { } unsafe fn deallocate(&self, ptr: std::ptr::NonNull<[u8]>, layout: std::alloc::Layout) { - (GlobalAllocator).deallocate(ptr, layout) + // SAFETY: Inherited from caller. + unsafe { (GlobalAllocator).deallocate(ptr, layout) } } } From 1a463608848f25e917a672b4906690f477b40505 Mon Sep 17 00:00:00 2001 From: Mark Hildebrand Date: Wed, 11 Feb 2026 18:32:34 -0800 Subject: [PATCH 2/3] Run the formatter. --- diskann-quantization/src/__codegen/x86_64.rs | 2 +- .../src/algorithms/hadamard.rs | 2 +- diskann-quantization/src/algorithms/heap.rs | 32 ++- .../src/algorithms/kmeans/common.rs | 2 +- .../src/algorithms/kmeans/lloyds.rs | 6 +- .../src/algorithms/kmeans/mod.rs | 2 +- .../src/algorithms/kmeans/plusplus.rs | 8 +- .../algorithms/transforms/double_hadamard.rs | 14 +- .../src/algorithms/transforms/null.rs | 2 +- .../algorithms/transforms/padding_hadamard.rs | 14 +- .../src/algorithms/transforms/test_utils.rs | 2 +- .../src/algorithms/transforms/utils.rs | 6 +- diskann-quantization/src/alloc/bump.rs | 4 +- diskann-quantization/src/alloc/mod.rs | 2 +- diskann-quantization/src/binary/quantizer.rs | 6 +- diskann-quantization/src/bits/distances.rs | 12 +- diskann-quantization/src/bits/packing.rs | 8 +- diskann-quantization/src/bits/slice.rs | 2 +- diskann-quantization/src/error.rs | 2 +- diskann-quantization/src/meta/slice.rs | 2 +- diskann-quantization/src/meta/vector.rs | 2 +- .../src/minmax/multi/max_sim.rs | 44 ++-- diskann-quantization/src/minmax/multi/meta.rs | 6 +- diskann-quantization/src/minmax/quantizer.rs | 26 +-- diskann-quantization/src/minmax/recompress.rs | 6 +- diskann-quantization/src/minmax/vectors.rs | 122 +++++------ diskann-quantization/src/num.rs | 6 +- .../src/product/tables/basic.rs | 4 +- .../src/product/tables/test.rs | 2 +- .../src/product/tables/transposed/pivots.rs | 24 +-- .../src/product/tables/transposed/table.rs | 4 +- diskann-quantization/src/product/train.rs | 6 +- diskann-quantization/src/random.rs | 2 +- diskann-quantization/src/scalar/quantizer.rs | 8 +- diskann-quantization/src/scalar/train.rs | 2 +- diskann-quantization/src/scalar/vectors.rs | 100 ++++----- diskann-quantization/src/spherical/iface.rs | 66 +++--- .../src/spherical/quantizer.rs | 96 ++++----- diskann-quantization/src/spherical/vectors.rs | 200 +++++++++--------- diskann-quantization/src/test_util.rs | 2 +- diskann-quantization/src/utils.rs | 4 +- 41 files changed, 425 insertions(+), 437 deletions(-) diff --git a/diskann-quantization/src/__codegen/x86_64.rs b/diskann-quantization/src/__codegen/x86_64.rs index 77735c830..2ada1be64 100644 --- a/diskann-quantization/src/__codegen/x86_64.rs +++ b/diskann-quantization/src/__codegen/x86_64.rs @@ -10,8 +10,8 @@ //! alternatives. use diskann_wide::{ - arch::x86_64::{V3, V4}, Architecture, + arch::x86_64::{V3, V4}, }; use crate::{ diff --git a/diskann-quantization/src/algorithms/hadamard.rs b/diskann-quantization/src/algorithms/hadamard.rs index b71ce949d..8871b93cc 100644 --- a/diskann-quantization/src/algorithms/hadamard.rs +++ b/diskann-quantization/src/algorithms/hadamard.rs @@ -359,9 +359,9 @@ where #[cfg(test)] mod tests { use rand::{ + SeedableRng, distr::{Distribution, StandardUniform}, rngs::StdRng, - SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/algorithms/heap.rs b/diskann-quantization/src/algorithms/heap.rs index 4f9ae4fef..c10540914 100644 --- a/diskann-quantization/src/algorithms/heap.rs +++ b/diskann-quantization/src/algorithms/heap.rs @@ -191,7 +191,7 @@ impl<'a, T: Ord + Copy> SliceHeap<'a, T> { mod tests { use std::collections::BinaryHeap; - use rand::{rngs::StdRng, Rng, SeedableRng}; + use rand::{Rng, SeedableRng, rngs::StdRng}; use super::*; @@ -350,15 +350,25 @@ mod tests { // Verify they have the same maximum assert_eq!( - slice_old_max, binary_old_max, + slice_old_max, + binary_old_max, "Iteration {}: Old maxima differ after updating {} to {}. SliceHeap old max: {:?}, BinaryHeap old max: {:?}", - iteration, slice_old_max.unwrap_or(0), new_value, slice_old_max, binary_old_max + iteration, + slice_old_max.unwrap_or(0), + new_value, + slice_old_max, + binary_old_max ); assert_eq!( - slice_new_max, binary_new_max, + slice_new_max, + binary_new_max, "Iteration {}: Maxima differ after updating {} to {}. SliceHeap max: {:?}, BinaryHeap max: {:?}", - iteration, slice_old_max.unwrap_or(0), new_value, slice_new_max, binary_new_max + iteration, + slice_old_max.unwrap_or(0), + new_value, + slice_new_max, + binary_new_max ); // Verify heap property is maintained in slice heap @@ -440,7 +450,11 @@ mod tests { assert!( slice[i] >= slice[left], "Heap property violated: parent {} at index {} < left child {} at index {}. Full heap: {:?}", - slice[i], i, slice[left], left, slice + slice[i], + i, + slice[left], + left, + slice ); } @@ -448,7 +462,11 @@ mod tests { assert!( slice[i] >= slice[right], "Heap property violated: parent {} at index {} < right child {} at index {}. Full heap: {:?}", - slice[i], i, slice[right], right, slice + slice[i], + i, + slice[right], + right, + slice ); } } diff --git a/diskann-quantization/src/algorithms/kmeans/common.rs b/diskann-quantization/src/algorithms/kmeans/common.rs index 74145b407..d563d2875 100644 --- a/diskann-quantization/src/algorithms/kmeans/common.rs +++ b/diskann-quantization/src/algorithms/kmeans/common.rs @@ -367,9 +367,9 @@ impl std::ops::Index<(usize, usize)> for BlockTranspose { mod tests { use diskann_utils::{lazy_format, views::Matrix}; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - Rng, SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs index 5c99d3d4e..2aa497c76 100644 --- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs +++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs @@ -5,7 +5,7 @@ use diskann_wide::{SIMDMask, SIMDMulAdd, SIMDPartialOrd, SIMDSelect, SIMDSumTree, SIMDVector}; -use super::common::{square_norm, BlockTranspose}; +use super::common::{BlockTranspose, square_norm}; use diskann_utils::{ strided::StridedView, views::{Matrix, MatrixView, MutMatrixView}, @@ -458,12 +458,12 @@ pub fn lloyds( #[cfg(test)] mod tests { use diskann_utils::{lazy_format, views::Matrix}; - use diskann_vector::{distance::SquaredL2, PureDistanceFunction}; + use diskann_vector::{PureDistanceFunction, distance::SquaredL2}; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, seq::{IndexedRandom, SliceRandom}, - Rng, SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/algorithms/kmeans/mod.rs b/diskann-quantization/src/algorithms/kmeans/mod.rs index 3362455cc..85e234d3d 100644 --- a/diskann-quantization/src/algorithms/kmeans/mod.rs +++ b/diskann-quantization/src/algorithms/kmeans/mod.rs @@ -4,8 +4,8 @@ */ pub(crate) mod common; -pub(crate) use common::square_norm; pub use common::BlockTranspose; +pub(crate) use common::square_norm; pub mod lloyds; pub mod plusplus; diff --git a/diskann-quantization/src/algorithms/kmeans/plusplus.rs b/diskann-quantization/src/algorithms/kmeans/plusplus.rs index e34945ad4..291cd47a0 100644 --- a/diskann-quantization/src/algorithms/kmeans/plusplus.rs +++ b/diskann-quantization/src/algorithms/kmeans/plusplus.rs @@ -11,12 +11,12 @@ use diskann_utils::{ }; use diskann_wide::{SIMDMulAdd, SIMDPartialOrd, SIMDSelect, SIMDVector}; use rand::{ - distr::{Distribution, Uniform}, RngCore, + distr::{Distribution, Uniform}, }; use thiserror::Error; -use super::common::{square_norm, BlockTranspose}; +use super::common::{BlockTranspose, square_norm}; /// An internal trait implemented for `BlockTranspose` used to accelerate /// @@ -520,8 +520,8 @@ pub fn kmeans_plusplus_into( #[cfg(test)] mod tests { use diskann_utils::{lazy_format, views::Matrix}; - use diskann_vector::{distance::SquaredL2, PureDistanceFunction}; - use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng}; + use diskann_vector::{PureDistanceFunction, distance::SquaredL2}; + use rand::{Rng, SeedableRng, rngs::StdRng, seq::SliceRandom}; use super::*; use crate::utils; diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs index 33ea3fbb8..a903d6c8b 100644 --- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs +++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs @@ -8,16 +8,16 @@ use std::num::NonZeroUsize; #[cfg(feature = "flatbuffers")] use flatbuffers::{FlatBufferBuilder, WIPOffset}; use rand::{ - distr::{Distribution, StandardUniform}, Rng, + distr::{Distribution, StandardUniform}, }; use thiserror::Error; #[cfg(feature = "flatbuffers")] use super::utils::{bool_to_sign, sign_to_bool}; use super::{ - utils::{check_dims, is_sign, subsample_indices, TransformFailed}, TargetDim, + utils::{TransformFailed, check_dims, is_sign, subsample_indices}, }; #[cfg(feature = "flatbuffers")] use crate::flatbuffers as fb; @@ -121,11 +121,7 @@ where // Generate random signs for the diagonal matrices let mut sample = |_: usize| { let sign: bool = StandardUniform {}.sample(rng); - if sign { - 0x8000_0000 - } else { - 0 - } + if sign { 0x8000_0000 } else { 0 } }; // Since implicit zero padding is used for this stage, we only create space for @@ -389,11 +385,11 @@ where #[cfg(test)] mod tests { use diskann_utils::lazy_format; - use rand::{rngs::StdRng, SeedableRng}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::{ - algorithms::transforms::{test_utils, Transform, TransformKind}, + algorithms::transforms::{Transform, TransformKind, test_utils}, alloc::GlobalAllocator, }; diff --git a/diskann-quantization/src/algorithms/transforms/null.rs b/diskann-quantization/src/algorithms/transforms/null.rs index ff20a9fe3..9e66986f6 100644 --- a/diskann-quantization/src/algorithms/transforms/null.rs +++ b/diskann-quantization/src/algorithms/transforms/null.rs @@ -10,7 +10,7 @@ use flatbuffers::{FlatBufferBuilder, WIPOffset}; #[cfg(feature = "flatbuffers")] use thiserror::Error; -use super::utils::{check_dims, TransformFailed}; +use super::utils::{TransformFailed, check_dims}; #[cfg(feature = "flatbuffers")] use crate::flatbuffers as fb; diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs index ed6d3b27f..637053f9f 100644 --- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs +++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs @@ -8,16 +8,16 @@ use std::num::NonZeroUsize; #[cfg(feature = "flatbuffers")] use flatbuffers::{FlatBufferBuilder, WIPOffset}; use rand::{ - distr::{Distribution, StandardUniform}, Rng, + distr::{Distribution, StandardUniform}, }; use thiserror::Error; #[cfg(feature = "flatbuffers")] use super::utils::{bool_to_sign, sign_to_bool}; use super::{ - utils::{check_dims, is_sign, subsample_indices, TransformFailed}, TargetDim, + utils::{TransformFailed, check_dims, is_sign, subsample_indices}, }; #[cfg(feature = "flatbuffers")] use crate::flatbuffers as fb; @@ -103,11 +103,7 @@ where let signs = Poly::from_iter( (0..dim.get()).map(|_| { let sign: bool = StandardUniform {}.sample(rng); - if sign { - 0x8000_0000 - } else { - 0 - } + if sign { 0x8000_0000 } else { 0 } }), allocator.clone(), )?; @@ -367,11 +363,11 @@ where #[cfg(test)] mod tests { use diskann_utils::lazy_format; - use rand::{rngs::StdRng, SeedableRng}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::{ - algorithms::transforms::{test_utils, Transform, TransformKind}, + algorithms::transforms::{Transform, TransformKind, test_utils}, alloc::GlobalAllocator, }; diff --git a/diskann-quantization/src/algorithms/transforms/test_utils.rs b/diskann-quantization/src/algorithms/transforms/test_utils.rs index c853cc904..ecf1b6080 100644 --- a/diskann-quantization/src/algorithms/transforms/test_utils.rs +++ b/diskann-quantization/src/algorithms/transforms/test_utils.rs @@ -4,9 +4,9 @@ */ use diskann_vector::{ + Norm, PureDistanceFunction, distance::{InnerProduct, SquaredL2}, norm::FastL2NormSquared, - Norm, PureDistanceFunction, }; use rand::{distr::Distribution, rngs::StdRng}; use rand_distr::StandardNormal; diff --git a/diskann-quantization/src/algorithms/transforms/utils.rs b/diskann-quantization/src/algorithms/transforms/utils.rs index ff19ad3f7..154c0ca32 100644 --- a/diskann-quantization/src/algorithms/transforms/utils.rs +++ b/diskann-quantization/src/algorithms/transforms/utils.rs @@ -51,11 +51,7 @@ pub(super) fn sign_to_bool(x: u32) -> bool { #[cfg(feature = "flatbuffers")] pub(super) fn bool_to_sign(x: bool) -> u32 { - if x { - 0x8000_0000 - } else { - 0 - } + if x { 0x8000_0000 } else { 0 } } pub(super) fn subsample_indices( diff --git a/diskann-quantization/src/alloc/bump.rs b/diskann-quantization/src/alloc/bump.rs index a223bbd23..c6c0ab205 100644 --- a/diskann-quantization/src/alloc/bump.rs +++ b/diskann-quantization/src/alloc/bump.rs @@ -7,8 +7,8 @@ use std::{ cell::UnsafeCell, ptr::NonNull, sync::{ - atomic::{AtomicUsize, Ordering}, Arc, + atomic::{AtomicUsize, Ordering}, }, }; @@ -172,9 +172,9 @@ unsafe impl AllocatorCore for BumpAllocator { #[cfg(test)] mod tests { use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/alloc/mod.rs b/diskann-quantization/src/alloc/mod.rs index 5f0857fbe..da58f8b77 100644 --- a/diskann-quantization/src/alloc/mod.rs +++ b/diskann-quantization/src/alloc/mod.rs @@ -12,7 +12,7 @@ mod traits; pub use aligned::{AlignedAllocator, NotPowerOfTwo}; pub use bump::BumpAllocator; -pub use poly::{poly, CompoundError, Poly, TrustedIter}; +pub use poly::{CompoundError, Poly, TrustedIter, poly}; pub use traits::{Allocator, AllocatorCore, AllocatorError}; /// A handle to Rust's global allocator. This type does not support allocations of size 0. diff --git a/diskann-quantization/src/binary/quantizer.rs b/diskann-quantization/src/binary/quantizer.rs index 675234990..566c0f282 100644 --- a/diskann-quantization/src/binary/quantizer.rs +++ b/diskann-quantization/src/binary/quantizer.rs @@ -4,9 +4,9 @@ */ use crate::{ + AsFunctor, CompressInto, bits::{Binary, MutBitSlice, Representation}, distances::Hamming, - AsFunctor, CompressInto, }; /// A simple, training-free binary quantizer. @@ -129,8 +129,8 @@ impl AsFunctor for BinaryQuantizer { #[cfg(test)] mod tests { - use diskann_utils::{views::Matrix, ReborrowMut}; - use rand::{rngs::StdRng, seq::SliceRandom, SeedableRng}; + use diskann_utils::{ReborrowMut, views::Matrix}; + use rand::{SeedableRng, rngs::StdRng, seq::SliceRandom}; use super::*; use crate::bits::{Binary, BoxedBitSlice}; diff --git a/diskann-quantization/src/bits/distances.rs b/diskann-quantization/src/bits/distances.rs index 00ece2883..b5d5d5766 100644 --- a/diskann-quantization/src/bits/distances.rs +++ b/diskann-quantization/src/bits/distances.rs @@ -104,14 +104,14 @@ //! | `BSlice` | `BSlice` | `MV` | Optimized | Optimized | Uses V3 | use diskann_vector::PureDistanceFunction; -use diskann_wide::{arch::Target2, Architecture, ARCH}; +use diskann_wide::{ARCH, Architecture, arch::Target2}; #[cfg(target_arch = "x86_64")] use diskann_wide::{ SIMDCast, SIMDDotProduct, SIMDMulAdd, SIMDReinterpret, SIMDSumTree, SIMDVector, }; use super::{Binary, BitSlice, BitTranspose, Dense, Representation, Unsigned}; -use crate::distances::{check_lengths, Hamming, InnerProduct, MathematicalResult, SquaredL2, MV}; +use crate::distances::{Hamming, InnerProduct, MV, MathematicalResult, SquaredL2, check_lengths}; // Convenience alias. type USlice<'a, const N: usize, Perm = Dense> = BitSlice<'a, N, Unsigned, Perm>; @@ -1965,10 +1965,10 @@ mod tests { use diskann_utils::Reborrow; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, seq::IndexedRandom, - Rng, SeedableRng, }; use super::*; @@ -2176,11 +2176,7 @@ mod tests { } fn get(&self) -> usize { - if cfg!(miri) { - self.miri - } else { - self.standard - } + if cfg!(miri) { self.miri } else { self.standard } } } diff --git a/diskann-quantization/src/bits/packing.rs b/diskann-quantization/src/bits/packing.rs index d17e0fb2f..234131a19 100644 --- a/diskann-quantization/src/bits/packing.rs +++ b/diskann-quantization/src/bits/packing.rs @@ -160,13 +160,9 @@ mod tests { // Make sure the encoded portion matches. let expected: u8 = ((encoded >> bitstart) & mask).try_into().unwrap(); assert_eq!( - expected, - value, + expected, value, "failed to propertly encode for NBITS = {}, before = {}, value = {}, bitstart = {}", - NBITS, - before, - value, - bitstart, + NBITS, before, value, bitstart, ); // Make sure decoding yields the correct value. diff --git a/diskann-quantization/src/bits/slice.rs b/diskann-quantization/src/bits/slice.rs index 3f28c8e72..e713d6c48 100644 --- a/diskann-quantization/src/bits/slice.rs +++ b/diskann-quantization/src/bits/slice.rs @@ -938,10 +938,10 @@ where #[cfg(test)] mod tests { use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, seq::{IndexedRandom, SliceRandom}, - Rng, SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/error.rs b/diskann-quantization/src/error.rs index 3178d66d3..9679e18c7 100644 --- a/diskann-quantization/src/error.rs +++ b/diskann-quantization/src/error.rs @@ -243,8 +243,8 @@ unsafe fn error_drop(object: *mut MaybeUninit) { #[cfg(test)] mod tests { use std::sync::{ - atomic::{AtomicUsize, Ordering}, Arc, Mutex, + atomic::{AtomicUsize, Ordering}, }; use thiserror::Error; diff --git a/diskann-quantization/src/meta/slice.rs b/diskann-quantization/src/meta/slice.rs index 6bdc3fc27..b2a14e552 100644 --- a/diskann-quantization/src/meta/slice.rs +++ b/diskann-quantization/src/meta/slice.rs @@ -426,9 +426,9 @@ mod tests { use std::fmt::Debug; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/meta/vector.rs b/diskann-quantization/src/meta/vector.rs index e353a255e..142e95d7d 100644 --- a/diskann-quantization/src/meta/vector.rs +++ b/diskann-quantization/src/meta/vector.rs @@ -546,9 +546,9 @@ where mod tests { use diskann_utils::{Reborrow, ReborrowMut}; use rand::{ + Rng, SeedableRng, distr::{Distribution, StandardUniform, Uniform}, rngs::StdRng, - Rng, SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/minmax/multi/max_sim.rs b/diskann-quantization/src/minmax/multi/max_sim.rs index 0cb2a4f60..8ccf4159d 100644 --- a/diskann-quantization/src/minmax/multi/max_sim.rs +++ b/diskann-quantization/src/minmax/multi/max_sim.rs @@ -42,10 +42,10 @@ impl MinMaxKernel { where Unsigned: Representation, distances::InnerProduct: for<'x, 'y> PureDistanceFunction< - crate::bits::BitSlice<'x, NBITS, Unsigned>, - crate::bits::BitSlice<'y, NBITS, Unsigned>, - distances::MathematicalResult, - >, + crate::bits::BitSlice<'x, NBITS, Unsigned>, + crate::bits::BitSlice<'y, NBITS, Unsigned>, + distances::MathematicalResult, + >, F: FnMut(usize, f32), { for (i, q_ref) in query.rows().enumerate() { @@ -80,10 +80,10 @@ impl where Unsigned: Representation, distances::InnerProduct: for<'x, 'y> PureDistanceFunction< - crate::bits::BitSlice<'x, NBITS, Unsigned>, - crate::bits::BitSlice<'y, NBITS, Unsigned>, - distances::MathematicalResult, - >, + crate::bits::BitSlice<'x, NBITS, Unsigned>, + crate::bits::BitSlice<'y, NBITS, Unsigned>, + distances::MathematicalResult, + >, { #[inline(always)] fn evaluate( @@ -116,10 +116,10 @@ impl where Unsigned: Representation, distances::InnerProduct: for<'a, 'b> PureDistanceFunction< - crate::bits::BitSlice<'a, NBITS, Unsigned>, - crate::bits::BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + crate::bits::BitSlice<'a, NBITS, Unsigned>, + crate::bits::BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { #[inline(always)] fn evaluate( @@ -139,13 +139,13 @@ where #[cfg(test)] mod tests { use super::*; - use crate::algorithms::transforms::NullTransform; + use crate::CompressInto; use crate::algorithms::Transform; + use crate::algorithms::transforms::NullTransform; use crate::bits::{Representation, Unsigned}; use crate::minmax::{Data, MinMaxQuantizer}; use crate::multi_vector::{Defaulted, Mat, Standard}; use crate::num::Positive; - use crate::CompressInto; use diskann_utils::ReborrowMut; use std::num::NonZeroUsize; @@ -214,10 +214,10 @@ mod tests { where Unsigned: Representation, distances::InnerProduct: for<'x, 'y> PureDistanceFunction< - crate::bits::BitSlice<'x, NBITS, Unsigned>, - crate::bits::BitSlice<'y, NBITS, Unsigned>, - distances::MathematicalResult, - >, + crate::bits::BitSlice<'x, NBITS, Unsigned>, + crate::bits::BitSlice<'y, NBITS, Unsigned>, + distances::MathematicalResult, + >, { doc.rows() .map(|d| { @@ -235,10 +235,10 @@ mod tests { where Unsigned: Representation, distances::InnerProduct: for<'x, 'y> PureDistanceFunction< - crate::bits::BitSlice<'x, NBITS, Unsigned>, - crate::bits::BitSlice<'y, NBITS, Unsigned>, - distances::MathematicalResult, - >, + crate::bits::BitSlice<'x, NBITS, Unsigned>, + crate::bits::BitSlice<'y, NBITS, Unsigned>, + distances::MathematicalResult, + >, { for &(nq, nd, dim) in TEST_CASES { let quantizer = make_quantizer(dim); diff --git a/diskann-quantization/src/minmax/multi/meta.rs b/diskann-quantization/src/minmax/multi/meta.rs index 5293de504..4b4d940a6 100644 --- a/diskann-quantization/src/minmax/multi/meta.rs +++ b/diskann-quantization/src/minmax/multi/meta.rs @@ -5,8 +5,9 @@ use std::ptr::NonNull; -use super::super::vectors::DataMutRef; use super::super::MinMaxQuantizer; +use super::super::vectors::DataMutRef; +use crate::CompressInto; use crate::bits::{Representation, Unsigned}; use crate::minmax::{self, Data}; use crate::multi_vector::matrix::{ @@ -15,7 +16,6 @@ use crate::multi_vector::matrix::{ use crate::multi_vector::{LayoutError, Mat, MatMut, MatRef, Standard}; use crate::scalar::InputContainsNaN; use crate::utils; -use crate::CompressInto; //////////////// // MinMaxMeta // @@ -297,8 +297,8 @@ where #[cfg(test)] mod tests { use super::*; - use crate::algorithms::transforms::NullTransform; use crate::algorithms::Transform; + use crate::algorithms::transforms::NullTransform; use crate::minmax::vectors::DataRef; use crate::num::Positive; use diskann_utils::{Reborrow, ReborrowMut}; diff --git a/diskann-quantization/src/minmax/quantizer.rs b/diskann-quantization/src/minmax/quantizer.rs index 13d624b0a..14966d2b3 100644 --- a/diskann-quantization/src/minmax/quantizer.rs +++ b/diskann-quantization/src/minmax/quantizer.rs @@ -8,13 +8,13 @@ use core::f32; use diskann_utils::views::MutDenseData; use crate::{ + AsFunctor, CompressInto, algorithms::Transform, alloc::{GlobalAllocator, ScopedAllocator}, bits::{Representation, Unsigned}, - minmax::{vectors::FullQueryMeta, FullQuery, MinMaxCosine, MinMaxCosineNormalized}, + minmax::{FullQuery, MinMaxCosine, MinMaxCosineNormalized, vectors::FullQueryMeta}, num::Positive, - scalar::{bit_scale, InputContainsNaN}, - AsFunctor, CompressInto, + scalar::{InputContainsNaN, bit_scale}, }; /// Recall that from the module-level documentation, MinMaxQuantizer, quantizes X @@ -341,11 +341,11 @@ mod minmax_quantizer_tests { use std::num::NonZeroUsize; use diskann_utils::{Reborrow, ReborrowMut}; - use diskann_vector::{distance::SquaredL2, PureDistanceFunction}; + use diskann_vector::{PureDistanceFunction, distance::SquaredL2}; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use super::*; @@ -398,14 +398,14 @@ mod minmax_quantizer_tests { let reconstruction_error: f32 = SquaredL2::evaluate(&*vector, &*reconstructed); let norm = vector.iter().map(|x| x * x).sum::(); assert!( - (reconstruction_error / norm) <= relative_err, - "Expected vector : {:?} to be reconstructed within error {} but instead got : {:?}, with error {} for dim : {}", - &vector, - relative_err, - &reconstructed, - reconstruction_error / norm, - dim, - ); + (reconstruction_error / norm) <= relative_err, + "Expected vector : {:?} to be reconstructed within error {} but instead got : {:?}, with error {} for dim : {}", + &vector, + relative_err, + &reconstructed, + reconstruction_error / norm, + dim, + ); assert!((loss.as_f32() - reconstruction_error) <= 1e-4); diff --git a/diskann-quantization/src/minmax/recompress.rs b/diskann-quantization/src/minmax/recompress.rs index c5d89a1b6..b38ef3fb1 100644 --- a/diskann-quantization/src/minmax/recompress.rs +++ b/diskann-quantization/src/minmax/recompress.rs @@ -4,9 +4,9 @@ */ use super::vectors::{DataMutRef, DataRef, MinMaxCompensation}; +use crate::CompressInto; use crate::bits::{Representation, Unsigned}; use crate::scalar::bit_scale; -use crate::CompressInto; use thiserror::Error; /// Recompression utilities for MinMax quantized vectors. @@ -193,14 +193,14 @@ mod recompress_tests { use diskann_utils::{Reborrow, ReborrowMut}; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use super::*; use crate::{ - algorithms::{transforms::NullTransform, Transform}, + algorithms::{Transform, transforms::NullTransform}, minmax::quantizer::MinMaxQuantizer, minmax::vectors::Data, num::Positive, diff --git a/diskann-quantization/src/minmax/vectors.rs b/diskann-quantization/src/minmax/vectors.rs index b8aac8a1c..4c832b76d 100644 --- a/diskann-quantization/src/minmax/vectors.rs +++ b/diskann-quantization/src/minmax/vectors.rs @@ -237,10 +237,10 @@ fn kernel( where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, F: Fn(f32, &MinMaxCompensation, &MinMaxCompensation) -> f32, { let raw_product = InnerProduct::evaluate(x.vector(), y.vector())?; @@ -262,10 +262,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate( x: DataRef<'_, NBITS>, @@ -281,10 +281,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: DataRef<'_, NBITS>, y: DataRef<'_, NBITS>) -> distances::Result { let v: distances::MathematicalResult = Self::evaluate(x, y); @@ -298,10 +298,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - &'a [f32], - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + &'a [f32], + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: &FullQuery, y: DataRef<'_, NBITS>) -> distances::MathematicalResult { let raw_product: f32 = InnerProduct::evaluate(&x.data, y.vector())?.into_inner(); @@ -316,10 +316,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - &'a [f32], - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + &'a [f32], + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: &FullQuery, y: DataRef<'_, NBITS>) -> distances::Result { let v: distances::MathematicalResult = Self::evaluate(x, y); @@ -335,10 +335,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate( x: DataRef<'_, NBITS>, @@ -356,10 +356,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: DataRef<'_, NBITS>, y: DataRef<'_, NBITS>) -> distances::Result { let v: distances::MathematicalResult = Self::evaluate(x, y); @@ -373,10 +373,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - &'a [f32], - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + &'a [f32], + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: &FullQuery, y: DataRef<'_, NBITS>) -> distances::MathematicalResult { let raw_product = InnerProduct::evaluate(&x.data, y.vector())?.into_inner(); @@ -394,10 +394,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - &'a [f32], - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + &'a [f32], + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate(x: &FullQuery, y: DataRef<'_, NBITS>) -> distances::Result { let v: distances::MathematicalResult = Self::evaluate(x, y); @@ -417,10 +417,10 @@ impl where Unsigned: Representation, MinMaxIP: for<'a, 'b> PureDistanceFunction< - DataRef<'a, NBITS>, - DataRef<'b, NBITS>, - distances::MathematicalResult, - >, + DataRef<'a, NBITS>, + DataRef<'b, NBITS>, + distances::MathematicalResult, + >, { // 1 - / (|X| * |Y|) fn evaluate(x: DataRef<'_, NBITS>, y: DataRef<'_, NBITS>) -> distances::Result { @@ -435,10 +435,10 @@ impl where Unsigned: Representation, MinMaxIP: for<'a, 'b> PureDistanceFunction< - &'a FullQuery, - DataRef<'b, NBITS>, - distances::MathematicalResult, - >, + &'a FullQuery, + DataRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate(x: &'_ FullQuery, y: DataRef<'_, NBITS>) -> distances::Result { let ip: MathematicalValue = MinMaxIP::evaluate(x, y)?; @@ -456,10 +456,10 @@ impl where Unsigned: Representation, MinMaxIP: for<'a, 'b> PureDistanceFunction< - DataRef<'a, NBITS>, - DataRef<'b, NBITS>, - distances::MathematicalResult, - >, + DataRef<'a, NBITS>, + DataRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate(x: DataRef<'_, NBITS>, y: DataRef<'_, NBITS>) -> distances::Result { let ip: MathematicalValue = MinMaxIP::evaluate(x, y)?; @@ -473,10 +473,10 @@ impl where Unsigned: Representation, MinMaxIP: for<'a, 'b> PureDistanceFunction< - &'a FullQuery, - DataRef<'b, NBITS>, - distances::MathematicalResult, - >, + &'a FullQuery, + DataRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate(x: &'_ FullQuery, y: DataRef<'_, NBITS>) -> distances::Result { let ip: MathematicalValue = MinMaxIP::evaluate(x, y)?; @@ -492,9 +492,9 @@ where mod minmax_vector_tests { use diskann_utils::Reborrow; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - Rng, SeedableRng, }; use super::*; @@ -504,15 +504,15 @@ mod minmax_vector_tests { where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, InnerProduct: for<'a, 'b> PureDistanceFunction< - &'a [f32], - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + &'a [f32], + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, R: Rng, { assert!(dim <= bit_scale::() as usize); diff --git a/diskann-quantization/src/num.rs b/diskann-quantization/src/num.rs index 24e3cff0d..17a632ac1 100644 --- a/diskann-quantization/src/num.rs +++ b/diskann-quantization/src/num.rs @@ -141,11 +141,7 @@ impl PowerOfTwo { /// method in the standard library. pub const fn arg_align_offset(self, lhs: usize) -> usize { let m = self.arg_mod(lhs); - if m == 0 { - 0 - } else { - self.raw() - m - } + if m == 0 { 0 } else { self.raw() - m } } /// Calculate the smallest value greater than or equal to `lhs` that is a multiple of diff --git a/diskann-quantization/src/product/tables/basic.rs b/diskann-quantization/src/product/tables/basic.rs index c7ecd5559..9469fa58d 100644 --- a/diskann-quantization/src/product/tables/basic.rs +++ b/diskann-quantization/src/product/tables/basic.rs @@ -6,7 +6,7 @@ use crate::traits::CompressInto; use crate::views::{ChunkOffsetsBase, ChunkOffsetsView}; use diskann_utils::views::{DenseData, MatrixBase, MatrixView}; -use diskann_vector::{distance::SquaredL2, PureDistanceFunction}; +use diskann_vector::{PureDistanceFunction, distance::SquaredL2}; use thiserror::Error; /// A basic PQ table that stores the pivot table in the following dense, row-major form: @@ -202,8 +202,8 @@ where mod tests { use diskann_utils::{lazy_format, views}; use rand::{ - distr::{Distribution, StandardUniform}, SeedableRng, + distr::{Distribution, StandardUniform}, }; use super::*; diff --git a/diskann-quantization/src/product/tables/test.rs b/diskann-quantization/src/product/tables/test.rs index 2c823c1eb..9eb1a74a5 100644 --- a/diskann-quantization/src/product/tables/test.rs +++ b/diskann-quantization/src/product/tables/test.rs @@ -6,9 +6,9 @@ // A collection of test helpers to ensure uniformity across tables. use diskann_utils::views::{Matrix, MatrixView, MutMatrixView}; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, seq::IndexedRandom, - Rng, SeedableRng, }; use crate::traits::CompressInto; diff --git a/diskann-quantization/src/product/tables/transposed/pivots.rs b/diskann-quantization/src/product/tables/transposed/pivots.rs index a6d96c256..d582d7e40 100644 --- a/diskann-quantization/src/product/tables/transposed/pivots.rs +++ b/diskann-quantization/src/product/tables/transposed/pivots.rs @@ -1061,11 +1061,11 @@ where #[cfg(test)] mod tests { use diskann_utils::{lazy_format, views}; - use diskann_vector::{distance, PureDistanceFunction}; + use diskann_vector::{PureDistanceFunction, distance}; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use super::*; @@ -1245,11 +1245,7 @@ mod tests { // Check that we correctly handle invalid configurations. let maybe_broadcast = |k, v: f32| { - if k == j { - vec![v; dim] - } else { - query.to_vec() - } + if k == j { vec![v; dim] } else { query.to_vec() } }; // Don't loop over the pathological values because that makes the test run way @@ -1452,16 +1448,18 @@ mod tests { // No dimensions let chunk = Chunk::new(strided::StridedView::try_from(&[], 3, 0, 0).unwrap()); let err = chunk.unwrap_err(); - assert!(err - .to_string() - .contains("cannot construct a Chunk from a source with zero dimensions")); + assert!( + err.to_string() + .contains("cannot construct a Chunk from a source with zero dimensions") + ); // No length let chunk = Chunk::new(strided::StridedView::try_from(&[], 0, 10, 10).unwrap()); let err = chunk.unwrap_err(); - assert!(err - .to_string() - .contains("cannot construct a Chunk from a source with zero length")); + assert!( + err.to_string() + .contains("cannot construct a Chunk from a source with zero length") + ); } // Make sure `find_closest` panics for an incorrect dimension. diff --git a/diskann-quantization/src/product/tables/transposed/table.rs b/diskann-quantization/src/product/tables/transposed/table.rs index 2db1ac8a7..a3eec0048 100644 --- a/diskann-quantization/src/product/tables/transposed/table.rs +++ b/diskann-quantization/src/product/tables/transposed/table.rs @@ -503,11 +503,11 @@ where mod test_compression { use std::collections::HashSet; - use diskann_vector::{distance, PureDistanceFunction}; + use diskann_vector::{PureDistanceFunction, distance}; use rand::{ + Rng, SeedableRng, distr::{Distribution, StandardUniform, Uniform}, rngs::StdRng, - Rng, SeedableRng, }; use super::*; diff --git a/diskann-quantization/src/product/train.rs b/diskann-quantization/src/product/train.rs index f3b2efcf9..ee5328651 100644 --- a/diskann-quantization/src/product/train.rs +++ b/diskann-quantization/src/product/train.rs @@ -12,13 +12,13 @@ use rayon::iter::{IntoParallelIterator, ParallelIterator}; use thiserror::Error; use crate::{ + Parallelism, algorithms::kmeans::{ self, - common::{square_norm, BlockTranspose}, + common::{BlockTranspose, square_norm}, }, cancel::Cancelation, random::{BoxedRngBuilder, RngBuilder}, - Parallelism, }; pub struct LightPQTrainingParameters { @@ -270,10 +270,10 @@ mod tests { use std::sync::atomic::{AtomicUsize, Ordering}; use rand::{ + Rng, SeedableRng, distr::{Distribution, StandardUniform, Uniform}, rngs::StdRng, seq::SliceRandom, - Rng, SeedableRng, }; use diskann_utils::lazy_format; diff --git a/diskann-quantization/src/random.rs b/diskann-quantization/src/random.rs index db9eec185..0c0d6d0ee 100644 --- a/diskann-quantization/src/random.rs +++ b/diskann-quantization/src/random.rs @@ -5,7 +5,7 @@ use std::hash::{Hash, Hasher}; -use rand::{rngs::StdRng, Rng, RngCore, SeedableRng}; +use rand::{Rng, RngCore, SeedableRng, rngs::StdRng}; /// Creation of random number generator in potentially parallelized applications. pub trait RngBuilder { diff --git a/diskann-quantization/src/scalar/quantizer.rs b/diskann-quantization/src/scalar/quantizer.rs index d6cbfe614..6c86fc228 100644 --- a/diskann-quantization/src/scalar/quantizer.rs +++ b/diskann-quantization/src/scalar/quantizer.rs @@ -14,8 +14,8 @@ use super::{ }, }; use crate::{ - bits::{MutBitSlice, PermutationStrategy, Representation, Unsigned}, AsFunctor, CompressInto, + bits::{MutBitSlice, PermutationStrategy, Representation, Unsigned}, }; /// A central parameter collection for a scalar quantization schema. @@ -459,20 +459,20 @@ pub enum SQComparisonError { mod tests { use std::collections::HashSet; - use diskann_utils::{views, ReborrowMut}; + use diskann_utils::{ReborrowMut, views}; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, seq::SliceRandom, - SeedableRng, }; use rand_distr::Normal; use super::*; use crate::{ bits::BoxedBitSlice, - scalar::{inverse_bit_scale, CompensatedVector}, + scalar::{CompensatedVector, inverse_bit_scale}, }; /// Test Rescale. diff --git a/diskann-quantization/src/scalar/train.rs b/diskann-quantization/src/scalar/train.rs index 89415efef..becf99fd5 100644 --- a/diskann-quantization/src/scalar/train.rs +++ b/diskann-quantization/src/scalar/train.rs @@ -106,7 +106,7 @@ impl Default for ScalarQuantizationParameters { #[cfg(test)] mod tests { - use rand::{rngs::StdRng, SeedableRng}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::test_util::create_test_problem; diff --git a/diskann-quantization/src/scalar/vectors.rs b/diskann-quantization/src/scalar/vectors.rs index 3f46c23fe..36080c9bf 100644 --- a/diskann-quantization/src/scalar/vectors.rs +++ b/diskann-quantization/src/scalar/vectors.rs @@ -8,7 +8,7 @@ use diskann_vector::{DistanceFunction, PureDistanceFunction}; use super::inverse_bit_scale; use crate::{ bits::{BitSlice, Dense, Representation, Unsigned}, - distances::{self, check_lengths, InnerProduct, SquaredL2, MV}, + distances::{self, InnerProduct, MV, SquaredL2, check_lengths}, meta, }; @@ -212,10 +212,10 @@ impl where Unsigned: Representation, SquaredL2: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -257,10 +257,10 @@ impl where Unsigned: Representation, Self: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -316,10 +316,10 @@ impl where Unsigned: Representation, InnerProduct: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -360,10 +360,10 @@ impl where Unsigned: Representation, Self: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -416,10 +416,10 @@ impl where Unsigned: Representation, SquaredL2: for<'a, 'b> PureDistanceFunction< - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'b, NBITS, Unsigned>, - distances::MathematicalResult, - >, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'b, NBITS, Unsigned>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -447,10 +447,10 @@ impl where Unsigned: Representation, Self: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, { fn evaluate_similarity( &self, @@ -470,9 +470,9 @@ where mod tests { use diskann_utils::{Reborrow, ReborrowMut}; use rand::{ + Rng, SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - Rng, SeedableRng, }; use super::*; @@ -518,35 +518,35 @@ mod tests { Unsigned: Representation, R: Rng, CompensatedSquaredL2: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, CompensatedSquaredL2: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::Result, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::Result, + >, CompensatedIP: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, CompensatedIP: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::Result, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::Result, + >, CompensatedCosineNormalized: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::MathematicalResult, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::MathematicalResult, + >, CompensatedCosineNormalized: for<'a, 'b> DistanceFunction< - CompensatedVectorRef<'a, NBITS>, - CompensatedVectorRef<'b, NBITS>, - distances::Result, - >, + CompensatedVectorRef<'a, NBITS>, + CompensatedVectorRef<'b, NBITS>, + distances::Result, + >, { // The distributions we use for `a` and `B` are taken from integer distributions, // which we then convert to `f32` and divide by a power of 2. diff --git a/diskann-quantization/src/spherical/iface.rs b/diskann-quantization/src/spherical/iface.rs index 0d64d7d07..6b9e9c349 100644 --- a/diskann-quantization/src/spherical/iface.rs +++ b/diskann-quantization/src/spherical/iface.rs @@ -138,8 +138,8 @@ use std::marker::PhantomData; use diskann_utils::{Reborrow, ReborrowMut}; use diskann_vector::{DistanceFunction, PreprocessedDistanceFunction}; use diskann_wide::{ - arch::{Scalar, Target1, Target2}, Architecture, + arch::{Scalar, Target1, Target2}, }; #[cfg(feature = "flatbuffers")] use flatbuffers::FlatBufferBuilder; @@ -149,13 +149,12 @@ use thiserror::Error; use diskann_wide::arch::x86_64::{V3, V4}; use super::{ - quantizer, CompensatedCosine, CompensatedIP, CompensatedSquaredL2, Data, DataMut, DataRef, - FullQuery, FullQueryMut, FullQueryRef, Query, QueryMut, QueryRef, SphericalQuantizer, - SupportedMetric, + CompensatedCosine, CompensatedIP, CompensatedSquaredL2, Data, DataMut, DataRef, FullQuery, + FullQueryMut, FullQueryRef, Query, QueryMut, QueryRef, SphericalQuantizer, SupportedMetric, + quantizer, }; -#[cfg(feature = "flatbuffers")] -use crate::{alloc::CompoundError, flatbuffers as fb}; use crate::{ + AsFunctor, CompressIntoWith, alloc::{ Allocator, AllocatorCore, AllocatorError, GlobalAllocator, Poly, ScopedAllocator, TryClone, }, @@ -164,8 +163,10 @@ use crate::{ error::InlineError, meta, num::PowerOfTwo, - poly, AsFunctor, CompressIntoWith, + poly, }; +#[cfg(feature = "flatbuffers")] +use crate::{alloc::CompoundError, flatbuffers as fb}; // A convenience definition to shorten the extensive where-clauses present in this file. type Rf32 = distances::Result; @@ -1096,12 +1097,7 @@ impl Impl { scratch: ScopedAllocator<'a>, ) -> Result<(), QueryCompressionError> where - SphericalQuantizer: CompressIntoWith< - &'a [f32], - T, - ScopedAllocator<'a>, - Error = quantizer::CompressionError, - >, + SphericalQuantizer: CompressIntoWith<&'a [f32], T, ScopedAllocator<'a>, Error = quantizer::CompressionError>, { self.quantizer .compress_into_with(query, storage, scratch) @@ -1127,11 +1123,11 @@ impl Impl { + 'static, B: AllocatorCore, SphericalQuantizer: for<'a> CompressIntoWith< - &'a [f32], - >::Target, - ScopedAllocator<'a>, - Error = quantizer::CompressionError, - >, + &'a [f32], + >::Target, + ScopedAllocator<'a>, + Error = quantizer::CompressionError, + >, SphericalQuantizer: Dispatchable, { if let Err(err) = self @@ -2020,11 +2016,11 @@ where #[cfg(test)] mod tests { use diskann_utils::views::{Matrix, MatrixView}; - use rand::{rngs::StdRng, SeedableRng}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::{ - algorithms::{transforms::TargetDim, TransformKind}, + algorithms::{TransformKind, transforms::TargetDim}, alloc::{AlignedAllocator, GlobalAllocator, Poly}, num::PowerOfTwo, spherical::PreScale, @@ -2276,31 +2272,35 @@ mod tests { // Errors let too_small = &dataset.row(0)[..dataset.ncols() - 1]; - assert!(plan - .fused_query_computer(too_small, layout, false, GlobalAllocator, scoped_global) - .is_err()); + assert!( + plan.fused_query_computer(too_small, layout, false, GlobalAllocator, scoped_global) + .is_err() + ); } // Errors { let mut too_small = vec![u8::default(); plan.bytes() - 1]; - assert!(plan - .compress(dataset.row(0), OpaqueMut(&mut too_small), scoped_global) - .is_err()); + assert!( + plan.compress(dataset.row(0), OpaqueMut(&mut too_small), scoped_global) + .is_err() + ); let mut too_big = vec![u8::default(); plan.bytes() + 1]; - assert!(plan - .compress(dataset.row(0), OpaqueMut(&mut too_big), scoped_global) - .is_err()); + assert!( + plan.compress(dataset.row(0), OpaqueMut(&mut too_big), scoped_global) + .is_err() + ); let mut just_right = vec![u8::default(); plan.bytes()]; - assert!(plan - .compress( + assert!( + plan.compress( &dataset.row(0)[..dataset.ncols() - 1], OpaqueMut(&mut just_right), scoped_global ) - .is_err()); + .is_err() + ); } } @@ -2536,8 +2536,8 @@ mod tests { #[cfg(feature = "flatbuffers")] mod serialization { use std::sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }; use super::*; diff --git a/diskann-quantization/src/spherical/quantizer.rs b/diskann-quantization/src/spherical/quantizer.rs index c53efc7b7..788fe8a35 100644 --- a/diskann-quantization/src/spherical/quantizer.rs +++ b/diskann-quantization/src/spherical/quantizer.rs @@ -5,9 +5,9 @@ use std::num::NonZeroUsize; -use diskann_utils::{views::MatrixView, ReborrowMut}; +use diskann_utils::{ReborrowMut, views::MatrixView}; use diskann_vector::{ - distance::InnerProduct, norm::FastL2Norm, MathematicalValue, Norm, PureDistanceFunction, + MathematicalValue, Norm, PureDistanceFunction, distance::InnerProduct, norm::FastL2Norm, }; #[cfg(feature = "flatbuffers")] use flatbuffers::{FlatBufferBuilder, WIPOffset}; @@ -18,11 +18,8 @@ use super::{ CompensatedCosine, CompensatedIP, CompensatedSquaredL2, DataMeta, DataMetaError, DataMut, FullQueryMeta, FullQueryMut, QueryMeta, QueryMut, SupportedMetric, }; -#[cfg(feature = "flatbuffers")] -use crate::{ - algorithms::transforms::TransformError, flatbuffers::spherical, spherical::InvalidMetric, -}; use crate::{ + AsFunctor, CompressIntoWith, algorithms::{ heap::SliceHeap, transforms::{NewTransformError, Transform, TransformFailed, TransformKind}, @@ -30,8 +27,11 @@ use crate::{ alloc::{Allocator, AllocatorError, GlobalAllocator, Poly, ScopedAllocator, TryClone}, bits::{PermutationStrategy, Representation, Unsigned}, num::Positive, - utils::{compute_means_and_average_norm, compute_normalized_means, CannotBeEmpty}, - AsFunctor, CompressIntoWith, + utils::{CannotBeEmpty, compute_means_and_average_norm, compute_normalized_means}, +}; +#[cfg(feature = "flatbuffers")] +use crate::{ + algorithms::transforms::TransformError, flatbuffers::spherical, spherical::InvalidMetric, }; /////////////// @@ -345,11 +345,7 @@ where let mul: f32 = match self.metric { SupportedMetric::Cosine => { let norm: f32 = (FastL2Norm).evaluate(data); - if norm == 0.0 { - 1.0 - } else { - 1.0 / norm - } + if norm == 0.0 { 1.0 } else { 1.0 / norm } } SupportedMetric::SquaredL2 | SupportedMetric::InnerProduct => scale, }; @@ -757,7 +753,7 @@ where { Ok(()) => {} Err(TransformFailed::AllocatorError(err)) => { - return Err(CompressionError::AllocatorError(err)) + return Err(CompressionError::AllocatorError(err)); } Err(TransformFailed::SourceMismatch { .. }) | Err(TransformFailed::DestinationMismatch { .. }) => { @@ -831,7 +827,7 @@ where { Ok(()) => {} Err(TransformFailed::AllocatorError(err)) => { - return Err(CompressionError::AllocatorError(err)) + return Err(CompressionError::AllocatorError(err)); } Err(TransformFailed::SourceMismatch { .. }) | Err(TransformFailed::DestinationMismatch { .. }) => { @@ -1151,7 +1147,7 @@ where { Ok(()) => {} Err(TransformFailed::AllocatorError(err)) => { - return Err(CompressionError::AllocatorError(err)) + return Err(CompressionError::AllocatorError(err)); } Err(TransformFailed::SourceMismatch { .. }) | Err(TransformFailed::DestinationMismatch { .. }) => { @@ -1211,16 +1207,15 @@ mod tests { use std::fmt::Display; use diskann_utils::{ - lazy_format, + ReborrowMut, lazy_format, views::{self, Matrix}, - ReborrowMut, }; - use diskann_vector::{norm::FastL2NormSquared, PureDistanceFunction}; + use diskann_vector::{PureDistanceFunction, norm::FastL2NormSquared}; use diskann_wide::ARCH; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use rand_distr::StandardNormal; @@ -2106,11 +2101,11 @@ mod tests { where for<'a> T: ReborrowMut<'a>, for<'a> SphericalQuantizer: CompressIntoWith< - &'a [f32], - >::Target, - ScopedAllocator<'a>, - Error = CompressionError, - >, + &'a [f32], + >::Target, + ScopedAllocator<'a>, + Error = CompressionError, + >, { let mut succeeded = false; let mut failed = false; @@ -2145,17 +2140,17 @@ mod tests { Unsigned: Representation, Perm: PermutationStrategy, for<'a> SphericalQuantizer: CompressIntoWith< - &'a [f32], - DataMut<'a, D>, - ScopedAllocator<'a>, - Error = CompressionError, - >, + &'a [f32], + DataMut<'a, D>, + ScopedAllocator<'a>, + Error = CompressionError, + >, for<'a> SphericalQuantizer: CompressIntoWith< - &'a [f32], - QueryMut<'a, Q, Perm>, - ScopedAllocator<'a>, - Error = CompressionError, - >, + &'a [f32], + QueryMut<'a, Q, Perm>, + ScopedAllocator<'a>, + Error = CompressionError, + >, { assert_eq!(setup.nrows, problem.data.nrows()); assert_eq!(setup.ncols, problem.data.ncols()); @@ -2195,17 +2190,17 @@ mod tests { Unsigned: Representation, Perm: PermutationStrategy, for<'a> SphericalQuantizer: CompressIntoWith< - &'a [f32], - DataMut<'a, D>, - ScopedAllocator<'a>, - Error = CompressionError, - >, + &'a [f32], + DataMut<'a, D>, + ScopedAllocator<'a>, + Error = CompressionError, + >, for<'a> SphericalQuantizer: CompressIntoWith< - &'a [f32], - QueryMut<'a, Q, Perm>, - ScopedAllocator<'a>, - Error = CompressionError, - >, + &'a [f32], + QueryMut<'a, Q, Perm>, + ScopedAllocator<'a>, + Error = CompressionError, + >, { let problem = test_util::create_test_problem(setup.nrows, setup.ncols, rng); let computed_means_f32: Vec<_> = problem.means.iter().map(|i| *i as f32).collect(); @@ -2515,18 +2510,19 @@ mod tests { let mut v = Data::<4, _>::new_boxed(quantizer.input_dim()); let data: &[f32] = &[1000.34, 1456.32, 1234.5446]; - assert!(quantizer - .compress_into_with(data, v.reborrow_mut(), ScopedAllocator::global()) - .is_ok(), + assert!( + quantizer + .compress_into_with(data, v.reborrow_mut(), ScopedAllocator::global()) + .is_ok(), "if this failed, the likely culprit is exceeding the value of the 16-bit correction terms" - ); + ); } } #[cfg(feature = "flatbuffers")] #[cfg(test)] mod test_serialization { - use rand::{rngs::StdRng, SeedableRng}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::{ diff --git a/diskann-quantization/src/spherical/vectors.rs b/diskann-quantization/src/spherical/vectors.rs index c43a671e4..0ad4af47c 100644 --- a/diskann-quantization/src/spherical/vectors.rs +++ b/diskann-quantization/src/spherical/vectors.rs @@ -112,8 +112,8 @@ //! inhereted properly, even if these functions are not inlined. use diskann_utils::{Reborrow, ReborrowMut}; -use diskann_vector::{norm::FastL2NormSquared, Norm}; -use diskann_wide::{arch::Target2, Architecture}; +use diskann_vector::{Norm, norm::FastL2NormSquared}; +use diskann_wide::{Architecture, arch::Target2}; use half::f16; use thiserror::Error; @@ -501,11 +501,11 @@ where A: Architecture, Unsigned: Representation, InnerProduct: for<'a> Target2< - A, - distances::MathematicalResult, - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'a, NBITS, Unsigned>, - >, + A, + distances::MathematicalResult, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'a, NBITS, Unsigned>, + >, { // NOTE: `Target2<_, _, _, _>` is used instead of `Architecture::run2` to ensure that // the kernel is inlined into this callsize. @@ -574,11 +574,11 @@ where A: Architecture, Unsigned: Representation, InnerProduct: for<'a> Target2< - A, - distances::MathematicalResult, - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'a, NBITS, Unsigned>, - >, + A, + distances::MathematicalResult, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'a, NBITS, Unsigned>, + >, { #[inline(always)] fn run( @@ -603,11 +603,11 @@ where Unsigned: Representation, Perm: PermutationStrategy, for<'a> InnerProduct: Target2< - A, - distances::MathematicalResult, - BitSlice<'a, Q, Unsigned, Perm>, - BitSlice<'a, D, Unsigned>, - >, + A, + distances::MathematicalResult, + BitSlice<'a, Q, Unsigned, Perm>, + BitSlice<'a, D, Unsigned>, + >, { #[inline(always)] fn run( @@ -647,11 +647,11 @@ where A: Architecture, Unsigned: Representation, InnerProduct: for<'a> Target2< - A, - distances::MathematicalResult, - &'a [f32], - BitSlice<'a, NBITS, Unsigned>, - >, + A, + distances::MathematicalResult, + &'a [f32], + BitSlice<'a, NBITS, Unsigned>, + >, { #[inline(always)] fn run( @@ -734,11 +734,11 @@ where A: Architecture, Unsigned: Representation, InnerProduct: for<'a> Target2< - A, - distances::MathematicalResult, - BitSlice<'a, NBITS, Unsigned>, - BitSlice<'a, NBITS, Unsigned>, - >, + A, + distances::MathematicalResult, + BitSlice<'a, NBITS, Unsigned>, + BitSlice<'a, NBITS, Unsigned>, + >, { #[inline(always)] fn run( @@ -767,11 +767,11 @@ where Unsigned: Representation, Perm: PermutationStrategy, for<'a> InnerProduct: Target2< - A, - distances::MathematicalResult, - BitSlice<'a, Q, Unsigned, Perm>, - BitSlice<'a, D, Unsigned>, - >, + A, + distances::MathematicalResult, + BitSlice<'a, Q, Unsigned, Perm>, + BitSlice<'a, D, Unsigned>, + >, { #[inline(always)] fn run( @@ -812,11 +812,11 @@ where A: Architecture, Unsigned: Representation, InnerProduct: for<'a> Target2< - A, - distances::MathematicalResult, - &'a [f32], - BitSlice<'a, NBITS, Unsigned>, - >, + A, + distances::MathematicalResult, + &'a [f32], + BitSlice<'a, NBITS, Unsigned>, + >, { #[inline(always)] fn run( @@ -898,13 +898,13 @@ where #[cfg(test)] mod tests { - use diskann_utils::{lazy_format, Reborrow}; - use diskann_vector::{distance::Metric, norm::FastL2Norm, PureDistanceFunction}; + use diskann_utils::{Reborrow, lazy_format}; + use diskann_vector::{PureDistanceFunction, distance::Metric, norm::FastL2Norm}; use diskann_wide::ARCH; use rand::{ + SeedableRng, distr::{Distribution, Uniform}, rngs::StdRng, - SeedableRng, }; use rand_distr::StandardNormal; @@ -1355,41 +1355,41 @@ mod tests { Unsigned: Representation, Perm: PermutationStrategy, for<'a> CompensatedIP: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, for<'a> CompensatedSquaredL2: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, for<'a> CompensatedCosine: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, for<'a> CompensatedIP: Target2< - diskann_wide::arch::Current, - distances::Result, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::Result, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, for<'a> CompensatedSquaredL2: Target2< - diskann_wide::arch::Current, - distances::Result, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::Result, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, for<'a> CompensatedCosine: Target2< - diskann_wide::arch::Current, - distances::Result, - QueryRef<'a, Q, Perm>, - DataRef<'a, D>, - >, + diskann_wide::arch::Current, + distances::Result, + QueryRef<'a, Q, Perm>, + DataRef<'a, D>, + >, { // The center let mut center = vec![0.0f32; dim]; @@ -1502,41 +1502,41 @@ mod tests { ) where Unsigned: Representation, for<'a> CompensatedIP: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, for<'a> CompensatedSquaredL2: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, for<'a> CompensatedCosine: Target2< - diskann_wide::arch::Current, - distances::MathematicalResult, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::MathematicalResult, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, for<'a> CompensatedIP: Target2< - diskann_wide::arch::Current, - distances::Result, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::Result, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, for<'a> CompensatedSquaredL2: Target2< - diskann_wide::arch::Current, - distances::Result, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::Result, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, for<'a> CompensatedCosine: Target2< - diskann_wide::arch::Current, - distances::Result, - FullQueryRef<'a>, - DataRef<'a, NBITS>, - >, + diskann_wide::arch::Current, + distances::Result, + FullQueryRef<'a>, + DataRef<'a, NBITS>, + >, { // The center let mut center = vec![0.0f32; dim]; diff --git a/diskann-quantization/src/test_util.rs b/diskann-quantization/src/test_util.rs index 82371d32a..d83ddc5fe 100644 --- a/diskann-quantization/src/test_util.rs +++ b/diskann-quantization/src/test_util.rs @@ -4,8 +4,8 @@ */ use std::sync::{ - atomic::{AtomicUsize, Ordering}, Arc, + atomic::{AtomicUsize, Ordering}, }; use diskann_utils::views::Matrix; diff --git a/diskann-quantization/src/utils.rs b/diskann-quantization/src/utils.rs index d785ff434..dc2e51004 100644 --- a/diskann-quantization/src/utils.rs +++ b/diskann-quantization/src/utils.rs @@ -193,8 +193,8 @@ where #[cfg(test)] mod tests { use diskann_utils::views::Matrix; - use diskann_vector::{norm::FastL2Norm, Norm}; - use rand::{rngs::StdRng, SeedableRng}; + use diskann_vector::{Norm, norm::FastL2Norm}; + use rand::{SeedableRng, rngs::StdRng}; use super::*; use crate::test_util::create_test_problem; From 4d8154e75ac33b763cdd461d582322d299af895c Mon Sep 17 00:00:00 2001 From: Mark Hildebrand Date: Fri, 13 Feb 2026 08:26:55 -0800 Subject: [PATCH 3/3] Address grammar issues. --- diskann-quantization/src/minmax/multi/meta.rs | 2 +- diskann-quantization/src/multi_vector/matrix.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/diskann-quantization/src/minmax/multi/meta.rs b/diskann-quantization/src/minmax/multi/meta.rs index 4b4d940a6..32b0f9185 100644 --- a/diskann-quantization/src/minmax/multi/meta.rs +++ b/diskann-quantization/src/minmax/multi/meta.rs @@ -156,7 +156,7 @@ where unsafe fn drop(self, ptr: NonNull) { let slice_ptr = std::ptr::slice_from_raw_parts_mut(ptr.as_ptr(), self.bytes()); - // Safety: inherited from caller. All implementations that create a new owned + // SAFETY: inherited from caller. All implementations that create a new owned // `Mat` are compatible with `Box` deallocation. let _ = unsafe { Box::from_raw(slice_ptr) }; } diff --git a/diskann-quantization/src/multi_vector/matrix.rs b/diskann-quantization/src/multi_vector/matrix.rs index 465ca42f7..2a8583d0c 100644 --- a/diskann-quantization/src/multi_vector/matrix.rs +++ b/diskann-quantization/src/multi_vector/matrix.rs @@ -425,7 +425,7 @@ unsafe impl Repr for Standard { // least `self.num_elements()` elements from the base pointer, so this access is safe. let row_ptr = unsafe { ptr.as_ptr().cast::().add(i * self.ncols) }; - // SAFETY: The logic is the same to the previous `unsafe` block. + // SAFETY: The logic is the same as the previous `unsafe` block. unsafe { std::slice::from_raw_parts(row_ptr, self.ncols) } } } @@ -447,7 +447,7 @@ unsafe impl ReprMut for Standard { // least `self.num_elements()` elements from the base pointer, so this access is safe. let row_ptr = unsafe { ptr.as_ptr().cast::().add(i * self.ncols) }; - // SAFETY: The logic is the same to the previous `unsafe` block. Further, the caller + // SAFETY: The logic is the same as the previous `unsafe` block. Further, the caller // attests that creating a mutable reference is safe. unsafe { std::slice::from_raw_parts_mut(row_ptr, self.ncols) } }