Merge pull request #12142 from alalek:dnn_ocl_fix_convolution_perf_tests

modules/dnn/perf/opencl/perf_convolution.cpp

-#include "../perf_precomp.hpp"
-#include "opencv2/ts/ocl_perf.hpp"
-#include <opencv2/dnn/shape_utils.hpp>
-
-#ifdef HAVE_OPENCL
-
-namespace opencv_test { namespace ocl {
-using namespace ::perf;
-
-namespace {
-enum {STRIDE_OFF = 1, STRIDE_ON = 2};
-CV_ENUM(StrideSize, STRIDE_OFF, STRIDE_ON);
-
-enum {GROUP_OFF = 1, GROUP_2 = 2};
-CV_ENUM(GroupSize, GROUP_OFF, GROUP_2);
-} // namespace
-
-//Squared Size
-#define SSZ(n) cv::Size(n, n)
-
-typedef std::pair<MatShape, int> InpShapeNumOut;
-typedef tuple<Size, InpShapeNumOut, GroupSize, StrideSize> ConvParam; //kernel_size, inp shape, groups, stride
-typedef TestBaseWithParam<ConvParam> ConvolutionPerfTest;
-
-static inline MatShape blobShape(int count, int nplanes, int height, int width)
-{
-    int data[] = {count, nplanes, height, width};
-    return MatShape(data, data+4);
-}
-
-OCL_PERF_TEST_P( ConvolutionPerfTest, perf, Combine(
-    Values(Size(1, 1), Size(3, 3), Size(5, 5), Size(11, 11)),
-    Values(make_pair(blobShape(1,   4, 224, 224),  64),
-           make_pair(blobShape(1,  64, 112, 122), 128),
-           make_pair(blobShape(1, 256,  28,  28), 512)),
-    GroupSize::all(),
-    StrideSize::all())
-)
-{
-    RNG rng(0);
-
-    ConvParam params = GetParam();
-    int ksz     = get<0>(params).width;
-    MatShape inpShape = get<1>(params).first;
-    int outCn   = get<1>(params).second;
-    int groups  = get<2>(params);
-    int stride  = (ksz >= 11) ? 4 : (int)get<3>(params);
-
-    int inpCn = inpShape[1];
-    int wgtSize[] = { outCn, inpCn/groups, ksz, ksz };
-    int biasSize[] = { outCn, 1, 1, 1 };
-    const int wtype = CV_32F;
-    Mat wgtBlob(4, wgtSize, wtype), biasBlob(4, biasSize, wtype);
-    Mat inpBlob(4, &inpShape[0], wtype);
-    rng.fill(biasBlob, RNG::UNIFORM, -1, +1);
-    rng.fill(wgtBlob, RNG::UNIFORM, -1, +1);
-    rng.fill(inpBlob, RNG::UNIFORM, -1, +1);
-
-    LayerParams lp;
-    lp.set("num_output", outCn);
-    lp.set("group", groups);
-    lp.set("stride", stride);
-    lp.set("kernel_size", ksz);
-    lp.blobs.reserve(2);
-    lp.blobs.push_back(wgtBlob);
-    lp.blobs.push_back(biasBlob);
-
-    std::vector<Mat*> inpBlobs(1, &inpBlob);
-    std::vector<Mat> outBlobs, internalBlobs;
-
-    Ptr<Layer> layer = cv::dnn::LayerFactory::createLayerInstance("Convolution", lp);
-    std::vector<MatShape> inputShapes(1, shape(inpBlob)), outShapes, internals;
-    layer->getMemoryShapes(inputShapes, 0, outShapes, internals);
-    for (size_t i = 0; i < outShapes.size(); i++)
-    {
-        outBlobs.push_back(Mat(outShapes[i], CV_32F));
-    }
-    for (size_t i = 0; i < internals.size(); i++)
-    {
-        internalBlobs.push_back(Mat());
-        if (total(internals[i]))
-            internalBlobs.back().create(internals[i], CV_32F);
-    }
-
-    layer->finalize(inpBlobs, outBlobs);
-    layer->preferableTarget = DNN_TARGET_OPENCL;
-
-    Mat inpBlob2D = inpBlob.reshape(1, outCn);
-    Mat wgtBlob2D = wgtBlob.reshape(1, outCn*(inpCn/groups));
-    Mat outBlob2D = outBlobs[0].reshape(1, outBlobs[0].size[0]);
-    declare.in(inpBlob2D, wgtBlob2D, WARMUP_RNG).out(outBlob2D);
-
-    // warmup
-    layer->forward(inpBlobs, outBlobs, internalBlobs);
-
-    TEST_CYCLE()
-    {
-        layer->forward(inpBlobs, outBlobs, internalBlobs);
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-}
-}
-
-#endif

modules/dnn/perf/perf_net.cpp

@@ -14,10 +14,7 @@
 
 namespace opencv_test {
 
-CV_ENUM(DNNBackend, DNN_BACKEND_DEFAULT, DNN_BACKEND_HALIDE, DNN_BACKEND_INFERENCE_ENGINE, DNN_BACKEND_OPENCV)
-CV_ENUM(DNNTarget, DNN_TARGET_CPU, DNN_TARGET_OPENCL, DNN_TARGET_OPENCL_FP16, DNN_TARGET_MYRIAD)
-
-class DNNTestNetwork : public ::perf::TestBaseWithParam< tuple<DNNBackend, DNNTarget> >
+class DNNTestNetwork : public ::perf::TestBaseWithParam< tuple<Backend, Target> >
 {
 public:
     dnn::Backend backend;
@@ -269,22 +266,6 @@ PERF_TEST_P_(DNNTestNetwork, Inception_v2_Faster_RCNN)
                Mat(cv::Size(800, 600), CV_32FC3));
 }
 
-const tuple<DNNBackend, DNNTarget> testCases[] = {
-#ifdef HAVE_HALIDE
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_HALIDE, DNN_TARGET_CPU),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_HALIDE, DNN_TARGET_OPENCL),
-#endif
-#ifdef HAVE_INF_ENGINE
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_CPU),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL_FP16),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_MYRIAD),
-#endif
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_OPENCV, DNN_TARGET_CPU),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL),
-    tuple<DNNBackend, DNNTarget>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16)
-};
-
-INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, testing::ValuesIn(testCases));
+INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, dnnBackendsAndTargets());
 
 } // namespace

