Merge pull request opencv#23211 from TolyaTalamanov:at/pipeline-model…

…ing-tool-perf-alignment

[G-API] Pipeline modeling tool: Refactor calculating performance statistics

* Add warmup execution

* Align perf metrics

* Add busy wait mode for source

* Small fix for late frames

* pl_fn to src_fn

* Change show statistics

* Correct warm-up iteration

* Properly calculate drop frames

* Enable frame dropping for streaming mode

* Enable frame dropping for streaming mode

* Fix comments to review

* Fix typos

* Cosmetic

modules/gapi/samples/pipeline_modeling_tool.cpp

@@ -35,6 +35,22 @@ static AppMode strToAppMode(const std::string& mode_str) {
     }
 }
 
+enum class WaitMode {
+    BUSY,
+    SLEEP
+};
+
+static WaitMode strToWaitMode(const std::string& mode_str) {
+    if (mode_str == "sleep") {
+        return WaitMode::SLEEP;
+    } else if (mode_str == "busy") {
+        return WaitMode::BUSY;
+    } else {
+        throw std::logic_error("Unsupported wait mode: " + mode_str +
+                "\nPlease chose between: busy (default) and sleep");
+    }
+}
+
 template <typename T>
 T read(const cv::FileNode& node) {
     return static_cast<T>(node);
@@ -401,7 +417,12 @@ int main(int argc, char* argv[]) {
                 if (app_mode == AppMode::BENCHMARK) {
                     latency = 0.0;
                 }
-                auto src = std::make_shared<DummySource>(latency, output, drop_frames);
+
+                const auto wait_mode =
+                    strToWaitMode(readOpt<std::string>(src_fn["wait_mode"]).value_or("busy"));
+                auto wait_strategy = (wait_mode == WaitMode::SLEEP) ? utils::sleep : utils::busyWait;
+                auto src = std::make_shared<DummySource>(
+                        utils::double_ms_t{latency}, output, drop_frames, std::move(wait_strategy));
                 builder.setSource(src_name, src);
             }
 
@@ -446,7 +467,7 @@ int main(int argc, char* argv[]) {
             // NB: Pipeline mode from config takes priority over cmd.
             auto pl_mode = cfg_pl_mode.has_value()
                 ? strToPLMode(cfg_pl_mode.value()) : cmd_pl_mode;
-            // NB: Using drop_frames with streaming pipelines will follow to
+            // NB: Using drop_frames with streaming pipelines will lead to
             // incorrect performance results.
             if (drop_frames && pl_mode == PLMode::STREAMING) {
                 throw std::logic_error(

modules/gapi/samples/pipeline_modeling_tool/dummy_source.hpp

@@ -12,26 +12,36 @@
 
 class DummySource final: public cv::gapi::wip::IStreamSource {
 public:
+    using WaitStrategy = std::function<void(std::chrono::microseconds)>;
     using Ptr = std::shared_ptr<DummySource>;
-    DummySource(const double       latency,
+    using ts_t = std::chrono::microseconds;
+
+    template <typename DurationT>
+    DummySource(const DurationT    latency,
                 const OutputDescr& output,
-                const bool         drop_frames);
+                const bool         drop_frames,
+                WaitStrategy&&     wait);
+
     bool pull(cv::gapi::wip::Data& data) override;
     cv::GMetaArg descr_of() const override;
-    double latency() const { return m_latency; };
 
 private:
-    double  m_latency;
-    cv::Mat m_mat;
-    bool    m_drop_frames;
-    double  m_next_tick_ts = -1;
-    int64_t m_curr_seq_id  = 0;
+    int64_t       m_latency;
+    cv::Mat       m_mat;
+    bool          m_drop_frames;
+    int64_t       m_next_tick_ts = -1;
+    int64_t       m_curr_seq_id  = 0;
+    WaitStrategy  m_wait;
 };
 
-DummySource::DummySource(const double       latency,
+template <typename DurationT>
+DummySource::DummySource(const DurationT    latency,
                          const OutputDescr& output,
-                         const bool         drop_frames)
-    : m_latency(latency), m_drop_frames(drop_frames) {
+                         const bool         drop_frames,
+                         WaitStrategy&&     wait)
+    : m_latency(std::chrono::duration_cast<ts_t>(latency).count()),
+      m_drop_frames(drop_frames),
+      m_wait(std::move(wait)) {
     utils::createNDMat(m_mat, output.dims, output.precision);
     utils::generateRandom(m_mat);
 }
@@ -42,10 +52,10 @@ bool DummySource::pull(cv::gapi::wip::Data& data) {
 
     // NB: Wait m_latency before return the first frame.
     if (m_next_tick_ts == -1) {
-        m_next_tick_ts = utils::timestamp<milliseconds>() + m_latency;
+        m_next_tick_ts = utils::timestamp<ts_t>() + m_latency;
     }
 
-    int64_t curr_ts = utils::timestamp<milliseconds>();
+    int64_t curr_ts = utils::timestamp<ts_t>();
     if (curr_ts < m_next_tick_ts) {
         /*
          *            curr_ts
@@ -57,38 +67,37 @@ bool DummySource::pull(cv::gapi::wip::Data& data) {
          *
          * NB: New frame will be produced at the m_next_tick_ts point.
          */
-        utils::sleep(m_next_tick_ts - curr_ts);
-    } else {
+        m_wait(ts_t{m_next_tick_ts - curr_ts});
+    } else if (m_latency != 0) {
         /*
          *                                       curr_ts
          *                         +1         +2    |
          *    |----------|----------|----------|----*-----|------->
          *               ^                     ^
          *         m_next_tick_ts ------------->
          *
-         *
-         *  NB: Shift m_next_tick_ts to the nearest tick before curr_ts and
-         *  update current seq_id correspondingly.
-         *
-         *  if drop_frames is enabled, wait for the next tick, otherwise
-         *  return last written frame (+2 at the picture above) immediately.
          */
+
+        // NB: Count how many frames have been produced since last pull (m_next_tick_ts).
         int64_t num_frames =
             static_cast<int64_t>((curr_ts - m_next_tick_ts) / m_latency);
-        m_curr_seq_id  += num_frames;
+        // NB: Shift m_next_tick_ts to the nearest tick before curr_ts.
         m_next_tick_ts += num_frames * m_latency;
+        // NB: if drop_frames is enabled, update current seq_id and wait for the next tick, otherwise
+        // return last written frame (+2 at the picture above) immediately.
         if (m_drop_frames) {
+            // NB: Shift tick to the next frame.
             m_next_tick_ts += m_latency;
-            ++m_curr_seq_id;
-            utils::sleep(m_next_tick_ts - curr_ts);
+            // NB: Wait for the next frame.
+            m_wait(ts_t{m_next_tick_ts - curr_ts});
+            // NB: Drop already produced frames + update seq_id for the current.
+            m_curr_seq_id += num_frames + 1;
         }
     }
-
     // NB: Just increase reference counter not to release mat memory
     // after assigning it to the data.
     cv::Mat mat = m_mat;
-
-    data.meta[meta_tag::timestamp] = utils::timestamp<milliseconds>();
+    data.meta[meta_tag::timestamp] = utils::timestamp<ts_t>();
     data.meta[meta_tag::seq_id] = m_curr_seq_id++;
     data = mat;
     m_next_tick_ts += m_latency;