Folly Code Review · 12/89

folly::fibers 분석 — M:N stackful coroutine

2026년 6월 4일 · Hawk · 4분 읽기

한 줄 요약: folly::fibers는 boost.context 기반 stackful coroutine으로 동기적으로 보이는 코드를 비동기 실행한다. C++20 coroutine보다 코드 변환이 가볍지만 stack 메모리를 쓴다.

#동기 — stackful coroutine이 필요한 이유

folly::Future 체인은 강력하지만 코드 모양이 비동기적이다.

1
folly::SemiFuture<Result> process(int id) {
2
  return fetchUser(id)
3
    .deferValue([](User u) { return fetchOrders(u); })
4
    .deferValue([](std::vector<Order> orders) { return summarize(orders); });
5
}

같은 로직을 동기 스타일로 쓰고 싶다.

1
Result process(int id) {
2
  User u = fetchUserSync(id);
3
  auto orders = fetchOrdersSync(u);
4
  return summarize(orders);
5
}

C++20 coroutine은 이를 위해 co_await을 도입했다. Folly fibers는 그 이전부터 같은 일을 한다. boost.context의 make_fcontext/jump_fcontext로 진짜 stack을 만들어 그 위에서 동기 코드를 돌린다. blocking call에서 fiber를 yield하고 다른 fiber로 jump한다.

#핵심 API

1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/EventBaseLoopController.h>
3
#include <folly/io/async/EventBase.h>
4

5
folly::EventBase evb;
6
folly::fibers::FiberManager& fm =
7
    folly::fibers::getFiberManager(evb);
8

9
fm.addTask([] {
10
  // 이 lambda는 fiber stack에서 실행됨
11
  Result r = doSyncWork();   // blocking call OK
12
  saveResult(r);
13
});
14

15
evb.loop();   // FiberManager 가 EventBase에 schedule됨

fm.addTask(fn)은 fn을 새 fiber stack에서 실행한다. fiber 안의 코드는 baton.wait(), await(future), channel read 등에서 yield할 수 있다.

#await — Future를 fiber 안에서 동기적으로

1
fm.addTask([] {
2
  folly::SemiFuture<int> sf = computeAsync();
3
  int v = folly::fibers::await([&](folly::Promise<int> p) {
4
    std::move(sf).via(...).thenValue([p = std::move(p)](int x) mutable {
5
      p.setValue(x);
6
    });
7
  });
8
  // v를 동기 코드처럼 사용
9
});

좀 더 간단한 변형도 있다.

1
int v = folly::fibers::await(computeAsyncFuture());   // SemiFuture 직접

await은 현재 fiber를 yield시키고 Promise를 caller가 채워줄 때 돌아온다. 다른 fiber는 그 사이 계속 돈다.

#Baton — fiber-aware 동기화

1
folly::fibers::Baton baton;
2

3
fm.addTask([&] {
4
  std::cout << "wait\n";
5
  baton.wait();   // fiber yield
6
  std::cout << "done\n";
7
});
8

9
// 다른 fiber 또는 다른 thread에서
10
baton.post();   // wait중인 fiber를 깨움

std::condition_variable과 비슷하지만 thread를 block하지 않고 fiber만 block한다. 같은 thread의 다른 fiber는 계속 진행된다.

#Channel — fiber 간 메시지 통신

1
folly::fibers::Channel<int, 10> ch;   // buffered, capacity 10
2

3
fm.addTask([&] {
4
  for (int i = 0; i < 100; ++i) {
5
    ch.send(i);   // 가득 차면 fiber yield
6
  }
7
  ch.close();
8
});
9

10
fm.addTask([&] {
11
  while (auto v = ch.receive()) {   // 비어 있으면 fiber yield
12
    process(*v);
13
  }
14
});

Go의 channel과 비슷하다. producer/consumer를 fiber 단위로 분리한다.

#내부 — stackful의 구현

Fiber cooperative swap

1
// folly/fibers/Fiber.h (요약)
2
class Fiber {
3
  void* stack_;           // mmap된 stack
4
  size_t stackSize_;
5
  boost::context::fcontext_t ctx_;   // saved context (rsp, rbp, ...)
6
  std::function<void()> func_;
7
  // ...
8
};
9