modules/dnn/perf/perf_precomp.hpp

@@ -4,6 +4,8 @@
 #include <opencv2/ts.hpp>
 #include <opencv2/dnn.hpp>
 
+#include "../test/test_common.hpp"
+
 namespace opencv_test {
 using namespace perf;
 using namespace cv::dnn;

modules/dnn/test/test_backends.cpp

@@ -285,21 +285,6 @@ TEST_P(DNNTestNetwork, FastNeuralStyle_eccv16)
     processNet("dnn/fast_neural_style_eccv16_starry_night.t7", "", inp, "", "", l1, lInf);
 }
 
-const tuple<Backend, Target> testCases[] = {
-#ifdef HAVE_HALIDE
-    tuple<Backend, Target>(DNN_BACKEND_HALIDE, DNN_TARGET_CPU),
-    tuple<Backend, Target>(DNN_BACKEND_HALIDE, DNN_TARGET_OPENCL),
-#endif
-#ifdef HAVE_INF_ENGINE
-    tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_CPU),
-    tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL),
-    tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL_FP16),
-    tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_MYRIAD),
-#endif
-    tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL),
-    tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16)
-};
-
-INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, testing::ValuesIn(testCases));
+INSTANTIATE_TEST_CASE_P(/*nothing*/, DNNTestNetwork, dnnBackendsAndTargets(true, true, false));
 
 }} // namespace

