使用 OpenMP 并行化用于 2D Haar 小波变换的 C 代码

Question

这是我的第一个问题。我正在尝试将 C 中的 2d haar 变换函数与 openMP 并行化。我获得了它here 并进行了相应的修改。 该程序获取黑白图像，将其放入矩阵并计算一级哈尔小波变换。最后，它将值标准化并将转换后的图像写入磁盘。

这是生成的图像1 level of HDT

我的问题是并行版本的运行速度比串行版本慢得多。 现在我在此处附上我要并行化的主要部分的 sn-p（稍后我可以放置所有周围的代码）：

void haar_2d ( int m, int n, double u[] )
// m & n are the dimentions (every image is a perfect square)
//u is the input array in **(non column-major!)** row-major order</del>
int i;
int j;
int k;
double s;
double *v;

int tid, nthreads, chunk;

s = sqrt ( 2.0 );

v = ( double * ) malloc ( m * n * sizeof ( double ) );

for ( j = 0; j < n; j++ )
{
    for ( i = 0; i < m; i++ )
    {
        v[i+j*m] = u[i+j*m];
    }
}
/*
Determine K, the largest power of 2 such that K <= M.
*/
k = 1;
while ( k * 2 <= m )
{
    k = k * 2;
}

/*   Transform all columns.  */

while ( n/2 < k ) // just 1 level of transformation
{
    k = k / 2;

    clock_t begin = clock();

    #pragma omp parallel shared(s,v,u,n,m,nthreads,chunk) private(i,j,tid)
    {
        tid = omp_get_thread_num();
        printf("Thread %d starting...\n",tid);

        #pragma omp for schedule (dynamic)
        for ( j = 0; j < n; j++ )
        {
            for ( i = 0; i < k; i++ )
            {               
                v[i  +j*m] = ( u[2*i+j*m] + u[2*i+1+j*m] ) / s;
                v[k+i+j*m] = ( u[2*i+j*m] - u[2*i+1+j*m] ) / s;
            }
        }

    #pragma omp for schedule (dynamic)
    for ( j = 0; j < n; j++ )
    {
        for ( i = 0; i < 2 * k; i++ )
        {
            u[i+j*m] = v[i+j*m];
        }
    }
}//end parallel

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf ( "Time for COLUMNS: %f ms\n", time_spent * 1000);

}//end while

// [...]code for rows
free ( v );

return;}

时间或多或少是：

Time for COLUMNS: 160.519000 ms // parallel
Time for COLUMNS: 62.842000 ms // serial

我尝试以多种不同的方式重新安排编译指示，例如使用静态调度、部分、任务等，还重新安排变量的数据范围并在并行区域内动态分配。 我认为并行化 2 级会很简单，但现在我已经苦苦挣扎了两天。寻求您的帮助，我已经在这里检查了所有相关问题，但仍然无法继续，或者至少无法理解原因。先感谢您。 （CPU Intel Core i3-4005U CPU @ 1.70GHz × 4线程，2核）

更新：

1) m & n 呢，它应该有一天也实现矩形图像，所以我把它留在那里。

2）我发现 u 实际上是一个普通数组，里面有一个线性化矩阵，即逐行（我使用 PGM 图像）。

3) memcpy 是一个更好的选择，所以现在我正在使用它。

关于主要话题，我试图通过为每个块生成一个任务来将作业划分为 n，结果比串行代码快一点。 现在我知道输入矩阵 u 处于良好的行优先顺序，2 个 fors 似乎相应地进行，但我不确定时间：同时使用 omp_get_wtime() 和 clock() 我不知道如何测量加速。我用不同的图像尺寸进行了测试，从 16x16 到 4096x4096，并行版本似乎使用 clock() 更慢，使用 omp_get_wtime() 和 gettimeofday() 更快。 对于如何使用 OpenMP 正确处理它，或者至少如何正确测量加速比，您有什么建议吗？

while ( n/2 < k )
{
    k = k / 2;
    double start_time = omp_get_wtime();
    // clock_t begin = clock();
    #pragma omp parallel shared(s,v,u,n,m,nthreads,chunk) private(i,j,tid) firstprivate(k)
    {
        nthreads = omp_get_num_threads();

         #pragma omp single
         {
          printf("Number of threads = %d\n", nthreads);

          int chunk = n/nthreads;
          printf("Chunks size = %d\n", chunk);
          printf("Thread %d is starting the tasks.\n", omp_get_thread_num());

          int h;

          for(h=0;h<n;h = h + chunk){
          printf("FOR CYCLE i=%d\n", h);

            #pragma omp task shared(s,v,u,n,m,nthreads,chunk) private(i,j,tid) firstprivate(h,k)
            {
                tid = omp_get_thread_num();
                 printf("Thread %d starts at %d position\n", tid , h);

                for ( j = h; j < h + chunk; j++ )
                {
                    for ( i = 0; i < k; i++ )
                    {
                        v[i  +j*m] = ( u[2*i+j*m] + u[2*i+1+j*m] ) / s;
                        v[k+i+j*m] = ( u[2*i+j*m] - u[2*i+1+j*m] ) / s;
                    }
                }
            }// end task
        }//end launching for
        #pragma omp taskwait
        }//end single
        }//end parallel region

        // clock_t end = clock();
        // double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
        // printf ( "COLUMNS: %f ms\n", time_spent * 1000);

        double time = omp_get_wtime() - start_time;
        printf ( "COLUMNS: %f ms\n", time*1000);

    for ( j = 0; j < n; j++ )
    {
        for ( i = 0; i < 2 * k; i++ )
        {
            u[i+j*m] = v[i+j*m];
        }
    }
 }//end while

Answer 1

关于您的代码，我有几个问题让我深感担忧。

1. m & n 是尺寸（每个图像都是一个完美的正方形）

   那为什么会有两个尺寸参数呢？

2. u 是列优先顺序的输入数组

   这是一个非常糟糕的主意。 C 对内存使用行优先排序，因此列优先索引会导致跨步内存访问。这对性能非常、非常不利。如果可能的话，你需要解决这个问题。

3. 因为u 和v 都是线性化矩阵，那么这个

   for (int j = 0; j < n; j++) {
       for (int i = 0; i < m; i++) {
           v[i + j * m] = u[i + j * m];
       }
   }
   

   可以替换为调用memcpy。

   memcpy(v, u, m * n * sizeof(double));
   

---

关于您的问题。您使用 OpenMP 的版本较慢的原因是您的所有线程都在做同样的事情。这没有用，并且会导致像false sharing 这样的坏事。您需要使用每个线程的 id（代码中的tid）来跨线程分区数据；请记住，虚假分享是不好的。

Answer 2

问题是我使用的是clock()而不是omp_get_wtime()，这要感谢Z boson。