diff --git a/src/ailego/math_batch/inner_product_distance_batch.h b/src/ailego/math_batch/inner_product_distance_batch.h
index 6375482a2..19a5e4e96 100644
--- a/src/ailego/math_batch/inner_product_distance_batch.h
+++ b/src/ailego/math_batch/inner_product_distance_batch.h
@@ -55,6 +55,58 @@ struct InnerProductDistanceBatchImpl {
   }
 };
 
+template <typename T, size_t BatchSize>
+struct MinusInnerProductDistanceBatchImpl {
+  using ValueType = typename std::remove_cv<T>::type;
+
+  // Keep the sign flip in the baseline-ISA caller. The dispatch translation
+  // unit is compiled for the highest available ISA so it can reference all
+  // optimized kernels; doing this work in an out-of-line specialization there
+  // can make Clang emit AVX-512 instructions before any runtime feature check.
+  static void compute_one_to_many(
+      const ValueType *query, const ValueType **ptrs,
+      std::array<const ValueType *, BatchSize> &prefetch_ptrs, size_t dim,
+      float *sums) {
+    InnerProductDistanceBatchImpl<ValueType, BatchSize>::compute_one_to_many(
+        query, ptrs, prefetch_ptrs, dim, sums);
+    for (size_t j = 0; j < BatchSize; ++j) {
+      sums[j] = -sums[j];
+    }
+  }
+};
+
+template <template <typename, size_t> class Impl, typename ValueType,
+          size_t BatchSize, size_t PrefetchStep>
+static inline void ComputeBatchChunked(const ValueType **vecs,
+                                       const ValueType *query, size_t num_vecs,
+                                       size_t dim, float *results) {
+  size_t i = 0;
+  for (; i + BatchSize <= num_vecs; i += BatchSize) {
+    std::array<const ValueType *, BatchSize> prefetch_ptrs;
+    for (size_t j = 0; j < BatchSize; ++j) {
+      if (i + j + BatchSize * PrefetchStep < num_vecs) {
+        prefetch_ptrs[j] = vecs[i + j + BatchSize * PrefetchStep];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    Impl<ValueType, BatchSize>::compute_one_to_many(
+        query, &vecs[i], prefetch_ptrs, dim, &results[i]);
+  }
+  if constexpr (std::is_same_v<ValueType, float> && BatchSize > 8) {
+    if (i + 8 <= num_vecs) {
+      ComputeBatchChunked<Impl, ValueType, 8, PrefetchStep>(&vecs[i], query, 8,
+                                                            dim, &results[i]);
+      i += 8;
+    }
+  }
+  for (; i < num_vecs; ++i) {  // TODO: unroll by 1, 2, 4, 8, etc.
+    std::array<const ValueType *, 1> prefetch_ptrs{nullptr};
+    Impl<ValueType, 1>::compute_one_to_many(query, &vecs[i], prefetch_ptrs, dim,
+                                            &results[i]);
+  }
+}
+
 template <typename T, size_t BatchSize, size_t PrefetchStep, typename>
 struct InnerProductDistanceBatch {
   using ValueType = typename std::remove_cv<T>::type;
@@ -62,24 +114,8 @@ struct InnerProductDistanceBatch {
   static inline void ComputeBatch(const ValueType **vecs,
                                   const ValueType *query, size_t num_vecs,
                                   size_t dim, float *results) {
-    size_t i = 0;
-    for (; i + BatchSize <= num_vecs; i += BatchSize) {
-      std::array<const ValueType *, BatchSize> prefetch_ptrs;
-      for (size_t j = 0; j < BatchSize; ++j) {
-        if (i + j + BatchSize * PrefetchStep < num_vecs) {
-          prefetch_ptrs[j] = vecs[i + j + BatchSize * PrefetchStep];
-        } else {
-          prefetch_ptrs[j] = nullptr;
-        }
-      }
-      InnerProductDistanceBatchImpl<ValueType, BatchSize>::compute_one_to_many(
-          query, &vecs[i], prefetch_ptrs, dim, &results[i]);
-    }
-    for (; i < num_vecs; ++i) {  // TODO: unroll by 1, 2, 4, 8, etc.
-      std::array<const ValueType *, 1> prefetch_ptrs{nullptr};
-      InnerProductDistanceBatchImpl<ValueType, 1>::compute_one_to_many(
-          query, &vecs[i], prefetch_ptrs, dim, &results[i]);
-    }
+    ComputeBatchChunked<InnerProductDistanceBatchImpl, ValueType, BatchSize,
+                        PrefetchStep>(vecs, query, num_vecs, dim, results);
   }
 
   static DistanceBatchQueryPreprocessFunc GetQueryPreprocessFunc() {
@@ -88,6 +124,19 @@ struct InnerProductDistanceBatch {
   }
 };
 
+template <typename T, size_t BatchSize, size_t PrefetchStep>
+struct MinusInnerProductDistanceBatch {
+  using ValueType = typename std::remove_cv<T>::type;
+
+  static inline void ComputeBatch(const ValueType **vecs,
+                                  const ValueType *query, size_t num_vecs,
+                                  size_t dim, float *results) {
+    ComputeBatchChunked<MinusInnerProductDistanceBatchImpl, ValueType,
+                        BatchSize, PrefetchStep>(vecs, query, num_vecs, dim,
+                                                 results);
+  }
+};
+
 template <>
 struct InnerProductDistanceBatchImpl<ailego::Float16, 1> {
   using ValueType = ailego::Float16;
@@ -132,6 +181,14 @@ struct InnerProductDistanceBatchImpl<float, 12> {
                                   size_t dim, float *sums);
 };
 
+template <>
+struct InnerProductDistanceBatchImpl<float, 8> {
+  using ValueType = float;
+  static void compute_one_to_many(const float *query, const float **ptrs,
+                                  std::array<const float *, 8> &prefetch_ptrs,
+                                  size_t dim, float *sums);
+};
+
 template <>
 struct InnerProductDistanceBatchImpl<int8_t, 12> {
   using ValueType = int8_t;
diff --git a/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc b/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
index 78376626a..9c7d3f8b4 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_dispatch.cc
@@ -50,6 +50,21 @@ void compute_one_to_many_inner_product_avx512fp16_fp16_12(
 #endif  //__AVX512FP16__
 
 #if defined(__AVX512F__)
+void compute_one_to_many_inner_product_avx512f_fp32_1(
+    const float *query, const float **ptrs,
+    std::array<const float *, 1> &prefetch_ptrs, size_t dimensionality,
+    float *results);
+
+void compute_one_to_many_inner_product_avx512f_fp32_12(
+    const float *query, const float **ptrs,
+    std::array<const float *, 12> &prefetch_ptrs, size_t dimensionality,
+    float *results);
+
+void compute_one_to_many_inner_product_avx512f_fp32_8(
+    const float *query, const float **ptrs,
+    std::array<const float *, 8> &prefetch_ptrs, size_t dimensionality,
+    float *results);
+
 void compute_one_to_many_inner_product_avx512f_fp16_1(
     const ailego::Float16 *query, const ailego::Float16 **ptrs,
     std::array<const ailego::Float16 *, 1> &prefetch_ptrs,
@@ -82,6 +97,11 @@ void compute_one_to_many_inner_product_avx2_fp32_12(
     std::array<const float *, 12> &prefetch_ptrs, size_t dimensionality,
     float *results);
 
+void compute_one_to_many_inner_product_avx2_fp32_8(
+    const float *query, const float **ptrs,
+    std::array<const float *, 8> &prefetch_ptrs, size_t dimensionality,
+    float *results);
+
 void compute_one_to_many_inner_product_avx2_fp16_12(
     const ailego::Float16 *query, const ailego::Float16 **ptrs,
     std::array<const ailego::Float16 *, 12> &prefetch_ptrs,
@@ -96,6 +116,12 @@ void compute_one_to_many_inner_product_avx2_int8_12(
 void InnerProductDistanceBatchImpl<float, 1>::compute_one_to_many(
     const ValueType *query, const ValueType **ptrs,
     std::array<const ValueType *, 1> &prefetch_ptrs, size_t dim, float *sums) {
+#if defined(__AVX512F__)
+  if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512F) {
+    return compute_one_to_many_inner_product_avx512f_fp32_1(
+        query, ptrs, prefetch_ptrs, dim, sums);
+  }
+#endif
 #if defined(__AVX2__)
   if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2) {
     return compute_one_to_many_inner_product_avx2_fp32_1(
@@ -167,6 +193,12 @@ InnerProductDistanceBatchImpl<int8_t, 1>::GetQueryPreprocessFunc() {
 void InnerProductDistanceBatchImpl<float, 12>::compute_one_to_many(
     const ValueType *query, const ValueType **ptrs,
     std::array<const ValueType *, 12> &prefetch_ptrs, size_t dim, float *sums) {
+#if defined(__AVX512F__)
+  if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512F) {
+    return compute_one_to_many_inner_product_avx512f_fp32_12(
+        query, ptrs, prefetch_ptrs, dim, sums);
+  }
+#endif
 #if defined(__AVX2__)
   if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2) {
     return compute_one_to_many_inner_product_avx2_fp32_12(
@@ -177,6 +209,25 @@ void InnerProductDistanceBatchImpl<float, 12>::compute_one_to_many(
                                                     dim, sums);
 }
 
+void InnerProductDistanceBatchImpl<float, 8>::compute_one_to_many(
+    const ValueType *query, const ValueType **ptrs,
+    std::array<const ValueType *, 8> &prefetch_ptrs, size_t dim, float *sums) {
+#if defined(__AVX512F__)
+  if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512F) {
+    return compute_one_to_many_inner_product_avx512f_fp32_8(
+        query, ptrs, prefetch_ptrs, dim, sums);
+  }
+#endif
+#if defined(__AVX2__)
+  if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2) {
+    return compute_one_to_many_inner_product_avx2_fp32_8(
+        query, ptrs, prefetch_ptrs, dim, sums);
+  }
+#endif
+  return compute_one_to_many_inner_product_fallback(query, ptrs, prefetch_ptrs,
+                                                    dim, sums);
+}
+
 void InnerProductDistanceBatchImpl<ailego::Float16, 12>::compute_one_to_many(
     const ailego::Float16 *query, const ailego::Float16 **ptrs,
     std::array<const ailego::Float16 *, 12> &prefetch_ptrs, size_t dim,
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
index bead50745..24e4c752f 100644
--- a/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx2.cc
@@ -129,6 +129,13 @@ void compute_one_to_many_inner_product_avx2_fp32_12(
       query, ptrs, prefetch_ptrs, dim, sums);
 }
 
+void compute_one_to_many_inner_product_avx2_fp32_8(
+    const float *query, const float **ptrs,
+    std::array<const float *, 8> &prefetch_ptrs, size_t dim, float *sums) {
+  return compute_one_to_many_inner_product_avx2_fp32<float, 8>(
+      query, ptrs, prefetch_ptrs, dim, sums);
+}
+
 #endif
 
-}  // namespace zvec::ailego::DistanceBatch
\ No newline at end of file
+}  // namespace zvec::ailego::DistanceBatch
diff --git a/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx512.cc b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx512.cc
new file mode 100644
index 000000000..fb7b5cf5a
--- /dev/null
+++ b/src/ailego/math_batch/inner_product_distance_batch_impl_fp32_avx512.cc
@@ -0,0 +1,89 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <array>
+#include <ailego/math/matrix_utility.i>
+#include <ailego/utility/math_helper.h>
+#include <zvec/ailego/internal/platform.h>
+#include "distance_batch_math.h"
+
+namespace zvec::ailego::DistanceBatch {
+
+#if defined(__AVX512F__)
+
+template <size_t BatchSize>
+static void compute_one_to_many_inner_product_avx512f_fp32(
+    const float *query, const float **ptrs,
+    std::array<const float *, BatchSize> &prefetch_ptrs, size_t dimensionality,
+    float *results) {
+  __m512 accumulators[BatchSize];
+  for (size_t i = 0; i < BatchSize; ++i) {
+    accumulators[i] = _mm512_setzero_ps();
+  }
+
+  size_t dim = 0;
+  for (; dim + 16 <= dimensionality; dim += 16) {
+    const __m512 query_values = _mm512_loadu_ps(query + dim);
+    for (size_t i = 0; i < BatchSize; ++i) {
+      const __m512 vector_values = _mm512_loadu_ps(ptrs[i] + dim);
+      accumulators[i] =
+          _mm512_fmadd_ps(query_values, vector_values, accumulators[i]);
+    }
+    if (prefetch_ptrs[0]) {
+      for (size_t i = 0; i < BatchSize; ++i) {
+        ailego_prefetch(prefetch_ptrs[i] + dim);
+      }
+    }
+  }
+
+  if (dim < dimensionality) {
+    const auto remaining = static_cast<unsigned>(dimensionality - dim);
+    const __mmask16 mask = static_cast<__mmask16>((1u << remaining) - 1u);
+    const __m512 query_values = _mm512_maskz_loadu_ps(mask, query + dim);
+    for (size_t i = 0; i < BatchSize; ++i) {
+      const __m512 vector_values = _mm512_maskz_loadu_ps(mask, ptrs[i] + dim);
+      accumulators[i] =
+          _mm512_fmadd_ps(query_values, vector_values, accumulators[i]);
+    }
+  }
+
+  for (size_t i = 0; i < BatchSize; ++i) {
+    results[i] = HorizontalAdd_FP32_V512(accumulators[i]);
+  }
+}
+
+void compute_one_to_many_inner_product_avx512f_fp32_1(
+    const float *query, const float **ptrs,
+    std::array<const float *, 1> &prefetch_ptrs, size_t dim, float *results) {
+  compute_one_to_many_inner_product_avx512f_fp32<1>(query, ptrs, prefetch_ptrs,
+                                                    dim, results);
+}
+
+void compute_one_to_many_inner_product_avx512f_fp32_12(
+    const float *query, const float **ptrs,
+    std::array<const float *, 12> &prefetch_ptrs, size_t dim, float *results) {
+  compute_one_to_many_inner_product_avx512f_fp32<12>(query, ptrs, prefetch_ptrs,
+                                                     dim, results);
+}
+
+void compute_one_to_many_inner_product_avx512f_fp32_8(
+    const float *query, const float **ptrs,
+    std::array<const float *, 8> &prefetch_ptrs, size_t dim, float *results) {
+  compute_one_to_many_inner_product_avx512f_fp32<8>(query, ptrs, prefetch_ptrs,
+                                                    dim, results);
+}
+
+#endif
+
+}  // namespace zvec::ailego::DistanceBatch
diff --git a/src/core/algorithm/flat/flat_searcher.cc b/src/core/algorithm/flat/flat_searcher.cc
index ef4e7d4b0..a3496fe22 100644
--- a/src/core/algorithm/flat/flat_searcher.cc
+++ b/src/core/algorithm/flat/flat_searcher.cc
@@ -102,6 +102,7 @@ int FlatSearcher<BATCH_SIZE>::load(IndexStorage::Pointer cntr,
 
   column_major_order_ = (meta_.major_order() == IndexMeta::MO_COLUMN);
   distance_matrix_.initialize(*measure_);
+  row_batch_distance_ = measure_->batch_distance();
 
   if (column_major_order_) {
     if (!distance_matrix_.is_valid()) {
diff --git a/src/core/algorithm/flat/flat_searcher.h b/src/core/algorithm/flat/flat_searcher.h
index 2b0d0d93d..1439f7e6d 100644
--- a/src/core/algorithm/flat/flat_searcher.h
+++ b/src/core/algorithm/flat/flat_searcher.h
@@ -49,6 +49,7 @@ class FlatSearcher : public IndexSearcher {
   int unload(void) override {
     container_ = nullptr;
     measure_ = nullptr;
+    row_batch_distance_ = nullptr;
     features_segment_ = nullptr;
     keys_ = nullptr;
     key_id_mapping_.clear();
@@ -150,6 +151,11 @@ class FlatSearcher : public IndexSearcher {
     return distance_matrix_;
   }
 
+  //! Retrieve the row-major batch distance function
+  const IndexMetric::MatrixBatchDistance &row_batch_distance(void) const {
+    return row_batch_distance_;
+  }
+
   //! Clone a features segment
   IndexStorage::Segment::Pointer clone_features_segment(void) const {
     return features_segment_->clone();
@@ -175,6 +181,7 @@ class FlatSearcher : public IndexSearcher {
   mutable std::vector<uint32_t> mapping_{};
   mutable std::mutex mapping_mutex_{};
   FlatDistanceMatrix<BATCH_SIZE> distance_matrix_{};
+  IndexMetric::MatrixBatchDistance row_batch_distance_{};
   IndexSearcher::Stats stats_{};
 };
 
diff --git a/src/core/algorithm/flat/flat_searcher_context.h b/src/core/algorithm/flat/flat_searcher_context.h
index a04e53ab6..f79511e00 100644
--- a/src/core/algorithm/flat/flat_searcher_context.h
+++ b/src/core/algorithm/flat/flat_searcher_context.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <array>
 #include <zvec/core/framework/index_document.h>
 #include <zvec/core/framework/index_error.h>
 #include "flat_index_format.h"
@@ -583,9 +584,34 @@ int FlatSearcherContext<BATCH_SIZE>::search_row_nofilter(
   heap->set_threshold(this->threshold());
 
   size_t left_size = features_segment_->data_size();
+  size_t block_size = feature_size_ * BATCH_SIZE;
   size_t read_offset = 0;
   size_t feature_index = 0;
   auto matrix = owner_->distance_matrix();
+  const auto &batch_distance = owner_->row_batch_distance();
+
+  auto enqueue_block = [&](const void *block, size_t count) {
+    if (batch_distance) {
+      std::array<const void *, BATCH_SIZE> feature_ptrs{};
+      const char *feature = static_cast<const char *>(block);
+      for (size_t i = 0; i < count; ++i) {
+        feature_ptrs[i] = feature;
+        feature += feature_size_;
+      }
+      batch_distance(feature_ptrs.data(), query, count, qmeta.dimension(),
+                     scores_);
+    } else {
+      const char *feature = static_cast<const char *>(block);
+      for (size_t i = 0; i < count; ++i) {
+        matrix.template distance<1>(feature, query, qmeta.dimension(),
+                                    &scores_[i]);
+        feature += feature_size_;
+      }
+    }
+    for (size_t i = 0; i < count; ++i) {
+      heap->emplace(0, scores_[i], feature_index++);
+    }
+  };
 
   while (left_size >= actual_read_size_) {
     const void *data = nullptr;
@@ -596,12 +622,8 @@ int FlatSearcherContext<BATCH_SIZE>::search_row_nofilter(
       return IndexError_ReadData;
     }
 
-    for (size_t offset = 0; offset < actual_read_size_;
-         offset += feature_size_) {
-      float score;
-      matrix.template distance<1>((const char *)data + offset, query,
-                                  qmeta.dimension(), &score);
-      heap->emplace(0, score, feature_index++);
+    for (size_t offset = 0; offset < actual_read_size_; offset += block_size) {
+      enqueue_block(static_cast<const char *>(data) + offset, BATCH_SIZE);
     }
     read_offset += actual_read_size_;
     left_size -= actual_read_size_;
@@ -614,11 +636,14 @@ int FlatSearcherContext<BATCH_SIZE>::search_row_nofilter(
     return IndexError_ReadData;
   }
 
-  for (size_t offset = 0; offset < left_size; offset += feature_size_) {
-    float score;
-    matrix.template distance<1>((const char *)data + offset, query,
-                                qmeta.dimension(), &score);
-    heap->emplace(0, score, feature_index++);
+  size_t left_size_aligned = left_size / block_size * block_size;
+  for (size_t offset = 0; offset < left_size_aligned; offset += block_size) {
+    enqueue_block(static_cast<const char *>(data) + offset, BATCH_SIZE);
+  }
+  size_t left_count = (left_size - left_size_aligned) / feature_size_;
+  if (left_count != 0) {
+    enqueue_block(static_cast<const char *>(data) + left_size_aligned,
+                  left_count);
   }
   for (auto &it : *heap) {
     it.set_key(owner_->key(it.index()));
diff --git a/src/core/algorithm/flat/flat_streamer_entity.cc b/src/core/algorithm/flat/flat_streamer_entity.cc
index 87d9a1906..6603ae553 100644
--- a/src/core/algorithm/flat/flat_streamer_entity.cc
+++ b/src/core/algorithm/flat/flat_streamer_entity.cc
@@ -76,6 +76,7 @@ int FlatStreamerEntity::open(IndexStorage::Pointer storage,
     return ret;
   }
   row_distance_ = metric->distance();
+  row_batch_distance_ = metric->batch_distance();
   column_distance_ =
       metric->distance_matrix(meta_.header.block_vector_count, 1);
 
@@ -240,6 +241,13 @@ int FlatStreamerEntity::search(const void *query, const IndexFilter &filter,
       return IndexError_ReadData;
     }
 
+    if (this->is_valid_block(hd->next)) {
+      IndexStorage::MemoryBlock next_header_block;
+      if (this->get_block_header(hd->next, next_header_block) == 0) {
+        ailego_prefetch(next_header_block.data());
+      }
+    }
+
     if (hd->vector_count > 0) {
       *scan_count += hd->vector_count;
       IndexStorage::MemoryBlock deletion_map_block;
@@ -264,14 +272,20 @@ void FlatStreamerEntity::search_block(const void *query,
                                       const BlockLocation &bl,
                                       const BlockHeader *hd, float norm_val,
                                       IndexDocumentHeap *heap) const {
-  std::vector<float> distances(block_vector_count());
+  std::array<float, 32> distances_storage;
+  std::vector<float> distances_overflow;
+  float *distances = distances_storage.data();
+  if (block_vector_count() > distances_storage.size()) {
+    distances_overflow.resize(block_vector_count());
+    distances = distances_overflow.data();
+  }
   IndexStorage::MemoryBlock vecs_block;
   this->get_block_vectors(bl, vecs_block);
   const char *vecs = reinterpret_cast<const char *>(vecs_block.data());
   IndexStorage::MemoryBlock keys_block;
   this->get_block_keys(bl, keys_block);
   const uint64_t *keys = reinterpret_cast<const uint64_t *>(keys_block.data());
-  row_major_distance(query, vecs, hd->vector_count, distances.data());
+  row_major_distance(query, vecs, hd->vector_count, distances);
   for (size_t k = 0; k < hd->vector_count; ++k) {
     if (keys[k] != kInvalidKey) {
       heap->emplace(keys[k], distances[k] * norm_val);
@@ -284,7 +298,13 @@ void FlatStreamerEntity::search_block(
     const void *query, const BlockLocation &bl, const BlockHeader *hd,
     float norm_val, const IndexFilter &filter, const DeletionMap *deletion_map,
     IndexDocumentHeap *heap, IndexContext::Stats *context_stats) const {
-  std::vector<float> distances(block_vector_count());
+  std::array<float, 32> distances_storage;
+  std::vector<float> distances_overflow;
+  float *distances = distances_storage.data();
+  if (block_vector_count() > distances_storage.size()) {
+    distances_overflow.resize(block_vector_count());
+    distances = distances_overflow.data();
+  }
 
   IndexStorage::MemoryBlock vecs_block;
   this->get_block_vectors(bl, vecs_block);
@@ -306,11 +326,31 @@ void FlatStreamerEntity::search_block(
     (*context_stats->mutable_filtered_count()) += hd->vector_count;
     return;
   }
-  for (size_t k = 0; k < hd->vector_count; ++k) {
-    if (keeps.test(k)) {
-      auto cur_vec = vecs + index_meta_.element_size() * k;
-      row_major_distance(query, cur_vec, 1, distances.data() + k);
-      ++(*context_stats->mutable_dist_calced_count());
+  if (row_batch_distance_ && hd->vector_count <= 32) {
+    std::array<const void *, 32> kept_ptrs{};
+    std::array<uint32_t, 32> kept_slots{};
+    size_t kept_count = 0;
+    for (size_t k = 0; k < hd->vector_count; ++k) {
+      if (keeps.test(k)) {
+        kept_ptrs[kept_count] = vecs + index_meta_.element_size() * k;
+        kept_slots[kept_count] = static_cast<uint32_t>(k);
+        ++kept_count;
+      }
+    }
+    std::array<float, 32> kept_scores{};
+    row_batch_distance_(kept_ptrs.data(), query, kept_count,
+                        index_meta_.dimension(), kept_scores.data());
+    for (size_t i = 0; i < kept_count; ++i) {
+      distances[kept_slots[i]] = kept_scores[i];
+    }
+    (*context_stats->mutable_dist_calced_count()) += kept_count;
+  } else {
+    for (size_t k = 0; k < hd->vector_count; ++k) {
+      if (keeps.test(k)) {
+        auto cur_vec = vecs + index_meta_.element_size() * k;
+        row_major_distance(query, cur_vec, 1, distances + k);
+        ++(*context_stats->mutable_dist_calced_count());
+      }
     }
   }
   for (size_t k = 0; k < hd->vector_count; ++k) {
diff --git a/src/core/algorithm/flat/flat_streamer_entity.h b/src/core/algorithm/flat/flat_streamer_entity.h
index 7cf915429..7265fc86f 100644
--- a/src/core/algorithm/flat/flat_streamer_entity.h
+++ b/src/core/algorithm/flat/flat_streamer_entity.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <array>
 #include <unordered_map>
 #include <ailego/parallel/lock.h>
 #include <ailego/utility/memory_helper.h>
@@ -155,6 +156,17 @@ class FlatStreamerEntity {
   inline void row_major_distance(const void *query, const void *feature,
                                  size_t fnum, float *out) const {
     const uint8_t *cur_feature = reinterpret_cast<const uint8_t *>(feature);
+    if (fnum > 1 && row_batch_distance_) {
+      std::array<const void *, 32> feature_ptrs{};
+      ailego_assert(fnum <= feature_ptrs.size());
+      for (size_t f = 0; f < fnum; ++f) {
+        feature_ptrs[f] = cur_feature;
+        cur_feature += index_meta_.element_size();
+      }
+      row_batch_distance_(feature_ptrs.data(), query, fnum,
+                          index_meta_.dimension(), out);
+      return;
+    }
     for (size_t f = 0; f < fnum; ++f) {
       row_distance_(query, cur_feature, index_meta_.dimension(), out + f);
       cur_feature += index_meta_.element_size();
@@ -388,6 +400,7 @@ class FlatStreamerEntity {
   IndexMeta index_meta_{};
   IndexStorage::Pointer storage_{};
   IndexMetric::MatrixDistance row_distance_{}, column_distance_{};
+  IndexMetric::MatrixBatchDistance row_batch_distance_{};
   mutable std::vector<IndexStorage::Segment::Pointer> segments_{};
   IndexStreamer::Stats &stats_;
   mutable std::shared_ptr<ailego::SharedMutex> key_info_map_lock_{};
diff --git a/src/core/metric/inner_product_metric.cc b/src/core/metric/inner_product_metric.cc
index 8ef0a11b2..f91b19e62 100644
--- a/src/core/metric/inner_product_metric.cc
+++ b/src/core/metric/inner_product_metric.cc
@@ -354,12 +354,12 @@ class InnerProductMetric : public IndexMetric {
     switch (data_type_) {
       case IndexMeta::DataType::DT_FP32:
         return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
-            ailego::BaseDistance<ailego::MinusInnerProductMatrix, float, 1,
-                                 1>::ComputeBatch);
+            ailego::DistanceBatch::MinusInnerProductDistanceBatch<
+                float, 12, 2>::ComputeBatch);
       case IndexMeta::DataType::DT_FP16:
         return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
-            ailego::BaseDistance<ailego::MinusInnerProductMatrix,
-                                 ailego::Float16, 1, 1>::ComputeBatch);
+            ailego::DistanceBatch::MinusInnerProductDistanceBatch<
+                ailego::Float16, 12, 2>::ComputeBatch);
       case IndexMeta::DataType::DT_INT8:
         return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
             ailego::BaseDistance<ailego::MinusInnerProductMatrix, int8_t, 1,
diff --git a/src/include/zvec/core/framework/index_document.h b/src/include/zvec/core/framework/index_document.h
index 686488e18..c649ca795 100644
--- a/src/include/zvec/core/framework/index_document.h
+++ b/src/include/zvec/core/framework/index_document.h
@@ -273,14 +273,14 @@ class IndexDocumentHeap : public ailego::Heap<IndexDocument> {
 
   //! Insert a document into the heap
   void emplace(uint64_t key, float score) {
-    if (score <= threshold_) {
+    if (this->should_emplace(score)) {
       ailego::Heap<IndexDocument>::emplace(key, score);
     }
   }
 
   //! Insert a document into the heap
   void emplace(uint64_t key, float score, uint32_t index) {
-    if (score <= threshold_) {
+    if (this->should_emplace(score)) {
       ailego::Heap<IndexDocument>::emplace(key, score, index);
     }
   }
@@ -296,6 +296,13 @@ class IndexDocumentHeap : public ailego::Heap<IndexDocument> {
   }
 
  private:
+  bool should_emplace(float score) const {
+    if (!(score <= threshold_)) {
+      return false;
+    }
+    return !this->full() || score < this->front().score();
+  }
+
   //! members
   float threshold_{std::numeric_limits<float>::max()};
 };
diff --git a/tests/core/algorithm/flat/flat_streamer_test.cc b/tests/core/algorithm/flat/flat_streamer_test.cc
index 2f614f218..07109ffe3 100644
--- a/tests/core/algorithm/flat/flat_streamer_test.cc
+++ b/tests/core/algorithm/flat/flat_streamer_test.cc
@@ -173,6 +173,67 @@ TEST_F(FlatStreamerTest, TestLinearSearch) {
   streamer.reset();
 }
 
+TEST_F(FlatStreamerTest, TestInnerProductBatchSearch) {
+  constexpr size_t kVectorCount = 65;
+  constexpr size_t kTopk = 3;
+
+  IndexMeta meta(IndexMeta::DataType::DT_FP32, dim);
+  meta.set_metric("InnerProduct", 0, Params());
+
+  auto streamer = IndexFactory::CreateStreamer("FlatStreamer");
+  ASSERT_TRUE(streamer);
+  ASSERT_EQ(0, streamer->init(meta, Params()));
+
+  auto storage = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_TRUE(storage);
+  ASSERT_EQ(0, storage->init(Params()));
+  ASSERT_EQ(0, storage->open(dir_ + "TestInnerProductBatchSearch", true));
+  ASSERT_EQ(0, streamer->open(storage));
+
+  auto context = streamer->create_context();
+  ASSERT_TRUE(context);
+  IndexQueryMeta qmeta(IndexMeta::DT_FP32, dim);
+  NumericalVector<float> vector(dim, 0.0f);
+  for (size_t i = 0; i < kVectorCount; ++i) {
+    vector[0] = static_cast<float>(i);
+    ASSERT_EQ(0, streamer->add_impl(i, vector.data(), qmeta, context));
+  }
+
+  NumericalVector<float> query(dim, 0.0f);
+  query[0] = 1.0f;
+  context->set_topk(kTopk);
+  ASSERT_EQ(0, streamer->search_impl(query.data(), qmeta, context));
+  ASSERT_EQ(kTopk, context->result().size());
+  EXPECT_EQ(64, context->result()[0].key());
+  EXPECT_EQ(63, context->result()[1].key());
+  EXPECT_EQ(62, context->result()[2].key());
+
+  std::string dump_path = dir_ + "TestInnerProductBatchSearchDump";
+  auto dumper = IndexFactory::CreateDumper("FileDumper");
+  ASSERT_TRUE(dumper);
+  ASSERT_EQ(0, dumper->init(Params()));
+  ASSERT_EQ(0, dumper->create(dump_path));
+  ASSERT_EQ(0, streamer->dump(dumper));
+  ASSERT_EQ(0, dumper->close());
+
+  auto container = IndexFactory::CreateStorage("MMapFileReadStorage");
+  ASSERT_TRUE(container);
+  ASSERT_EQ(0, container->init(Params()));
+  ASSERT_EQ(0, container->open(dump_path, false));
+  auto searcher = IndexFactory::CreateSearcher("FlatSearcher");
+  ASSERT_TRUE(searcher);
+  ASSERT_EQ(0, searcher->init(Params()));
+  ASSERT_EQ(0, searcher->load(container, IndexMetric::Pointer()));
+
+  auto search_context = searcher->create_context();
+  search_context->set_topk(kTopk);
+  ASSERT_EQ(0, searcher->search_impl(query.data(), qmeta, search_context));
+  ASSERT_EQ(kTopk, search_context->result().size());
+  EXPECT_EQ(64, search_context->result()[0].key());
+  EXPECT_EQ(63, search_context->result()[1].key());
+  EXPECT_EQ(62, search_context->result()[2].key());
+}
+
 TEST_F(FlatStreamerTest, TestAddAndSearch) {
   IndexStreamer::Pointer streamer =
       IndexFactory::CreateStreamer("FlatStreamer");
@@ -1305,4 +1366,4 @@ TEST_F(FlatStreamerTest, TestInt8WithRotate) {
 
 #if defined(__GNUC__) || defined(__GNUG__)
 #pragma GCC diagnostic pop
-#endif
\ No newline at end of file
+#endif
diff --git a/tests/core/metric/inner_product_metric_test.cc b/tests/core/metric/inner_product_metric_test.cc
index 8a0c521c8..3dba92efb 100644
--- a/tests/core/metric/inner_product_metric_test.cc
+++ b/tests/core/metric/inner_product_metric_test.cc
@@ -11,7 +11,9 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#include <array>
 #include <iostream>
+#include <vector>
 #include <gtest/gtest.h>
 #include "zvec/core/framework/index_factory.h"
 
@@ -74,4 +76,45 @@ TEST(InnerProductMetric, General) {
   float result = 1.0f;
   metric->normalize(&result);
   EXPECT_FLOAT_EQ(-1.0f, result);
-}
\ No newline at end of file
+}
+
+TEST(InnerProductMetric, BatchFp32MatchesSingleDistance) {
+  constexpr size_t kDimension = 384;
+  constexpr size_t kVectorCount = 25;
+
+  IndexMeta meta(IndexMeta::DataType::DT_FP32, kDimension);
+  auto metric = IndexFactory::CreateMetric("InnerProduct");
+  ASSERT_TRUE(metric);
+  ASSERT_EQ(0, metric->init(meta, ailego::Params()));
+
+  auto single_distance = metric->distance();
+  auto batch_distance = metric->batch_distance();
+  ASSERT_TRUE(single_distance);
+  ASSERT_TRUE(batch_distance);
+
+  std::vector<float> query(kDimension);
+  std::vector<std::vector<float>> vectors(kVectorCount,
+                                          std::vector<float>(kDimension));
+  std::array<const void *, kVectorCount> vector_ptrs{};
+  for (size_t d = 0; d < kDimension; ++d) {
+    query[d] = static_cast<float>(static_cast<int>(d % 17) - 8) / 17.0f;
+  }
+  for (size_t i = 0; i < kVectorCount; ++i) {
+    for (size_t d = 0; d < kDimension; ++d) {
+      vectors[i][d] = static_cast<float>(((i + 3) * (d + 5)) % 29) / 29.0f;
+    }
+    vector_ptrs[i] = vectors[i].data();
+  }
+
+  std::array<float, kVectorCount> expected{};
+  std::array<float, kVectorCount> actual{};
+  for (size_t i = 0; i < kVectorCount; ++i) {
+    single_distance(vector_ptrs[i], query.data(), kDimension, &expected[i]);
+  }
+  batch_distance(vector_ptrs.data(), query.data(), kVectorCount, kDimension,
+                 actual.data());
+
+  for (size_t i = 0; i < kVectorCount; ++i) {
+    EXPECT_NEAR(expected[i], actual[i], 1e-4f);
+  }
+}