New upstream version 6.0.20upstream

1 files changed, 26 insertions, 65 deletions

diff --git a/src/mongo/db/query/sbe_plan_cache.cpp b/src/mongo/db/query/sbe_plan_cache.cpp
index c8944057639..70d864e7074 100644
--- a/src/mongo/db/query/sbe_plan_cache.cpp
+++ b/src/mongo/db/query/sbe_plan_cache.cpp
@@ -31,7 +31,7 @@
 
 #include "mongo/db/query/sbe_plan_cache.h"
 
-#include "mongo/db/query/plan_cache_size_parameter.h"
+#include "mongo/db/query/util/memory_util.h"
 #include "mongo/db/server_options.h"
 #include "mongo/logv2/log.h"
 #include "mongo/util/processinfo.h"
@@ -42,71 +42,23 @@ namespace {
 const auto sbePlanCacheDecoration =
     ServiceContext::declareDecoration<std::unique_ptr<sbe::PlanCache>>();
 
-size_t convertToSizeInBytes(const plan_cache_util::PlanCacheSizeParameter& param) {
-    constexpr size_t kBytesInMB = 1024 * 1024;
-    constexpr size_t kMBytesInGB = 1024;
-
-    double sizeInMB = param.size;
-
-    switch (param.units) {
-        case plan_cache_util::PlanCacheSizeUnits::kPercent:
-            sizeInMB *= ProcessInfo::getMemSizeMB() / 100.0;
-            break;
-        case plan_cache_util::PlanCacheSizeUnits::kMB:
-            break;
-        case plan_cache_util::PlanCacheSizeUnits::kGB:
-            sizeInMB *= kMBytesInGB;
-            break;
-    }
-
-    return static_cast<size_t>(sizeInMB * kBytesInMB);
-}
-
-/**
- * Sets upper size limit on the PlanCache size to 500GB or 25% of the system's memory, whichever is
- * smaller.
- */
-size_t capPlanCacheSize(size_t planCacheSize) {
-    constexpr size_t kBytesInGB = 1024 * 1024 * 1024;
-
-    // Maximum size of the plan cache expressed in bytes.
-    constexpr size_t kMaximumPlanCacheSize = 500 * kBytesInGB;
-
-    // Maximum size of the plan cache expressed as a share of the memory available to the process.
-    const plan_cache_util::PlanCacheSizeParameter limitToProcessSize{
-        25, plan_cache_util::PlanCacheSizeUnits::kPercent};
-    const size_t limitToProcessSizeInBytes = convertToSizeInBytes(limitToProcessSize);
-
-    // The size will be capped by the minimum of the two values defined above.
-    const size_t maxPlanCacheSize = std::min(kMaximumPlanCacheSize, limitToProcessSizeInBytes);
-
-    if (planCacheSize > maxPlanCacheSize) {
-        planCacheSize = maxPlanCacheSize;
-        LOGV2_DEBUG(6007000,
-                    1,
-                    "The plan cache size has been capped",
-                    "maxPlanCacheSize"_attr = maxPlanCacheSize);
-    }
-
-    return planCacheSize;
-}
-
-size_t getPlanCacheSizeInBytes(const plan_cache_util::PlanCacheSizeParameter& param) {
-    size_t planCacheSize = convertToSizeInBytes(param);
-    uassert(5968001,
-            "Cache size must be at least 1KB * number of cores",
-            planCacheSize >= 1024 * ProcessInfo::getNumCores());
-    return capPlanCacheSize(planCacheSize);
-}
 
 class PlanCacheOnParamChangeUpdaterImpl final : public plan_cache_util::OnParamChangeUpdater {
 public:
-    void updateCacheSize(ServiceContext* serviceCtx,
-                         plan_cache_util::PlanCacheSizeParameter parameter) final {
+    void updateCacheSize(ServiceContext* serviceCtx, memory_util::MemorySize memSize) final {
         if (feature_flags::gFeatureFlagSbePlanCache.isEnabledAndIgnoreFCV()) {
-            auto size = getPlanCacheSizeInBytes(parameter);
+            auto newSizeBytes = memory_util::getRequestedMemSizeInBytes(memSize);
+            auto cappedCacheSize = memory_util::capMemorySize(newSizeBytes /*requestedSizeBytes*/,
+                                                              500 /*maximumSizeGB*/,
+                                                              25 /*percentTotalSystemMemory*/);
+            if (cappedCacheSize < newSizeBytes) {
+                LOGV2_DEBUG(6007001,
+                            1,
+                            "The plan cache size has been capped",
+                            "cappedSize"_attr = cappedCacheSize);
+            }
             auto& globalPlanCache = sbePlanCacheDecoration(serviceCtx);
-            globalPlanCache->reset(size);
+            globalPlanCache->reset(cappedCacheSize);
         }
     }
 
@@ -124,12 +76,21 @@ ServiceContext::ConstructorActionRegisterer planCacheRegisterer{
             std::make_unique<PlanCacheOnParamChangeUpdaterImpl>();
 
         if (feature_flags::gFeatureFlagSbePlanCache.isEnabledAndIgnoreFCV()) {
-            auto status = plan_cache_util::PlanCacheSizeParameter::parse(planCacheSize.get());
+            auto status = memory_util::MemorySize::parse(planCacheSize.get());
             uassertStatusOK(status);
-
-            auto size = getPlanCacheSizeInBytes(status.getValue());
+            auto size = memory_util::getRequestedMemSizeInBytes(status.getValue());
+            auto cappedCacheSize = memory_util::capMemorySize(size /*requestedSizeBytes*/,
+                                                              500 /*maximumSizeGB*/,
+                                                              25 /*percentTotalSystemMemory*/);
+            if (cappedCacheSize < size) {
+                LOGV2_DEBUG(6007000,
+                            1,
+                            "The plan cache size has been capped",
+                            "cappedSize"_attr = cappedCacheSize);
+            }
             auto& globalPlanCache = sbePlanCacheDecoration(serviceCtx);
-            globalPlanCache = std::make_unique<sbe::PlanCache>(size, ProcessInfo::getNumCores());
+            globalPlanCache =
+                std::make_unique<sbe::PlanCache>(cappedCacheSize, ProcessInfo::getNumCores());
         }
     }};