SERVER-45947 Make hedging server parameters settable at runtime

5 files changed, 52 insertions, 35 deletions

diff --git a/src/mongo/s/hedge_options_util.cpp b/src/mongo/s/hedge_options_util.cpp
index 9301a416bcf..d4ffd133f65 100644
--- a/src/mongo/s/hedge_options_util.cpp
+++ b/src/mongo/s/hedge_options_util.cpp
@@ -39,14 +39,15 @@ boost::optional<executor::RemoteCommandRequestOnAny::HedgeOptions> extractHedgeO
     OperationContext* opCtx, const BSONObj& cmdObj) {
     const auto hedgingMode = ReadPreferenceSetting::get(opCtx).hedgingMode;
 
-    if (gReadHedgingMode == kReadHedgingModeOn && hedgingMode && hedgingMode->getEnabled()) {
+    if (gReadHedgingMode.load() == ReadHedgingMode::kOn && hedgingMode &&
+        hedgingMode->getEnabled()) {
         boost::optional<int> maxTimeMS;
         if (auto cmdOptionMaxTimeMSField = cmdObj[QueryRequest::cmdOptionMaxTimeMS]) {
             maxTimeMS = uassertStatusOK(QueryRequest::parseMaxTimeMS(cmdOptionMaxTimeMSField));
         }
 
         // Check if the operation is worth hedging.
-        if (maxTimeMS && maxTimeMS > gMaxTimeMSThresholdForHedging) {
+        if (maxTimeMS && maxTimeMS > gMaxTimeMSThresholdForHedging.load()) {
             return boost::none;
         }
 
@@ -55,8 +56,8 @@ boost::optional<executor::RemoteCommandRequestOnAny::HedgeOptions> extractHedgeO
         bool shouldDelayHedging = hedgingMode->getDelay();
 
         if (shouldDelayHedging) {
-            delay = maxTimeMS ? Milliseconds{gHedgingDelayPercentage * maxTimeMS.get() / 100}
-                              : Milliseconds{gDefaultHedgingDelayMS};
+            delay = maxTimeMS ? Milliseconds{gHedgingDelayPercentage.load() * maxTimeMS.get() / 100}
+                              : Milliseconds{gDefaultHedgingDelayMS.load()};
         }
 
         return executor::RemoteCommandRequestOnAny::HedgeOptions{1, delay};
diff --git a/src/mongo/s/hedge_options_util_test.cpp b/src/mongo/s/hedge_options_util_test.cpp
index 1fd54e39082..1407caa6e01 100644
--- a/src/mongo/s/hedge_options_util_test.cpp
+++ b/src/mongo/s/hedge_options_util_test.cpp
@@ -112,9 +112,10 @@ protected:
 
     static inline const BSONObj kDefaultParameters =
         BSON(kReadHedgingModeFieldName
-             << "on" << kMaxTimeMSThresholdForHedgingFieldName << gMaxTimeMSThresholdForHedging
-             << kHedgingDelayPercentageFieldName << gHedgingDelayPercentage
-             << kDefaultHedgingDelayMSFieldName << gDefaultHedgingDelayMS);
+             << "on" << kMaxTimeMSThresholdForHedgingFieldName
+             << gMaxTimeMSThresholdForHedging.load() << kHedgingDelayPercentageFieldName
+             << gHedgingDelayPercentage.load() << kDefaultHedgingDelayMSFieldName
+             << gDefaultHedgingDelayMS.load());
 
 private:
     ServiceContext::UniqueServiceContext _serviceCtx = ServiceContext::make();
diff --git a/src/mongo/s/mongos_server_parameters.cpp b/src/mongo/s/mongos_server_parameters.cpp
index de9d5507598..8adb722635b 100644
--- a/src/mongo/s/mongos_server_parameters.cpp
+++ b/src/mongo/s/mongos_server_parameters.cpp
@@ -29,18 +29,34 @@
 
 #include "mongo/s/mongos_server_parameters.h"
 
+#include "mongo/base/status.h"
+#include "mongo/s/mongos_server_parameters_gen.h"
 #include "mongo/util/str.h"
 
 namespace mongo {
 
-/**
- * Validation callback for setParameter 'readHedgingMode'.
- */
-Status validateReadHedgingMode(const std::string& mode) {
-    if (mode != kReadHedgingModeOn && mode != kReadHedgingModeOff) {
-        return {ErrorCodes::BadValue,
-                str::stream() << "readHedgingMode must be either \"" << kReadHedgingModeOn
-                              << "\" or \"" << kReadHedgingModeOff << "\""};
+namespace {
+std::string toReadHedgingModeString(ReadHedgingMode readHedgingMode) {
+    return readHedgingMode == ReadHedgingMode::kOn ? "on" : "off";
+}
+}  // namespace
+
+AtomicWord<ReadHedgingMode> gReadHedgingMode{ReadHedgingMode::kOn};
+
+void HedgingModeServerParameter::append(OperationContext*,
+                                        BSONObjBuilder& builder,
+                                        const std::string& name) {
+    builder.append(name, toReadHedgingModeString(gReadHedgingMode.load()));
+}
+
+Status HedgingModeServerParameter::setFromString(const std::string& modeStr) {
+    if (modeStr == "on") {
+        gReadHedgingMode.store(ReadHedgingMode::kOn);
+    } else if (modeStr == "off") {
+        gReadHedgingMode.store(ReadHedgingMode::kOff);
+    } else {
+        return Status{ErrorCodes::BadValue,
+                      str::stream() << "Unrecognized readHedgingMode '" << modeStr << "'"};
     }
     return Status::OK();
 }
diff --git a/src/mongo/s/mongos_server_parameters.h b/src/mongo/s/mongos_server_parameters.h
index 9c2a580278b..b992e3f214c 100644
--- a/src/mongo/s/mongos_server_parameters.h
+++ b/src/mongo/s/mongos_server_parameters.h
@@ -29,18 +29,13 @@
 
 #pragma once
 
+#include "mongo/platform/atomic_word.h"
 #include "mongo/platform/basic.h"
 
-#include "mongo/base/status.h"
-
 namespace mongo {
 
-constexpr auto kReadHedgingModeOn = "on";
-constexpr auto kReadHedgingModeOff = "off";
+enum ReadHedgingMode { kOn, kOff };
 
-/**
- * Validation callback for setParameter 'readHedgingMode'.
- */
-Status validateReadHedgingMode(const std::string& mode);
+extern AtomicWord<ReadHedgingMode> gReadHedgingMode;
 
 }  // namespace mongo
diff --git a/src/mongo/s/mongos_server_parameters.idl b/src/mongo/s/mongos_server_parameters.idl
index aaac5f4d2dc..00376d40cf3 100644
--- a/src/mongo/s/mongos_server_parameters.idl
+++ b/src/mongo/s/mongos_server_parameters.idl
@@ -63,35 +63,39 @@ server_parameters:
   readHedgingMode:
     description: >-
         Enables hedged reads.
-    set_at: [ startup ]
-    cpp_vartype: std::string
-    cpp_varname: "gReadHedgingMode"
-    default: "on"
-    validator:
-      callback: "validateReadHedgingMode"
+    set_at: [ startup, runtime ]
+    cpp_class:
+      name: HedgingModeServerParameter
 
   maxTimeMSThresholdForHedging:
     description: >-
         The upper threshold for the expected running time of an operation (maxTimeMS)
         for it to be worth hedging.
-    set_at: [ startup ]
-    cpp_vartype: int
+    set_at: [ startup, runtime ]
+    cpp_vartype: AtomicWord<int>
     cpp_varname: "gMaxTimeMSThresholdForHedging"
+    validator:
+        gte: 0
     default: 5000
 
   hedgingDelayPercentage:
     description: >-
         The percentage of maxTimeMS to wait for before dispatching subsequent reads.
-    set_at: [ startup ]
-    cpp_vartype: int
+    set_at: [ startup, runtime ]
+    cpp_vartype: AtomicWord<int>
     cpp_varname: "gHedgingDelayPercentage"
+    validator:
+        gte: 0
+        lte: 100
     default: 25
 
   defaultHedgingDelayMS:
     description: >-
           The default wait time in milliseconds before dispatching subsequent reads if
           maxTimeMS is not given.
-    set_at: [ startup ]
-    cpp_vartype: int
+    set_at: [ startup, runtime ]
+    cpp_vartype: AtomicWord<int>
     cpp_varname: "gDefaultHedgingDelayMS"
+    validator:
+        gte: 0
     default: 1250