vectordb-bench 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

vectordb_bench/backend/clients/mongodb/mongodb.py

@@ -0,0 +1,200 @@
+import logging
+import time
+from contextlib import contextmanager
+
+from pymongo import MongoClient
+from pymongo.operations import SearchIndexModel
+
+from ..api import VectorDB
+from .config import MongoDBIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class MongoDBError(Exception):
+    """Custom exception class for MongoDB client errors."""
+
+
+class MongoDB(VectorDB):
+    def __init__(
+        self,
+        dim: int,
+        db_config: dict,
+        db_case_config: MongoDBIndexConfig,
+        collection_name: str = "vdb_bench_collection",
+        id_field: str = "id",
+        vector_field: str = "vector",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.dim = dim
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.collection_name = collection_name
+        self.id_field = id_field
+        self.vector_field = vector_field
+        self.drop_old = drop_old
+
+        # Update index dimensions
+        index_params = self.case_config.index_param()
+        log.info(f"index params: {index_params}")
+        index_params["fields"][0]["numDimensions"] = dim
+        self.index_params = index_params
+
+        # Initialize  - they'll also be set in init()
+        uri = self.db_config["connection_string"]
+        self.client = MongoClient(uri)
+        self.db = self.client[self.db_config["database"]]
+        self.collection = self.db[self.collection_name]
+        if self.drop_old and self.collection_name in self.db.list_collection_names():
+            log.info(f"MongoDB client dropping old collection: {self.collection_name}")
+            self.db.drop_collection(self.collection_name)
+        self.client = None
+        self.db = None
+        self.collection = None
+
+    @contextmanager
+    def init(self):
+        """Initialize MongoDB client and cleanup when done"""
+        try:
+            uri = self.db_config["connection_string"]
+            self.client = MongoClient(uri)
+            self.db = self.client[self.db_config["database"]]
+            self.collection = self.db[self.collection_name]
+
+            yield
+        finally:
+            if self.client is not None:
+                self.client.close()
+                self.client = None
+                self.db = None
+                self.collection = None
+
+    def _create_index(self) -> None:
+        """Create vector search index"""
+        index_name = "vector_index"
+        index_params = self.index_params
+        log.info(f"index params {index_params}")
+        # drop index if already exists
+        if self.collection.list_indexes():
+            all_indexes = self.collection.list_search_indexes()
+            if any(idx.get("name") == index_name for idx in all_indexes):
+                log.info(f"Drop index: {index_name}")
+                try:
+                    self.collection.drop_search_index(index_name)
+                    while True:
+                        indices = list(self.collection.list_search_indexes())
+                        indices = [idx for idx in indices if idx["name"] == index_name]
+                        log.debug(f"index status {indices}")
+                        if len(indices) == 0:
+                            break
+                        log.info(f"index deleting {indices}")
+                except Exception:
+                    log.exception(f"Error dropping index {index_name}")
+        try:
+            # Create vector search index
+            search_index = SearchIndexModel(definition=index_params, name=index_name, type="vectorSearch")
+
+            self.collection.create_search_index(search_index)
+            log.info(f"Created vector search index: {index_name}")
+            self._wait_for_index_ready(index_name)
+
+            # Create regular index on id field for faster lookups
+            self.collection.create_index(self.id_field)
+            log.info(f"Created index on {self.id_field} field")
+
+        except Exception:
+            log.exception(f"Error creating index {index_name}")
+            raise
+
+    def _wait_for_index_ready(self, index_name: str, check_interval: int = 5) -> None:
+        """Wait for index to be ready"""
+        while True:
+            indices = list(self.collection.list_search_indexes())
+            log.debug(f"index status {indices}")
+            if indices and any(idx.get("name") == index_name and idx.get("queryable") for idx in indices):
+                break
+            for idx in indices:
+                if idx.get("name") == index_name and idx.get("status") == "FAILED":
+                    error_msg = f"Index {index_name} failed to build"
+                    raise MongoDBError(error_msg)
+
+            time.sleep(check_interval)
+        log.info(f"Index {index_name} is ready")
+
+    def need_normalize_cosine(self) -> bool:
+        return False
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+        **kwargs,
+    ) -> (int, Exception | None):
+        """Insert embeddings into MongoDB"""
+
+        # Prepare documents in bulk
+        documents = [
+            {
+                self.id_field: id_,
+                self.vector_field: embedding,
+            }
+            for id_, embedding in zip(metadata, embeddings, strict=False)
+        ]
+
+        # Use ordered=False for better insert performance
+        try:
+            self.collection.insert_many(documents, ordered=False)
+        except Exception as e:
+            return 0, e
+        return len(documents), None
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+        **kwargs,
+    ) -> list[int]:
+        """Search for similar vectors"""
+        search_params = self.case_config.search_param()
+
+        vector_search = {"queryVector": query, "index": "vector_index", "path": self.vector_field, "limit": k}
+
+        # Add exact search parameter if specified
+        if search_params["exact"]:
+            vector_search["exact"] = True
+        else:
+            # Set numCandidates based on k value and data size
+            # For 50K dataset, use higher multiplier for better recall
+            num_candidates = min(10000, k * search_params["num_candidates_ratio"])
+            vector_search["numCandidates"] = num_candidates
+
+        # Add filter if specified
+        if filters:
+            log.info(f"Applying filter: {filters}")
+            vector_search["filter"] = {
+                "id": {"gte": filters["id"]},
+            }
+        pipeline = [
+            {"$vectorSearch": vector_search},
+            {
+                "$project": {
+                    "_id": 0,
+                    self.id_field: 1,
+                    "score": {"$meta": "vectorSearchScore"},  # Include similarity score
+                }
+            },
+        ]
+
+        results = list(self.collection.aggregate(pipeline))
+        return [doc[self.id_field] for doc in results]
+
+    def optimize(self, data_size: int | None = None) -> None:
+        """MongoDB vector search indexes are self-optimizing"""
+        log.info("optimize for search")
+        self._create_index()
+        self._wait_for_index_ready("vector_index")
+
+    def ready_to_load(self) -> None:
+        """MongoDB is always ready to load"""

