diff --git a/CHANGELOG.md b/CHANGELOG.md
index 42d5b8978f4ee0432c56ef7e69076a31366b5c89..7d88bc270e7493e1bea0ab322fe32c4cf3eaa778 100644
--- a/CHANGELOG.md
+++ b/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
 
diff --git a/core/src/db/Options.h b/core/src/db/Options.h
index ebecb4de5a0ff2c51174cb123d9cd6466ae54bde..91459a8d5fac1217e616575790a0d53328cf03b1 100644
--- a/core/src/db/Options.h
+++ b/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());
 
diff --git a/core/src/db/engine/ExecutionEngineImpl.cpp b/core/src/db/engine/ExecutionEngineImpl.cpp
index 4f2f5422546b23fe503281c2da426072dc2cd1eb..973d8b59129f8269ed0460f752f7868b654f06fa 100644
--- a/core/src/db/engine/ExecutionEngineImpl.cpp
+++ b/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) {
diff --git a/core/src/db/engine/ExecutionEngineImpl.h b/core/src/db/engine/ExecutionEngineImpl.h
index 7eb304426ec9d30c0f91ec9f5de0537df5266de4..da0e7cfb6489022050c31f462440be3f6417ddfc 100644
--- a/core/src/db/engine/ExecutionEngineImpl.h
+++ b/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
diff --git a/core/src/scheduler/SchedInst.cpp b/core/src/scheduler/SchedInst.cpp
index 867052ef5dcc3232f9abf3cfd83d75b1f77b539b..69d293f986891844f953b4ed9f8291e15783e6d7 100644
--- a/core/src/scheduler/SchedInst.cpp
+++ b/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);
 
diff --git a/core/src/scheduler/optimizer/BuildIndexPass.cpp b/core/src/scheduler/optimizer/BuildIndexPass.cpp
index cd1b7550d8ef519432cf7ae4ffac7e945b50a807..d535b9675fa74a0935b9263c850962cff79b2d80 100644
--- a/core/src/scheduler/optimizer/BuildIndexPass.cpp
+++ b/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;
diff --git a/core/src/scheduler/optimizer/FaissFlatPass.h b/core/src/scheduler/optimizer/FaissFlatPass.h
index 60adf62a0758ca6124e8c2266679b0d1fa7b14fd..f219bebdf3713809418035af44e0ad223c290f11 100644
--- a/core/src/scheduler/optimizer/FaissFlatPass.h
+++ b/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>;
diff --git a/core/src/scheduler/optimizer/FaissIVFFlatPass.h b/core/src/scheduler/optimizer/FaissIVFFlatPass.h
index 9264db32a88f2bbde1d533f115046f748dc230b2..2d15539014245afecc7c590190d12f7892675e92 100644
--- a/core/src/scheduler/optimizer/FaissIVFFlatPass.h
+++ b/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>;
diff --git a/core/src/scheduler/optimizer/FaissIVFSQ8HPass.cpp b/core/src/scheduler/optimizer/FaissIVFSQ8HPass.cpp
index b63a0f7490c987e749edfddf7dcfb6a9889dca7a..a99e861e036edf1b13ef6f76700b3c751d998945 100644
--- a/core/src/scheduler/optimizer/FaissIVFSQ8HPass.cpp
+++ b/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);
 }
diff --git a/core/src/scheduler/optimizer/FaissIVFSQ8HPass.h b/core/src/scheduler/optimizer/FaissIVFSQ8HPass.h
index fa830ff08ae4ef23fec16c71250e980b1f1c2b04..0d2892809fd1ba606b3e655e95040c328c84d53c 100644
--- a/core/src/scheduler/optimizer/FaissIVFSQ8HPass.h
+++ b/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>;
diff --git a/core/src/scheduler/optimizer/FaissIVFSQ8Pass.h b/core/src/scheduler/optimizer/FaissIVFSQ8Pass.h
index c5853283f762b0a91b39e612f1255390cb67098e..e92ea2fe4e7ca0454ade7018c875b3e3ea3f6190 100644
--- a/core/src/scheduler/optimizer/FaissIVFSQ8Pass.h
+++ b/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>;
diff --git a/core/src/server/Config.cpp b/core/src/server/Config.cpp
index 2ff91bfe3ab90652357d4f28194467e6c84dbf74..f3efcff0cc23bf51b4d38518ec245fe6eccb9439 100644
--- a/core/src/server/Config.cpp
+++ b/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();
 }
diff --git a/core/src/server/Config.h b/core/src/server/Config.h
index a6e78671b3082920e74a8924d5d2a049ddd6b3d8..0907080a6fa0c6528e0305f3834cae599728e5b5 100644
--- a/core/src/server/Config.h
+++ b/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 */
diff --git a/core/src/server/DBWrapper.cpp b/core/src/server/DBWrapper.cpp
index 1ff914dc6937f12a213bf569e65b6292c3636e09..f7a43d671c44d73512daba82471292d70acaa395 100644
--- a/core/src/server/DBWrapper.cpp
+++ b/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;
diff --git a/core/src/utils/CommonUtil.cpp b/core/src/utils/CommonUtil.cpp
index fbf3112aeb29b80e6e228fc322ab09f8b5d1df94..26e43619fb405136b5d9ac706a8d3375d621cee0 100644
--- a/core/src/utils/CommonUtil.cpp
+++ b/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;
diff --git a/core/src/utils/CommonUtil.h b/core/src/utils/CommonUtil.h
index 939bdd6d31e8ee46ead21b70bafbc930c17be9d8..121196986a31797654da4a256335be3db0232e09 100644
--- a/core/src/utils/CommonUtil.h
+++ b/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);
diff --git a/core/src/wrapper/KnowhereResource.cpp b/core/src/wrapper/KnowhereResource.cpp
index bf6675cafa7725404bf833d2e3acf6fe50b74245..5a2296b16e95dfa2c2f4194b1badf313237619ff 100644
--- a/core/src/wrapper/KnowhereResource.cpp
+++ b/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;
diff --git a/core/unittest/server/test_config.cpp b/core/unittest/server/test_config.cpp
index e0fde62916e842701a3c34ee7c36e102953c87db..664a08d63105f54d32271462464f1ada41a9dcbf 100644
--- a/core/unittest/server/test_config.cpp
+++ b/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
 }
diff --git a/core/unittest/server/test_util.cpp b/core/unittest/server/test_util.cpp
index 68400f2454b58b1a1c7c6e2fb582ab16563a9ccd..e5884cac6546d32b796b0fbb92cd69e30eae1f6a 100644
--- a/core/unittest/server/test_util.cpp
+++ b/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);