folly::observer — hot config의 atomic refresh

1
std::mutex cfgMutex;
2
Config currentConfig;
3

4
Config GetConfig() {
5
  std::lock_guard lk(cfgMutex);   // 모든 read가 lock 경합
6
  return currentConfig;
7
}

1
std::atomic<std::shared_ptr<Config>> config;   // C++20 atomic shared_ptr
2

3
Config GetConfig() {
4
  return *config.load();
5
}

1
#include <folly/observer/Observer.h>
2
#include <folly/observer/SimpleObservable.h>
3

4
folly::observer::SimpleObservable<Config> obs{LoadInitialConfig()};
5

6
folly::observer::Observer<Config> read = obs.getObserver();
7

8
// 어딘가에서 update
9
obs.setValue(LoadNewConfig());
10

11
// hot path read
12
void HandleRequest() {
13
  auto snapshot = read.getSnapshot();
14
  // snapshot은 reference-stable Config*
15
  if (snapshot->isFeatureEnabled()) {
16
    // ...
17
  }
18
}

1
folly::observer::Snapshot<Config> snap = obs.getSnapshot();
2

3
// snap이 살아있는 동안 T*가 안정 — refresh 일어나도 이 snapshot은 옛 값
4
const Config& cfg = *snap;
5
ProcessLong(cfg);   // 중간에 setValue가 와도 cfg는 일관됨
6

7
// snapshot이 destroy되면 옛 값은 GC 가능

1
auto config = configObs.getObserver();   // Observer<Config>
2

3
auto timeoutObs = folly::observer::makeObserver([config] {
4
  auto snap = (*config).getSnapshot();
5
  return snap->timeout_ms;   // 의존성 자동 추적
6
});
7

8
// 사용
9
void HandleReq() {
10
  auto t = timeoutObs.getSnapshot();
11
  ApplyTimeout(*t);
12
}

1
// folly/observer/Observer.h 약식
2
class ObserverCore {
3
 public:
4
  std::shared_ptr<const void> getCurrentValue() const;
5
  void setValue(std::shared_ptr<const void> newVal);
6

7
  // dependent observer
8
  void addDependent(std::weak_ptr<ObserverCore> dep);
9
  void notifyDependentsAsync();   // executor에 schedule
10

11
 private:
12
  std::atomic<std::shared_ptr<const void>> value_;
13
  std::vector<std::weak_ptr<ObserverCore>> dependents_;
14
};
15

16
template <class T>
17
class Observer {
18
  std::shared_ptr<ObserverCore> core_;
19

20
  Snapshot<T> getSnapshot() const {
21
    auto val = core_->getCurrentValue();   // atomic load + ref count
22
    return Snapshot<T>{std::static_pointer_cast<const T>(val)};
23
  }
24
};

1
template <class T>
2
class TLObserver {
3
  ThreadLocal<Snapshot<T>> cached_;
4
  Observer<T>              base_;
5

6
  Snapshot<T> getSnapshot() {
7
    auto& cache = *cached_;
8
    if (cache && stillCurrent(cache)) return cache;
9
    cache = base_.getSnapshot();
10
    return cache;
11
  }
12
};

1
class FeatureGate {
2
  folly::observer::Observer<FlagSet> flags_;
3
 public:
4
  FeatureGate(folly::observer::Observer<FlagSet> obs) : flags_(std::move(obs)) {}
5

6
  bool IsEnabled(folly::StringPiece name) const {
7
    auto snap = flags_.getSnapshot();
8
    return snap->contains(name);
9
  }
10
};
11

12
// 어딘가에서 update
13
flagsObservable.setValue(LoadFromConfigServer());

1
// 1. snapshot을 멤버로 보관
2
struct Handler {
3
  folly::observer::Snapshot<Config> snap_ = configObs.getSnapshot();   // 영원히 옛 값
4
  void handle() { use(*snap_); }   // refresh 안 됨
5
};
6
// → Observer를 보관하고 handle 안에서 getSnapshot
7

8
// 2. setValue를 hot path에서
9
void HandleReq(Req r) {
10
  observable.setValue(newConfig);   // request마다 update?
11
  // → write가 자주면 observer 부적합
12
}
13

14
// 3. derived observer의 func 안에서 다른 thread 작업
15
auto derived = folly::observer::makeObserver([] {
16
  return std::async([] { return load(); });   // 의존성 추적 안 됨
17
});
18

19
// 4. snapshot lifetime을 RAII 밖으로
20
const Config& cfg = *snap;
21
return &cfg;   // snap이 scope 끝에 destroy → dangling

1
class LoadBalancer {
2
  folly::observer::Observer<Weights> weights_;
3

4
 public:
5
  LoadBalancer(folly::observer::Observer<Weights> obs)
6
    : weights_(std::move(obs)) {}
7

8
  Backend& Pick() {
9
    auto snap = weights_.getSnapshot();
10
    return weightedRandom(*snap);
11
  }
12
};
13

14
// background thread가 health check 기반 weight 계산
15
backgroundExecutor->add([&] {
16
  auto newWeights = ComputeFromHealth();
17
  weightsObservable.setValue(std::move(newWeights));
18
});