Главная » C++ » Eigen & amp; OpenMP: нет распараллеливания из-за ложного совместного использования и перегрузки потока

Eigen & amp; OpenMP: нет распараллеливания из-за ложного совместного использования и перегрузки потока

Спецификация системы:

  1. Процессор Intel Xeon E7-v3 (4 разъема, 16 ядер / разъемов, 2
    нитей / ядро)
  2. Использование семейства Eigen и C ++

Ниже приведена последовательная реализация фрагмента кода:

Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);
for (int k=0; k<nCols; ++k) {
row(k) = get_Matrix_Entry(j,k+nColStart);
}

}

double get_Matrix_Entry(int x , int y){
return exp(-(x-y)*(x-y));
}

Мне нужно распараллелить часть get_Row, так как nCols может достигать 10 ^ 6, поэтому я попробовал определенные методы, как:

  1. Наивное распараллеливание:

    Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {
Eigen::VectorXd row(nCols);

#pragma omp parallel for schedule(static,8)
for (int k=0; k<nCols; ++k) {
row(k)    =   get_Matrix_Entry(j,k+nColStart);

return row;
}

  2. Стрип майнинг:

    Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {
int vec_len = 8;
Eigen::VectorXd row(nCols) ;
int i,cols;
cols=nCols;
int rem = cols%vec_len;
if(rem!=0)
cols-=rem;

#pragma omp parallel for
for(int ii=0;ii<cols; ii+=vec_len){
for(i=ii;i<ii+vec_len;i++){
row(i) = get_Matrix_Entry(j,i+nColStart);
}
}

for(int jj=i; jj<nCols;jj++)
row(jj) = get_Matrix_Entry(j,jj+nColStart);

return row;
}

  3. Где-то из Интернета, чтобы избежать ложного обмена:

    Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {
int cache_line_size=8;
Eigen::MatrixXd row_m(nCols,cache_line_size);

#pragma omp parallel for schedule(static,1)
for (int k=0; k<nCols; ++k)
row_m(k,0)  =   get_Matrix_Entry(j,k+nColStart);

Eigen::VectorXd row(nCols);
row = row_m.block(0,0,nCols,1);

return row;

}

ВЫХОД:

Ни один из вышеперечисленных методов не помог в сокращении времени, необходимого для выполнения get_row для больших nCols, подразумевая, что параллельное распараллеливание работает аналогично другим методам (хотя лучше по сравнению с последовательным), какие-либо предложения или метод, которые могут помочь улучшить время?

Как упомянул пользователь Avi Ginsburg, я упоминаю некоторые другие детали системы:

  • g ++ (GCC) — компилятор с версией 4.4.7
  • Собственная версия библиотеки 3.3.2
  • Используемые флаги компилятора: «-c -fopenmp -Wall -march = native -O3 -funroll-all-loops -ffast-math -ffinite-math-only -I header», здесь header — папка, содержащая Eigen.

  • Вывод gcc -march = native -Q —help = target -> (упоминаются только описания некоторых флагов):

    -mavx [включено]

    -mfancy-math-387 [включено]

    -мфма [отключено]

    -март = core2

Для полного описания флагов, пожалуйста, смотрите этот.

1

Решение

Попробуйте переписать ваши функции как одно выражение и позвольте Eigen векторизовать себя, то есть:

Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);

row = (-( Eigen::VectorXd::LinSpaced(nCols, nColStart, nColStart + nCols - 1).array()
- double(j)).square()).exp().matrix();

return row;
}

Обязательно используйте -mavx а также -mfma (или -march = native) при компиляции. Дает мне ускорение x4 на i7 (я знаю, вы говорите о попытке использовать потоки 64/128, но это с одним потоком).

Вы можете включить openmp для дальнейшего ускорения, разделив вычисления на сегменты:

Eigen::VectorXd get_Row_omp(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);

#pragma omp parallel
{
int num_threads = omp_get_num_threads();
int tid = omp_get_thread_num();
int n_per_thread = nCols / num_threads;
if ((n_per_thread * num_threads < nCols)) n_per_thread++;
int start = tid * n_per_thread;
int len = n_per_thread;
if (tid + 1 == num_threads) len = nCols - start;

if(start < nCols)
row.segment(start, len) = (-(Eigen::VectorXd::LinSpaced(len,
nColStart + start, nColStart + start + len - 1)
.array() - double(j)).square()).exp().matrix();

}
return row;

}

