Skip to content

O
opencv
Commit 5e9750d1 authored by Dmitry Matveev's avatar Dmitry Matveev Committed by Alexander Alekhin
Browse files
Options

Merge pull request #12870 from dmatveev:gapi_fluid_basic_hetero_support 

* G-API Fluid basic heterogeneity support: initial upload

* G-API Fluid heterogeneity: address some coding style issues

* G-API Fluid heterogeneity: fix compiler warnings

* G-API Fluid heterogeneity: fix warnings on Windows & ARMv7

* G-API Fluid heterogeneity: finally fix Windows warnings

* G-API Fluid heterogeneity: fix dangling reference problem
parent 2180a676
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 240 additions and 65 deletions
modules/gapi/src/backends/fluid/gfluidbackend.hpp
View file @ 5e9750d1
......@@ -21,7 +21,7 @@ namespace cv { namespace gimpl {
struct FluidUnit
{
static const char *name() { return "FluidKernel"; }
static const char *name() { return "FluidUnit"; }
GFluidKernel k;
gapi::fluid::BorderOpt border;
int border_size;
......@@ -40,11 +40,12 @@ struct FluidData
static const char *name() { return "FluidData"; }
// FIXME: This structure starts looking like "FluidBuffer" meta
int latency = 0;
int skew = 0;
int max_consumption = 1;
int border_size = 0;
int lpi_write = 1;
int latency = 0;
int skew = 0;
int max_consumption = 1;
int border_size = 0;
int lpi_write = 1;
bool internal = false; // is node internal to any fluid island
gapi::fluid::BorderOpt border;
};
......@@ -98,6 +99,7 @@ class GFluidExecutable final: public GIslandExecutable
{
const ade::Graph &m_g;
GModel::ConstGraph m_gm;
const std::vector<ade::NodeHandle> m_nodes;
std::vector<std::unique_ptr<FluidAgent>> m_agents;
std::vector<cv::gapi::fluid::Buffer> m_buffers;
......@@ -117,6 +119,8 @@ class GFluidExecutable final: public GIslandExecutable
void bindOutArg(const RcDesc &rc, const GRunArgP &arg);
void packArg (GArg &in_arg, const GArg &op_arg);
void initBufferRois(std::vector<int>& readStarts, std::vector<cv::gapi::own::Rect>& rois);
public:
GFluidExecutable(const ade::Graph &g,
const std::vector<ade::NodeHandle> &nodes,
......
modules/gapi/src/backends/fluid/gfluidbuffer.cpp
View file @ 5e9750d1
......@@ -20,12 +20,6 @@
namespace cv {
namespace gapi {
//namespace own {
// class Mat;
// CV_EXPORTS cv::GMatDesc descr_of(const Mat &mat);
//}//own
namespace fluid {
bool operator == (const fluid::Border& b1, const fluid::Border& b2)
{
......@@ -503,38 +497,34 @@ fluid::Buffer::Priv::Priv(int read_start, cv::gapi::own::Rect roi)
{}
void fluid::Buffer::Priv::init(const cv::GMatDesc &desc,
int line_consumption,
int border_size,
int skew,
int wlpi,
int readStartPos,
cv::gapi::own::Rect roi)
{
GAPI_Assert(m_line_consumption == -1);
GAPI_Assert(line_consumption > 0);
m_line_consumption = line_consumption;
m_border_size = border_size;
m_skew = skew;
m_writer_lpi = wlpi;
m_desc = desc;
m_readStart = readStartPos;
m_roi = roi;
m_writer_lpi = wlpi;
m_desc = desc;
m_readStart = readStartPos;
m_roi = roi == cv::Rect{} ? cv::Rect{0, 0, desc.size.width, desc.size.height}
: roi;
}
void fluid::Buffer::Priv::allocate(BorderOpt border)
void fluid::Buffer::Priv::allocate(BorderOpt border,
int border_size,
int line_consumption,
int skew)
{
GAPI_Assert(!m_storage);
GAPI_Assert(line_consumption > 0);
// Init physical buffer
// FIXME? combine line_consumption with skew?
auto data_height = std::max(m_line_consumption, m_skew) + m_writer_lpi - 1;
auto data_height = std::max(line_consumption, skew) + m_writer_lpi - 1;
m_storage = createStorage(data_height,
m_desc.size.width,
CV_MAKETYPE(m_desc.depth, m_desc.chan),
m_border_size,
border_size,
border);
// Finally, initialize carets
......@@ -544,9 +534,15 @@ void fluid::Buffer::Priv::allocate(BorderOpt border)
void fluid::Buffer::Priv::bindTo(const cv::gapi::own::Mat &data, bool is_input)
{
// FIXME: move all these fields into a separate structure
GAPI_Assert(m_skew == 0);
GAPI_Assert(m_desc == descr_of(data));
if ( is_input) GAPI_Assert(m_writer_lpi == 1);
// Currently m_writer_lpi is obtained from metadata which is shared between islands
// and this assert can trigger for slot which connects two fluid islands.
// m_writer_lpi is used only in write-related functions and doesn't affect
// buffer which is island's input so it's safe to skip this check.
// FIXME:
// Bring back this check when we move to 1 buffer <-> 1 metadata model
// if (is_input) GAPI_Assert(m_writer_lpi == 1);
m_storage = createStorage(data, m_roi);
......@@ -638,8 +634,8 @@ fluid::Buffer::Buffer(const cv::GMatDesc &desc)
int lineConsumption = 1;
int border = 0, skew = 0, wlpi = 1, readStart = 0;
cv::gapi::own::Rect roi = {0, 0, desc.size.width, desc.size.height};
m_priv->init(desc, lineConsumption, border, skew, wlpi, readStart, roi);
m_priv->allocate({});
m_priv->init(desc, wlpi, readStart, roi);
m_priv->allocate({}, border, lineConsumption, skew);
}
fluid::Buffer::Buffer(const cv::GMatDesc &desc,
......@@ -652,17 +648,16 @@ fluid::Buffer::Buffer(const cv::GMatDesc &desc,
{
int readStart = 0;
cv::gapi::own::Rect roi = {0, 0, desc.size.width, desc.size.height};
m_priv->init(desc, max_line_consumption, border_size, skew, wlpi, readStart, roi);
m_priv->allocate(border);
m_priv->init(desc, wlpi, readStart, roi);
m_priv->allocate(border, border_size, max_line_consumption, skew);
}
fluid::Buffer::Buffer(const cv::gapi::own::Mat &data, bool is_input)
: m_priv(new Priv())
{
int lineConsumption = 1;
int border = 0, skew = 0, wlpi = 1, readStart = 0;
int wlpi = 1, readStart = 0;
cv::gapi::own::Rect roi{0, 0, data.cols, data.rows};
m_priv->init(descr_of(data), lineConsumption, border, skew, wlpi, readStart, roi);
m_priv->init(descr_of(data), wlpi, readStart, roi);
m_priv->bindTo(data, is_input);
}
......
modules/gapi/src/backends/fluid/gfluidbuffer_priv.hpp
View file @ 5e9750d1
......@@ -11,14 +11,8 @@
#include <vector>
#include "opencv2/gapi/fluid/gfluidbuffer.hpp"
#include "opencv2/gapi/own/convert.hpp" // cv::gapi::own::to_ocv
#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
namespace gapi { namespace own {
class Mat;
GAPI_EXPORTS cv::GMatDesc descr_of(const Mat &mat);
}}//gapi::own
namespace cv {
namespace gapi {
namespace fluid {
......@@ -233,9 +227,6 @@ void debugBufferPriv(const Buffer& buffer, std::ostream &os);
// like readDone/writeDone in low-level tests
class GAPI_EXPORTS Buffer::Priv
{
int m_line_consumption = -1;
int m_border_size = -1;
int m_skew = -1;
int m_writer_lpi = 1;
cv::GMatDesc m_desc = cv::GMatDesc{-1,-1,{-1,-1}};
......@@ -262,14 +253,11 @@ public:
// API used by actors/backend
void init(const cv::GMatDesc &desc,
int line_consumption,
int border_size,
int skew,
int wlpi,
int readStart,
cv::gapi::own::Rect roi);
void allocate(BorderOpt border);
void allocate(BorderOpt border, int border_size, int line_consumption, int skew);
void bindTo(const cv::gapi::own::Mat &data, bool is_input);
inline void addView(const View& view) { m_views.push_back(view); }
......
modules/gapi/test/gapi_basic_hetero_tests.cpp
View file @ 5e9750d1
......@@ -31,6 +31,22 @@ namespace
}
};
void FluidFooRow(const uint8_t* in, uint8_t* out, int length)
{
for (int i = 0; i < length; i++)
{
out[i] = in[i] + 3;
}
}
void FluidBarRow(const uint8_t* in1, const uint8_t* in2, uint8_t* out, int length)
{
for (int i = 0; i < length; i++)
{
out[i] = 3*(in1[i] + in2[i]);
}
}
GAPI_FLUID_KERNEL(FFoo, I::Foo, false)
{
static const int Window = 1;
......@@ -38,12 +54,7 @@ namespace
static void run(const cv::gapi::fluid::View &in,
cv::gapi::fluid::Buffer &out)
{
const uint8_t* in_ptr = in.InLine<uint8_t>(0);
uint8_t *out_ptr = out.OutLine<uint8_t>();
for (int i = 0; i < in.length(); i++)
{
out_ptr[i] = in_ptr[i] + 3;
}
FluidFooRow(in.InLineB(0), out.OutLineB(), in.length());
}
};
......@@ -55,15 +66,88 @@ namespace
const cv::gapi::fluid::View &in2,
cv::gapi::fluid::Buffer &out)
{
const uint8_t* in1_ptr = in1.InLine<uint8_t>(0);
const uint8_t* in2_ptr = in2.InLine<uint8_t>(0);
uint8_t *out_ptr = out.OutLine<uint8_t>();
for (int i = 0; i < in1.length(); i++)
FluidBarRow(in1.InLineB(0), in2.InLineB(0), out.OutLineB(), in1.length());
}
};
G_TYPED_KERNEL(FluidFooI, <cv::GMat(cv::GMat)>, "test.kernels.fluid_foo")
{
static cv::GMatDesc outMeta(const cv::GMatDesc &in) { return in; }
};
G_TYPED_KERNEL(FluidBarI, <cv::GMat(cv::GMat,cv::GMat)>, "test.kernels.fluid_bar")
{
static cv::GMatDesc outMeta(const cv::GMatDesc &in, const cv::GMatDesc &) { return in; }
};
GAPI_FLUID_KERNEL(FluidFoo, FluidFooI, false)
{
static const int Window = 1;
static void run(const cv::gapi::fluid::View &in,
cv::gapi::fluid::Buffer &out)
{
FluidFooRow(in.InLineB(0), out.OutLineB(), in.length());
}
};
GAPI_FLUID_KERNEL(FluidBar, FluidBarI, false)
{
static const int Window = 1;
static void run(const cv::gapi::fluid::View &in1,
const cv::gapi::fluid::View &in2,
cv::gapi::fluid::Buffer &out)
{
FluidBarRow(in1.InLineB(0), in2.InLineB(0), out.OutLineB(), in1.length());
}
};
GAPI_FLUID_KERNEL(FluidFoo2lpi, FluidFooI, false)
{
static const int Window = 1;
static const int LPI = 2;
static void run(const cv::gapi::fluid::View &in,
cv::gapi::fluid::Buffer &out)
{
for (int l = 0; l < out.lpi(); l++)
{
out_ptr[i] = 3*(in1_ptr[i] + in2_ptr[i]);
FluidFooRow(in.InLineB(l), out.OutLineB(l), in.length());
}
}
};
cv::Mat ocvFoo(const cv::Mat &in)
{
cv::Mat out;
OCVFoo::run(in, out);
return out;
}
cv::Mat ocvBar(const cv::Mat &in1, const cv::Mat &in2)
{
cv::Mat out;
OCVBar::run(in1, in2, out);
return out;
}
cv::Mat fluidFoo(const cv::Mat &in)
{
cv::Mat out(in.rows, in.cols, in.type());
for (int y = 0; y < in.rows; y++)
{
FluidFooRow(in.ptr(y), out.ptr(y), in.cols);
}
return out;
}
cv::Mat fluidBar(const cv::Mat &in1, const cv::Mat &in2)
{
cv::Mat out(in1.rows, in1.cols, in1.type());
for (int y = 0; y < in1.rows; y++)
{
FluidBarRow(in1.ptr(y), in2.ptr(y), out.ptr(y), in1.cols);
}
return out;
}
} // anonymous namespace
struct GAPIHeteroTest: public ::testing::Test
......@@ -98,7 +182,7 @@ TEST_F(GAPIHeteroTest, TestOCV)
EXPECT_TRUE(cv::gapi::cpu::backend() == m_ocv_kernels.lookup<I::Foo>());
EXPECT_TRUE(cv::gapi::cpu::backend() == m_ocv_kernels.lookup<I::Bar>());
cv::Mat ref = 4*(m_in_mat+2 + m_in_mat+2);
cv::Mat ref = ocvBar(ocvFoo(m_in_mat), ocvFoo(m_in_mat));
EXPECT_NO_THROW(m_comp.apply(m_in_mat, m_out_mat, cv::compile_args(m_ocv_kernels)));
EXPECT_EQ(0, cv::countNonZero(ref != m_out_mat));
}
......@@ -108,17 +192,121 @@ TEST_F(GAPIHeteroTest, TestFluid)
EXPECT_TRUE(cv::gapi::fluid::backend() == m_fluid_kernels.lookup<I::Foo>());
EXPECT_TRUE(cv::gapi::fluid::backend() == m_fluid_kernels.lookup<I::Bar>());
cv::Mat ref = 3*(m_in_mat+3 + m_in_mat+3);
cv::Mat ref = fluidBar(fluidFoo(m_in_mat), fluidFoo(m_in_mat));
EXPECT_NO_THROW(m_comp.apply(m_in_mat, m_out_mat, cv::compile_args(m_fluid_kernels)));
EXPECT_EQ(0, cv::countNonZero(ref != m_out_mat));
}
TEST_F(GAPIHeteroTest, TestBoth_ExpectFailure)
TEST_F(GAPIHeteroTest, TestBoth)
{
EXPECT_TRUE(cv::gapi::cpu::backend() == m_hetero_kernels.lookup<I::Foo>());
EXPECT_TRUE(cv::gapi::fluid::backend() == m_hetero_kernels.lookup<I::Bar>());
EXPECT_ANY_THROW(m_comp.apply(m_in_mat, m_out_mat, cv::compile_args(m_hetero_kernels)));
cv::Mat ref = fluidBar(ocvFoo(m_in_mat), ocvFoo(m_in_mat));
EXPECT_NO_THROW(m_comp.apply(m_in_mat, m_out_mat, cv::compile_args(m_hetero_kernels)));
EXPECT_EQ(0, cv::countNonZero(ref != m_out_mat));
}
struct GAPIBigHeteroTest : public ::testing::TestWithParam<std::array<int, 9>>
{
cv::GComputation m_comp;
cv::gapi::GKernelPackage m_kernels;
cv::Mat m_in_mat;
cv::Mat m_out_mat1;
cv::Mat m_out_mat2;
cv::Mat m_ref_mat1;
cv::Mat m_ref_mat2;
GAPIBigHeteroTest();
};
// Foo7
// .-> Foo2 -> Foo3 -<
// Foo0 -> Foo1 Bar -> Foo6
// `-> Foo4 -> Foo5 -`
GAPIBigHeteroTest::GAPIBigHeteroTest()
: m_comp([&](){
auto flags = GetParam();
std::array<std::function<cv::GMat(cv::GMat)>, 8> foos;
for (int i = 0; i < 8; i++)
{
foos[i] = flags[i] ? &I::Foo::on : &FluidFooI::on;
}
auto bar = flags[8] ? &I::Bar::on : &FluidBarI::on;
cv::GMat in;
auto foo1Out = foos[1](foos[0](in));
auto foo3Out = foos[3](foos[2](foo1Out));
auto foo6Out = foos[6](bar(foo3Out,
foos[5](foos[4](foo1Out))));
auto foo7Out = foos[7](foo3Out);
return cv::GComputation(GIn(in), GOut(foo6Out, foo7Out));
})
, m_kernels(cv::gapi::kernels<OCVFoo, OCVBar, FluidFoo, FluidBar>())
, m_in_mat(cv::Mat::eye(cv::Size(64, 64), CV_8UC1))
{
auto flags = GetParam();
std::array<std::function<cv::Mat(cv::Mat)>, 8> foos;
for (int i = 0; i < 8; i++)
{
foos[i] = flags[i] ? ocvFoo : fluidFoo;
}
auto bar = flags[8] ? ocvBar : fluidBar;
cv::Mat foo1OutMat = foos[1](foos[0](m_in_mat));
cv::Mat foo3OutMat = foos[3](foos[2](foo1OutMat));
m_ref_mat1 = foos[6](bar(foo3OutMat,
foos[5](foos[4](foo1OutMat))));
m_ref_mat2 = foos[7](foo3OutMat);
}
TEST_P(GAPIBigHeteroTest, Test)
{
EXPECT_NO_THROW(m_comp.apply(gin(m_in_mat), gout(m_out_mat1, m_out_mat2), cv::compile_args(m_kernels)));
EXPECT_EQ(0, cv::countNonZero(m_ref_mat1 != m_out_mat1));
EXPECT_EQ(0, cv::countNonZero(m_ref_mat2 != m_out_mat2));
}
static auto configurations = []()
{
// Fill all possible configurations
// from 000000000 to 111111111
std::array<std::array<int, 9>, 512> arr;
for (auto n = 0; n < 512; n++)
{
for (auto i = 0; i < 9; i++)
{
arr[n][i] = (n >> (8 - i)) & 1;
}
}
return arr;
}();
INSTANTIATE_TEST_CASE_P(GAPIBigHeteroTest, GAPIBigHeteroTest,
::testing::ValuesIn(configurations));
TEST(GAPIHeteroTestLPI, Test)
{
cv::GMat in;
auto mid = FluidFooI::on(in);
auto out = FluidFooI::on(mid);
cv::gapi::island("isl0", GIn(in), GOut(mid));
cv::gapi::island("isl1", GIn(mid), GOut(out));
cv::GComputation c(in, out);
cv::Mat in_mat = cv::Mat::eye(cv::Size(64, 64), CV_8UC1);
cv::Mat out_mat;
EXPECT_NO_THROW(c.apply(in_mat, out_mat, cv::compile_args(cv::gapi::kernels<FluidFoo2lpi>())));
cv::Mat ref = fluidFoo(fluidFoo(in_mat));
EXPECT_EQ(0, cv::countNonZero(ref != out_mat));
}
} // namespace opencv_test
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment