cc core: cleanup wait-all-checked-upgrade experiment

Removes the old WaitAllChecked implementation and cleans up the related experiment.
commit_hash:fcd3a1cc43e3858f76fc3f7f172529f01511387c

Author: lexeyo

core/include/userver/utils/impl/userver_experiments.hpp

@@ -58,7 +58,6 @@ extern UserverExperiment kJemallocBgThread;
 extern UserverExperiment kServerSelectionTimeoutExperiment;
 extern UserverExperiment kPgCcExperiment;
 extern UserverExperiment kYdbDeadlinePropagationExperiment;
-extern UserverExperiment kWaitAllCheckedUpgradeExperiment;
 extern UserverExperiment kPgConnlimitWatchdogFallbackExperiment;
 extern UserverExperiment kPgConnlimitWatchdogReservationExperiment;
 

core/src/engine/wait_all_checked.cpp

@@ -23,54 +23,6 @@ void RethrowError(ContextAccessor& accessor) {
     }
 }
 
-FutureStatus DoWaitAllCheckedOld(utils::span<ContextAccessor*> targets, Deadline deadline) {
-    UASSERT_MSG(AreUniqueValues(targets), "Same tasks/futures were detected in WaitAny* call");
-    auto& current = current_task::GetCurrentTaskContext();
-
-    WaitAnyWaitStrategy wait_strategy{targets, current};
-    while (true) {
-        bool all_completed = true;
-        for (auto& target : targets) {
-            if (!target) {
-                continue;
-            }
-
-            const bool is_ready = target->IsReady();
-            if (is_ready) {
-                auto exception_ptr = target->GetErrorResult();
-                if (exception_ptr) {
-                    std::rethrow_exception(exception_ptr);
-                }
-                target = nullptr;
-            }
-            all_completed &= is_ready;
-        }
-        if (all_completed) {
-            break;
-        }
-
-        auto sleep_status = current.Sleep(wait_strategy, deadline);
-
-        switch (sleep_status) {
-            case TaskContext::WakeupSource::kNotify:
-                break;
-            case TaskContext::WakeupSource::kDeadlineTimer:
-                return FutureStatus::kTimeout;
-            case TaskContext::WakeupSource::kCancelRequest:
-                return FutureStatus::kCancelled;
-            case TaskContext::WakeupSource::kNone:
-                UASSERT_MSG(false, "Unexpected WakeupSource::kNone");
-                break;
-            case TaskContext::WakeupSource::kBootstrap:
-                UASSERT_MSG(false, "Unexpected WakeupSource::kBootstrap");
-                break;
-        }
-    }
-
-    UASSERT(std::all_of(targets.begin(), targets.end(), [](auto* target) { return !target; }));
-    return FutureStatus::kReady;
-}
-
 }  // namespace
 
 class WaitAllCheckedContext final {
@@ -189,9 +141,6 @@ void WaitAllCheckedContext::Impl::DoNotify(
 }
 
 FutureStatus DoWaitAllChecked(std::vector<ContextAccessor*>&& targets, Deadline deadline) {
-    if (!utils::impl::kWaitAllCheckedUpgradeExperiment.IsEnabled()) {
-        return DoWaitAllCheckedOld(targets, deadline);
-    }
     UASSERT_MSG(AreUniqueValues(targets), "Same tasks/futures were detected in WaitAny* call");
     WaitAllCheckedContext context{std::move(targets)};
     return context.WaitUntil(deadline);

core/src/engine/wait_all_checked_test.cpp

@@ -43,15 +43,7 @@ engine::TaskWithResult<int> FastSuccessfulTask(int i) {
 
 }  // namespace
 
-class WaitAllChecked : public ::testing::Test {
-public:
-    void SetUp() override { scope_.Set(utils::impl::kWaitAllCheckedUpgradeExperiment, true); }
-
-private:
-    utils::impl::UserverExperimentsScope scope_;
-};
-
-UTEST_F(WaitAllChecked, JustWorksVectorTasks) {
+UTEST(WaitAllChecked, JustWorksVectorTasks) {
     static constexpr std::size_t kTaskCount = 4;
 
     std::vector<engine::TaskWithResult<void>> tasks;
@@ -69,7 +61,7 @@ UTEST_F(WaitAllChecked, JustWorksVectorTasks) {
     }
 }
 
-UTEST_F(WaitAllChecked, JustWorksVariadicTasks) {
+UTEST(WaitAllChecked, JustWorksVariadicTasks) {
     static constexpr std::size_t kTaskCount = 3;
 
     std::vector<engine::TaskWithResult<void>> tasks;
@@ -87,7 +79,7 @@ UTEST_F(WaitAllChecked, JustWorksVariadicTasks) {
     }
 }
 
-UTEST_F_MT(WaitAllChecked, EarlyThrow, 4) {
+UTEST_MT(WaitAllChecked, EarlyThrow, 4) {
     std::vector<engine::TaskWithResult<void>> tasks;
     tasks.reserve(GetThreadCount() + 1);
 
@@ -99,13 +91,13 @@ UTEST_F_MT(WaitAllChecked, EarlyThrow, 4) {
     UEXPECT_THROW(engine::WaitAllChecked(tasks), std::runtime_error);
 }
 
-UTEST_F(WaitAllChecked, InvalidTask) {
+UTEST(WaitAllChecked, InvalidTask) {
     std::vector<engine::TaskWithResult<void>> tasks;
     tasks.emplace_back();
     UEXPECT_NO_THROW(engine::WaitAllChecked(tasks));
 }
 
-UTEST_F(WaitAllChecked, ValidAndInvalidTasks) {
+UTEST(WaitAllChecked, ValidAndInvalidTasks) {
     std::vector<engine::TaskWithResult<void>> tasks;
     tasks.push_back(FastSuccessfulTask());
     for (std::size_t i = 0; i < 3; ++i) {
@@ -116,7 +108,7 @@ UTEST_F(WaitAllChecked, ValidAndInvalidTasks) {
     EXPECT_TRUE(tasks[0].IsFinished());
 }
 
-UTEST_F(WaitAllChecked, Cancellation) {
+UTEST(WaitAllChecked, Cancellation) {
     constexpr std::size_t kTaskCount = 3;
 
     std::vector<engine::TaskWithResult<void>> tasks;
@@ -130,7 +122,7 @@ UTEST_F(WaitAllChecked, Cancellation) {
     UEXPECT_THROW(engine::WaitAllChecked(tasks), engine::WaitInterruptedException);
 }
 
-UTEST_F(WaitAllChecked, SequentialWakeups) {
+UTEST(WaitAllChecked, SequentialWakeups) {
     constexpr std::size_t kTaskCount = 10;
 
     engine::SingleConsumerEvent events[kTaskCount];
@@ -149,7 +141,7 @@ UTEST_F(WaitAllChecked, SequentialWakeups) {
     engine::WaitAllChecked(tasks);
 }
 
-UTEST_F(WaitAllChecked, TaskWithResult) {
+UTEST(WaitAllChecked, TaskWithResult) {
     constexpr std::size_t kTaskCount = 10;
 
     std::vector<engine::TaskWithResult<int>> tasks;
@@ -167,7 +159,7 @@ UTEST_F(WaitAllChecked, TaskWithResult) {
     }
 }
 
-UTEST_F(WaitAllChecked, HeterogenousWait) {
+UTEST(WaitAllChecked, HeterogenousWait) {
     constexpr int kExpectedValue = 42;
 
     auto task = FastSuccessfulTask();
@@ -187,40 +179,39 @@ UTEST_F(WaitAllChecked, HeterogenousWait) {
     EXPECT_EQ(future.get(), kExpectedValue);
 }
 
-UTEST_F(WaitAllChecked, DeadlineSuccess) {
+UTEST(WaitAllChecked, DeadlineSuccess) {
     auto task = FastSuccessfulTask();
     EXPECT_EQ(engine::WaitAllCheckedFor(utest::kMaxTestWaitTime, task), engine::FutureStatus::kReady);
     EXPECT_TRUE(task.IsFinished());
 }
 
-UTEST_F(WaitAllChecked, DeadlineTimeout) {
+UTEST(WaitAllChecked, DeadlineTimeout) {
     auto task = SlowSuccessfulTask();
     EXPECT_EQ(engine::WaitAllCheckedFor(10ms, task), engine::FutureStatus::kTimeout);
     EXPECT_FALSE(task.IsFinished());
 }
 
-UTEST_F(WaitAllChecked, DeadlineCancelled) {
+UTEST(WaitAllChecked, DeadlineCancelled) {
     auto task = SlowSuccessfulTask();
     engine::current_task::SetDeadline(engine::Deadline::FromDuration(10ms));
     EXPECT_EQ(engine::WaitAllCheckedFor(utest::kMaxTestWaitTime, task), engine::FutureStatus::kCancelled);
 }
 
-UTEST_F(WaitAllChecked, DeadlineCancelledBefore) {
+UTEST(WaitAllChecked, DeadlineCancelledBefore) {
     auto task = SlowSuccessfulTask();
     engine::current_task::SetDeadline(engine::Deadline::Passed());
     EXPECT_EQ(engine::WaitAllCheckedFor(utest::kMaxTestWaitTime, task), engine::FutureStatus::kCancelled);
 }
 
-UTEST_F(WaitAllChecked, DeadlineTimeoutUntil) {
+UTEST(WaitAllChecked, DeadlineTimeoutUntil) {
     auto task = SlowSuccessfulTask();
     EXPECT_EQ(
         engine::WaitAllCheckedUntil(std::chrono::steady_clock::now() + 10ms, task),
         engine::FutureStatus::kTimeout
     );
 }
 
-UTEST_F_MT(WaitAllChecked, ExceptionStressTest, 16) {
-    ASSERT_TRUE(utils::impl::kWaitAllCheckedUpgradeExperiment.IsEnabled());
+UTEST_MT(WaitAllChecked, ExceptionStressTest, 16) {
     for (auto _ : utest::StressLoop()) {
         const std::size_t task_count = utils::RandRange(100u, 500u);
         const std::size_t failing = utils::RandRange(std::size_t{0}, task_count);

core/src/utils/impl/userver_experiments.cpp

@@ -94,7 +94,6 @@ UserverExperiment kJemallocBgThread{"jemalloc-bg-thread"};
 UserverExperiment kServerSelectionTimeoutExperiment{"mongo-server-selection-timeout"};
 UserverExperiment kPgCcExperiment{"pg-cc"};
 UserverExperiment kYdbDeadlinePropagationExperiment{"ydb-deadline-propagation"};
-UserverExperiment kWaitAllCheckedUpgradeExperiment{"wait-all-checked-upgrade"};
 UserverExperiment kPgConnlimitWatchdogFallbackExperiment{"pg-connlimit-watchdog-new-fallback"};
 UserverExperiment kPgConnlimitWatchdogReservationExperiment{"pg-connlimit-watchdog-new-reservation"};