Fix high CPU usage from cursor position request feedback loop (#1310)

* Fix high CPU usage from cursor position request feedback loop (#1302)

In non-alternate-screen modes, every Draw() sends a \x1b[6n cursor
position request. Two compounding bugs turned this into a permanent
~60fps redraw loop, pegging both the app and the terminal emulator
(most visibly tmux):

1. ThrottledRequest::Send() never updated last_request_time_, so the
   intended 500ms throttle never engaged: a new request was sent as
   soon as the previous reply arrived.

2. The terminal input parser sink requested an animation frame for
   every parsed event, including cursor position reports, which are
   internal replies to our own request. The armed animation frame
   invalidated the frame, triggering a full redraw that sent the next
   request, whose reply armed the next frame, and so on.

Fix: record last_request_time_ in Send(), and stop requesting
animation frames for cursor position reports (they are still delivered
to the event buffer and consumed as before).

Measured with the gallery example idling inside tmux: the app drops
from ~24% CPU to ~0.4%, the tmux server from ~8% (detached; ~100% of
a core with an attached client) to ~0%.

Fixes #1302

* Request animation frames when handling events, not when receiving them

Move RequestAnimationFrame() from the two event producers (the
TerminalInputParser callback and App::PostEvent) to the Event branch of
App::Internal::HandleTask, below the internal-reply early-returns.

A single place now decides which events grant an animation frame, next
to the code discriminating event kinds. As a result, every internal
terminal reply (cursor shape, terminal capabilities, name/version,
emulator) stops arming animation frames: previously only cursor
position reports were exempted, and only on the parser path. This also
moves the animation_requested_ write onto the main loop thread,
removing an unsynchronized write when PostEvent is called from another
thread.

Add a test covering the event -> animation tick pipeline. See #1302.

* Only produce animation frames when requested

Restore the FTXUI 6 behavior: animation frames are produced only when
requested via animation::RequestAnimationFrame(), typically by an
animation::Animator which arms it on construction and re-arms it from
OnAnimation until the transition completes.

Handling an event no longer implicitly grants an animation tick. That
behavior was introduced accidentally by the v7 event loop rework
(33a40ee) and is what made the #1302 feedback loop possible in the
first place: internal terminal replies are events too.

Author: ArthurSonzogni

CHANGELOG.md

@@ -4,6 +4,15 @@ Changelog
 Next
 ====
 
+### Component
+- Bugfix: Fix high CPU usage (app and terminal emulator, e.g. tmux) caused by a
+  cursor position request/reply feedback loop redrawing the screen at ~60fps in
+  the non-alternate-screen modes. See #1302.
+- Animation frames are now produced only when requested via
+  `animation::RequestAnimationFrame()` (e.g. by `animation::Animator`), as in
+  FTXUI 6. Receiving an event no longer implicitly triggers an animation
+  frame.
+
 ### Dom
 - Performance: `text` computes its requirement once and renders only the
   visible lines. This makes scrolling a large text inside a `frame`

src/ftxui/component/animation_test.cpp

@@ -3,10 +3,18 @@
 // the LICENSE file.
 
 #include <gtest/gtest.h>
+#include <chrono>      // for milliseconds
 #include <functional>  // for function
+#include <thread>      // for sleep_for
 #include <vector>      // for allocator, vector
 
 #include "ftxui/component/animation.hpp"  // for Function, BackIn, BackInOut, BackOut, BounceIn, BounceInOut, BounceOut, CircularIn, CircularInOut, CircularOut, CubicIn, CubicInOut, CubicOut, ElasticIn, ElasticInOut, ElasticOut, ExponentialIn, ExponentialInOut, ExponentialOut, Linear, QuadraticIn, QuadraticInOut, QuadraticOut, QuarticIn, QuarticInOut, QuarticOut, QuinticIn, QuinticInOut, QuinticOut, SineIn, SineInOut, SineOut
+#include "ftxui/component/app.hpp"        // for App
+#include "ftxui/component/component.hpp"  // for Make
+#include "ftxui/component/component_base.hpp"  // for ComponentBase
+#include "ftxui/component/event.hpp"           // for Event
+#include "ftxui/component/loop.hpp"            // for Loop
+#include "ftxui/dom/elements.hpp"              // for text
 
 namespace ftxui {
 
@@ -35,4 +43,61 @@ TEST(AnimationTest, StartAndEnd) {
   }
 }
 
+namespace {
+
+class AnimationCounter : public ComponentBase {
+ public:
+  int count = 0;
+
+ private:
+  Element OnRender() override { return text(""); }
+  void OnAnimation(animation::Params& /*params*/) override { count++; }
+  bool OnEvent(Event event) override {
+    if (event == Event::Character('a')) {
+      animation::RequestAnimationFrame();
+      return true;
+    }
+    return false;
+  }
+};
+
+// Give the recurring AnimationTask (reposted every 15ms) time to become due,
+// then run the loop to execute it.
+void RunAnimationTask(Loop& loop) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(20));
+  loop.RunOnce();
+}
+
+}  // namespace
+
+// OnAnimation must tick only when a frame was requested with
+// animation::RequestAnimationFrame(), typically by an Animator. In particular,
+// handling an event must not implicitly produce a tick: internal terminal
+// replies are events too, and animating on them caused the #1302 feedback
+// loop.
+TEST(AnimationTest, TicksOnlyWhenRequested) {
+  auto component = Make<AnimationCounter>();
+  auto screen = App::FixedSize(10, 1);
+  Loop loop(&screen, component);
+  loop.RunOnce();
+
+  // No request: the recurring AnimationTask is a no-op.
+  RunAnimationTask(loop);
+  EXPECT_EQ(component->count, 0);
+
+  // An event alone doesn't produce a tick.
+  screen.PostEvent(Event::Custom);
+  loop.RunOnce();
+  RunAnimationTask(loop);
+  EXPECT_EQ(component->count, 0);
+
+  // A component requesting a frame gets exactly one tick.
+  screen.PostEvent(Event::Character('a'));
+  loop.RunOnce();
+  RunAnimationTask(loop);
+  EXPECT_EQ(component->count, 1);
+  RunAnimationTask(loop);
+  EXPECT_EQ(component->count, 1);
+}
+
 }  // namespace ftxui

src/ftxui/component/app.cpp

@@ -228,6 +228,7 @@ struct App::Internal {
    private:
     void Send() {
       last_sent_time_ = std::chrono::steady_clock::now();
+      last_request_time_ = last_sent_time_;
       pending_request_ = true;
       send_();
     }
@@ -556,7 +557,6 @@ App::Internal::Internal(App* app,
       use_alternative_screen_(use_alternative_screen),
       terminal_input_parser([&](Event event) {
         event_buffer.Push(std::move(event));
-        public_->RequestAnimationFrame();
       }),
       cursor_position_request(this, [this] {
         TerminalSend(DeviceStatusReport(DSRMode::kCursor));
@@ -1533,7 +1533,6 @@ void App::Post(Task task) {
 
 void App::PostEvent(Event event) {
   internal_->event_buffer.Push(std::move(event));
-  RequestAnimationFrame();
 }
 
 // static