vectordb_bench/backend/clients/pgdiskann/pgdiskann.py

@@ -143,10 +143,7 @@ class PgDiskANN(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):

vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py

@@ -153,10 +153,7 @@ class PgVectoRS(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -200,10 +197,7 @@ class PgVectoRS(VectorDB):
             self.cursor.execute(index_create_sql)
             self.conn.commit()
         except Exception as e:
-            log.warning(
-                f"Failed to create pgvecto.rs index {self._index_name} \
-                    at table {self.table_name} error: {e}",
-            )
+            log.warning(f"Failed to create pgvecto.rs index {self._index_name} at table {self.table_name} error: {e}")
             raise e from None
 
     def _create_table(self, dim: int):
@@ -258,9 +252,7 @@ class PgVectoRS(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -228,10 +228,7 @@ class PgVector(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -415,9 +412,7 @@ class PgVector(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py

@@ -143,10 +143,7 @@ class PgVectorScale(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -255,9 +252,7 @@ class PgVectorScale(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pinecone/pinecone.py

@@ -59,10 +59,7 @@ class Pinecone(VectorDB):
         self.index = pc.Index(self.index_name)
         yield
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py

@@ -62,10 +62,7 @@ class QdrantCloud(VectorDB):
         self.qdrant_client = None
         del self.qdrant_client
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.qdrant_client, "Please call self.init() before"
         # wait for vectors to be fully indexed
         try:
@@ -76,8 +73,8 @@ class QdrantCloud(VectorDB):
                     continue
                 if info.status == CollectionStatus.GREEN:
                     msg = (
-                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, ",
-                        f"Collection status: {info.indexed_vectors_count}",
+                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, "
+                        f"Collection status: {info.indexed_vectors_count}"
                     )
                     log.info(msg)
                     return

vectordb_bench/backend/clients/redis/redis.py

@@ -95,10 +95,7 @@ class Redis(VectorDB):
     def ready_to_search(self) -> bool:
         """Check if the database is ready to search."""
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/test/cli.py

@@ -17,7 +17,7 @@ class TestTypedDict(CommonTypedDict): ...
 @click_parameter_decorators_from_typed_dict(TestTypedDict)
 def Test(**parameters: Unpack[TestTypedDict]):
     run(
-        db=DB.NewClient,
+        db=DB.Test,
         db_config=TestConfig(db_label=parameters["db_label"]),
         db_case_config=TestIndexConfig(),
         **parameters,

vectordb_bench/backend/clients/test/test.py

@@ -33,10 +33,7 @@ class Test(VectorDB):
 
         yield
 
-    def ready_to_load(self) -> bool:
-        return True
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py

@@ -67,10 +67,7 @@ class WeaviateCloud(VectorDB):
         self.client = None
         del self.client
 
-    def ready_to_load(self):
-        """Should call insert first, do nothing"""
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.client.schema.exists(self.collection_name)
         self.client.schema.update_config(
             self.collection_name,

vectordb_bench/backend/data_source.py

@@ -63,9 +63,7 @@ class AliyunOSSReader(DatasetReader):
         # check size equal
         remote_size, local_size = info.content_length, local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True
@@ -89,9 +87,7 @@ class AliyunOSSReader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append((remote_file, local_file))
 
         if len(downloads) == 0:
@@ -135,9 +131,7 @@ class AwsS3Reader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append(remote_file)
 
         if len(downloads) == 0:
@@ -157,9 +151,7 @@ class AwsS3Reader(DatasetReader):
         # check size equal
         remote_size, local_size = info.get("size"), local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True

vectordb_bench/backend/runner/mp_runner.py

@@ -79,14 +79,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) ",
-                        f"search_count: {count}, latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) "
+                        f"search_count: {count}, latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.info(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return (count, total_dur, latencies)
@@ -94,9 +94,7 @@ class MultiProcessingSearchRunner:
     @staticmethod
     def get_mp_context():
         mp_start_method = "spawn"
-        log.debug(
-            f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}",
-        )
+        log.debug(f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}")
         return mp.get_context(mp_start_method)
 
     def _run_all_concurrencies_mem_efficient(self):
@@ -113,9 +111,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        log.info(f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [executor.submit(self.search, self.test_data, q, cond) for i in range(conc)]
                         # Sync all processes
                         while q.qsize() < conc:
@@ -124,9 +120,7 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result()[0] for r in future_iter])
@@ -140,18 +134,14 @@ class MultiProcessingSearchRunner:
                         conc_qps_list.append(qps)
                         conc_latency_p99_list.append(latency_p99)
                         conc_latency_avg_list.append(latency_avg)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
-                f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
+                f"Fail to search, concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}"
             )
             traceback.print_exc()
 
@@ -193,9 +183,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        log.info(f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [
                             executor.submit(self.search_by_dur, duration, self.test_data, q, cond) for i in range(conc)
                         ]
@@ -206,24 +194,18 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result() for r in future_iter])
                         cost = time.perf_counter() - start
 
                         qps = round(all_count / cost, 4)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
                 f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
@@ -275,14 +257,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) search_count: {count}, ",
-                        f"latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) search_count: {count}, "
+                        f"latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.debug(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return count

vectordb_bench/backend/runner/rate_runner.py

@@ -73,14 +73,14 @@ class RatedMultiThreadingInsertRunner:
 
                         if len(not_done) > 0:
                             log.warning(
-                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] ",
-                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round",
+                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] "
+                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round"
                             )
                             executing_futures = list(not_done)
                         else:
                             log.debug(
-                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} ",
-                                f"task in 1s, wait_interval={wait_interval:.2f}",
+                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} "
+                                f"task in 1s, wait_interval={wait_interval:.2f}"
                             )
                             executing_futures = []
                     except Exception as e:

