본문으로 건너뛰기
Folly Code Review · 63/89

folly vs std 선택 기준 분석

· Hawk · 8분 읽기

#한 줄 요약

std/abseil/folly 사이의 선택은 세 가지 변수의 함수다. 의존성 격리 부담, 워크로드 규모(N과 QPS), latency profile(p50 vs p99). 무조건 folly가 답은 아니다. 이 절에서는 결정 트리를 정리한다.

#결정 변수

  1. 의존성 비용 — Folly는 boost + gflags + double-conversion 등 transitive dep이 무겁다. 소규모 프로젝트엔 부담.
  2. 워크로드 규모 — N(컬렉션 크기, QPS) 작으면 std/abseil이 더 빠를 수 있다.
  3. latency profile — p99를 중시하면 folly의 jemalloc·SBO·lock-free가 유리. p50만 보면 차이 적음.
  4. 팀 익숙도 — Folly 도입은 std 대비 learning curve가 있다.
  5. 빌드 시간 — Folly 헤더는 무겁다(템플릿 heavy). 빌드 시간에 민감하면 std 선호.

#결정 트리

1) 외부에 공개되는 lib인가?
yes → std 우선 (의존성 최소)
no → 2)
2) production scale (QPS > 1k, 데이터 > 1MB)?
no → std 우선 (의존성 비용 > 성능 이득)
yes → 3)
3) latency p99에 민감한가?
no → std 또는 abseil
yes → 4)
4) 워크로드별 측정 결과 folly가 빠른가?
no → std/abseil 선택
yes → folly

#카테고리별 선택 가이드

#String

케이스선택
짧은 string (< 23 bytes), 일반 사용std::string
매우 큰 string (KB+), copy 많음folly::fbstring
API 경계 (read-only)std::string_view, folly::StringPiece
format 필요std::format (C++20) 또는 folly::format
substring fragment 누적absl::Cord

#Map / Set

케이스선택
N < 100, single-threadstd::unordered_map 또는 flat_map
N < 100, hot key lookupfolly::small_vector + linear scan
N >= 100, single-threadfolly::F14FastMap
reference stability 필요folly::F14NodeMap
concurrent insert/readfolly::ConcurrentHashMap
read-mostly + write 드묾folly::AtomicHashMap
simple key-value cachefolly::EvictingCacheMap

#Queue

케이스선택
single-threadstd::queue
MPMC, bounded, predictable loadfolly::MPMCQueue
MPMC, unbounded, burstfolly::UnboundedQueue
SPSC (1
)
folly::ProducerConsumerQueue
fiber 간 통신folly::fibers::Channel

#Future / Async

케이스선택
단순 std::async, 별도 chain 없음std::future
coroutine 기반C++20 coroutine + cppcoro/asio
복잡한 chain, multi-executorfolly::Future / SemiFuture
고성능 RPC frameworkfolly::coro

#Singleton

케이스선택
dependency 없음, 단순 cacheMeyers static 또는 absl::NoDestructor
dependency 있음, destruction order 중요folly::Singleton
핫패스 access, ns 단위folly::Singleton + try_get_fast

#Callable

케이스선택
기본 callable wrapperstd::function
unique_ptr capture 필요folly::Function
once-only callbackfolly::Function<Sig &&>
zero-overhead inline 필요template lambda 또는 fu2::function_view

#Exception

케이스선택
동기 throw/catch표준 std::exception
async/thread 경계folly::exception_wrapper
Expected 패턴std::expected (C++23) 또는 folly::Expected

#Optional

케이스선택
신규 코드, C++17+std::optional
fbcode 내부 신규folly::Optional (관행)
C++23 monadicstd::optional
C++20 이하 + monadicfolly::Optional

#프로젝트 규모별 가이드

#작은 프로젝트 (1-5명, < 10k LOC)

대부분 std + abseil 충분. Folly는 의존성·빌드시간 비용이 ROI 안 맞음.

추천 스택: std + 필요한 곳에 abseil.

#중간 (5-50명, 10k-500k LOC)

특정 모듈만 folly. RPC backend, async pipeline 같은 hot path에 선택적 사용.

추천 스택: std + abseil + 핫모듈에 folly subset.

#대형 (50+ 명, 500k+ LOC, production scale)

Folly 전면 도입 검토 가치. Meta급 워크로드면 throughput 차이가 cluster 비용으로 환산됨.

추천 스택: std + folly 전면 + abseil은 일부.

#throughput vs latency profile

워크로드의 프로파일에 따라 선택이 갈린다.

  • throughput-bound (배치, ML 학습, ETL) — F14, fbstring, jemalloc 통합으로 alloc 비용 절감 효과가 크다. Folly가 유리하다.
  • latency-bound (RPC handler, 실시간) — try_get_fast, lock-free queue, IOBuf zero-copy 같은 Folly의 production 디테일이 빛난다.
  • startup-bound (CLI tool, short-lived) — Folly의 무거운 init 비용이 부담이다. std + abseil이 유리하다.

