{

pid_t pid=gettid();

int syscallres=syscall(__NR_sched_setaffinity, pid, sizeof(mask), &mask);

if (syscallres)

{

int err=errno;

err=err;//to avoid warnings about unused variables

LOGE("Error in the syscall setaffinity: mask=%d=0x%x err=%d=0x%x", mask, mask, err, err);

}

{

void TearDown()

{

cv::setNumThreads(-1);

}

{

const int bigValue = 0x00000FFF;

if (m.depth() < CV_32F)

{

int minmax[] = {0, 256};

cv::Mat mr = cv::Mat(m.rows, (int)(m.cols * m.elemSize()), CV_8U, m.ptr(), m.step[0]);

cv::randu(mr, cv::Mat(1, 1, CV_32S, minmax), cv::Mat(1, 1, CV_32S, minmax + 1));

}

else if (m.depth() == CV_32F)

{

//float minmax[] = {-FLT_MAX, FLT_MAX};

float minmax[] = {-bigValue, bigValue};

cv::Mat mr = m.reshape(1);

cv::randu(mr, cv::Mat(1, 1, CV_32F, minmax), cv::Mat(1, 1, CV_32F, minmax + 1));

}

else

{

//double minmax[] = {-DBL_MAX, DBL_MAX};

double minmax[] = {-bigValue, bigValue};

cv::Mat mr = m.reshape(1);

cv::randu(mr, cv::Mat(1, 1, CV_64F, minmax), cv::Mat(1, 1, CV_64F, minmax + 1));

}

{

if (!storageInPath.empty())

{

LOGE("Subsequent initialization of Regression utility is not allowed.");

return;

}

const char *data_path_dir = getenv("OPENCV_TEST_DATA_PATH");

const char *path_separator = "/";

if (data_path_dir)

{

int len = (int)strlen(data_path_dir)-1;

if (len < 0) len = 0;

std::string path_base = (data_path_dir[0] == 0 ? std::string(".") : std::string(data_path_dir))

+ (data_path_dir[len] == '/' || data_path_dir[len] == '\\' ? "" : path_separator)

+ "perf"

+ path_separator;

storageInPath = path_base + testSuitName + ext;

storageOutPath = path_base + testSuitName;

}

else

{

storageInPath = testSuitName + ext;

storageOutPath = testSuitName;

}

suiteName = testSuitName;

try

{

if (storageIn.open(storageInPath, cv::FileStorage::READ))

{

rootIn = storageIn.root();

if (storageInPath.length() > 3 && storageInPath.substr(storageInPath.length()-3) == ".gz")

storageOutPath += "_new";

storageOutPath += ext;

}

}

catch(cv::Exception&)

{

LOGE("Failed to open sanity data for reading: %s", storageInPath.c_str());

}

if(!storageIn.isOpened())

storageOutPath = storageInPath;

{

const ::testing::TestInfo* const test_info =

::testing::UnitTest::GetInstance()->current_test_info();

if (test_info == 0)

return "undefined";

std::string nodename = std::string(test_info->test_case_name()) + "--" + test_info->name();

size_t idx = nodename.find_first_of('/');

if (idx != std::string::npos)

nodename.erase(idx);

const char* type_param = test_info->type_param();

if (type_param != 0)

(nodename += "--") += type_param;

const char* value_param = test_info->value_param();

if (value_param != 0)

(nodename += "--") += value_param;

for(size_t i = 0; i < nodename.length(); ++i)

if (!isalnum(nodename[i]) && '_' != nodename[i])

nodename[i] = '-';

return nodename;

{

switch (m.depth())

{

case CV_8U: return *(m.ptr<unsigned char>(y, x) + cn);

case CV_8S: return *(m.ptr<signed char>(y, x) + cn);

case CV_16U: return *(m.ptr<unsigned short>(y, x) + cn);

case CV_16S: return *(m.ptr<signed short>(y, x) + cn);

case CV_32S: return *(m.ptr<signed int>(y, x) + cn);

case CV_32F: return *(m.ptr<float>(y, x) + cn);

case CV_64F: return *(m.ptr<double>(y, x) + cn);

default: return 0;

}

{

if (!m.empty() && m.dims < 2) return;

double min, max;

cv::minMaxIdx(m, &min, &max);

write() << "min" << min << "max" << max;

write() << "last" << "{" << "x" << m.size.p[1] - 1 << "y" << m.size.p[0] - 1

<< "val" << getElem(m, m.size.p[0] - 1, m.size.p[1] - 1, m.channels() - 1) << "}";

int x, y, cn;

x = regRNG.uniform(0, m.size.p[1]);

y = regRNG.uniform(0, m.size.p[0]);

cn = regRNG.uniform(0, m.channels());

write() << "rng1" << "{" << "x" << x << "y" << y;

if(cn > 0) write() << "cn" << cn;

write() << "val" << getElem(m, y, x, cn) << "}";

x = regRNG.uniform(0, m.size.p[1]);

y = regRNG.uniform(0, m.size.p[0]);

cn = regRNG.uniform(0, m.channels());

write() << "rng2" << "{" << "x" << x << "y" << y;

if (cn > 0) write() << "cn" << cn;

write() << "val" << getElem(m, y, x, cn) << "}";

{

if (!actual.empty() && actual.dims < 2) return;

double expect_min = (double)node["min"];

double expect_max = (double)node["max"];

if (err == ERROR_RELATIVE)

eps *= std::max(std::abs(expect_min), std::abs(expect_max));

double actual_min, actual_max;

cv::minMaxIdx(actual, &actual_min, &actual_max);

ASSERT_NEAR(expect_min, actual_min, eps)

<< argname << " has unexpected minimal value" << std::endl;

ASSERT_NEAR(expect_max, actual_max, eps)

<< argname << " has unexpected maximal value" << std::endl;

cv::FileNode last = node["last"];

double actual_last = getElem(actual, actual.size.p[0] - 1, actual.size.p[1] - 1, actual.channels() - 1);

int expect_cols = (int)last["x"] + 1;

int expect_rows = (int)last["y"] + 1;

ASSERT_EQ(expect_cols, actual.size.p[1])

<< argname << " has unexpected number of columns" << std::endl;

ASSERT_EQ(expect_rows, actual.size.p[0])

<< argname << " has unexpected number of rows" << std::endl;

double expect_last = (double)last["val"];

ASSERT_NEAR(expect_last, actual_last, eps)

<< argname << " has unexpected value of the last element" << std::endl;

cv::FileNode rng1 = node["rng1"];

int x1 = rng1["x"];

int y1 = rng1["y"];

int cn1 = rng1["cn"];

double expect_rng1 = (double)rng1["val"];

// it is safe to use x1 and y1 without checks here because we have already

// verified that mat size is the same as recorded

double actual_rng1 = getElem(actual, y1, x1, cn1);

ASSERT_NEAR(expect_rng1, actual_rng1, eps)

<< argname << " has unexpected value of the ["<< x1 << ":" << y1 << ":" << cn1 <<"] element" << std::endl;

cv::FileNode rng2 = node["rng2"];

int x2 = rng2["x"];

int y2 = rng2["y"];

int cn2 = rng2["cn"];

double expect_rng2 = (double)rng2["val"];

double actual_rng2 = getElem(actual, y2, x2, cn2);

ASSERT_NEAR(expect_rng2, actual_rng2, eps)

<< argname << " has unexpected value of the ["<< x2 << ":" << y2 << ":" << cn2 <<"] element" << std::endl;

{

write() << "kind" << array.kind();

write() << "type" << array.type();

if (isVector(array))

{

int total = (int)array.total();

int idx = regRNG.uniform(0, total);

write() << "len" << total;

write() << "idx" << idx;

cv::Mat m = array.getMat(idx);

if (m.total() * m.channels() < 26) //5x5 or smaller

write() << "val" << m;

else

write(m);

}

else

{

if (array.total() * array.channels() < 26) //5x5 or smaller

write() << "val" << array.getMat();

else

write(array.getMat());

}

{

cv::Mat diff64f;

diff.reshape(1).convertTo(diff64f, CV_64F);

cv::Mat expected_abs = cv::abs(expected.reshape(1));

cv::Mat actual_abs = cv::abs(actual.reshape(1));

cv::Mat maximum, mask;

cv::max(expected_abs, actual_abs, maximum);

cv::multiply(maximum, cv::Vec<double, 1>(eps), maximum, CV_64F);

cv::compare(diff64f, maximum, mask, cv::CMP_GT);

int v = cv::countNonZero(mask);

if (v > 0 && max_violation != 0 && max_allowed != 0)

{

int loc[10];

cv::minMaxIdx(maximum, 0, max_allowed, 0, loc, mask);

*max_violation = diff64f.at<double>(loc[1], loc[0]);

}

return v;

{

int expected_kind = (int)node["kind"];

int expected_type = (int)node["type"];

ASSERT_EQ(expected_kind, array.kind()) << " Argument \"" << node.name() << "\" has unexpected kind";

ASSERT_EQ(expected_type, array.type()) << " Argument \"" << node.name() << "\" has unexpected type";

cv::FileNode valnode = node["val"];

if (isVector(array))

{

int expected_length = (int)node["len"];

ASSERT_EQ(expected_length, (int)array.total()) << " Vector \"" << node.name() << "\" has unexpected length";

int idx = node["idx"];

cv::Mat actual = array.getMat(idx);

if (valnode.isNone())

{

ASSERT_LE((size_t)26, actual.total() * (size_t)actual.channels())

<< " \"" << node.name() << "[" << idx << "]\" has unexpected number of elements";

verify(node, actual, eps, cv::format("%s[%d]", node.name().c_str(), idx), err);

}

else

{

cv::Mat expected;

valnode >> expected;

if(expected.empty())

{

ASSERT_TRUE(actual.empty())

<< " expected empty " << node.name() << "[" << idx<< "]";

}

else

{

ASSERT_EQ(expected.size(), actual.size())

<< " " << node.name() << "[" << idx<< "] has unexpected size";

cv::Mat diff;

cv::absdiff(expected, actual, diff);

if (err == ERROR_ABSOLUTE)

{

if (!cv::checkRange(diff, true, 0, 0, eps))

{

if(expected.total() * expected.channels() < 12)

std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;

double max;

cv::minMaxIdx(diff.reshape(1), 0, &max);

FAIL() << " Absolute difference (=" << max << ") between argument \""

<< node.name() << "[" << idx << "]\" and expected value is greater than " << eps;

}

}

else if (err == ERROR_RELATIVE)

{

double maxv, maxa;

int violations = countViolations(expected, actual, diff, eps, &maxv, &maxa);

if (violations > 0)

{

if(expected.total() * expected.channels() < 12)

std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;

FAIL() << " Relative difference (" << maxv << " of " << maxa << " allowed) between argument \""

<< node.name() << "[" << idx << "]\" and expected value is greater than " << eps << " in " << violations << " points";

}

}

}

}

}

else

{

if (valnode.isNone())

{

ASSERT_LE((size_t)26, array.total() * (size_t)array.channels())

<< " Argument \"" << node.name() << "\" has unexpected number of elements";

verify(node, array.getMat(), eps, "Argument \"" + node.name() + "\"", err);

}

else

{

cv::Mat expected;

valnode >> expected;

cv::Mat actual = array.getMat();

if(expected.empty())

{

ASSERT_TRUE(actual.empty())

<< " expected empty " << node.name();

}

else

{

ASSERT_EQ(expected.size(), actual.size())

<< " Argument \"" << node.name() << "\" has unexpected size";

cv::Mat diff;

cv::absdiff(expected, actual, diff);

if (err == ERROR_ABSOLUTE)

{

if (!cv::checkRange(diff, true, 0, 0, eps))

{

if(expected.total() * expected.channels() < 12)

std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;

double max;

cv::minMaxIdx(diff.reshape(1), 0, &max);

FAIL() << " Difference (=" << max << ") between argument1 \"" << node.name()

<< "\" and expected value is greater than " << eps;

}

}

else if (err == ERROR_RELATIVE)

{

double maxv, maxa;

int violations = countViolations(expected, actual, diff, eps, &maxv, &maxa);

if (violations > 0)

{

if(expected.total() * expected.channels() < 12)

std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;

FAIL() << " Relative difference (" << maxv << " of " << maxa << " allowed) between argument \"" << node.name()

<< "\" and expected value is greater than " << eps << " in " << violations << " points";

}

}

}

}

}

{

bytesIn = 0;

bytesOut = 0;

samples = 0;

outliers = 0;

gmean = 0;

gstddev = 0;

mean = 0;

stddev = 0;

median = 0;

min = 0;

frequency = 0;

terminationReason = TERM_UNKNOWN;

{

std::vector<std::string> plain_only;

plain_only.push_back("plain");

TestBase::Init(plain_only, argc, argv);

int argc, const char* const argv[])

{

available_impls = availableImpls;

const std::string command_line_keys =

"{ |perf_max_outliers |8 |percent of allowed outliers}"

"{ |perf_min_samples |10 |minimal required numer of samples}"

"{ |perf_force_samples |100 |force set maximum number of samples for all tests}"

"{ |perf_seed |809564 |seed for random numbers generator}"

"{ |perf_threads |-1 |the number of worker threads, if parallel execution is enabled}"

"{ |perf_write_sanity |false |create new records for sanity checks}"

"{ |perf_verify_sanity |false |fail tests having no regression data for sanity checks}"

"{ |perf_impl |" + available_impls[0] +

"|the implementation variant of functions under test}"

"{ |perf_list_impls |false |list available implementation variants and exit}"

"{ |perf_run_cpu |false |deprecated, equivalent to --perf_impl=plain}"

"{ |perf_strategy |default |specifies performance measuring strategy: default, base or simple (weak restrictions)}"

#ifdef ANDROID

"{ |perf_time_limit |6.0 |default time limit for a single test (in seconds)}"

"{ |perf_affinity_mask |0 |set affinity mask for the main thread}"

"{ |perf_log_power_checkpoints | |additional xml logging for power measurement}"

#else

"{ |perf_time_limit |3.0 |default time limit for a single test (in seconds)}"

#endif

"{ |perf_max_deviation |1.0 |}"

"{h |help |false |print help info}"

#ifdef HAVE_CUDA

"{ |perf_cuda_device |0 |run GPU test suite onto specific CUDA capable device}"

"{ |perf_cuda_info_only |false |print an information about system and an available CUDA devices and then exit.}"

#endif

;

cv::CommandLineParser args(argc, argv, command_line_keys.c_str());

if (args.get<bool>("help"))

{

args.printParams();

printf("\n\n");

return;

}

::testing::AddGlobalTestEnvironment(new PerfEnvironment);

param_impl = args.get<bool>("perf_run_cpu") ? "plain" : args.get<std::string>("perf_impl");

std::string perf_strategy = args.get<std::string>("perf_strategy");

if (perf_strategy == "default")

{

// nothing

}

else if (perf_strategy == "base")

{

param_strategy = PERF_STRATEGY_BASE;

}

else if (perf_strategy == "simple")

{

param_strategy = PERF_STRATEGY_SIMPLE;

}

else

{

printf("No such strategy: %s\n", perf_strategy.c_str());

exit(1);

}

param_max_outliers = std::min(100., std::max(0., args.get<double>("perf_max_outliers")));

param_min_samples = std::max(1u, args.get<unsigned int>("perf_min_samples"));

param_max_deviation = std::max(0., args.get<double>("perf_max_deviation"));

param_seed = args.get<uint64>("perf_seed");

param_time_limit = std::max(0., args.get<double>("perf_time_limit"));

param_force_samples = args.get<unsigned int>("perf_force_samples");

param_write_sanity = args.get<bool>("perf_write_sanity");

param_verify_sanity = args.get<bool>("perf_verify_sanity");

param_threads = args.get<int>("perf_threads");

#ifdef ANDROID

param_affinity_mask = args.get<int>("perf_affinity_mask");

log_power_checkpoints = args.get<bool>("perf_log_power_checkpoints");

#endif

bool param_list_impls = args.get<bool>("perf_list_impls");

if (param_list_impls)

{

fputs("Available implementation variants:", stdout);

for (size_t i = 0; i < available_impls.size(); ++i) {

putchar(' ');

fputs(available_impls[i].c_str(), stdout);

}

putchar('\n');

exit(0);

}

if (std::find(available_impls.begin(), available_impls.end(), param_impl) == available_impls.end())

{

printf("No such implementation: %s\n", param_impl.c_str());

exit(1);

}

#ifdef HAVE_CUDA

bool printOnly = args.get<bool>("perf_cuda_info_only");

if (printOnly)

exit(0);

#endif

if (available_impls.size() > 1)

printf("[----------]\n[ INFO ] \tImplementation variant: %s.\n[----------]\n", param_impl.c_str()), fflush(stdout);

#ifdef HAVE_CUDA

param_cuda_device = std::max(0, std::min(cv::gpu::getCudaEnabledDeviceCount(), args.get<int>("perf_cuda_device")));

if (param_impl == "cuda")

{

cv::gpu::DeviceInfo info(param_cuda_device);

if (!info.isCompatible())

{

printf("[----------]\n[ FAILURE ] \tDevice %s is NOT compatible with current GPU module build.\n[----------]\n", info.name().c_str()), fflush(stdout);

exit(-1);

}

cv::gpu::setDevice(param_cuda_device);

printf("[----------]\n[ GPU INFO ] \tRun test suite on %s GPU.\n[----------]\n", info.name().c_str()), fflush(stdout);

}

#endif

timeLimitDefault = param_time_limit == 0.0 ? 1 : (int64)(param_time_limit * cv::getTickFrequency());

iterationsLimitDefault = param_force_samples == 0 ? (unsigned)(-1) : param_force_samples;

_timeadjustment = _calibrate();

{

::testing::Test::RecordProperty("cv_implementation", param_impl);

::testing::Test::RecordProperty("cv_num_threads", param_threads);

#ifdef HAVE_CUDA

if (param_impl == "cuda")

{

cv::gpu::DeviceInfo info(param_cuda_device);

::testing::Test::RecordProperty("cv_cuda_gpu", info.name());

}

#endif

{

enum PERF_STRATEGY ret = param_strategy;

param_strategy = strategy;

return ret;

{

class _helper : public ::perf::TestBase

{

public:

performance_metrics& getMetrics() { return calcMetrics(); }

virtual void TestBody() {}

virtual void PerfTestBody()

{

//the whole system warmup

SetUp();

cv::Mat a(2048, 2048, CV_32S, cv::Scalar(1));

cv::Mat b(2048, 2048, CV_32S, cv::Scalar(2));

declare.time(30);

double s = 0;

for(declare.iterations(20); startTimer(), next(); stopTimer())

s+=a.dot(b);

declare.time(s);

//self calibration

SetUp();

for(declare.iterations(1000); startTimer(), next(); stopTimer()){}

}

};

_timeadjustment = 0;

_helper h;

h.PerfTestBody();

double compensation = h.getMetrics().min;

if (param_strategy == PERF_STRATEGY_SIMPLE)

{

CV_Assert(compensation < 0.01 * cv::getTickFrequency());

compensation = 0.0f; // simple strategy doesn't require any compensation

}

LOGD("Time compensation is %.0f", compensation);

return (int64)compensation;

{

if (!a.empty())

{

sizes.push_back(std::pair<int, cv::Size>(getSizeInBytes(a), getSize(a)));

warmup(a, wtype);

}

else if (a.kind() != cv::_InputArray::NONE)

ADD_FAILURE() << " Uninitialized input/output parameters are not allowed for performance tests";

{

if (a.empty()) return;

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();

for (size_t i = 0; i < total; ++i)

warmup_impl(a.getMat((int)i), wtype);

}

{

if (a.empty()) return 0;

int total = (int)a.total();

if (a.kind() != cv::_InputArray::STD_VECTOR_MAT && a.kind() != cv::_InputArray::STD_VECTOR_VECTOR)

return total * CV_ELEM_SIZE(a.type());

int size = 0;

for (int i = 0; i < total; ++i)

size += (int)a.total(i) * CV_ELEM_SIZE(a.type(i));

return size;

{

if (a.kind() != cv::_InputArray::STD_VECTOR_MAT && a.kind() != cv::_InputArray::STD_VECTOR_VECTOR)

return a.size();

return cv::Size();

{

static int64 lastActivityPrintTime = 0;

if (currentIter != (unsigned int)-1)

{

if (currentIter + 1 != times.size())

ADD_FAILURE() << " next() is called before stopTimer()";

}

else

{

lastActivityPrintTime = 0;

metrics.clear();

}

cv::theRNG().state = param_seed; //this rng should generate same numbers for each run

++currentIter;

bool has_next = false;

do {

assert(currentIter == times.size());

if (currentIter == 0)

{

has_next = true;

break;

}

if (param_strategy == PERF_STRATEGY_BASE)

{

has_next = currentIter < nIters && totalTime < timeLimit;

}

else

{

assert(param_strategy == PERF_STRATEGY_SIMPLE);

if (totalTime - lastActivityPrintTime >= cv::getTickFrequency() * 10)

{

std::cout << '.' << std::endl;

lastActivityPrintTime = totalTime;

}

if (currentIter >= nIters)

{

has_next = false;

break;

}

if (currentIter < param_min_samples)

{

has_next = true;

break;

}

calcMetrics();

double criteria = 0.03; // 3%

if (fabs(metrics.mean) > 1e-6)

has_next = metrics.stddev > criteria * fabs(metrics.mean);

else

has_next = true;

}

} while (false);

#ifdef ANDROID

if (log_power_checkpoints)

{

timeval tim;

gettimeofday(&tim, NULL);

unsigned long long t1 = tim.tv_sec * 1000LLU + (unsigned long long)(tim.tv_usec / 1000.f);

if (currentIter == 1) RecordProperty("test_start", cv::format("%llu",t1).c_str());

if (!has_next) RecordProperty("test_complete", cv::format("%llu",t1).c_str());

}

#endif

if (has_next)

startTimer(); // really we should measure activity from this moment, so reset start time

return has_next;

{

switch(wtype)

{

case WARMUP_READ:

cv::sum(m.reshape(1));

return;

case WARMUP_WRITE:

m.reshape(1).setTo(cv::Scalar::all(0));

return;

case WARMUP_RNG:

randu(m);

return;

default:

return;

}

{

unsigned int res = 0;

for (SizeVector::const_iterator i = inputData.begin(); i != inputData.end(); ++i)