MS-574 uniform config name format, add config default value

Former-commit-id: 1b0f3de46457c54e3f5fa890f94c1a99d274f8ff

cpp/conf/server_config.template

 server_config:
   address: 0.0.0.0              # milvus server ip address (IPv4)
-  port: 19530                 # the port milvus listen to, default: 19530, range: 1025 ~ 65534
-  mode: single                # milvus deployment type: single, cluster, read_only
-  time_zone: UTC+8            # Use the UTC-x or UTC+x to specify a time zone. eg. UTC+8 for China Standard Time
+  port: 19530                   # port range: 1025 ~ 65534
+  mode: single                  # deployment type: single, cluster, read_only
+  time_zone: UTC+8
 
 db_config:
-  db_path: @MILVUS_DB_PATH@             # milvus data storage path
-  db_slave_path:                        # secondry data storage path, split by semicolon
+  db_path: @MILVUS_DB_PATH@     # milvus database path
+  db_slave_path:                # secondary database path, split by semicolon
 
   # URI format: dialect://username:password@host:port/database
   # All parts except dialect are optional, but you MUST include the delimiters
   # Currently dialect supports mysql or sqlite
   db_backend_url: sqlite://:@:/
 
-  archive_disk_threshold: 0        # triger archive action if storage size exceed this value, 0 means no limit, unit: GB
-  archive_days_threshold: 0        # files older than x days will be archived, 0 means no limit, unit: day
-  insert_buffer_size: 4            # maximum insert buffer size allowed, default: 4, unit: GB, should be at least 1 GB.
-                                   # the sum of insert_buffer_size and cpu_cache_capacity should be less than total memory, unit: GB
-  build_index_gpu: 0               # which gpu is used to build index, default: 0, range: 0 ~ gpu number - 1
+  archive_disk_threshold: 0     # GB, file will be archived when disk usage exceed, 0 for no limit
+  archive_days_threshold: 0     # DAYS, older files will be archived, 0 for no limit
+  buffer_size: 4                # GB, maximum insert buffer size allowed
+  build_index_gpu: 0            # gpu id used for building index
 
 metric_config:
-  is_startup: off                       # if monitoring start: on, off
-  collector: prometheus                 # metrics collector: prometheus
-  prometheus_config:                    # following are prometheus configure
-    port: 8080                          # the port prometheus use to fetch metrics
-    push_gateway_ip_address: 127.0.0.1  # push method configure: push gateway ip address
-    push_gateway_port: 9091             # push method configure: push gateway port
+  auto_bootup: off              # whether enable monitoring when bootup
+  collector: prometheus         # prometheus
+  prometheus_config:
+    port: 8080                  # port prometheus used to fetch metrics
 
 cache_config:
-  cpu_cache_capacity: 16            # how many memory are used as cache, unit: GB, range: 0 ~ less than total memory
-  cpu_cache_free_percent: 0.85      # old data will be erased from cache when cache is full, this value specify how much memory should be kept, range: greater than zero ~ 1.0
-  insert_cache_immediately: false   # insert data will be load into cache immediately for hot query
+  cpu_mem_capacity: 16          # GB, CPU memory size used for cache
+  cpu_mem_threshold: 0.85       # percent of data kept when cache cleanup triggered
+  insert_immediately: false     # whether load data into cache when insert
 
 engine_config:
-  use_blas_threshold: 20
+  blas_threshold: 20
 
 resource_config:
   mode: simple
-  resources:
-#    - cpu
+  pool:
+    - cpu
     - gpu0

cpp/src/cache/CpuCacheMgr.cpp

@@ -30,11 +30,13 @@ namespace {
 
 CpuCacheMgr::CpuCacheMgr() {
     server::ConfigNode& config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_CACHE);
-    int64_t cap = config.GetInt64Value(server::CONFIG_CPU_CACHE_CAPACITY, 16);
+    int64_t cap =
+        config.GetInt64Value(server::CONFIG_CACHE_CPU_MEM_CAPACITY, std::stoi(server::CONFIG_CACHE_CPU_MEM_CAPACITY_DEFAULT));
     cap *= unit;
     cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL<<32);
 
