Move stats gathering off the UI thread. Throttle it 10/second.

Author: Mysticial

Common/Cpp/Stopwatch.h

@@ -4,8 +4,8 @@
  *
  */
 
-#ifndef PokemonAutomation_VideoPipeline_SnapshotManager_H
-#define PokemonAutomation_VideoPipeline_SnapshotManager_H
+#ifndef PokemonAutomation_VideoPipeline_Stopwatch_H
+#define PokemonAutomation_VideoPipeline_Stopwatch_H
 
 #include "Time.h"
 

SerialPrograms/Source/CommonFramework/VideoPipeline/UI/VideoOverlayWidget.cpp

@@ -35,7 +35,8 @@ VideoOverlayWidget::VideoOverlayWidget(QWidget& parent, VideoOverlaySession& ses
     , m_texts(std::make_shared<std::vector<OverlayText>>(session.texts()))
     , m_images(std::make_shared<std::vector<OverlayImage>>(session.images()))
     , m_log(std::make_shared<std::vector<OverlayLogLine>>(session.log_texts()))
-    , m_stats(nullptr)
+//    , m_stats(nullptr)
+    , m_stats_paint("VideoOverlayWidget::paintEvent", "ms", 1000, std::chrono::seconds(10))
 {
     setAttribute(Qt::WA_NoSystemBackground);
     setAttribute(Qt::WA_TranslucentBackground);
@@ -81,10 +82,6 @@ void VideoOverlayWidget::update_log_background(const std::shared_ptr<const std::
     m_log_text_bg_boxes = bg_boxes;
 }
 #endif
-void VideoOverlayWidget::on_overlay_update_stats(const std::list<OverlayStat*>* stats){
-    WriteSpinLock lg(m_lock, "VideoOverlay::update_stats()");
-    m_stats = stats;
-}
 
 void VideoOverlayWidget::on_watchdog_timeout(){
     QMetaObject::invokeMethod(this, [this]{ this->update(); });
@@ -96,6 +93,8 @@ void VideoOverlayWidget::on_watchdog_timeout(){
 void VideoOverlayWidget::resizeEvent(QResizeEvent* event){}
 
 void VideoOverlayWidget::paintEvent(QPaintEvent*){
+    WallClock time0 = current_time();
+
     QPainter painter(this);
     {
         WriteSpinLock lg(m_lock, "VideoOverlay::paintEvent()");
@@ -112,12 +111,16 @@ void VideoOverlayWidget::paintEvent(QPaintEvent*){
         if (m_session.enabled_log()){
             render_log(painter);
         }
-        if (m_session.enabled_stats() && m_stats){
+        if (m_session.enabled_stats()){
             render_stats(painter);
         }
     }
 
     global_watchdog().delay(*this);
+
+    WallClock time1 = current_time();
+    uint32_t microseconds = (uint32_t)std::chrono::duration_cast<std::chrono::microseconds>(time1 - time0).count();
+    m_stats_paint.report_data(m_session.logger(), microseconds);
 }
 
 
@@ -291,14 +294,7 @@ void VideoOverlayWidget::render_stats(QPainter& painter){
     int height = this->height();
     int start_x = (int)(width * 0.78);
 
-    std::vector<OverlayStatSnapshot> lines;
-    for (const auto& stat : *m_stats){
-        OverlayStatSnapshot snapshot = stat->get_current();
-        if (!snapshot.text.empty()){
-            lines.emplace_back(std::move(snapshot));
-        }
-    }
-
+    std::vector<OverlayStatSnapshot> lines = m_session.stats();
 
     painter.fillRect(
         start_x,

SerialPrograms/Source/CommonFramework/VideoPipeline/UI/VideoOverlayWidget.h

@@ -10,6 +10,7 @@
 #include <QWidget>
 #include "Common/Cpp/Concurrency/SpinLock.h"
 #include "Common/Cpp/Concurrency/Watchdog.h"
+#include "CommonFramework/Tools/StatAccumulator.h"
 #include "CommonFramework/VideoPipeline/VideoOverlaySession.h"
 
 namespace PokemonAutomation{
@@ -52,8 +53,6 @@ class VideoOverlayWidget : public QWidget, private VideoOverlaySession::ContentL
     virtual void on_overlay_update_images(const std::shared_ptr<const std::vector<OverlayImage>>& images) override;
     // callback function from VideoOverlaySession on overlay images updated
     virtual void on_overlay_update_log   (const std::shared_ptr<const std::vector<OverlayLogLine>>& logs) override;
-    // callback function from VideoOverlaySession on overlay stats updated
-    virtual void on_overlay_update_stats (const std::list<OverlayStat*>* stats) override;
 
     virtual void on_watchdog_timeout() override;
 
@@ -89,7 +88,8 @@ class VideoOverlayWidget : public QWidget, private VideoOverlaySession::ContentL
     std::shared_ptr<const std::vector<OverlayText>> m_texts;
     std::shared_ptr<const std::vector<OverlayImage>> m_images;
     std::shared_ptr<const std::vector<OverlayLogLine>> m_log;
-    const std::list<OverlayStat*>* m_stats;
+
+    PeriodicStatsReporterI32 m_stats_paint;
 };
 
 

SerialPrograms/Source/CommonFramework/VideoPipeline/VideoOverlaySession.cpp

@@ -17,7 +17,6 @@ namespace PokemonAutomation{
 void VideoOverlaySession::add_listener(ContentListener& listener){
     WriteSpinLock lg(m_lock);
     m_content_listeners.insert(&listener);
-    listener.on_overlay_update_stats(&m_stats_order);
 }
 void VideoOverlaySession::remove_listener(ContentListener& listener){
     WriteSpinLock lg(m_lock);
@@ -27,13 +26,17 @@ void VideoOverlaySession::remove_listener(ContentListener& listener){
 
 
 VideoOverlaySession::~VideoOverlaySession(){
-    ReadSpinLock lg(m_lock);
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_stats(nullptr);
+    {
+        std::lock_guard<std::mutex> lg(m_stats_lock);
+        m_stopping = true;
     }
+    m_stats_cv.notify_all();
+    m_stats_updater.join();
 }
-VideoOverlaySession::VideoOverlaySession(VideoOverlayOption& option)
-    : m_option(option)
+VideoOverlaySession::VideoOverlaySession(Logger& logger, VideoOverlayOption& option)
+    : m_logger(logger)
+    , m_option(option)
+    , m_stats_updater(&VideoOverlaySession::stats_thread, this)
 {}
 
 
@@ -71,6 +74,25 @@ void VideoOverlaySession::set(const VideoOverlayOption& option){
 }
 
 
+void VideoOverlaySession::stats_thread(){
+    std::unique_lock<std::mutex> lg(m_stats_lock);
+    while (!m_stopping){
+        {
+            std::vector<OverlayStatSnapshot> lines;
+            ReadSpinLock lg0(m_lock);
+            for (const auto& stat : m_stats){
+                OverlayStatSnapshot snapshot = stat.first->get_current();
+                if (!snapshot.text.empty()){
+                    lines.emplace_back(std::move(snapshot));
+                }
+            }
+            m_stat_lines = std::move(lines);
+        }
+        m_stats_cv.wait_for(lg, std::chrono::milliseconds(100));
+    }
+}
+
+
 void VideoOverlaySession::set_enabled_boxes(bool enabled){
     m_option.boxes.store(enabled, std::memory_order_relaxed);
     ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_boxes()");
@@ -108,6 +130,9 @@ void VideoOverlaySession::set_enabled_stats(bool enabled){
 }
 
 
+//
+//  Boxes
+//
 
 void VideoOverlaySession::add_box(const OverlayBox& box){
     WriteSpinLock lg(m_lock, "VideoOverlaySession::add_box()");
@@ -135,7 +160,6 @@ void VideoOverlaySession::push_box_update(){
         listener->on_overlay_update_boxes(ptr);
     }
 }
-
 std::vector<OverlayBox> VideoOverlaySession::boxes() const{
     ReadSpinLock lg(m_lock);
     std::vector<OverlayBox> ret;
@@ -145,6 +169,11 @@ std::vector<OverlayBox> VideoOverlaySession::boxes() const{
     return ret;
 }
 
+
+//
+//  Texts
+//
+
 void VideoOverlaySession::add_text(const OverlayText& text){
     WriteSpinLock lg(m_lock, "VideoOverlaySession::add_text()");
     m_texts.insert(&text);
@@ -171,7 +200,6 @@ void VideoOverlaySession::push_text_update(){
         listener->on_overlay_update_text(ptr);
     }
 }
-
 std::vector<OverlayText> VideoOverlaySession::texts() const{
     ReadSpinLock lg(m_lock);
     std::vector<OverlayText> ret;
@@ -182,6 +210,10 @@ std::vector<OverlayText> VideoOverlaySession::texts() const{
 }
 
 
+//
+//  Images
+//
+
 void VideoOverlaySession::add_image(const OverlayImage& image){
     WriteSpinLock lg(m_lock, "VideoOverlaySession::add_image()");
     m_images.insert(&image);
@@ -208,7 +240,6 @@ void VideoOverlaySession::push_image_update(){
         listener->on_overlay_update_images(ptr);
     }
 }
-
 std::vector<OverlayImage> VideoOverlaySession::images() const{
     ReadSpinLock lg(m_lock);
     std::vector<OverlayImage> ret;
@@ -219,6 +250,10 @@ std::vector<OverlayImage> VideoOverlaySession::images() const{
 }
 
 
+//
+//  Log
+//
+
 void VideoOverlaySession::add_log(std::string message, Color color){
     WriteSpinLock lg(m_lock, "VideoOverlaySession::add_log_text()");
     m_log_texts.emplace_front(color, std::move(message));
@@ -229,7 +264,6 @@ void VideoOverlaySession::add_log(std::string message, Color color){
 
     push_log_text_update();
 }
-
 void VideoOverlaySession::clear_log(){
     WriteSpinLock lg(m_lock, "VideoOverlaySession::clear_log_texts()");
     m_log_texts.clear();
@@ -251,7 +285,6 @@ void VideoOverlaySession::push_log_text_update(){
         listener->on_overlay_update_log(ptr);
     }
 }
-
 std::vector<OverlayLogLine> VideoOverlaySession::log_texts() const{
     ReadSpinLock lg(m_lock);
     std::vector<OverlayLogLine> ret;
@@ -262,7 +295,9 @@ std::vector<OverlayLogLine> VideoOverlaySession::log_texts() const{
 }
 
 
-
+//
+//  Stats
+//
 
 void VideoOverlaySession::add_stat(OverlayStat& stat){
     WriteSpinLock lg(m_lock);
@@ -271,11 +306,6 @@ void VideoOverlaySession::add_stat(OverlayStat& stat){
         return;
     }
 
-    //  Remove all stats so they aren't being referenced.
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_stats(nullptr);
-    }
-
     m_stats_order.emplace_back(&stat);
     auto list_iter = m_stats_order.end();
     --list_iter;
@@ -285,11 +315,6 @@ void VideoOverlaySession::add_stat(OverlayStat& stat){
         m_stats_order.pop_back();
         throw;
     }
-
-    //  Add all the stats back.
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_stats(&m_stats_order);
-    }
 }
 void VideoOverlaySession::remove_stat(OverlayStat& stat){
     WriteSpinLock lg(m_lock);
@@ -298,20 +323,14 @@ void VideoOverlaySession::remove_stat(OverlayStat& stat){
         return;
     }
 
-    //  Remove all stats so they aren't being referenced.
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_stats(nullptr);
-    }
-
     m_stats_order.erase(iter->second);
     m_stats.erase(iter);
-
-    //  Add all the stats back.
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_stats(&m_stats_order);
-    }
 }
 
+std::vector<OverlayStatSnapshot> VideoOverlaySession::stats() const{
+    ReadSpinLock lg(m_lock);
+    return m_stat_lines;
+}
 
 
 

SerialPrograms/Source/CommonFramework/VideoPipeline/VideoOverlaySession.h

@@ -19,6 +19,10 @@
 #include <set>
 #include <map>
 #include <deque>
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+#include "Common/Cpp/AbstractLogger.h"
 #include "Common/Cpp/Color.h"
 #include "Common/Cpp/Concurrency/SpinLock.h"
 #include "VideoOverlay.h"
@@ -59,16 +63,6 @@ class VideoOverlaySession : public VideoOverlay{
         // is modified by VideoOverlaySession::add/remove_log().
         virtual void on_overlay_update_log    (const std::shared_ptr<const std::vector<OverlayLogLine>>& boxes){}
 
-        //  This one is different from the others. The listeners will store this
-        //  pointer and access it directly and asynchronously. If you need to
-        //  change the structure of the list itself, you must first call this
-        //  with null to remove it from all the listeners. Then add the updated
-        //  one back when you're done.
-        //  This is called immediately when attaching a listener to give the
-        //  current stats. The listener must drop all references to the stats
-        //  before detaching.
-        virtual void on_overlay_update_stats(const std::list<OverlayStat*>* stats){}
-
     };
 
     //  Add a UI class to listen to any overlay change. The UI class needs to inherit Listener.
@@ -80,7 +74,9 @@ class VideoOverlaySession : public VideoOverlay{
 
 public:
     ~VideoOverlaySession();
-    VideoOverlaySession(VideoOverlayOption& option);
+    VideoOverlaySession(Logger& logger, VideoOverlayOption& option);
+
+    Logger& logger() const{ return m_logger; }
 
     void get(VideoOverlayOption& option);
     void set(const VideoOverlayOption& option);
@@ -114,6 +110,9 @@ class VideoOverlaySession : public VideoOverlay{
     // is modified by VideoOverlaySession::add/remove_log().
     std::vector<OverlayLogLine> log_texts() const;
 
+    std::vector<OverlayStatSnapshot> stats() const;
+
+
     virtual void add_box(const OverlayBox& box) override;
     virtual void remove_box(const OverlayBox& box) override;
 
@@ -131,18 +130,20 @@ class VideoOverlaySession : public VideoOverlay{
 
 
 private:
+    void stats_thread();
+
     //  Push updates to the various listeners.
     void push_box_update();
     void push_text_update();
     void push_image_update();
     void push_log_text_update();
 
-
 private:
-    mutable SpinLock m_lock;
-
+    Logger& m_logger;
     VideoOverlayOption& m_option;
 
+    mutable SpinLock m_lock;
+
     std::set<const OverlayBox*> m_boxes;
     std::set<const OverlayText*> m_texts;
     std::set<const OverlayImage*> m_images;
@@ -152,6 +153,12 @@ class VideoOverlaySession : public VideoOverlay{
     std::map<OverlayStat*, std::list<OverlayStat*>::iterator> m_stats;
 
     std::set<ContentListener*> m_content_listeners;
+
+    bool m_stopping = false;
+    std::vector<OverlayStatSnapshot> m_stat_lines;
+    std::mutex m_stats_lock;
+    std::condition_variable m_stats_cv;
+    std::thread m_stats_updater;
 };