add deadlock detection

Author: Kirillog

codegen/yieldpass.cpp

@@ -106,9 +106,6 @@ struct YieldInserter {
       return;
     }
 
-    errs() << "yields inserted to the " << F.getName() << "\n";
-    errs() << F << "\n";
-
     visited.insert(name);
 
     Builder Builder(&*F.begin());
@@ -140,6 +137,9 @@ struct YieldInserter {
       }
     }
 #endif
+
+    errs() << "yields inserted to the " << F.getName() << "\n";
+    errs() << F << "\n";
   }
 
   bool ItsYieldInst(Instruction *inst) {

runtime/include/futex.h

@@ -9,6 +9,8 @@
 struct CoroBase;
 
 struct FutexQueues {
+  // TODO(kmitkin): due to usage in as_atomic functions rewrite to custom hash
+  // table & linked list
   std::unordered_map<std::uintptr_t, std::deque<CoroBase *>> queues;
 
   void Push(FutexState state, CoroBase *coro) {

runtime/include/lib.h

@@ -27,6 +27,8 @@ extern FutexQueues futex_queues;
 
 extern "C" void CoroYield();
 
+extern "C" bool CoroSpin(bool condition);
+
 struct CoroBase : public std::enable_shared_from_this<CoroBase> {
   CoroBase(const CoroBase&) = delete;
   CoroBase(CoroBase&&) = delete;
@@ -72,7 +74,13 @@ struct CoroBase : public std::enable_shared_from_this<CoroBase> {
     futex_queues.Push(state, this);
   }
 
-  bool IsBlocked() { return futex_queues.IsBlocked(fstate, this); }
+  void SetSpinLocked(bool is_spinlocked) {
+    this->is_spinlocked = is_spinlocked;
+  }
+
+  bool IsBlocked() {
+    return is_spinlocked || futex_queues.IsBlocked(fstate, this);
+  }
 
   // Checks if the coroutine is parked.
   bool IsParked() const;
@@ -86,6 +94,7 @@ struct CoroBase : public std::enable_shared_from_this<CoroBase> {
 
   friend void CoroBody(int);
   friend void ::CoroYield();
+  friend bool ::CoroSpin(bool);
 
   template <typename Target, typename... Args>
   friend class Coro;
@@ -99,6 +108,7 @@ struct CoroBase : public std::enable_shared_from_this<CoroBase> {
   // Futex state on which coroutine is blocked.
  public:
   FutexState fstate{};
+  bool is_spinlocked{false};
   // Name.
   std::string_view name;
   boost::context::fiber_context ctx;

runtime/include/minimization.h

@@ -1,7 +1,6 @@
 #pragma once
 #include <unordered_set>
 
-#include "lib.h"
 #include "scheduler_fwd.h"
 
 /**
@@ -11,8 +10,9 @@
 struct RoundMinimizor {
   // Minimizes the number of tasks in the nonlinearized history; modifies
   // argument `nonlinear_history`.
-  virtual void Minimize(SchedulerWithReplay& sched,
-                        Scheduler::BothHistories& nonlinear_history) const = 0;
+  virtual void Minimize(
+      SchedulerWithReplay& sched,
+      Scheduler::NonLinearizableHistory& nonlinear_history) const = 0;
 
   /**
    * Returns ids of tasks taken from `full_history`, excluding those ids, that
@@ -37,8 +37,9 @@ struct GreedyRoundMinimizor : public RoundMinimizor {
    * pairs of tasks and remove them together, this is done to account for
    * data-structures that have the `add/remove` semantics.
    */
-  void Minimize(SchedulerWithReplay& sched,
-                Scheduler::BothHistories& nonlinear_history) const override;
+  void Minimize(
+      SchedulerWithReplay& sched,
+      Scheduler::NonLinearizableHistory& nonlinear_history) const override;
 
  protected:
   /**
@@ -54,7 +55,7 @@ struct GreedyRoundMinimizor : public RoundMinimizor {
    */
   virtual Scheduler::Result OnTasksRemoved(
       SchedulerWithReplay& sched,
-      const Scheduler::BothHistories& nonlinear_history,
+      const Scheduler::NonLinearizableHistory& nonlinear_history,
       const std::unordered_set<int>& task_ids) const = 0;
 };
 
@@ -71,7 +72,7 @@ struct SameInterleavingMinimizor : public GreedyRoundMinimizor {
  protected:
   virtual Scheduler::Result OnTasksRemoved(
       SchedulerWithReplay& sched,
-      const Scheduler::BothHistories& nonlinear_history,
+      const Scheduler::NonLinearizableHistory& nonlinear_history,
       const std::unordered_set<int>& task_ids) const override;
 };
 
@@ -92,7 +93,7 @@ struct StrategyExplorationMinimizor : public GreedyRoundMinimizor {
  protected:
   virtual Scheduler::Result OnTasksRemoved(
       SchedulerWithReplay& sched,
-      const Scheduler::BothHistories& nonlinear_history,
+      const Scheduler::NonLinearizableHistory& nonlinear_history,
       const std::unordered_set<int>& task_ids) const override;
 
  private:

runtime/include/minimization_smart.h

@@ -2,11 +2,9 @@
 
 #include <random>
 #include <set>
-#include <string>
 #include <unordered_map>
 #include <vector>
 
-#include "lib.h"
 #include "minimization.h"
 #include "pretty_print.h"
 #include "scheduler_fwd.h"
@@ -37,21 +35,22 @@ struct SmartMinimizor : public RoundMinimizor {
                           int offsprings_generation_attemps = 10,
                           int initial_mutations_count = 10);
 
-  void Minimize(SchedulerWithReplay& sched,
-                Scheduler::BothHistories& nonlinear_histories) const override;
+  void Minimize(
+      SchedulerWithReplay& sched,
+      Scheduler::NonLinearizableHistory& nonlinear_histories) const override;
 
  private:
   struct Solution {
     explicit Solution(const Strategy& strategy,
-                      const Scheduler::BothHistories& histories,
+                      const Scheduler::NonLinearizableHistory& histories,
                       int total_tasks);
 
     float GetFitness() const;
     int GetValidTasks() const;
 
     std::unordered_map<int, std::unordered_set<int>>
         tasks;  // ThreadId -> { ValidTaskId1, ValidTaskId2, ... }
-    Scheduler::BothHistories nonlinear_histories;
+    Scheduler::NonLinearizableHistory nonlinear_histories;
     // Fitness is a value in range [0.0, 1.0], the bigger it is, the better is
     // the Solution.
    private:

runtime/include/pct_strategy.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <cassert>
+#include <limits>
+#include <optional>
 #include <random>
 
 #include "scheduler.h"
@@ -25,23 +27,21 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
     PrepareForDepth(current_depth, avg_k);
   }
 
-  // If there aren't any non returned tasks and the amount of finished tasks
-  // is equal to the max_tasks the finished task will be returned
-  TaskWithMetaData Next() override {
-    return this->NextVerifiedFor(NextThreadId());
-  }
-
-  size_t NextThreadId() override {
+  std::optional<size_t> NextThreadId() override {
     auto& threads = this->threads;
-    int max = std::numeric_limits<int>::min();
+    size_t max = std::numeric_limits<size_t>::min();
     size_t index_of_max = 0;
     // Have to ignore waiting threads, so can't do it faster than O(n)
     for (size_t i = 0; i < threads.size(); ++i) {
       // Ignore waiting tasks
-      // debug(stderr, "prior: %d, number %d\n", priorities[i], i);
+      debug(stderr, "prior: %d, number %d\n", priorities[i], i);
       if (!threads[i].empty() && threads[i].back()->IsBlocked()) {
-        // debug(stderr, "blocked on %p val %d\n",
-        // threads[i].back()->fstate.addr, threads[i].back()->fstate.value);
+        // NOTE(kmitkin): if we don't get deadlock here, then we able to make a
+        // progress,
+        //                so we have to check spinlock condition again
+        threads[i].back()->SetSpinLocked(false);
+        debug(stderr, "blocked on %p val %d\n", threads[i].back()->fstate.addr,
+              threads[i].back()->fstate.value);
         // dual waiting if request finished, but follow up isn't
         // skip dual tasks that already have finished the request
         // section(follow-up will be executed in another task, so we can't
@@ -55,10 +55,11 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
       }
     }
 
-    if (round_robin_stage > 0) {
+    if (round_robin_stage > 0) [[unlikely]] {
       for (size_t attempt = 0; attempt < threads.size(); ++attempt) {
         auto i = (++last_chosen) % threads.size();
         if (!threads[i].empty() && threads[i].back()->IsBlocked()) {
+          threads[i].back()->SetSpinLocked(false);
           continue;
         }
         index_of_max = i;
@@ -72,7 +73,7 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
     }
 
     // TODO: Choose wiser constant
-    if (count_chosen_same == 1000 && index_of_max == last_chosen) {
+    if (count_chosen_same == 1000 && index_of_max == last_chosen) [[unlikely]] {
       round_robin_stage = 5;
       round_robin_start = index_of_max;
     }
@@ -83,8 +84,9 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
       count_chosen_same = 1;
     }
 
-    assert(max != std::numeric_limits<int>::min() &&
-           "all threads are empty or blocked");
+    if (max == std::numeric_limits<size_t>::min()) [[unlikely]] {
+      return std::nullopt;
+    }
 
     // Check whether the priority change is required
     current_schedule_length++;
@@ -94,25 +96,26 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
       }
     }
 
-    // debug(stderr, "Chosen thread: %d, cnt_count: %d\n", index_of_max,
-    //      count_chosen_same);
+    debug(stderr, "Chosen thread: %d, cnt_count: %d\n", index_of_max,
+          count_chosen_same);
     last_chosen = index_of_max;
     return index_of_max;
   }
 
   // NOTE: `Next` version use heuristics for livelock avoiding, but not there
   // refactor later to avoid copy-paste
-  TaskWithMetaData NextSchedule() override {
+  std::optional<TaskWithMetaData> NextSchedule() override {
     auto& round_schedule = this->round_schedule;
     auto& threads = this->threads;
-    int max = std::numeric_limits<int>::min();
+    size_t max = std::numeric_limits<size_t>::min();
     size_t index_of_max = 0;
     // Have to ignore waiting threads, so can't do it faster than O(n)
     for (size_t i = 0; i < threads.size(); ++i) {
       int task_index = this->GetNextTaskInThread(i);
       // Ignore waiting tasks
       if (task_index == threads[i].size() ||
           threads[i][task_index]->IsBlocked()) {
+        threads[i][task_index]->SetSpinLocked(false);
         // dual waiting if request finished, but follow up isn't
         // skip dual tasks that already have finished the request
         // section(follow-up will be executed in another task, so we can't
@@ -126,7 +129,7 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
       }
     }
 
-    if (round_robin_stage > 0) {
+    if (round_robin_stage > 0) [[unlikely]] {
       for (size_t attempt = 0; attempt < threads.size(); ++attempt) {
         auto i = (++last_chosen) % threads.size();
         int task_index = this->GetNextTaskInThread(i);
@@ -145,7 +148,7 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
     }
 
     // TODO: Choose wiser constant
-    if (count_chosen_same == 1000 && index_of_max == last_chosen) {
+    if (count_chosen_same == 1000 && index_of_max == last_chosen) [[unlikely]] {
       round_robin_stage = 5;
       round_robin_start = index_of_max;
     }
@@ -155,6 +158,11 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
     } else {
       count_chosen_same = 1;
     }
+
+    if (max == std::numeric_limits<size_t>::min()) {
+      return std::nullopt;
+    }
+
     last_chosen = index_of_max;
     // Picked thread is `index_of_max`
     int next_task_index = this->GetNextTaskInThread(index_of_max);

runtime/include/pick_strategy.h

@@ -8,20 +8,24 @@
 
 template <typename TargetObj, StrategyVerifier Verifier>
 struct PickStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
-  virtual size_t Pick() = 0;
+  virtual std::optional<size_t> Pick() = 0;
 
-  virtual size_t PickSchedule() = 0;
+  virtual std::optional<size_t> PickSchedule() = 0;
 
   explicit PickStrategy(size_t threads_count,
                         std::vector<TaskBuilder> constructors)
       : BaseStrategyWithThreads<TargetObj, Verifier>(threads_count,
                                                      constructors) {}
 
-  size_t NextThreadId() override { return Pick(); }
+  std::optional<size_t> NextThreadId() override { return Pick(); }
 
-  TaskWithMetaData NextSchedule() override {
+  std::optional<TaskWithMetaData> NextSchedule() override {
     auto& round_schedule = this->round_schedule;
-    size_t current_thread = PickSchedule();
+    auto current_thread_opt = PickSchedule();
+    if (!current_thread_opt.has_value()) {
+      return std::nullopt;
+    }
+    size_t current_thread = current_thread_opt.value();
     int next_task_index = this->GetNextTaskInThread(current_thread);
     bool is_new = round_schedule[current_thread] != next_task_index;