From 31e6251793989177693d081599bd81c28a25a51e Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Fri, 27 Dec 2013 16:33:18 +0400 Subject: [PATCH 1/2] added new perf tests to core --- modules/core/perf/opencl/perf_arithm.cpp | 116 ++++++++++++++- modules/core/perf/opencl/perf_channels.cpp | 156 +++++++++++++++++++++ modules/core/perf/opencl/perf_dxt.cpp | 99 +++++++++++++ modules/core/perf/opencl/perf_gemm.cpp | 82 +++++++++++ modules/core/src/arithm.cpp | 2 +- modules/core/src/convert.cpp | 12 +- modules/core/test/ocl/test_arithm.cpp | 2 +- modules/core/test/test_misc.cpp | 2 +- 8 files changed, 460 insertions(+), 11 deletions(-) create mode 100644 modules/core/perf/opencl/perf_channels.cpp create mode 100644 modules/core/perf/opencl/perf_dxt.cpp create mode 100644 modules/core/perf/opencl/perf_gemm.cpp diff --git a/modules/core/perf/opencl/perf_arithm.cpp b/modules/core/perf/opencl/perf_arithm.cpp index 2056359684..f6e62da69c 100644 --- a/modules/core/perf/opencl/perf_arithm.cpp +++ b/modules/core/perf/opencl/perf_arithm.cpp @@ -460,7 +460,7 @@ OCL_PERF_TEST_P(BitwiseAndFixture, Bitwise_and, checkDeviceMaxMemoryAllocSize(srcSize, type); - Mat src1(srcSize, type), src2(srcSize, type), dst(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_and(src1, src2, dst); @@ -481,7 +481,7 @@ OCL_PERF_TEST_P(BitwiseXorFixture, Bitwise_xor, checkDeviceMaxMemoryAllocSize(srcSize, type); - Mat src1(srcSize, type), src2(srcSize, type), dst(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_xor(src1, src2, dst); @@ -617,11 +617,11 @@ OCL_PERF_TEST_P(SqrtFixture, Sqrt, ::testing::Combine( checkDeviceMaxMemoryAllocSize(srcSize, type); - Mat src(srcSize, type), dst(srcSize, type); + UMat src(srcSize, type), dst(srcSize, type); randu(src, 0, 1000); declare.in(src).out(dst); - TEST_CYCLE() cv::sqrt(src, dst); + OCL_TEST_CYCLE() cv::sqrt(src, dst); SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE); } @@ -706,6 +706,114 @@ OCL_PERF_TEST_P(NormFixture, DISABLED_Norm, SANITY_CHECK(res, 1e-6, ERROR_RELATIVE); } +///////////// Repeat //////////////////////// + +typedef Size_MatType RepeatFixture; + +OCL_PERF_TEST_P(RepeatFixture, Repeat, + ::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), nx = 2, ny = 2; + + checkDeviceMaxMemoryAllocSize(srcSize, type); + + UMat src(srcSize, type), dst(Size(srcSize.width * nx, srcSize.height * ny), type); + declare.in(src, WARMUP_RNG).out(dst); + + OCL_TEST_CYCLE() cv::repeat(src, nx, ny, dst); + + SANITY_CHECK(dst); +} + +///////////// Min //////////////////////// + +typedef Size_MatType MinFixture; + +OCL_PERF_TEST_P(MinFixture, Min, + ::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::min(src1, src2, dst); + + SANITY_CHECK(dst); +} + +///////////// Max //////////////////////// + +typedef Size_MatType MaxFixture; + +OCL_PERF_TEST_P(MaxFixture, Max, + ::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::max(src1, src2, dst); + + SANITY_CHECK(dst); +} + +///////////// InRange //////////////////////// + +typedef Size_MatType InRangeFixture; + +OCL_PERF_TEST_P(InRangeFixture, InRange, + ::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), lb(srcSize, type), ub(srcSize, type), dst(srcSize, CV_8UC1); + declare.in(src, lb, ub, WARMUP_RNG).out(dst); + + OCL_TEST_CYCLE() cv::inRange(src, lb, ub, dst); + + SANITY_CHECK(dst); +} + +///////////// Normalize //////////////////////// + +CV_ENUM(NormalizeModes, CV_MINMAX, CV_L2, CV_L1, CV_C) + +typedef tuple NormalizeParams; +typedef TestBaseWithParam NormalizeFixture; + +OCL_PERF_TEST_P(NormalizeFixture, Normalize, + ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES, NormalizeModes::all())) +{ + const NormalizeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), mode = get<2>(params); + + checkDeviceMaxMemoryAllocSize(srcSize, type); + + UMat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); + + OCL_TEST_CYCLE() cv::normalize(src, dst, 10, 110, mode); + + SANITY_CHECK(dst, 5e-2); +} + } } // namespace cvtest::ocl #endif // HAVE_OPENCL diff --git a/modules/core/perf/opencl/perf_channels.cpp b/modules/core/perf/opencl/perf_channels.cpp new file mode 100644 index 0000000000..f2a0d68a40 --- /dev/null +++ b/modules/core/perf/opencl/perf_channels.cpp @@ -0,0 +1,156 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Fangfang Bai, fangfang@multicorewareinc.com +// Jin Ma, jin@multicorewareinc.com +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors as is and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "perf_precomp.hpp" +#include "opencv2/ts/ocl_perf.hpp" + +#ifdef HAVE_OPENCL + +namespace cvtest { +namespace ocl { + +///////////// Merge//////////////////////// + +typedef tuple MergeParams; +typedef TestBaseWithParam MergeFixture; + +OCL_PERF_TEST_P(MergeFixture, Merge, + ::testing::Combine(OCL_TEST_SIZES, OCL_PERF_ENUM(CV_8U, CV_32F), Values(2, 3))) +{ + const MergeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), cn = get<2>(params), dtype = CV_MAKE_TYPE(depth, cn); + + checkDeviceMaxMemoryAllocSize(srcSize, dtype); + + UMat dst(srcSize, dtype); + vector src(cn); + for (vector::iterator i = src.begin(), end = src.end(); i != end; ++i) + { + i->create(srcSize, CV_MAKE_TYPE(depth, 1)); + declare.in(*i, WARMUP_RNG); + } + declare.out(dst); + + OCL_TEST_CYCLE() cv::merge(src, dst); + + SANITY_CHECK(dst); +} + +///////////// Split //////////////////////// + +typedef MergeParams SplitParams; +typedef TestBaseWithParam SplitFixture; + +OCL_PERF_TEST_P(SplitFixture, Split, + ::testing::Combine(OCL_TEST_SIZES, OCL_PERF_ENUM(CV_8U, CV_32F), Values(2, 3))) +{ + const SplitParams params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), cn = get<2>(params), type = CV_MAKE_TYPE(depth, cn); + + ASSERT_TRUE(cn == 3 || cn == 2); + + checkDeviceMaxMemoryAllocSize(srcSize, type); + + UMat src(srcSize, type); + std::vector dst(cn, UMat(srcSize, CV_MAKE_TYPE(depth, 1))); + + declare.in(src, WARMUP_RNG); + for (int i = 0; i < cn; ++i) + declare.in(dst[i]); + + OCL_TEST_CYCLE() cv::split(src, dst); + + ASSERT_EQ(cn, (int)dst.size()); + + if (cn == 2) + { + UMat & dst0 = dst[0], & dst1 = dst[1]; + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); + } + else + { + UMat & dst0 = dst[0], & dst1 = dst[1], & dst2 = dst[2]; + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); + } +} + +///////////// MixChannels //////////////////////// + +typedef tuple MixChannelsParams; +typedef TestBaseWithParam MixChannelsFixture; + +OCL_PERF_TEST_P(MixChannelsFixture, MixChannels, + ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), + OCL_PERF_ENUM(CV_8U, CV_32F))) +{ + const MixChannelsParams params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), type = CV_MAKE_TYPE(depth, 2), n = 2; + + checkDeviceMaxMemoryAllocSize(srcSize, type); + + UMat templ(srcSize, type); + std::vector src(n, templ), dst(n, templ); + for (int i = 0; i < n; ++i) + declare.in(src[i], WARMUP_RNG).out(dst[i]); + + int fromTo[] = { 1,2, 2,0, 0,3, 3,1 }; + + OCL_TEST_CYCLE() cv::mixChannels(src, dst, fromTo, 4); + + UMat & dst0 = dst[0], & dst1 = dst[1]; + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); +} + +} } // namespace cvtest::ocl + +#endif // HAVE_OPENCL diff --git a/modules/core/perf/opencl/perf_dxt.cpp b/modules/core/perf/opencl/perf_dxt.cpp new file mode 100644 index 0000000000..d0219913b5 --- /dev/null +++ b/modules/core/perf/opencl/perf_dxt.cpp @@ -0,0 +1,99 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Fangfang Bai, fangfang@multicorewareinc.com +// Jin Ma, jin@multicorewareinc.com +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors as is and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "perf_precomp.hpp" +#include "opencv2/ts/ocl_perf.hpp" + +#ifdef HAVE_OPENCL + +namespace cvtest { +namespace ocl { + +///////////// dft //////////////////////// + +typedef tuple DftParams; +typedef TestBaseWithParam DftFixture; + +OCL_PERF_TEST_P(DftFixture, Dft, ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), + Values((int)DFT_ROWS, (int)DFT_SCALE, (int)DFT_INVERSE, + (int)DFT_INVERSE | DFT_SCALE, (int)DFT_ROWS | DFT_INVERSE))) +{ + const DftParams params = GetParam(); + const Size srcSize = get<0>(params); + const int flags = get<1>(params); + + UMat src(srcSize, CV_32FC2), dst(srcSize, CV_32FC2); + declare.in(src, WARMUP_RNG).out(dst); + + OCL_TEST_CYCLE() cv::dft(src, dst, flags | DFT_COMPLEX_OUTPUT); + + SANITY_CHECK(dst, 1e-3); +} + +///////////// MulSpectrums //////////////////////// + +typedef tuple MulSpectrumsParams; +typedef TestBaseWithParam MulSpectrumsFixture; + +OCL_PERF_TEST_P(MulSpectrumsFixture, MulSpectrums, + ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), + Bool())) +{ + const MulSpectrumsParams params = GetParam(); + const Size srcSize = get<0>(params); + const bool conj = get<1>(params); + + UMat src1(srcSize, CV_32FC2), src2(srcSize, CV_32FC2), dst(srcSize, CV_32FC2); + declare.in(src1, src2, WARMUP_RNG).out(dst); + + OCL_TEST_CYCLE() cv::mulSpectrums(src1, src2, dst, 0, conj); + + SANITY_CHECK(dst, 1e-3); +} + +} } // namespace cvtest::ocl + +#endif // HAVE_OPENCL diff --git a/modules/core/perf/opencl/perf_gemm.cpp b/modules/core/perf/opencl/perf_gemm.cpp new file mode 100644 index 0000000000..3aa87d6a1e --- /dev/null +++ b/modules/core/perf/opencl/perf_gemm.cpp @@ -0,0 +1,82 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Fangfang Bai, fangfang@multicorewareinc.com +// Jin Ma, jin@multicorewareinc.com +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors as is and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "perf_precomp.hpp" +#include "opencv2/ts/ocl_perf.hpp" + +#ifdef HAVE_OPENCL + +namespace cvtest { +namespace ocl { + +///////////// gemm //////////////////////// + +typedef tuple GemmParams; +typedef TestBaseWithParam GemmFixture; + +OCL_PERF_TEST_P(GemmFixture, Gemm, ::testing::Combine( + ::testing::Values(Size(1000, 1000), Size(1500, 1500)), + Values((int)cv::GEMM_3_T, (int)cv::GEMM_3_T | (int)cv::GEMM_2_T))) +{ + GemmParams params = GetParam(); + const Size srcSize = get<0>(params); + const int flags = get<1>(params); + + UMat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1); + declare.in(src1, src2, src3).out(dst); + randu(src1, -10.0f, 10.0f); + randu(src2, -10.0f, 10.0f); + randu(src3, -10.0f, 10.0f); + + OCL_TEST_CYCLE() cv::gemm(src1, src2, 0.6, src3, 1.5, dst, flags); + + SANITY_CHECK(dst, 0.01); +} + +} } // namespace cvtest::ocl + +#endif // HAVE_OPENCL diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index b58eda1aa9..c4db92b6db 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -1409,7 +1409,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst, int wtype, dims1 = psrc1->dims(), dims2 = psrc2->dims(); Size sz1 = dims1 <= 2 ? psrc1->size() : Size(); Size sz2 = dims2 <= 2 ? psrc2->size() : Size(); - bool use_opencl = _dst.kind() == _OutputArray::UMAT && ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2; + bool use_opencl = _dst.isUMat() && ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2; bool src1Scalar = checkScalar(*psrc1, type2, kind1, kind2); bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1); diff --git a/modules/core/src/convert.cpp b/modules/core/src/convert.cpp index 6259a7ada2..0040740f65 100644 --- a/modules/core/src/convert.cpp +++ b/modules/core/src/convert.cpp @@ -619,9 +619,11 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, if(npairs == 0) return; bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT && - src.kind() != _InputArray::STD_VECTOR_VECTOR; + src.kind() != _InputArray::STD_VECTOR_VECTOR && + src.kind() != _InputArray::STD_VECTOR_UMAT; bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT && - dst.kind() != _InputArray::STD_VECTOR_VECTOR; + dst.kind() != _InputArray::STD_VECTOR_VECTOR && + dst.kind() != _InputArray::STD_VECTOR_UMAT; int i; int nsrc = src_is_mat ? 1 : (int)src.total(); int ndst = dst_is_mat ? 1 : (int)dst.total(); @@ -642,9 +644,11 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, if(fromTo.empty()) return; bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT && - src.kind() != _InputArray::STD_VECTOR_VECTOR; + src.kind() != _InputArray::STD_VECTOR_VECTOR && + src.kind() != _InputArray::STD_VECTOR_UMAT; bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT && - dst.kind() != _InputArray::STD_VECTOR_VECTOR; + dst.kind() != _InputArray::STD_VECTOR_VECTOR && + dst.kind() != _InputArray::STD_VECTOR_UMAT; int i; int nsrc = src_is_mat ? 1 : (int)src.total(); int ndst = dst_is_mat ? 1 : (int)dst.total(); diff --git a/modules/core/test/ocl/test_arithm.cpp b/modules/core/test/ocl/test_arithm.cpp index 7bc0b5ac0e..3aa47b7d2a 100644 --- a/modules/core/test/ocl/test_arithm.cpp +++ b/modules/core/test/ocl/test_arithm.cpp @@ -1234,7 +1234,7 @@ OCL_TEST_P(Normalize, Mat) for (int i = 0, size = sizeof(modes) / sizeof(modes[0]); i < size; ++i) { OCL_OFF(cv::normalize(src1_roi, dst1_roi, 10, 110, modes[i], src1_roi.type(), mask_roi)); - OCL_ON(cv::normalize(usrc1_roi, udst1_roi, 10, 110, modes[i], src1_roi.type(), umask_roi)); + OCL_ON(cv::normalize(usrc1_roi, udst1_roi, 10, 110, modes[i], src1_roi.type(), umask_roi)); Near(1); } diff --git a/modules/core/test/test_misc.cpp b/modules/core/test/test_misc.cpp index 5af419c939..e40d40de31 100644 --- a/modules/core/test/test_misc.cpp +++ b/modules/core/test/test_misc.cpp @@ -25,7 +25,7 @@ TEST(Core_Drawing, _914) } -TEST(Core_OutputArraySreate, _1997) +TEST(Core_OutputArrayCreate, _1997) { struct local { static void create(OutputArray arr, Size submatSize, int type) From bb7e96311ea9dce813c561c762a82a54403adf4d Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Fri, 27 Dec 2013 21:57:20 +0400 Subject: [PATCH 2/2] disabled cv::split perf test --- modules/core/perf/opencl/perf_channels.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/perf/opencl/perf_channels.cpp b/modules/core/perf/opencl/perf_channels.cpp index f2a0d68a40..958bb73b5d 100644 --- a/modules/core/perf/opencl/perf_channels.cpp +++ b/modules/core/perf/opencl/perf_channels.cpp @@ -85,7 +85,7 @@ OCL_PERF_TEST_P(MergeFixture, Merge, typedef MergeParams SplitParams; typedef TestBaseWithParam SplitFixture; -OCL_PERF_TEST_P(SplitFixture, Split, +OCL_PERF_TEST_P(SplitFixture, DISABLED_Split, ::testing::Combine(OCL_TEST_SIZES, OCL_PERF_ENUM(CV_8U, CV_32F), Values(2, 3))) { const SplitParams params = GetParam();