vectordb_bench/backend/runner/read_write_runner.py

@@ -45,8 +45,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         self.read_dur_after_write = read_dur_after_write
 
         log.info(
-            f"Init runner, concurencys={concurrencies}, search_stage={search_stage}, ",
-            f"stage_search_dur={read_dur_after_write}",
+            f"Init runner, concurencys={concurrencies}, search_stage={search_stage}, "
+            f"stage_search_dur={read_dur_after_write}"
         )
 
         test_emb = np.stack(dataset.test_data["emb"])
@@ -80,7 +80,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         """Optimize needs to run in differenct process for pymilvus schema recursion problem"""
         with self.db.init():
             log.info("Search after write - Optimize start")
-            self.db.optimize()
+            self.db.optimize(data_size=self.data_volume)
             log.info("Search after write - Optimize finished")
 
     def run_search(self):
@@ -88,12 +88,10 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         res, ssearch_dur = self.serial_search_runner.run()
         recall, ndcg, p99_latency = res
         log.info(
-            f"Search after write - Serial search - recall={recall}, ndcg={ndcg}, p99={p99_latency}, ",
+            f"Search after write - Serial search - recall={recall}, ndcg={ndcg}, p99={p99_latency}, "
             f"dur={ssearch_dur:.4f}",
         )