10
// 전환 시
11
void switchToFiber(Fiber* f) {
12
  boost::context::jump_fcontext(&main_ctx_, f->ctx_, 0);
13
  // jump 후 함수가 yield하면 여기로 돌아옴
14
}

boost::context::jump_fcontext는 register 저장/복구를 어셈블리로 수행한다. context switch는 100ns 정도로 OS thread switch(~1μs)보다 한 자릿수 빠르다.

stack은 기본 64KB(설정 가능)다. 1만 개 fiber면 640MB. M

모델이지만 stack memory가 thread보다 절약되는 정도지 무한은 아니다.

#C++20 coroutine과의 비교

C++20 coroutine은 stackless다. compiler가 함수의 local을 heap-allocated frame에 변환한다.

항목	folly::fibers (stackful)	C++20 coroutine (stackless)
stack	진짜 stack (mmap)	heap-allocated frame
memory	fiber당 64KB+	함수당 변수 합
변환	없음 (그냥 함수)	compiler 변환 (`co_await`)
호출 깊이	일반 함수처럼 무제한	coroutine은 stackless라 nested 어려움
디버깅	stack trace 정상	frame이 흩어져 어려움
표준	비표준	표준 (C++20)

C++20 coroutine은 함수당 heap allocation을 한 번 한다. 메모리는 fiber보다 적게 쓰지만 컴파일러 마법이 들어간다. fiber는 메모리가 더 들지만 코드는 그대로다.

#적합한 사용 사례

Fiber 권장:

Legacy 동기 코드를 그대로 비동기 실행하고 싶을 때
nested function call이 깊을 때 (RPC -> validate -> log -> db …)
디버깅 가능한 stack trace가 필요할 때

C++20 coroutine 권장:

새 코드, 메모리 효율이 중요할 때
표준 사용 가능한 환경
folly::coro::Task<T>로 통합 가능

Folly는 두 모델을 모두 지원한다. folly/experimental/coro/에 C++20 coroutine 통합이 있다.

#EventBase와의 통합

1
folly::EventBase evb;
2
folly::fibers::FiberManager::Options opts;
3
opts.stackSize = 64 * 1024;
4
auto& fm = folly::fibers::getFiberManager(evb, opts);
5

6
fm.addTask([&] {
7
  // I/O는 EventBase에 schedule되고
8
  // 그 결과를 await으로 동기 스타일로 받음
9
  auto result = folly::fibers::await(asyncFetch());
10
  process(result);
11
});
12

13
evb.loopForever();

FiberManager는 EventBase에 schedule된 task다. EventBase loop이 돌 때마다 ready fiber를 실행한다.

#코드 리뷰 포인트

fiber stack size가 적정한가? 기본 64KB. 깊은 호출이면 늘리고, 많이 띄우면 줄인다.
fiber 안에서 thread blocking 호출을 하지 않는가? std::this_thread::sleep_for는 fiber만이 아니라 전체 thread를 block한다. folly::fibers::sleep_for 사용.
shared state에 동시 접근 시 lock이 있는가? 같은 thread의 다른 fiber라도 yield 지점에서 race가 생긴다.
C++20 coroutine과 혼용하는가? 가능하지만 진입점이 헷갈린다. 모듈 단위로 통일한다.

#자주 보는 안티패턴

1
// 1. fiber 안에서 thread block
2
fm.addTask([] {
3
  std::this_thread::sleep_for(std::chrono::seconds(1));   // 잘못
4
  // 같은 thread의 모든 fiber가 멈춤
5
});
6

7
// 옳음:
8
fm.addTask([] {
9
  folly::fibers::Baton b;
10
  b.try_wait_for(std::chrono::seconds(1));   // fiber만 yield
11
});
12

13
// 2. 너무 큰 stack
14
opts.stackSize = 16 * 1024 * 1024;   // 16MB
15
fm.addTask(...);   // 1만 개면 160GB
16

17
// 3. fiber 외부에서 await
18
folly::fibers::await(sf);   // fiber 안에서만 호출 가능 — assert 위반
19

20
// 4. shared mutable state without lock
21
int counter = 0;
22
fm.addTask([&] { ... counter++; ... });   // yield 지점에서 race