Fix some potential performance defects (#445) (#447)

yhmo · web-flow · commit ca9d37114496 · 2026-03-19T11:55:22.000+08:00
Signed-off-by: yhmo &lt;yihua.mo@zilliz.com&gt;
diff --git a/src/impl/MilvusClientV2Impl.cpp b/src/impl/MilvusClientV2Impl.cpp
@@ -136,7 +136,7 @@ MilvusClientV2Impl::CreateCollection(const CreateCollectionRequest& request) {
         }
 
         // properties
-        for (auto it : request.Properties()) {
+        for (const auto& it : request.Properties()) {
             auto kv = rpc_request.add_properties();
             kv->set_key(it.first);
             kv->set_value(it.second);
diff --git a/src/impl/types/FieldData.cpp b/src/impl/types/FieldData.cpp
@@ -359,14 +359,14 @@ BinaryVecFieldData::ToBinaryStrings(const std::vector<std::vector<uint8_t>>& dat
     std::vector<std::string> ret;
     ret.reserve(data.size());
     for (const auto& item : data) {
-        ret.emplace_back(std::move(ToBinaryString(item)));
+        ret.emplace_back(ToBinaryString(item));
     }
-    return std::move(ret);
+    return ret;
 }
 
 std::string
 BinaryVecFieldData::ToBinaryString(const std::vector<uint8_t>& data) {
-    return std::move(std::string{data.begin(), data.end()});
+    return std::string{data.begin(), data.end()};
 }
 
 std::vector<std::vector<uint8_t>>
@@ -376,15 +376,15 @@ BinaryVecFieldData::ToUnsignedChars(const std::vector<std::string>& data) {
     for (const auto& item : data) {
         ret.emplace_back(item.begin(), item.end());
     }
-    return std::move(ret);
+    return ret;
 }
 
 std::vector<uint8_t>
 BinaryVecFieldData::ToUnsignedChars(const std::string& data) {
     std::vector<uint8_t> ret;
     ret.reserve(data.size());
     std::copy(data.begin(), data.end(), std::back_inserter(ret));
-    return std::move(ret);
+    return ret;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/impl/utils/CompareUtils.cpp b/src/impl/utils/CompareUtils.cpp
@@ -203,7 +203,7 @@ operator==(const proto::schema::FieldData& lhs, const JSONFieldData& rhs) {
 
     EntityRows jsons;
     for (const auto& str : scalars_data) {
-        jsons.emplace_back(std::move(nlohmann::json::parse(str)));
+        jsons.emplace_back(nlohmann::json::parse(str));
     }
     return std::equal(jsons.begin(), jsons.end(), rhs.Data().begin());
 }
diff --git a/src/impl/utils/DqlUtils.cpp b/src/impl/utils/DqlUtils.cpp
@@ -28,7 +28,7 @@
 namespace milvus {
 
 SparseFloatVecFieldData::ElementT
-DecodeSparseFloatVector(std::string& bytes) {
+DecodeSparseFloatVector(const std::string& bytes) {
     if (bytes.size() % 8 != 0) {
         throw std::runtime_error("Unexpected binary string is received from server side!");
     }
@@ -65,8 +65,8 @@ BuildFieldDataSparseVectors(const google::protobuf::RepeatedPtrField<std::string
     auto end = cursor;
     std::advance(end, count);
     while (cursor != end) {
-        std::string bytes = *cursor;
-        data.emplace_back(std::move(DecodeSparseFloatVector(bytes)));
+        const std::string& bytes = *cursor;
+        data.emplace_back(DecodeSparseFloatVector(bytes));
         cursor++;
     }
     return data;
@@ -358,13 +358,21 @@ CreateMilvusFieldData(const proto::schema::FieldData& proto_data, size_t offset,
             return Status::OK();
         }
         case proto::schema::DataType::JSON: {
-            std::vector<nlohmann::json> objects;
+            // Don't use BuildFieldDataScalars here: JSON requires json::parse() for each element,
+            // so we parse only the [offset, end) range to avoid parsing all elements upfront.
             const auto& scalars_data = proto_scalars.json_data().data();
-            for (const auto& s : scalars_data) {
-                objects.emplace_back(std::move(nlohmann::json::parse(s)));
+            auto total = static_cast<size_t>(scalars_data.size());
+            if (offset >= total) {
+                field_data = std::make_shared<JSONFieldData>(std::move(name), std::vector<JSONFieldData::ElementT>{},
+                                                             std::move(valid_data));
+                return Status::OK();
+            }
+            size_t end = (offset + count > total) ? total : offset + count;
+            std::vector<JSONFieldData::ElementT> values;
+            values.reserve(end - offset);
+            for (size_t i = offset; i < end; ++i) {
+                values.emplace_back(nlohmann::json::parse(scalars_data[static_cast<int>(i)]));
             }
-            std::vector<JSONFieldData::ElementT> values =
-                BuildFieldDataScalars<JSONFieldData::ElementT>(objects, offset, count);
             field_data = std::make_shared<JSONFieldData>(std::move(name), std::move(values), std::move(valid_data));
             return Status::OK();
         }
@@ -498,7 +506,7 @@ FillStructValue(const FieldDataPtr& array_data, std::vector<std::vector<nlohmann
     for (auto k = 0; k < actual_count; k++) {
         const auto& arr = actual_ptr->Value(k);
         if (structs.size() <= k) {
-            structs.emplace_back(std::move(std::vector<nlohmann::json>()));
+            structs.emplace_back();
             structs[k].resize(arr.size());
         }
         for (auto j = 0; j < arr.size(); j++) {
@@ -593,7 +601,7 @@ ConvertStructFieldData(const proto::schema::FieldData& proto_data, size_t offset
                         vector_field.dim() * 4, floats.data(), floats.size(), 0, floats.size());
                     auto num = k - offset;
                     if (structs.size() <= num) {
-                        structs.emplace_back(std::move(std::vector<nlohmann::json>()));
+                        structs.emplace_back();
                         structs[num].resize(vectors.size());
                     }
                     for (auto j = 0; j < vectors.size(); j++) {
@@ -746,8 +754,7 @@ SetEmbeddingLists(const std::vector<EmbeddingList>& emb_lists, proto::milvus::Se
             std::string content;
             content.reserve(emb_list.Count() * emb_list.Dim() * 4);
             for (const auto& vector : vectors.Data()) {
-                std::string single_content(reinterpret_cast<const char*>(vector.data()), vector.size() * sizeof(float));
-                content += single_content;
+                content.append(reinterpret_cast<const char*>(vector.data()), vector.size() * sizeof(float));
             }
             rpc_request->set_nq(static_cast<int64_t>(emb_list.Count()));
             placeholder_value.add_values(std::move(content));
@@ -798,8 +805,8 @@ GenGetter(const FieldDataPtr& field) {
         // special process float16/bfloat16 vector to float arrays
         if (field->Type() == DataType::FLOAT16_VECTOR || field->Type() == DataType::BFLOAT16_VECTOR) {
             bool is_fp16 = (field->Type() == DataType::FLOAT16_VECTOR);
-            std::vector<uint16_t> f16_vec = is_fp16 ? std::static_pointer_cast<Float16VecFieldData>(field)->Value(i)
-                                                    : std::static_pointer_cast<BFloat16VecFieldData>(field)->Value(i);
+            const auto& f16_vec = is_fp16 ? std::static_pointer_cast<Float16VecFieldData>(field)->Data()[i]
+                                          : std::static_pointer_cast<BFloat16VecFieldData>(field)->Data()[i];
             std::vector<float> f32_vec;
             f32_vec.reserve(f16_vec.size());
             std::transform(f16_vec.begin(), f16_vec.end(), std::back_inserter(f32_vec),
@@ -938,7 +945,7 @@ GenGetters(const std::vector<FieldDataPtr>& fields) {
                 break;
         }
     }
-    return std::move(getters);
+    return getters;
 }
 
 Status
diff --git a/src/impl/utils/FP16.cpp b/src/impl/utils/FP16.cpp
@@ -100,43 +100,43 @@ BF16toF32(uint16_t val) {
 }
 
 std::vector<uint16_t>
-ArrayF32toF16(std::vector<float> array) {
+ArrayF32toF16(const std::vector<float>& array) {
     std::vector<uint16_t> result;
     result.reserve(array.size());
     for (float v : array) {
         result.push_back(F32toF16(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<float>
-ArrayF16toF32(std::vector<uint16_t> array) {
+ArrayF16toF32(const std::vector<uint16_t>& array) {
     std::vector<float> result;
     result.reserve(array.size());
     for (uint16_t v : array) {
         result.push_back(F16toF32(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<uint16_t>
-ArrayF32toBF16(std::vector<float> array) {
+ArrayF32toBF16(const std::vector<float>& array) {
     std::vector<uint16_t> result;
     result.reserve(array.size());
     for (float v : array) {
         result.push_back(F32toBF16(v));
     }
-    return std::move(result);
+    return result;
 }
 
 std::vector<float>
-ArrayBF16toF32(std::vector<uint16_t> array) {
+ArrayBF16toF32(const std::vector<uint16_t>& array) {
     std::vector<float> result;
     result.reserve(array.size());
     for (uint16_t v : array) {
         result.push_back(BF16toF32(v));
     }
-    return std::move(result);
+    return result;
 }
 
 }  // namespace milvus
diff --git a/src/include/milvus/types/ConnectParam.h b/src/include/milvus/types/ConnectParam.h
@@ -339,11 +339,11 @@ class ConnectParam {
  private:
     std::string uri_ = "http://localhost:19530";
 
-    uint64_t connect_timeout_ms_ = 10000;    // the same with pymilvus
-    uint64_t keepalive_time_ms_ = 10000;     // Send keepalive pings every 10 seconds
-    uint64_t keepalive_timeout_ms_ = 5000;   // Keepalive ping timeout after 5 seconds
-    bool keepalive_without_calls_ = true;    // Allow keepalive pings when there are no gRPC calls
-    uint64_t rpc_deadline_ms_ = 0;           // the same with java sdk
+    uint64_t connect_timeout_ms_ = 10000;   // the same with pymilvus
+    uint64_t keepalive_time_ms_ = 10000;    // Send keepalive pings every 10 seconds
+    uint64_t keepalive_timeout_ms_ = 5000;  // Keepalive ping timeout after 5 seconds
+    bool keepalive_without_calls_ = true;   // Allow keepalive pings when there are no gRPC calls
+    uint64_t rpc_deadline_ms_ = 0;          // the same with java sdk
 
     bool tls_{false};
     std::string server_name_;
diff --git a/src/include/milvus/utils/FP16.h b/src/include/milvus/utils/FP16.h
@@ -49,24 +49,24 @@ BF16toF32(uint16_t val);
  * @brief Convert a float32 array to a float16 array represented by uint16_t.
  */
 std::vector<uint16_t>
-ArrayF32toF16(std::vector<float> array);
+ArrayF32toF16(const std::vector<float>& array);
 
 /**
  * @brief Convert a float16 array to a float32 array.
  */
 std::vector<float>
-ArrayF16toF32(std::vector<uint16_t> array);
+ArrayF16toF32(const std::vector<uint16_t>& array);
 
 /**
  * @brief Convert a float32 array to a bfloat16 array represented by uint16_t.
  */
 std::vector<uint16_t>
-ArrayF32toBF16(std::vector<float> array);
+ArrayF32toBF16(const std::vector<float>& array);
 
 /**
  * @brief Convert a bfloat16 array to a float32 array.
  */
 std::vector<float>
-ArrayBF16toF32(std::vector<uint16_t> array);
+ArrayBF16toF32(const std::vector<uint16_t>& array);
 
 }  // namespace milvus

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ MilvusClientV2Impl::CreateCollection(const CreateCollectionRequest& request) {`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`// properties`
`139`		`- for (auto it : request.Properties()) {`
	`139`	`+ for (const auto& it : request.Properties()) {`
`140`	`140`	`auto kv = rpc_request.add_properties();`
`141`	`141`	`kv->set_key(it.first);`
`142`	`142`	`kv->set_value(it.second);`
Original file line number	Diff line number	Diff line change
`@@ -359,14 +359,14 @@ BinaryVecFieldData::ToBinaryStrings(const std::vector<std::vector<uint8_t>>& dat`
`359`	`359`	`std::vector<std::string> ret;`
`360`	`360`	`ret.reserve(data.size());`
`361`	`361`	`for (const auto& item : data) {`
`362`		`- ret.emplace_back(std::move(ToBinaryString(item)));`
	`362`	`+ ret.emplace_back(ToBinaryString(item));`
`363`	`363`	`}`
`364`		`- return std::move(ret);`
	`364`	`+ return ret;`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`std::string`
`368`	`368`	`BinaryVecFieldData::ToBinaryString(const std::vector<uint8_t>& data) {`
`369`		`- return std::move(std::string{data.begin(), data.end()});`
	`369`	`+ return std::string{data.begin(), data.end()};`
`370`	`370`	`}`
`371`	`371`
`372`	`372`	`std::vector<std::vector<uint8_t>>`
`@@ -376,15 +376,15 @@ BinaryVecFieldData::ToUnsignedChars(const std::vector<std::string>& data) {`
`376`	`376`	`for (const auto& item : data) {`
`377`	`377`	`ret.emplace_back(item.begin(), item.end());`
`378`	`378`	`}`
`379`		`- return std::move(ret);`
	`379`	`+ return ret;`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`std::vector<uint8_t>`
`383`	`383`	`BinaryVecFieldData::ToUnsignedChars(const std::string& data) {`
`384`	`384`	`std::vector<uint8_t> ret;`
`385`	`385`	`ret.reserve(data.size());`
`386`	`386`	`std::copy(data.begin(), data.end(), std::back_inserter(ret));`
`387`		`- return std::move(ret);`
	`387`	`+ return ret;`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ operator==(const proto::schema::FieldData& lhs, const JSONFieldData& rhs) {`
`203`	`203`
`204`	`204`	`EntityRows jsons;`
`205`	`205`	`for (const auto& str : scalars_data) {`
`206`		`- jsons.emplace_back(std::move(nlohmann::json::parse(str)));`
	`206`	`+ jsons.emplace_back(nlohmann::json::parse(str));`
`207`	`207`	`}`
`208`	`208`	`return std::equal(jsons.begin(), jsons.end(), rhs.Data().begin());`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,43 +100,43 @@ BF16toF32(uint16_t val) {`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`std::vector<uint16_t>`
`103`		`-ArrayF32toF16(std::vector<float> array) {`
	`103`	`+ArrayF32toF16(const std::vector<float>& array) {`
`104`	`104`	`std::vector<uint16_t> result;`
`105`	`105`	`result.reserve(array.size());`
`106`	`106`	`for (float v : array) {`
`107`	`107`	`result.push_back(F32toF16(v));`
`108`	`108`	`}`
`109`		`- return std::move(result);`
	`109`	`+ return result;`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`std::vector<float>`
`113`		`-ArrayF16toF32(std::vector<uint16_t> array) {`
	`113`	`+ArrayF16toF32(const std::vector<uint16_t>& array) {`
`114`	`114`	`std::vector<float> result;`
`115`	`115`	`result.reserve(array.size());`
`116`	`116`	`for (uint16_t v : array) {`
`117`	`117`	`result.push_back(F16toF32(v));`
`118`	`118`	`}`
`119`		`- return std::move(result);`
	`119`	`+ return result;`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`std::vector<uint16_t>`
`123`		`-ArrayF32toBF16(std::vector<float> array) {`
	`123`	`+ArrayF32toBF16(const std::vector<float>& array) {`
`124`	`124`	`std::vector<uint16_t> result;`
`125`	`125`	`result.reserve(array.size());`
`126`	`126`	`for (float v : array) {`
`127`	`127`	`result.push_back(F32toBF16(v));`
`128`	`128`	`}`
`129`		`- return std::move(result);`
	`129`	`+ return result;`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`std::vector<float>`
`133`		`-ArrayBF16toF32(std::vector<uint16_t> array) {`
	`133`	`+ArrayBF16toF32(const std::vector<uint16_t>& array) {`
`134`	`134`	`std::vector<float> result;`
`135`	`135`	`result.reserve(array.size());`
`136`	`136`	`for (uint16_t v : array) {`
`137`	`137`	`result.push_back(BF16toF32(v));`
`138`	`138`	`}`
`139`		`- return std::move(result);`
	`139`	`+ return result;`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`} // namespace milvus`