moved temporary vectors to sratch space

Author: Ananya Sutradhar

include/scratch.h

@@ -122,6 +122,36 @@ template <typename T> class InMemQueryScratch : public AbstractScratch<T>
         return _tmp_intersection;
     }
 
+    // Scratch space accessors for Jaccard similarity calculations
+    inline std::vector<float> &jaccard_similarities_scratch()
+    {
+        return _jaccard_similarities_scratch;
+    }
+    
+    inline std::vector<float> &init_penalties_scratch()
+    {
+        return _init_penalties_scratch;
+    }
+    
+    inline std::vector<uint32_t> &valid_init_candidates_scratch()
+    {
+        return _valid_init_candidates_scratch;
+    }
+    
+    inline std::vector<uint32_t> &filtered_ids_scratch()
+    {
+        return _filtered_ids_scratch;
+    }
+    
+    // Method to pre-size scratch vectors for batch operations
+    inline void resize_jaccard_scratch_for_batch(size_t expected_batch_size)
+    {
+        _jaccard_similarities_scratch.reserve(expected_batch_size);
+        _init_penalties_scratch.reserve(expected_batch_size);
+        _valid_init_candidates_scratch.reserve(expected_batch_size);
+        _filtered_ids_scratch.reserve(expected_batch_size);
+    }
+
 
   private:
     uint32_t _L;
@@ -169,6 +199,12 @@ template <typename T> class InMemQueryScratch : public AbstractScratch<T>
     std::vector<uint32_t> _closest_clusters;
     std::vector<float> _cluster_distances;
     float *_aligned_query_float;
+    
+    // Scratch space for Jaccard similarity batch calculations
+    std::vector<float> _jaccard_similarities_scratch;
+    std::vector<float> _init_penalties_scratch;
+    std::vector<uint32_t> _valid_init_candidates_scratch;
+    std::vector<uint32_t> _filtered_ids_scratch;
 };
 
 //

src/index.cpp

@@ -1130,6 +1130,10 @@ std::pair<uint32_t, uint32_t> Index<T, TagT, LabelT>::iterate_to_fixed_point(
     uint32_t hops = 0;
     uint32_t cmps = 0;
 
+    // Pre-size scratch vectors for batch operations to avoid reallocations
+    size_t estimated_batch_size = std::max(init_ids.size(), (size_t)(Lsize * 2));
+    scratch->resize_jaccard_scratch_for_batch(estimated_batch_size);
+
     float *pq_dists = nullptr;
 
     if (print_qstats)
@@ -1166,7 +1170,8 @@ std::pair<uint32_t, uint32_t> Index<T, TagT, LabelT>::iterate_to_fixed_point(
     uint32_t candidates_filtered = 0;
 
     // STEP 1: Collect all valid initial candidates first
-    std::vector<uint32_t> valid_init_candidates;
+    std::vector<uint32_t> &valid_init_candidates = scratch->valid_init_candidates_scratch();
+    valid_init_candidates.clear();
     valid_init_candidates.reserve(init_ids.size());
 
     for (auto id : init_ids)
@@ -1202,11 +1207,13 @@ std::pair<uint32_t, uint32_t> Index<T, TagT, LabelT>::iterate_to_fixed_point(
     }
 
     // STEP 2: BATCH PROCESS all initial candidates' filter scores at once
-    std::vector<float> init_penalties;
+    std::vector<float> &init_penalties = scratch->init_penalties_scratch();
+    init_penalties.clear();
     if (use_filter && !valid_init_candidates.empty())
     {
         auto jaccard_start = std::chrono::high_resolution_clock::now();
-        std::vector<float> jaccard_similarities;
+        std::vector<float> &jaccard_similarities = scratch->jaccard_similarities_scratch();
+        jaccard_similarities.clear();
         calculate_jaccard_similarity_batch(valid_init_candidates, filter_labels, jaccard_similarities);
         std::chrono::duration<double> jaccard_diff = std::chrono::high_resolution_clock::now() - jaccard_start;
         curr_jaccard_time += jaccard_diff.count();
@@ -1425,14 +1432,16 @@ std::pair<uint32_t, uint32_t> Index<T, TagT, LabelT>::iterate_to_fixed_point(
             if (use_filter && !id_scratch.empty())
             {
                 auto jaccard_start = std::chrono::high_resolution_clock::now();
-                std::vector<float> jaccard_similarities;
+                std::vector<float> &jaccard_similarities = scratch->jaccard_similarities_scratch();
+                jaccard_similarities.clear();
                 calculate_jaccard_similarity_batch(id_scratch, filter_labels, jaccard_similarities);
                 std::chrono::duration<double> jaccard_diff = std::chrono::high_resolution_clock::now() - jaccard_start;
                 curr_jaccard_time += jaccard_diff.count();
 
                 // Convert similarities to penalties and apply filtering
                 res_vec.reserve(id_scratch.size());
-                std::vector<uint32_t> filtered_ids;
+                std::vector<uint32_t> &filtered_ids = scratch->filtered_ids_scratch();
+                filtered_ids.clear();
                 filtered_ids.reserve(id_scratch.size());
 
                 for (size_t i = 0; i < id_scratch.size(); ++i)

src/scratch.cpp

@@ -42,6 +42,16 @@ InMemQueryScratch<T>::InMemQueryScratch(uint32_t search_l, uint32_t indexing_l,
     _inserted_into_pool_bs = new boost::dynamic_bitset<>();
     _id_scratch.reserve((size_t)std::ceil(1.5 * defaults::GRAPH_SLACK_FACTOR * _R * _R));
     _dist_scratch.reserve((size_t)std::ceil(1.5 * defaults::GRAPH_SLACK_FACTOR * _R * _R));
+    
+    // Initialize scratch space for Jaccard similarity calculations
+    size_t max_neighbor_batch = (size_t)std::ceil(defaults::GRAPH_SLACK_FACTOR * _R); // Single level neighbors
+    size_t max_init_batch = 1000; // Conservative estimate for initial candidates
+    size_t max_batch_size = std::max(max_neighbor_batch, max_init_batch);
+    
+    _jaccard_similarities_scratch.reserve(max_batch_size);
+    _init_penalties_scratch.reserve(max_batch_size);
+    _valid_init_candidates_scratch.reserve(max_batch_size);
+    _filtered_ids_scratch.reserve(max_batch_size);
 
     resize_for_new_L(std::max(search_l, indexing_l));
 }
@@ -62,6 +72,12 @@ template <typename T> void InMemQueryScratch<T>::clear()
     _expanded_nodes_set.clear();
     _expanded_nghrs_vec.clear();
     _occlude_list_output.clear();
+    
+    // Clear Jaccard similarity scratch vectors
+    _jaccard_similarities_scratch.clear();
+    _init_penalties_scratch.clear();
+    _valid_init_candidates_scratch.clear();
+    _filtered_ids_scratch.clear();
 }
 
 template <typename T> void InMemQueryScratch<T>::resize_for_new_L(uint32_t new_l)