Folly vs Abseil 철학 비교 — performance-first vs std-compatible

1
// Abseil — 예외 사용 안 함
2
absl::StatusOr<User> GetUser(int id) {
3
  if (id < 0) return absl::InvalidArgumentError("id<0");
4
  return User{id};
5
}
6

7
// Folly — 예외 적극 활용
8
folly::Future<User> getUserAsync(int id) {
9
  if (id < 0) throw std::invalid_argument("id<0");
10
  return folly::makeFuture(User{id});
11
}

1
// Abseil — 동일 빌드 unit 내 보장
2
// 모든 binary가 같은 Abseil version으로 컴파일되어야 함
3

4
// Folly — 어떤 ABI 보장도 없음
5
// commit 단위로 layout이 바뀔 수 있음
6
// 정적 링크 강제 권장

1
// Abseil — async 없음
2
// std::future, std::async, std::thread 사용
3

4
// Folly — 풍부한 async 도구
5
folly::SemiFuture<int> compute();
6
folly::CPUThreadPoolExecutor pool(8);
7
compute().via(&pool).thenValue([](int x) { ... });
8

9
// Fiber: M:N stackful coroutine
10
folly::fibers::FiberManager fm(...);
11
fm.addTask([] { /* baton.wait() OK */ });

1
// Abseil — Swiss table 기반 hashmap
2
absl::flat_hash_map<K, V>      // value-stable 아님
3
absl::node_hash_map<K, V>      // pointer-stable
4
absl::btree_map<K, V>          // ordered
5

6
// Folly — F14 (Facebook 14-way) hashmap
7
folly::F14ValueMap<K, V>       // value 직접 저장
8
folly::F14NodeMap<K, V>        // pointer-stable
9
folly::F14VectorMap<K, V>      // iteration locality 최적
10
folly::F14FastMap<K, V>        // size 기반 자동 선택

1
// Abseil 스타일
2
absl::StatusOr<Config> LoadConfig(absl::string_view path) {
3
  auto file = std::ifstream(std::string(path));
4
  if (!file) {
5
    return absl::NotFoundError(absl::StrCat("missing: ", path));
6
  }
7
  // ...
8
  return Config{};
9
}
10

11
absl::Status Run() {
12
  ASSIGN_OR_RETURN(auto cfg, LoadConfig("a.cfg"));
13
  return absl::OkStatus();
14
}

1
// Folly 스타일 (예외)
2
folly::Future<Config> loadConfigAsync(folly::StringPiece path) {
3
  return folly::via(&io_executor_, [path = path.str()] {
4
    std::ifstream file(path);
5
    if (!file) throw std::runtime_error(folly::sformat("missing: {}", path));
6
    return Config{};
7
  });
8
}
9

10
// 또는 Try<T>
11
folly::Try<Config> loadConfig(folly::StringPiece path) {
12
  std::ifstream file(path.str());
13
  if (!file) return folly::Try<Config>(folly::make_exception_wrapper<std::runtime_error>("missing"));
14
  return folly::Try<Config>(Config{});
15
}

1
// Abseil
2
std::string s = absl::StrCat("user=", name, " id=", id);
3
auto parts = absl::StrSplit(line, ',');
4
std::string joined = absl::StrJoin(parts, "|");
5

6
// Folly
7
std::string s = folly::sformat("user={} id={}", name, id);
8
std::vector<folly::StringPiece> parts;
9
folly::split(',', line, parts);
10
std::string joined = folly::join("|", parts);

1
// 1. 두 라이브러리에서 같은 기능을 둘 다 import
2
#include <folly/Optional.h>
3
#include "absl/types/optional.h"
4
// folly::Optional<absl::optional<int>>  ← 의미 없음
5

6
// 2. Abseil exception을 Folly Future로 잘못 전파
7
absl::Status s = ...;
8
folly::makeFuture(s);  // Status는 throw되지 않음 — Future 체인이 error로 안 흐름
9

10
// 3. F14에 value-stable iterator 가정
11
folly::F14ValueMap<K, V> m;
12
auto& v = m[k];
13
m.insert(...);   // rehash 가능 — v dangling