folly::Future 분석 — std::future의 한계를 넘는 composable async

1
#include <folly/futures/Future.h>
2
#include <folly/executors/CPUThreadPoolExecutor.h>
3

4
folly::CPUThreadPoolExecutor pool(4);
5

6
// 1) 즉시 완료된 Future
7
folly::SemiFuture<int> sf = folly::makeSemiFuture(42);
8

9
// 2) executor에 bind → Future
10
folly::Future<int> f = std::move(sf).via(&pool);
11

12
// 3) continuation 체인
13
auto result = std::move(f)
14
  .thenValue([](int x) { return x * 2; })
15
  .thenValue([](int x) { return std::to_string(x); })
16
  .thenError(folly::tag_t<std::exception>{}, [](auto const& e) {
17
    return std::string{"error: "} + e.what();
18
  })
19
  .get();   // blocking wait

1
// folly/futures/detail/Core.h (요약)
2
template <class T>
3
class Core {
4
 public:
5
  enum class State {
6
    Start,
7
    OnlyResult,        // result만 있음 (callback 없음)
8
    OnlyCallback,      // callback만 있음 (result 없음)
9
    OnlyCallbackAllowInline,
10
    Proxy,
11
    Done,              // result + callback 모두 처리
12
    Empty,
13
  };
14

15
  std::atomic<State> state_;
16
  folly::Try<T> result_;
17
  Callback callback_;
18
  Executor::KeepAlive<> executor_;
19
};

1
// folly/futures/detail/Core.cpp (개념)
2
void Core::setResult(Try<T> t) {
3
  State expected = State::Start;
4
  if (state_.compare_exchange_strong(expected, State::OnlyResult)) {
5
    result_ = std::move(t);
6
    return;   // callback이 나중에 옴
7
  }
8
  // 이미 callback이 등록됨 → 즉시 실행
9
  result_ = std::move(t);
10
  state_ = State::Done;
11
  executor_->add([cb = std::move(callback_), r = std::move(result_)]() mutable {
12
    cb(std::move(r));
13
  });
14
}

1
// SemiFuture<int>::thenValue (개념)
2
template <class F>
3
auto SemiFuture<int>::thenValue(F&& fn) && {
4
  using R = std::invoke_result_t<F, int>;
5
  auto [p, f] = folly::makePromiseContract<R>();   // 새 Promise/Future 쌍
6
  std::move(*this).setCallback_([p = std::move(p), fn = std::move(fn)](Try<int>&& t) mutable {
7
    if (t.hasException()) {
8
      p.setException(std::move(t.exception()));
9
    } else {
10
      p.setWith([&] { return fn(*std::move(t)); });
11
    }
12
  });
13
  return std::move(f);
14
}

1
folly::IOThreadPoolExecutor io(2);
2
folly::CPUThreadPoolExecutor cpu(4);
3

4
folly::SemiFuture<std::string> fetchUrl(std::string url);
5
folly::SemiFuture<Parsed> parse(std::string body);
6

7
folly::SemiFuture<Parsed> getParsed(std::string url) {
8
  return fetchUrl(std::move(url))
9
    .via(&io)              // I/O는 IO pool
10
    .thenValue([cpu = &cpu](std::string body) {
11
      return parse(std::move(body))
12
        .via(cpu);          // parse는 CPU pool
13
    });
14
}

1
// 1. SemiFuture를 그대로 .get()
2
auto v = computeSemi().get();  // executor 없음 → InlineExecutor 또는 deadlock
3

4
// 2. Future를 멤버로 보관
5
class Worker {
6
  folly::Future<int> f_;   // continuation 체인이 살아 있어야 의미 있음
7
};
8

9
// 3. 매 호출마다 새 thread pool
10
void handle() {
11
  folly::CPUThreadPoolExecutor pool(4);   // 매번 생성/파괴 — 비용 폭증
12
  compute().via(&pool).get();
13
}
14

15
// 4. exception swallow
16
compute().thenValue([](int x) { return parse(x); }).get();
17
// parse가 throw하면 get()에서 다시 throw — caller가 모를 수 있음