Merge pull request #17000 from rgarnov:async_islands

alalek · alalek · commit 055645080161 · 2020-04-10T12:23:53.000Z
diff --git a/modules/gapi/include/opencv2/gapi/garray.hpp b/modules/gapi/include/opencv2/gapi/garray.hpp
@@ -29,7 +29,6 @@ namespace cv
 // (user-inaccessible) classes.
 class GNode;
 struct GOrigin;
-
 template<typename T> class GArray;
 
 /**
@@ -116,6 +115,7 @@ namespace detail
         virtual ~BasicVectorRef() {}
 
         virtual void mov(BasicVectorRef &ref) = 0;
+        virtual const void* ptr() const = 0;
     };
 
     template<typename T> class VectorRefT final: public BasicVectorRef
@@ -208,6 +208,8 @@ namespace detail
             GAPI_Assert(tv != nullptr);
             wref() = std::move(tv->wref());
         }
+
+        virtual const void* ptr() const override { return &rref(); }
     };
 
     // This class strips type information from VectorRefT<> and makes it usable
@@ -262,6 +264,9 @@ namespace detail
         {
             return m_ref->m_desc;
         }
+
+        // May be used to uniquely identify this object internally
+        const void *ptr() const { return m_ref->ptr(); }
     };
 
     // Helper (FIXME: work-around?)
diff --git a/modules/gapi/include/opencv2/gapi/gopaque.hpp b/modules/gapi/include/opencv2/gapi/gopaque.hpp
@@ -25,7 +25,6 @@ namespace cv
 // (user-inaccessible) classes.
 class GNode;
 struct GOrigin;
-
 template<typename T> class GOpaque;
 
 /**
@@ -107,6 +106,7 @@ namespace detail
         virtual ~BasicOpaqueRef() {}
 
         virtual void mov(BasicOpaqueRef &ref) = 0;
+        virtual const void* ptr() const = 0;
     };
 
     template<typename T> class OpaqueRefT final: public BasicOpaqueRef
@@ -198,6 +198,8 @@ namespace detail
             GAPI_Assert(tv != nullptr);
             wref() = std::move(tv->wref());
         }
+
+        virtual const void* ptr() const override { return &rref(); }
     };
 
     // This class strips type information from OpaqueRefT<> and makes it usable
@@ -250,6 +252,9 @@ namespace detail
         {
             return m_ref->m_desc;
         }
+
+        // May be used to uniquely identify this object internally
+        const void *ptr() const { return m_ref->ptr(); }
     };
 } // namespace detail
 
diff --git a/modules/gapi/src/api/gproto.cpp b/modules/gapi/src/api/gproto.cpp
@@ -264,4 +264,27 @@ std::ostream& operator<<(std::ostream& os, const cv::GMetaArg &arg)
 
     return os;
 }
+} // namespace cv
+
+const void* cv::gimpl::proto::ptr(const GRunArgP &arg)
+{
+    switch (arg.index())
+    {
+#if !defined(GAPI_STANDALONE)
+    case GRunArgP::index_of<cv::Mat*>():
+        return static_cast<const void*>(cv::util::get<cv::Mat*>(arg));
+    case GRunArgP::index_of<cv::Scalar*>():
+        return static_cast<const void*>(cv::util::get<cv::Scalar*>(arg));
+    case GRunArgP::index_of<cv::UMat*>():
+        return static_cast<const void*>(cv::util::get<cv::UMat*>(arg));
+#endif
+    case GRunArgP::index_of<cv::gapi::own::Mat*>():
+        return static_cast<const void*>(cv::util::get<cv::gapi::own::Mat*>(arg));
+    case GRunArgP::index_of<cv::detail::VectorRef>():
+        return cv::util::get<cv::detail::VectorRef>(arg).ptr();
+    case GRunArgP::index_of<cv::detail::OpaqueRef>():
+        return cv::util::get<cv::detail::OpaqueRef>(arg).ptr();
+    default:
+        util::throw_error(std::logic_error("Unknown GRunArgP type!"));
+    }
 }
diff --git a/modules/gapi/src/api/gproto_priv.hpp b/modules/gapi/src/api/gproto_priv.hpp
@@ -28,8 +28,14 @@ GAPI_EXPORTS const GOrigin& origin_of (const GArg      &arg);
 bool           is_dynamic(const GArg      &arg);
 GProtoArg      rewrap    (const GArg      &arg);
 
+// FIXME:: GAPI_EXPORTS because of tests only!!
+GAPI_EXPORTS const void*    ptr       (const GRunArgP  &arg);
+
 } // proto
 } // gimpl
 } // cv
 
+// FIXME: the gproto.cpp file has more functions that listed here
+// where those are declared??
+
 #endif // OPENCV_GAPI_GPROTO_PRIV_HPP
diff --git a/modules/gapi/src/compiler/gislandmodel.cpp b/modules/gapi/src/compiler/gislandmodel.cpp
@@ -327,13 +327,40 @@ void GIslandExecutable::run(GIslandExecutable::IInput &in, GIslandExecutable::IO
     std::vector<OutObj> out_objs;
     const auto &in_desc  = in.desc();
     const auto &out_desc = out.desc();
-    const auto in_vector = in.get(); // FIXME: passing temporary objects to toRange() leads to issues
+    const auto  in_msg   = in.get();
+    if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg))
+    {
+        out.post(cv::gimpl::EndOfStream{});
+        return;
+    }
+    GAPI_Assert(cv::util::holds_alternative<cv::GRunArgs>(in_msg));
+    const auto in_vector = cv::util::get<cv::GRunArgs>(in_msg);
     in_objs.reserve(in_desc.size());
     out_objs.reserve(out_desc.size());
     for (auto &&it: ade::util::zip(ade::util::toRange(in_desc),
                                    ade::util::toRange(in_vector)))
     {
-        in_objs.emplace_back(std::get<0>(it), std::get<1>(it));
+        // FIXME: Not every Island expects a cv::Mat instead of own::Mat on input
+        // This kludge should go as a result of de-ownification
+        const cv::GRunArg& in_data_orig = std::get<1>(it);
+        cv::GRunArg in_data;
+#if !defined(GAPI_STANDALONE)
+        switch (in_data_orig.index())
+        {
+        case cv::GRunArg::index_of<cv::Mat>():
+            in_data = cv::GRunArg{cv::to_own(cv::util::get<cv::Mat>(in_data_orig))};
+            break;
+        case cv::GRunArg::index_of<cv::Scalar>():
+            in_data = cv::GRunArg{(cv::util::get<cv::Scalar>(in_data_orig))};
+            break;
+        default:
+            in_data = in_data_orig;
+            break;
+        }
+#else
+        in_data = in_data_orig;
+#endif // GAPI_STANDALONE
+        in_objs.emplace_back(std::get<0>(it), std::move(in_data));
     }
     for (auto &&it: ade::util::indexed(ade::util::toRange(out_desc)))
     {
diff --git a/modules/gapi/src/compiler/gislandmodel.hpp b/modules/gapi/src/compiler/gislandmodel.hpp
@@ -123,6 +123,24 @@ class GAPI_EXPORTS GIslandExecutable
     virtual bool canReshape() const = 0;
     virtual void reshape(ade::Graph& g, const GCompileArgs& args) = 0;
 
+    // This method is called when the GStreamingCompiled gets a new
+    // input source to process. Normally this method is called once
+    // per stream execution.
+    //
+    // The idea of this method is to reset backend's stream-associated
+    // internal state, if there is any.
+    //
+    // The regular GCompiled invocation doesn't call this, there may
+    // be reset() introduced there but it is completely unnecessary at
+    // this moment.
+    //
+    // FIXME: The design on this and so-called "stateful" kernels is not
+    // closed yet.
+    // FIXME: This thing will likely break stuff once we introduce
+    // "multi-source streaming", a better design needs to be proposed
+    // at that stage.
+    virtual void handleNewStream() {}; // do nothing here by default
+
     virtual ~GIslandExecutable() = default;
 };
 
@@ -133,15 +151,18 @@ class GIslandExecutable::IODesc {
     void set(const std::vector<cv::gimpl::RcDesc> &newd) { d = newd; }
     const std::vector<cv::gimpl::RcDesc> &desc() const   { return d; }
 };
+struct EndOfStream {};
+using StreamMsg = cv::util::variant<EndOfStream, cv::GRunArgs>;
 struct GIslandExecutable::IInput: public GIslandExecutable::IODesc {
     virtual ~IInput() = default;
-    virtual cv::GRunArgs get() = 0;     // Get a new input vector (blocking)
-    virtual cv::GRunArgs try_get() = 0; // Get a new input vector (non-blocking)
+    virtual StreamMsg get() = 0;     // Get a new input vector (blocking)
+    virtual StreamMsg try_get() = 0; // Get a new input vector (non-blocking)
 };
 struct GIslandExecutable::IOutput: public GIslandExecutable::IODesc {
     virtual ~IOutput() = default;
     virtual GRunArgP get(int idx) = 0;  // Allocate (wrap) a new data object for output idx
     virtual void post(GRunArgP&&) = 0;  // Release the object back to the framework (mark available)
+    virtual void post(EndOfStream&&) = 0; // Post end-of-stream marker back to the framework
 };
 
 // GIslandEmitter - a backend-specific thing which feeds data into
diff --git a/modules/gapi/src/executor/gexecutor.cpp b/modules/gapi/src/executor/gexecutor.cpp
@@ -126,13 +126,13 @@ void cv::gimpl::GExecutor::initResource(const ade::NodeHandle &orig_nh)
 class cv::gimpl::GExecutor::Input final: public cv::gimpl::GIslandExecutable::IInput
 {
     cv::gimpl::Mag &mag;
-    virtual cv::GRunArgs get() override
+    virtual StreamMsg get() override
     {
         cv::GRunArgs res;
         for (const auto &rc : desc()) { res.emplace_back(magazine::getArg(mag, rc)); }
-        return res;
+        return StreamMsg{std::move(res)};
     }
-    virtual cv::GRunArgs try_get() override { return get(); }
+    virtual StreamMsg try_get() override { return get(); }
 public:
     Input(cv::gimpl::Mag &m, const std::vector<RcDesc> &rcs) : mag(m) { set(rcs); }
 };
@@ -142,6 +142,7 @@ class cv::gimpl::GExecutor::Output final: public cv::gimpl::GIslandExecutable::I
     cv::gimpl::Mag &mag;
     virtual GRunArgP get(int idx) override { return magazine::getObjPtr(mag, desc()[idx]); }
     virtual void post(GRunArgP&&) override { } // Do nothing here
+    virtual void post(EndOfStream&&) override {} // Do nothing here too
 public:
     Output(cv::gimpl::Mag &m, const std::vector<RcDesc> &rcs) : mag(m) { set(rcs); }
 };
diff --git a/modules/gapi/src/executor/gstreamingexecutor.cpp b/modules/gapi/src/executor/gstreamingexecutor.cpp
diff --git a/modules/gapi/test/internal/gapi_int_proto_tests.cpp b/modules/gapi/test/internal/gapi_int_proto_tests.cpp
diff --git a/modules/gapi/test/streaming/gapi_streaming_tests.cpp b/modules/gapi/test/streaming/gapi_streaming_tests.cpp
