folly::coro::Task — lazy single-shot 코루틴

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

5
folly::coro::Task<int> Add(int a, int b) {
6
  co_return a + b;
7
}
8

9
folly::coro::Task<int> Compose() {
10
  int x = co_await Add(1, 2);
11
  int y = co_await Add(x, 10);
12
  co_return y;
13
}
14

15
int main() {
16
  folly::CPUThreadPoolExecutor pool(4);
17
  int v = folly::coro::blockingWait(Compose().scheduleOn(&pool));
18
  // v == 13
19
}

1
// 1. scheduleOn: SemiAwaitable로 만든다. blockingWait 또는 SemiFuture 변환에 사용.
2
auto sf = Compute().scheduleOn(&pool).start();  // start() → SemiFuture<int>
3

4
// 2. co_await: 부모 Task의 executor를 상속받아 실행
5
folly::coro::Task<int> Caller() {
6
  int v = co_await Compute();   // pool이 명시되지 않음 — 부모 따라감
7
  co_return v;
8
}

1
folly::coro::Task<int> RiskyCompute();
2

3
folly::coro::Task<int> Safe() {
4
  auto t = co_await folly::coro::co_awaitTry(RiskyCompute());
5
  if (t.hasException()) {
6
    LOG(ERROR) << "compute failed: " << t.exception().what();
7
    co_return -1;
8
  }
9
  co_return t.value();
10
}

1
folly::coro::Task<void> Log(std::string msg) {
2
  co_await asyncWrite(msg);
3
  co_return;   // 또는 그냥 함수 끝
4
}

1
// folly/coro/Task.h 약식
2
template <class T>
3
class Task {
4
 public:
5
  using promise_type = TaskPromise<T>;
6
  // ...
7
};
8

9
template <class T>
10
class TaskPromise {
11
 public:
12
  Task<T> get_return_object() noexcept {
13
    return Task<T>{std::coroutine_handle<TaskPromise>::from_promise(*this)};
14
  }
15
  std::suspend_always initial_suspend() noexcept { return {}; }
16
  FinalAwaiter        final_suspend() noexcept   { return {}; }
17
  void                return_value(T value) noexcept {
18
    result_.emplace(std::move(value));
19
  }
20
  void unhandled_exception() noexcept {
21
    result_.emplaceException(std::current_exception());
22
  }
23

24
 private:
25
  folly::Try<T>                  result_;
26
  folly::Executor::KeepAlive<>   executor_;
27
  std::coroutine_handle<>        continuation_;
28
};

1
// awaiter — co_await Task<T>의 동작
2
struct TaskAwaiter {
3
  std::coroutine_handle<TaskPromise<T>> child_;
4

5
  bool await_ready() noexcept { return false; }
6

7
  auto await_suspend(std::coroutine_handle<> caller) noexcept {
8
    auto& childPromise = child_.promise();
9
    childPromise.continuation_ = caller;
10
    childPromise.executor_     = currentExecutor();   // 부모로부터 상속
11
    return child_;   // symmetric transfer — 즉시 child 실행
12
  }
13

14
  T await_resume() {
15
    auto& promise = child_.promise();
16
    if (promise.result_.hasException()) {
17
      promise.result_.exception().throw_exception();
18
    }
19
    return std::move(*promise.result_);
20
  }
21
};

1
folly::coro::Task<int> RecursiveSum(int n) {
2
  if (n == 0) co_return 0;
3
  int rest = co_await RecursiveSum(n - 1);
4
  co_return n + rest;
5
}
6

7
// n = 100,000도 OK
8
folly::coro::blockingWait(RecursiveSum(100000).scheduleOn(&pool));

1
// Good — value capture
2
folly::coro::Task<int> Compute(std::string s) {
3
  co_await Delay(std::chrono::milliseconds(1));
4
  co_return std::stoi(s);
5
}
6

7
// Bad — reference 인자
8
folly::coro::Task<int> Compute(const std::string& s) {  // dangling 위험
9
  co_await Delay(std::chrono::milliseconds(1));
10
  co_return std::stoi(s);  // suspend 뒤에 s가 살아있을까?
11
}

1
folly::coro::Task<int> MakeWork(std::string input) {
2
  co_return co_await [s = std::move(input)]() -> folly::coro::Task<int> {
3
    co_await Delay(std::chrono::milliseconds(1));
4
    co_return std::stoi(s);
5
  }();
6
}

1
// Task → SemiFuture
2
folly::SemiFuture<int> sf = std::move(task).scheduleOn(&pool).start();
3

4
// SemiFuture → Task
5
folly::coro::Task<int> t = folly::coro::toTask(std::move(sf));
6

7
// 또는 SemiFuture는 직접 co_await 가능
8
folly::coro::Task<int> Caller(folly::SemiFuture<int> sf) {
9
  int v = co_await std::move(sf);
10
  co_return v;
11
}

1
// 1. Task 즉시 폐기
2
void Bad() {
3
  Compute();   // 무시됨 — 실행 안 됨
4
}
5

6
// 2. Task를 두 번 await
7
folly::coro::Task<int> Twice(folly::coro::Task<int> t) {
8
  int a = co_await std::move(t);
9
  int b = co_await std::move(t);  // already consumed — UB
10
  co_return a + b;
11
}
12

13
// 3. ScheduleOn 두 번
14
auto v = co_await Compute().scheduleOn(&p1).scheduleOn(&p2);  // p2가 이김 — 의도 불명