refactor code

Author: Kirillog

runtime/include/futex.h runtime/include/block_manager.hruntime/include/futex.h renamed to runtime/include/block_manager.h

@@ -4,29 +4,29 @@
 #include <deque>
 #include <unordered_map>
 
-#include "futex_state.h"
+#include "block_state.h"
 
 struct CoroBase;
 
-struct FutexQueues {
+struct BlockManager {
   // 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) {
+  void BlockOn(BlockState state, CoroBase *coro) {
     if (!queues.contains(state.addr)) {
       queues[state.addr] = std::deque<CoroBase *>{};
     }
     queues[state.addr].push_back(coro);
   }
 
-  bool IsBlocked(const FutexState &state, CoroBase *coro) {
+  bool IsBlocked(const BlockState &state, CoroBase *coro) {
     return state.addr &&
            std::find(queues[state.addr].begin(), queues[state.addr].end(),
                      coro) != queues[state.addr].end();
   }
 
-  std::size_t Pop(std::intptr_t addr, std::size_t max_wakes) {
+  std::size_t UnblockOn(std::intptr_t addr, std::size_t max_wakes) {
     if (!queues.contains(addr)) [[unlikely]] {
       return 0;
     }
@@ -38,12 +38,12 @@ struct FutexQueues {
     return wakes;
   }
 
-  void PopAll(std::intptr_t addr) {
+  void UnblockAllOn(std::intptr_t addr) {
     if (!queues.contains(addr)) {
       return;
     }
     queues[addr].clear();
   }
 };
 
-extern FutexQueues futex_queues;
+extern BlockManager block_manager;

runtime/include/futex_state.h runtime/include/block_state.hruntime/include/futex_state.h renamed to runtime/include/block_state.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cstdint>
-struct FutexState {
+struct BlockState {
   std::intptr_t addr;
   long value;
 

runtime/include/blocking_primitives.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <mutex>
 
-#include "futex.h"
+#include "block_manager.h"
 #include "lib.h"
 #include "verifying_macro.h"
 
@@ -27,13 +27,13 @@ struct mutex {
 
   as_atomic void unlock() {
     locked = 0;
-    futex_queues.PopAll(
+    block_manager.UnblockAllOn(
         state.addr);  // To have the ability schedule any coroutine
   }
 
  private:
   int locked{0};
-  FutexState state{reinterpret_cast<std::intptr_t>(&locked), locked};
+  BlockState state{reinterpret_cast<std::intptr_t>(&locked), locked};
 
   friend struct condition_variable;
 };
@@ -48,7 +48,7 @@ struct shared_mutex {
   }
   as_atomic void unlock() {
     locked = 0;
-    futex_queues.PopAll(state.addr);
+    block_manager.UnblockAllOn(state.addr);
   }
   as_atomic void lock_shared() {
     while (locked == -1) {
@@ -59,12 +59,12 @@ struct shared_mutex {
   }
   as_atomic void unlock_shared() {
     --locked;
-    futex_queues.PopAll(state.addr);
+    block_manager.UnblockAllOn(state.addr);
   }
 
  private:
   int locked{0};
-  FutexState state{reinterpret_cast<std::intptr_t>(&locked), locked};
+  BlockState state{reinterpret_cast<std::intptr_t>(&locked), locked};
 };
 
 struct condition_variable {
@@ -76,9 +76,9 @@ struct condition_variable {
     lock.lock();
   }
 
-  as_atomic void notify_one() { futex_queues.Pop(addr, 1); }
+  as_atomic void notify_one() { block_manager.UnblockOn(addr, 1); }
 
-  as_atomic void notify_all() { futex_queues.PopAll(addr); }
+  as_atomic void notify_all() { block_manager.UnblockAllOn(addr); }
 
  private:
   std::intptr_t addr;

runtime/include/lib.h

@@ -9,21 +9,21 @@
 #include <utility>
 #include <vector>
 
-#include "futex.h"
+#include "block_manager.h"
 
 #define panic() assert(false)
 
 struct CoroBase;
 
-struct FutexQueues;
+struct BlockManager;
 
 // Current executing coroutine.
 extern std::shared_ptr<CoroBase> this_coro;
 
 // Scheduler context
 extern boost::context::fiber_context sched_ctx;
 
-extern FutexQueues futex_queues;
+extern BlockManager block_manager;
 
 extern "C" void CoroYield();
 
@@ -67,14 +67,14 @@ struct CoroBase : public std::enable_shared_from_this<CoroBase> {
   // Terminate the coroutine.
   void Terminate();
 
-  void SetBlocked(const FutexState& state) {
+  void SetBlocked(const BlockState& state) {
     fstate = state;
-    futex_queues.Push(state, this);
+    block_manager.BlockOn(state, this);
   }
 
-  FutexState GetFutexState() { return fstate; }
+  BlockState GetBlockState() { return fstate; }
 
-  bool IsBlocked() { return futex_queues.IsBlocked(fstate, this); }
+  bool IsBlocked() { return block_manager.IsBlocked(fstate, this); }
 
   // Checks if the coroutine is parked.
   bool IsParked() const;
@@ -99,7 +99,7 @@ struct CoroBase : public std::enable_shared_from_this<CoroBase> {
   // Is coroutine returned.
   bool is_returned{};
   // Futex state on which coroutine is blocked.
-  FutexState fstate{};
+  BlockState fstate{};
   // Name.
   std::string_view name;
   boost::context::fiber_context ctx;

runtime/include/pct_strategy.h

@@ -37,8 +37,8 @@ struct PctStrategy : public BaseStrategyWithThreads<TargetObj, Verifier> {
       // 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()->GetFutexState().addr,
-        // threads[i].back()->GetFutexState().value);
+        // threads[i].back()->GetBlockState().addr,
+        // threads[i].back()->GetBlockState().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

runtime/lib.cpp

@@ -12,7 +12,7 @@ Task this_coro{};
 
 boost::context::fiber_context sched_ctx;
 
-FutexQueues futex_queues;
+BlockManager block_manager;
 
 namespace ltest {
 std::vector<TaskBuilder> task_builders{};

syscall_intercept/hook.cpp

@@ -5,7 +5,7 @@
 
 #include <cerrno>
 
-#include "runtime/include/futex.h"
+#include "runtime/include/block_manager.h"
 #include "runtime/include/lib.h"
 #include "runtime/include/logger.h"
 #include "runtime/include/syscall_trap.h"
@@ -25,7 +25,7 @@ static int hook(long syscall_number, long arg0, long arg1, long arg2, long arg3,
           (unsigned long)arg0, arg1, arg2, *((int *)arg0));
     arg1 = arg1 & FUTEX_CMD_MASK;
     if (arg1 == FUTEX_WAIT || arg1 == FUTEX_WAIT_BITSET) {
-      auto fstate = FutexState{arg0, arg2};
+      auto fstate = BlockState{arg0, arg2};
       if (fstate.CanBeBlocked()) {
         this_coro->SetBlocked(fstate);
         CoroYield();
@@ -36,7 +36,7 @@ static int hook(long syscall_number, long arg0, long arg1, long arg2, long arg3,
       }
     } else if (arg1 == FUTEX_WAKE || arg1 == FUTEX_WAKE_BITSET) {
       debug(stderr, "caught wake\n");
-      *result = futex_queues.Pop(arg0, arg2);
+      *result = block_manager.Pop(arg0, arg2);
     } else {
       assert(false && "unsupported futex call");
     }