fbcode 패턴 모음 — folly 사용의 실전

한 줄 요약: 21 parts 88 chapters를 통과한 folly 시리즈의 마지막. fbcode 코드 리뷰에서 반복적으로 등장하는 folly 사용 패턴을 한 자리에 정리한다.

#시리즈 마무리

이 시리즈는 folly를 다음 14 파트로 시작해 7 파트를 추가했다.

1. Part 1: 개요 / 철학 / build
2. Part 2: Future / Promise
3. Part 3: Executors
4. Part 4: IOBuf / Cursor
5. Part 5: String 계열
6. Part 6: Conv
7. Part 7: F14 hash maps
8. Part 8: 컨테이너
9. Part 9: 동기화 primitive
10. Part 10: Queue
11. Part 11: dynamic / JSON
12. Part 12: Singleton
13. Part 13: Utility
14. Part 14: 코드 리뷰 가이드
15. Part 15: coro
16. Part 16: Expected / Try
17. Part 17: Range / Uri / Hash
18. Part 18: Init / Indestructible / MicroLock
19. Part 19: Format / Demangle / DynamicConverter
20. Part 20: RecordIO / Compression / AsyncIO / Cancellation
21. Part 21: Observer / 패턴 모음

여기서는 시리즈 내내 반복된 생산 코드의 folly 패턴을 챕터 횡단으로 묶는다.

#패턴 1 — 함수 인자는 view, 반환은 owning

1
// Good
2
void Process(folly::StringPiece s);
3
folly::fbstring Build();
4

5
std::unique_ptr<folly::IOBuf> Encode(folly::ByteRange data);
6

7
// Bad
8
void Process(const std::string& s);   // 호출자가 std::string 강요
9
fbstring* Build();                     // ownership 모호

StringPiece / ByteRange / Range<Iter>로 받아 임의 view를 허용. 반환은 ownership이 명확한 type.

#패턴 2 — Future 체인 vs 코루틴

1
// Future style (legacy)
2
folly::SemiFuture<Result> Process(Input x) {
3
  return Step1(x)
4
    .via(executor)
5
    .thenValue([](S1 s1) { return Step2(s1); })
6
    .thenValue([](S2 s2) { return Step3(s2); });
7
}
8

9
// Coroutine style (preferred for new code)
10
folly::coro::Task<Result> Process(Input x) {
11
  auto s1 = co_await Step1(x);
12
  auto s2 = co_await Step2(s1);
13
  co_return co_await Step3(s2);
14
}

새 코드는 코루틴. 두 모델이 양방향 변환 가능해 점진적 마이그레이션.

#패턴 3 — Synchronized 우선, raw mutex는 예외

1
// Good
2
folly::Synchronized<std::vector<Item>> items_;
3

4
void Add(Item x) {
5
  items_.wlock()->push_back(std::move(x));
6
}
7

8
size_t Size() const {
9
  return items_.rlock()->size();
10
}
11

12
// Bad
13
std::mutex             mu_;
14
std::vector<Item>      items_;
15
// data와 mutex가 분리 — lock 누락 risk

Synchronized<T>로 데이터와 lock을 한 객체에. lock 없이 접근하는 코드 경로가 컴파일러로 막힘.

#패턴 4 — F14는 기본 hash map

1
folly::F14FastMap<std::string, int> m;          // value-stable, fast
2
folly::F14NodeMap<Key, BigValue> nm;            // pointer-stable
3
folly::F14ValueMap<Key, SmallValue> vm;         // value-inline (smaller)
4
folly::F14VectorMap<Key, Value> ordered;        // iteration order = insertion

std::unordered_map 대신 F14가 기본. variant 선택은 value 크기와 pointer stability.

#패턴 5 — Indestructible로 global

1
Foo& GetFoo() {
2
  static folly::Indestructible<Foo> instance;
3
  return *instance;
4
}

Meyers singleton의 static deinit order 위험을 회피.

#패턴 6 — Init은 main() 첫 줄

1
int main(int argc, char* argv[]) {
2
  folly::Init init(&argc, &argv);
3
  RunServer();
4
}

gflags, glog, signal handler 일괄 init. fbcode 거의 모든 binary 표준.

#패턴 7 — JSON은 dynamic + parseJson

1
auto d = folly::parseJson(text);
2
auto cfg = folly::convertTo<Config>(d);   // DynamicConverter
3
// 또는
4
auto host = d["host"].asString();

dynamic이 type-erased, struct로 변환은 traits 한 번.

#패턴 8 — to 한 줄 변환

1
auto n = folly::to<int>("42");
2
auto s = folly::to<std::string>(42);
3
auto fp = folly::to<double>(s);

std::to_string / std::stoi의 통합. 잘못된 입력에 throw, tryTo<T>는 Expected.