modules/dnn/test/test_common.hpp

@@ -42,6 +42,47 @@
 #ifndef __OPENCV_TEST_COMMON_HPP__
 #define __OPENCV_TEST_COMMON_HPP__
 
+#ifdef HAVE_OPENCL
+#include "opencv2/core/ocl.hpp"
+#endif
+
+namespace cv { namespace dnn {
+CV__DNN_EXPERIMENTAL_NS_BEGIN
+static inline void PrintTo(const cv::dnn::Backend& v, std::ostream* os)
+{
+    switch (v) {
+    case DNN_BACKEND_DEFAULT: *os << "DEFAULT"; return;
+    case DNN_BACKEND_HALIDE: *os << "HALIDE"; return;
+    case DNN_BACKEND_INFERENCE_ENGINE: *os << "DLIE"; return;
+    case DNN_BACKEND_OPENCV: *os << "OCV"; return;
+    } // don't use "default:" to emit compiler warnings
+    *os << "DNN_BACKEND_UNKNOWN(" << v << ")";
+}
+
+static inline void PrintTo(const cv::dnn::Target& v, std::ostream* os)
+{
+    switch (v) {
+    case DNN_TARGET_CPU: *os << "CPU"; return;
+    case DNN_TARGET_OPENCL: *os << "OCL"; return;
+    case DNN_TARGET_OPENCL_FP16: *os << "OCL_FP16"; return;
+    case DNN_TARGET_MYRIAD: *os << "MYRIAD"; return;
+    } // don't use "default:" to emit compiler warnings
+    *os << "DNN_TARGET_UNKNOWN(" << v << ")";
+}
+
+using opencv_test::tuple;
+using opencv_test::get;
+static inline void PrintTo(const tuple<cv::dnn::Backend, cv::dnn::Target> v, std::ostream* os)
+{
+    PrintTo(get<0>(v), os);
+    *os << "/";
+    PrintTo(get<1>(v), os);
+}
+
+CV__DNN_EXPERIMENTAL_NS_END
+}} // namespace
+
+
 static inline const std::string &getOpenCVExtraDir()
 {
     return cvtest::TS::ptr()->get_data_path();
@@ -190,4 +231,50 @@ static inline bool readFileInMemory(const std::string& filename, std::string& co
     return true;
 }
 
+namespace opencv_test {
+
+using namespace cv::dnn;
+
+static testing::internal::ParamGenerator<tuple<Backend, Target> > dnnBackendsAndTargets(
+        bool withInferenceEngine = true,
+        bool withHalide = false,
+        bool withCpuOCV = true
+)
+{
+    std::vector<tuple<Backend, Target> > targets;
+#ifdef HAVE_HALIDE
+    if (withHalide)
+    {
+        targets.push_back(make_tuple(DNN_BACKEND_HALIDE, DNN_TARGET_CPU));
+        if (cv::ocl::useOpenCL())
+            targets.push_back(make_tuple(DNN_BACKEND_HALIDE, DNN_TARGET_OPENCL));
+    }
+#endif
+#ifdef HAVE_INF_ENGINE
+    if (withInferenceEngine)
+    {
+        targets.push_back(make_tuple(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_CPU));
+        if (cv::ocl::useOpenCL())
+        {
+            targets.push_back(make_tuple(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL));
+            targets.push_back(make_tuple(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL_FP16));
+        }
+        if (checkMyriadTarget())
+            targets.push_back(make_tuple(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_MYRIAD));
+    }
+#endif
+    if (withCpuOCV)
+        targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_CPU));
+#ifdef HAVE_OPENCL
+    if (cv::ocl::useOpenCL())
+    {
+        targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL));
+        targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16));
+    }
+#endif
+    return testing::ValuesIn(targets);
+}
+
+} // namespace
+
 #endif

modules/dnn/test/test_halide_layers.cpp

