reformat

Author: Matthijs van Otterdijk

benches/distance.rs

@@ -17,9 +17,9 @@ fn bench_cpu_distance(b: &mut Bencher) {
 
 #[cfg(feature = "simd")]
 mod simd_benches {
-    use terminusdb_semantic_indexer::vecmath::*;
-    use terminusdb_semantic_indexer::vecmath::simd::*;
     use rand::{rngs::StdRng, SeedableRng};
+    use terminusdb_semantic_indexer::vecmath::simd::*;
+    use terminusdb_semantic_indexer::vecmath::*;
     use test::Bencher;
 
     #[bench]

src/lib.rs

@@ -1,5 +1,5 @@
 pub mod indexer;
 pub mod openai;
 pub mod server;
-pub mod vectors;
 pub mod vecmath;
+pub mod vectors;

src/vecmath.rs

@@ -36,12 +36,16 @@ fn clamp_01(f: f32) -> f32 {
 }
 
 fn normalize_cosine_distance(f: f32) -> f32 {
-    clamp_01((f-1.0)/-2.0)
+    clamp_01((f - 1.0) / -2.0)
 }
 
-
 pub fn normalized_cosine_distance_cpu(left: &Embedding, right: &Embedding) -> f32 {
-    normalize_cosine_distance(left.iter().zip(right.iter()).map(|(l,r)|l*r).sum::<f32>())
+    normalize_cosine_distance(
+        left.iter()
+            .zip(right.iter())
+            .map(|(l, r)| l * r)
+            .sum::<f32>(),
+    )
 }
 
 #[cfg(feature = "simd")]
@@ -57,7 +61,7 @@ pub fn normalized_cosine_distance_simd(left: &Embedding, right: &Embedding) -> f
 pub fn normalize_vec_cpu(vec: &mut Embedding) {
     let mut sum = 0.0;
     for f in vec.iter() {
-        sum += f*f;
+        sum += f * f;
     }
     let magnitude = sum.sqrt();
     //eprintln!("cpu magnitude: {}", magnitude);
@@ -89,9 +93,9 @@ pub fn normalize_vec(vec: &mut Embedding) {
 
 #[cfg(feature = "simd")]
 pub mod simd {
-    use packed_simd::f32x16;
-    use aligned_box::AlignedBox;
     use super::*;
+    use aligned_box::AlignedBox;
+    use packed_simd::f32x16;
 
     pub fn aligned_box(e: Embedding) -> AlignedBox<Embedding> {
         AlignedBox::new(std::mem::align_of::<f32x16>(), e).unwrap()
@@ -115,12 +119,15 @@ pub mod simd {
         }
     }
 
-    pub unsafe fn normalized_cosine_distance_simd_aligned_unchecked(left: &Embedding, right: &Embedding) -> f32 {
+    pub unsafe fn normalized_cosine_distance_simd_aligned_unchecked(
+        left: &Embedding,
+        right: &Embedding,
+    ) -> f32 {
         //eprintln!("using {} ({} lanes)", stringify!(f32x16), 16);
         let mut sum = <f32x16>::splat(0.);
-        for x in 0..left.len()/16 {
-            let l = <f32x16>::from_slice_aligned_unchecked(&left[x*16..(x+1)*16]);
-            let r = <f32x16>::from_slice_aligned_unchecked(&right[x*16..(x+1)*16]);
+        for x in 0..left.len() / 16 {
+            let l = <f32x16>::from_slice_aligned_unchecked(&left[x * 16..(x + 1) * 16]);
+            let r = <f32x16>::from_slice_aligned_unchecked(&right[x * 16..(x + 1) * 16]);
             sum += l * r;
         }
         normalize_cosine_distance(sum.sum())
@@ -130,26 +137,27 @@ pub mod simd {
         //eprintln!("using {} ({} lanes)", stringify!(f32x16), 16);
         let mut sum = <f32x16>::splat(0.);
         let exp = <f32x16>::splat(2.);
-        for x in 0..vec.len()/16 {
-            let part = <f32x16>::from_slice_aligned_unchecked(&vec[x*16..(x+1)*16]);
-            sum += part*part;
+        for x in 0..vec.len() / 16 {
+            let part = <f32x16>::from_slice_aligned_unchecked(&vec[x * 16..(x + 1) * 16]);
+            sum += part * part;
         }
         let magnitude = sum.sum().sqrt();
         //eprintln!("simd magnitude: {}", magnitude);
         let magnitude = <f32x16>::splat(magnitude);
 
-        for x in 0..vec.len()/16 {
-            let scaled = <f32x16>::from_slice_aligned_unchecked(&vec[x*16..(x+1)*16]) / magnitude;
-            scaled.write_to_slice_aligned_unchecked(&mut vec[x*16..(x+1)*16]);
+        for x in 0..vec.len() / 16 {
+            let scaled =
+                <f32x16>::from_slice_aligned_unchecked(&vec[x * 16..(x + 1) * 16]) / magnitude;
+            scaled.write_to_slice_aligned_unchecked(&mut vec[x * 16..(x + 1) * 16]);
         }
     }
 
     pub fn normalized_cosine_distance_simd_unaligned(left: &Embedding, right: &Embedding) -> f32 {
         //eprintln!("using {} ({} lanes, unaligned)", stringify!(f32x16), 16);
         let mut sum = <f32x16>::splat(0.);
-        for x in 0..left.len()/16 {
-            let l = <f32x16>::from_slice_unaligned(&left[x*16..(x+1)*16]);
-            let r = <f32x16>::from_slice_unaligned(&right[x*16..(x+1)*16]);
+        for x in 0..left.len() / 16 {
+            let l = <f32x16>::from_slice_unaligned(&left[x * 16..(x + 1) * 16]);
+            let r = <f32x16>::from_slice_unaligned(&right[x * 16..(x + 1) * 16]);
             sum += l * r;
         }
         normalize_cosine_distance(sum.sum())
@@ -159,17 +167,17 @@ pub mod simd {
         //eprintln!("using {} ({} lanes, unaligned)", stringify!(f32x16), 16);
         let mut sum = <f32x16>::splat(0.);
         //let exp = <f32x16>::splat(2.);
-        for x in 0..vec.len()/16 {
-            let part = <f32x16>::from_slice_unaligned(&vec[x*16..(x+1)*16]);
-            sum += part*part;
+        for x in 0..vec.len() / 16 {
+            let part = <f32x16>::from_slice_unaligned(&vec[x * 16..(x + 1) * 16]);
+            sum += part * part;
         }
         let magnitude = sum.sum().sqrt();
         //eprintln!("simd magnitude: {}", magnitude);
         let magnitude = <f32x16>::splat(magnitude);
 
-        for x in 0..vec.len()/16 {
-            let scaled = <f32x16>::from_slice_unaligned(&vec[x*16..(x+1)*16]) / magnitude;
-            scaled.write_to_slice_unaligned(&mut vec[x*16..(x+1)*16]);
+        for x in 0..vec.len() / 16 {
+            let scaled = <f32x16>::from_slice_unaligned(&vec[x * 16..(x + 1) * 16]) / magnitude;
+            scaled.write_to_slice_unaligned(&mut vec[x * 16..(x + 1) * 16]);
         }
     }
 }
@@ -178,7 +186,9 @@ pub mod simd {
 mod tests {
     use rand::{rngs::StdRng, SeedableRng};
 
-    use crate::vecmath::simd::{normalize_vec_simd_unaligned, normalized_cosine_distance_simd_unaligned};
+    use crate::vecmath::simd::{
+        normalize_vec_simd_unaligned, normalized_cosine_distance_simd_unaligned,
+    };
 
     use super::*;
     #[test]
@@ -194,14 +204,29 @@ mod tests {
         normalize_vec_cpu(&mut e1);
         normalize_vec_simd_unaligned(&mut e2);
 
-        eprintln!("distance (cpu): {}", normalized_cosine_distance_cpu(&e1, &e2));
-        eprintln!("distance (simd): {}", normalized_cosine_distance_simd_unaligned(&e1, &e2));
-        eprintln!("distance (simd same): {}", normalized_cosine_distance_simd_unaligned(&e1, &e1));
+        eprintln!(
+            "distance (cpu): {}",
+            normalized_cosine_distance_cpu(&e1, &e2)
+        );
+        eprintln!(
+            "distance (simd): {}",
+            normalized_cosine_distance_simd_unaligned(&e1, &e2)
+        );
+        eprintln!(
+            "distance (simd same): {}",
+            normalized_cosine_distance_simd_unaligned(&e1, &e1)
+        );
 
         let mut e3 = random_embedding(&mut rng);
         normalize_vec_cpu(&mut e3);
-        eprintln!("distance (cpu): {}", normalized_cosine_distance_cpu(&e1, &e3));
-        eprintln!("distance (simd): {}", normalized_cosine_distance_simd_unaligned(&e1, &e3));
+        eprintln!(
+            "distance (cpu): {}",
+            normalized_cosine_distance_cpu(&e1, &e3)
+        );
+        eprintln!(
+            "distance (simd): {}",
+            normalized_cosine_distance_simd_unaligned(&e1, &e3)
+        );
 
         assert_eq!(e1, e2);
     }

src/vectors.rs

@@ -15,7 +15,7 @@ use std::sync::{Arc, Condvar, Mutex, RwLock, Weak};
 use lru::LruCache;
 use urlencoding::encode;
 
-use crate::vecmath::{EMBEDDING_LENGTH, EMBEDDING_BYTE_LENGTH, Embedding, EmbeddingBytes};
+use crate::vecmath::{Embedding, EmbeddingBytes, EMBEDDING_BYTE_LENGTH, EMBEDDING_LENGTH};
 
 // 3 memory pages of 4K hold 2 OpenAI vectors.
 // We set things up so that blocks are some multiple of 2 pages.