-        log.info(
-            f"Search after wirte - Conc search start, dur for each conc={self.read_dur_after_write}",
-        )
+        log.info(f"Search after wirte - Conc search start, dur for each conc={self.read_dur_after_write}")
         max_qps = self.run_by_dur(self.read_dur_after_write)
         log.info(f"Search after wirte - Conc search finished, max_qps={max_qps}")
 
@@ -157,9 +155,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
 
             got = wait_next_target(start_batch, target_batch)
             if got is False:
-                log.warning(
-                    f"Abnormal exit, target_batch={target_batch}, start_batch={start_batch}",
-                )
+                log.warning(f"Abnormal exit, target_batch={target_batch}, start_batch={start_batch}")
                 return None
 
             log.info(f"Insert {perc}% done, total batch={total_batch}")
@@ -167,8 +163,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
             res, ssearch_dur = self.serial_search_runner.run()
             recall, ndcg, p99_latency = res
             log.info(
-                f"[{target_batch}/{total_batch}] Serial search - {perc}% done, recall={recall}, ",
-                f"ndcg={ndcg}, p99={p99_latency}, dur={ssearch_dur:.4f}",
+                f"[{target_batch}/{total_batch}] Serial search - {perc}% done, recall={recall}, "
+                f"ndcg={ndcg}, p99={p99_latency}, dur={ssearch_dur:.4f}"
             )
 
             # Search duration for non-last search stage is carefully calculated.
@@ -183,8 +179,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
                 each_conc_search_dur = csearch_dur / len(self.concurrencies)
                 if each_conc_search_dur < 30:
                     warning_msg = (
-                        f"Results might be inaccurate, duration[{csearch_dur:.4f}] left for conc-search is too short, ",
-                        f"total available dur={total_dur_between_stages}, serial_search_cost={ssearch_dur}.",
+                        f"Results might be inaccurate, duration[{csearch_dur:.4f}] left for conc-search is too short, "
+                        f"total available dur={total_dur_between_stages}, serial_search_cost={ssearch_dur}."
                     )
                     log.warning(warning_msg)
 
@@ -193,7 +189,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
                 each_conc_search_dur = 60
 
             log.info(
-                f"[{target_batch}/{total_batch}] Concurrent search - {perc}% start, dur={each_conc_search_dur:.4f}",
+                f"[{target_batch}/{total_batch}] Concurrent search - {perc}% start, dur={each_conc_search_dur:.4f}"
             )
             max_qps = self.run_by_dur(each_conc_search_dur)
             result.append((perc, max_qps, recall, ndcg, p99_latency))