folly::coro::Baton·Mutex — 코루틴-aware 동기화

1
// Bad
2
folly::coro::Task<void> Process(SharedData& d) {
3
  std::lock_guard lk(d.mu);   // ← thread block. pool 1/n 잠금.
4
  co_await asyncWrite(d.snapshot());
5
  d.update();
6
}

1
#include <folly/coro/Baton.h>
2

3
folly::coro::Baton baton;
4

5
folly::coro::Task<void> Waiter() {
6
  co_await baton;        // suspend until post
7
  // do work
8
}
9

10
folly::coro::Task<void> Poster() {
11
  // ... compute ...
12
  baton.post();         // wake all waiters
13
}

1
folly::coro::Baton ready;
2

3
auto t1 = []() -> folly::coro::Task<void> { co_await ready; /* ... */ }();
4
auto t2 = []() -> folly::coro::Task<void> { co_await ready; /* ... */ }();
5
auto t3 = []() -> folly::coro::Task<void> { co_await ready; /* ... */ }();
6

7
// ... 시간이 흐른 후
8
ready.post();   // 셋 다 동시에 깨어남

1
#include <folly/coro/Mutex.h>
2

3
folly::coro::Mutex mu;
4
int counter = 0;
5

6
folly::coro::Task<void> Increment() {
7
  auto lock = co_await mu.co_scoped_lock();
8
  // critical section — 다른 코루틴이 이 mu에 락 시도하면 suspend
9
  co_await asyncWork();
10
  ++counter;
11
  // lock 소멸자가 unlock
12
}

1
// std::mutex와 std::async — lock 들고 async 안 됨
2
std::mutex m;
3
auto fut = std::async(std::launch::async, [&] {
4
  std::lock_guard lk(m);
5
  return otherAsync().get();   // block — thread 다시 잠김
6
});

1
folly::coro::SharedMutex mu;
2
Config cfg;
3

4
folly::coro::Task<Config> Read() {
5
  auto lk = co_await mu.co_scoped_lock_shared();
6
  co_return cfg;
7
}
8

9
folly::coro::Task<void> Write(Config c) {
10
  auto lk = co_await mu.co_scoped_lock();
11
  cfg = std::move(c);
12
}

1
folly::coro::Semaphore sem{4};   // 최대 4 동시
2

3
folly::coro::Task<void> BatchProcess(std::vector<Item> items) {
4
  std::vector<folly::coro::Task<void>> tasks;
5
  for (auto& item : items) {
6
    tasks.push_back([&, item]() -> folly::coro::Task<void> {
7
      auto guard = co_await sem.co_scoped_lock();
8
      co_await Process(item);
9
    }());
10
  }
11
  co_await folly::coro::collectAllRange(std::move(tasks));
12
}

1
// folly/coro/Mutex.h 약식
2
class Mutex {
3
 public:
4
  auto co_lock() noexcept {
5
    struct Awaiter {
6
      Mutex* mu;
7
      std::coroutine_handle<> handle_;
8
      Awaiter* next_ = nullptr;
9

10
      bool await_ready() noexcept {
11
        return mu->tryLock();
12
      }
13
      void await_suspend(std::coroutine_handle<> h) noexcept {
14
        handle_ = h;
15
        mu->addWaiter(this);   // atomic linked list 앞에 push
16
      }
17
      void await_resume() noexcept {}
18
    };
19
    return Awaiter{this};
20
  }
21

22
  void unlock() noexcept {
23
    auto* w = popWaiter();   // atomic pop
24
    if (w) {
25
      // resume on executor — current thread 또는 captured executor
26
      executor_->add([h = w->handle_] { h.resume(); });
27
    } else {
28
      locked_.store(false);
29
    }
30
  }
31
};

1
// 1. coro::Mutex 사용하지만 std::lock_guard와 혼용
2
folly::coro::Mutex mu;
3
{
4
  std::lock_guard lk(mu);   // 컴파일 에러 또는 wrong overload
5
  co_await ...;
6
}
7

8
// 2. Baton을 broadcast로 사용한 뒤 reset 잊음
9
baton.post();
10
// 다음 라운드 시작
11
co_await baton;   // 즉시 통과 — 의도와 다름
12

13
// 3. Semaphore acquire 후 await 도중 throw, release 안 됨
14
co_await sem.acquire();   // raw acquire
15
co_await mayThrow();      // 예외 → semaphore 영원히 점유
16
co_await sem.release();
17
// → co_scoped_lock으로 RAII 처리해야