Skip to content

Fix some potential performance defects (#445) #447

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
sre-ci-robot merged 1 commit into from
Mar 19, 2026
Merged

Fix some potential performance defects (#445) #447

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/impl/MilvusClientV2Impl.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
10 changes: 5 additions & 5 deletions src/impl/types/FieldData.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>>
Expand All @@ -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;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Expand Down
2 changes: 1 addition & 1 deletion src/impl/utils/CompareUtils.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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());
}
Expand Down
37 changes: 22 additions & 15 deletions src/impl/utils/DqlUtils.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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!");
}
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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();
}
Expand Down Expand Up @@ -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++) {
Expand Down Expand Up @@ -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++) {
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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),
Expand Down Expand Up @@ -938,7 +945,7 @@ GenGetters(const std::vector<FieldDataPtr>& fields) {
break;
}
}
return std::move(getters);
return getters;
}

Status
Expand Down
16 changes: 8 additions & 8 deletions src/impl/utils/FP16.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
10 changes: 5 additions & 5 deletions src/include/milvus/types/ConnectParam.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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_;
Expand Down
8 changes: 4 additions & 4 deletions src/include/milvus/utils/FP16.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Loading