Commit 8a6e8364 authored by 蔡宇东's avatar 蔡宇东
Browse files

MS-574 rename some configurations 


Former-commit-id: a7e700ae417c28527f665ac919666d3a22a73707
parent 4d72034f

cpp/conf/server_config.template

+7 −5
Original line number Diff line number Diff line
@@ -11,25 +11,27 @@ db_config: 
  secondary_path:                   # path used to store data only, split by semicolon



  backend_url: sqlite://:@:/        # URI format: dialect://username:password@host:port/database

                                    # Keep 'dialect://:@:/', and replace other texts with real values.

                                    # Keep 'dialect://:@:/', and replace other texts with real values

                                    # Replace 'dialect' with 'mysql' or 'sqlite'



  insert_buffer_size: 4             # GB, maximum insert buffer size allowed

                                    # sum of insert_buffer_size and cpu_cache_capacity cannot exceed total memory

  build_index_gpu: 0                # gpu id used for building index



metric_config:

  enable_monitor: false             # enable monitoring or not

  collector: prometheus             # prometheus

  prometheus_config:

    port: 8080                      # port prometheus used to fetch metrics

    port: 8080                      # port prometheus uses to fetch metrics



cache_config:

  cpu_mem_capacity: 16              # GB, CPU memory used for cache

  cpu_mem_threshold: 0.85           # percentage of data that will be kept when cache cleanup is triggered

  cpu_cache_capacity: 16            # GB, CPU memory used for cache

  cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered

  cache_insert_data: false          # whether to load inserted data into cache



engine_config:

  blas_threshold: 20

  use_blas_threshold: 20            # if nq <  use_blas_threshold, use SSE, faster with fluctuated response times

                                    # if nq >= use_blas_threshold, use OpenBlas, slower with stable response times



resource_config:

  resource_pool:

cpp/src/cache/CpuCacheMgr.cpp

+8 −8
Original line number Diff line number Diff line
@@ -34,23 +34,23 @@ CpuCacheMgr::CpuCacheMgr() { 
    server::Config &config = server::Config::GetInstance();

    Status s;



    int32_t cpu_mem_cap;

    s = config.GetCacheConfigCpuMemCapacity(cpu_mem_cap);

    int32_t cpu_cache_cap;

    s = config.GetCacheConfigCpuCacheCapacity(cpu_cache_cap);

    if (!s.ok()) {

        SERVER_LOG_ERROR << s.message();

    }

    int64_t cap = cpu_mem_cap * unit;

    int64_t cap = cpu_cache_cap * unit;

    cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL << 32);



    float cpu_mem_threshold;

    s = config.GetCacheConfigCpuMemThreshold(cpu_mem_threshold);

    float cpu_cache_threshold;

    s = config.GetCacheConfigCpuCacheThreshold(cpu_cache_threshold);

    if (!s.ok()) {

        SERVER_LOG_ERROR << s.message();

    }

    if (cpu_mem_threshold > 0.0 && cpu_mem_threshold <= 1.0) {

        cache_->set_freemem_percent(cpu_mem_threshold);

    if (cpu_cache_threshold > 0.0 && cpu_cache_threshold <= 1.0) {

        cache_->set_freemem_percent(cpu_cache_threshold);

    } else {

        SERVER_LOG_ERROR << "Invalid cpu_mem_threshold: " << cpu_mem_threshold

        SERVER_LOG_ERROR << "Invalid cpu_cache_threshold: " << cpu_cache_threshold

                         << ", by default set to " << cache_->freemem_percent();

    }

}

cpp/src/cache/GpuCacheMgr.cpp

+4 −4
Original line number Diff line number Diff line
@@ -38,16 +38,16 @@ GpuCacheMgr::GpuCacheMgr() { 
    server::Config &config = server::Config::GetInstance();

    Status s;



    int32_t gpu_mem_cap;

    s = config.GetCacheConfigGpuMemCapacity(gpu_mem_cap);

    int32_t gpu_cache_cap;

    s = config.GetCacheConfigGpuCacheCapacity(gpu_cache_cap);

    if (!s.ok()) {

        SERVER_LOG_ERROR << s.message();

    }

    int32_t cap = gpu_mem_cap * G_BYTE;

    int32_t cap = gpu_cache_cap * G_BYTE;

    cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL << 32);



    float gpu_mem_threshold;

    s = config.GetCacheConfigGpuMemThreshold(gpu_mem_threshold);

    s = config.GetCacheConfigGpuCacheThreshold(gpu_mem_threshold);

    if (!s.ok()) {

        SERVER_LOG_ERROR << s.message();

    }

