Merge pull request #17020 from dbudniko:dbudniko/serialization_backend

G-API Serialization routines

* Serialization backend in tests, initial version

* S11N/00: A Great Rename

- "Serialization" is too long and too error-prone to type,
  so now it is renamed to "s11n" everywhere;
- Same applies to "SRLZ";
- Tests also renamed to start with 'S11N.*' (easier to run);
- Also updated copyright years in new files to 2020.

* S11N/01: Some basic interface segregation

- Moved some details (low-level functions) out of serialization.hpp;
- Introduced I::IStream and I::OStream interfaces;
- Implemented those via the existing [De]SerializationStream classes;
- Moved all operators to use interfaces instead of classes;
- Moved the htonl/ntohl handling out of operators (to the classes).

The implementation didn't change much, it is a subject to the further
refactoring

* S11N/02: Basic operator reorg, basic tests, vector support

- Reorganized operators on atomic types to follow >>/<< model
  (put them closer in the code for the respective types);
- Introduce more operators for basic (scalar) types;
- Drop all vector s11n overloads -- replace with a generic
  (template-based) one;
- Introduced a new test suite where low-level s11n functionality
  is tested (for the basic types).

* S11N/03: Operators reorganization

- Sorted the Opaque types enum by complexity;
- Reorganized the existing operators for basic types, also ordered by
  complexity;
- Organized operators in three groups (Basics, OpenCV, G-API);
- Added a generic serialization for variant<>;
- Reimplemented some of the existing operators (for OpenCV and G-API
  data structures);
- Introduced new operators for cv::gimpl data types. These operators
  (and so, the data structures) are not yet used in the graph
  dump/reconstruction routine, it will be done as a next step.

* S11N/04: The Great Clean-up

- Drop the duplicates of GModel data structures from the
  serialization, serialize the GModel data structures themselve
  instead (hand-written code replaced with operators).
- Also removed usuned code for printing, etc.

* S11N/05: Internal API Clean-up

- Minimize the serialization API to just Streams and Operators;
- Refactor and fix the graph serialization (deconstruction and
  reconstruction) routines, fix data addressing problems there;
- Move the serialization.[ch]pp files to the core G-API library

* S11N/06: Top-level API introduction

- !!!This is likely the most invasive commit in the series!!!
- Introduced a top-level API to serialize and deserialize a GComputation
- Extended the compiler to support both forms of a GComputation:
  an expession based and a deserialized one. This has led to changes in
  the cv::GComputation::Priv and in its dependent components (even the
  transformation tests);
- Had to extend the kernel API (GKernel) with extra information on
  operations (mainly `outMeta`) which was only available for expression
  based graphs. Now the `outMeta` can be taken from kernels too (and for
  the deserialized graphs it is the only way);
- Revisited the internal serialization API, had to expose previously
  hidden entities (like `GSerialized`);
- Extended the serialized graph info with new details (object counter,
  protocol). Added unordered_map generic serialization for that;
- Reworked the very first pipeline test to be "proper"; GREEN now, the rest
  is to be reworked in the next iteration.

* S11N/07: Tests reworked

- Moved the sample pipeline tests w/serialization to
  test the public API (`cv::gapi::serialize`, then
  followed by `cv::gapi::deserialize<>`). All GREEN.
- As a consequence, dropped the "Serialization" test
  backend as no longer necessary.

* S11N/08: Final touches

- Exposed the C++ native data types at Streams level;
- Switched the ByteMemoryIn/OutStreams to store data in `char`
  internally (2x less memory for sample pipelines);
- Fixed and refactored Mat dumping to the stream;
- Renamed S11N pipeline tests to their new meaning.

* linux build fix

* fix RcDesc and int uint warnings

* more Linux build fix

* white space and virtual android error fix (attempt)

* more warnings to be fixed

* android warnings fix attempt

* one more attempt for android build fix

* android warnings one more fix

* return back override

* avoid size_t

* static deserialize

* and how do you like this, elon? anonymous namespace  to fix android warning.

* static inline

* trying to fix standalone build

* mat dims fix

