diff --git a/tests/benchmark/benchmarks.sh b/tests/benchmark/benchmarks.sh
index 76389ad89..03963bca3 100755
--- a/tests/benchmark/benchmarks.sh
+++ b/tests/benchmark/benchmarks.sh
@@ -83,7 +83,7 @@ elif [ "$BM_TYPE" = "bm-batch-iter-uint8-multi" ] ; then
 
 # Updated index benchmarks
 elif [ "$BM_TYPE" = "bm-updated-fp32-single" ] ; then
-    echo updated_index_single_fp32
+    echo bm_updated_index_single_fp32
 
 # Spaces benchmarks
 elif [ "$BM_TYPE" = "bm-spaces" ] ; then
diff --git a/tests/benchmark/bm_batch_iterator.h b/tests/benchmark/bm_batch_iterator.h
index 384566847..ea42fc6f4 100644
--- a/tests/benchmark/bm_batch_iterator.h
+++ b/tests/benchmark/bm_batch_iterator.h
@@ -44,8 +44,8 @@ void BM_BatchIterator<index_type_t>::RunBatchedSearch_HNSW(
     benchmark::State &st, std::atomic_int &correct, size_t iter, size_t num_batches,
     size_t batch_size, size_t &total_res_num, size_t batch_increase_factor, size_t index_memory,
     double &memory_delta) {
-    VecSimBatchIterator *batchIterator = VecSimBatchIterator_New(
-        INDICES.at(VecSimAlgo_HNSWLIB), QUERIES[iter % N_QUERIES].data(), nullptr);
+    VecSimBatchIterator *batchIterator =
+        VecSimBatchIterator_New(INDICES.at(INDEX_HNSW), QUERIES[iter % N_QUERIES].data(), nullptr);
     VecSimQueryReply *accumulated_results[num_batches];
     size_t batch_num = 0;
     total_res_num = 0;
@@ -62,13 +62,13 @@ void BM_BatchIterator<index_type_t>::RunBatchedSearch_HNSW(
     }
     st.PauseTiming();
     // Update the memory delta as a result of using the batch iterator.
-    size_t curr_memory = VecSimIndex_StatsInfo(INDICES.at(VecSimAlgo_HNSWLIB)).memory;
+    size_t curr_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_HNSW)).memory;
     memory_delta += (double)(curr_memory - index_memory);
     VecSimBatchIterator_Free(batchIterator);
 
     // Measure recall - compare every result that was collected in some batch to the BF results.
-    auto bf_results = VecSimIndex_TopKQuery(
-        INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(), total_res_num, nullptr, BY_SCORE);
+    auto bf_results = VecSimIndex_TopKQuery(INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(),
+                                            total_res_num, nullptr, BY_SCORE);
     for (size_t i = 0; i < batch_num; i++) {
         auto hnsw_results = accumulated_results[i];
         BM_VecSimGeneral::MeasureRecall(hnsw_results, bf_results, correct);
@@ -83,12 +83,12 @@ void BM_BatchIterator<index_type_t>::BF_FixedBatchSize(benchmark::State &st) {
     size_t batch_size = st.range(0);
     size_t num_batches = st.range(1);
     size_t iter = 0;
-    size_t index_memory = VecSimIndex_StatsInfo(INDICES[VecSimAlgo_BF]).memory;
+    size_t index_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_BF)).memory;
     double memory_delta = 0.0;
 
     for (auto _ : st) {
         VecSimBatchIterator *batchIterator = VecSimBatchIterator_New(
-            INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(), nullptr);
+            INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(), nullptr);
         size_t batches_counter = 0;
         while (VecSimBatchIterator_HasNext(batchIterator)) {
             VecSimQueryReply *res = VecSimBatchIterator_Next(batchIterator, batch_size, BY_ID);
@@ -98,7 +98,7 @@ void BM_BatchIterator<index_type_t>::BF_FixedBatchSize(benchmark::State &st) {
                 break;
             }
         }
-        size_t curr_memory = VecSimIndex_StatsInfo(INDICES[VecSimAlgo_BF]).memory;
+        size_t curr_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_BF)).memory;
         memory_delta += (double)(curr_memory - index_memory);
         VecSimBatchIterator_Free(batchIterator);
         iter++;
