From d7ca7af192d3647ed1ef93a6b008f9158f3ce847 Mon Sep 17 00:00:00 2001 From: Jialiang Tan Date: Thu, 22 Aug 2024 11:35:37 -0700 Subject: [PATCH] [native] Switch to use string based arbitrator configs --- .../src/main/sphinx/presto_cpp/properties.rst | 162 +++++++++++++++--- .../presto_cpp/main/PrestoServer.cpp | 46 +++-- .../presto_cpp/main/common/Configs.cpp | 41 +---- .../presto_cpp/main/common/Configs.h | 74 +++----- 4 files changed, 198 insertions(+), 125 deletions(-) diff --git a/presto-docs/src/main/sphinx/presto_cpp/properties.rst b/presto-docs/src/main/sphinx/presto_cpp/properties.rst index be38fef8f0d6..68ae422bd9f4 100644 --- a/presto-docs/src/main/sphinx/presto_cpp/properties.rst +++ b/presto-docs/src/main/sphinx/presto_cpp/properties.rst @@ -95,14 +95,43 @@ The configuration properties of Presto C++ workers are described here, in alphab In-memory cache. -``query.max-memory-per-node`` +``runtime-metrics-collection-enabled`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +* **Type:** ``boolean`` +* **Default value:** ``false`` + + Enables collection of worker level metrics. + +``task.max-drivers-per-task`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * **Type:** ``integer`` +* **Default value:** ``number of hardware CPUs`` + + Number of drivers to use per task. Defaults to hardware CPUs. + +``query.max-memory-per-node`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` * **Default value:** ``4GB`` Max memory usage for each query. + +``system-memory-gb`` +^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``integer`` +* **Default value:** ``40`` + + Memory allocation limit enforced by an internal memory allocator. It consists of two parts: + 1) Memory used by the queries as specified in ``query-memory-gb``; 2) Memory used by the + system, such as disk spilling and cache prefetch. + + Set ``system-memory-gb`` to the available machine memory of the deployment. + + ``query-memory-gb`` ^^^^^^^^^^^^^^^^^^^ @@ -113,41 +142,128 @@ The configuration properties of Presto C++ workers are described here, in alphab worker node. Memory for system usage such as disk spilling and cache prefetch are not counted in it. -``query-reserved-memory-gb`` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +``shared-arbitrator.reserved-capacity`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -* **Type:** ``integer`` -* **Default value:** ``4`` +* **Type:** ``string`` +* **Default value:** ``4GB`` Specifies the total amount of memory in GB reserved for the queries on a worker node. A query can only allocate from this reserved space if 1) the non-reserved space in ``query-memory-gb`` is used up; and 2) the amount - it tries to get is less than ``memory-pool-reserved-capacity``. + it tries to get is less than ``shared-arbitrator.memory-pool-reserved-capacity``. -``runtime-metrics-collection-enabled`` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -* **Type:** ``boolean`` +``shared-arbitrator.memory-pool-initial-capacity`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``128MB`` + + The initial memory pool capacity in bytes allocated on creation. + +``shared-arbitrator.global-arbitration-enabled`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` * **Default value:** ``false`` - Enables collection of worker level metrics. + If true, it allows shared arbitrator to reclaim used memory across query + memory pools. -``system-memory-gb`` -^^^^^^^^^^^^^^^^^^^^ +``shared-arbitrator.memory-pool-reserved-capacity`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -* **Type:** ``integer`` -* **Default value:** ``40`` +* **Type:** ``string`` +* **Default value:** ``64MB`` - Memory allocation limit enforced via internal memory allocator. It consists of two parts: - 1) Memory used by the queries as specified in ``query-memory-gb``; 2) Memory used by the - system, such as disk spilling and cache prefetch. + The amount of memory in bytes reserved for each query memory pool. When + a query tries to allocate memory from the reserved space whose size is + specified by ``shared-arbitrator.reserved-capacity``, it cannot allocate + more than the value specified in ``shared-arbitrator.memory-pool-reserved-capacity``. - Set ``system-memory-gb`` to the available machine memory of the deployment. +``shared-arbitrator.memory-pool-transfer-capacity`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -``task.max-drivers-per-task`` -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +* **Type:** ``string`` +* **Default value:** ``32MB`` -* **Type:** ``integer`` -* **Default value:** ``number of hardware CPUs`` + The minimal memory capacity in bytes transferred between memory pools + during memory arbitration. - Number of drivers to use per task. Defaults to hardware CPUs. +``shared-arbitrator.memory-reclaim-max-wait-time`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``5m`` + + Specifies the max time to wait for memory reclaim by arbitration. The + memory reclaim might fail if the max wait time has exceeded. If it is + zero, then there is no timeout. + +``shared-arbitrator.fast-exponential-growth-capacity-limit`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``512MB`` + + When shared arbitrator grows memory pool's capacity, the growth bytes will + be adjusted in the following way: + + * If 2 * current capacity is less than or equal to + ``shared-arbitrator.fast-exponential-growth-capacity-limit``, grow + through fast path by at least doubling the current capacity, when + conditions allow (see below NOTE section). + * If 2 * current capacity is greater than + ``shared-arbitrator.fast-exponential-growth-capacity-limit``, grow + through slow path by growing capacity by at least + ``shared-arbitrator.slow-capacity-grow-pct`` * current capacity if + allowed (see below NOTE section). + + NOTE: If original requested growth bytes is larger than the adjusted + growth bytes or adjusted growth bytes reaches max capacity limit, the + adjusted growth bytes will not be respected. + + NOTE: Capacity growth adjust is only enabled if both + ``shared-arbitrator.fast-exponential-growth-capacity-limit`` and + ``shared-arbitrator.slow-capacity-grow-pct`` are set, otherwise it is + disabled. + +``shared-arbitrator.slow-capacity-grow-pct`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``0.25`` + + See description for ``shared-arbitrator.fast-exponential-growth-capacity-limit`` + +``shared-arbitrator.memory-pool-min-free-capacity`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``128MB`` + + When shared arbitrator shrinks memory pool's capacity, the shrink bytes + will be adjusted in a way such that AFTER shrink, the stricter (whichever + is smaller) of the following conditions is met, in order to better fit the + pool's current memory usage: + + * Free capacity is greater or equal to capacity * + ``shared-arbitrator.memory-pool-min-free-capacity-pct`` + * Free capacity is greater or equal to + ``shared-arbitrator.memory-pool-min-free-capacity`` + + NOTE: In the conditions when original requested shrink bytes ends up + with more free capacity than above two conditions, the adjusted shrink + bytes is not respected. + + NOTE: Capacity shrink adjustment is enabled when both + ``shared-arbitrator.memory-pool-min-free-capacity-pct`` and + ``shared-arbitrator.memory-pool-min-free-capacity`` are set. + +``shared-arbitrator.memory-pool-min-free-capacity-pct`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +* **Type:** ``string`` +* **Default value:** ``0.25`` + See description for ``shared-arbitrator.memory-pool-min-free-capacity`` diff --git a/presto-native-execution/presto_cpp/main/PrestoServer.cpp b/presto-native-execution/presto_cpp/main/PrestoServer.cpp index 0e663bbf0dfd..5ee52935cc22 100644 --- a/presto-native-execution/presto_cpp/main/PrestoServer.cpp +++ b/presto-native-execution/presto_cpp/main/PrestoServer.cpp @@ -812,27 +812,43 @@ void PrestoServer::initializeVeloxMemory() { memoryGb, "Query memory capacity must not be larger than system memory capacity"); options.arbitratorCapacity = queryMemoryGb << 30; - const uint64_t queryReservedMemoryGb = velox::config::toCapacity( + const uint64_t sharedArbitratorReservedMemoryGb = velox::config::toCapacity( systemConfig->sharedArbitratorReservedCapacity(), velox::config::CapacityUnit::GIGABYTE); VELOX_USER_CHECK_LE( - queryReservedMemoryGb, + sharedArbitratorReservedMemoryGb, queryMemoryGb, - "Query reserved memory capacity must not be larger than query memory capacity"); - - // TODO(jtan6): [Config Refactor] Migrate these old settings to string based - // extra settings + grow & shrink settings. - options.arbitratorReservedCapacity = queryReservedMemoryGb << 30; - options.memoryPoolInitCapacity = systemConfig->memoryPoolInitCapacity(); - options.memoryPoolReservedCapacity = - systemConfig->memoryPoolReservedCapacity(); - options.memoryPoolTransferCapacity = - systemConfig->memoryPoolTransferCapacity(); - options.memoryReclaimWaitMs = systemConfig->memoryReclaimWaitMs(); - options.globalArbitrationEnabled = - systemConfig->memoryArbitratorGlobalArbitrationEnabled(); + "Shared arbitrator reserved memory capacity must not be larger than " + "query memory capacity"); + options.largestSizeClassPages = systemConfig->largestSizeClassPages(); options.arbitrationStateCheckCb = velox::exec::memoryArbitrationStateCheck; + + using SharedArbitratorConfig = velox::memory::SharedArbitrator::ExtraConfig; + options.extraArbitratorConfigs = { + {std::string(SharedArbitratorConfig::kReservedCapacity), + systemConfig->sharedArbitratorReservedCapacity()}, + {std::string(SharedArbitratorConfig::kMemoryPoolInitialCapacity), + systemConfig->sharedArbitratorMemoryPoolInitialCapacity()}, + {std::string(SharedArbitratorConfig::kMemoryPoolReservedCapacity), + systemConfig->sharedArbitratorMemoryPoolReservedCapacity()}, + {std::string(SharedArbitratorConfig::kMemoryPoolTransferCapacity), + systemConfig->sharedArbitratorMemoryPoolTransferCapacity()}, + {std::string(SharedArbitratorConfig::kMemoryReclaimMaxWaitTime), + systemConfig->sharedArbitratorMemoryReclaimWaitTime()}, + {std::string(SharedArbitratorConfig::kMemoryPoolMinFreeCapacity), + systemConfig->sharedArbitratorMemoryPoolMinFreeCapacity()}, + {std::string(SharedArbitratorConfig::kMemoryPoolMinFreeCapacityPct), + systemConfig->sharedArbitratorMemoryPoolMinFreeCapacityPct()}, + {std::string(SharedArbitratorConfig::kGlobalArbitrationEnabled), + systemConfig->sharedArbitratorGlobalArbitrationEnabled()}, + {std::string( + SharedArbitratorConfig::kFastExponentialGrowthCapacityLimit), + systemConfig->sharedArbitratorFastExponentialGrowthCapacityLimit()}, + {std::string(SharedArbitratorConfig::kSlowCapacityGrowPct), + systemConfig->sharedArbitratorSlowCapacityGrowPct()}, + {std::string(SharedArbitratorConfig::kCheckUsageLeak), + folly::to(systemConfig->enableMemoryLeakCheck())}}; } memory::initializeMemoryManager(options); PRESTO_STARTUP_LOG(INFO) << "Memory manager has been setup: " diff --git a/presto-native-execution/presto_cpp/main/common/Configs.cpp b/presto-native-execution/presto_cpp/main/common/Configs.cpp index 50e1bb52cb29..35c068009e55 100644 --- a/presto-native-execution/presto_cpp/main/common/Configs.cpp +++ b/presto-native-execution/presto_cpp/main/common/Configs.cpp @@ -185,9 +185,7 @@ SystemConfig::SystemConfig() { BOOL_PROP(kEnableSerializedPageChecksum, true), BOOL_PROP(kUseMmapAllocator, true), STR_PROP(kMemoryArbitratorKind, ""), - BOOL_PROP(kMemoryArbitratorGlobalArbitrationEnabled, false), NUM_PROP(kQueryMemoryGb, 38), - NUM_PROP(kQueryReservedMemoryGb, 4), STR_PROP(kSharedArbitratorReservedCapacity, "4GB"), STR_PROP(kSharedArbitratorMemoryPoolInitialCapacity, "128MB"), STR_PROP(kSharedArbitratorMemoryPoolReservedCapacity, "64MB"), @@ -509,9 +507,8 @@ std::string SystemConfig::memoryArbitratorKind() const { return optionalProperty(kMemoryArbitratorKind).value_or(""); } -bool SystemConfig::memoryArbitratorGlobalArbitrationEnabled() const { - return optionalProperty(kMemoryArbitratorGlobalArbitrationEnabled) - .value_or(false); +int32_t SystemConfig::queryMemoryGb() const { + return optionalProperty(kQueryMemoryGb).value(); } std::string SystemConfig::sharedArbitratorGlobalArbitrationEnabled() const { @@ -520,25 +517,11 @@ std::string SystemConfig::sharedArbitratorGlobalArbitrationEnabled() const { .value_or("false"); } -int32_t SystemConfig::queryMemoryGb() const { - return optionalProperty(kQueryMemoryGb).value(); -} - -int32_t SystemConfig::queryReservedMemoryGb() const { - return optionalProperty(kQueryReservedMemoryGb).value(); -} - std::string SystemConfig::sharedArbitratorReservedCapacity() const { return optionalProperty(kSharedArbitratorReservedCapacity) .value(); } -uint64_t SystemConfig::memoryPoolInitCapacity() const { - static constexpr uint64_t kMemoryPoolInitCapacityDefault = 128 << 20; - return optionalProperty(kMemoryPoolInitCapacity) - .value_or(kMemoryPoolInitCapacityDefault); -} - std::string SystemConfig::sharedArbitratorMemoryPoolInitialCapacity() const { static constexpr std::string_view kSharedArbitratorMemoryPoolInitialCapacityDefault = "128MB"; @@ -547,12 +530,6 @@ std::string SystemConfig::sharedArbitratorMemoryPoolInitialCapacity() const { .value_or(std::string(kSharedArbitratorMemoryPoolInitialCapacityDefault)); } -uint64_t SystemConfig::memoryPoolReservedCapacity() const { - static constexpr uint64_t kMemoryPoolReservedCapacityDefault = 64 << 20; - return optionalProperty(kMemoryPoolReservedCapacity) - .value_or(kMemoryPoolReservedCapacityDefault); -} - std::string SystemConfig::sharedArbitratorMemoryPoolReservedCapacity() const { static constexpr std::string_view kSharedArbitratorMemoryPoolReservedCapacityDefault = "64MB"; @@ -562,12 +539,6 @@ std::string SystemConfig::sharedArbitratorMemoryPoolReservedCapacity() const { std::string(kSharedArbitratorMemoryPoolReservedCapacityDefault)); } -uint64_t SystemConfig::memoryPoolTransferCapacity() const { - static constexpr uint64_t kMemoryPoolTransferCapacityDefault = 32 << 20; - return optionalProperty(kMemoryPoolTransferCapacity) - .value_or(kMemoryPoolTransferCapacityDefault); -} - std::string SystemConfig::sharedArbitratorMemoryPoolTransferCapacity() const { static constexpr std::string_view kSharedArbitratorMemoryPoolTransferCapacityDefault = "32MB"; @@ -577,12 +548,6 @@ std::string SystemConfig::sharedArbitratorMemoryPoolTransferCapacity() const { std::string(kSharedArbitratorMemoryPoolTransferCapacityDefault)); } -uint64_t SystemConfig::memoryReclaimWaitMs() const { - static constexpr uint64_t kMemoryReclaimWaitMsDefault = {300'000}; // 5 mins. - return optionalProperty(kMemoryReclaimWaitMs) - .value_or(kMemoryReclaimWaitMsDefault); -} - std::string SystemConfig::sharedArbitratorMemoryReclaimWaitTime() const { static constexpr std::string_view kSharedArbitratorMemoryReclaimMaxWaitTimeDefault = "5m"; @@ -620,7 +585,7 @@ std::string SystemConfig::sharedArbitratorMemoryPoolMinFreeCapacityPct() const { static constexpr std::string_view kSharedArbitratorMemoryPoolMinFreeCapacityPctDefault = "0.25"; return optionalProperty( - kSharedArbitratorMemoryPoolMinFreeCapacityPctDefault) + kSharedArbitratorMemoryPoolMinFreeCapacityPct) .value_or( std::string(kSharedArbitratorMemoryPoolMinFreeCapacityPctDefault)); } diff --git a/presto-native-execution/presto_cpp/main/common/Configs.h b/presto-native-execution/presto_cpp/main/common/Configs.h index b4b233a987c4..b088fdc65cf2 100644 --- a/presto-native-execution/presto_cpp/main/common/Configs.h +++ b/presto-native-execution/presto_cpp/main/common/Configs.h @@ -372,76 +372,61 @@ class SystemConfig : public ConfigBase { /// NOTE: the query memory capacity is enforced by memory arbitrator so that /// this config only applies if the memory arbitration has been enabled. static constexpr std::string_view kQueryMemoryGb{"query-memory-gb"}; - static constexpr std::string_view kArbitratorCapacity{"arbitrator-capacity"}; /// Specifies the memory arbitrator kind. If it is empty, then there is no /// memory arbitration. static constexpr std::string_view kMemoryArbitratorKind{ "memory-arbitrator-kind"}; - /// Specifies the total amount of memory in GB reserved for the queries on - /// a single worker node. A query can only allocate from this reserved space - /// if 1) the non-reserved space in "query-memory-gb" is used up; and 2) the - /// amount it tries to get is less than 'memory-pool-reserved-capacity'. + /// Specifies the total amount of memory reserved for the queries on a single + /// worker node. A query can only allocate from this reserved space if 1) the + /// non-reserved space in "query-memory-gb" is used up; and 2) the amount it + /// tries to get is less than + /// 'shared-arbitrator.memory-pool-reserved-capacity'. /// - /// NOTE: the reserved query memory capacity is enforced by memory arbitrator - /// so that this config only applies if the memory arbitration has been - /// enabled. - static constexpr std::string_view kQueryReservedMemoryGb{ - "query-reserved-memory-gb"}; + /// NOTE: the reserved query memory capacity is enforced by shared arbitrator + /// so that this config only applies if memory arbitration is enabled. static constexpr std::string_view kSharedArbitratorReservedCapacity{ "shared-arbitrator.reserved-capacity"}; /// The initial memory pool capacity in bytes allocated on creation. - static constexpr std::string_view kMemoryPoolInitCapacity{ - "memory-pool-init-capacity"}; static constexpr std::string_view kSharedArbitratorMemoryPoolInitialCapacity{ "shared-arbitrator.memory-pool-initial-capacity"}; - /// If true, it allows memory arbitrator to reclaim used memory cross query + /// If true, it allows shared arbitrator to reclaim used memory across query /// memory pools. - static constexpr std::string_view kMemoryArbitratorGlobalArbitrationEnabled{ - "memory-arbitrator-global-arbitration-enabled"}; static constexpr std::string_view kSharedArbitratorGlobalArbitrationEnabled{ "shared-arbitrator.global-arbitration-enabled"}; /// The amount of memory in bytes reserved for each query memory pool. When /// a query tries to allocate memory from the reserved space whose size is - /// specified by 'query-reserved-memory-gb', it cannot allocate more than the - /// value specified in 'memory-pool-reserved-capacity'. - static constexpr std::string_view kMemoryPoolReservedCapacity{ - "memory-pool-reserved-capacity"}; + /// specified by 'shared-arbitrator.reserved-capacity', it cannot allocate + /// more than the value specified in + /// 'shared-arbitrator.memory-pool-reserved-capacity'. static constexpr std::string_view kSharedArbitratorMemoryPoolReservedCapacity{ "shared-arbitrator.memory-pool-reserved-capacity"}; /// The minimal memory capacity in bytes transferred between memory pools /// during memory arbitration. - /// - /// NOTE: this config only applies if the memory arbitration has been enabled. - static constexpr std::string_view kMemoryPoolTransferCapacity{ - "memory-pool-transfer-capacity"}; static constexpr std::string_view kSharedArbitratorMemoryPoolTransferCapacity{ "shared-arbitrator.memory-pool-transfer-capacity"}; /// Specifies the max time to wait for memory reclaim by arbitration. The /// memory reclaim might fail if the max wait time has exceeded. If it is /// zero, then there is no timeout. - /// - /// NOTE: this config only applies if the memory arbitration has been enabled. - static constexpr std::string_view kMemoryReclaimWaitMs{ - "memory-reclaim-wait-ms"}; static constexpr std::string_view kSharedArbitratorMemoryReclaimMaxWaitTime{ "shared-arbitrator.memory-reclaim-max-wait-time"}; /// When shared arbitrator grows memory pool's capacity, the growth bytes will /// be adjusted in the following way: /// - If 2 * current capacity is less than or equal to - /// 'fastExponentialGrowthCapacityLimit', grow through fast path by at - /// least doubling the current capacity, when conditions allow (see below - /// NOTE section). + /// 'shared-arbitrator.fast-exponential-growth-capacity-limit', grow + /// through fast path by at least doubling the current capacity, when + /// conditions allow (see below NOTE section). /// - If 2 * current capacity is greater than - /// 'fastExponentialGrowthCapacityLimit', grow through slow path by growing - /// capacity by at least 'slowCapacityGrowPct' * current capacity if + /// 'shared-arbitrator.fast-exponential-growth-capacity-limit', grow + /// through slow path by growing capacity by at least + /// 'shared-arbitrator.slow-capacity-grow-pct' * current capacity if /// allowed (see below NOTE section). /// /// NOTE: If original requested growth bytes is larger than the adjusted @@ -449,8 +434,9 @@ class SystemConfig : public ConfigBase { /// adjusted growth bytes will not be respected. /// /// NOTE: Capacity growth adjust is only enabled if both - /// 'fastExponentialGrowthCapacityLimit' and 'slowCapacityGrowPct' are set, - /// otherwise it is disabled. + /// 'shared-arbitrator.fast-exponential-growth-capacity-limit' and + /// 'shared-arbitrator.slow-capacity-grow-pct' are set, otherwise it is + /// disabled. static constexpr std::string_view kSharedArbitratorFastExponentialGrowthCapacityLimit{ "shared-arbitrator.fast-exponential-growth-capacity-limit"}; @@ -462,15 +448,17 @@ class SystemConfig : public ConfigBase { /// is smaller) of the following conditions is met, in order to better fit the /// pool's current memory usage: /// - Free capacity is greater or equal to capacity * - /// 'memoryPoolMinFreeCapacityPct' - /// - Free capacity is greater or equal to 'memoryPoolMinFreeCapacity' + /// 'shared-arbitrator.memory-pool-min-free-capacity-pct' + /// - Free capacity is greater or equal to + /// 'shared-arbitrator.memory-pool-min-free-capacity' /// /// NOTE: In the conditions when original requested shrink bytes ends up /// with more free capacity than above 2 conditions, the adjusted shrink /// bytes is not respected. /// /// NOTE: Capacity shrink adjustment is enabled when both - /// 'memoryPoolMinFreeCapacityPct' and 'memoryPoolMinFreeCapacity' are set. + /// 'shared-arbitrator.memory-pool-min-free-capacity-pct' and + /// 'shared-arbitrator.memory-pool-min-free-capacity' are set. static constexpr std::string_view kSharedArbitratorMemoryPoolMinFreeCapacity{ "shared-arbitrator.memory-pool-min-free-capacity"}; static constexpr std::string_view @@ -779,8 +767,6 @@ class SystemConfig : public ConfigBase { std::string memoryArbitratorKind() const; - bool memoryArbitratorGlobalArbitrationEnabled() const; - std::string sharedArbitratorGlobalArbitrationEnabled() const; std::string sharedArbitratorReservedCapacity() const; @@ -803,16 +789,6 @@ class SystemConfig : public ConfigBase { int32_t queryMemoryGb() const; - int32_t queryReservedMemoryGb() const; - - uint64_t memoryPoolInitCapacity() const; - - uint64_t memoryPoolReservedCapacity() const; - - uint64_t memoryPoolTransferCapacity() const; - - uint64_t memoryReclaimWaitMs() const; - bool enableSystemMemoryPoolUsageTracking() const; bool enableHttpAccessLog() const;