folly::EventBase 분석 — libevent 이벤트 루프의 핵심

1
#include <folly/io/async/EventBase.h>
2

3
folly::EventBase evb;
4

5
// 1) loop 시작
6
std::thread t([&] { evb.loopForever(); });
7

8
// 2) schedule (cross-thread OK)
9
evb.runInEventBaseThread([] { std::cout << "in EB thread\n"; });
10
evb.runInEventBaseThreadAndWait([] { ... });   // blocking
11

12
// 3) timer
13
evb.runAfterDelay([] { LOG(INFO) << "5s"; }, 5000);
14

15
// 4) Future
16
sf.via(&evb).thenValue([](auto x) { ... });
17

18
// 5) loop 종료
19
evb.terminateLoopSoon();
20
t.join();

1
class EventBase {
2
 public:
3
  bool loop();           // 한 iteration
4
  bool loopOnce();       // 한 event 처리 후 return
5
  void loopForever();    // 영원히
6
  void terminateLoopSoon();
7
};

1
std::thread other([&] {
2
  // 다른 thread에서
3
  evb.runInEventBaseThread([] {
4
    // EventBase loop thread에서 실행
5
    sock->write(buf);   // race 없이 안전
6
  });
7
});

1
// folly/io/async/EventBase.cpp (개념)
2
void EventBase::runInEventBaseThread(Func fn) {
3
  if (inRunningEventBaseThread()) {
4
    queue_->add(std::move(fn));   // 같은 thread면 직접 큐에
5
  } else {
6
    notificationQueue_->add(std::move(fn));   // cross-thread
7
    notifyFd_->signal();                        // EventBase loop 깨우기
8
  }
9
}

1
// EventBase는 folly::Executor를 구현
2
class EventBase : public folly::Executor {
3
 public:
4
  void add(Func f) override {
5
    runInEventBaseThread(std::move(f));
6
  }
7
};
8

9
// 사용
10
fetchAsync(url).via(&evb).thenValue([](Response r) {
11
  // EventBase thread에서 실행
12
});

1
evb.runAfterDelay([] { ... }, 100);   // 100ms 후

1
// folly/io/async/HHWheelTimer.h (개념)
2
class HHWheelTimer {
3
  // 8 + 4 levels의 wheel — 256ms ~ 수십일 범위
4
  std::array<TimeoutList, 256> buckets_[4];
5
  std::chrono::milliseconds tickInterval_;
6
};

1
class MyObserver : public folly::EventBase::LoopCallback {
2
  void runLoopCallback() noexcept override {
3
    LOG(INFO) << "loop iteration";
4
  }
5
};
6

7
MyObserver o;
8
evb.runInLoop(&o);

1
folly::EventBaseManager* m = folly::EventBaseManager::get();
2
folly::EventBase* eb = m->getEventBase();

1
// Single threaded
2
folly::EventBase evb;
3
std::thread t([&] { evb.loopForever(); });
4
// 모든 callback이 t에서 실행 — race 없음
5

6
// Multi threaded
7
folly::IOThreadPoolExecutor io(4);
8
auto* eb = io.getEventBase();   // 4개 중 하나 (round-robin)
9
// 같은 fd는 같은 EventBase로 pin

1
// 1. loop 안에서 blocking
2
evb.runInEventBaseThread([] {
3
  std::this_thread::sleep_for(std::chrono::seconds(1));   // loop 멈춤
4
});
5

6
// 2. EventBase state를 다른 thread에서 직접 수정
7
class Conn {
8
  folly::AsyncSocket* sock_;
9
  void close() { sock_->close(); }   // 어느 thread에서 호출?
10
};
11
// 옳음:
12
void close() {
13
  evb_->runInEventBaseThread([this] { sock_->close(); });
14
}
15

16
// 3. EventBase가 destruct되기 전에 loop 종료 안 함
17
folly::EventBase evb;
18
std::thread t([&] { evb.loopForever(); });
19
// evb destruct — t는 dangling reference로 SEGV
20
// terminateLoopSoon() + t.join() 먼저
21

22
// 4. 한 thread에서 두 EventBase loop
23
folly::EventBase eb1, eb2;
24
eb1.loopForever();   // 두 번째는 실행 안 됨
25
eb2.loopForever();