folly::coro 개요 — production C++20 코루틴 어댑터

1
folly::coro::Task<std::string> Fetch(std::string url);
2
folly::SemiFuture<int>          LegacyParse(std::string body);
3

4
folly::coro::Task<int> Pipeline(std::string url) {
5
  auto body = co_await Fetch(url);          // Task
6
  int  n    = co_await LegacyParse(body);   // SemiFuture
7
  co_return n;
8
}

1
folly::coro::Task<T>           — lazy single-shot, executor에 schedule
2
folly::coro::AsyncGenerator<T> — async stream (co_yield)
3
folly::coro::Generator<T>      — sync stream (co_yield) — 일반 코루틴 generator
4
folly::coro::Baton             — coroutine-aware 1-shot notification
5
folly::coro::Mutex             — coroutine-aware mutex
6
folly::coro::SharedMutex       — RW mutex
7
folly::coro::Semaphore         — counting semaphore
8
folly::coro::Promise<T>        — manual promise (Future의 Promise와 유사)
9
folly::coro::AsyncScope        — fire-and-forget 안전판
10
folly::coro::CancellationToken — 협력적 취소

1
#include <folly/coro/Task.h>
2
#include <folly/coro/BlockingWait.h>
3
#include <folly/coro/Collect.h>
4
#include <folly/executors/CPUThreadPoolExecutor.h>
5

6
folly::coro::Task<int> Compute(int x) {
7
  // 다른 Task await
8
  int y = co_await Helper(x);
9
  co_return x * y;
10
}
11

12
folly::coro::Task<std::vector<int>> ParallelCompute() {
13
  auto [a, b, c] = co_await folly::coro::collectAll(
14
    Compute(1), Compute(2), Compute(3));
15
  co_return std::vector{a, b, c};
16
}
17

18
int main() {
19
  folly::CPUThreadPoolExecutor pool(4);
20
  auto result = folly::coro::blockingWait(
21
    ParallelCompute().scheduleOn(&pool));
22
  // result = [1, 2, 9]
23
}

1
folly::coro::Task<UserProfile> GetUserProfile(UserId id) {
2
  // 동시에 셋을 시작
3
  auto userTask    = userService_->getUser(id);
4
  auto prefsTask   = prefsService_->getPrefs(id);
5
  auto avatarTask  = avatarService_->getAvatar(id);
6

7
  auto [user, prefs, avatar] = co_await folly::coro::collectAll(
8
    std::move(userTask),
9
    std::move(prefsTask),
10
    std::move(avatarTask));
11

12
  co_return UserProfile{std::move(user), std::move(prefs), std::move(avatar)};
13
}

1
// folly/coro/Task.h 의 약식
2
template <class T>
3
class Task {
4
 public:
5
  class promise_type {
6
   public:
7
    Task<T> get_return_object() noexcept;
8
    suspend_always initial_suspend() noexcept;             // lazy start
9
    auto           final_suspend() noexcept;               // resume awaiter
10
    void           return_value(T v) noexcept;
11
    void           unhandled_exception() noexcept;
12

13
    // executor binding
14
    folly::Executor::KeepAlive<> executor_;
15

16
    // exception 보관
17
    folly::Try<T> result_;
18
  };
19

20
  // awaiter: co_await Task<T>의 동작
21
  auto operator co_await() && noexcept;
22
};

1
// 1. Task를 호출만 하고 await도 schedule도 안 함
2
void Caller() {
3
  Compute(1);   // 영원히 실행되지 않음
4
}
5

6
// 2. 라이브러리 함수 안에서 blockingWait
7
int Helper() {
8
  return folly::coro::blockingWait(SomeTask());  // 호출자가 이미 coro면 deadlock 위험
9
}
10

11
// 3. reference capture가 lambda 외부 수명보다 김
12
folly::coro::Task<int> Bad(int& x) {
13
  co_return co_await Helper(x);  // Bad() 반환 후 x가 dangling이면 끝
14
}