Merge pull request #1984 from ilya-lavrenov:tapi_perf

modules/core/perf/opencl/perf_arithm.cpp

@@ -47,13 +47,81 @@
 namespace cvtest {
 namespace ocl {
 
+///////////// Lut ////////////////////////
+
+typedef Size_MatType LUTFixture;
+
+OCL_PERF_TEST_P(LUTFixture, LUT,
+          ::testing::Combine(OCL_TEST_SIZES,
+                             OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params), cn = CV_MAT_CN(type);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, CV_8UC(cn)), lut(1, 256, type);
+    int dstType = CV_MAKETYPE(lut.depth(), src.channels());
+    UMat dst(srcSize, dstType);
+
+    declare.in(src, lut, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::LUT(src, lut, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Exp ////////////////////////
+
+typedef Size_MatType ExpFixture;
+
+OCL_PERF_TEST_P(ExpFixture, Exp, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    declare.in(src).out(dst);
+    randu(src, 5, 16);
+
+    OCL_TEST_CYCLE() cv::exp(src, dst);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+///////////// Log ////////////////////////
+
+typedef Size_MatType LogFixture;
+
+OCL_PERF_TEST_P(LogFixture, Log, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    randu(src, 1, 10000);
+    declare.in(src).out(dst);
+
+    OCL_TEST_CYCLE() cv::log(src, dst);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
 ///////////// Add ////////////////////////
 
 typedef Size_MatType AddFixture;
 
 OCL_PERF_TEST_P(AddFixture, Add,
-            ::testing::Combine(OCL_TEST_SIZES,
-                               OCL_TEST_TYPES))
+                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
 {
     const Size srcSize = GET_PARAM(0);
     const int type = GET_PARAM(1);
@@ -61,15 +129,583 @@ OCL_PERF_TEST_P(AddFixture, Add,
     checkDeviceMaxMemoryAllocSize(srcSize, type);
 
     UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
-    randu(src1);
-    randu(src2);
-    declare.in(src1, src2).out(dst);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
 
     OCL_TEST_CYCLE() cv::add(src1, src2, dst);
 
     SANITY_CHECK(dst);
 }
 
+///////////// Subtract ////////////////////////
+
+typedef Size_MatType SubtractFixture;
+
+OCL_PERF_TEST_P(SubtractFixture, Subtract,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::subtract(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Mul ////////////////////////
+
+typedef Size_MatType MulFixture;
+
+OCL_PERF_TEST_P(MulFixture, Multiply, ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::multiply(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Div ////////////////////////
+
+typedef Size_MatType DivFixture;
+
+OCL_PERF_TEST_P(DivFixture, Divide,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::divide(src1, src2, dst);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+///////////// Absdiff ////////////////////////
+
+typedef Size_MatType AbsDiffFixture;
+
+OCL_PERF_TEST_P(AbsDiffFixture, Absdiff,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).in(dst);
+
+    OCL_TEST_CYCLE() cv::absdiff(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// CartToPolar ////////////////////////
+
+typedef Size_MatType CartToPolarFixture;
+
+OCL_PERF_TEST_P(CartToPolarFixture, CartToPolar, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type),
+            dst1(srcSize, type), dst2(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst1, dst2);
+
+    OCL_TEST_CYCLE() cv::cartToPolar(src1, src2, dst1, dst2);
+
+    SANITY_CHECK(dst1, 8e-3);
+    SANITY_CHECK(dst2, 8e-3);
+}
+
+///////////// PolarToCart ////////////////////////
+
+typedef Size_MatType PolarToCartFixture;
+
+OCL_PERF_TEST_P(PolarToCartFixture, PolarToCart, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type),
+            dst1(srcSize, type), dst2(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst1, dst2);
+
+    OCL_TEST_CYCLE() cv::polarToCart(src1, src2, dst1, dst2);
+
+    SANITY_CHECK(dst1, 5e-5);
+    SANITY_CHECK(dst2, 5e-5);
+}
+
+///////////// Magnitude ////////////////////////
+
+typedef Size_MatType MagnitudeFixture;
+
+OCL_PERF_TEST_P(MagnitudeFixture, Magnitude, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type),
+            dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::magnitude(src1, src2, dst);
+
+    SANITY_CHECK(dst, 1e-6);
+}
+
+///////////// Transpose ////////////////////////
+
+typedef Size_MatType TransposeFixture;
+
+OCL_PERF_TEST_P(TransposeFixture, Transpose, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::transpose(src, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Flip ////////////////////////
+
+enum
+{
+    FLIP_BOTH = 0, FLIP_ROWS, FLIP_COLS
+};
+
+CV_ENUM(FlipType, FLIP_BOTH, FLIP_ROWS, FLIP_COLS)
+
+typedef std::tr1::tuple<Size, MatType, FlipType> FlipParams;
+typedef TestBaseWithParam<FlipParams> FlipFixture;
+
+OCL_PERF_TEST_P(FlipFixture, Flip,
+            ::testing::Combine(OCL_TEST_SIZES,
+                               OCL_TEST_TYPES, FlipType::all()))
+{
+    const FlipParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    const int flipType = get<2>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::flip(src, dst, flipType - 1);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// minMaxLoc ////////////////////////
+
+typedef Size_MatType MinMaxLocFixture;
+
+OCL_PERF_TEST_P(MinMaxLocFixture, MinMaxLoc,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    bool onecn = CV_MAT_CN(type) == 1;
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type);;
+    declare.in(src, WARMUP_RNG);
+
+    double min_val = 0.0, max_val = 0.0;
+    Point min_loc, max_loc;
+
+    OCL_TEST_CYCLE() cv::minMaxLoc(src, &min_val, &max_val, onecn ? &min_loc : NULL,
+                                   onecn ? &max_loc : NULL);
+
+    ASSERT_GE(max_val, min_val);
+    SANITY_CHECK(min_val);
+    SANITY_CHECK(max_val);
+
+    int min_loc_x = min_loc.x, min_loc_y = min_loc.y, max_loc_x = max_loc.x,
+            max_loc_y = max_loc.y;
+    SANITY_CHECK(min_loc_x);
+    SANITY_CHECK(min_loc_y);
+    SANITY_CHECK(max_loc_x);
+    SANITY_CHECK(max_loc_y);
+}
+
+///////////// Sum ////////////////////////
+
+typedef Size_MatType SumFixture;
+
+OCL_PERF_TEST_P(SumFixture, Sum,
+            ::testing::Combine(OCL_TEST_SIZES,
+                               OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params), depth = CV_MAT_DEPTH(type);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type);
+    Scalar result;
+    randu(src, 0, 60);
+    declare.in(src);
+
+    OCL_TEST_CYCLE() result = cv::sum(src);
+
+    if (depth >= CV_32F)
+        SANITY_CHECK(result, 1e-6, ERROR_RELATIVE);
+    else
+        SANITY_CHECK(result);
+}
+
+///////////// countNonZero ////////////////////////
+
+typedef Size_MatType CountNonZeroFixture;
+
+OCL_PERF_TEST_P(CountNonZeroFixture, CountNonZero,
+                ::testing::Combine(OCL_TEST_SIZES,
+                               OCL_PERF_ENUM(CV_8UC1, CV_32FC1)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type);
+    int result = 0;
+    randu(src, 0, 10);
+    declare.in(src);
+
+    OCL_TEST_CYCLE() result = cv::countNonZero(src);
+
+    SANITY_CHECK(result);
+}
+
+///////////// Phase ////////////////////////
+
+typedef Size_MatType PhaseFixture;
+
+OCL_PERF_TEST_P(PhaseFixture, Phase, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type),
+            dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::phase(src1, src2, dst, 1);
+
+    SANITY_CHECK(dst, 1e-2);
+}
+
+///////////// bitwise_and////////////////////////
+
+typedef Size_MatType BitwiseAndFixture;
+
+OCL_PERF_TEST_P(BitwiseAndFixture, Bitwise_and,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::bitwise_and(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// bitwise_xor ////////////////////////
+
+typedef Size_MatType BitwiseXorFixture;
+
+OCL_PERF_TEST_P(BitwiseXorFixture, Bitwise_xor,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::bitwise_xor(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// bitwise_or ////////////////////////
+
+typedef Size_MatType BitwiseOrFixture;
+
+OCL_PERF_TEST_P(BitwiseOrFixture, Bitwise_or,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::bitwise_or(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// bitwise_not ////////////////////////
+
+typedef Size_MatType BitwiseNotFixture;
+
+OCL_PERF_TEST_P(BitwiseNotFixture, Bitwise_not,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::bitwise_not(src, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// compare////////////////////////
+
+CV_ENUM(CmpCode, CMP_LT, CMP_LE, CMP_EQ, CMP_NE, CMP_GE, CMP_GT)
+
+typedef std::tr1::tuple<Size, MatType, CmpCode> CompareParams;
+typedef TestBaseWithParam<CompareParams> CompareFixture;
+
+OCL_PERF_TEST_P(CompareFixture, Compare,
+            ::testing::Combine(OCL_TEST_SIZES,
+                               OCL_TEST_TYPES, CmpCode::all()))
+{
+    const CompareParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    const int cmpCode = get<2>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, CV_8UC1);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::compare(src1, src2, dst, cmpCode);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// pow ////////////////////////
+
+typedef Size_MatType PowFixture;
+
+OCL_PERF_TEST_P(PowFixture, Pow, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    randu(src, -100, 100);
+    declare.in(src).out(dst);
+
+    OCL_TEST_CYCLE() cv::pow(src, -2.0, dst);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+///////////// AddWeighted////////////////////////
+
+typedef Size_MatType AddWeightedFixture;
+
+OCL_PERF_TEST_P(AddWeightedFixture, AddWeighted,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params), depth = CV_MAT_DEPTH(type);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+    double alpha = 2.0, beta = 1.0, gama = 3.0;
+
+    OCL_TEST_CYCLE() cv::addWeighted(src1, alpha, src2, beta, gama, dst);
+
+    if (depth >= CV_32F)
+        SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+    else
+        SANITY_CHECK(dst);
+}
+
+///////////// Sqrt ///////////////////////
+
+typedef Size_MatType SqrtFixture;
+
+OCL_PERF_TEST_P(SqrtFixture, Sqrt, ::testing::Combine(
+                OCL_TEST_SIZES, OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    Mat src(srcSize, type), dst(srcSize, type);
+    randu(src, 0, 1000);
+    declare.in(src).out(dst);
+
+    TEST_CYCLE() cv::sqrt(src, dst);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+///////////// SetIdentity ////////////////////////
+
+typedef Size_MatType SetIdentityFixture;
+
+OCL_PERF_TEST_P(SetIdentityFixture, SetIdentity,
+            ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat dst(srcSize, type);
+    declare.out(dst);
+
+    OCL_TEST_CYCLE() cv::setIdentity(dst, cv::Scalar::all(181));
+
+    SANITY_CHECK(dst);
+}
+
+///////////// MeanStdDev ////////////////////////
+
+typedef Size_MatType MeanStdDevFixture;
+
+OCL_PERF_TEST_P(MeanStdDevFixture, DISABLED_MeanStdDev,
+                ::testing::Combine(OCL_PERF_ENUM(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    const double eps = 1e-5;
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type);
+    Scalar mean, stddev;
+    declare.in(src, WARMUP_RNG);
+
+    OCL_TEST_CYCLE() cv::meanStdDev(src, mean, stddev);
+
+    double mean0 = mean[0], mean1 = mean[1], mean2 = mean[2], mean3 = mean[3];
+    double stddev0 = stddev[0], stddev1 = stddev[1], stddev2 = stddev[2], stddev3 = stddev[3];
+
+    SANITY_CHECK(mean0, eps, ERROR_RELATIVE);
+    SANITY_CHECK(mean1, eps, ERROR_RELATIVE);
+    SANITY_CHECK(mean2, eps, ERROR_RELATIVE);
+    SANITY_CHECK(mean3, eps, ERROR_RELATIVE);
+    SANITY_CHECK(stddev0, eps, ERROR_RELATIVE);
+    SANITY_CHECK(stddev1, eps, ERROR_RELATIVE);
+    SANITY_CHECK(stddev2, eps, ERROR_RELATIVE);
+    SANITY_CHECK(stddev3, eps, ERROR_RELATIVE);
+}
+
+///////////// Norm ////////////////////////
+
+CV_ENUM(NormType, NORM_INF, NORM_L1, NORM_L2)
+
+typedef std::tr1::tuple<Size, MatType, NormType> NormParams;
+typedef TestBaseWithParam<NormParams> NormFixture;
+
+OCL_PERF_TEST_P(NormFixture, DISABLED_Norm,
+                ::testing::Combine(OCL_PERF_ENUM(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), OCL_TEST_TYPES, NormType::all()))
+{
+    const NormParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    const int normType = get<2>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type);
+    double res;
+    declare.in(src1, src2, WARMUP_RNG);
+
+    OCL_TEST_CYCLE() res = cv::norm(src1, src2, normType);
+
+    SANITY_CHECK(res, 1e-6, ERROR_RELATIVE);
+}
+
 } } // namespace cvtest::ocl
 
 #endif // HAVE_OPENCL

modules/ts/include/opencv2/ts/ocl_perf.hpp

@@ -52,6 +52,9 @@ namespace ocl {
 
 using namespace perf;
 
+using std::tr1::get;
+using std::tr1::tuple;
+
 #define OCL_PERF_STRATEGY PERF_STRATEGY_SIMPLE
 
 #define OCL_PERF_TEST_P(fixture, name, params) SIMPLE_PERF_TEST_P(fixture, name, params)
@@ -68,21 +71,22 @@ using namespace perf;
     void OCL##_##fixture##_##name::PerfTestBody()
 
 
-#define OCL_SIZE_1000 Size(1000, 1000)
-#define OCL_SIZE_2000 Size(2000, 2000)
-#define OCL_SIZE_4000 Size(4000, 4000)
+#define OCL_SIZE_1 szVGA
+#define OCL_SIZE_2 sz720p
+#define OCL_SIZE_3 sz1080p
+#define OCL_SIZE_4 sz2160p
 
-#define OCL_TEST_SIZES ::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000, OCL_SIZE_4000)
+#define OCL_TEST_SIZES ::testing::Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3, OCL_SIZE_4)
 #define OCL_TEST_TYPES ::testing::Values(CV_8UC1, CV_32FC1, CV_8UC4, CV_32FC4)
 
 #define OCL_PERF_ENUM ::testing::Values
 
 // TODO Replace finish call to dstUMat.wait()
 #define OCL_TEST_CYCLE() \
-    for (; startTimer(), next(); cvtest::ocl::perf::safeFinish(), stopTimer())
+    for (cvtest::ocl::perf::safeFinish(); startTimer(), next(); cvtest::ocl::perf::safeFinish(), stopTimer())
 
 #define OCL_TEST_CYCLE_MULTIRUN(runsNum) \
-    for (declare.runs(runsNum); startTimer(), next(); cvtest::ocl::perf::safeFinish(), stopTimer()) \
+    for (declare.runs(runsNum), cvtest::ocl::perf::safeFinish(); startTimer(), next(); cvtest::ocl::perf::safeFinish(), stopTimer()) \
         for (int r = 0; r < runsNum; cvtest::ocl::perf::safeFinish(), ++r)
 
 namespace perf {

modules/ts/src/ocl_perf.cpp

@@ -53,41 +53,31 @@ namespace perf {
 void checkDeviceMaxMemoryAllocSize(const Size& size, int type, int factor)
 {
     assert(factor > 0);
+
     if (!cv::ocl::useOpenCL())
         return;
-    int cn = CV_MAT_CN(type);
-    int cn_ocl = cn == 3 ? 4 : cn;
-    int type_ocl = CV_MAKE_TYPE(CV_MAT_DEPTH(type), cn_ocl);
-    size_t memSize = size.area() * CV_ELEM_SIZE(type_ocl);
+
+    size_t memSize = size.area() * CV_ELEM_SIZE(type);
     const cv::ocl::Device& dev = cv::ocl::Device::getDefault();
+
     if (memSize * factor >= dev.maxMemAllocSize())
-    {
         throw ::perf::TestBase::PerfSkipTestException();
-    }
 }
 
 void randu(InputOutputArray dst)
 {
     if (dst.depth() == CV_8U)
-    {
         cv::randu(dst, 0, 256);
-    }
     else if (dst.depth() == CV_8S)
-    {
         cv::randu(dst, -128, 128);
-    }
     else if (dst.depth() == CV_16U)
-    {
         cv::randu(dst, 0, 1024);
-    }
     else if (dst.depth() == CV_32F || dst.depth() == CV_64F)
-    {
         cv::randu(dst, -1.0, 1.0);
-    }
-    else // (dst.depth() == CV_16S || dst.depth() == CV_32S)
-    {
+    else if (dst.depth() == CV_16S || dst.depth() == CV_32S)
         cv::randu(dst, -4096, 4096);
-    }
+    else
+        CV_Error(Error::StsUnsupportedFormat, "Unsupported format");
 }
 
 } // namespace perf

modules/ts/src/ts_perf.cpp

@@ -268,7 +268,8 @@ std::string Regression::getCurrentTestNodeName()
 
 bool Regression::isVector(cv::InputArray a)
 {
-    return a.kind() == cv::_InputArray::STD_VECTOR_MAT || a.kind() == cv::_InputArray::STD_VECTOR_VECTOR;
+    return a.kind() == cv::_InputArray::STD_VECTOR_MAT || a.kind() == cv::_InputArray::STD_VECTOR_VECTOR ||
+           a.kind() == cv::_InputArray::STD_VECTOR_UMAT;
 }
 
 double Regression::getElem(cv::Mat& m, int y, int x, int cn)
@@ -866,17 +867,27 @@ void TestBase::declareArray(SizeVector& sizes, cv::InputOutputArray a, WarmUpTyp
 void TestBase::warmup(cv::InputOutputArray a, WarmUpType wtype)
 {
     if (a.empty())
-    {
         return;
-    }
-    else if (a.isUMat())
-    {
-        return; // TODO current warmup_impl is not useful for GPU-based data
+    else if (a.isUMat() && wtype != WARMUP_READ)
+    {
+        int depth = a.depth();
+        if (depth == CV_8U)
+            cv::randu(a, 0, 256);
+        else if (depth == CV_8S)
+            cv::randu(a, -128, 128);
+        else if (depth == CV_16U)
+            cv::randu(a, 0, 1024);
+        else if (depth == CV_32F || depth == CV_64F)
+            cv::randu(a, -1.0, 1.0);
+        else if (depth == CV_16S || depth == CV_32S)
+            cv::randu(a, -4096, 4096);
+        else
+            CV_Error(cv::Error::StsUnsupportedFormat, "Unsupported format");
+
+        return;
     }
     else if (a.kind() != cv::_InputArray::STD_VECTOR_MAT && a.kind() != cv::_InputArray::STD_VECTOR_VECTOR)
-    {
         warmup_impl(a.getMat(), wtype);
-    }
     else
     {
         size_t total = a.total();