Fix a main-thread assertion in the QuorumIntersectionChecker

src/herder/HerderImpl.cpp

@@ -29,6 +29,7 @@
 #include "util/DebugMetaUtils.h"
 #include "util/LogSlowExecution.h"
 #include "util/Logging.h"
+#include "util/Math.h"
 #include "util/StatusManager.h"
 #include "util/Timer.h"
 
@@ -1786,13 +1787,16 @@ HerderImpl::checkAndMaybeReanalyzeQuorumMap()
         mLastQuorumMapIntersectionState.mInterruptFlag = false;
         mLastQuorumMapIntersectionState.mCheckingQuorumMapHash = curr;
         auto& cfg = mApp.getConfig();
+        assertThreadIsMain();
+        auto seed = gRandomEngine();
         auto qic = QuorumIntersectionChecker::create(
-            qmap, cfg, mLastQuorumMapIntersectionState.mInterruptFlag);
+            qmap, cfg, mLastQuorumMapIntersectionState.mInterruptFlag, seed);
         auto ledger = trackingConsensusLedgerIndex();
         auto nNodes = qmap.size();
         auto& hState = mLastQuorumMapIntersectionState;
         auto& app = mApp;
-        auto worker = [curr, ledger, nNodes, qic, qmap, cfg, &app, &hState] {
+        auto worker = [curr, ledger, nNodes, qic, qmap, cfg, seed, &app,
+                       &hState] {
             try
             {
                 ZoneScoped;
@@ -1805,8 +1809,8 @@ HerderImpl::checkAndMaybeReanalyzeQuorumMap()
                     // intersecting; if not intersecting we should finish ASAP
                     // and raise an alarm.
                     critical = QuorumIntersectionChecker::
-                        getIntersectionCriticalGroups(qmap, cfg,
-                                                      hState.mInterruptFlag);
+                        getIntersectionCriticalGroups(
+                            qmap, cfg, hState.mInterruptFlag, seed);
                 }
                 app.postOnMainThread(
                     [ok, curr, ledger, nNodes, split, critical, &hState] {

src/herder/QuorumIntersectionChecker.h

@@ -23,21 +23,24 @@ class QuorumIntersectionChecker
     static std::shared_ptr<QuorumIntersectionChecker>
     create(QuorumTracker::QuorumMap const& qmap,
            std::optional<stellar::Config> const& cfg,
-           std::atomic<bool>& interruptFlag, bool quiet = false);
+           std::atomic<bool>& interruptFlag,
+           stellar_default_random_engine::result_type seed, bool quiet = false);
 
     static std::shared_ptr<QuorumIntersectionChecker>
     create(QuorumSetMap const& qmap, std::optional<stellar::Config> const& cfg,
-           std::atomic<bool>& interruptFlag, bool quiet = false);
-
-    static std::set<std::set<NodeID>>
-    getIntersectionCriticalGroups(QuorumTracker::QuorumMap const& qmap,
-                                  std::optional<stellar::Config> const& cfg,
-                                  std::atomic<bool>& interruptFlag);
-
-    static std::set<std::set<NodeID>>
-    getIntersectionCriticalGroups(QuorumSetMap const& qmap,
-                                  std::optional<stellar::Config> const& cfg,
-                                  std::atomic<bool>& interruptFlag);
+           std::atomic<bool>& interruptFlag,
+           stellar_default_random_engine::result_type seed, bool quiet = false);
+
+    static std::set<std::set<NodeID>> getIntersectionCriticalGroups(
+        QuorumTracker::QuorumMap const& qmap,
+        std::optional<stellar::Config> const& cfg,
+        std::atomic<bool>& interruptFlag,
+        stellar_default_random_engine::result_type seed);
+
+    static std::set<std::set<NodeID>> getIntersectionCriticalGroups(
+        QuorumSetMap const& qmap, std::optional<stellar::Config> const& cfg,
+        std::atomic<bool>& interruptFlag,
+        stellar_default_random_engine::result_type seed);
 
     virtual ~QuorumIntersectionChecker(){};
     virtual bool networkEnjoysQuorumIntersection() const = 0;

src/herder/QuorumIntersectionCheckerImpl.cpp

@@ -269,16 +269,15 @@ MinQuorumEnumerator::anyMinQuorumHasDisjointQuorum()
 QuorumIntersectionCheckerImpl::QuorumIntersectionCheckerImpl(
     QuorumIntersectionChecker::QuorumSetMap const& qmap,
     std::optional<Config> const& cfg, std::atomic<bool>& interruptFlag,
-    bool quiet)
+    stellar_default_random_engine::result_type seed, bool quiet)
     : mCfg(cfg)
     , mLogTrace(Logging::logTrace("SCP"))
     , mQuiet(quiet)
     , mTSC()
     , mInterruptFlag(interruptFlag)
     , mCachedQuorums(MAX_CACHED_QUORUMS_SIZE)
+    , mRand(seed)
 {
-    assertThreadIsMain();
-    mRand.seed(stellar::gRandomEngine());
     buildGraph(qmap);
     // Awkwardly, the graph size is zero when we initialize mTSC. Update it
     // here.
@@ -818,35 +817,40 @@ toQuorumIntersectionMap(QuorumTracker::QuorumMap const& qmap)
 namespace stellar
 {
 std::shared_ptr<QuorumIntersectionChecker>
-QuorumIntersectionChecker::create(QuorumTracker::QuorumMap const& qmap,
-                                  std::optional<Config> const& cfg,
-                                  std::atomic<bool>& interruptFlag, bool quiet)
+QuorumIntersectionChecker::create(
+    QuorumTracker::QuorumMap const& qmap, std::optional<Config> const& cfg,
+    std::atomic<bool>& interruptFlag,
+    stellar_default_random_engine::result_type seed, bool quiet)
 {
-    return create(toQuorumIntersectionMap(qmap), cfg, interruptFlag, quiet);
+    return create(toQuorumIntersectionMap(qmap), cfg, interruptFlag, seed,
+                  quiet);
 }
 
 std::shared_ptr<QuorumIntersectionChecker>
-QuorumIntersectionChecker::create(QuorumSetMap const& qmap,
-                                  std::optional<Config> const& cfg,
-                                  std::atomic<bool>& interruptFlag, bool quiet)
+QuorumIntersectionChecker::create(
+    QuorumSetMap const& qmap, std::optional<Config> const& cfg,
+    std::atomic<bool>& interruptFlag,
+    stellar_default_random_engine::result_type seed, bool quiet)
 {
     return std::make_shared<QuorumIntersectionCheckerImpl>(
-        qmap, cfg, interruptFlag, quiet);
+        qmap, cfg, interruptFlag, seed, quiet);
 }
 
 std::set<std::set<NodeID>>
 QuorumIntersectionChecker::getIntersectionCriticalGroups(
     QuorumTracker::QuorumMap const& qmap, std::optional<Config> const& cfg,
-    std::atomic<bool>& interruptFlag)
+    std::atomic<bool>& interruptFlag,
+    stellar_default_random_engine::result_type seed)
 {
     return getIntersectionCriticalGroups(toQuorumIntersectionMap(qmap), cfg,
-                                         interruptFlag);
+                                         interruptFlag, seed);
 }
 
 std::set<std::set<NodeID>>
 QuorumIntersectionChecker::getIntersectionCriticalGroups(
     QuorumSetMap const& qmap, std::optional<Config> const& cfg,
-    std::atomic<bool>& interruptFlag)
+    std::atomic<bool>& interruptFlag,
+    stellar_default_random_engine::result_type seed)
 {
     // We're going to search for "intersection-critical" groups, by considering
     // each SCPQuorumSet S that (a) has no innerSets of its own and (b) occurs
@@ -932,9 +936,9 @@ QuorumIntersectionChecker::getIntersectionCriticalGroups(
         }
 
         // Check to see if this modified config is vulnerable to splitting.
-        auto checker =
-            QuorumIntersectionChecker::create(test_qmap, cfg, interruptFlag,
-                                              /*quiet=*/true);
+        auto checker = QuorumIntersectionChecker::create(test_qmap, cfg,
+                                                         interruptFlag, seed,
+                                                         /*quiet=*/true);
         if (checker->networkEnjoysQuorumIntersection())
         {
             CLOG_DEBUG(SCP,

src/herder/QuorumIntersectionCheckerImpl.h

@@ -534,7 +534,9 @@ class QuorumIntersectionCheckerImpl : public stellar::QuorumIntersectionChecker
     QuorumIntersectionCheckerImpl(
         stellar::QuorumIntersectionChecker::QuorumSetMap const& qmap,
         std::optional<stellar::Config> const& cfg,
-        std::atomic<bool>& interruptFlag, bool quiet = false);
+        std::atomic<bool>& interruptFlag,
+        stellar::stellar_default_random_engine::result_type seed,
+        bool quiet = false);
     bool networkEnjoysQuorumIntersection() const override;
 
     std::pair<std::vector<stellar::NodeID>, std::vector<stellar::NodeID>>