#측정 워크플로

새 모듈을 시작할 때 다음 사이클을 따른다.

  1. std로 구현하고 정확성을 우선한다.
  2. 핫패스를 식별한다 (perf, profile).
  3. 핫패스에만 abseil/folly 후보를 적용한다.
  4. 벤치마크로 std vs candidate를 측정한다 (p50, p99, peak memory).
  5. 측정 결과로 선택을 확정한다.
  6. PR 설명에 이유를 명시한다.

이 사이클을 거치지 않은 mass-replace는 anti-pattern.

#Meta 외부에서의 현실

Meta 사내는 fbcode가 일관적으로 folly. 외부에선 다음 고려.

  • CI 빌드 시간 — folly 헤더는 무겁다. 빌드 시간이 두 배 이상 늘 수 있다.
  • header-only이 아님 — link 비용, ABI 호환.
  • API stability — folly는 ABI 안정 보장 적음. major bump가 잦다.
  • 문서 부족 — 일부 모듈은 source code가 유일한 문서.

이 비용을 감수할 만한 throughput·latency 이득이 있어야 한다.

#abseil의 자리

abseil은 std와 folly 사이.

  • std에 가까운 API.
  • Google production-validated.
  • 의존성 적당 (boost 안 씀).
  • 문서 좋음.

“std로 부족한데 folly는 과한” 자리에 abseil. flat_hash_map, Status, Cord, Span 등.

#코드 리뷰에서의 질문

PR에 새 folly 의존성이 추가됐을 때 묻는다.

  1. std 또는 abseil로 안 되는 이유는?
  2. 벤치마크 결과 (전/후 비교)?
  3. 의존성 증가가 빌드시간에 미치는 영향?
  4. 팀 익숙도 (다른 사람이 유지보수 가능?)
  5. fallback path는?

답이 명확하지 않으면 std로 시작 권장.

#정리

  • folly는 무조건 빠르지 않다. 컨텍스트가 맞아야 std/abseil을 이긴다.
  • 결정 변수: 의존성 비용, 워크로드 규모, latency profile, 팀 익숙도, 빌드 시간.
  • 외부 lib는 std, 핫패스만 선택적 folly, 큰 시스템은 전면 folly 검토.
  • 카테고리별 선택 표를 따른다.
  • 측정 없는 도입은 anti-pattern.
  • abseil은 “std 부족, folly 과함” 자리에 자주 답.

#시리즈를 마치며

이 시리즈는 Folly의 핵심 모듈을 통해 production-scale C++ 라이브러리의 설계 결정을 살펴봤다. 단순한 API 사용법보다 왜 이런 형태인가에 무게를 뒀다.

같은 시각으로 abseil, boost, range-v3 같은 다른 라이브러리도 읽어 보면, 각 팀이 어떤 워크로드를 가정하고 trade-off를 했는지 보인다. 라이브러리의 “왜”를 읽는 능력은 자기 코드의 trade-off를 더 명확히 만든다.

#다음 추천 시리즈

  • Effective Modern C++ — Folly가 활용한 C++ 기능들의 토대.
  • Performance Engineering — Folly가 푸는 문제(throughput, latency)의 일반 원리.
  • Abseil deep dive (예정) — Google 측 대응 라이브러리.

#관련 항목

