diff --git a/ci/jenkinsfile/deploy2staging.groovy b/ci/jenkinsfile/deploy2staging.groovy index 8079698894a076d8038a7d7b44f41184007158d1..ee01097de8fd89179f5db1bb54862cb47c15aaab 100644 --- a/ci/jenkinsfile/deploy2staging.groovy +++ b/ci/jenkinsfile/deploy2staging.groovy @@ -5,7 +5,7 @@ try { dir ("milvus-helm") { checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]]) dir ("milvus/milvus-gpu") { - sh "helm install --wait --timeout 300 --set engine.image.repository="zilliz.azurecr.cn/milvus/engine" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.4.0 ." + sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.4.0 ." } } } catch (exc) { diff --git a/ci/jenkinsfile/dev_test.groovy b/ci/jenkinsfile/dev_test.groovy index 8ae7e4c47863d860807abfac31fd32e0130fdefe..8e91777a023ef148b5870d6d966dc682a4d6bfe2 100644 --- a/ci/jenkinsfile/dev_test.groovy +++ b/ci/jenkinsfile/dev_test.groovy @@ -3,7 +3,7 @@ timeout(time: 40, unit: 'MINUTES') { dir ("${PROJECT_NAME}_test") { checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]]) sh 'python3 -m pip install -r requirements.txt' - sh "pytest . --alluredir="test_out/dev/single/sqlite" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local" + sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local" } // mysql database backend test @@ -20,7 +20,7 @@ timeout(time: 40, unit: 'MINUTES') { } } dir ("${PROJECT_NAME}_test") { - sh "pytest . --alluredir="test_out/dev/single/mysql" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local" + sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local" } } catch (exc) { echo 'Milvus Test Failed !' diff --git a/ci/jenkinsfile/staging_test.groovy b/ci/jenkinsfile/staging_test.groovy index 39fceb15384cfcae7a9097815d69454373e8c543..7fceee5dfd9e72108f29abfbddec6c4238e1e48f 100644 --- a/ci/jenkinsfile/staging_test.groovy +++ b/ci/jenkinsfile/staging_test.groovy @@ -4,7 +4,7 @@ timeout(time: 40, unit: 'MINUTES') { checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]]) sh 'python3 -m pip install -r requirements.txt' def service_ip = sh (script: "kubectl get svc --namespace milvus-1 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim() - sh "pytest . --alluredir="test_out/staging/single/sqlite" --ip ${service_ip}" + sh "pytest . --alluredir=\"test_out/staging/single/sqlite\" --ip ${service_ip}" } // mysql database backend test @@ -17,12 +17,12 @@ timeout(time: 40, unit: 'MINUTES') { } dir ("milvus-helm") { dir ("milvus/milvus-gpu") { - sh "helm install --wait --timeout 300 --set engine.image.repository="zilliz.azurecr.cn/milvus/engine" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.4.0 ." + sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.4.0 ." } } dir ("${PROJECT_NAME}_test") { def service_ip = sh (script: "kubectl get svc --namespace milvus-2 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim() - sh "pytest . --alluredir="test_out/staging/single/mysql" --ip ${service_ip}" + sh "pytest . --alluredir=\"test_out/staging/single/mysql\" --ip ${service_ip}" } } catch (exc) { echo 'Milvus Test Failed !' diff --git a/cpp/src/db/DBImpl.cpp b/cpp/src/db/DBImpl.cpp index 7145db04b2473e8f18482b83da13a00707c0404e..a9386ff1eb8e865ccfd3579be2c6e930621c3fb7 100644 --- a/cpp/src/db/DBImpl.cpp +++ b/cpp/src/db/DBImpl.cpp @@ -317,6 +317,7 @@ void DBImpl::StartMetricTask() { int64_t cache_usage = cache::CpuCacheMgr::GetInstance()->CacheUsage(); int64_t cache_total = cache::CpuCacheMgr::GetInstance()->CacheCapacity(); server::Metrics::GetInstance().CpuCacheUsageGaugeSet(cache_usage*100/cache_total); + server::Metrics::GetInstance().GpuCacheUsageGaugeSet(); uint64_t size; Size(size); server::Metrics::GetInstance().DataFileSizeGaugeSet(size); diff --git a/cpp/src/db/meta/SqliteMetaImpl.cpp b/cpp/src/db/meta/SqliteMetaImpl.cpp index d0d64236882566960c841b5de7630857c9bc5dc4..a06c391ca5f2c68003313d7fb63413a540e8553c 100644 --- a/cpp/src/db/meta/SqliteMetaImpl.cpp +++ b/cpp/src/db/meta/SqliteMetaImpl.cpp @@ -413,7 +413,6 @@ Status SqliteMetaImpl::DescribeTableIndex(const std::string &table_id, TableInde auto groups = ConnectorPtr->select(columns(&TableSchema::engine_type_, &TableSchema::nlist_, - &TableSchema::index_file_size_, &TableSchema::metric_type_), where(c(&TableSchema::table_id_) == table_id and c(&TableSchema::state_) != (int)TableSchema::TO_DELETE)); diff --git a/cpp/src/metrics/MetricBase.h b/cpp/src/metrics/MetricBase.h index a11bf14179aa6576f71f33a7724a9f7ca72c9f5d..3fb947cb1035824b5f86a69c2976255c4c3902a6 100644 --- a/cpp/src/metrics/MetricBase.h +++ b/cpp/src/metrics/MetricBase.h @@ -32,7 +32,7 @@ class MetricsBase{ virtual void BuildIndexDurationSecondsHistogramObserve(double value) {}; virtual void CpuCacheUsageGaugeSet(double value) {}; - virtual void GpuCacheUsageGaugeSet(double value) {}; + virtual void GpuCacheUsageGaugeSet() {}; virtual void MetaAccessTotalIncrement(double value = 1) {}; virtual void MetaAccessDurationSecondsHistogramObserve(double value) {}; diff --git a/cpp/src/metrics/PrometheusMetrics.cpp b/cpp/src/metrics/PrometheusMetrics.cpp index 08dad64724bf55be408c821f6b12b792bf522f57..08f1fe7dc24cced8fbb8014597f2be3e931bbe75 100644 --- a/cpp/src/metrics/PrometheusMetrics.cpp +++ b/cpp/src/metrics/PrometheusMetrics.cpp @@ -167,15 +167,26 @@ void PrometheusMetrics::CPUTemperature() { } } -void PrometheusMetrics::GpuCacheUsageGaugeSet(double value) { +void PrometheusMetrics::GpuCacheUsageGaugeSet() { if(!startup_) return; - int64_t num_processors = server::SystemInfo::GetInstance().num_processor(); + server::ConfigNode& config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_CACHE); + std::string gpu_ids_str = config.GetValue(server::CONFIG_GPU_IDS, "0,1"); - for (auto i = 0; i < num_processors; ++i) { -// int gpu_cache_usage = cache::GpuCacheMgr::GetInstance(i)->CacheUsage(); -// int gpu_cache_total = cache::GpuCacheMgr::GetInstance(i)->CacheCapacity(); -// prometheus::Gauge &gpu_cache = gpu_cache_usage_.Add({{"GPU_Cache", std::to_string(i)}}); -// gpu_cache.Set(gpu_cache_usage * 100 / gpu_cache_total); + std::vector gpu_ids; + + std::stringstream ss(gpu_ids_str); + for (int i; ss >> i;) { + gpu_ids.push_back(i); + if (ss.peek() == ',') { + ss.ignore(); + } + } + + for(auto i = 0; i < gpu_ids.size(); ++i) { + uint64_t cache_usage = cache::GpuCacheMgr::GetInstance(gpu_ids[i])->CacheUsage(); + uint64_t cache_capacity = cache::GpuCacheMgr::GetInstance(gpu_ids[i])->CacheCapacity(); + prometheus::Gauge &gpu_cache = gpu_cache_usage_.Add({{"GPU_Cache", std::to_string(i)}}); + gpu_cache.Set(cache_usage * 100 / cache_capacity); } } diff --git a/cpp/src/metrics/PrometheusMetrics.h b/cpp/src/metrics/PrometheusMetrics.h index ab37195583b87cc666d1a18725d540538be220d2..f0fe74cfaa0bb0fc5bc25da79bec64be303bb3fd 100644 --- a/cpp/src/metrics/PrometheusMetrics.h +++ b/cpp/src/metrics/PrometheusMetrics.h @@ -55,7 +55,7 @@ class PrometheusMetrics: public MetricsBase { void IndexFileSizeHistogramObserve(double value) override { if(startup_) index_files_size_histogram_.Observe(value);}; void BuildIndexDurationSecondsHistogramObserve(double value) override { if(startup_) build_index_duration_seconds_histogram_.Observe(value);}; void CpuCacheUsageGaugeSet(double value) override { if(startup_) cpu_cache_usage_gauge_.Set(value);}; - void GpuCacheUsageGaugeSet(double value) override; + void GpuCacheUsageGaugeSet() override; void MetaAccessTotalIncrement(double value = 1) override { if(startup_) meta_access_total_.Increment(value);}; void MetaAccessDurationSecondsHistogramObserve(double value) override { if(startup_) meta_access_duration_seconds_histogram_.Observe(value);}; @@ -343,7 +343,7 @@ class PrometheusMetrics: public MetricsBase { .Help("current cache usage by bytes") .Register(*registry_); prometheus::Gauge &cpu_cache_usage_gauge_ = cpu_cache_usage_.Add({}); - + //record GPU cache usage and % prometheus::Family &gpu_cache_usage_ = prometheus::BuildGauge() .Name("gpu_cache_usage_bytes") diff --git a/cpp/src/server/grpc_impl/GrpcRequestHandler.cpp b/cpp/src/server/grpc_impl/GrpcRequestHandler.cpp index be0c6adebb094dd621704c0c3d7c9c08002ea5b2..0ae711c32a2828e8b9aabfc7354d75852a0f3f8c 100644 --- a/cpp/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/cpp/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -18,7 +18,7 @@ GrpcRequestHandler::CreateTable(::grpc::ServerContext *context, const ::milvus::grpc::TableSchema *request, ::milvus::grpc::Status *response) { - BaseTaskPtr task_ptr = CreateTableTask::Create(*request); + BaseTaskPtr task_ptr = CreateTableTask::Create(request); GrpcRequestScheduler::ExecTask(task_ptr, response); return ::grpc::Status::OK; } @@ -52,7 +52,7 @@ GrpcRequestHandler::CreateIndex(::grpc::ServerContext *context, const ::milvus::grpc::IndexParam *request, ::milvus::grpc::Status *response) { - BaseTaskPtr task_ptr = CreateIndexTask::Create(*request); + BaseTaskPtr task_ptr = CreateIndexTask::Create(request); GrpcRequestScheduler::ExecTask(task_ptr, response); return ::grpc::Status::OK; } @@ -62,7 +62,7 @@ GrpcRequestHandler::Insert(::grpc::ServerContext *context, const ::milvus::grpc::InsertParam *request, ::milvus::grpc::VectorIds *response) { - BaseTaskPtr task_ptr = InsertTask::Create(*request, *response); + BaseTaskPtr task_ptr = InsertTask::Create(request, response); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); response->mutable_status()->set_reason(grpc_status.reason()); @@ -76,7 +76,7 @@ GrpcRequestHandler::Search(::grpc::ServerContext *context, ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer) { std::vector file_id_array; - BaseTaskPtr task_ptr = SearchTask::Create(*request, file_id_array, *writer); + BaseTaskPtr task_ptr = SearchTask::Create(request, file_id_array, writer); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); if (grpc_status.error_code() != SERVER_SUCCESS) { @@ -93,7 +93,11 @@ GrpcRequestHandler::SearchInFiles(::grpc::ServerContext *context, ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer) { std::vector file_id_array; - BaseTaskPtr task_ptr = SearchTask::Create(request->search_param(), file_id_array, *writer); + for(int i = 0; i < request->file_id_array_size(); i++) { + file_id_array.push_back(request->file_id_array(i)); + } + ::milvus::grpc::SearchInFilesParam *request_mutable = const_cast<::milvus::grpc::SearchInFilesParam *>(request); + BaseTaskPtr task_ptr = SearchTask::Create(request_mutable->mutable_search_param(), file_id_array, writer); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); if (grpc_status.error_code() != SERVER_SUCCESS) { @@ -109,7 +113,7 @@ GrpcRequestHandler::DescribeTable(::grpc::ServerContext *context, const ::milvus::grpc::TableName *request, ::milvus::grpc::TableSchema *response) { - BaseTaskPtr task_ptr = DescribeTableTask::Create(request->table_name(), *response); + BaseTaskPtr task_ptr = DescribeTableTask::Create(request->table_name(), response); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); response->mutable_table_name()->mutable_status()->set_error_code(grpc_status.error_code()); @@ -137,7 +141,7 @@ GrpcRequestHandler::ShowTables(::grpc::ServerContext *context, const ::milvus::grpc::Command *request, ::grpc::ServerWriter<::milvus::grpc::TableName> *writer) { - BaseTaskPtr task_ptr = ShowTablesTask::Create(*writer); + BaseTaskPtr task_ptr = ShowTablesTask::Create(writer); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); if (grpc_status.error_code() != SERVER_SUCCESS) { @@ -167,7 +171,7 @@ GrpcRequestHandler::Cmd(::grpc::ServerContext *context, GrpcRequestHandler::DeleteByRange(::grpc::ServerContext *context, const ::milvus::grpc::DeleteByRangeParam *request, ::milvus::grpc::Status *response) { - BaseTaskPtr task_ptr = DeleteByRangeTask::Create(*request); + BaseTaskPtr task_ptr = DeleteByRangeTask::Create(request); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); response->set_error_code(grpc_status.error_code()); @@ -191,7 +195,7 @@ GrpcRequestHandler::PreloadTable(::grpc::ServerContext *context, GrpcRequestHandler::DescribeIndex(::grpc::ServerContext *context, const ::milvus::grpc::TableName *request, ::milvus::grpc::IndexParam *response) { - BaseTaskPtr task_ptr = DescribeIndexTask::Create(request->table_name(), *response); + BaseTaskPtr task_ptr = DescribeIndexTask::Create(request->table_name(), response); ::milvus::grpc::Status grpc_status; GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status); response->mutable_table_name()->mutable_status()->set_reason(grpc_status.reason()); diff --git a/cpp/src/server/grpc_impl/GrpcRequestTask.cpp b/cpp/src/server/grpc_impl/GrpcRequestTask.cpp index a185272f269f2048f20b38326dcfbefad9eefefa..a4b8d68c296e4066f263ecf41f148e18845e67bc 100644 --- a/cpp/src/server/grpc_impl/GrpcRequestTask.cpp +++ b/cpp/src/server/grpc_impl/GrpcRequestTask.cpp @@ -107,14 +107,18 @@ namespace { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -CreateTableTask::CreateTableTask(const ::milvus::grpc::TableSchema &schema) +CreateTableTask::CreateTableTask(const ::milvus::grpc::TableSchema *schema) : GrpcBaseTask(DDL_DML_TASK_GROUP), schema_(schema) { } BaseTaskPtr -CreateTableTask::Create(const ::milvus::grpc::TableSchema &schema) { +CreateTableTask::Create(const ::milvus::grpc::TableSchema *schema) { + if(schema == nullptr) { + SERVER_LOG_ERROR << "grpc input is null!"; + return nullptr; + } return std::shared_ptr(new CreateTableTask(schema)); } @@ -124,26 +128,26 @@ CreateTableTask::OnExecute() { try { //step 1: check arguments - ServerError res = ValidationUtil::ValidateTableName(schema_.table_name().table_name()); + ServerError res = ValidationUtil::ValidateTableName(schema_->table_name().table_name()); if (res != SERVER_SUCCESS) { - return SetError(res, "Invalid table name: " + schema_.table_name().table_name()); + return SetError(res, "Invalid table name: " + schema_->table_name().table_name()); } - res = ValidationUtil::ValidateTableDimension(schema_.dimension()); + res = ValidationUtil::ValidateTableDimension(schema_->dimension()); if (res != SERVER_SUCCESS) { - return SetError(res, "Invalid table dimension: " + std::to_string(schema_.dimension())); + return SetError(res, "Invalid table dimension: " + std::to_string(schema_->dimension())); } - res = ValidationUtil::ValidateTableIndexFileSize(schema_.index_file_size()); + res = ValidationUtil::ValidateTableIndexFileSize(schema_->index_file_size()); if(res != SERVER_SUCCESS) { - return SetError(res, "Invalid index file size: " + std::to_string(schema_.index_file_size())); + return SetError(res, "Invalid index file size: " + std::to_string(schema_->index_file_size())); } //step 2: construct table schema engine::meta::TableSchema table_info; - table_info.table_id_ = schema_.table_name().table_name(); - table_info.dimension_ = (uint16_t) schema_.dimension(); - table_info.index_file_size_ = schema_.index_file_size(); + table_info.table_id_ = schema_->table_name().table_name(); + table_info.dimension_ = (uint16_t) schema_->dimension(); + table_info.index_file_size_ = schema_->index_file_size(); //step 3: create table engine::Status stat = DBWrapper::DB()->CreateTable(table_info); @@ -162,14 +166,14 @@ CreateTableTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -DescribeTableTask::DescribeTableTask(const std::string &table_name, ::milvus::grpc::TableSchema &schema) +DescribeTableTask::DescribeTableTask(const std::string &table_name, ::milvus::grpc::TableSchema *schema) : GrpcBaseTask(DDL_DML_TASK_GROUP), table_name_(table_name), schema_(schema) { } BaseTaskPtr -DescribeTableTask::Create(const std::string &table_name, ::milvus::grpc::TableSchema &schema) { +DescribeTableTask::Create(const std::string &table_name, ::milvus::grpc::TableSchema *schema) { return std::shared_ptr(new DescribeTableTask(table_name, schema)); } @@ -192,8 +196,8 @@ DescribeTableTask::OnExecute() { return SetError(DB_META_TRANSACTION_FAILED, "Engine failed: " + stat.ToString()); } - schema_.mutable_table_name()->set_table_name(table_info.table_id_); - schema_.set_dimension(table_info.dimension_); + schema_->mutable_table_name()->set_table_name(table_info.table_id_); + schema_->set_dimension(table_info.dimension_); } catch (std::exception &ex) { return SetError(SERVER_UNEXPECTED_ERROR, ex.what()); @@ -205,13 +209,17 @@ DescribeTableTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -CreateIndexTask::CreateIndexTask(const ::milvus::grpc::IndexParam &index_param) +CreateIndexTask::CreateIndexTask(const ::milvus::grpc::IndexParam *index_param) : GrpcBaseTask(DDL_DML_TASK_GROUP), index_param_(index_param) { } BaseTaskPtr -CreateIndexTask::Create(const ::milvus::grpc::IndexParam &index_param) { +CreateIndexTask::Create(const ::milvus::grpc::IndexParam *index_param) { + if(index_param == nullptr) { + SERVER_LOG_ERROR << "grpc input is null!"; + return nullptr; + } return std::shared_ptr(new CreateIndexTask(index_param)); } @@ -221,7 +229,7 @@ CreateIndexTask::OnExecute() { TimeRecorder rc("CreateIndexTask"); //step 1: check arguments - std::string table_name_ = index_param_.table_name().table_name(); + std::string table_name_ = index_param_->table_name().table_name(); ServerError res = ValidationUtil::ValidateTableName(table_name_); if (res != SERVER_SUCCESS) { return SetError(res, "Invalid table name: " + table_name_); @@ -237,26 +245,27 @@ CreateIndexTask::OnExecute() { return SetError(SERVER_TABLE_NOT_EXIST, "Table " + table_name_ + " not exists"); } - res = ValidationUtil::ValidateTableIndexType(index_param_.mutable_index()->index_type()); + auto &grpc_index = index_param_->index(); + res = ValidationUtil::ValidateTableIndexType(grpc_index.index_type()); if(res != SERVER_SUCCESS) { - return SetError(res, "Invalid index type: " + std::to_string(index_param_.mutable_index()->index_type())); + return SetError(res, "Invalid index type: " + std::to_string(grpc_index.index_type())); } - res = ValidationUtil::ValidateTableIndexNlist(index_param_.mutable_index()->nlist()); + res = ValidationUtil::ValidateTableIndexNlist(grpc_index.nlist()); if(res != SERVER_SUCCESS) { - return SetError(res, "Invalid index nlist: " + std::to_string(index_param_.mutable_index()->nlist())); + return SetError(res, "Invalid index nlist: " + std::to_string(grpc_index.nlist())); } - res = ValidationUtil::ValidateTableIndexMetricType(index_param_.mutable_index()->metric_type()); + res = ValidationUtil::ValidateTableIndexMetricType(grpc_index.metric_type()); if(res != SERVER_SUCCESS) { - return SetError(res, "Invalid index metric type: " + std::to_string(index_param_.mutable_index()->metric_type())); + return SetError(res, "Invalid index metric type: " + std::to_string(grpc_index.metric_type())); } //step 2: check table existence engine::TableIndex index; - index.engine_type_ = index_param_.mutable_index()->index_type(); - index.nlist_ = index_param_.mutable_index()->nlist(); - index.metric_type_ = index_param_.mutable_index()->metric_type(); + index.engine_type_ = grpc_index.index_type(); + index.nlist_ = grpc_index.nlist(); + index.metric_type_ = grpc_index.metric_type(); stat = DBWrapper::DB()->CreateIndex(table_name_, index); if (!stat.ok()) { return SetError(SERVER_BUILD_INDEX_ERROR, "Engine failed: " + stat.ToString()); @@ -361,14 +370,14 @@ DropTableTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -ShowTablesTask::ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> &writer) +ShowTablesTask::ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> *writer) : GrpcBaseTask(DDL_DML_TASK_GROUP), writer_(writer) { } BaseTaskPtr -ShowTablesTask::Create(::grpc::ServerWriter<::milvus::grpc::TableName> &writer) { +ShowTablesTask::Create(::grpc::ServerWriter<::milvus::grpc::TableName> *writer) { return std::shared_ptr(new ShowTablesTask(writer)); } @@ -383,7 +392,7 @@ ShowTablesTask::OnExecute() { for (auto &schema : schema_array) { ::milvus::grpc::TableName tableName; tableName.set_table_name(schema.table_id_); - if (!writer_.Write(tableName)) { + if (!writer_->Write(tableName)) { return SetError(SERVER_WRITE_ERROR, "Write table name failed!"); } } @@ -391,17 +400,21 @@ ShowTablesTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -InsertTask::InsertTask(const ::milvus::grpc::InsertParam &insert_param, - ::milvus::grpc::VectorIds &record_ids) - : GrpcBaseTask(DDL_DML_TASK_GROUP), - insert_param_(insert_param), - record_ids_(record_ids) { - record_ids_.Clear(); +InsertTask::InsertTask(const ::milvus::grpc::InsertParam *insert_param, + ::milvus::grpc::VectorIds *record_ids) + : GrpcBaseTask(DDL_DML_TASK_GROUP), + insert_param_(insert_param), + record_ids_(record_ids) { + record_ids_->Clear(); } BaseTaskPtr -InsertTask::Create(const ::milvus::grpc::InsertParam &insert_param, - ::milvus::grpc::VectorIds &record_ids) { +InsertTask::Create(const ::milvus::grpc::InsertParam *insert_param, + ::milvus::grpc::VectorIds *record_ids) { + if(insert_param == nullptr) { + SERVER_LOG_ERROR << "grpc input is null!"; + return nullptr; + } return std::shared_ptr(new InsertTask(insert_param, record_ids)); } @@ -411,16 +424,16 @@ InsertTask::OnExecute() { TimeRecorder rc("InsertVectorTask"); //step 1: check arguments - ServerError res = ValidationUtil::ValidateTableName(insert_param_.table_name()); + ServerError res = ValidationUtil::ValidateTableName(insert_param_->table_name()); if (res != SERVER_SUCCESS) { - return SetError(res, "Invalid table name: " + insert_param_.table_name()); + return SetError(res, "Invalid table name: " + insert_param_->table_name()); } - if (insert_param_.row_record_array().empty()) { + if (insert_param_->row_record_array().empty()) { return SetError(SERVER_INVALID_ROWRECORD_ARRAY, "Row record array is empty"); } - if (!record_ids_.vector_id_array().empty()) { - if (record_ids_.vector_id_array().size() != insert_param_.row_record_array_size()) { + if (!record_ids_->vector_id_array().empty()) { + if (record_ids_->vector_id_array().size() != insert_param_->row_record_array_size()) { return SetError(SERVER_ILLEGAL_VECTOR_ID, "Size of vector ids is not equal to row record array size"); } @@ -428,12 +441,12 @@ InsertTask::OnExecute() { //step 2: check table existence engine::meta::TableSchema table_info; - table_info.table_id_ = insert_param_.table_name(); + table_info.table_id_ = insert_param_->table_name(); engine::Status stat = DBWrapper::DB()->DescribeTable(table_info); if (!stat.ok()) { if (stat.IsNotFound()) { return SetError(SERVER_TABLE_NOT_EXIST, - "Table " + insert_param_.table_name() + " not exists"); + "Table " + insert_param_->table_name() + " not exists"); } else { return SetError(DB_META_TRANSACTION_FAILED, "Engine failed: " + stat.ToString()); } @@ -443,7 +456,7 @@ InsertTask::OnExecute() { uint64_t row_count = 0; DBWrapper::DB()->GetTableRowCount(table_info.table_id_, row_count); bool empty_table = (row_count == 0); - bool user_provide_ids = !insert_param_.row_id_array().empty(); + bool user_provide_ids = !insert_param_->row_id_array().empty(); if(!empty_table) { //user already provided id before, all insert action require user id if(engine::utils::UserDefinedId(table_info.flag_) && !user_provide_ids) { @@ -465,14 +478,14 @@ InsertTask::OnExecute() { #endif //step 3: prepare float data - std::vector vec_f(insert_param_.row_record_array_size() * table_info.dimension_, 0); + std::vector vec_f(insert_param_->row_record_array_size() * table_info.dimension_, 0); // TODO: change to one dimension array in protobuf or use multiple-thread to copy the data - for (size_t i = 0; i < insert_param_.row_record_array_size(); i++) { - if (insert_param_.row_record_array(i).vector_data().empty()) { + for (size_t i = 0; i < insert_param_->row_record_array_size(); i++) { + if (insert_param_->row_record_array(i).vector_data().empty()) { return SetError(SERVER_INVALID_ROWRECORD_ARRAY, "Row record float array is empty"); } - uint64_t vec_dim = insert_param_.row_record_array(i).vector_data().size(); + uint64_t vec_dim = insert_param_->row_record_array(i).vector_data().size(); if (vec_dim != table_info.dimension_) { ServerError error_code = SERVER_INVALID_VECTOR_DIMENSION; std::string error_msg = "Invalid rowrecord dimension: " + std::to_string(vec_dim) @@ -481,31 +494,31 @@ InsertTask::OnExecute() { return SetError(error_code, error_msg); } memcpy(&vec_f[i * table_info.dimension_], - insert_param_.row_record_array(i).vector_data().data(), + insert_param_->row_record_array(i).vector_data().data(), table_info.dimension_ * sizeof(float)); } rc.ElapseFromBegin("prepare vectors data"); //step 4: insert vectors - auto vec_count = (uint64_t) insert_param_.row_record_array_size(); - std::vector vec_ids(insert_param_.row_id_array_size(), 0); - if(!insert_param_.row_id_array().empty()) { - const int64_t* src_data = insert_param_.row_id_array().data(); + auto vec_count = (uint64_t) insert_param_->row_record_array_size(); + std::vector vec_ids(insert_param_->row_id_array_size(), 0); + if(!insert_param_->row_id_array().empty()) { + const int64_t* src_data = insert_param_->row_id_array().data(); int64_t* target_data = vec_ids.data(); - memcpy(target_data, src_data, (size_t)(sizeof(int64_t)*insert_param_.row_id_array_size())); + memcpy(target_data, src_data, (size_t)(sizeof(int64_t)*insert_param_->row_id_array_size())); } - stat = DBWrapper::DB()->InsertVectors(insert_param_.table_name(), vec_count, vec_f.data(), vec_ids); + stat = DBWrapper::DB()->InsertVectors(insert_param_->table_name(), vec_count, vec_f.data(), vec_ids); rc.ElapseFromBegin("add vectors to engine"); if (!stat.ok()) { return SetError(SERVER_CACHE_ERROR, "Cache error: " + stat.ToString()); } for (int64_t id : vec_ids) { - record_ids_.add_vector_id_array(id); + record_ids_->add_vector_id_array(id); } - auto ids_size = record_ids_.vector_id_array_size(); + auto ids_size = record_ids_->vector_id_array_size(); if (ids_size != vec_count) { std::string msg = "Add " + std::to_string(vec_count) + " vectors but only return " + std::to_string(ids_size) + " id"; @@ -514,7 +527,7 @@ InsertTask::OnExecute() { //step 5: update table flag if(empty_table && user_provide_ids) { - stat = DBWrapper::DB()->UpdateTableFlag(insert_param_.table_name(), + stat = DBWrapper::DB()->UpdateTableFlag(insert_param_->table_name(), table_info.flag_ | engine::meta::FLAG_MASK_USERID); } @@ -533,9 +546,9 @@ InsertTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -SearchTask::SearchTask(const ::milvus::grpc::SearchParam &search_vector_infos, +SearchTask::SearchTask(const ::milvus::grpc::SearchParam *search_vector_infos, const std::vector &file_id_array, - ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> &writer) + ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer) : GrpcBaseTask(DQL_TASK_GROUP), search_param_(search_vector_infos), file_id_array_(file_id_array), @@ -544,9 +557,13 @@ SearchTask::SearchTask(const ::milvus::grpc::SearchParam &search_vector_infos, } BaseTaskPtr -SearchTask::Create(const ::milvus::grpc::SearchParam &search_vector_infos, - const std::vector &file_id_array, - ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> &writer) { +SearchTask::Create(const ::milvus::grpc::SearchParam *search_vector_infos, + const std::vector &file_id_array, + ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer) { + if(search_vector_infos == nullptr) { + SERVER_LOG_ERROR << "grpc input is null!"; + return nullptr; + } return std::shared_ptr(new SearchTask(search_vector_infos, file_id_array, writer)); } @@ -557,24 +574,24 @@ SearchTask::OnExecute() { TimeRecorder rc("SearchTask"); //step 1: check arguments - std::string table_name_ = search_param_.table_name(); + std::string table_name_ = search_param_->table_name(); ServerError res = ValidationUtil::ValidateTableName(table_name_); if (res != SERVER_SUCCESS) { return SetError(res, "Invalid table name: " + table_name_); } - int64_t top_k_ = search_param_.topk(); + int64_t top_k_ = search_param_->topk(); if (top_k_ <= 0 || top_k_ > 1024) { return SetError(SERVER_INVALID_TOPK, "Invalid topk: " + std::to_string(top_k_)); } - int64_t nprobe = search_param_.nprobe(); + int64_t nprobe = search_param_->nprobe(); if (nprobe <= 0) { return SetError(SERVER_INVALID_NPROBE, "Invalid nprobe: " + std::to_string(nprobe)); } - if (search_param_.query_record_array().empty()) { + if (search_param_->query_record_array().empty()) { return SetError(SERVER_INVALID_ROWRECORD_ARRAY, "Row record array is empty"); } @@ -596,8 +613,8 @@ SearchTask::OnExecute() { std::string error_msg; std::vector<::milvus::grpc::Range> range_array; - for (size_t i = 0; i < search_param_.query_range_array_size(); i++) { - range_array.emplace_back(search_param_.query_range_array(i)); + for (size_t i = 0; i < search_param_->query_range_array_size(); i++) { + range_array.emplace_back(search_param_->query_range_array(i)); } ConvertTimeRangeToDBDates(range_array, dates, error_code, error_msg); if (error_code != SERVER_SUCCESS) { @@ -614,13 +631,13 @@ SearchTask::OnExecute() { #endif //step 3: prepare float data - auto record_array_size = search_param_.query_record_array_size(); + auto record_array_size = search_param_->query_record_array_size(); std::vector vec_f(record_array_size * table_info.dimension_, 0); for (size_t i = 0; i < record_array_size; i++) { - if (search_param_.query_record_array(i).vector_data().empty()) { + if (search_param_->query_record_array(i).vector_data().empty()) { return SetError(SERVER_INVALID_ROWRECORD_ARRAY, "Query record float array is empty"); } - uint64_t query_vec_dim = search_param_.query_record_array(i).vector_data().size(); + uint64_t query_vec_dim = search_param_->query_record_array(i).vector_data().size(); if (query_vec_dim != table_info.dimension_) { ServerError error_code = SERVER_INVALID_VECTOR_DIMENSION; std::string error_msg = "Invalid rowrecord dimension: " + std::to_string(query_vec_dim) @@ -629,14 +646,14 @@ SearchTask::OnExecute() { } memcpy(&vec_f[i * table_info.dimension_], - search_param_.query_record_array(i).vector_data().data(), + search_param_->query_record_array(i).vector_data().data(), table_info.dimension_ * sizeof(float)); } rc.ElapseFromBegin("prepare vector data"); //step 4: search vectors engine::QueryResults results; - auto record_count = (uint64_t) search_param_.query_record_array().size(); + auto record_count = (uint64_t) search_param_->query_record_array().size(); if (file_id_array_.empty()) { stat = DBWrapper::DB()->Query(table_name_, (size_t) top_k_, record_count, nprobe, vec_f.data(), @@ -666,14 +683,14 @@ SearchTask::OnExecute() { //step 5: construct result array for (uint64_t i = 0; i < record_count; i++) { auto &result = results[i]; - const auto &record = search_param_.query_record_array(i); + const auto &record = search_param_->query_record_array(i); ::milvus::grpc::TopKQueryResult grpc_topk_result; for (auto &pair : result) { ::milvus::grpc::QueryResult *grpc_result = grpc_topk_result.add_query_result_arrays(); grpc_result->set_id(pair.first); grpc_result->set_distance(pair.second); } - if (!writer_.Write(grpc_topk_result)) { + if (!writer_->Write(grpc_topk_result)) { return SetError(SERVER_WRITE_ERROR, "Write topk result failed!"); } } @@ -765,13 +782,17 @@ CmdTask::OnExecute() { } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -DeleteByRangeTask::DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam &delete_by_range_param) +DeleteByRangeTask::DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam *delete_by_range_param) : GrpcBaseTask(DDL_DML_TASK_GROUP), delete_by_range_param_(delete_by_range_param){ } BaseTaskPtr -DeleteByRangeTask::Create(const ::milvus::grpc::DeleteByRangeParam &delete_by_range_param) { +DeleteByRangeTask::Create(const ::milvus::grpc::DeleteByRangeParam *delete_by_range_param) { + if(delete_by_range_param == nullptr) { + SERVER_LOG_ERROR << "grpc input is null!"; + return nullptr; + } return std::shared_ptr(new DeleteByRangeTask(delete_by_range_param)); } @@ -781,7 +802,7 @@ DeleteByRangeTask::OnExecute() { TimeRecorder rc("DeleteByRangeTask"); //step 1: check arguments - std::string table_name = delete_by_range_param_.table_name(); + std::string table_name = delete_by_range_param_->table_name(); ServerError res = ValidationUtil::ValidateTableName(table_name); if (res != SERVER_SUCCESS) { return SetError(res, "Invalid table name: " + table_name); @@ -807,7 +828,7 @@ DeleteByRangeTask::OnExecute() { std::string error_msg; std::vector<::milvus::grpc::Range> range_array; - range_array.emplace_back(delete_by_range_param_.range()); + range_array.emplace_back(delete_by_range_param_->range()); ConvertTimeRangeToDBDates(range_array, dates, error_code, error_msg); if (error_code != SERVER_SUCCESS) { return SetError(error_code, error_msg); @@ -870,7 +891,7 @@ PreloadTableTask::OnExecute() { //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// DescribeIndexTask::DescribeIndexTask(const std::string &table_name, - ::milvus::grpc::IndexParam &index_param) + ::milvus::grpc::IndexParam *index_param) : GrpcBaseTask(DDL_DML_TASK_GROUP), table_name_(table_name), index_param_(index_param) { @@ -879,7 +900,7 @@ DescribeIndexTask::DescribeIndexTask(const std::string &table_name, BaseTaskPtr DescribeIndexTask::Create(const std::string &table_name, - ::milvus::grpc::IndexParam &index_param){ + ::milvus::grpc::IndexParam *index_param){ return std::shared_ptr(new DescribeIndexTask(table_name, index_param)); } @@ -901,10 +922,10 @@ DescribeIndexTask::OnExecute() { return SetError(DB_META_TRANSACTION_FAILED, "Engine failed: " + stat.ToString()); } - index_param_.mutable_table_name()->set_table_name(table_name_); - index_param_.mutable_index()->set_index_type(index.engine_type_); - index_param_.mutable_index()->set_nlist(index.nlist_); - index_param_.mutable_index()->set_metric_type(index.metric_type_); + index_param_->mutable_table_name()->set_table_name(table_name_); + index_param_->mutable_index()->set_index_type(index.engine_type_); + index_param_->mutable_index()->set_nlist(index.nlist_); + index_param_->mutable_index()->set_metric_type(index.metric_type_); rc.ElapseFromBegin("totally cost"); } catch (std::exception &ex) { diff --git a/cpp/src/server/grpc_impl/GrpcRequestTask.h b/cpp/src/server/grpc_impl/GrpcRequestTask.h index e43b9fba6056f2ed4faec659f093ad2b4886448a..91d7bbfea0f962f4d2fa2c0c2a67bdafc7b27eaf 100644 --- a/cpp/src/server/grpc_impl/GrpcRequestTask.h +++ b/cpp/src/server/grpc_impl/GrpcRequestTask.h @@ -23,17 +23,17 @@ namespace grpc { class CreateTableTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const ::milvus::grpc::TableSchema &schema); + Create(const ::milvus::grpc::TableSchema *schema); protected: explicit - CreateTableTask(const ::milvus::grpc::TableSchema &request); + CreateTableTask(const ::milvus::grpc::TableSchema *request); ServerError OnExecute() override; private: - const ::milvus::grpc::TableSchema schema_; + const ::milvus::grpc::TableSchema *schema_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -58,10 +58,10 @@ private: class DescribeTableTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const std::string &table_name, ::milvus::grpc::TableSchema &schema); + Create(const std::string &table_name, ::milvus::grpc::TableSchema *schema); protected: - DescribeTableTask(const std::string &table_name, ::milvus::grpc::TableSchema &schema); + DescribeTableTask(const std::string &table_name, ::milvus::grpc::TableSchema *schema); ServerError OnExecute() override; @@ -69,7 +69,7 @@ protected: private: std::string table_name_; - ::milvus::grpc::TableSchema &schema_; + ::milvus::grpc::TableSchema *schema_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -94,76 +94,76 @@ private: class CreateIndexTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const ::milvus::grpc::IndexParam &index_Param); + Create(const ::milvus::grpc::IndexParam *index_Param); protected: explicit - CreateIndexTask(const ::milvus::grpc::IndexParam &index_Param); + CreateIndexTask(const ::milvus::grpc::IndexParam *index_Param); ServerError OnExecute() override; private: - ::milvus::grpc::IndexParam index_param_; + const ::milvus::grpc::IndexParam *index_param_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class ShowTablesTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(::grpc::ServerWriter<::milvus::grpc::TableName> &writer); + Create(::grpc::ServerWriter<::milvus::grpc::TableName> *writer); protected: explicit - ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> &writer); + ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> *writer); ServerError OnExecute() override; private: - ::grpc::ServerWriter<::milvus::grpc::TableName> writer_; + ::grpc::ServerWriter<::milvus::grpc::TableName> *writer_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class InsertTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const ::milvus::grpc::InsertParam &insert_Param, - ::milvus::grpc::VectorIds &record_ids_); + Create(const ::milvus::grpc::InsertParam *insert_Param, + ::milvus::grpc::VectorIds *record_ids_); protected: - InsertTask(const ::milvus::grpc::InsertParam &insert_Param, - ::milvus::grpc::VectorIds &record_ids_); + InsertTask(const ::milvus::grpc::InsertParam *insert_Param, + ::milvus::grpc::VectorIds *record_ids_); ServerError OnExecute() override; private: - const ::milvus::grpc::InsertParam insert_param_; - ::milvus::grpc::VectorIds &record_ids_; + const ::milvus::grpc::InsertParam *insert_param_; + ::milvus::grpc::VectorIds *record_ids_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class SearchTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const ::milvus::grpc::SearchParam &search_param, + Create(const ::milvus::grpc::SearchParam *search_param, const std::vector &file_id_array, - ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> &writer); + ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer); protected: - SearchTask(const ::milvus::grpc::SearchParam &search_param, + SearchTask(const ::milvus::grpc::SearchParam *search_param, const std::vector &file_id_array, - ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> &writer); + ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer); ServerError OnExecute() override; private: - const ::milvus::grpc::SearchParam search_param_; + const ::milvus::grpc::SearchParam *search_param_; std::vector file_id_array_; - ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> writer_; + ::grpc::ServerWriter<::milvus::grpc::TopKQueryResult> *writer_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -204,16 +204,16 @@ private: class DeleteByRangeTask : public GrpcBaseTask { public: static BaseTaskPtr - Create(const ::milvus::grpc::DeleteByRangeParam &delete_by_range_param); + Create(const ::milvus::grpc::DeleteByRangeParam *delete_by_range_param); protected: - DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam &delete_by_range_param); + DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam *delete_by_range_param); ServerError OnExecute() override; private: - ::milvus::grpc::DeleteByRangeParam delete_by_range_param_; + const ::milvus::grpc::DeleteByRangeParam *delete_by_range_param_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -237,18 +237,18 @@ class DescribeIndexTask : public GrpcBaseTask { public: static BaseTaskPtr Create(const std::string &table_name, - ::milvus::grpc::IndexParam &index_param); + ::milvus::grpc::IndexParam *index_param); protected: DescribeIndexTask(const std::string &table_name, - ::milvus::grpc::IndexParam &index_param); + ::milvus::grpc::IndexParam *index_param); ServerError OnExecute() override; private: std::string table_name_; - ::milvus::grpc::IndexParam& index_param_; + ::milvus::grpc::IndexParam *index_param_; }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/cpp/unittest/metrics/metricbase_test.cpp b/cpp/unittest/metrics/metricbase_test.cpp index feda6d1bf9aea3ccabe2f07264dcf05fc53681d6..10087b370abd51b5617878420bb2bc01fe66a207 100644 --- a/cpp/unittest/metrics/metricbase_test.cpp +++ b/cpp/unittest/metrics/metricbase_test.cpp @@ -22,7 +22,7 @@ TEST(MetricbaseTest, METRICBASE_TEST){ instance.IndexFileSizeHistogramObserve(1.0); instance.BuildIndexDurationSecondsHistogramObserve(1.0); instance.CpuCacheUsageGaugeSet(1.0); - instance.GpuCacheUsageGaugeSet(1.0); + instance.GpuCacheUsageGaugeSet(); instance.MetaAccessTotalIncrement(); instance.MetaAccessDurationSecondsHistogramObserve(1.0); instance.FaissDiskLoadDurationSecondsHistogramObserve(1.0); diff --git a/cpp/unittest/metrics/prometheus_test.cpp b/cpp/unittest/metrics/prometheus_test.cpp index ece3cf9012b0093f1a5f71f9393011a88cfbfddd..912e910f32f1b81d3b52c6de16c58dc2e6d5a833 100644 --- a/cpp/unittest/metrics/prometheus_test.cpp +++ b/cpp/unittest/metrics/prometheus_test.cpp @@ -23,7 +23,7 @@ TEST(PrometheusTest, PROMETHEUS_TEST){ instance.IndexFileSizeHistogramObserve(1.0); instance.BuildIndexDurationSecondsHistogramObserve(1.0); instance.CpuCacheUsageGaugeSet(1.0); - instance.GpuCacheUsageGaugeSet(1.0); + instance.GpuCacheUsageGaugeSet(); instance.MetaAccessTotalIncrement(); instance.MetaAccessDurationSecondsHistogramObserve(1.0); instance.FaissDiskLoadDurationSecondsHistogramObserve(1.0);