Merge pull request #430 from cydrain/caiyd_use_all_int64

#306 use int64 for config integer

CHANGELOG.md

@@ -22,15 +22,16 @@ Please mark all change in change log and use the ticket from JIRA.
 - \#346 - Support build index with multiple gpu
 
 ## Improvement
-- \#275 - Rename C++ SDK IndexType
-- \#284 - Change C++ SDK to shared library
+- \#255 - Add ivfsq8 test report detailed version
 - \#260 - C++ SDK README
 - \#266 - Rpc request source code refactor
-- \#314 - add Find FAISS in CMake
+- \#275 - Rename C++ SDK IndexType
+- \#284 - Change C++ SDK to shared library
+- \#306 - Use int64 for all config integer
 - \#310 - Add Q&A for 'protocol https not supported or disable in libcurl' issue
+- \#314 - add Find FAISS in CMake
 - \#322 - Add option to enable / disable prometheus
 - \#358 - Add more information in build.sh and install.md
-- \#255 - Add ivfsq8 test report detailed version
 - \#404 - Add virtual method Init() in Pass abstract class
 - \#409 - Add a Fallback pass in optimizer
 

core/src/db/Options.h

@@ -33,7 +33,7 @@ static const char* ARCHIVE_CONF_DISK = "disk";
 static const char* ARCHIVE_CONF_DAYS = "days";
 
 struct ArchiveConf {
-    using CriteriaT = std::map<std::string, int>;
+    using CriteriaT = std::map<std::string, int64_t>;
 
     explicit ArchiveConf(const std::string& type, const std::string& criterias = std::string());
 

core/src/db/engine/ExecutionEngineImpl.cpp

@@ -146,7 +146,7 @@ ExecutionEngineImpl::HybridLoad() const {
     const std::string key = location_ + ".quantizer";
 
     server::Config& config = server::Config::GetInstance();
-    std::vector<int32_t> gpus;
+    std::vector<int64_t> gpus;
     Status s = config.GetGpuResourceConfigSearchResources(gpus);
     if (!s.ok()) {
         ENGINE_LOG_ERROR << s.message();
@@ -586,7 +586,7 @@ ExecutionEngineImpl::GpuCache(uint64_t gpu_id) {
 Status
 ExecutionEngineImpl::Init() {
     server::Config& config = server::Config::GetInstance();
-    std::vector<int32_t> gpu_ids;
+    std::vector<int64_t> gpu_ids;
     Status s = config.GetGpuResourceConfigBuildIndexResources(gpu_ids);
     for (auto id : gpu_ids) {
         if (gpu_num_ == id) {

core/src/db/engine/ExecutionEngineImpl.h

@@ -122,8 +122,8 @@ class ExecutionEngineImpl : public ExecutionEngine {
     int64_t dim_;
     std::string location_;
 
-    int32_t nlist_ = 0;
-    int32_t gpu_num_ = 0;
+    int64_t nlist_ = 0;
+    int64_t gpu_num_ = 0;
 };
 
 }  // namespace engine

core/src/scheduler/SchedInst.cpp

@@ -55,9 +55,9 @@ load_simple_config() {
     // get resources
 #ifdef MILVUS_GPU_VERSION
     server::Config& config = server::Config::GetInstance();
-    std::vector<int32_t> gpu_ids;
+    std::vector<int64_t> gpu_ids;
     config.GetGpuResourceConfigSearchResources(gpu_ids);
-    std::vector<int32_t> build_gpu_ids;
+    std::vector<int64_t> build_gpu_ids;
     config.GetGpuResourceConfigBuildIndexResources(build_gpu_ids);
     auto pcie = Connection("pcie", 12000);
 

core/src/scheduler/optimizer/BuildIndexPass.cpp

@@ -26,7 +26,7 @@ namespace scheduler {
 void
 BuildIndexPass::Init() {
     server::Config& config = server::Config::GetInstance();
-    std::vector<int32_t> build_resources;
+    std::vector<int64_t> build_resources;
     Status s = config.GetGpuResourceConfigBuildIndexResources(build_resources);
     if (!s.ok()) {
         throw;

core/src/scheduler/optimizer/FaissFlatPass.h

@@ -45,9 +45,9 @@ class FaissFlatPass : public Pass {
     Run(const TaskPtr& task) override;
 
  private:
-    int32_t threshold_ = std::numeric_limits<int32_t>::max();
+    int64_t threshold_ = std::numeric_limits<int64_t>::max();
     int64_t count_ = 0;
-    std::vector<int32_t> gpus;
+    std::vector<int64_t> gpus;
 };
 
 using FaissFlatPassPtr = std::shared_ptr<FaissFlatPass>;

core/src/scheduler/optimizer/FaissIVFFlatPass.h

@@ -45,9 +45,9 @@ class FaissIVFFlatPass : public Pass {
     Run(const TaskPtr& task) override;
 
  private:
-    int32_t threshold_ = std::numeric_limits<int32_t>::max();
+    int64_t threshold_ = std::numeric_limits<int64_t>::max();
     int64_t count_ = 0;
-    std::vector<int32_t> gpus;
+    std::vector<int64_t> gpus;
 };
 
 using FaissIVFFlatPassPtr = std::shared_ptr<FaissIVFFlatPass>;

core/src/scheduler/optimizer/FaissIVFSQ8HPass.cpp

@@ -32,7 +32,7 @@ FaissIVFSQ8HPass::Init() {
     server::Config& config = server::Config::GetInstance();
     Status s = config.GetEngineConfigGpuSearchThreshold(threshold_);
     if (!s.ok()) {
-        threshold_ = std::numeric_limits<int32_t>::max();
+        threshold_ = std::numeric_limits<int64_t>::max();
     }
     s = config.GetGpuResourceConfigSearchResources(gpus);
 }

core/src/scheduler/optimizer/FaissIVFSQ8HPass.h

@@ -45,9 +45,9 @@ class FaissIVFSQ8HPass : public Pass {
     Run(const TaskPtr& task) override;
 
  private:
-    int32_t threshold_ = std::numeric_limits<int32_t>::max();
+    int64_t threshold_ = std::numeric_limits<int64_t>::max();
     int64_t count_ = 0;
-    std::vector<int32_t> gpus;
+    std::vector<int64_t> gpus;
 };
 
 using FaissIVFSQ8HPassPtr = std::shared_ptr<FaissIVFSQ8HPass>;

core/src/scheduler/optimizer/FaissIVFSQ8Pass.h

@@ -45,9 +45,9 @@ class FaissIVFSQ8Pass : public Pass {
     Run(const TaskPtr& task) override;
 
  private:
-    int32_t threshold_ = std::numeric_limits<int32_t>::max();
+    int64_t threshold_ = std::numeric_limits<int64_t>::max();
     int64_t count_ = 0;
-    std::vector<int32_t> gpus;
+    std::vector<int64_t> gpus;
 };
 
 using FaissIVFSQ8PassPtr = std::shared_ptr<FaissIVFSQ8Pass>;

core/src/server/Config.cpp

@@ -113,19 +113,19 @@ Config::ValidateConfig() {
         return s;
     }
 
-    int32_t db_archive_disk_threshold;
+    int64_t db_archive_disk_threshold;
     s = GetDBConfigArchiveDiskThreshold(db_archive_disk_threshold);
     if (!s.ok()) {
         return s;
     }
 
-    int32_t db_archive_days_threshold;
+    int64_t db_archive_days_threshold;
     s = GetDBConfigArchiveDaysThreshold(db_archive_days_threshold);
     if (!s.ok()) {
         return s;
     }
 
-    int32_t db_insert_buffer_size;
+    int64_t db_insert_buffer_size;
     s = GetDBConfigInsertBufferSize(db_insert_buffer_size);
     if (!s.ok()) {
         return s;
@@ -170,19 +170,19 @@ Config::ValidateConfig() {
     }
 
     /* engine config */
-    int32_t engine_use_blas_threshold;
+    int64_t engine_use_blas_threshold;
     s = GetEngineConfigUseBlasThreshold(engine_use_blas_threshold);
     if (!s.ok()) {
         return s;
     }
 
-    int32_t engine_omp_thread_num;
+    int64_t engine_omp_thread_num;
     s = GetEngineConfigOmpThreadNum(engine_omp_thread_num);
     if (!s.ok()) {
         return s;
     }
 
-    int32_t engine_gpu_search_threshold;
+    int64_t engine_gpu_search_threshold;
     s = GetEngineConfigGpuSearchThreshold(engine_gpu_search_threshold);
     if (!s.ok()) {
         return s;
@@ -208,13 +208,13 @@ Config::ValidateConfig() {
         return s;
     }
 
-    std::vector<int32_t> search_resources;
+    std::vector<int64_t> search_resources;
     s = GetGpuResourceConfigSearchResources(search_resources);
     if (!s.ok()) {
         return s;
     }
 
-    std::vector<int32_t> index_build_resources;
+    std::vector<int64_t> index_build_resources;
     s = GetGpuResourceConfigBuildIndexResources(index_build_resources);
     if (!s.ok()) {
         return s;
@@ -485,7 +485,7 @@ Config::CheckDBConfigInsertBufferSize(const std::string& value) {
                           ". Possible reason: db_config.insert_buffer_size is not a positive integer.";
         return Status(SERVER_INVALID_ARGUMENT, msg);
     } else {
-        int64_t buffer_size = std::stoi(value) * GB;
+        int64_t buffer_size = std::stoll(value) * GB;
         if (buffer_size <= 0) {
             std::string msg = "Invalid insert buffer size: " + value +
                               ". Possible reason: db_config.insert_buffer_size is not a positive integer.";
@@ -540,7 +540,7 @@ Config::CheckCacheConfigCpuCacheCapacity(const std::string& value) {
                           ". Possible reason: cache_config.cpu_cache_capacity is not a positive integer.";
         return Status(SERVER_INVALID_ARGUMENT, msg);
     } else {
-        int64_t cpu_cache_capacity = std::stoi(value) * GB;
+        int64_t cpu_cache_capacity = std::stoll(value) * GB;
         if (cpu_cache_capacity <= 0) {
             std::string msg = "Invalid cpu cache capacity: " + value +
                               ". Possible reason: cache_config.cpu_cache_capacity is not a positive integer.";
@@ -557,7 +557,7 @@ Config::CheckCacheConfigCpuCacheCapacity(const std::string& value) {
             std::cerr << "WARNING: cpu cache capacity value is too big" << std::endl;
         }
 
-        int32_t buffer_value;
+        int64_t buffer_value;
         Status s = GetDBConfigInsertBufferSize(buffer_value);
         if (!s.ok()) {
             return s;
@@ -619,10 +619,10 @@ Config::CheckEngineConfigOmpThreadNum(const std::string& value) {
         return Status(SERVER_INVALID_ARGUMENT, msg);
     }
 
-    int32_t omp_thread = std::stoi(value);
-    uint32_t sys_thread_cnt = 8;
+    int64_t omp_thread = std::stoll(value);
+    int64_t sys_thread_cnt = 8;
     CommonUtil::GetSystemAvailableThreads(sys_thread_cnt);
-    if (omp_thread > static_cast<int32_t>(sys_thread_cnt)) {
+    if (omp_thread > sys_thread_cnt) {
         std::string msg = "Invalid omp thread num: " + value +
                           ". Possible reason: engine_config.omp_thread_num exceeds system cpu cores.";
         return Status(SERVER_INVALID_ARGUMENT, msg);
@@ -657,14 +657,14 @@ Config::CheckGpuResourceConfigCacheCapacity(const std::string& value) {
                           ". Possible reason: gpu_resource_config.cache_capacity is not a positive integer.";
         return Status(SERVER_INVALID_ARGUMENT, msg);
     } else {
-        uint64_t gpu_cache_capacity = std::stoi(value) * GB;
-        std::vector<int32_t> gpu_ids;
+        int64_t gpu_cache_capacity = std::stoll(value) * GB;
+        std::vector<int64_t> gpu_ids;
         Status s = GetGpuResourceConfigBuildIndexResources(gpu_ids);
         if (!s.ok()) {
             return s;
         }
 
-        for (int32_t gpu_id : gpu_ids) {
+        for (int64_t gpu_id : gpu_ids) {
             size_t gpu_memory;
             if (!ValidationUtil::GetGpuMemory(gpu_id, gpu_memory).ok()) {
                 std::string msg = "Fail to get GPU memory for GPU device: " + std::to_string(gpu_id);
@@ -855,37 +855,37 @@ Config::GetDBConfigBackendUrl(std::string& value) {
 }
 
 Status
-Config::GetDBConfigArchiveDiskThreshold(int32_t& value) {
+Config::GetDBConfigArchiveDiskThreshold(int64_t& value) {
     std::string str =
         GetConfigStr(CONFIG_DB, CONFIG_DB_ARCHIVE_DISK_THRESHOLD, CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT);
     Status s = CheckDBConfigArchiveDiskThreshold(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
 Status
-Config::GetDBConfigArchiveDaysThreshold(int32_t& value) {
+Config::GetDBConfigArchiveDaysThreshold(int64_t& value) {
     std::string str =
         GetConfigStr(CONFIG_DB, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT);
     Status s = CheckDBConfigArchiveDaysThreshold(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
 Status
-Config::GetDBConfigInsertBufferSize(int32_t& value) {
+Config::GetDBConfigInsertBufferSize(int64_t& value) {
     std::string str = GetConfigStr(CONFIG_DB, CONFIG_DB_INSERT_BUFFER_SIZE, CONFIG_DB_INSERT_BUFFER_SIZE_DEFAULT);
     Status s = CheckDBConfigInsertBufferSize(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
@@ -927,7 +927,7 @@ Config::GetCacheConfigCpuCacheCapacity(int64_t& value) {
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
@@ -957,37 +957,37 @@ Config::GetCacheConfigCacheInsertData(bool& value) {
 }
 
 Status
-Config::GetEngineConfigUseBlasThreshold(int32_t& value) {
+Config::GetEngineConfigUseBlasThreshold(int64_t& value) {
     std::string str =
         GetConfigStr(CONFIG_ENGINE, CONFIG_ENGINE_USE_BLAS_THRESHOLD, CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT);
     Status s = CheckEngineConfigUseBlasThreshold(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
 Status
-Config::GetEngineConfigOmpThreadNum(int32_t& value) {
+Config::GetEngineConfigOmpThreadNum(int64_t& value) {
     std::string str = GetConfigStr(CONFIG_ENGINE, CONFIG_ENGINE_OMP_THREAD_NUM, CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT);
     Status s = CheckEngineConfigOmpThreadNum(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
 Status
-Config::GetEngineConfigGpuSearchThreshold(int32_t& value) {
+Config::GetEngineConfigGpuSearchThreshold(int64_t& value) {
     std::string str =
         GetConfigStr(CONFIG_ENGINE, CONFIG_ENGINE_GPU_SEARCH_THRESHOLD, CONFIG_ENGINE_GPU_SEARCH_THRESHOLD_DEFAULT);
     Status s = CheckEngineConfigGpuSearchThreshold(str);
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
@@ -1020,7 +1020,7 @@ Config::GetGpuResourceConfigCacheCapacity(int64_t& value) {
     if (!s.ok()) {
         return s;
     }
-    value = std::stoi(str);
+    value = std::stoll(str);
     return Status::OK();
 }
 
@@ -1046,7 +1046,7 @@ Config::GetGpuResourceConfigCacheThreshold(float& value) {
 }
 
 Status
-Config::GetGpuResourceConfigSearchResources(std::vector<int32_t>& value) {
+Config::GetGpuResourceConfigSearchResources(std::vector<int64_t>& value) {
     bool gpu_resource_enable = false;
     Status s = GetGpuResourceConfigEnable(gpu_resource_enable);
     if (!s.ok()) {
@@ -1065,13 +1065,13 @@ Config::GetGpuResourceConfigSearchResources(std::vector<int32_t>& value) {
         return s;
     }
     for (std::string& res : res_vec) {
-        value.push_back(std::stoi(res.substr(3)));
+        value.push_back(std::stoll(res.substr(3)));
     }
     return Status::OK();
 }
 
 Status
-Config::GetGpuResourceConfigBuildIndexResources(std::vector<int32_t>& value) {
+Config::GetGpuResourceConfigBuildIndexResources(std::vector<int64_t>& value) {
     bool gpu_resource_enable = false;
     Status s = GetGpuResourceConfigEnable(gpu_resource_enable);
     if (!s.ok()) {
@@ -1091,7 +1091,7 @@ Config::GetGpuResourceConfigBuildIndexResources(std::vector<int32_t>& value) {
         return s;
     }
     for (std::string& res : res_vec) {
-        value.push_back(std::stoi(res.substr(3)));
+        value.push_back(std::stoll(res.substr(3)));
     }
     return Status::OK();
 }

core/src/server/Config.h

@@ -210,11 +210,11 @@ class Config {
     Status
     GetDBConfigBackendUrl(std::string& value);
     Status
-    GetDBConfigArchiveDiskThreshold(int32_t& value);
+    GetDBConfigArchiveDiskThreshold(int64_t& value);
     Status
-    GetDBConfigArchiveDaysThreshold(int32_t& value);
+    GetDBConfigArchiveDaysThreshold(int64_t& value);
     Status
-    GetDBConfigInsertBufferSize(int32_t& value);
+    GetDBConfigInsertBufferSize(int64_t& value);
     Status
     GetDBConfigPreloadTable(std::string& value);
 
@@ -236,11 +236,11 @@ class Config {
 
     /* engine config */
     Status
-    GetEngineConfigUseBlasThreshold(int32_t& value);
+    GetEngineConfigUseBlasThreshold(int64_t& value);
     Status
-    GetEngineConfigOmpThreadNum(int32_t& value);
+    GetEngineConfigOmpThreadNum(int64_t& value);
     Status
-    GetEngineConfigGpuSearchThreshold(int32_t& value);
+    GetEngineConfigGpuSearchThreshold(int64_t& value);
 
     /* gpu resource config */
     Status
@@ -250,9 +250,9 @@ class Config {
     Status
     GetGpuResourceConfigCacheThreshold(float& value);
     Status
-    GetGpuResourceConfigSearchResources(std::vector<int32_t>& value);
+    GetGpuResourceConfigSearchResources(std::vector<int64_t>& value);
     Status
-    GetGpuResourceConfigBuildIndexResources(std::vector<int32_t>& value);
+    GetGpuResourceConfigBuildIndexResources(std::vector<int64_t>& value);
 
  public:
     /* server config */

core/src/server/DBWrapper.cpp

@@ -89,7 +89,7 @@ DBWrapper::StartService() {
     }
 
     // engine config
-    int32_t omp_thread;
+    int64_t omp_thread;
     s = config.GetEngineConfigOmpThreadNum(omp_thread);
     if (!s.ok()) {
         std::cerr << s.ToString() << std::endl;
@@ -100,7 +100,7 @@ DBWrapper::StartService() {
         omp_set_num_threads(omp_thread);
         SERVER_LOG_DEBUG << "Specify openmp thread number: " << omp_thread;
     } else {
-        uint32_t sys_thread_cnt = 8;
+        int64_t sys_thread_cnt = 8;
         if (CommonUtil::GetSystemAvailableThreads(sys_thread_cnt)) {
             omp_thread = static_cast<int32_t>(ceil(sys_thread_cnt * 0.5));
             omp_set_num_threads(omp_thread);
@@ -108,7 +108,7 @@ DBWrapper::StartService() {
     }
 
     // init faiss global variable
-    int32_t use_blas_threshold;
+    int64_t use_blas_threshold;
     s = config.GetEngineConfigUseBlasThreshold(use_blas_threshold);
     if (!s.ok()) {
         std::cerr << s.ToString() << std::endl;
@@ -119,7 +119,7 @@ DBWrapper::StartService() {
 
     // set archive config
     engine::ArchiveConf::CriteriaT criterial;
-    int32_t disk, days;
+    int64_t disk, days;
     s = config.GetDBConfigArchiveDiskThreshold(disk);
     if (!s.ok()) {
         std::cerr << s.ToString() << std::endl;

core/src/utils/CommonUtil.cpp

@@ -54,7 +54,7 @@ CommonUtil::GetSystemMemInfo(uint64_t& total_mem, uint64_t& free_mem) {
 }
 
 bool
-CommonUtil::GetSystemAvailableThreads(uint32_t& thread_count) {
+CommonUtil::GetSystemAvailableThreads(int64_t& thread_count) {
     // threadCnt = std::thread::hardware_concurrency();
     thread_count = sysconf(_SC_NPROCESSORS_CONF);
     thread_count *= THREAD_MULTIPLY_CPU;

core/src/utils/CommonUtil.h

@@ -30,7 +30,7 @@ class CommonUtil {
     static bool
     GetSystemMemInfo(uint64_t& total_mem, uint64_t& free_mem);
     static bool
-    GetSystemAvailableThreads(uint32_t& thread_count);
+    GetSystemAvailableThreads(int64_t& thread_count);
 
     static bool
     IsFileExist(const std::string& path);

core/src/wrapper/KnowhereResource.cpp

@@ -48,7 +48,7 @@ KnowhereResource::Initialize() {
 
     // get build index gpu resource
     server::Config& config = server::Config::GetInstance();
-    std::vector<int32_t> build_index_gpus;
+    std::vector<int64_t> build_index_gpus;
     s = config.GetGpuResourceConfigBuildIndexResources(build_index_gpus);
     if (!s.ok())
         return s;
@@ -58,7 +58,7 @@ KnowhereResource::Initialize() {
     }
 
     // get search gpu resource
-    std::vector<int32_t> search_gpus;
+    std::vector<int64_t> search_gpus;
     s = config.GetGpuResourceConfigSearchResources(search_gpus);
     if (!s.ok())
         return s;

core/unittest/server/test_config.cpp

@@ -104,7 +104,6 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     milvus::server::Config& config = milvus::server::Config::GetInstance();
     milvus::Status s;
     std::string str_val;
-    int32_t int32_val;
     int64_t int64_val;
     float float_val;
     bool bool_val;
@@ -160,26 +159,26 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     ASSERT_TRUE(s.ok());
     ASSERT_TRUE(str_val == db_backend_url);
 
-    int32_t db_archive_disk_threshold = 100;
+    int64_t db_archive_disk_threshold = 100;
     s = config.SetDBConfigArchiveDiskThreshold(std::to_string(db_archive_disk_threshold));
     ASSERT_TRUE(s.ok());
-    s = config.GetDBConfigArchiveDiskThreshold(int32_val);
+    s = config.GetDBConfigArchiveDiskThreshold(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == db_archive_disk_threshold);
+    ASSERT_TRUE(int64_val == db_archive_disk_threshold);
 
-    int32_t db_archive_days_threshold = 365;
+    int64_t db_archive_days_threshold = 365;
     s = config.SetDBConfigArchiveDaysThreshold(std::to_string(db_archive_days_threshold));
     ASSERT_TRUE(s.ok());
-    s = config.GetDBConfigArchiveDaysThreshold(int32_val);
+    s = config.GetDBConfigArchiveDaysThreshold(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == db_archive_days_threshold);
+    ASSERT_TRUE(int64_val == db_archive_days_threshold);
 
-    int32_t db_insert_buffer_size = 2;
+    int64_t db_insert_buffer_size = 2;
     s = config.SetDBConfigInsertBufferSize(std::to_string(db_insert_buffer_size));
     ASSERT_TRUE(s.ok());
-    s = config.GetDBConfigInsertBufferSize(int32_val);
+    s = config.GetDBConfigInsertBufferSize(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == db_insert_buffer_size);
+    ASSERT_TRUE(int64_val == db_insert_buffer_size);
 
     /* metric config */
     bool metric_enable_monitor = false;
@@ -223,26 +222,26 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     ASSERT_TRUE(bool_val == cache_insert_data);
 
     /* engine config */
-    int32_t engine_use_blas_threshold = 50;
+    int64_t engine_use_blas_threshold = 50;
     s = config.SetEngineConfigUseBlasThreshold(std::to_string(engine_use_blas_threshold));
     ASSERT_TRUE(s.ok());
-    s = config.GetEngineConfigUseBlasThreshold(int32_val);
+    s = config.GetEngineConfigUseBlasThreshold(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == engine_use_blas_threshold);
+    ASSERT_TRUE(int64_val == engine_use_blas_threshold);
 
-    int32_t engine_omp_thread_num = 8;
+    int64_t engine_omp_thread_num = 8;
     s = config.SetEngineConfigOmpThreadNum(std::to_string(engine_omp_thread_num));
     ASSERT_TRUE(s.ok());
-    s = config.GetEngineConfigOmpThreadNum(int32_val);
+    s = config.GetEngineConfigOmpThreadNum(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == engine_omp_thread_num);
+    ASSERT_TRUE(int64_val == engine_omp_thread_num);
 
-    int32_t engine_gpu_search_threshold = 800;
+    int64_t engine_gpu_search_threshold = 800;
     s = config.SetEngineConfigGpuSearchThreshold(std::to_string(engine_gpu_search_threshold));
     ASSERT_TRUE(s.ok());
-    s = config.GetEngineConfigGpuSearchThreshold(int32_val);
+    s = config.GetEngineConfigGpuSearchThreshold(int64_val);
     ASSERT_TRUE(s.ok());
-    ASSERT_TRUE(int32_val == engine_gpu_search_threshold);
+    ASSERT_TRUE(int64_val == engine_gpu_search_threshold);
 
     /* gpu resource config */
     bool resource_enable_gpu = true;
@@ -267,7 +266,7 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     ASSERT_TRUE(float_val == gpu_cache_threshold);
 
     std::vector<std::string> search_resources = {"gpu0"};
-    std::vector<int32_t> search_res_vec;
+    std::vector<int64_t> search_res_vec;
     std::string search_res_str;
     milvus::server::StringHelpFunctions::MergeStringWithDelimeter(
         search_resources, milvus::server::CONFIG_GPU_RESOURCE_DELIMITER, search_res_str);
@@ -276,11 +275,11 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     s = config.GetGpuResourceConfigSearchResources(search_res_vec);
     ASSERT_TRUE(s.ok());
     for (size_t i = 0; i < search_resources.size(); i++) {
-        ASSERT_TRUE(std::stoi(search_resources[i].substr(3)) == search_res_vec[i]);
+        ASSERT_TRUE(std::stoll(search_resources[i].substr(3)) == search_res_vec[i]);
     }
 
     std::vector<std::string> build_index_resources = {"gpu0"};
-    std::vector<int32_t> build_index_res_vec;
+    std::vector<int64_t> build_index_res_vec;
     std::string build_index_res_str;
     milvus::server::StringHelpFunctions::MergeStringWithDelimeter(
         build_index_resources, milvus::server::CONFIG_GPU_RESOURCE_DELIMITER, build_index_res_str);
@@ -289,7 +288,7 @@ TEST_F(ConfigTest, SERVER_CONFIG_VALID_TEST) {
     s = config.GetGpuResourceConfigBuildIndexResources(build_index_res_vec);
     ASSERT_TRUE(s.ok());
     for (size_t i = 0; i < build_index_resources.size(); i++) {
-        ASSERT_TRUE(std::stoi(build_index_resources[i].substr(3)) == build_index_res_vec[i]);
+        ASSERT_TRUE(std::stoll(build_index_resources[i].substr(3)) == build_index_res_vec[i]);
     }
 #endif
 }

core/unittest/server/test_util.cpp

@@ -60,7 +60,7 @@ TEST(UtilTest, COMMON_TEST) {
     ASSERT_GT(total_mem, 0);
     ASSERT_GT(free_mem, 0);
 
-    uint32_t thread_cnt = 0;
+    int64_t thread_cnt = 0;
     milvus::server::CommonUtil::GetSystemAvailableThreads(thread_cnt);
     ASSERT_GT(thread_cnt, 0);