@@ -113,7 +113,7 @@ void BM_BatchIterator<index_type_t>::BF_VariableBatchSize(benchmark::State &st)
     size_t iter = 0;
     for (auto _ : st) {
         VecSimBatchIterator *batchIterator = VecSimBatchIterator_New(
-            INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(), nullptr);
+            INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(), nullptr);
         size_t batches_counter = 0;
         while (VecSimBatchIterator_HasNext(batchIterator)) {
             VecSimQueryReply *res = VecSimBatchIterator_Next(batchIterator, batch_size, BY_ID);
@@ -137,7 +137,7 @@ void BM_BatchIterator<index_type_t>::BF_BatchesToAdhocBF(benchmark::State &st) {
     size_t iter = 0;
     for (auto _ : st) {
         VecSimBatchIterator *batchIterator = VecSimBatchIterator_New(
-            INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(), nullptr);
+            INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(), nullptr);
         size_t batches_counter = 0;
         while (VecSimBatchIterator_HasNext(batchIterator)) {
             if (batches_counter == num_batches) {
@@ -151,7 +151,7 @@ void BM_BatchIterator<index_type_t>::BF_BatchesToAdhocBF(benchmark::State &st) {
         VecSimBatchIterator_Free(batchIterator);
         // Switch to ad-hoc BF
         for (size_t i = 0; i < N_VECTORS; i += step) {
-            VecSimIndex_GetDistanceFrom_Unsafe(INDICES[VecSimAlgo_BF], i,
+            VecSimIndex_GetDistanceFrom_Unsafe(INDICES.at(INDEX_BF), i,
                                                QUERIES[iter % N_QUERIES].data());
         }
         iter++;
@@ -166,7 +166,7 @@ void BM_BatchIterator<index_type_t>::HNSW_FixedBatchSize(benchmark::State &st) {
     size_t total_res_num = num_batches * batch_size;
     size_t iter = 0;
     std::atomic_int correct = 0;
-    size_t index_memory = VecSimIndex_StatsInfo(INDICES[VecSimAlgo_HNSWLIB]).memory;
+    size_t index_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_HNSW)).memory;
     double memory_delta = 0.0;
 
     for (auto _ : st) {
@@ -185,7 +185,7 @@ void BM_BatchIterator<index_type_t>::HNSW_VariableBatchSize(benchmark::State &st
     size_t total_res_num;
     size_t iter = 0;
     std::atomic_int correct = 0;
-    size_t index_memory = VecSimIndex_StatsInfo(INDICES[VecSimAlgo_HNSWLIB]).memory;
+    size_t index_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_HNSW)).memory;
     double memory_delta = 0.0;
 
     for (auto _ : st) {
@@ -204,7 +204,7 @@ void BM_BatchIterator<index_type_t>::HNSW_BatchesToAdhocBF(benchmark::State &st)
     size_t total_res_num;
     size_t iter = 0;
     std::atomic_int correct = 0;
-    size_t index_memory = VecSimIndex_StatsInfo(INDICES[VecSimAlgo_HNSWLIB]).memory;
+    size_t index_memory = VecSimIndex_StatsInfo(INDICES.at(INDEX_HNSW)).memory;
     double memory_delta = 0.0;
 
     for (auto _ : st) {
@@ -212,7 +212,7 @@ void BM_BatchIterator<index_type_t>::HNSW_BatchesToAdhocBF(benchmark::State &st)
                               memory_delta);
         // Switch to ad-hoc BF
         for (size_t i = 0; i < N_VECTORS; i += step) {
-            VecSimIndex_GetDistanceFrom_Unsafe(INDICES[VecSimAlgo_HNSWLIB], i,
+            VecSimIndex_GetDistanceFrom_Unsafe(INDICES.at(INDEX_HNSW), i,
                                                QUERIES[iter % N_QUERIES].data());
         }
         iter++;
diff --git a/tests/benchmark/bm_common.h b/tests/benchmark/bm_common.h
index 72c2cf4cd..261c612bc 100644
--- a/tests/benchmark/bm_common.h
+++ b/tests/benchmark/bm_common.h
@@ -47,13 +47,13 @@ void BM_VecSimCommon<index_type_t>::RunTopK_HNSW(benchmark::State &st, size_t ef
                                                  unsigned short index_offset, bool is_tiered) {
     HNSWRuntimeParams hnswRuntimeParams = {.efRuntime = ef};
     auto query_params = BM_VecSimGeneral::CreateQueryParams(hnswRuntimeParams);
-    auto hnsw_results = VecSimIndex_TopKQuery(
-        INDICES[is_tiered ? VecSimAlgo_TIERED : VecSimAlgo_HNSWLIB + index_offset],
-        QUERIES[iter % N_QUERIES].data(), k, &query_params, BY_SCORE);
+    auto hnsw_results =
+        VecSimIndex_TopKQuery(INDICES.at(is_tiered ? INDEX_TIERED_HNSW : INDEX_HNSW + index_offset),
+                              QUERIES[iter % N_QUERIES].data(), k, &query_params, BY_SCORE);
     st.PauseTiming();
 
     // Measure recall:
-    auto bf_results = VecSimIndex_TopKQuery(INDICES[VecSimAlgo_BF + index_offset],
+    auto bf_results = VecSimIndex_TopKQuery(INDICES.at(INDEX_BF + index_offset),
                                             QUERIES[iter % N_QUERIES].data(), k, nullptr, BY_SCORE);
 
     BM_VecSimGeneral::MeasureRecall(hnsw_results, bf_results, correct);
@@ -65,7 +65,7 @@ void BM_VecSimCommon<index_type_t>::RunTopK_HNSW(benchmark::State &st, size_t ef
 
 template <typename index_type_t>
 void BM_VecSimCommon<index_type_t>::Memory_FLAT(benchmark::State &st, unsigned short index_offset) {
-    auto index = INDICES[VecSimAlgo_BF + index_offset];
+    auto index = INDICES.at(INDEX_BF + index_offset);
     index->fitMemory();
 
     for (auto _ : st) {
@@ -75,7 +75,7 @@ void BM_VecSimCommon<index_type_t>::Memory_FLAT(benchmark::State &st, unsigned s
 }
 template <typename index_type_t>
 void BM_VecSimCommon<index_type_t>::Memory_HNSW(benchmark::State &st, unsigned short index_offset) {
-    auto index = INDICES[VecSimAlgo_HNSWLIB + index_offset];
+    auto index = INDICES.at(INDEX_HNSW + index_offset);
     index->fitMemory();
 
     for (auto _ : st) {
@@ -86,7 +86,7 @@ void BM_VecSimCommon<index_type_t>::Memory_HNSW(benchmark::State &st, unsigned s
 template <typename index_type_t>
 void BM_VecSimCommon<index_type_t>::Memory_Tiered(benchmark::State &st,
                                                   unsigned short index_offset) {
-    auto index = INDICES[VecSimAlgo_TIERED + index_offset];
+    auto index = INDICES.at(INDEX_TIERED_HNSW + index_offset);
     index->fitMemory();
     for (auto _ : st) {
         // Do nothing...
@@ -101,8 +101,8 @@ void BM_VecSimCommon<index_type_t>::TopK_BF(benchmark::State &st, unsigned short
     size_t k = st.range(0);
     size_t iter = 0;
     for (auto _ : st) {
-        VecSimIndex_TopKQuery(INDICES[VecSimAlgo_BF + index_offset],
-                              QUERIES[iter % N_QUERIES].data(), k, nullptr, BY_SCORE);
+        VecSimIndex_TopKQuery(INDICES.at(INDEX_BF + index_offset), QUERIES[iter % N_QUERIES].data(),
+                              k, nullptr, BY_SCORE);
         iter++;
     }
 }
@@ -127,7 +127,7 @@ void BM_VecSimCommon<index_type_t>::TopK_Tiered(benchmark::State &st, unsigned s
     std::atomic_int correct = 0;
     std::atomic_int iter = 0;
     auto *tiered_index =
-        dynamic_cast<TieredHNSWIndex<data_t, dist_t> *>(INDICES[VecSimAlgo_TIERED]);
+        dynamic_cast<TieredHNSWIndex<data_t, dist_t> *>(INDICES.at(INDEX_TIERED_HNSW));
     size_t total_iters = 50;
     VecSimQueryReply *all_results[total_iters];
 
@@ -136,9 +136,9 @@ void BM_VecSimCommon<index_type_t>::TopK_Tiered(benchmark::State &st, unsigned s
         HNSWRuntimeParams hnswRuntimeParams = {.efRuntime = search_job->ef};
         auto query_params = BM_VecSimGeneral::CreateQueryParams(hnswRuntimeParams);
         size_t cur_iter = search_job->iter;
-        auto hnsw_results =
-            VecSimIndex_TopKQuery(INDICES[VecSimAlgo_TIERED], QUERIES[cur_iter % N_QUERIES].data(),
-                                  search_job->k, &query_params, BY_SCORE);
+        auto hnsw_results = VecSimIndex_TopKQuery(INDICES.at(INDEX_TIERED_HNSW),
+                                                  QUERIES[cur_iter % N_QUERIES].data(),
+                                                  search_job->k, &query_params, BY_SCORE);
         search_job->all_results[cur_iter] = hnsw_results;
         delete job;
     };
@@ -156,7 +156,7 @@ void BM_VecSimCommon<index_type_t>::TopK_Tiered(benchmark::State &st, unsigned s
     // Measure recall
     for (iter = 0; iter < total_iters; iter++) {
         auto bf_results =
-            VecSimIndex_TopKQuery(INDICES[VecSimAlgo_BF + index_offset],
+            VecSimIndex_TopKQuery(INDICES.at(INDEX_BF + index_offset),
                                   QUERIES[iter % N_QUERIES].data(), k, nullptr, BY_SCORE);
         BM_VecSimGeneral::MeasureRecall(all_results[iter], bf_results, correct);
 
diff --git a/tests/benchmark/bm_definitions.h b/tests/benchmark/bm_definitions.h
index 34e987ce6..6e1e655f5 100644
--- a/tests/benchmark/bm_definitions.h
+++ b/tests/benchmark/bm_definitions.h
@@ -21,6 +21,29 @@ struct IndexType {
     typedef DistType dist_t;
 };
 
+enum IndexTypeIndex {
+    INDEX_BF = 0,
+    INDEX_BF_UPDATED,
+    INDEX_HNSW,
+    INDEX_HNSW_UPDATED,
+    INDEX_TIERED_HNSW,
+    INDEX_SVS,
+    INDEX_TIERED_SVS,
+    INDEX_SVS_QUANTIZED,
+    NUMBER_OF_INDEX_TYPES
+};
+
+enum IndexTypeFlags {
+    INDEX_TYPE_BF = 1 << 0,
+    INDEX_TYPE_BF_UPDATED = 1 << 1,
+    INDEX_TYPE_HNSW = 1 << 2,
+    INDEX_TYPE_HNSW_UPDATED = 1 << 3,
+    INDEX_TYPE_TIERED_HNSW = 1 << 4,
+    INDEX_TYPE_SVS = 1 << 5,
+    INDEX_TYPE_TIERED_SVS = 1 << 6,
+    INDEX_TYPE_SVS_QUANTIZED = 1 << 7
+};
+
 using fp32_index_t = IndexType<VecSimType_FLOAT32, float, float>;
 using fp64_index_t = IndexType<VecSimType_FLOAT64, double, double>;
 using bf16_index_t = IndexType<VecSimType_BFLOAT16, vecsim_types::bfloat16, float>;
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_bf16.h b/tests/benchmark/bm_initialization/bm_basics_initialize_bf16.h
index d92af1df4..d3e2d1a72 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_bf16.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_bf16.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, bf16_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), bf16_ind
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), bf16_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, bf16_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, bf16_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_fp16.h b/tests/benchmark/bm_initialization/bm_basics_initialize_fp16.h
index 314766874..d78536e49 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_fp16.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_fp16.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, fp16_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), fp16_ind
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), fp16_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, fp16_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, fp16_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_fp32.h b/tests/benchmark/bm_initialization/bm_basics_initialize_fp32.h
index 1c474c6eb..b1b378b2e 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_fp32.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_fp32.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, fp32_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), fp32_ind
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), fp32_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, fp32_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, fp32_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_fp64.h b/tests/benchmark/bm_initialization/bm_basics_initialize_fp64.h
index 78cc47dbd..541001293 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_fp64.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_fp64.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, fp64_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), fp64_ind
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), fp64_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, fp64_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, fp64_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_int8.h b/tests/benchmark/bm_initialization/bm_basics_initialize_int8.h
index ae03c1a8f..850fa7b3e 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_int8.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_int8.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, int8_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), int8_ind
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), int8_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, int8_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, int8_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_initialization/bm_basics_initialize_uint8.h b/tests/benchmark/bm_initialization/bm_basics_initialize_uint8.h
index b53ebee17..a727f3044 100644
--- a/tests/benchmark/bm_initialization/bm_basics_initialize_uint8.h
+++ b/tests/benchmark/bm_initialization/bm_basics_initialize_uint8.h
@@ -32,8 +32,8 @@ BENCHMARK_REGISTER_F(BM_VecSimCommon, BM_FUNC_NAME(Memory, Tiered))->Iterations(
 // AddLabel
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL, uint8_index_t)
 (benchmark::State &st) { AddLabel(st); }
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_BF);
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_HNSWLIB);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_BF);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_HNSW);
 
 // DeleteLabel Registration. Definition is placed in the .cpp file.
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, BF));
@@ -65,14 +65,14 @@ BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_FUNC_NAME(Range, HNSW), uint8_in
 REGISTER_Range_HNSW(BM_FUNC_NAME(Range, HNSW), uint8_index_t);
 
 // Tiered HNSW add/delete benchmarks
-REGISTER_AddLabel(BM_ADD_LABEL, VecSimAlgo_TIERED);
+REGISTER_AddLabel(BM_ADD_LABEL, INDEX_TIERED_HNSW);
 REGISTER_DeleteLabel(BM_FUNC_NAME(DeleteLabel, Tiered));
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC, uint8_index_t)
 (benchmark::State &st) { AddLabel_AsyncIngest(st); }
 BENCHMARK_REGISTER_F(BM_VecSimBasics, BM_ADD_LABEL_ASYNC)
-    ->UNIT_AND_ITERATIONS->Arg(VecSimAlgo_TIERED)
-    ->ArgName("VecSimAlgo_TIERED");
+    ->UNIT_AND_ITERATIONS->Arg(INDEX_TIERED_HNSW)
+    ->ArgName("INDEX_TIERED_HNSW");
 
 BENCHMARK_TEMPLATE_DEFINE_F(BM_VecSimBasics, BM_DELETE_LABEL_ASYNC, uint8_index_t)
 (benchmark::State &st) { DeleteLabel_AsyncRepair(st); }
diff --git a/tests/benchmark/bm_updated_index.h b/tests/benchmark/bm_updated_index.h
index 5ae9291dc..ad842da11 100644
--- a/tests/benchmark/bm_updated_index.h
+++ b/tests/benchmark/bm_updated_index.h
@@ -25,7 +25,7 @@
 template <typename index_type_t>
 class BM_VecSimUpdatedIndex : public BM_VecSimCommon<index_type_t> {
 public:
-    const static unsigned short updated_index_offset = 3;
+    const static unsigned short updated_index_offset = 1;
     // The constructor is called after we have already registered the tests residing in
     // BM_VecSimCommon, (and not in this class) so `ref_count` is not zero at the first time
     // BM_VecSimUpdatedIndex Ctor is called, and we can't rely on it to decide whether we should
@@ -47,8 +47,8 @@ class BM_VecSimUpdatedIndex : public BM_VecSimCommon<index_type_t> {
 
     ~BM_VecSimUpdatedIndex() {
         if (REF_COUNT == first_updatedBM_ref_count) {
-            VecSimIndex_Free(INDICES[VecSimAlgo_BF + updated_index_offset]);
-            VecSimIndex_Free(INDICES[VecSimAlgo_HNSWLIB + updated_index_offset]);
+            VecSimIndex_Free(INDICES.at(INDEX_BF + updated_index_offset));
+            VecSimIndex_Free(INDICES.at(INDEX_HNSW + updated_index_offset));
         }
     }
 
@@ -67,39 +67,43 @@ template <typename index_type_t>
 void BM_VecSimUpdatedIndex<index_type_t>::Initialize() {
 
     VecSimType type = index_type_t::get_index_type();
+    if (BM_VecSimGeneral::enabled_index_types & IndexTypeFlags::INDEX_TYPE_BF) {
+        BFParams bf_params = {
+            .type = type, .dim = DIM, .metric = VecSimMetric_Cosine, .multi = IS_MULTI};
+        // This index will be inserted after the basic indices at indices[VecSimAlfo_BF +
+        // update_offset]
+        INDICES.at(INDEX_BF + updated_index_offset) =
+            BM_VecSimIndex<index_type_t>::CreateNewIndex(bf_params);
 
-    BFParams bf_params = {
-        .type = type, .dim = DIM, .metric = VecSimMetric_Cosine, .multi = IS_MULTI};
-    // This index will be inserted after the basic indices at indices[VecSimAlfo_BF + update_offset]
-    INDICES.push_back(BM_VecSimIndex<index_type_t>::CreateNewIndex(bf_params));
-
-    // Initially, load all the vectors to the updated bf index (before we override it).
-    for (size_t i = 0; i < N_VECTORS; ++i) {
-        const char *blob = BM_VecSimIndex<index_type_t>::GetHNSWDataByInternalId(i);
-        size_t label = BM_VecSimIndex<index_type_t>::CastToHNSW(INDICES[VecSimAlgo_HNSWLIB])
-                           ->getExternalLabel(i);
-        VecSimIndex_AddVector(INDICES[VecSimAlgo_BF + updated_index_offset], blob, label);
+        // Initially, load all the vectors to the updated bf index (before we override it).
+        for (size_t i = 0; i < N_VECTORS; ++i) {
+            const char *blob = BM_VecSimIndex<index_type_t>::GetHNSWDataByInternalId(i);
+            size_t label = BM_VecSimIndex<index_type_t>::CastToHNSW(INDICES.at(INDEX_HNSW))
+                               ->getExternalLabel(i);
+            VecSimIndex_AddVector(INDICES.at(INDEX_BF + updated_index_offset), blob, label);
+        }
     }
 
-    // Generate index from file.
-    // This index will be inserted after the basic indices at indices[VecSimAlgo_HNSWLIB +
-    // update_offset]
-    INDICES.push_back(HNSWFactory::NewIndex(
-        BM_VecSimIndex<index_type_t>::AttachRootPath(updated_hnsw_index_file)));
+    if (BM_VecSimGeneral::enabled_index_types & IndexTypeFlags::INDEX_TYPE_HNSW) {
+        // Generate index from file.
+        // This index will be inserted after the basic indices at indices[VecSimAlgo_HNSWLIB +
+        // update_offset]
+        INDICES.at(INDEX_HNSW + updated_index_offset) = (HNSWFactory::NewIndex(
+            BM_VecSimIndex<index_type_t>::AttachRootPath(updated_hnsw_index_file)));
 
-    if (!BM_VecSimIndex<index_type_t>::CastToHNSW(
-             INDICES[VecSimAlgo_HNSWLIB + updated_index_offset])
-             ->checkIntegrity()
-             .valid_state) {
-        throw std::runtime_error("The loaded HNSW index is corrupted. Exiting...");
-    }
-    // Add the same vectors to the *updated* FLAT index (override the previous vectors).
-    for (size_t i = 0; i < N_VECTORS; ++i) {
-        const char *blob =
-            BM_VecSimIndex<index_type_t>::GetHNSWDataByInternalId(i, updated_index_offset);
-        size_t label = BM_VecSimIndex<index_type_t>::CastToHNSW(
-                           INDICES[VecSimAlgo_HNSWLIB + updated_index_offset])
-                           ->getExternalLabel(i);
-        VecSimIndex_AddVector(INDICES[VecSimAlgo_BF + updated_index_offset], blob, label);
+        if (!BM_VecSimIndex<index_type_t>::CastToHNSW(INDICES.at(INDEX_HNSW + updated_index_offset))
+                 ->checkIntegrity()
+                 .valid_state) {
+            throw std::runtime_error("The loaded HNSW index is corrupted. Exiting...");
+        }
+        // Add the same vectors to the *updated* FLAT index (override the previous vectors).
+        for (size_t i = 0; i < N_VECTORS; ++i) {
+            const char *blob =
+                BM_VecSimIndex<index_type_t>::GetHNSWDataByInternalId(i, updated_index_offset);
+            size_t label = BM_VecSimIndex<index_type_t>::CastToHNSW(
+                               INDICES.at(INDEX_HNSW + updated_index_offset))
+                               ->getExternalLabel(i);
+            VecSimIndex_AddVector(INDICES.at(INDEX_BF + updated_index_offset), blob, label);
+        }
     }
 }
diff --git a/tests/benchmark/bm_vecsim_basics.h b/tests/benchmark/bm_vecsim_basics.h
index f9e39c331..e10d9d74b 100644
--- a/tests/benchmark/bm_vecsim_basics.h
+++ b/tests/benchmark/bm_vecsim_basics.h
@@ -50,7 +50,7 @@ class BM_VecSimBasics : public BM_VecSimCommon<index_type_t> {
 template <typename index_type_t>
 void BM_VecSimBasics<index_type_t>::AddLabel(benchmark::State &st) {
 
-    auto index = INDICES[st.range(0)];
+    auto index = INDICES.at(st.range(0));
     size_t index_size = N_VECTORS;
     size_t initial_label_count = index->indexLabelCount();
 
@@ -88,7 +88,7 @@ void BM_VecSimBasics<index_type_t>::AddLabel(benchmark::State &st) {
     for (size_t label = initial_label_count; label < new_label_count; label++) {
         // If index is tiered HNSW, remove directly from the underline HNSW.
         VecSimIndex_DeleteVector(
-            INDICES[st.range(0) == VecSimAlgo_TIERED ? VecSimAlgo_HNSWLIB : st.range(0)], label);
+            INDICES.at(st.range(0) == INDEX_TIERED_HNSW ? INDEX_HNSW : st.range(0)), label);
     }
     assert(VecSimIndex_IndexSize(index) == N_VECTORS);
 }
@@ -96,7 +96,7 @@ void BM_VecSimBasics<index_type_t>::AddLabel(benchmark::State &st) {
 template <typename index_type_t>
 void BM_VecSimBasics<index_type_t>::AddLabel_AsyncIngest(benchmark::State &st) {
 
-    auto index = INDICES[st.range(0)];
+    auto index = INDICES.at(st.range(0));
     size_t index_size = N_VECTORS;
     size_t initial_label_count = index->indexLabelCount();
 
@@ -137,7 +137,7 @@ void BM_VecSimBasics<index_type_t>::AddLabel_AsyncIngest(benchmark::State &st) {
     size_t new_label_count = index->indexLabelCount();
     // Remove directly inplace from the underline HNSW index.
     for (size_t label_ = initial_label_count; label_ < new_label_count; label_++) {
-        VecSimIndex_DeleteVector(INDICES[VecSimAlgo_HNSWLIB], label_);
+        VecSimIndex_DeleteVector(INDICES.at(INDEX_HNSW), label_);
     }
 
     assert(VecSimIndex_IndexSize(index) == N_VECTORS);
@@ -195,7 +195,7 @@ void BM_VecSimBasics<index_type_t>::DeleteLabel_AsyncRepair(benchmark::State &st
     // Remove a different vector in every execution.
     size_t label_to_remove = 0;
     auto *tiered_index =
-        dynamic_cast<TieredHNSWIndex<data_t, dist_t> *>(INDICES[VecSimAlgo_TIERED]);
+        dynamic_cast<TieredHNSWIndex<data_t, dist_t> *>(INDICES.at(INDEX_TIERED_HNSW));
 
     tiered_index->fitMemory();
     double memory_before = tiered_index->getAllocationSize();
@@ -257,7 +257,7 @@ void BM_VecSimBasics<index_type_t>::Range_BF(benchmark::State &st) {
     size_t total_res = 0;
 
     for (auto _ : st) {
-        auto res = VecSimIndex_RangeQuery(INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(),
+        auto res = VecSimIndex_RangeQuery(INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(),
                                           radius, nullptr, BY_ID);
         total_res += VecSimQueryReply_Len(res);
         iter++;
@@ -276,15 +276,14 @@ void BM_VecSimBasics<index_type_t>::Range_HNSW(benchmark::State &st) {
     auto query_params = BM_VecSimGeneral::CreateQueryParams(hnswRuntimeParams);
 
     for (auto _ : st) {
-        auto hnsw_results =
-            VecSimIndex_RangeQuery(INDICES[VecSimAlgo_HNSWLIB], QUERIES[iter % N_QUERIES].data(),
-                                   radius, &query_params, BY_ID);
+        auto hnsw_results = VecSimIndex_RangeQuery(
+            INDICES.at(INDEX_HNSW), QUERIES[iter % N_QUERIES].data(), radius, &query_params, BY_ID);
         st.PauseTiming();
         total_res += VecSimQueryReply_Len(hnsw_results);
 
         // Measure recall:
         auto bf_results = VecSimIndex_RangeQuery(
-            INDICES[VecSimAlgo_BF], QUERIES[iter % N_QUERIES].data(), radius, nullptr, BY_ID);
+            INDICES.at(INDEX_BF), QUERIES[iter % N_QUERIES].data(), radius, nullptr, BY_ID);
         total_res_bf += VecSimQueryReply_Len(bf_results);
 
         VecSimQueryReply_Free(bf_results);
diff --git a/tests/benchmark/bm_vecsim_general.h b/tests/benchmark/bm_vecsim_general.h
index 11a58671f..2f3ed021b 100644
--- a/tests/benchmark/bm_vecsim_general.h
+++ b/tests/benchmark/bm_vecsim_general.h
@@ -43,6 +43,7 @@ class BM_VecSimGeneral : public benchmark::Fixture {
     static size_t n_vectors;
 
     static bool is_multi;
+    static uint32_t enabled_index_types;
     static tieredIndexMock mock_thread_pool;
 
     static size_t n_queries;
diff --git a/tests/benchmark/bm_vecsim_index.h b/tests/benchmark/bm_vecsim_index.h
index 93252db22..fde0a6a2b 100644
--- a/tests/benchmark/bm_vecsim_index.h
+++ b/tests/benchmark/bm_vecsim_index.h
@@ -24,7 +24,7 @@ class BM_VecSimIndex : public BM_VecSimGeneral {
 
     static std::vector<std::vector<data_t>> queries;
 
-    static std::vector<VecSimIndex *> indices;
+    static std::array<VecSimIndex *, IndexTypeIndex::NUMBER_OF_INDEX_TYPES> indices;
 
     BM_VecSimIndex();
 
@@ -35,7 +35,7 @@ class BM_VecSimIndex : public BM_VecSimGeneral {
         return dynamic_cast<HNSWIndex<data_t, dist_t> *>(index);
     }
     static inline const char *GetHNSWDataByInternalId(size_t id, unsigned short index_offset = 0) {
-        return CastToHNSW(indices[VecSimAlgo_HNSWLIB + index_offset])->getDataByInternalId(id);
+        return CastToHNSW(indices[INDEX_HNSW + index_offset])->getDataByInternalId(id);
     }
 
 private:
@@ -67,28 +67,28 @@ template <>
 std::vector<std::vector<uint8_t>> BM_VecSimIndex<uint8_index_t>::queries{};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<fp32_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<fp32_index_t>::indices{nullptr};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<fp64_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<fp64_index_t>::indices{nullptr};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<bf16_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<bf16_index_t>::indices{nullptr};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<fp16_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<fp16_index_t>::indices{nullptr};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<int8_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<int8_index_t>::indices{nullptr};
 
 template <>
-std::vector<VecSimIndex *> BM_VecSimIndex<uint8_index_t>::indices{};
+std::array<VecSimIndex *, NUMBER_OF_INDEX_TYPES> BM_VecSimIndex<uint8_index_t>::indices{nullptr};
 
 template <typename index_type_t>
 BM_VecSimIndex<index_type_t>::~BM_VecSimIndex() {
     ref_count--;
     if (ref_count == 0) {
-        VecSimIndex_Free(indices[VecSimAlgo_BF]);
+        VecSimIndex_Free(indices[INDEX_BF]);
         /* Note that VecSimAlgo_HNSW will be destroyed as part of the tiered index release, and
          * the VecSimAlgo_Tiered index ptr will be deleted when the mock thread pool ctx object is
          * destroyed.
@@ -112,45 +112,51 @@ void BM_VecSimIndex<index_type_t>::Initialize() {
     // dim, block_size, M, EF_C, n_vectors, is_multi, n_queries, hnsw_index_file and
     // test_queries_file are BM_VecSimGeneral static data members that are defined for a specific
     // index type benchmarks.
-    BFParams bf_params = {.type = type,
-                          .dim = dim,
-                          .metric = VecSimMetric_Cosine,
-                          .multi = is_multi,
-                          .blockSize = block_size};
-
-    indices.push_back(CreateNewIndex(bf_params));
-
-    // Initialize and load HNSW index for DBPedia data set.
-    indices.push_back(HNSWFactory::NewIndex(AttachRootPath(hnsw_index_file)));
-
-    auto *hnsw_index = CastToHNSW(indices[VecSimAlgo_HNSWLIB]);
-    size_t ef_r = 10;
-    hnsw_index->setEf(ef_r);
-
-    // Create tiered index from the loaded HNSW index.
-    auto &mock_thread_pool = BM_VecSimGeneral::mock_thread_pool;
-    TieredIndexParams tiered_params = {.jobQueue = &BM_VecSimGeneral::mock_thread_pool.jobQ,
-                                       .jobQueueCtx = mock_thread_pool.ctx,
-                                       .submitCb = tieredIndexMock::submit_callback,
-                                       .flatBufferLimit = block_size,
-                                       .primaryIndexParams = nullptr,
-                                       .specificParams = {TieredHNSWParams{.swapJobThreshold = 0}}};
-
-    auto *tiered_index =
-        TieredFactory::TieredHNSWFactory::NewIndex<data_t, dist_t>(&tiered_params, hnsw_index);
-    mock_thread_pool.ctx->index_strong_ref.reset(tiered_index);
-
-    indices.push_back(tiered_index);
-
-    // Launch the BG threads loop that takes jobs from the queue and executes them.
-    mock_thread_pool.init_threads();
-
-    // Add the same vectors to Flat index.
-    for (size_t i = 0; i < n_vectors; ++i) {
-        const char *blob = GetHNSWDataByInternalId(i);
-        // Fot multi value indices, the internal id is not necessarily equal the label.
-        size_t label = CastToHNSW(indices[VecSimAlgo_HNSWLIB])->getExternalLabel(i);
-        VecSimIndex_AddVector(indices[VecSimAlgo_BF], blob, label);
+    if (enabled_index_types & IndexTypeFlags::INDEX_TYPE_BF) {
+        BFParams bf_params = {.type = type,
+                              .dim = dim,
+                              .metric = VecSimMetric_Cosine,
+                              .multi = is_multi,
+                              .blockSize = block_size};
+        indices[INDEX_BF] = CreateNewIndex(bf_params);
+    }
+    if (enabled_index_types & IndexTypeFlags::INDEX_TYPE_HNSW) {
+        // Initialize and load HNSW index for DBPedia data set.
+        indices[INDEX_HNSW] = HNSWFactory::NewIndex(AttachRootPath(hnsw_index_file));
+
+        auto *hnsw_index = CastToHNSW(indices[INDEX_HNSW]);
+        size_t ef_r = 10;
+        hnsw_index->setEf(ef_r);
+        // Create tiered index from the loaded HNSW index.
+        if (enabled_index_types & IndexTypeFlags::INDEX_TYPE_TIERED_HNSW) {
+            auto &mock_thread_pool = BM_VecSimGeneral::mock_thread_pool;
+            TieredIndexParams tiered_params = {
+                .jobQueue = &BM_VecSimGeneral::mock_thread_pool.jobQ,
+                .jobQueueCtx = mock_thread_pool.ctx,
+                .submitCb = tieredIndexMock::submit_callback,
+                .flatBufferLimit = block_size,
+                .primaryIndexParams = nullptr,
+                .specificParams = {TieredHNSWParams{.swapJobThreshold = 0}}};
+
+            auto *tiered_index = TieredFactory::TieredHNSWFactory::NewIndex<data_t, dist_t>(
+                &tiered_params, hnsw_index);
+            mock_thread_pool.ctx->index_strong_ref.reset(tiered_index);
+
+            indices[INDEX_TIERED_HNSW] = tiered_index;
+
+            // Launch the BG threads loop that takes jobs from the queue and executes them.
+            mock_thread_pool.init_threads();
+        }
+    }
+
+    if (indices[INDEX_HNSW] && indices[INDEX_BF]) {
+        // Add the same vectors to Flat index.
+        for (size_t i = 0; i < n_vectors; ++i) {
+            const char *blob = GetHNSWDataByInternalId(i);
+            // Fot multi value indices, the internal id is not necessarily equal the label.
+            size_t label = CastToHNSW(indices[INDEX_HNSW])->getExternalLabel(i);
+            VecSimIndex_AddVector(indices[INDEX_BF], blob, label);
+        }
     }
 
     // Load the test query vectors form file. Index file path is relative to repository root dir.
diff --git a/tests/benchmark/run_files/bm_basics_multi_bf16.cpp b/tests/benchmark/run_files/bm_basics_multi_bf16.cpp
index bfc570221..0b3228e80 100644
--- a/tests/benchmark/run_files/bm_basics_multi_bf16.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_bf16.cpp
@@ -8,6 +8,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1111025;
@@ -27,11 +30,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel_Async, Multi)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), bf16_index_t, BruteForceIndex_Multi,
-                    vecsim_types::bfloat16, float, VecSimAlgo_BF)
+                    vecsim_types::bfloat16, float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), bf16_index_t, HNSWIndex_Multi,
-                    vecsim_types::bfloat16, float, VecSimAlgo_HNSWLIB)
+                    vecsim_types::bfloat16, float, INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), bf16_index_t, TieredHNSWIndex,
-                    vecsim_types::bfloat16, float, VecSimAlgo_TIERED)
+                    vecsim_types::bfloat16, float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_bf16.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_multi_fp16.cpp b/tests/benchmark/run_files/bm_basics_multi_fp16.cpp
index 2113f3071..990f08107 100644
--- a/tests/benchmark/run_files/bm_basics_multi_fp16.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_fp16.cpp
@@ -8,6 +8,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1111025;
@@ -27,11 +30,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel_Async, Multi)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp16_index_t, BruteForceIndex_Multi,
-                    vecsim_types::float16, float, VecSimAlgo_BF)
+                    vecsim_types::float16, float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp16_index_t, HNSWIndex_Multi,
-                    vecsim_types::float16, float, VecSimAlgo_HNSWLIB)
+                    vecsim_types::float16, float, INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp16_index_t, TieredHNSWIndex,
-                    vecsim_types::float16, float, VecSimAlgo_TIERED)
+                    vecsim_types::float16, float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp16.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_multi_fp32.cpp b/tests/benchmark/run_files/bm_basics_multi_fp32.cpp
index 2c79baf18..148b661e2 100644
--- a/tests/benchmark/run_files/bm_basics_multi_fp32.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_fp32.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1111025;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel_Async, Multi)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp32_index_t, BruteForceIndex_Multi, float,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp32_index_t, HNSWIndex_Multi, float, float,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp32_index_t, TieredHNSWIndex, float, float,
-                    VecSimAlgo_TIERED)
+                    INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp32.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_multi_fp64.cpp b/tests/benchmark/run_files/bm_basics_multi_fp64.cpp
index 9af1e9301..0266344dd 100644
--- a/tests/benchmark/run_files/bm_basics_multi_fp64.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_fp64.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1111025;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel_Async, Multi)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp64_index_t, BruteForceIndex_Multi, double,
-                    double, VecSimAlgo_BF)
+                    double, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp64_index_t, HNSWIndex_Multi, double, double,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp64_index_t, TieredHNSWIndex, double,
-                    double, VecSimAlgo_TIERED)
+                    double, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp64.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_multi_int8.cpp b/tests/benchmark/run_files/bm_basics_multi_int8.cpp
index 7ede953a4..08893ae40 100644
--- a/tests/benchmark/run_files/bm_basics_multi_int8.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_int8.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       DeleteLabel_Async_Multi
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), int8_index_t, BruteForceIndex_Multi, int8_t,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), int8_index_t, HNSWIndex_Multi, int8_t, float,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), int8_index_t, TieredHNSWIndex, int8_t, float,
-                    VecSimAlgo_TIERED)
+                    INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_int8.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_multi_uint8.cpp b/tests/benchmark/run_files/bm_basics_multi_uint8.cpp
index 22930ad1d..eff037a4e 100644
--- a/tests/benchmark/run_files/bm_basics_multi_uint8.cpp
+++ b/tests/benchmark/run_files/bm_basics_multi_uint8.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       DeleteLabel_Async_Multi
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), uint8_index_t, BruteForceIndex_Multi, uint8_t,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), uint8_index_t, HNSWIndex_Multi, uint8_t, float,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), uint8_index_t, TieredHNSWIndex, uint8_t,
-                    float, VecSimAlgo_TIERED)
+                    float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_uint8.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_bf16.cpp b/tests/benchmark/run_files/bm_basics_single_bf16.cpp
index a94e7a27e..4f123bda3 100644
--- a/tests/benchmark/run_files/bm_basics_single_bf16.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_bf16.cpp
@@ -8,6 +8,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -27,10 +30,10 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel, Async, Single)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), bf16_index_t, BruteForceIndex_Single,
-                    vecsim_types::bfloat16, float, VecSimAlgo_BF)
+                    vecsim_types::bfloat16, float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), bf16_index_t, HNSWIndex_Single,
-                    vecsim_types::bfloat16, float, VecSimAlgo_HNSWLIB)
+                    vecsim_types::bfloat16, float, INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), bf16_index_t, TieredHNSWIndex,
-                    vecsim_types::bfloat16, float, VecSimAlgo_TIERED)
+                    vecsim_types::bfloat16, float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_bf16.h"
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_fp16.cpp b/tests/benchmark/run_files/bm_basics_single_fp16.cpp
index a158d5a89..1d1e49d92 100644
--- a/tests/benchmark/run_files/bm_basics_single_fp16.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_fp16.cpp
@@ -8,6 +8,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -27,10 +30,10 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel, Async, Single)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp16_index_t, BruteForceIndex_Single,
-                    vecsim_types::float16, float, VecSimAlgo_BF)
+                    vecsim_types::float16, float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp16_index_t, HNSWIndex_Single,
-                    vecsim_types::float16, float, VecSimAlgo_HNSWLIB)
+                    vecsim_types::float16, float, INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp16_index_t, TieredHNSWIndex,
-                    vecsim_types::float16, float, VecSimAlgo_TIERED)
+                    vecsim_types::float16, float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp16.h"
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_fp32.cpp b/tests/benchmark/run_files/bm_basics_single_fp32.cpp
index 620845d54..141c701ab 100644
--- a/tests/benchmark/run_files/bm_basics_single_fp32.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_fp32.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,10 +29,10 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel_Async, Single)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp32_index_t, BruteForceIndex_Single, float,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp32_index_t, HNSWIndex_Single, float, float,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp32_index_t, TieredHNSWIndex, float, float,
-                    VecSimAlgo_TIERED)
+                    INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp32.h"
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_fp64.cpp b/tests/benchmark/run_files/bm_basics_single_fp64.cpp
index 47ea1362d..fbaa8449e 100644
--- a/tests/benchmark/run_files/bm_basics_single_fp64.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_fp64.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,10 +29,10 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel, Async, Single)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), fp64_index_t, BruteForceIndex_Single, double,
-                    double, VecSimAlgo_BF)
+                    double, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), fp64_index_t, HNSWIndex_Single, double, double,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), fp64_index_t, TieredHNSWIndex, double,
-                    double, VecSimAlgo_TIERED)
+                    double, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_fp64.h"
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_int8.cpp b/tests/benchmark/run_files/bm_basics_single_int8.cpp
index 919b5efa3..708d37136 100644
--- a/tests/benchmark/run_files/bm_basics_single_int8.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_int8.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       CONCAT_WITH_UNDERSCORE_ARCH(DeleteLabel, Async, Single)
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), int8_index_t, BruteForceIndex_Single, int8_t,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), int8_index_t, HNSWIndex_Single, int8_t, float,
-                    VecSimAlgo_HNSWLIB)
+                    INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), int8_index_t, TieredHNSWIndex, int8_t, float,
-                    VecSimAlgo_TIERED)
+                    INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_int8.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_basics_single_uint8.cpp b/tests/benchmark/run_files/bm_basics_single_uint8.cpp
index 1d9011ba1..8eb239da6 100644
--- a/tests/benchmark/run_files/bm_basics_single_uint8.cpp
+++ b/tests/benchmark/run_files/bm_basics_single_uint8.cpp
@@ -7,6 +7,9 @@
 ***************************************/
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
@@ -26,11 +29,11 @@ const char *BM_VecSimGeneral::test_queries_file =
 #define BM_DELETE_LABEL_ASYNC       DeleteLabel_Async_Single
 
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, BF), uint8_index_t, BruteForceIndex_Single, uint8_t,
-                    float, VecSimAlgo_BF)
+                    float, INDEX_BF)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, HNSW), uint8_index_t, HNSWIndex_Single, uint8_t,
-                    float, VecSimAlgo_HNSWLIB)
+                    float, INDEX_HNSW)
 DEFINE_DELETE_LABEL(BM_FUNC_NAME(DeleteLabel, Tiered), uint8_index_t, TieredHNSWIndex, uint8_t,
-                    float, VecSimAlgo_TIERED)
+                    float, INDEX_TIERED_HNSW)
 #include "benchmark/bm_initialization/bm_basics_initialize_uint8.h"
 
 BENCHMARK_MAIN();
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_bf16.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_bf16.cpp
index ccfd5686e..64d59a320 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_bf16.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_bf16.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1111025;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_fp16.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_fp16.cpp
index 7a73a6d10..6c936b7db 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_fp16.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_fp16.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1111025;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_fp32.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_fp32.cpp
index 3c3a22509..119c2ee35 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_fp32.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_fp32.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1111025;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_fp64.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_fp64.cpp
index a75635359..0fb4b4df9 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_fp64.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_fp64.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1111025;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_int8.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_int8.cpp
index 6e7247b5a..0c44908be 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_int8.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_int8.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_multi_uint8.cpp b/tests/benchmark/run_files/bm_batch_iterator_multi_uint8.cpp
index bea3cda8e..5b3ffb0b6 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_multi_uint8.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_multi_uint8.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = true;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_bf16.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_bf16.cpp
index 351f89167..b86998a03 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_bf16.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_bf16.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_fp16.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_fp16.cpp
index 35ca175ff..ac75eea97 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_fp16.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_fp16.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_fp32.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_fp32.cpp
index b45613e23..64a4cff8f 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_fp32.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_fp32.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_fp64.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_fp64.cpp
index 8ef5cd22f..8d94b0d25 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_fp64.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_fp64.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 // Global benchmark data
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_int8.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_int8.cpp
index a9c7f8a97..62e027133 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_int8.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_int8.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_batch_iterator_single_uint8.cpp b/tests/benchmark/run_files/bm_batch_iterator_single_uint8.cpp
index b0890b51f..f3140e506 100644
--- a/tests/benchmark/run_files/bm_batch_iterator_single_uint8.cpp
+++ b/tests/benchmark/run_files/bm_batch_iterator_single_uint8.cpp
@@ -1,6 +1,9 @@
 #include "benchmark/bm_batch_iterator.h"
 
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types = IndexTypeFlags::INDEX_TYPE_BF |
+                                                 IndexTypeFlags::INDEX_TYPE_HNSW |
+                                                 IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::n_vectors = 1000000;
diff --git a/tests/benchmark/run_files/bm_updated_index_single_fp32.cpp b/tests/benchmark/run_files/bm_updated_index_single_fp32.cpp
index e5289912b..877675f24 100644
--- a/tests/benchmark/run_files/bm_updated_index_single_fp32.cpp
+++ b/tests/benchmark/run_files/bm_updated_index_single_fp32.cpp
@@ -4,6 +4,9 @@
   Basic tests for updated single value index.
 ***************************************/
 bool BM_VecSimGeneral::is_multi = false;
+uint32_t BM_VecSimGeneral::enabled_index_types =
+    IndexTypeFlags::INDEX_TYPE_BF | IndexTypeFlags::INDEX_TYPE_HNSW |
+    IndexTypeFlags::INDEX_TYPE_HNSW_UPDATED | IndexTypeFlags::INDEX_TYPE_TIERED_HNSW;
 
 size_t BM_VecSimGeneral::n_queries = 10000;
 size_t BM_VecSimGeneral::dim = 768;