folly Meta 스타일 code review 패턴

1
BENCHMARK(fbstringCopy, iters) {
2
  folly::fbstring s("benchmark string");
3
  for (size_t i = 0; i < iters; ++i) {
4
    folly::fbstring copy = s;
5
    folly::doNotOptimizeAway(copy);
6
  }
7
}
8

9
BENCHMARK(stdstringCopy, iters) {
10
  std::string s("benchmark string");
11
  for (size_t i = 0; i < iters; ++i) {
12
    std::string copy = s;
13
    folly::doNotOptimizeAway(copy);
14
  }
15
}
16

17
// 결과 예시:
18
// fbstringCopy   100000000   12.3 ns
19
// stdstringCopy  100000000   45.6 ns  → fbstring 3.7x 빠름

1
// 회피 — 매 push가 realloc 가능
2
std::string upper(const std::string& s) {
3
  std::string r;
4
  for (char c : s) r += std::toupper(c);
5
  return r;
6
}
7

8
// Good — 미리 할당
9
std::string upper(const std::string& s) {
10
  std::string r;
11
  r.reserve(s.size());
12
  for (char c : s) r += std::toupper(c);
13
  return r;
14
}
15

16
// Better — in-place
17
void upperInPlace(std::string& s) {
18
  for (char& c : s) c = std::toupper(c);
19
}

1
// 회피 — 흩어진 메모리
2
struct Node { Node* next; Node* prev; int data; };
3
std::list<Node> items;
4

5
// Good — 연속 메모리
6
std::vector<int> items;
7

8
// Folly 스타일
9
folly::fbvector<int> items; // jemalloc 통합

1
/**
2
 * Thread Safety:
3
 *   - All methods are thread-safe.
4
 *   - Multiple threads may call increment() concurrently.
5
 *
6
 * Memory Ordering:
7
 *   - Uses std::memory_order_relaxed for performance.
8
 *   - No happens-before relationship between operations.
9
 */
10
class Counter {
11
 public:
12
  void increment() noexcept { count_.fetch_add(1, std::memory_order_relaxed); }
13
  int64_t get() const noexcept { return count_.load(std::memory_order_relaxed); }
14
 private:
15
  std::atomic<int64_t> count_{0};
16
};

1
// 회피 — 데이터 레이스
2
class Cache {
3
 public:
4
  void set(string k, int v) { data_[k] = v; }   // unsynchronized
5
  int get(string k) { return data_[k]; }
6
 private:
7
  std::unordered_map<string, int> data_;
8
};
9

10
// Good — 명시 동기화
11
class Cache {
12
 public:
13
  void set(string k, int v) {
14
    std::lock_guard l(m_);
15
    data_[k] = v;
16
  }
17
  std::optional<int> get(string k) {
18
    std::lock_guard l(m_);
19
    auto it = data_.find(k);
20
    return it != data_.end() ? std::optional(it->second) : std::nullopt;
21
  }
22
 private:
23
  std::mutex m_;
24
  std::unordered_map<string, int> data_;
25
};
26

27
// Better — lock-free
28
class Cache {
29
 public:
30
  void set(string k, int v) { data_.insert_or_assign(k, v); }
31
  std::optional<int> get(string k) {
32
    auto it = data_.find(k);
33
    return it != data_.end() ? std::optional(it->second) : std::nullopt;
34
  }
35
 private:
36
  folly::ConcurrentHashMap<string, int> data_;
37
};

1
// Good — 검증 먼저, 그 다음 commit
2
void transfer(Account& to, int amount) {
3
  if (amount > balance_) throw std::runtime_error("insufficient");
4

5
  balance_ -= amount;
6
  try {
7
    to.balance_ += amount;
8
  } catch (...) {
9
    balance_ += amount; // rollback
10
    throw;
11
  }
12
}
13

14
// Better — copy-and-commit
15
void transfer(Account& to, int amount) {
16
  int new_balance = balance_ - amount;
17
  int new_to     = to.balance_ + amount;
18
  if (new_balance < 0) throw std::runtime_error("insufficient");
19

20
  // 검증 끝, 이제 noexcept commit
21
  balance_      = new_balance;
22
  to.balance_   = new_to;
23
}

