Skip to content

Commit

Permalink
Merge pull request opencv#2081 from ilya-lavrenov:tapi_perf
Browse files Browse the repository at this point in the history
  • Loading branch information
Andrey Pavlenko authored and OpenCV Buildbot committed Dec 28, 2013
2 parents dbaf125 + bb7e963 commit 4a6c2ce
Show file tree
Hide file tree
Showing 7 changed files with 452 additions and 7 deletions.
116 changes: 112 additions & 4 deletions modules/core/perf/opencl/perf_arithm.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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);
Expand Down Expand Up @@ -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);
}
Expand Down Expand Up @@ -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<Size, MatType, NormalizeModes> NormalizeParams;
typedef TestBaseWithParam<NormalizeParams> 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
156 changes: 156 additions & 0 deletions modules/core/perf/opencl/perf_channels.cpp
View file
Original file line number Diff line number Diff line change
@@ -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, [email protected]
// Jin Ma, [email protected]
//
// 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<Size, MatDepth, int> MergeParams;
typedef TestBaseWithParam<MergeParams> 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<UMat> src(cn);
for (vector<UMat>::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<SplitParams> SplitFixture;

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();
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<UMat> 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<Size, MatDepth> MixChannelsParams;
typedef TestBaseWithParam<MixChannelsParams> 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<UMat> 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
Loading

0 comments on commit 4a6c2ce

Please sign in to comment.