Change BM INDICES from vector to fixed size to array [MOD-10160]

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

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,15 +204,15 @@ 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) {
         RunBatchedSearch_HNSW(st, correct, iter, num_batches, 10, total_res_num, 2, index_memory,
                               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++;

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);
 

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>;

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); }

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); }

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); }

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); }

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); }