-    double free_percent = config.GetDoubleValue(server::CACHE_FREE_PERCENT, 0.85);
+    double free_percent =
+        config.GetDoubleValue(server::CONFIG_CACHE_CPU_MEM_THRESHOLD, std::stof(server::CONFIG_CACHE_CPU_MEM_THRESHOLD_DEFAULT));
     if(free_percent > 0.0 && free_percent <= 1.0) {
         cache_->set_freemem_percent(free_percent);
     } else {

cpp/src/cache/GpuCacheMgr.cpp

@@ -35,11 +35,13 @@ namespace {
 GpuCacheMgr::GpuCacheMgr() {
     server::ConfigNode& config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_CACHE);
 
-    int64_t cap = config.GetInt64Value(server::CONFIG_GPU_CACHE_CAPACITY, 0);
+    int64_t cap =
+        config.GetInt64Value(server::CONFIG_CACHE_GPU_MEM_CAPACITY, std::stoi(server::CONFIG_CACHE_GPU_MEM_CAPACITY_DEFAULT));
     cap *= G_BYTE;
     cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL<<32);
 
-    double free_percent = config.GetDoubleValue(server::GPU_CACHE_FREE_PERCENT, 0.85);
+    double free_percent =
+        config.GetDoubleValue(server::CONFIG_CACHE_GPU_MEM_THRESHOLD, std::stof(server::CONFIG_CACHE_GPU_MEM_THRESHOLD_DEFAULT));
     if (free_percent > 0.0 && free_percent <= 1.0) {
         cache_->set_freemem_percent(free_percent);
     } else {

cpp/src/db/engine/ExecutionEngineImpl.cpp

@@ -336,7 +336,7 @@ Status ExecutionEngineImpl::Init() {
     using namespace zilliz::milvus::server;
     ServerConfig &config = ServerConfig::GetInstance();
     ConfigNode server_config = config.GetConfig(CONFIG_DB);
-    gpu_num_ = server_config.GetInt32Value(CONFIG_DB_BUILD_INDEX_GPU, 0);
+    gpu_num_ = server_config.GetInt32Value(CONFIG_DB_BUILD_INDEX_GPU, std::stoi(CONFIG_DB_BUILD_INDEX_GPU_DEFAULT));
 
     return Status::OK();
 }

cpp/src/main.cpp

@@ -110,7 +110,7 @@ main(int argc, char *argv[]) {
     signal(SIGUSR2, server::SignalUtil::HandleSignal);
     signal(SIGTERM, server::SignalUtil::HandleSignal);
 
-    server::Server &server = server::Server::Instance();
+    server::Server &server = server::Server::GetInstance();
     server.Init(start_daemonized, pid_filename, config_filename, log_config_file);
     server.Start();
 

cpp/src/metrics/Metrics.cpp

@@ -32,7 +32,8 @@ Metrics::GetInstance() {
 MetricsBase &
 Metrics::CreateMetricsCollector() {
     ConfigNode &config = ServerConfig::GetInstance().GetConfig(CONFIG_METRIC);
-    std::string collector_type_str = config.GetValue(CONFIG_METRIC_COLLECTOR);
+    std::string collector_type_str =
+        config.GetValue(CONFIG_METRIC_COLLECTOR, CONFIG_METRIC_COLLECTOR_DEFAULT);
 
     if (collector_type_str == "prometheus") {
         return PrometheusMetrics::GetInstance();

cpp/src/metrics/PrometheusMetrics.cpp

@@ -26,15 +26,19 @@ namespace zilliz {
 namespace milvus {
 namespace server {
 
-    ErrorCode
+ErrorCode
 PrometheusMetrics::Init() {
     try {
-        ConfigNode &configNode = ServerConfig::GetInstance().GetConfig(CONFIG_METRIC);
-        startup_ = configNode.GetValue(CONFIG_METRIC_IS_STARTUP) == "on";
-        if(!startup_) return SERVER_SUCCESS;
+        ConfigNode &metric_config = ServerConfig::GetInstance().GetConfig(CONFIG_METRIC);
+        startup_ =
+            metric_config.GetBoolValue(CONFIG_METRIC_AUTO_BOOTUP, std::stoi(CONFIG_METRIC_AUTO_BOOTUP_DEFAULT));
+        if (!startup_) return SERVER_SUCCESS;
+
         // Following should be read from config file.
-        const std::string bind_address = configNode.GetChild(CONFIG_PROMETHEUS).GetValue(CONFIG_METRIC_PROMETHEUS_PORT);
-        const std::string uri = std::string("/metrics");
+        ConfigNode &prometheus_config = metric_config.GetChild(CONFIG_METRIC_PROMETHEUS);
+        const std::string bind_address =
+            prometheus_config.GetValue(CONFIG_METRIC_PROMETHEUS_PORT, CONFIG_METRIC_PROMETHEUS_PORT_DEFAULT);
+        const std::string uri = std::string("/tmp/metrics");
         const std::size_t num_threads = 2;
 
         // Init Exposer

cpp/src/scheduler/SchedInst.cpp

@@ -39,12 +39,12 @@ std::mutex JobMgrInst::mutex_;
 void
 load_simple_config() {
     server::ConfigNode &config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_RESOURCE);
-    auto mode = config.GetValue("mode", "simple");
+    auto mode = config.GetValue(server::CONFIG_RESOURCE_MODE, server::CONFIG_RESOURCE_MODE_DEFAULT);
 
-    auto resources = config.GetSequence("resources");
+    auto pool = config.GetSequence(server::CONFIG_RESOURCE_POOL);
     bool cpu = false;
     std::set<uint64_t> gpu_ids;
-    for (auto &resource : resources) {
+    for (auto &resource : pool) {
         if (resource == "cpu") {
             cpu = true;
             break;

cpp/src/server/DBWrapper.cpp

@@ -38,7 +38,7 @@ Status DBWrapper::StartService() {
     //db config
     engine::DBOptions opt;
     ConfigNode& db_config = ServerConfig::GetInstance().GetConfig(CONFIG_DB);
-    opt.meta.backend_uri = db_config.GetValue(CONFIG_DB_URL);
+    opt.meta.backend_uri = db_config.GetValue(CONFIG_DB_BACKEND_URL);
     std::string db_path = db_config.GetValue(CONFIG_DB_PATH);
     opt.meta.path = db_path + "/db";
 
@@ -47,10 +47,11 @@ Status DBWrapper::StartService() {
 
     // cache config
     ConfigNode& cache_config = ServerConfig::GetInstance().GetConfig(CONFIG_CACHE);
-    opt.insert_cache_immediately_ = cache_config.GetBoolValue(CONFIG_INSERT_CACHE_IMMEDIATELY, false);
+    opt.insert_cache_immediately_ =
+        cache_config.GetBoolValue(CONFIG_CACHE_INSERT_IMMEDIATELY, std::stoi(CONFIG_CACHE_INSERT_IMMEDIATELY_DEFAULT));
 
     ConfigNode& serverConfig = ServerConfig::GetInstance().GetConfig(CONFIG_SERVER);
-    std::string mode = serverConfig.GetValue(CONFIG_CLUSTER_MODE, "single");
+    std::string mode = serverConfig.GetValue(CONFIG_SERVER_MODE, CONFIG_SERVER_MODE_DEFAULT);
     if (mode == "single") {
         opt.mode = engine::DBOptions::MODE::SINGLE;
     }
@@ -67,7 +68,8 @@ Status DBWrapper::StartService() {
 
     // engine config
     ConfigNode& engine_config = ServerConfig::GetInstance().GetConfig(CONFIG_ENGINE);
-    int32_t omp_thread = engine_config.GetInt32Value(CONFIG_OMP_THREAD_NUM, 0);
+    int32_t omp_thread =
+        engine_config.GetInt32Value(CONFIG_ENGINE_OMP_THREAD_NUM, std::stoi(CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT));
     if(omp_thread > 0) {
         omp_set_num_threads(omp_thread);
         SERVER_LOG_DEBUG << "Specify openmp thread number: " << omp_thread;
@@ -79,12 +81,16 @@ Status DBWrapper::StartService() {
         }
     }
 
-    faiss::distance_compute_blas_threshold = engine_config.GetInt32Value(CONFIG_DCBT, 20);//init faiss global variable
+    //init faiss global variable
+    faiss::distance_compute_blas_threshold =
+        engine_config.GetInt32Value(CONFIG_ENGINE_BLAS_THRESHOLD, std::stoi(CONFIG_ENGINE_BLAS_THRESHOLD_DEFAULT));
 
     //set archive config
     engine::ArchiveConf::CriteriaT criterial;
-    int64_t disk = db_config.GetInt64Value(CONFIG_DB_ARCHIVE_DISK, 0);
-    int64_t days = db_config.GetInt64Value(CONFIG_DB_ARCHIVE_DAYS, 0);
+    int64_t disk =
+        db_config.GetInt64Value(CONFIG_DB_ARCHIVE_DISK_THRESHOLD, std::stoi(CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT));
+    int64_t days =
+        db_config.GetInt64Value(CONFIG_DB_ARCHIVE_DAYS_THRESHOLD, std::stoi(CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT));
     if(disk > 0) {
         criterial[engine::ARCHIVE_CONF_DISK] = disk;
     }

cpp/src/server/Server.cpp

@@ -43,18 +43,11 @@ namespace milvus {
 namespace server {
 
 Server &
-Server::Instance() {
+Server::GetInstance() {
     static Server server;
     return server;
 }
 
-Server::Server() {
-
-}
-Server::~Server() {
-
-}
-
 void
 Server::Init(int64_t daemonized,
              const std::string &pid_filename,
@@ -171,7 +164,7 @@ Server::Start() {
         ServerConfig &config = ServerConfig::GetInstance();
         ConfigNode server_config = config.GetConfig(CONFIG_SERVER);
 
-        std::string time_zone = server_config.GetValue(CONFIG_TIME_ZONE, "UTC+8");
+        std::string time_zone = server_config.GetValue(CONFIG_SERVER_TIME_ZONE, CONFIG_SERVER_TIME_ZONE_DEFAULT);
         if (time_zone.length() == 3) {
             time_zone = "CUT";
         } else {

cpp/src/server/Server.h

@@ -29,7 +29,7 @@ namespace server {
 
 class Server {
  public:
-    static Server &Instance();
+    static Server &GetInstance();
 
     void Init(int64_t daemonized,
               const std::string &pid_filename,
@@ -40,8 +40,8 @@ class Server {
     void Stop();
 
  private:
-    Server();
-    ~Server();
+    Server() = default;
+    ~Server() = default;
 
     void Daemonize();
 

cpp/src/server/ServerConfig.cpp

@@ -109,50 +109,51 @@ ServerConfig::CheckServerConfig() {
     bool okay = true;
     ConfigNode server_config = GetConfig(CONFIG_SERVER);
 
-    std::string ip_address = server_config.GetValue(CONFIG_SERVER_ADDRESS, "127.0.0.1");
+    std::string ip_address = server_config.GetValue(CONFIG_SERVER_ADDRESS, CONFIG_SERVER_ADDRESS_DEFAULT);
     if (!ValidationUtil::ValidateIpAddress(ip_address).ok()) {
         std::cerr << "ERROR: invalid server IP address: " << ip_address << std::endl;
         okay = false;
     }
 
-    std::string port_str = server_config.GetValue(CONFIG_SERVER_PORT, "19530");
+    std::string port_str = server_config.GetValue(CONFIG_SERVER_PORT, CONFIG_SERVER_PORT_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(port_str).ok()) {
         std::cerr << "ERROR: port " << port_str << " is not a number" << std::endl;
         okay = false;
     } else {
         int32_t port = std::stol(port_str);
-        if (port < 1025 | port > 65534) {
-            std::cerr << "ERROR: port " << port_str << " out of range [1025, 65534]" << std::endl;
+        if (!(port > 1024 && port < 65535)) {
+            std::cerr << "ERROR: port " << port_str << " out of range (1024, 65535)" << std::endl;
             okay = false;
         }
     }
 
-    std::string mode = server_config.GetValue(CONFIG_CLUSTER_MODE, "single");
+    std::string mode = server_config.GetValue(CONFIG_SERVER_MODE, CONFIG_SERVER_MODE_DEFAULT);
     if (mode != "single" && mode != "cluster" && mode != "read_only") {
         std::cerr << "ERROR: mode " << mode << " is not one of ['single', 'cluster', 'read_only']" << std::endl;
         okay = false;
     }
 
-    std::string time_zone = server_config.GetValue(CONFIG_TIME_ZONE, "UTC+8");
+    std::string time_zone = server_config.GetValue(CONFIG_SERVER_TIME_ZONE, CONFIG_SERVER_TIME_ZONE_DEFAULT);
     int flag = 0;
-    if(time_zone.length() < 3)
+    if (time_zone.length() <= 3) {
         flag = 1;
-    else if(time_zone.substr(0, 3) != "UTC")
+    } else {
+        if (time_zone.substr(0, 3) != "UTC") {
             flag = 1;
-    else if(time_zone.length() > 3){
+        } else {
             try {
-            stoi(time_zone.substr(3, std::string::npos));
-        }
-        catch (std::invalid_argument &) {
+                stoi(time_zone.substr(3));
+            } catch (...) {
                 flag = 1;
             }
         }
-    if(flag == 1){
-        std::cerr << "ERROR: time_zone " << time_zone << " is not in a right format" << std::endl;
+    }
+    if (flag == 1) {
+        std::cerr << "ERROR: time_zone " << time_zone << " format wrong" << std::endl;
         okay = false;
     }
 
-    return (okay ? Status::OK() : Status(SERVER_INVALID_ARGUMENT, "Server config is illegal"));
+    return (okay ? Status::OK() : Status(SERVER_INVALID_ARGUMENT, "Illegal server config"));
 }
 
 Status
@@ -182,25 +183,25 @@ ServerConfig::CheckDBConfig() {
         okay = false;
     }
 
-    std::string db_backend_url = db_config.GetValue(CONFIG_DB_URL);
+    std::string db_backend_url = db_config.GetValue(CONFIG_DB_BACKEND_URL);
     if (!ValidationUtil::ValidateDbURI(db_backend_url).ok()) {
         std::cerr << "ERROR: invalid db_backend_url: " << db_backend_url << std::endl;
         okay = false;
     }
 
-    std::string archive_disk_threshold_str = db_config.GetValue(CONFIG_DB_INSERT_BUFFER_SIZE, "0");
+    std::string archive_disk_threshold_str = db_config.GetValue(CONFIG_DB_ARCHIVE_DISK_THRESHOLD, CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(archive_disk_threshold_str).ok()) {
         std::cerr << "ERROR: archive_disk_threshold " << archive_disk_threshold_str << " is not a number" << std::endl;
         okay = false;
     }
 
-    std::string archive_days_threshold_str = db_config.GetValue(CONFIG_DB_INSERT_BUFFER_SIZE, "0");
+    std::string archive_days_threshold_str = db_config.GetValue(CONFIG_DB_ARCHIVE_DAYS_THRESHOLD, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(archive_days_threshold_str).ok()) {
         std::cerr << "ERROR: archive_days_threshold " << archive_days_threshold_str << " is not a number" << std::endl;
         okay = false;
     }
 
-    std::string insert_buffer_size_str = db_config.GetValue(CONFIG_DB_INSERT_BUFFER_SIZE, "4");
+    std::string insert_buffer_size_str = db_config.GetValue(CONFIG_DB_BUFFER_SIZE, CONFIG_DB_BUFFER_SIZE_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(insert_buffer_size_str).ok()) {
         std::cerr << "ERROR: insert_buffer_size " << insert_buffer_size_str << " is not a number" << std::endl;
         okay = false;
@@ -216,7 +217,7 @@ ServerConfig::CheckDBConfig() {
         }
     }
 
-    std::string gpu_index_str = db_config.GetValue(CONFIG_DB_BUILD_INDEX_GPU, "0");
+    std::string gpu_index_str = db_config.GetValue(CONFIG_DB_BUILD_INDEX_GPU, CONFIG_DB_BUILD_INDEX_GPU_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(gpu_index_str).ok()) {
         std::cerr << "ERROR: gpu_index " << gpu_index_str << " is not a number" << std::endl;
         okay = false;
@@ -245,13 +246,14 @@ ServerConfig::CheckMetricConfig() {
     bool okay = true;
     ConfigNode metric_config = GetConfig(CONFIG_METRIC);
 
-    std::string is_startup_str = metric_config.GetValue(CONFIG_METRIC_IS_STARTUP, "off");
+    std::string is_startup_str =
+        metric_config.GetValue(CONFIG_METRIC_AUTO_BOOTUP, CONFIG_METRIC_AUTO_BOOTUP_DEFAULT);
     if (!ValidationUtil::ValidateStringIsBool(is_startup_str).ok()) {
         std::cerr << "ERROR: invalid is_startup config: " << is_startup_str << std::endl;
         okay = false;
     }
 
-    std::string port_str = metric_config.GetChild(CONFIG_PROMETHEUS).GetValue(CONFIG_METRIC_PROMETHEUS_PORT, "8080");
+    std::string port_str = metric_config.GetChild(CONFIG_METRIC_PROMETHEUS).GetValue(CONFIG_METRIC_PROMETHEUS_PORT, "8080");
     if (!ValidationUtil::ValidateStringIsNumber(port_str).ok()) {
         std::cerr << "ERROR: port specified in prometheus_config " << port_str << " is not a number" << std::endl;
         okay = false;
@@ -274,7 +276,8 @@ ServerConfig::CheckCacheConfig() {
     bool okay = true;
     ConfigNode cache_config = GetConfig(CONFIG_CACHE);
 
-    std::string cpu_cache_capacity_str = cache_config.GetValue(CONFIG_CPU_CACHE_CAPACITY, "16");
+    std::string cpu_cache_capacity_str =
+        cache_config.GetValue(CONFIG_CACHE_CPU_MEM_CAPACITY, CONFIG_CACHE_CPU_MEM_CAPACITY_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(cpu_cache_capacity_str).ok()) {
         std::cerr << "ERROR: cpu_cache_capacity " << cpu_cache_capacity_str << " is not a number" << std::endl;
         okay = false;
@@ -292,15 +295,17 @@ ServerConfig::CheckCacheConfig() {
             std::cerr << "Warning: cpu_cache_capacity value is too aggressive" << std::endl;
         }
 
-        uint64_t insert_buffer_size = (uint64_t) GetConfig(CONFIG_DB).GetInt32Value(CONFIG_DB_INSERT_BUFFER_SIZE, 4);
-        insert_buffer_size *= GB;
-        if (insert_buffer_size + cpu_cache_capacity >= total_mem) {
+        uint64_t buffer_size =
+            (uint64_t) GetConfig(CONFIG_DB).GetInt32Value(CONFIG_DB_BUFFER_SIZE, std::stoi(CONFIG_DB_BUFFER_SIZE_DEFAULT));
+        buffer_size *= GB;
+        if (buffer_size + cpu_cache_capacity >= total_mem) {
             std::cerr << "ERROR: sum of cpu_cache_capacity and insert_buffer_size exceed system memory" << std::endl;
             okay = false;
         }
     }
 
-    std::string cpu_cache_free_percent_str = cache_config.GetValue(CACHE_FREE_PERCENT, "0.85");
+    std::string cpu_cache_free_percent_str =
+        cache_config.GetValue(CONFIG_CACHE_CPU_MEM_THRESHOLD, CONFIG_CACHE_CPU_MEM_THRESHOLD_DEFAULT);
     double cpu_cache_free_percent;
     if (!ValidationUtil::ValidateStringIsDouble(cpu_cache_free_percent_str, cpu_cache_free_percent).ok()) {
         std::cerr << "ERROR: cpu_cache_free_percent " << cpu_cache_free_percent_str << " is not a double" << std::endl;
@@ -311,13 +316,15 @@ ServerConfig::CheckCacheConfig() {
         okay = false;
     }
 
-    std::string insert_cache_immediately_str = cache_config.GetValue(CONFIG_INSERT_CACHE_IMMEDIATELY, "false");
+    std::string insert_cache_immediately_str =
+        cache_config.GetValue(CONFIG_CACHE_INSERT_IMMEDIATELY, CONFIG_CACHE_INSERT_IMMEDIATELY_DEFAULT);
     if (!ValidationUtil::ValidateStringIsBool(insert_cache_immediately_str).ok()) {
         std::cerr << "ERROR: invalid insert_cache_immediately config: " << insert_cache_immediately_str << std::endl;
         okay = false;
     }
 
-    std::string gpu_cache_capacity_str = cache_config.GetValue(CONFIG_GPU_CACHE_CAPACITY, "0");
+    std::string gpu_cache_capacity_str =
+        cache_config.GetValue(CONFIG_CACHE_GPU_MEM_CAPACITY, CONFIG_CACHE_GPU_MEM_CAPACITY_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(gpu_cache_capacity_str).ok()) {
         std::cerr << "ERROR: gpu_cache_capacity " << gpu_cache_capacity_str << " is not a number" << std::endl;
         okay = false;
@@ -325,7 +332,7 @@ ServerConfig::CheckCacheConfig() {
     else {
         uint64_t gpu_cache_capacity = (uint64_t) std::stol(gpu_cache_capacity_str);
         gpu_cache_capacity *= GB;
-        int gpu_index = GetConfig(CONFIG_DB).GetInt32Value(CONFIG_DB_BUILD_INDEX_GPU, 0);
+        int gpu_index = GetConfig(CONFIG_DB).GetInt32Value(CONFIG_DB_BUILD_INDEX_GPU, std::stoi(CONFIG_DB_BUILD_INDEX_GPU_DEFAULT));
         size_t gpu_memory;
         if (!ValidationUtil::GetGpuMemory(gpu_index, gpu_memory).ok()) {
             std::cerr << "ERROR: could not get gpu memory for device " << gpu_index << std::endl;
@@ -341,7 +348,8 @@ ServerConfig::CheckCacheConfig() {
         }
     }
 
-    std::string gpu_cache_free_percent_str = cache_config.GetValue(GPU_CACHE_FREE_PERCENT, "0.85");
+    std::string gpu_cache_free_percent_str =
+        cache_config.GetValue(CONFIG_CACHE_GPU_MEM_THRESHOLD, CONFIG_CACHE_GPU_MEM_THRESHOLD_DEFAULT);
     double gpu_cache_free_percent;
     if (!ValidationUtil::ValidateStringIsDouble(gpu_cache_free_percent_str, gpu_cache_free_percent).ok()) {
         std::cerr << "ERROR: gpu_cache_free_percent " << gpu_cache_free_percent_str << " is not a double" << std::endl;
@@ -365,13 +373,15 @@ ServerConfig::CheckEngineConfig() {
     bool okay = true;
     ConfigNode engine_config = GetConfig(CONFIG_ENGINE);
 
-    std::string use_blas_threshold_str = engine_config.GetValue(CONFIG_DCBT, "20");
+    std::string use_blas_threshold_str =
+        engine_config.GetValue(CONFIG_ENGINE_BLAS_THRESHOLD, CONFIG_ENGINE_BLAS_THRESHOLD_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(use_blas_threshold_str).ok()) {
         std::cerr << "ERROR: use_blas_threshold " << use_blas_threshold_str << " is not a number" << std::endl;
         okay = false;
     }
 
-    std::string omp_thread_num_str = engine_config.GetValue(CONFIG_OMP_THREAD_NUM, "0");
+    std::string omp_thread_num_str =
+        engine_config.GetValue(CONFIG_ENGINE_OMP_THREAD_NUM, CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT);
     if (!ValidationUtil::ValidateStringIsNumber(omp_thread_num_str).ok()) {
         std::cerr << "ERROR: omp_thread_num " << omp_thread_num_str << " is not a number" << std::endl;
         okay = false;
@@ -393,20 +403,20 @@ ServerConfig::CheckResourceConfig() {
     /*
       resource_config:
         mode: simple
-        resources:
+        pool:
           - cpu
           - gpu0
           - gpu100
      */
     bool okay = true;
     server::ConfigNode &config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_RESOURCE);
-    auto mode = config.GetValue("mode", "simple");
+    auto mode = config.GetValue(CONFIG_RESOURCE_MODE, CONFIG_RESOURCE_MODE_DEFAULT);
     if (mode != "simple") {
         std::cerr << "ERROR: invalid resource config: mode is " << mode << std::endl;
         okay = false;
     }
-    auto resources = config.GetSequence("resources");
-    if (resources.empty()) {
+    auto pool = config.GetSequence(CONFIG_RESOURCE_POOL);
+    if (pool.empty()) {
         std::cerr << "ERROR: invalid resource config: resources empty" << std::endl;
         okay = false;
     }

cpp/src/server/ServerConfig.h

@@ -26,52 +26,69 @@ namespace zilliz {
 namespace milvus {
 namespace server {
 
+/* server config */
 static const char* CONFIG_SERVER = "server_config";
 static const char* CONFIG_SERVER_ADDRESS = "address";
+static const char* CONFIG_SERVER_ADDRESS_DEFAULT = "127.0.0.1";
 static const char* CONFIG_SERVER_PORT = "port";
-static const char* CONFIG_CLUSTER_MODE = "mode";
-static const char* CONFIG_TIME_ZONE = "time_zone";
+static const char* CONFIG_SERVER_PORT_DEFAULT = "19530";
+static const char* CONFIG_SERVER_MODE = "mode";
+static const char* CONFIG_SERVER_MODE_DEFAULT = "single";
+static const char* CONFIG_SERVER_TIME_ZONE = "time_zone";
+static const char* CONFIG_SERVER_TIME_ZONE_DEFAULT = "UTC+8";
 
+/* db config */
 static const char* CONFIG_DB = "db_config";
-static const char* CONFIG_DB_URL = "db_backend_url";
 static const char* CONFIG_DB_PATH = "db_path";
+static const char* CONFIG_DB_PATH_DEFAULT = "/tmp/milvus";
 static const char* CONFIG_DB_SLAVE_PATH = "db_slave_path";
-static const char* CONFIG_DB_ARCHIVE_DISK = "archive_disk_threshold";
-static const char* CONFIG_DB_ARCHIVE_DAYS = "archive_days_threshold";
-static const char* CONFIG_DB_INSERT_BUFFER_SIZE = "insert_buffer_size";
-static const char* CONFIG_DB_PARALLEL_REDUCE = "parallel_reduce";
+static const char* CONFIG_DB_SLAVE_PATH_DEFAULT = "";
+static const char* CONFIG_DB_BACKEND_URL = "db_backend_url";
+static const char* CONFIG_DB_BACKEND_URL_DEFAULT = "sqlite://:@:/";
+static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD = "archive_disk_threshold";
+static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT = "0";
+static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD = "archive_days_threshold";
+static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT = "0";
+static const char* CONFIG_DB_BUFFER_SIZE = "buffer_size";
+static const char* CONFIG_DB_BUFFER_SIZE_DEFAULT = "4";
 static const char* CONFIG_DB_BUILD_INDEX_GPU = "build_index_gpu";
+static const char* CONFIG_DB_BUILD_INDEX_GPU_DEFAULT = "0";
 
-static const char* CONFIG_LOG = "log_config";
-
+/* cache config */
 static const char* CONFIG_CACHE = "cache_config";
-static const char* CONFIG_CPU_CACHE_CAPACITY = "cpu_cache_capacity";
-static const char* CONFIG_GPU_CACHE_CAPACITY = "gpu_cache_capacity";
-static const char* CACHE_FREE_PERCENT = "cpu_cache_free_percent";
-static const char* CONFIG_INSERT_CACHE_IMMEDIATELY = "insert_cache_immediately";
-static const char *GPU_CACHE_FREE_PERCENT = "gpu_cache_free_percent";
-
+static const char* CONFIG_CACHE_CPU_MEM_CAPACITY = "cpu_mem_capacity";
+static const char* CONFIG_CACHE_CPU_MEM_CAPACITY_DEFAULT = "16";
+static const char* CONFIG_CACHE_GPU_MEM_CAPACITY = "gpu_mem_capacity";
+static const char* CONFIG_CACHE_GPU_MEM_CAPACITY_DEFAULT = "0";
+static const char* CONFIG_CACHE_CPU_MEM_THRESHOLD = "cpu_mem_threshold";
+static const char* CONFIG_CACHE_CPU_MEM_THRESHOLD_DEFAULT = "0.85";
+static const char* CONFIG_CACHE_GPU_MEM_THRESHOLD = "gpu_mem_threshold";
+static const char* CONFIG_CACHE_GPU_MEM_THRESHOLD_DEFAULT = "0.85";
+static const char* CONFIG_CACHE_INSERT_IMMEDIATELY = "insert_immediately";
+static const char* CONFIG_CACHE_INSERT_IMMEDIATELY_DEFAULT = "0";
+
+/* metric config */
 static const char* CONFIG_METRIC = "metric_config";
-static const char* CONFIG_METRIC_IS_STARTUP = "is_startup";
+static const char* CONFIG_METRIC_AUTO_BOOTUP = "auto_bootup";
+static const char* CONFIG_METRIC_AUTO_BOOTUP_DEFAULT = "0";
 static const char* CONFIG_METRIC_COLLECTOR = "collector";
-static const char* CONFIG_PROMETHEUS = "prometheus_config";
+static const char* CONFIG_METRIC_COLLECTOR_DEFAULT = "prometheus";
+static const char* CONFIG_METRIC_PROMETHEUS = "prometheus_config";
 static const char* CONFIG_METRIC_PROMETHEUS_PORT = "port";
+static const char* CONFIG_METRIC_PROMETHEUS_PORT_DEFAULT = "8080";
 
+/* engine config */
 static const char* CONFIG_ENGINE = "engine_config";
-static const char* CONFIG_DCBT = "use_blas_threshold";
-static const char* CONFIG_OMP_THREAD_NUM = "omp_thread_num";
+static const char* CONFIG_ENGINE_BLAS_THRESHOLD = "blas_threshold";
+static const char* CONFIG_ENGINE_BLAS_THRESHOLD_DEFAULT = "20";
+static const char* CONFIG_ENGINE_OMP_THREAD_NUM = "omp_thread_num";
+static const char* CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT = "0";
 
+/* resource config */
 static const char* CONFIG_RESOURCE = "resource_config";
-static const char* CONFIG_RESOURCES = "resources";
-static const char* CONFIG_RESOURCE_TYPE = "type";
-static const char* CONFIG_RESOURCE_DEVICE_ID = "device_id";
-static const char* CONFIG_RESOURCE_ENABLE_EXECUTOR = "enable_executor";
-static const char* CONFIG_RESOURCE_NUM = "gpu_resource_num";
-static const char* CONFIG_RESOURCE_PIN_MEMORY = "pinned_memory";
-static const char* CONFIG_RESOURCE_TEMP_MEMORY = "temp_memory";
-static const char* CONFIG_RESOURCE_CONNECTIONS = "connections";
-static const char* CONFIG_SPEED_CONNECTIONS = "speed";
-static const char* CONFIG_ENDPOINT_CONNECTIONS = "endpoint";
+static const char* CONFIG_RESOURCE_MODE = "mode";
+static const char* CONFIG_RESOURCE_MODE_DEFAULT = "simple";
+static const char* CONFIG_RESOURCE_POOL = "pool";
 
 
 class ServerConfig {

cpp/src/server/grpc_impl/GrpcServer.cpp

@@ -76,8 +76,8 @@ GrpcServer::StartService() {
     ServerConfig &config = ServerConfig::GetInstance();
     ConfigNode server_config = config.GetConfig(CONFIG_SERVER);
     ConfigNode engine_config = config.GetConfig(CONFIG_ENGINE);
-    std::string address = server_config.GetValue(CONFIG_SERVER_ADDRESS, "127.0.0.1");
-    int32_t port = server_config.GetInt32Value(CONFIG_SERVER_PORT, 19530);
+    std::string address = server_config.GetValue(CONFIG_SERVER_ADDRESS, CONFIG_SERVER_ADDRESS_DEFAULT);
+    int32_t port = server_config.GetInt32Value(CONFIG_SERVER_PORT, std::stoi(CONFIG_SERVER_PORT_DEFAULT));
 
     std::string server_address(address + ":" + std::to_string(port));
 

cpp/src/utils/SignalUtil.cpp

@@ -34,7 +34,7 @@ void SignalUtil::HandleSignal(int signum) {
         case SIGUSR2: {
             SERVER_LOG_INFO << "Server received signal: " << signum;
 
-            server::Server &server = server::Server::Instance();
+            server::Server &server = server::Server::GetInstance();
             server.Stop();
 
             exit(0);
@@ -43,7 +43,7 @@ void SignalUtil::HandleSignal(int signum) {
             SERVER_LOG_INFO << "Server received critical signal: " << signum;
             SignalUtil::PrintStacktrace();
 
-            server::Server &server = server::Server::Instance();
+            server::Server &server = server::Server::GetInstance();
             server.Stop();
 
             exit(1);

cpp/src/wrapper/KnowhereResource.cpp

@@ -41,14 +41,15 @@ ErrorCode KnowhereResource::Initialize() {
     server::ServerConfig& root_config = server::ServerConfig::GetInstance();
     server::ConfigNode& db_config = root_config.GetConfig(server::CONFIG_DB);
 
-    int32_t build_index_gpu = db_config.GetInt32Value(server::CONFIG_DB_BUILD_INDEX_GPU, 0);
+    int32_t build_index_gpu =
+        db_config.GetInt32Value(server::CONFIG_DB_BUILD_INDEX_GPU, std::stoi(server::CONFIG_DB_BUILD_INDEX_GPU_DEFAULT));
     gpu_resources.insert(std::make_pair(build_index_gpu, GpuResourceSetting()));
 
     //get search gpu resource
     server::ConfigNode& res_config = root_config.GetConfig(server::CONFIG_RESOURCE);
-    auto resources = res_config.GetSequence("resources");
+    auto pool = res_config.GetSequence(server::CONFIG_RESOURCE_POOL);
     std::set<uint64_t> gpu_ids;
-    for (auto &resource : resources) {
+    for (auto &resource : pool) {
         if (resource.length() < 4 || resource.substr(0, 3) != "gpu") {
             // invalid
             continue;

cpp/unittest/server/rpc_test.cpp

@@ -67,7 +67,7 @@ class RpcHandlerTest : public testing::Test {
         engine::DBOptions opt;
 
         server::ConfigNode &db_config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_DB);
-        db_config.SetValue(server::CONFIG_DB_URL, "sqlite://:@:/");
+        db_config.SetValue(server::CONFIG_DB_BACKEND_URL, "sqlite://:@:/");
         db_config.SetValue(server::CONFIG_DB_PATH, "/tmp/milvus_test");
         db_config.SetValue(server::CONFIG_DB_SLAVE_PATH, "");
         db_config.SetValue(server::CONFIG_DB_ARCHIVE_DISK, "");
@@ -77,7 +77,7 @@ class RpcHandlerTest : public testing::Test {
         cache_config.SetValue(server::CONFIG_INSERT_CACHE_IMMEDIATELY, "");
 
         server::ConfigNode &engine_config = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_ENGINE);
-        engine_config.SetValue(server::CONFIG_OMP_THREAD_NUM, "");
+        engine_config.SetValue(server::CONFIG_ENGINE_OMP_THREAD_NUM, "");
 
         server::ConfigNode &serverConfig = server::ServerConfig::GetInstance().GetConfig(server::CONFIG_SERVER);
 //        serverConfig.SetValue(server::CONFIG_CLUSTER_MODE, "cluster");