Code refine

Author: rfsaliev

src/VecSim/algorithms/brute_force/brute_force.h

@@ -59,9 +59,6 @@ class BruteForceIndex : public VecSimIndexAbstract<DataType, DistType> {
 
     const RawDataContainer *getVectorsContainer() const { return this->vectors; }
 
-    const labelType getLabelByInternalId(idType internal_id) const {
-        return idToLabelMapping.at(internal_id);
-    }
     // Remove a specific vector that is stored under a label from the index by its internal id.
     virtual int deleteVectorById(labelType label, idType id) = 0;
     // Remove a vector and return a map between internal ids and the original internal ids of the

src/VecSim/algorithms/brute_force/brute_force_multi.h

@@ -95,13 +95,15 @@ class BruteForceIndex_Multi : public BruteForceIndex<DataType, DistType> {
         }
         return keys;
     };
+
     inline vecsim_stl::vector<idType> getElementIds(size_t label) const override {
         auto it = labelToIdsLookup.find(label);
         if (it == labelToIdsLookup.end()) {
             return vecsim_stl::vector<idType>{this->allocator}; // return an empty collection
         }
         return it->second;
     }
+
     inline vecsim_stl::abstract_priority_queue<DistType, labelType> *
     getNewMaxPriorityQueue() const override {
         return new (this->allocator)

src/VecSim/algorithms/hnsw/hnsw_tiered.h

@@ -571,7 +571,7 @@ void TieredHNSWIndex<DataType, DistType>::executeInsertJob(HNSWInsertJob *job) {
         // corresponding job id. Note that after calling deleteVectorById, the last id's label
         // shouldn't be available, since it is removed from the lookup.
         labelType last_vec_label =
-            this->frontendIndex->getLabelByInternalId(this->frontendIndex->indexSize() - 1);
+            this->frontendIndex->getVectorLabel(this->frontendIndex->indexSize() - 1);
         int deleted = this->frontendIndex->deleteVectorById(job->label, job->id);
         if (deleted && job->id != this->frontendIndex->indexSize()) {
             // If the vector removal caused a swap with the last id, update the relevant insert job.

src/VecSim/algorithms/svs/svs_tiered.h

@@ -371,7 +371,7 @@ class TieredSVSIndex : public VecSimTieredIndex<DataType, float> {
                 // calculating all the distances and access the BF index. We take the lock on this
                 // call.
                 auto cur_flat_results = [this, n_res]() {
-                    std::shared_lock<std::shared_mutex> flat_lock{index->flatIndexGuard};
+                    std::shared_lock flat_lock{index->flatIndexGuard};
                     return flat_iterator->getNextResults(n_res, BY_SCORE_THEN_ID);
                 }();
                 // This is also the only time `getNextResults` on the BF iterator can fail.
@@ -538,20 +538,20 @@ class TieredSVSIndex : public VecSimTieredIndex<DataType, float> {
         std::vector<DataType> vectors_to_move;
 
         { // lock frontendIndex from modifications
-            std::shared_lock<std::shared_mutex> frontend_lock{this->flatIndexGuard};
+            std::shared_lock flat_lock{this->flatIndexGuard};
 
             auto flat_index = this->GetFlatIndex();
-            auto frontend_index_size = this->frontendIndex->indexSize();
+            const auto frontend_index_size = this->frontendIndex->indexSize();
             const size_t dim = flat_index->getDim();
             labels_to_move.reserve(frontend_index_size);
             vectors_to_move.reserve(frontend_index_size * dim);
 
-            for (idType i = 0; i < frontend_index_size; ++i) {
+            for (idType i = 0; i < frontend_index_size; i++) {
                 labels_to_move.push_back(flat_index->getVectorLabel(i));
                 auto data = flat_index->getDataByInternalId(i);
                 vectors_to_move.insert(vectors_to_move.end(), data, data + dim);
             }
-            // restart journal from current frontend index state
+            // reset journal to the current frontend index state
             swaps_journal.clear();
         } // release frontend index
 
@@ -590,6 +590,8 @@ class TieredSVSIndex : public VecSimTieredIndex<DataType, float> {
                 }
             }
             // delete vectors from the frontend index in reverse order
+            // it increases the chance of avoiding swaps in the frontend index and performance
+            // improvement
             size_t deleted = 0;
             for (idType i = labels_to_move.size(); i > 0; --i) {
                 auto label = labels_to_move[i - 1];
@@ -679,13 +681,13 @@ class TieredSVSIndex : public VecSimTieredIndex<DataType, float> {
         // Async mode - add vector to the frontend index and schedule an update job if needed.
         if (!this->backendIndex->isMultiValue()) {
             // Remove vector from the backend index if it exists in case of non-MULTI.
-            std::scoped_lock lock(this->mainIndexGuard);
+            std::lock_guard lock(this->mainIndexGuard);
             ret -= svs_index->deleteVectors(&label, 1);
             // If main index is empty then update_threshold is trainingTriggerThreshold,
             // overwise it is 1.
         }
         {
-            std::shared_lock<std::shared_mutex> lock(this->mainIndexGuard);
+            std::shared_lock lock(this->mainIndexGuard);
             update_threshold = this->backendIndex->indexSize() == 0 ? this->trainingTriggerThreshold
                                                                     : this->updateTriggerThreshold;
         }
@@ -866,7 +868,7 @@ class TieredSVSIndex : public VecSimTieredIndex<DataType, float> {
     void runGC() override {
         TIERED_LOG(VecSimCommonStrings::LOG_VERBOSE_STRING,
                    "running asynchronous GC for tiered SVS index");
-        std::unique_lock<std::shared_mutex> backend_lock{this->mainIndexGuard};
+        std::lock_guard lock{this->mainIndexGuard};
         // VecSimIndexAbstract::runGC() is protected
         static_cast<VecSimIndexInterface *>(this->backendIndex)->runGC();
     }

tests/unit/test_svs_tiered.cpp

@@ -1095,7 +1095,7 @@ TYPED_TEST(SVSTieredIndexTest, parallelInsertSearch) {
     auto sz_f = tiered_index->GetFlatIndex()->indexSize();
     auto sz_b = tiered_index->GetBackendIndex()->indexSize();
     EXPECT_LE(sz_f, this->getUpdateThreshold());
-    EXPECT_EQ(sz_f + sz_b, n) << "Flat index size: " << sz_f << ", Backend index size: " << sz_b;
+    EXPECT_EQ(sz_f + sz_b, n);
     EXPECT_EQ(successful_searches, n);
     EXPECT_EQ(mock_thread_pool.jobQ.size(), 0);
 }