带有任务的 OpenMP 代码的特殊性能：1 个线程的性能优于多个线程答案

【问题标题】：Peculiar performance of OpenMP code with tasks: 1 thread performing better than multiple threads带有任务的 OpenMP 代码的特殊性能：1 个线程的性能优于多个线程
【发布时间】：2012-10-07 00:22:37
【问题描述】：

我有以下代码，我已经为其实现了明确的任务版本：

int waves = N_a + N_b +1;  /*considering N_a == N_b */
#pragma omp parallel firstprivate(a, gap, waves) private(temp, wave, ii, i) shared(np, mp, elements)
    {
#pragma omp master
        {
            for(wave = 0; wave < waves; ++wave) {
                // 0 <= wave < n-1
                if(wave < N_a-1) {
                    elements = wave+1;
                    np = wave+1;
                    mp = 0+1;
                }
                // n-1 <= wave < m
                else if(wave < N_b) {
                    elements = N_a;
                    np = N_a-1+1;
                    mp = wave-(N_a-1)+1;
                }
                // m <= wave < m+n-1
                else {
                    elements = N_a-1-(wave-N_b);
                    np = N_a-1+1;
                    mp = wave-(N_a-1)+1;
                }

                for(ii = 0; ii < elements; ii+=chunk) {
                    min = MIN(elements,ii + chunk);
#pragma omp task firstprivate(ii, np, mp, chunk, elements)
                    {
                        for (i = ii; i < min; i++)
                        {

                        temp[0] = H[(np-i)-1][(mp+i)-1] + similarity(seq_a[a][(np-i)-1],seq_b[a][(mp+i)-1]);
                        temp[1] = H[(np-i)-1][(mp+i)]-gap;
                        temp[2] = H[(np-i)][(mp+i)-1]-gap;
                        temp[3] = 0;
                        H[(np-i)][(mp+i)] = find_array_max(temp,4);
                        }
                    } // task
                } //for loop
 #pragma omp taskwait
            }
        }

    }

奇怪的是，在执行代码时，1 线程的性能比 2、4、8 和 16 线程的性能要好得多。只有一个并行区域，我已经剥离了内部 for 循环，以便每个“块”数量的元素都有助于创建任务。

我坚持创建一个任务实现，因为其中元素的价值会不断变化，我觉得代码有潜力通过高效的任务实现来对抗非结构化并行。

我正在英特尔 xe12 版本的编译器上尝试这个。以下是我观察到的样本块大小读数：256 和 N_a = N_b = 4096：

1 个线程：1.237560 2个线程：7.223232 4 个线程：4.579173 8 个线程：3.663661 16 线程：4.425525

我注意到 gcc 编译器的类似行为。有人可以请为什么带有 1 个线程的代码比多线程做得更好。对于 N_a = N_b = 1024、2048 和 8192，我也看到了类似的结果。

谢谢。

【问题讨论】：

你能提供一个小的、独立的例子吗？
你应该检查here以了解性能。
“1 个线程”是指使用OMP_NUM_THREADS=1 运行还是在未启用 OpenMP 的情况下进行编译？

标签： c parallel-processing task openmp

【解决方案1】：

您的所有代码都由#pragma omp master 保护，它只允许主线程运行所有计算。您必须删除此编译指示（或者有任何理由吗？）才能看到至少一些缩放。

【讨论】：