commit ef8f1aea66b749ec352ea0ad97d734e8fada2f2e
author Austin Schuh <austin.linux@gmail.com> Sat Dec 11 12:35:05 2021 -0800
committer Austin Schuh <austin.linux@gmail.com> Sat Dec 11 12:49:59 2021 -0800
tree d1ac0c4ed407836230398e2c3091a6371eab9102
parent 64e636f84bad6dd25cec3ce3960ff7fba06a38c2

Convert EventScheduler to use classes for callbacks

std::function is slow to construct and destroy.  Convert the hot path
over to use a class instead.

Change-Id: Ic7627da065576ef0c03bb09e07b60ee5a95b0c94
Signed-off-by: Austin Schuh <austin.linux@gmail.com>

aos/events/simulated_event_loop.cc

diff --git a/aos/events/simulated_event_loop.cc b/aos/events/simulated_event_loop.cc
index a43cb30..4ea7ebd 100644
--- a/aos/events/simulated_event_loop.cc
+++ b/aos/events/simulated_event_loop.cc
@@ -112,7 +112,7 @@
 
 // TODO(Brian): This should be in the anonymous namespace, but that annoys GCC
 // for some reason...
-class SimulatedWatcher : public WatcherState {
+class SimulatedWatcher : public WatcherState, public EventScheduler::Event {
  public:
   SimulatedWatcher(
       SimulatedEventLoop *simulated_event_loop, EventScheduler *scheduler,
@@ -123,6 +123,8 @@
 
   bool has_run() const;
 
+  void Handle() noexcept override;
+
   void Startup(EventLoop * /*event_loop*/) override {}
 
   void Schedule(std::shared_ptr<SimulatedMessage> message);
@@ -463,7 +465,8 @@
   bool fell_behind_ = false;
 };
 
-class SimulatedTimerHandler : public TimerHandler {
+class SimulatedTimerHandler : public TimerHandler,
+                              public EventScheduler::Event {
  public:
   explicit SimulatedTimerHandler(EventScheduler *scheduler,
                                  SimulatedEventLoop *simulated_event_loop,
@@ -475,6 +478,8 @@
 
   void HandleEvent() noexcept;
 
+  void Handle() noexcept override;
+
   void Disable() override;
 
  private:
@@ -487,7 +492,8 @@
   monotonic_clock::duration repeat_offset_;
 };
 
-class SimulatedPhasedLoopHandler : public PhasedLoopHandler {
+class SimulatedPhasedLoopHandler : public PhasedLoopHandler,
+                                   public EventScheduler::Event {
  public:
   SimulatedPhasedLoopHandler(EventScheduler *scheduler,
                              SimulatedEventLoop *simulated_event_loop,
@@ -500,6 +506,8 @@
 
   void Schedule(monotonic_clock::time_point sleep_time) override;
 
+  void Handle() noexcept override;
+
  private:
   SimulatedEventLoop *simulated_event_loop_;
   EventHandler<SimulatedPhasedLoopHandler> event_;
@@ -887,15 +895,17 @@
   }
 }
 
+void SimulatedWatcher::Handle() noexcept {
+  DCHECK(token_ != scheduler_->InvalidToken());
+  token_ = scheduler_->InvalidToken();
+  simulated_event_loop_->HandleEvent();
+}
+
 void SimulatedWatcher::DoSchedule(monotonic_clock::time_point event_time) {
   CHECK(token_ == scheduler_->InvalidToken())
       << ": May not schedule multiple times";
   token_ = scheduler_->Schedule(
-      event_time + simulated_event_loop_->send_delay(), [this]() {
-        DCHECK(token_ != scheduler_->InvalidToken());
-        token_ = scheduler_->InvalidToken();
-        simulated_event_loop_->HandleEvent();
-      });
+      event_time + simulated_event_loop_->send_delay(), this);
 }
 
 void SimulatedChannel::MakeRawWatcher(SimulatedWatcher *watcher) {
@@ -1085,15 +1095,17 @@
       simulated_event_loop_->monotonic_now();
   base_ = base;
   repeat_offset_ = repeat_offset;
-  token_ = scheduler_->Schedule(std::max(base, monotonic_now), [this]() {
-    DCHECK(token_ != scheduler_->InvalidToken());
-    token_ = scheduler_->InvalidToken();
-    simulated_event_loop_->HandleEvent();
-  });
+  token_ = scheduler_->Schedule(std::max(base, monotonic_now), this);
   event_.set_event_time(base_);
   simulated_event_loop_->AddEvent(&event_);
 }
 
+void SimulatedTimerHandler::Handle() noexcept {
+  DCHECK(token_ != scheduler_->InvalidToken());
+  token_ = scheduler_->InvalidToken();
+  simulated_event_loop_->HandleEvent();
+}
+
 void SimulatedTimerHandler::HandleEvent() noexcept {
   const monotonic_clock::time_point monotonic_now =
       simulated_event_loop_->monotonic_now();
@@ -1111,11 +1123,7 @@
   if (repeat_offset_ != monotonic_clock::zero()) {
     // Reschedule.
     while (base_ <= monotonic_now) base_ += repeat_offset_;
-    token_ = scheduler_->Schedule(base_, [this]() {
-      DCHECK(token_ != scheduler_->InvalidToken());
-      token_ = scheduler_->InvalidToken();
-      simulated_event_loop_->HandleEvent();
-    });
+    token_ = scheduler_->Schedule(base_, this);
     event_.set_event_time(base_);
     simulated_event_loop_->AddEvent(&event_);
   }
@@ -1171,6 +1179,12 @@
   }
 }
 
+void SimulatedPhasedLoopHandler::Handle() noexcept {
+  DCHECK(token_ != scheduler_->InvalidToken());
+  token_ = scheduler_->InvalidToken();
+  simulated_event_loop_->HandleEvent();
+}
+
 void SimulatedPhasedLoopHandler::Schedule(
     monotonic_clock::time_point sleep_time) {
   // The allocations in here are due to infrastructure and don't count in the no
@@ -1180,11 +1194,7 @@
     scheduler_->Deschedule(token_);
     token_ = scheduler_->InvalidToken();
   }
-  token_ = scheduler_->Schedule(sleep_time, [this]() {
-    DCHECK(token_ != scheduler_->InvalidToken());
-    token_ = scheduler_->InvalidToken();
-    simulated_event_loop_->HandleEvent();
-  });
+  token_ = scheduler_->Schedule(sleep_time, this);
   event_.set_event_time(sleep_time);
   simulated_event_loop_->AddEvent(&event_);
 }