omp reduction on vector of cv::Mat or cv::Mat in general

Question

//In other words, this equilavent to cv::Mat1f mat(5,n)
//i.e. a matrix 5xn
std::vector<cv::Mat1f> mat(5,cv::Mat1f::zeros(1,n));
std::vector<float> indexes(m);
// fill indexes
// m >> nThreads (from hundreds to thousands)
for(size_t i=0; i<m; i++){
  mat[indexes[m]] += 1;
}

The expected result is to increase each element of each row by one. This is a toy example, the actual sum is far more compliacted. I tried to parallelize it with:

#pragma omp declare reduction(vec_float_plus : std::vector<cv::Mat1f> : \
            std::transform(omp_out.begin(), omp_out.end(), omp_in.begin(), omp_out.begin(), std::plus<cv::Mat1f>())) \
            initializer(omp_priv=omp_orig);

#pragma omp parallel for reduction(vec_float_plus : mat)
for(size_t i=0; i<m; i++){
    mat[indexes[m]] += 1;
}

But this fails because each element of each row is randomly inizitialized. How can I solve this?

So I found out that the problem is related to this. So I should initialize mat with:

std::vector<cv::Mat1f> mat(5);
for(size_t i=0; i<mat.size(); i++)
  mat[i] = cv::Mat1f::zeros(1,n);

But then this would create problems with omp_priv = omp_orig, since it would consider std::vector<cv::Mat1f> mat(5); and it's values are undefined. How can I solve this? The only solution that came to my mind is to create a wrapper structure, something like:

class vectMat{
public:
    vectMat(size_t rows, size_t j){
        for(size_t i=0; i<rows; i++)
            mats.push_back(cv::Mat1f::zeros(1,j));
    }
private:
    std::vector<cv::Mat1f> mats;
};

But then what should I implement to make it work with the rest of the code?

What do you mean with *"each element of each row is randomly inizitialized"*? — Zulan, Apr 04 '17 at 08:14
@Zulan In the previous case the different lines were "linked", so I can't initialize `mat` as in the first case, but then there are problems with `omp_priv = omp_orig` , don't you think? — justHelloWorld, Apr 04 '17 at 09:24

Zulan · Answer 1 · 2017-04-04T10:36:45.447

1

Types such as cv::Mat1f, that use references instead of copying, are indeed dangerous in this context. You make a clear explicit solution by splitting the parallel region and the for loop.

#pragma omp declare reduction(vec_mat1f_plus : std::vector<cv::Mat1f> : \
            std::transform(omp_out.begin(), omp_out.end(), omp_in.begin(), omp_out.begin(), std::plus<cv::Mat1f>()));
// initializer not necessary if you initialize explicitly

std::vector<cv::Mat1f> mat;
#pragma omp parallel reduction(vec_mat1f_plus : mat)
{
  mat = std::vector<cv::Mat1f>(5);
  for (auto& elem : mat) {
    elem = cv:Mat1f::zeros(1, n);
  }
  #pragma omp for
  for(size_t i=0; i<m; i++){
    mat[indexes[m]] += 1;
  }
}

^{I haven't tested whether std::plus<cv::Mat1f> works, but it looks good.}

Your approach with vectMat will also work if you provide an operator= that deep-copies the underlying Mat with clone(), and keep the initializer.

edited Apr 04 '17 at 10:36

answered Apr 04 '17 at 07:30

Zulan

21,896
6
49
109

thanks for your answer. I oversimplified my example, please look at my updated question – justHelloWorld Apr 04 '17 at 07:36
@justHelloWorld I updated the answer on your updated question. Think I got it not what you need. – Zulan Apr 04 '17 at 10:37
thanks for your update. However, at the end of this code `mat.size()=0` :( – justHelloWorld Apr 04 '17 at 10:49
Of course if was 0: I was not initializing `mat` before the reduction (so stupid for me). I edited your question (first time that I do it, I don't know how it works :D) – justHelloWorld Apr 04 '17 at 11:13

omp reduction on vector of cv::Mat or cv::Mat in general

1 Answers1

Linked