#패턴 9 — Cancellation을 처음부터

1
folly::coro::Task<Result> Compute(folly::CancellationToken ct) {
2
  // 매 step마다 check
3
  if (ct.isCancellationRequested()) throw folly::OperationCancelled{};
4
  // ...
5
}

긴 작업은 처음부터 cancel-aware. 나중에 추가하기 어렵다.

#패턴 10 — Observer로 hot config

1
class Service {
2
  folly::observer::Observer<Config> cfg_;
3
 public:
4
  void Handle() {
5
    auto snap = cfg_.getSnapshot();
6
    if (snap->featureEnabled) { ... }
7
  }
8
};

read-heavy 값은 observer. lock-free atomic load.

#패턴 11 — Try/thenTry로 예외 처리

1
compute()
2
  .thenTry([](folly::Try<int>&& t) {
3
    if (t.hasException()) return -1;
4
    return *t * 2;
5
  });
6

7
// 코루틴
8
auto t = co_await folly::coro::co_awaitTry(MaybeFails());
9
if (t.hasException()) { /* ... */ }

throw가 normal control flow면 Try로 받아 비용 절감.

#패턴 12 — StringPiece는 함수 경계 표준

1
void Parse(folly::StringPiece s);   // std::string, const char*, std::string_view 모두 받음

API boundary의 받는 자리가 항상 view.

#패턴 13 — IOBuf chain은 직접 만들지 말 것

1
folly::IOBufQueue q{folly::IOBufQueue::cacheChainLength()};
2
q.append(buf1);
3
q.append(buf2);
4
auto out = q.move();

수동 next chain 연결은 깨지기 쉽다. IOBufQueue가 표준.

#패턴 14 — fbstring은 boundary에서 변환

1
folly::fbstring fs = Build();
2
std::string sd = fs.toStdString();   // boundary 한 번
3

4
// 또는 처음부터 std::string 사용
5
std::string Build();

fbcode 내부는 fbstring, 외부 API와의 경계만 std::string으로 변환.

#패턴 15 — Conv는 ASCII fast path 활용

1
auto n = folly::to<int>("12345");   // SIMD-friendly fast path

큰 batch parsing에 stl 보다 결정적으로 빠름.

#코드 리뷰 빈도 높은 지적

다음은 fbcode PR review에서 가장 자주 받는 코멘트 모음.

1. “std::string&로 받지 말고 folly::StringPiece 또는 std::string_view로.”
2. “raw std::mutex + 데이터 대신 folly::Synchronized<T>.”
3. “std::unordered_map은 folly::F14FastMap으로 — 성능 4-5x.”
4. “std::shared_ptr을 매 호출 복사하지 말고 folly::observer 모델.”
5. “Future::then은 deprecated. thenValue + thenError 또는 코루틴.”
6. “새 코드는 코루틴 folly::coro::Task로 — Future chain은 legacy.”
7. “global mutex는 folly::Indestructible로 wrap — deinit order fiasco 회피.”
8. “hot path에 folly::format 대신 fmt::format 또는 std::format.”
9. “std::async로 disk I/O 던지지 말고 folly::AsyncIO (io_uring).”
10. “OperationCancelled 잡고 silent return하지 말 것 — propagate.”

#일반 가이드 — folly를 적게 쓰기

표준이 따라잡은 자리는 표준이 옳다.

• folly::Optional → std::optional
• folly::Function → std::move_only_function (C++23) 또는 std::function
• folly::StringPiece → std::string_view (대부분 자리)
• folly::format → std::format (C++20+)

folly가 우위인 자리만 folly:

• 코루틴 (folly::coro)
• F14 hash map
• Synchronized
• IOBuf
• 동시성 자료구조 (MPMCQueue, ConcurrentHashMap)
• Future chain (legacy migration)
• AsyncIO / io_uring wrapper

#시리즈를 마치며

folly는 프로덕션 C++의 잃어버린 절반이다. 표준이 채우지 못한 자리에서 Meta가 10년 넘게 쌓아온 추상. 이 시리즈를 통과한 독자는 다음을 얻었기를 바란다.

• 각 folly 구성요소의 왜 존재하는가.
• 표준/abseil과의 trade-off.
• 코드 리뷰에서 무엇을 살펴봐야 하는가.
• 안티패턴과 그 회피.

새 코드는 가능하면 표준, 표준이 부족한 자리는 folly. 그 경계 인식이 이 시리즈의 가장 큰 가치다.

#관련 항목

• Folly 시리즈 시작 — 00-preface
• Folly Part 1-01 — 개요
• Folly Part 14-01 — Meta 스타일 코드 리뷰
• Folly Part 14-02 — 안티패턴
• Folly Part 14-03 — std vs folly 선택
• 원문 — folly GitHub
• Meta Engineering blog