Code cleanup: remove dead code, fix warnings, hoist thread_local

From /simplify review:
- Delete dead load_data_as_f32 (superseded by load_data_typed)
- Delete dead find_medoid_public (never called from diskann-disk)
- Remove redundant partition_assign wrapper (was 1-line passthrough to
  partition_assign_impl, renamed impl back to partition_assign)
- Remove unused mut on two cluster bindings in quantized partition
- Hoist thread_local! F32_BUF to module scope in quantize.rs
- Add missing trim_heap() after partition in build_internal_sq_impl

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: WeiyaoLuo

diskann-disk/src/build/builder/build.rs

@@ -667,31 +667,6 @@ where
     }
 }
 
-#[cfg(feature = "pipnn")]
-fn load_data_as_f32<T, SP>(
-    data_path: &str,
-    storage_provider: &SP,
-) -> ANNResult<(usize, usize, Vec<f32>)>
-where
-    T: VectorRepr,
-    SP: StorageReadProvider,
-{
-    let matrix = read_bin::<T>(&mut storage_provider.open_reader(data_path)?)?;
-    let npoints = matrix.nrows();
-    let ndims = matrix.ncols();
-
-    // Convert to f32
-    let mut f32_data = vec![0.0f32; npoints * ndims];
-    for i in 0..npoints {
-        let src = matrix.row(i);
-        let dst = &mut f32_data[i * ndims..(i + 1) * ndims];
-        T::as_f32_into(src, dst)
-            .map_err(|e| ANNError::log_index_error(format!("Data conversion error: {}", e)))?;
-    }
-
-    Ok((npoints, ndims, f32_data))
-}
-
 /// Load data in its native type T without converting to f32.
 #[cfg(feature = "pipnn")]
 fn load_data_typed<T, SP>(

diskann-pipnn/src/builder.rs

@@ -264,11 +264,6 @@ impl PiPNNGraph {
 /// matching DiskANN's `find_medoid_with_sampling` behavior. The centroid
 /// is a geometric center, so L2 is the natural metric regardless of the
 /// build distance metric.
-/// Public wrapper for find_medoid, used by diskann-disk's build pipeline.
-pub fn find_medoid_public<T: VectorRepr>(data: &[T], npoints: usize, ndims: usize) -> usize {
-    find_medoid(data, npoints, ndims)
-}
-
 fn find_medoid<T: VectorRepr>(data: &[T], npoints: usize, ndims: usize) -> usize {
     let dist_fn = make_dist_fn(Metric::L2);
 

diskann-pipnn/src/partition.rs

@@ -132,25 +132,15 @@ fn partition_assign_quantized(
 /// Fused GEMM + assignment: compute distances to leaders in stripes and immediately
 /// extract top-k assignments without materializing the full N x L distance matrix.
 /// Peak memory: stripe * L * 4 bytes (~64MB) instead of N * L * 4 bytes.
+/// Fused GEMM + assignment: compute distances to leaders in stripes and immediately
+/// extract top-k assignments without materializing the full N x L distance matrix.
 fn partition_assign<T: VectorRepr + Send + Sync>(
     data: &[T],
     ndims: usize,
     points: &[usize],
     leaders: &[usize],
     fanout: usize,
     metric: diskann_vector::distance::Metric,
-) -> Vec<Vec<usize>> {
-    partition_assign_impl(data, ndims, points, leaders, fanout, metric)
-}
-
-/// Core implementation: fused GEMM + distance + top-k assignment in parallel stripes.
-fn partition_assign_impl<T: VectorRepr + Send + Sync>(
-    data: &[T],
-    ndims: usize,
-    points: &[usize],
-    leaders: &[usize],
-    fanout: usize,
-    metric: diskann_vector::distance::Metric,
 ) -> Vec<Vec<usize>> {
     let np = points.len();
     let nl = leaders.len();
@@ -568,7 +558,7 @@ pub fn parallel_partition_quantized(
     let assign_time = t0.elapsed();
 
     let t1 = std::time::Instant::now();
-    let mut clusters: Vec<Vec<usize>> = clusters_local
+    let clusters: Vec<Vec<usize>> = clusters_local
         .into_iter()
         .map(|local_cluster| local_cluster.into_iter().map(|li| indices[li]).collect())
         .collect();
@@ -634,7 +624,7 @@ fn partition_quantized_recursive(
     let leaders: Vec<usize> = indices.choose_multiple(rng, num_leaders).copied().collect();
 
     let clusters_local = partition_assign_quantized(qdata, indices, &leaders, fanout);
-    let mut clusters: Vec<Vec<usize>> = clusters_local
+    let clusters: Vec<Vec<usize>> = clusters_local
         .into_iter()
         .map(|lc| lc.into_iter().map(|li| indices[li]).collect())
         .collect();

diskann-pipnn/src/quantize.rs

@@ -9,6 +9,12 @@
 //! then packs vectors into compact bit arrays for fast Hamming distance.
 
 use rayon::prelude::*;
+use std::cell::RefCell;
+
+thread_local! {
+    /// Reusable f32 buffer for T→f32 conversion during parallel quantization.
+    static QUANT_F32_BUF: RefCell<Vec<f32>> = RefCell::new(Vec::new());
+}
 
 /// Result of 1-bit quantization.
 pub struct QuantizedData {
@@ -63,11 +69,7 @@ pub fn quantize_1bit<T: diskann::utils::VectorRepr + Send + Sync>(
         .enumerate()
         .for_each(|(i, out)| {
             let src = &data[i * ndims..(i + 1) * ndims];
-            // Thread-local f32 buffer for T→f32 conversion (reused across vectors).
-            thread_local! {
-                static F32_BUF: std::cell::RefCell<Vec<f32>> = std::cell::RefCell::new(Vec::new());
-            }
-            F32_BUF.with(|cell| {
+            QUANT_F32_BUF.with(|cell| {
                 let mut buf = cell.borrow_mut();
                 if buf.len() < ndims { buf.resize(ndims, 0.0); }
                 let f32_vec = &mut buf[..ndims];