@@ -44,23 +44,9 @@ static void test(LayerParams& params, Mat& input, Backend backendId, Target targ
     test(input, net, backendId, targetId, skipCheck);
 }
 
-static testing::internal::ParamGenerator<tuple<Backend, Target> > dnnBackendsAndTargetsWithHalide()
+static inline testing::internal::ParamGenerator<tuple<Backend, Target> > dnnBackendsAndTargetsWithHalide()
 {
-    static const tuple<Backend, Target> testCases[] = {
-#ifdef HAVE_HALIDE
-        tuple<Backend, Target>(DNN_BACKEND_HALIDE, DNN_TARGET_CPU),
-        tuple<Backend, Target>(DNN_BACKEND_HALIDE, DNN_TARGET_OPENCL),
-#endif
-#ifdef HAVE_INF_ENGINE
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_CPU),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL_FP16),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_MYRIAD),
-#endif
-        tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL),
-        tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16)
-    };
-    return testing::ValuesIn(testCases);
+    return dnnBackendsAndTargets(true, true, false); // OpenCV/CPU is used as reference
 }
 
 class Test_Halide_layers : public DNNTestLayer {};

modules/dnn/test/test_precomp.hpp

@@ -49,35 +49,6 @@
 #include "opencv2/dnn.hpp"
 #include "test_common.hpp"
 
-namespace cv {
-namespace dnn {
-CV__DNN_EXPERIMENTAL_NS_BEGIN
-
-static inline void PrintTo(const cv::dnn::Backend& v, std::ostream* os)
-{
-    switch (v) {
-    case DNN_BACKEND_DEFAULT: *os << "DNN_BACKEND_DEFAULT"; return;
-    case DNN_BACKEND_HALIDE: *os << "DNN_BACKEND_HALIDE"; return;
-    case DNN_BACKEND_INFERENCE_ENGINE: *os << "DNN_BACKEND_INFERENCE_ENGINE"; return;
-    case DNN_BACKEND_OPENCV: *os << "DNN_BACKEND_OPENCV"; return;
-    } // don't use "default:" to emit compiler warnings
-    *os << "DNN_BACKEND_UNKNOWN(" << v << ")";
-}
-
-static inline void PrintTo(const cv::dnn::Target& v, std::ostream* os)
-{
-    switch (v) {
-    case DNN_TARGET_CPU: *os << "DNN_TARGET_CPU"; return;
-    case DNN_TARGET_OPENCL: *os << "DNN_TARGET_OPENCL"; return;
-    case DNN_TARGET_OPENCL_FP16: *os << "DNN_TARGET_OPENCL_FP16"; return;
-    case DNN_TARGET_MYRIAD: *os << "DNN_TARGET_MYRIAD"; return;
-    } // don't use "default:" to emit compiler warnings
-    *os << "DNN_TARGET_UNKNOWN(" << v << ")";
-}
-
-CV__DNN_EXPERIMENTAL_NS_END
-}} // namespace
-
 namespace opencv_test {
 using namespace cv::dnn;
 
@@ -95,22 +66,6 @@ static testing::internal::ParamGenerator<Target> availableDnnTargets()
     return testing::ValuesIn(targets);
 }
 
-static testing::internal::ParamGenerator<tuple<Backend, Target> > dnnBackendsAndTargets()
-{
-    static const tuple<Backend, Target> testCases[] = {
-    #ifdef HAVE_INF_ENGINE
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_CPU),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_OPENCL_FP16),
-        tuple<Backend, Target>(DNN_BACKEND_INFERENCE_ENGINE, DNN_TARGET_MYRIAD),
-    #endif
-        tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_CPU),
-        tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL),
-        tuple<Backend, Target>(DNN_BACKEND_OPENCV, DNN_TARGET_OPENCL_FP16)
-    };
-    return testing::ValuesIn(testCases);
-}
-
 class DNNTestLayer : public TestWithParam<tuple<Backend, Target> >
 {
 public: