C 真正依赖的并行化

将真正的依赖循环并行化值得吗？有什么利弊？我们平均能得到多少加速

例如：

    int sum = 0;
    for(i=0;i<2000-1;i++){
            for(j=0;j<2000;j++) {
                curr[i][j] = some_value_here;
                sum += curr[i][j];
            }
    }

int和=0；
for（i=0；i
sum
充当一个简单的累加器，整个操作是一个并行归约。正确的解决方案是让每个线程累加自己的私有和，然后在末尾将所有私有和相加。OpenMP提供了
归约
子句，它正好实现以下功能：

int sum = 0;
#pragma omp parallel for collapse(2) reduction(+:sum)
for(i=0;i<2000-1;i++){
        for(j=0;j<2000;j++) {
            curr[i][j] = some_value_here;
            sum += curr[i][j];
        }
}

这里的潜在加速比等于执行单元的数量，前提是每个执行单元有一个线程，并且没有那么多线程，因此并行区域末尾的同步求和所需的时间可以忽略不计。
sum
充当一个简单的累加器，整个操作是一个并行的累加器归纳法。正确的解决方案是让每个线程累加自己的私有和，然后在末尾将所有私有和相加。OpenMP提供了
reduce
子句，该子句正好可以：

int sum = 0;
#pragma omp parallel for collapse(2) reduction(+:sum)
for(i=0;i<2000-1;i++){
        for(j=0;j<2000;j++) {
            curr[i][j] = some_value_here;
            sum += curr[i][j];
        }
}

这里的潜在加速比等于执行单元的数量，前提是每个执行单元有一个线程，并且没有那么多线程，因此并行区域末尾的同步求和所需的时间可以忽略不计。
这个问题的答案在于我对你的另一个问题的回答。哪一个，哈哈！什么你是说“真的”依赖关系？存在明显的写后读依赖关系；
sum
在每次迭代中写入，然后在下一次迭代中读取。在不了解硬件特性的情况下，无法说明可以获得多大的速度。写入的代码会添加3998000个附加项，但如果没有，依赖关系深度可以降低到ceil（日志[2]（3998000）−1))=22，所以如果你有硬件的话，单独加法的潜在加速比超过181727。@EricPostpischil，这实际上是一个简单的缩减问题，加速比大致等于执行单元的数量。@HristoIliev：正如我所写的，这取决于硬件。问题是我们可以得到多少加速一般，在没有硬件规范的情况下，这不是一个明智的问题。这个问题的答案在于我对你的另一个问题的回答。哪一个，哈哈！你说的“真”是什么意思依赖关系？存在明显的写后读依赖关系；
sum
在每次迭代中写入，然后在下一次迭代中读取。在不了解硬件特性的情况下，无法说明可以获得多大的速度。写入的代码会添加3998000个附加项，但如果没有，依赖关系深度可以降低到ceil（日志[2]（3998000）−1))=22，所以如果你有硬件的话，单独加法的潜在加速比超过181727。@EricPostpischil，这实际上是一个简单的缩减问题，加速比大致等于执行单元的数量。@HristoIliev：正如我所写的，这取决于硬件。问题是我们可以得到多少加速平均，在没有硬件规范的情况下，这不是一个合理的问题。我使用16和32个线程进行测试，您认为您使用原子操作的方式是一个好的选择吗？我不是说使用
原子
-这只是为了说明当您应用
reduce
子句时OpenMP为您做了什么。我使用要测试16和32个线程，您认为您使用原子操作的方式是一个好选择吗？我不是说使用
原子
-它只是为了说明当您应用
reduce
子句时OpenMP为您做了什么。