* fix mat r/w for standalone

Co-authored-by: Dmitry Matveev <dmitry.matveev@intel.com>

modules/gapi/src/api/gcomputation.cpp

@@ -56,19 +56,38 @@ cv::GComputation::GComputation(const std::vector<GMat> &ins,
                                const std::vector<GMat> &outs)
     : m_priv(new Priv())
 {
+    Priv::Expr e;
     const auto wrap = [](cv::GMat m) { return GProtoArg(m); };
-    ade::util::transform(ins,  std::back_inserter(m_priv->m_ins),  wrap);
-    ade::util::transform(outs, std::back_inserter(m_priv->m_outs), wrap);
+    ade::util::transform(ins,  std::back_inserter(e.m_ins),  wrap);
+    ade::util::transform(outs, std::back_inserter(e.m_outs), wrap);
+    m_priv->m_shape = std::move(e);
 }
 
 cv::GComputation::GComputation(cv::GProtoInputArgs &&ins,
                                cv::GProtoOutputArgs &&outs)
     : m_priv(new Priv())
 {
-    m_priv->m_ins  = std::move(ins.m_args);
-    m_priv->m_outs = std::move(outs.m_args);
+    m_priv->m_shape = Priv::Expr{
+          std::move(ins.m_args)
+        , std::move(outs.m_args)
+    };
 }
 
+cv::GComputation::GComputation(cv::gimpl::s11n::I::IStream &is)
+    : m_priv(new Priv())
+{
+    m_priv->m_shape = gimpl::s11n::deserialize(is);
+}
+
+void cv::GComputation::serialize(cv::gimpl::s11n::I::OStream &os) const
+{
+    // Build a basic GModel and write the whole thing to the stream
+    auto pG = cv::gimpl::GCompiler::makeGraph(*m_priv);
+    std::vector<ade::NodeHandle> nhs(pG->nodes().begin(), pG->nodes().end());
+    gimpl::s11n::serialize(os, *pG, nhs);
+}
+
+
 cv::GCompiled cv::GComputation::compile(GMetaArgs &&metas, GCompileArgs &&args)
 {
     // FIXME: Cache gcompiled per parameters here?

modules/gapi/src/api/gcomputation_priv.hpp

@@ -8,20 +8,37 @@
 #ifndef OPENCV_GAPI_GCOMPUTATION_PRIV_HPP
 #define OPENCV_GAPI_GCOMPUTATION_PRIV_HPP
 
+#include <ade/graph.hpp>
+
+#include "opencv2/gapi/util/variant.hpp"
+
 #include "opencv2/gapi.hpp"
 #include "opencv2/gapi/gcall.hpp"
 
 #include "opencv2/gapi/util/variant.hpp"
 
+#include "backends/common/serialization.hpp"
+
 namespace cv {
 
 class GComputation::Priv
 {
 public:
+    struct Expr {
+        cv::GProtoArgs m_ins;
+        cv::GProtoArgs m_outs;
+    };
+
+    using Dump = cv::gimpl::s11n::GSerialized;
+
+    using Shape = cv::util::variant
+        < Expr    // An expression-based graph
+        , Dump    // A deserialized graph
+        >;
+
     GCompiled   m_lastCompiled;
     GMetaArgs   m_lastMetas; // TODO: make GCompiled remember its metas?
-    GProtoArgs  m_ins;
-    GProtoArgs  m_outs;
+    Shape       m_shape;
 };
 
 }

modules/gapi/src/api/s11n.cpp

@@ -0,0 +1,20 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2020 Intel Corporation
+
+#include <opencv2/gapi/s11n.hpp>
+
+#include "backends/common/serialization.hpp"
+
+std::vector<char> cv::gapi::serialize(const cv::GComputation &c) {
+    cv::gimpl::s11n::ByteMemoryOutStream os;
+    c.serialize(os);
+    return os.data();
+}
+
+cv::GComputation cv::gapi::detail::getGraph(const std::vector<char> &p) {
+    cv::gimpl::s11n::ByteMemoryInStream is(p);
+    return cv::GComputation(is);
+}