cpp/src/server/Config.cpp

+91 −91
Original line number Diff line number Diff line
@@ -135,20 +135,20 @@ Config::ValidateConfig() { 
    if (!s.ok()) return s;



    /* cache config */

    int32_t cache_cpu_mem_capacity;

    s = GetCacheConfigCpuMemCapacity(cache_cpu_mem_capacity);

    int32_t cache_cpu_cache_capacity;

    s = GetCacheConfigCpuCacheCapacity(cache_cpu_cache_capacity);

    if (!s.ok()) return s;



    float cache_cpu_mem_threshold;

    s = GetCacheConfigCpuMemThreshold(cache_cpu_mem_threshold);

    float cache_cpu_cache_threshold;

    s = GetCacheConfigCpuCacheThreshold(cache_cpu_cache_threshold);

    if (!s.ok()) return s;



    int32_t cache_gpu_mem_capacity;

    s = GetCacheConfigGpuMemCapacity(cache_gpu_mem_capacity);

    int32_t cache_gpu_cache_capacity;

    s = GetCacheConfigGpuCacheCapacity(cache_gpu_cache_capacity);

    if (!s.ok()) return s;



    float cache_gpu_mem_threshold;

    s = GetCacheConfigGpuMemThreshold(cache_gpu_mem_threshold);

    float cache_gpu_cache_threshold;

    s = GetCacheConfigGpuCacheThreshold(cache_gpu_cache_threshold);

    if (!s.ok()) return s;



    bool cache_insert_data;
@@ -156,8 +156,8 @@ Config::ValidateConfig() { 
    if (!s.ok()) return s;



    /* engine config */

    int32_t engine_blas_threshold;

    s = GetEngineConfigBlasThreshold(engine_blas_threshold);

    int32_t engine_use_blas_threshold;

    s = GetEngineConfigUseBlasThreshold(engine_use_blas_threshold);

    if (!s.ok()) return s;



    int32_t engine_omp_thread_num;
@@ -226,23 +226,23 @@ Config::ResetDefaultConfig() { 
    if (!s.ok()) return s;



    /* cache config */

    s = SetCacheConfigCpuMemCapacity(CONFIG_CACHE_CPU_MEM_CAPACITY_DEFAULT);

    s = SetCacheConfigCpuCacheCapacity(CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT);

    if (!s.ok()) return s;



    s = SetCacheConfigCpuMemThreshold(CONFIG_CACHE_CPU_MEM_THRESHOLD_DEFAULT);

    s = SetCacheConfigCpuCacheThreshold(CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT);

    if (!s.ok()) return s;



    s = SetCacheConfigGpuMemCapacity(CONFIG_CACHE_GPU_MEM_CAPACITY_DEFAULT);

    s = SetCacheConfigGpuCacheCapacity(CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT);

    if (!s.ok()) return s;



    s = SetCacheConfigGpuMemThreshold(CONFIG_CACHE_GPU_MEM_THRESHOLD_DEFAULT);

    s = SetCacheConfigGpuCacheThreshold(CONFIG_CACHE_GPU_CACHE_THRESHOLD_DEFAULT);

    if (!s.ok()) return s;



    s = SetCacheConfigCacheInsertData(CONFIG_CACHE_CACHE_INSERT_DATA_DEFAULT);

    if (!s.ok()) return s;



    /* engine config */

    s = SetEngineConfigBlasThreshold(CONFIG_ENGINE_BLAS_THRESHOLD_DEFAULT);

    s = SetEngineConfigUseBlasThreshold(CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT);

    if (!s.ok()) return s;



    s = SetEngineConfigOmpThreadNum(CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT);
@@ -417,17 +417,17 @@ Config::CheckMetricConfigPrometheusPort(const std::string &value) { 
}



Status

Config::CheckCacheConfigCpuMemCapacity(const std::string &value) {

Config::CheckCacheConfigCpuCacheCapacity(const std::string &value) {

    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_mem_capacity: " + value);

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_capacity: " + value);

    } else {

        uint64_t cpu_cache_capacity = std::stoi(value) * GB;

        uint64_t total_mem = 0, free_mem = 0;

        CommonUtil::GetSystemMemInfo(total_mem, free_mem);

        if (cpu_cache_capacity >= total_mem) {

            return Status(SERVER_INVALID_ARGUMENT, "Cache config cpu_mem_capacity exceed system memory: " + value);

            return Status(SERVER_INVALID_ARGUMENT, "Cache config cpu_cache_capacity exceed system memory: " + value);

        } else if (cpu_cache_capacity > (double) total_mem * 0.9) {

            std::cerr << "Warning: cpu_mem_capacity value is too big" << std::endl;

            std::cerr << "Warning: cpu_cache_capacity value is too big" << std::endl;

        }



        int32_t buffer_value;
@@ -435,29 +435,29 @@ Config::CheckCacheConfigCpuMemCapacity(const std::string &value) { 
        if (!s.ok()) return s;

        int64_t insert_buffer_size = buffer_value * GB;

        if (insert_buffer_size + cpu_cache_capacity >= total_mem) {

            return Status(SERVER_INVALID_ARGUMENT, "Sum of cpu_mem_capacity and buffer_size exceed system memory");

            return Status(SERVER_INVALID_ARGUMENT, "Sum of cpu_cache_capacity and buffer_size exceed system memory");

        }

    }

    return Status::OK();

}



Status

Config::CheckCacheConfigCpuMemThreshold(const std::string &value) {

Config::CheckCacheConfigCpuCacheThreshold(const std::string &value) {

    if (!ValidationUtil::ValidateStringIsFloat(value).ok()) {

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_mem_threshold: " + value);

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_threshold: " + value);

    } else {

        float cpu_mem_threshold = std::stof(value);

        if (cpu_mem_threshold <= 0.0 || cpu_mem_threshold >= 1.0) {

            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_mem_threshold: " + value);

        float cpu_cache_threshold = std::stof(value);

        if (cpu_cache_threshold <= 0.0 || cpu_cache_threshold >= 1.0) {

            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_threshold: " + value);

        }

    }

    return Status::OK();

}



Status

Config::CheckCacheConfigGpuMemCapacity(const std::string &value) {

Config::CheckCacheConfigGpuCacheCapacity(const std::string &value) {

    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {

        std::cerr << "ERROR: gpu_cache_capacity " << value << " is not a number" << std::endl;

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_capacity: " + value);

    } else {

        uint64_t gpu_cache_capacity = std::stoi(value) * GB;

        int gpu_index;
@@ -469,22 +469,22 @@ Config::CheckCacheConfigGpuMemCapacity(const std::string &value) { 
                          "Fail to get GPU memory for GPU device: " + std::to_string(gpu_index));

        } else if (gpu_cache_capacity >= gpu_memory) {

            return Status(SERVER_INVALID_ARGUMENT,

                          "Cache config gpu_mem_capacity exceed GPU memory: " + std::to_string(gpu_memory));

                          "Cache config gpu_cache_capacity exceed GPU memory: " + std::to_string(gpu_memory));

        } else if (gpu_cache_capacity > (double) gpu_memory * 0.9) {

            std::cerr << "Warning: gpu_mem_capacity value is too big" << std::endl;

            std::cerr << "Warning: gpu_cache_capacity value is too big" << std::endl;

        }

    }

    return Status::OK();

}



Status

Config::CheckCacheConfigGpuMemThreshold(const std::string &value) {

Config::CheckCacheConfigGpuCacheThreshold(const std::string &value) {

    if (!ValidationUtil::ValidateStringIsFloat(value).ok()) {

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_mem_threshold: " + value);

        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_threshold: " + value);

    } else {

        float gpu_mem_threshold = std::stof(value);

        if (gpu_mem_threshold <= 0.0 || gpu_mem_threshold >= 1.0) {

            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_mem_threshold: " + value);

        float gpu_cache_threshold = std::stof(value);

        if (gpu_cache_threshold <= 0.0 || gpu_cache_threshold >= 1.0) {

            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_threshold: " + value);

        }

    }

    return Status::OK();
@@ -499,9 +499,9 @@ Config::CheckCacheConfigCacheInsertData(const std::string &value) { 
}



Status

Config::CheckEngineConfigBlasThreshold(const std::string &value) {

Config::CheckEngineConfigUseBlasThreshold(const std::string &value) {

    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {

        return Status(SERVER_INVALID_ARGUMENT, "Invalid engine config blas threshold: " + value);

        return Status(SERVER_INVALID_ARGUMENT, "Invalid engine config use_blas_threshold: " + value);

    }

    return Status::OK();

}
@@ -729,45 +729,45 @@ Config::GetMetricConfigStrPrometheusPort() { 
////////////////////////////////////////////////////////////////////////////////

/* cache config */

std::string

Config::GetCacheConfigStrCpuMemCapacity() {

Config::GetCacheConfigStrCpuCacheCapacity() {

    std::string value;

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_MEM_CAPACITY, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_CPU_MEM_CAPACITY,

                                                     CONFIG_CACHE_CPU_MEM_CAPACITY_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_MEM_CAPACITY, value);

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_CAPACITY, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_CPU_CACHE_CAPACITY,

                                                     CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_CAPACITY, value);

    }

    return value;

}



std::string

Config::GetCacheConfigStrCpuMemThreshold() {

Config::GetCacheConfigStrCpuCacheThreshold() {

    std::string value;

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_MEM_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_CPU_MEM_THRESHOLD,

                                                     CONFIG_CACHE_CPU_MEM_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_MEM_THRESHOLD, value);

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_CPU_CACHE_THRESHOLD,

                                                     CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_THRESHOLD, value);

    }

    return value;

}



std::string

Config::GetCacheConfigStrGpuMemCapacity() {

Config::GetCacheConfigStrGpuCacheCapacity() {

    std::string value;

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_MEM_CAPACITY, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_GPU_MEM_CAPACITY,

                                                     CONFIG_CACHE_GPU_MEM_CAPACITY_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_MEM_CAPACITY, value);

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_CAPACITY, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_GPU_CACHE_CAPACITY,

                                                     CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_CAPACITY, value);

    }

    return value;

}



std::string

Config::GetCacheConfigStrGpuMemThreshold() {

Config::GetCacheConfigStrGpuCacheThreshold() {

    std::string value;

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_MEM_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_GPU_MEM_THRESHOLD,

                                                     CONFIG_CACHE_GPU_MEM_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_MEM_THRESHOLD, value);

    if (!GetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_CACHE).GetValue(CONFIG_CACHE_GPU_CACHE_THRESHOLD,

                                                     CONFIG_CACHE_GPU_CACHE_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_THRESHOLD, value);

    }

    return value;

}
@@ -786,12 +786,12 @@ Config::GetCacheConfigStrCacheInsertData() { 
////////////////////////////////////////////////////////////////////////////////

/* engine config */

std::string

Config::GetEngineConfigStrBlasThreshold() {

Config::GetEngineConfigStrUseBlasThreshold() {

    std::string value;

    if (!GetConfigValueInMem(CONFIG_ENGINE, CONFIG_ENGINE_BLAS_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_ENGINE).GetValue(CONFIG_ENGINE_BLAS_THRESHOLD,

                                                      CONFIG_ENGINE_BLAS_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_ENGINE, CONFIG_ENGINE_BLAS_THRESHOLD, value);

    if (!GetConfigValueInMem(CONFIG_ENGINE, CONFIG_ENGINE_USE_BLAS_THRESHOLD, value).ok()) {

        value = GetConfigNode(CONFIG_ENGINE).GetValue(CONFIG_ENGINE_USE_BLAS_THRESHOLD,

                                                      CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT);

        SetConfigValueInMem(CONFIG_ENGINE, CONFIG_ENGINE_USE_BLAS_THRESHOLD, value);

    }

    return value;

}
@@ -922,36 +922,36 @@ Config::GetMetricConfigPrometheusPort(std::string &value) { 
}



Status

Config::GetCacheConfigCpuMemCapacity(int32_t &value) {

    std::string str = GetCacheConfigStrCpuMemCapacity();

    Status s = CheckCacheConfigCpuMemCapacity(str);

Config::GetCacheConfigCpuCacheCapacity(int32_t &value) {

    std::string str = GetCacheConfigStrCpuCacheCapacity();

    Status s = CheckCacheConfigCpuCacheCapacity(str);

    if (!s.ok()) return s;

    value = std::stoi(str);

    return Status::OK();

}



Status

Config::GetCacheConfigCpuMemThreshold(float &value) {

    std::string str = GetCacheConfigStrCpuMemThreshold();

    Status s = CheckCacheConfigCpuMemThreshold(str);

Config::GetCacheConfigCpuCacheThreshold(float &value) {

    std::string str = GetCacheConfigStrCpuCacheThreshold();

    Status s = CheckCacheConfigCpuCacheThreshold(str);

    if (!s.ok()) return s;

    value = std::stof(str);

    return Status::OK();

}



Status

Config::GetCacheConfigGpuMemCapacity(int32_t &value) {

    std::string str = GetCacheConfigStrGpuMemCapacity();

    Status s = CheckCacheConfigGpuMemCapacity(str);

Config::GetCacheConfigGpuCacheCapacity(int32_t &value) {

    std::string str = GetCacheConfigStrGpuCacheCapacity();

    Status s = CheckCacheConfigGpuCacheCapacity(str);

    if (!s.ok()) return s;

    value = std::stoi(str);

    return Status::OK();

}



Status

Config::GetCacheConfigGpuMemThreshold(float &value) {

    std::string str = GetCacheConfigStrGpuMemThreshold();

    Status s = CheckCacheConfigGpuMemThreshold(str);

Config::GetCacheConfigGpuCacheThreshold(float &value) {

    std::string str = GetCacheConfigStrGpuCacheThreshold();

    Status s = CheckCacheConfigGpuCacheThreshold(str);

    if (!s.ok()) return s;

    value = std::stof(str);

    return Status::OK();
@@ -968,9 +968,9 @@ Config::GetCacheConfigCacheInsertData(bool &value) { 
}



Status

Config::GetEngineConfigBlasThreshold(int32_t &value) {

    std::string str = GetEngineConfigStrBlasThreshold();

    Status s = CheckEngineConfigBlasThreshold(str);

Config::GetEngineConfigUseBlasThreshold(int32_t &value) {

    std::string str = GetEngineConfigStrUseBlasThreshold();

    Status s = CheckEngineConfigUseBlasThreshold(str);

    if (!s.ok()) return s;

    value = std::stoi(str);

    return Status::OK();
@@ -1116,34 +1116,34 @@ Config::SetMetricConfigPrometheusPort(const std::string &value) { 


/* cache config */

Status

Config::SetCacheConfigCpuMemCapacity(const std::string &value) {

    Status s = CheckCacheConfigCpuMemCapacity(value);

Config::SetCacheConfigCpuCacheCapacity(const std::string &value) {

    Status s = CheckCacheConfigCpuCacheCapacity(value);

    if (!s.ok()) return s;

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_MEM_CAPACITY, value);

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_CACHE_CAPACITY, value);

    return Status::OK();

}



Status

Config::SetCacheConfigCpuMemThreshold(const std::string &value) {

    Status s = CheckCacheConfigCpuMemThreshold(value);

Config::SetCacheConfigCpuCacheThreshold(const std::string &value) {

    Status s = CheckCacheConfigCpuCacheThreshold(value);

    if (!s.ok()) return s;

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_MEM_THRESHOLD, value);

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_CACHE_THRESHOLD, value);

    return Status::OK();

}



Status

Config::SetCacheConfigGpuMemCapacity(const std::string &value) {

    Status s = CheckCacheConfigGpuMemCapacity(value);

Config::SetCacheConfigGpuCacheCapacity(const std::string &value) {

    Status s = CheckCacheConfigGpuCacheCapacity(value);

    if (!s.ok()) return s;

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_MEM_CAPACITY, value);

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_CACHE_CAPACITY, value);

    return Status::OK();

}



Status

Config::SetCacheConfigGpuMemThreshold(const std::string &value) {

    Status s = CheckCacheConfigGpuMemThreshold(value);

Config::SetCacheConfigGpuCacheThreshold(const std::string &value) {

    Status s = CheckCacheConfigGpuCacheThreshold(value);

    if (!s.ok()) return s;

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_MEM_THRESHOLD, value);

    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_CACHE_THRESHOLD, value);

    return Status::OK();

}
@@ -1157,10 +1157,10 @@ Config::SetCacheConfigCacheInsertData(const std::string &value) { 


/* engine config */

Status

Config::SetEngineConfigBlasThreshold(const std::string &value) {

    Status s = CheckEngineConfigBlasThreshold(value);

Config::SetEngineConfigUseBlasThreshold(const std::string &value) {

    Status s = CheckEngineConfigUseBlasThreshold(value);

    if (!s.ok()) return s;

    SetConfigValueInMem(CONFIG_DB, CONFIG_ENGINE_BLAS_THRESHOLD, value);

    SetConfigValueInMem(CONFIG_DB, CONFIG_ENGINE_USE_BLAS_THRESHOLD, value);

    return Status::OK();

}

cpp/src/server/Config.h

+30 −30

File changed.

Preview size limit exceeded, changes collapsed.