folly::Lazy — 지연 초기화 wrapper

1
// 회피 — 무거운 객체를 매번 생성
2
class Handler {
3
  ExpensiveCache cache_{loadFromDisk()}; // ctor에서 디스크 I/O
4
  Handler() {} // 인스턴스 생성마다 cache 만들어짐
5
};

1
class Handler {
2
  mutable std::optional<ExpensiveCache> cache_;
3
  mutable std::once_flag flag_;
4

5
  const ExpensiveCache& cache() const {
6
    std::call_once(flag_, [&]{ cache_.emplace(loadFromDisk()); });
7
    return *cache_;
8
  }
9
};

1
#include <folly/Lazy.h>
2

3
class Handler {
4
  folly::Lazy<ExpensiveCache> cache_ = folly::lazy([]{ return loadFromDisk(); });
5

6
  void serve() {
7
    auto& c = *cache_; // 첫 접근 시 lambda 실행
8
    c.lookup(...);
9
  }
10
};

1
template <typename Func>
2
class Lazy {
3
  using T = std::invoke_result_t<Func>;
4

5
  mutable std::optional<T> value_;
6
  mutable std::once_flag flag_;
7
  Func creator_;
8

9
public:
10
  T& operator*() const {
11
    std::call_once(flag_, [&]{ value_.emplace(creator_()); });
12
    return *value_;
13
  }
14
  T* operator->() const { return &**this; }
15
};

1
// 회피 — 매번 compile (느림)
2
bool match(string s) {
3
  std::regex re("complex pattern"); // compile 비용
4
  return std::regex_search(s, re);
5
}
6

7
// Good — 첫 호출에 compile, 이후 cache
8
bool match(string s) {
9
  static folly::Lazy<std::regex> re = folly::lazy([]{
10
    return std::regex("complex pattern");
11
  });
12
  return std::regex_search(s, *re);
13
}

1
class ServiceContext {
2
  folly::Lazy<DbConnection> db_ = folly::lazy([]{ return connectToDb(); });
3
};
4

5
void handleRequest(ServiceContext& ctx) {
6
  if (need_db) {
7
    ctx.db_->query(...); // 첫 사용 시 connect
8
  }
9
}

1
class Inference {
2
  folly::Lazy<Model> model_ = folly::lazy([]{ return Model::load("path"); });
3
};

1
// 회피 — 항상 사용되는 객체에 Lazy
2
class Worker {
3
  folly::Lazy<Logger> log_ = folly::lazy([]{ return Logger(); }); // 항상 쓰는데
4
};
5

6
// Good — 항상 쓰면 그냥 멤버
7
class Worker {
8
  Logger log_;
9
};

1
// 회피 — capture by reference + lifetime 문제
2
auto x = makeBigConfig();
3
auto lazy = folly::lazy([&x]{ return process(x); });
4
// lazy 살아있을 때 x가 살아 있어야 함
5

6
// Good — by value capture
7
auto lazy = folly::lazy([x = std::move(x)]{ return process(x); });

1
// 회피 — 핫패스 첫 호출이 느림
2
folly::Lazy<HeavyCache> cache;
3
// p99 latency가 첫 request에서 spike

1
void warmup() {
2
  *cache; // pre-init
3
}

1
// 회피 — 이중 indirection
2
folly::Lazy<std::unique_ptr<T>> bad;
3

4
// Good — Lazy<T>
5
folly::Lazy<T> good;

1
// 회피
2
void use() {
3
  auto lz = folly::lazy([]{ return compute(); });
4
  auto v = *lz; // 즉시 첫 접근 — lazy 의미 없음
5
}

1
// 회피
2
folly::Lazy<T> bad = folly::lazy([]{
3
  throw std::runtime_error("..."); // 첫 호출자에게만 던져짐
4
});
5

6
// 첫 호출자 catch한 후 다음 호출은 어떻게 되나?
7
// Folly Lazy 구현마다 다르므로 명세 확인 필요

1
class X {
2
  folly::Lazy<T> lazy_; // non-mutable
3

4
  const T& get() const {
5
    return *lazy_; // 컴파일 에러 — lazy_가 mutable이 아니면
6
  }
7
};
8

9
// Good — mutable Lazy
10
mutable folly::Lazy<T> lazy_;