Folly Code Review · 64 of 89

  1. 1 Folly Code Review — Meta의 production-grade C++ 라이브러리 코드 분석
  2. 2 Folly 개요 — Meta가 production에서 검증한 utility 모음 분석
  3. 3 Folly vs Abseil 철학 비교 — performance-first vs std-compatible
  4. 4 Folly 빌드와 fbcode 환경 — monorepo의 그림자
  5. 5 Folly API stability 정책 — 어떤 보장도 없다는 솔직함
  6. 6 Folly production validation 문화 — peta-scale에서 단련된 코드
  7. 7 folly::Future 분석 — std::future의 한계를 넘는 composable async
  8. 8 folly::Promise·makeFuture — Future를 만드는 두 길
  9. 9 folly::SemiFuture vs Future — executor binding의 명시화
  10. 10 folly::Future thenValue·thenError·thenTry — continuation 체인 분석
  11. 11 folly::collect·collectAll·collectAny — fan-in 패턴 분석
  12. 12 folly::Future retry·window·via — 제어 흐름 조합자
  13. 13 folly::fibers 분석 — M:N stackful coroutine
  14. 14 folly::InlineExecutor — 호출자 thread에서 즉시 실행
  15. 15 folly::CPUThreadPoolExecutor — CPU-bound 작업의 표준 thread pool
  16. 16 folly::IOThreadPoolExecutor — libevent 기반 I/O pool
  17. 17 folly::ManualExecutor — 결정적 테스트를 위한 수동 진행
  18. 18 folly::EventBase 분석 — libevent 이벤트 루프의 핵심
  19. 19 folly::IOBuf 분석 — zero-copy buffer chain의 기본 단위
  20. 20 folly::IOBufQueue — chain의 push/pull 추상화
  21. 21 folly::io::Cursor·RWCursor — chain 위의 stream
  22. 22 folly Zero-copy 패턴 — IOBuf로 ScatterGather I/O 표현
  23. 23 folly::IOBuf shared semantics — clone·unshare·takeOwnership
  24. 24 folly::FBString 분석 — SSO + COW 구현
  25. 25 folly의 fmt::format 통합 — 모던 포맷팅 채택
  26. 26 folly::StringPiece — string_view 호환 분석
  27. 27 folly Join·Split utilities — 문자열 분해와 결합
  28. 28 folly::to·tryTo — text↔num 변환 분석
  29. 29 folly Conv Customization — 사용자 타입 지원
  30. 30 folly Conv 성능 비교 — sprintf·stringstream 대비
  31. 31 folly::F14ValueMap vs std::unordered_map
  32. 32 folly::F14NodeMap — stable pointer가 필요할 때
  33. 33 folly::F14VectorMap — cache-friendly iteration
  34. 34 folly::F14FastMap — auto-select 동작
  35. 35 folly F14 internals — SIMD probing 메커니즘
  36. 36 folly::small_vector — inline storage 분석
  37. 37 folly::FixedString — compile-time string
  38. 38 folly::AtomicHashMap — lock-free read 분석
  39. 39 folly::ConcurrentHashMap — sharded 동시 해시 맵
  40. 40 folly::EvictingCacheMap — LRU 구현 분석
  41. 41 folly::Synchronized — lock wrapper 패턴
  42. 42 folly::SharedMutex 분석
  43. 43 folly::Baton — one-shot wait 동기화
  44. 44 folly::RWSpinLock 분석
  45. 45 folly::PicoSpinLock — 1-byte spinlock
  46. 46 folly::ProducerConsumerQueue — SPSC 큐 분석
  47. 47 folly::MPMCQueue — multi-producer multi-consumer
  48. 48 folly::UnboundedQueue — 동적 크기 lock-free
  49. 49 folly::fibers::Channel — Go-like channel
  50. 50 folly::dynamic — JSON-like dynamic type 분석
  51. 51 folly JSON conversion — toJson·parseJson
  52. 52 folly dynamic ↔ struct — manual marshaling
  53. 53 folly dynamic Visitor pattern — type별 분기
  54. 54 folly::Singleton vs Meyers/static — 왜 Folly의 Singleton인가
  55. 55 folly::SingletonVault 분석 — 등록·소멸·의존성
  56. 56 folly::Singleton try_get·try_get_fast — TLS-cached 접근
  57. 57 folly::ExceptionWrapper — type-erased exception holder
  58. 58 folly::ScopeGuard·SCOPE_EXIT — RAII cleanup
  59. 59 folly::Optional vs std::optional
  60. 60 folly::Function vs std::function
  61. 61 folly::Lazy — 지연 초기화 wrapper
  62. 62 folly Meta 스타일 code review 패턴
  63. 63 folly anti-patterns — 잘못 쓰면 std보다 느림
  64. 64 folly vs std 선택 기준 분석
  65. 65 folly::coro 개요 — production C++20 코루틴 어댑터
  66. 66 folly::coro::Task — lazy single-shot 코루틴
  67. 67 folly::coro::AsyncGenerator — 비동기 스트림
  68. 68 folly coro blockingWait·collectAll — 동기 경계와 fan-in
  69. 69 folly::coro::Baton·Mutex — 코루틴-aware 동기화
  70. 70 folly::Expected — 결과 또는 오류
  71. 71 folly::Try — Future 결과 wrapper
  72. 72 folly::Try vs Expected 선택 기준
  73. 73 folly::Range — 일반 iterator pair
  74. 74 folly::Uri — URL 파서
  75. 75 folly Fingerprint64·128 — 분산 hash
  76. 76 folly SpookyHashV2 — fast non-crypto hash
  77. 77 folly::Init — main() 부트스트랩
  78. 78 folly::Indestructible — global lifetime 패턴
  79. 79 folly::MicroLock — 1-byte 락
  80. 80 folly::MicroSpinLock — 가장 좁은 spin lock
  81. 81 folly::format — legacy formatter 분석
  82. 82 folly::demangle — typeid 디망글링
  83. 83 folly::DynamicConverter — dynamic ↔ struct
  84. 84 folly::RecordIO — append-only 로그 파일 포맷
  85. 85 folly::io::Compression — zstd·lz4·snappy wrapper
  86. 86 folly::AsyncIO — io_uring·Linux AIO
  87. 87 folly::CancellationToken — 코루틴·Future 취소 전파
  88. 88 folly::observer — hot config의 atomic refresh
  89. 89 fbcode 패턴 모음 — folly 사용의 실전