Что касается меня (4 ядра), я получаю дополнительное ускорение ~ 3,3 при вычислении 10 ^ 8 элементов, но ожидаю, что оно будет ниже для 10 ^ 6 и / или 64/128 ядер (конечно, с учетом количества ядер).

редактировать

Я не ставил никаких проверок, чтобы убедиться, что потоки OMP не выходят за пределы и
Я перепутал второй и третий аргументы в Eigen::VectorXd::LinSpaced серийной версии. Это, вероятно, объясняет любые ваши ошибки. Кроме того, я вставил код, который я использовал для тестирования здесь. Я собрал с g++ -std=c++11 -fopenmp -march=native -O3, адаптироваться к вашим потребностям.

#include <Eigen/Core>
#include <iostream>
#include <omp.h>double get_Matrix_Entry(int x, int y) {
return exp(-(x - y)*(x - y));
}

Eigen::VectorXd get_RowOld(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);
for (int k = 0; k<nCols; ++k) {
row(k) = get_Matrix_Entry(j, k + nColStart);
}
return row;
}Eigen::VectorXd get_Row(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);

row = (-( Eigen::VectorXd::LinSpaced(nCols, nColStart, nColStart + nCols - 1).array() - double(j)).square()).exp().matrix();

return row;
}

Eigen::VectorXd get_Row_omp(const int j, const int nColStart, const int nCols) {

Eigen::VectorXd row(nCols);

#pragma omp parallel
{
int num_threads = omp_get_num_threads();
int tid = omp_get_thread_num();
int n_per_thread = nCols / num_threads;
if ((n_per_thread * num_threads < nCols)) n_per_thread++;
int start = tid * n_per_thread;
int len = n_per_thread;
if (tid + 1 == num_threads) len = nCols - start;#pragma omp critical
{
std::cout << tid << "/" << num_threads << "\t" << n_per_thread << "\t" << start <<
"\t" << len << "\t" << start+len << "\n\n";
}

if(start < nCols)
row.segment(start, len) = (-(Eigen::VectorXd::LinSpaced(len, nColStart + start, nColStart + start + len - 1).array() - double(j)).square()).exp().matrix();

}
return row;
}

int main()
{
std::cout << EIGEN_WORLD_VERSION << '.' << EIGEN_MAJOR_VERSION << '.' << EIGEN_MINOR_VERSION << '\n';
volatile int b = 3;
int sz = 6553600;
sz = 16;
b = 6553500;
b = 3;
{
auto beg = omp_get_wtime();
auto r = get_RowOld(5, b, sz);
auto end = omp_get_wtime();
auto diff = end - beg;
std::cout << r.rows() << "\t" << r.cols() << "\n";
//              std::cout << r.transpose() << "\n";
std::cout << "Old: " << r.mean() << "\n" << diff << "\n\n";

beg = omp_get_wtime();
auto r2 = get_Row(5, b, sz);
end = omp_get_wtime();
diff = end - beg;
std::cout << r2.rows() << "\t" << r2.cols() << "\n";
//              std::cout << r2.transpose() << "\n";
std::cout << "Eigen:         " << (r2-r).cwiseAbs().sum() << "\t" << (r-r2).cwiseAbs().mean() << "\n" << diff << "\n\n";

auto omp_beg = omp_get_wtime();
auto r3 = get_Row_omp(5, b, sz);
auto omp_end = omp_get_wtime();
auto omp_diff = omp_end - omp_beg;
std::cout << r3.rows() << "\t" << r3.cols() << "\n";
//              std::cout << r3.transpose() << "\n";
std::cout << "OMP and Eigen: " << (r3-r).cwiseAbs().sum() << "\t" << (r - r3).cwiseAbs().mean() << "\n" << omp_diff << "\n";
}

return 0;

}
2

Другие решения

Других решений пока нет …

Источник
По вопросам рекламы [email protected]
Web-Answers © 2024 Наверх