folly::Baton — one-shot wait 동기화

1
std::mutex mu;
2
std::condition_variable cv;
3
bool ready = false;
4

5
// thread A
6
void wait_for_ready() {
7
  std::unique_lock g(mu);
8
  cv.wait(g, []{ return ready; });
9
}
10

11
// thread B
12
void signal_ready() {
13
  { std::lock_guard g(mu); ready = true; }
14
  cv.notify_all();
15
}

1
folly::Baton<> b;
2

3
// thread A
4
b.wait();         // post 될 때까지 sleep
5

6
// thread B
7
b.post();         // wake

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

3
// 1. 기본 — single post, multiple-wait OK (n번째 wait도 즉시 통과)
4
folly::Baton<> b;
5
b.wait();                   // post 전까지 block
6
b.post();                   // wake all (보통 하나)
7

8
// 2. 타임아웃
9
if (b.try_wait_for(std::chrono::seconds(1))) {
10
  // posted
11
} else {
12
  // timeout
13
}
14

15
// 3. try_wait — non-blocking
16
if (b.try_wait()) { /* 이미 posted */ }
17

18
// 4. 재사용 — reset
19
b.reset();
20
// 그 후 wait/post 다시 가능
21

22
// 5. blocking mode template param
23
folly::Baton<true>  spin_baton;   // spin 한 후 futex (기본)
24
folly::Baton<false> futex_only;   // spin 없이 바로 sleep

1
// 약식 — folly/synchronization/Baton.h
2
template <bool MayBlock = true>
3
class Baton {
4
  std::atomic<uint32_t> state_;
5
  // state values:
6
  //   INIT     = 0
7
  //   WAITING  = 1
8
  //   EARLY_DELIVERY = 2 (post가 wait 전에 옴)
9
  //   TIMED_OUT = 3
10
};

1
// 약식
2
void post() {
3
  uint32_t prev = state_.exchange(EARLY_DELIVERY,
4
                                   std::memory_order_release);
5
  if (prev == WAITING) {
6
    // 누가 sleep 중
7
    futex_wake_one(&state_);
8
  }
9
}

1
// 약식
2
void wait() {
3
  // 1. spin 시도
4
  for (int spin = 0; spin < kMaxSpins; ++spin) {
5
    uint32_t s = state_.load(std::memory_order_acquire);
6
    if (s == EARLY_DELIVERY) return;
7
    cpu_pause();
8
  }
9
  // 2. WAITING으로 표시 후 futex sleep
10
  uint32_t expected = INIT;
11
  if (state_.compare_exchange_strong(expected, WAITING,
12
                                      std::memory_order_acquire)) {
13
    while (state_.load() == WAITING) {
14
      futex_wait(&state_, WAITING);
15
    }
16
  }
17
  // 그 외 EARLY_DELIVERY 였음 — 즉시 반환
18
}

1
Baton:
2
  state load (acquire) → spin → CAS → futex_wait
3
  state exchange (release) → futex_wake
4

5
cv:
6
  mutex.lock → predicate → mutex.unlock → futex_wait
7
  mutex.lock → state change → mutex.unlock → futex_wake_all → cv_mu.lock

1
// 약식 — folly::Future가 내부적으로
2
struct State {
3
  folly::Baton<> baton;
4
  std::optional<T> value;
5
};
6

7
void Promise::setValue(T v) {
8
  state_->value = std::move(v);
9
  state_->baton.post();
10
}
11

12
T Future::get() {
13
  state_->baton.wait();
14
  return std::move(*state_->value);
15
}

1
folly::Baton<> ready;
2
std::thread worker([&]() {
3
  Setup();
4
  ready.post();    // ready
5
  RunLoop();
6
});
7

8
ready.wait();      // setup 끝까지 대기
9
StartUsingWorker();

1
TEST(MyTest, AsyncCallback) {
2
  folly::Baton<> done;
3
  service.DoAsync([&]() { done.post(); });
4
  ASSERT_TRUE(done.try_wait_for(std::chrono::seconds(5)));
5
}

1
// std — cv 풀세트
2
std::condition_variable cv;
3
std::mutex mu;
4
bool flag = false;
5
void wait() { std::unique_lock g(mu); cv.wait(g, []{ return flag; }); }
6

7
// abseil — Notification
8
absl::Notification n;
9
n.WaitForNotification();
10
n.Notify();   // 한 번만 가능
11

12
// folly
13
folly::Baton<> b;
14
b.wait();
15
b.post();     // 여러 번 호출 가능, 추가 post는 no-op

1
// Bad — Baton을 반복 사용 (reset 없이)
2
folly::Baton<> b;
3
for (int i = 0; i < N; ++i) {
4
  worker.Submit([&]{ ... b.post(); });
5
  b.wait();
6
  // 두 번째부터는 EARLY_DELIVERY 라 즉시 통과 → race!
7
}
8

9
// Good — 매번 reset
10
for (int i = 0; i < N; ++i) {
11
  b.reset();
12
  worker.Submit([&]{ ... b.post(); });
13
  b.wait();
14
}

1
// Good — timeout으로 deadlock 검출
2
if (!b.try_wait_for(std::chrono::seconds(30))) {
3
  LOG(ERROR) << "deadlock?";
4
}

1
// 주의 — Baton이 stack object일 때 lifetime
2
{
3
  folly::Baton<> b;
4
  worker.Submit([&b]{ b.post(); });
5
  b.wait();
6
}   // worker가 아직 b를 본다면? — wait 후 destruct이므로 OK