{

pid_t pid=gettid();

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

if (syscallres)

{

int err=errno;

CV_UNUSED(err);

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;

}

#ifndef WINRT

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

#else

const char *data_path_dir = OPENCV_TEST_DATA_PATH;

#endif

cvtest::addDataSearchSubDirectory("");

cvtest::addDataSearchSubDirectory(testSuitName);

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;

{

return a.kind() == cv::_InputArray::STD_VECTOR_MAT || a.kind() == cv::_InputArray::STD_VECTOR_VECTOR ||

a.kind() == cv::_InputArray::STD_VECTOR_UMAT;

{

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] = {0};

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

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

}

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;

{

perf_validation_results.clear();

std::ifstream infile(fileName.c_str());

while (!infile.eof())

{

std::string name;

float value = 0;

if (!(infile >> value))

{

if (infile.eof())

break; // it is OK

std::cout << "ERROR: Can't load performance validation results from " << fileName << "!" << std::endl;

return;

}

infile.ignore(1);

if (!(std::getline(infile, name)))

{

std::cout << "ERROR: Can't load performance validation results from " << fileName << "!" << std::endl;

return;

}

if (!name.empty() && name[name.size() - 1] == '\r') // CRLF processing on Linux

name.resize(name.size() - 1);

perf_validation_results[name] = value;

}

std::cout << "Performance validation results loaded from " << fileName << " (" << perf_validation_results.size() << " entries)" << std::endl;

{

if (!perf_validation_results_outfile.empty())

{

std::ofstream outfile((perf_validation_results_directory + perf_validation_results_outfile).c_str());

std::map<std::string, float>::const_iterator i;

for (i = perf_validation_results.begin(); i != perf_validation_results.end(); ++i)

{

outfile << i->second << ';';

outfile << i->first << std::endl;

}

outfile.close();

std::cout << "Performance validation results saved (" << perf_validation_results.size() << " entries)" << std::endl;

}

{

virtual ~PerfValidationEnvironment() {}

virtual void SetUp() {}

virtual void TearDown()

{

savePerfValidationResults();

}

{

// Print empty line for a big tree nodes

if(pNode->m_pParent)

{

int parendIdx = pNode->m_pParent->findChild(pNode);

if(parendIdx > 0 && pNode->m_pParent->m_childs[parendIdx-1]->m_childs.size())

{

printShift(pNode->m_pParent->m_childs[parendIdx-1]->m_childs[0], pRoot);

printf("\n");

}

}

// Check if parents have more childes

std::vector<cv::instr::InstrNode*> cache;

cv::instr::InstrNode *pTmpNode = pNode;

while(pTmpNode->m_pParent && pTmpNode->m_pParent != pRoot)

{

cache.push_back(pTmpNode->m_pParent);

pTmpNode = pTmpNode->m_pParent;

}

for(int i = (int)cache.size()-1; i >= 0; i--)

{

if(cache[i]->m_pParent)

{

if(cache[i]->m_pParent->findChild(cache[i]) == (int)cache[i]->m_pParent->m_childs.size()-1)

printf(" ");

else

printf("| ");

}

}

{

if(pNode->m_pParent && pNode->m_pParent->m_pParent)

return ((double)pNode->m_payload.m_ticksTotal*100/pNode->m_pParent->m_payload.m_ticksTotal);

else

return 100;

{

cv::instr::InstrNode* globNode = pNode;

while(globNode->m_pParent && globNode->m_pParent->m_pParent)

globNode = globNode->m_pParent;

return ((double)pNode->m_payload.m_ticksTotal*100/(double)globNode->m_payload.m_ticksTotal);

{

printf("%s", (pNode->m_payload.m_funName.substr(0, 40) + ((pNode->m_payload.m_funName.size()>40)?"...":"")).c_str());

// Write instrumentation flags

if(pNode->m_payload.m_instrType != cv::instr::TYPE_GENERAL || pNode->m_payload.m_implType != cv::instr::IMPL_PLAIN)

{

printf("<");

if(pNode->m_payload.m_instrType == cv::instr::TYPE_WRAPPER)

printf("W");

else if(pNode->m_payload.m_instrType == cv::instr::TYPE_FUN)

printf("F");

else if(pNode->m_payload.m_instrType == cv::instr::TYPE_MARKER)

printf("MARK");

if(pNode->m_payload.m_instrType != cv::instr::TYPE_GENERAL && pNode->m_payload.m_implType != cv::instr::IMPL_PLAIN)

printf("_");

if(pNode->m_payload.m_implType == cv::instr::IMPL_IPP)

printf("IPP");

else if(pNode->m_payload.m_implType == cv::instr::IMPL_OPENCL)

printf("OCL");

printf(">");

}

if(pNode->m_pParent)

{

printf(" - TC:%d C:%d", pNode->m_payload.m_threads, pNode->m_payload.m_counter);

printf(" T:%.2fms", pNode->m_payload.getTotalMs());

if(pNode->m_pParent->m_pParent)

printf(" L:%.0f%% G:%.0f%%", calcLocalWeight(pNode), calcGlobalWeight(pNode));

}

printf("\n");

{

// Group childes by name

for(size_t i = 1; i < pNode->m_childs.size(); i++)

{

if(pNode->m_childs[i-1]->m_payload.m_funName == pNode->m_childs[i]->m_payload.m_funName )

continue;

for(size_t j = i+1; j < pNode->m_childs.size(); j++)

{

if(pNode->m_childs[i-1]->m_payload.m_funName == pNode->m_childs[j]->m_payload.m_funName )

{

cv::swap(pNode->m_childs[i], pNode->m_childs[j]);

i++;

}

}

}

}

for(size_t i = 0; i < pNode->m_childs.size(); i++)

{

printShift(pNode->m_childs[i], pRoot);

if(i == pNode->m_childs.size()-1)

printf("\\---");

else

printf("|---");

printNodeRec(pNode->m_childs[i], pRoot);

}

{

std::ostringstream out;

out << std::fixed << std::setprecision(p) << value;

return out.str();

{

cv::String string;

if (pNode->m_payload.m_funName == "ROOT")

string = pNode->m_payload.m_funName;

else

{

string = "#";

string += std::to_string((int)pNode->m_payload.m_instrType);

string += pNode->m_payload.m_funName;

string += " - L:";

string += to_string_with_precision(calcLocalWeight(pNode));

string += ", G:";

string += to_string_with_precision(calcGlobalWeight(pNode));

}

string += "(";

for(size_t i = 0; i < pNode->m_childs.size(); i++)

string += nodeToString(pNode->m_childs[i]);

string += ")";

return string;

{

uint64 ticks = 0;

if (pNode->m_pParent && (type < 0 || pNode->m_payload.m_instrType == type) && pNode->m_payload.m_implType == impl)

{

ticks = pNode->m_payload.m_ticksTotal;

return ticks;

}

for(size_t i = 0; i < pNode->m_childs.size(); i++)

ticks += getNodeTimeRec(pNode->m_childs[i], type, impl);

return ticks;

{

uint64 ticks = 0;

cv::instr::InstrNode *pRoot = cv::instr::getTrace();

ticks = getNodeTimeRec(pRoot, cv::instr::TYPE_FUN, impl);

return ticks;

{

uint64 ticks = 0;

cv::instr::InstrNode *pRoot = cv::instr::getTrace();

for(size_t i = 0; i < pRoot->m_childs.size(); i++)

ticks += pRoot->m_childs[i]->m_payload.m_ticksTotal;

return ticks;

{

cv::String string = nodeToString(cv::instr::getTrace());

return string;

{

printf("[ TRACE ]\n");

printNodeRec(cv::instr::getTrace(), cv::instr::getTrace());

#ifdef HAVE_IPP

printf("\nIPP weight: %.1f%%", ((double)getImplTime(cv::instr::IMPL_IPP)*100/(double)getTotalTime()));

#endif

#ifdef HAVE_OPENCL

printf("\nOPENCL weight: %.1f%%", ((double)getImplTime(cv::instr::IMPL_OPENCL)*100/(double)getTotalTime()));

#endif

printf("\n[/TRACE ]\n");

fflush(stdout);

{

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

plain_only.push_back("plain");

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

int argc, const char* const argv[])

{

CV_TRACE_FUNCTION();

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)}"

"{ perf_read_validation_results | |specifies file name with performance results from previous run}"

"{ perf_write_validation_results | |specifies file name to write performance validation results}"

#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 |}"

#ifdef HAVE_IPP

"{ perf_ipp_check |false |check whether IPP works without failures}"

#endif

#ifdef CV_COLLECT_IMPL_DATA

"{ perf_collect_impl |false |collect info about executed implementations}"

#endif

#ifdef ENABLE_INSTRUMENTATION

"{ perf_instrument |0 |instrument code to collect implementations trace: 1 - perform instrumentation; 2 - separate functions with the same name }"

#endif

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

#ifdef HAVE_CUDA

"{ perf_cuda_device |0 |run CUDA 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