folly::Indestructible — global lifetime 패턴

1
#include <folly/Indestructible.h>
2

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

1
#include <folly/Indestructible.h>
2

3
class MyConfig {
4
 public:
5
  MyConfig() { /* 생성 */ }
6
  // 일부러 destructor를 두지 않음 (또는 두더라도 호출 안 됨)
7

8
  std::string GetValue(folly::StringPiece key) const;
9
};
10

11
folly::Indestructible<MyConfig> kConfig;
12

13
void Use() {
14
  auto v = kConfig->GetValue("foo");
15
  // 또는 (*kConfig).GetValue(...)
16
}

1
template <class T>
2
class Indestructible {
3
 public:
4
  template <class... Args>
5
  constexpr explicit Indestructible(Args&&... args) {
6
    new (&storage_) T(std::forward<Args>(args)...);
7
  }
8

9
  // 소멸자 — empty. T를 destroy하지 않음.
10
  ~Indestructible() {}
11

12
  T&       operator*()       { return *reinterpret_cast<T*>(&storage_); }
13
  T*       operator->()      { return reinterpret_cast<T*>(&storage_); }
14
  const T& operator*() const { /* ... */ }
15
};

1
// 잘못된 의존 — Logger가 Mutex에 의존
2
namespace {
3
  Mutex   logMutex;   // 1
4
  Logger  logger;     // 2 (logMutex 사용)
5
}
6

7
// process exit
8
// ~Logger() 가 실행 — logMutex 사용
9
// ~logMutex() 가 그 후 실행
10
// 만약 reverse 순서로 deinit되면 Logger가 dead Mutex 접근

1
folly::Indestructible<Mutex>  logMutex;
2
folly::Indestructible<Logger> logger{*logMutex};
3
// 둘 다 destroy되지 않음 — 의존 그래프 신경 안 써도 됨

1
// 1. raw leak
2
Foo* g_foo = nullptr;
3
Foo& GetFoo() {
4
  static std::once_flag flag;
5
  std::call_once(flag, [] { g_foo = new Foo; });
6
  return *g_foo;
7
}
8

9
// 2. Indestructible
10
Foo& GetFoo() {
11
  static folly::Indestructible<Foo> g_foo;
12
  return *g_foo;
13
}

1
// constexpr 생성자가 있는 T면 Indestructible도 constinit 가능
2
constinit folly::Indestructible<MyConfig> kConfig{/* args */};

1
// Meyers
2
Foo& GetFooMeyers() {
3
  static Foo instance;          // ~Foo() 호출됨 → 순서 문제 risk
4
  return instance;
5
}
6

7
// Indestructible
8
Foo& GetFooIndestructible() {
9
  static folly::Indestructible<Foo> instance;  // ~Foo() 호출 안 됨 → 안전
10
  return *instance;
11
}

1
// 1. heavy 자원을 Indestructible로 보유
2
folly::Indestructible<std::vector<HeavyObject>> kCache{LoadCache()};
3
// → process exit 시 heap에 leak — OS가 회수하지만 leak detector noise
4

5
// 2. Indestructible을 thread_local
6
thread_local folly::Indestructible<Foo> kFoo;
7
// → thread 종료 시 storage 사라짐 — 의도와 맞나? 보통은 그냥 thread_local Foo가 OK
8

9
// 3. ~Indestructible() 실행 후 *kFoo 접근 (불가능하지만 의도 헷갈림)
10
// → Indestructible 자체는 trivially destructible이므로 함수 frame 끝에 사라짐
11
//   global storage에 두는 게 일반 사용. local Indestructible은 어색.

1
// log category registry
2
namespace folly {
3
LogCategoryRegistry& LoggerDB::get() {
4
  static folly::Indestructible<LogCategoryRegistry> registry;
5
  return *registry;
6
}
7
}