1
class Resource {
2
 public:
3
  // move는 noexcept이어야 STL container가 최적화
4
  Resource(Resource&& o) noexcept : data_(std::exchange(o.data_, nullptr)) {}
5
  Resource& operator=(Resource&& o) noexcept {
6
    delete data_;
7
    data_ = std::exchange(o.data_, nullptr);
8
    return *this;
9
  }
10
  // 소멸자는 항상 noexcept
11
  ~Resource() noexcept { delete data_; }
12
 private:
13
  int* data_ = nullptr;
14
};

1
// Good — STL 호환
2
class Container {
3
 public:
4
  size_t size() const;
5
  bool empty() const;
6
  void clear();
7
  void reserve(size_t);
8
};
9

10
// 회피 — Java-style 혼재
11
class Container {
12
 public:
13
  size_t getSize() const;
14
  bool isEmpty() const;
15
  void Clear();
16
};

1
template <typename T>
2
class Optional {
3
 public:
4
  template <typename F>
5
  auto map(F&& f) const -> Optional<decltype(f(std::declval<T>()))> {
6
    if (hasValue_) return Optional(f(value_));
7
    return Optional();
8
  }
9
};
10

11
// 사용: inline되어 런타임 오버헤드 없음
12
auto y = maybeInt.map([](int x){ return x * 2; });

1
TEST(StringPerf, CopyPerformance) {
2
  folly::BenchmarkSuspender s;
3
  folly::fbstring str(1000, 'x');
4
  s.dismiss();
5

6
  auto start = std::chrono::high_resolution_clock::now();
7
  for (int i = 0; i < 100000; ++i) {
8
    folly::fbstring copy = str;
9
    folly::doNotOptimizeAway(copy);
10
  }
11
  auto end = std::chrono::high_resolution_clock::now();
12
  auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() / 100000;
13
  EXPECT_LT(ns, 50); // 회귀 가드
14
}

1
TEST(ConcurrentHashMapTest, ConcurrentAccess) {
2
  folly::ConcurrentHashMap<int, int> map;
3
  std::atomic<int> errors{0};
4

5
  std::vector<std::thread> ts;
6
  for (int i = 0; i < 10; ++i) {
7
    ts.emplace_back([&, i]{
8
      for (int j = 0; j < 10000; ++j) {
9
        int k = i * 10000 + j;
10
        map.insert(k, j);
11
        auto it = map.find(k);
12
        if (it == map.end() || it->second != j) ++errors;
13
      }
14
    });
15
  }
16
  for (auto& t : ts) t.join();
17
  EXPECT_EQ(0, errors.load());
18
}

1
## Summary
2
변경 내용
3

4
## Motivation
5
왜 필요한가
6

7
## Performance
8
### Benchmarks
9
Before:
10
  op X: 100ns (p50), 150ns (p99)
11
After:
12
  op X: 50ns (p50), 80ns (p99)
13
  Improvement: 2x p50, 1.9x p99
14

15
### Memory
16
peak heap 변화
17

18
## Thread Safety
19
분석
20

21
## Test Plan
22
- [ ] unit
23
- [ ] benchmark
24
- [ ] stress
25
- [ ] ASAN/TSAN clean

1
// Expected — 예상 가능한 실패
2
folly::Expected<User, Error> findUser(int id) {
3
  if (!exists(id)) return folly::makeUnexpected(Error::NotFound);
4
  return users_[id];
5
}
6

7
// 예외 — 프로그래머 오류 또는 복구 불가
8
void processUser(User* u) {
9
  if (!u) throw std::invalid_argument("null");
10
}

1
// 회피 — 콜백 지옥
2
getUser(id).thenValue([](User u) {
3
  return getOrders(u.id).thenValue([u](Orders o) {
4
    return getPayments(o.id).thenValue([u,o](Payments p) {
5
      return process(u, o, p);
6
    });
7
  });
8
});
9

10
// Good — collectAll
11
folly::collectAll(getUser(id), getOrders(orderId), getPayments(pid))
12
  .thenValue([](auto t) {
13
    auto [u, o, p] = t;
14
    return process(u, o, p);
15
  });

1
// 1. 예외 사용 OK
2
try { risky(); } catch (const std::exception& e) { handle(e); }
3

4
// 2. 매크로 사용 (FOLLY_*)
5
FOLLY_ALWAYS_INLINE void hotPath() {}
6

7
// 3. pImpl로 ABI 안정
8
class Impl;
9

10
// 4. 헤더 구조
11
// folly/Feature.h — 공개 API
12
// folly/detail/FeatureDetail.h — 구현 상세