使用OpenMP并行化两个for循环。

huangapple go评论59阅读模式
英文:

Parallelise 2 for loops with OpenMP

问题

以下是代码部分的中文翻译:

所以我有这个函数,我必须使用OpenMP静态调度来并行化,以适应n个线程

void computeAccelerations(){
    int i,j;
    for(i=0;i<bodies;i++){
        accelerations[i].x = 0;	accelerations[i].y = 0; accelerations[i].z = 0;
        for(j=0;j<bodies;j++){
            if(i!=j){
                //accelerations[i] = addVectors(accelerations[i],scaleVector(GravConstant*masses[j]/pow(mod(subtractVectors(positions[i],positions[j])),3),subtractVectors(positions[j],positions[i])));
                vector sij = {positions[i].x-positions[j].x,positions[i].y-positions[j].y,positions[i].z-positions[j].z};
                vector sji = {positions[j].x-positions[i].x,positions[j].y-positions[i].y,positions[j].z-positions[i].z};
                double mod = sqrt(sij.x*sij.x + sij.y*sij.y + sij.z*sij.z);
                double mod3 = mod * mod * mod;
                double s = GravConstant*masses[j]/mod3;
                vector S = {s*sji.x,s*sji.y,s*sji.z};
                accelerations[i].x+=S.x;accelerations[i].y+=S.y;accelerations[i].z+=S.z;
            }
        }
    }
}

我尝试做类似的事情:

```c
void computeAccelerations_static(int num_of_threads){
int i,j;
#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for(i=0;i<bodies;i++){
    accelerations[i].x = 0; accelerations[i].y = 0; accelerations[i].z = 0;
    for(j=0;j<bodies;j++){
        if(i!=j){
            //accelerations[i] = addVectors(accelerations[i],scaleVector(GravConstant*masses[j]/pow(mod(subtractVectors(positions[i],positions[j])),3),subtractVectors(positions[j],positions[i])));
            vector sij = {positions[i].x-positions[j].x,positions[i].y-positions[j].y,positions[i].z-positions[j].z};
            vector sji = {positions[j].x-positions[i].x,positions[j].y-positions[i].y,positions[j].z-positions[i].z};
            double mod = sqrt(sij.x*sij.x + sij.y*sij.y + sij.z*sij.z);
            double mod3 = mod * mod * mod;
            double s = GravConstant*masses[j]/mod3;
            vector S = {s*sji.x,s*sji.y,s*sji.z};
            accelerations[i].x+=S.x;accelerations[i].y+=S.y;accelerations[i].z+=S.z;
        }
    }
}

自然而然地添加#pragma omp parallel for num_threads(num_of_threads) schedule(static),但这并不正确。

我认为accelerations[i]存在一些虚假共享问题,但我不知道如何解决它。我感激任何帮助。谢谢。


<details>
<summary>英文:</summary>
So I have this function that I have to parallelize with OpenMP static scheduling for n threads
void computeAccelerations(){
int i,j;
for(i=0;i&lt;bodies;i++){
accelerations[i].x = 0;	accelerations[i].y = 0; accelerations[i].z = 0;
for(j=0;j&lt;bodies;j++){
if(i!=j){
//accelerations[i] = addVectors(accelerations[i],scaleVector(GravConstant*masses[j]/pow(mod(subtractVectors(positions[i],positions[j])),3),subtractVectors(positions[j],positions[i])));
vector sij = {positions[i].x-positions[j].x,positions[i].y-positions[j].y,positions[i].z-positions[j].z};
vector sji = {positions[j].x-positions[i].x,positions[j].y-positions[i].y,positions[j].z-positions[i].z};
double mod = sqrt(sij.x*sij.x + sij.y*sij.y + sij.z*sij.z);
double mod3 = mod * mod * mod;
double s = GravConstant*masses[j]/mod3;
vector S = {s*sji.x,s*sji.y,s*sji.z};
accelerations[i].x+=S.x;accelerations[i].y+=S.y;accelerations[i].z+=S.z;
}
}
}
}
I tried to do something like:

void computeAccelerations_static(int num_of_threads){
int i,j;
#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for(i=0;i<bodies;i++){
accelerations[i].x = 0; accelerations[i].y = 0; accelerations[i].z = 0;
for(j=0;j<bodies;j++){
if(i!=j){
//accelerations[i] = addVectors(accelerations[i],scaleVector(GravConstantmasses[j]/pow(mod(subtractVectors(positions[i],positions[j])),3),subtractVectors(positions[j],positions[i])));
vector sij = {positions[i].x-positions[j].x,positions[i].y-positions[j].y,positions[i].z-positions[j].z};
vector sji = {positions[j].x-positions[i].x,positions[j].y-positions[i].y,positions[j].z-positions[i].z};
double mod = sqrt(sij.x
sij.x + sij.ysij.y + sij.zsij.z);
double mod3 = mod * mod * mod;
double s = GravConstantmasses[j]/mod3;
vector S = {s
sji.x,ssji.y,ssji.z};
accelerations[i].x+=S.x;accelerations[i].y+=S.y;accelerations[i].z+=S.z;
}
}
}


It comes naturally to just add the ```#pragma omp parallel for num_threads(num_of_threads) schedule(static)``` but it isn&#39;t correct. 
I think there is some kind of false sharing with the ``accelerations[i]`` but I don&#39;t know how to approach it. I appreciate any kind of help. Thank you.
</details>
# 答案1
**得分**: 2
在你的循环嵌套中,只有外部循环的迭代被并行化。因为`i`是循环控制变量,每个线程都有自己的私有副本,但从代码风格的角度来看,最好在循环控制块中声明`i`。
`j`则不同。它在并行区域之外声明,*不是*并行化循环的控制变量。因此,它在线程之间是共享的。因为执行`i`循环迭代的每个线程都操作共享变量`j`,所以会出现数据竞争的严重问题。这可以通过将`j`的声明移到并行区域内来解决(除其他替代方案之外),最好放在其关联循环的控制块中。
总之,代码应该是这样的:
```cpp
// int i, j;
#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for (int i = 0; i < bodies; i++) {
accelerations[i].x = 0;
accelerations[i].y = 0;
accelerations[i].z = 0;
#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for (int j = 0; j < bodies; j++) {
if (i != j) {
vector sij = { positions[i].x - positions[j].x,
positions[i].y - positions[j].y,
positions[i].z - positions[j].z };
double mod = sqrt(sij.x * sij.x + sij.y * sij.y + sij.z * sij.z);
double mod3 = mod * mod * mod;
double s = GravConstant * masses[j] / mod3;
accelerations[i].x -= s * sij.x;
accelerations[i].y -= s * sij.y;
accelerations[i].z -= s * sij.z;
}
}
}

还要注意,计算sji似乎是浪费的,因为在数学上它只是-sij,而且既不sji也不sij被修改。我建议将上述代码简化为以下形式:

#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for (int i = 0; i < bodies; i++) {
    accelerations[i].x = 0;
    accelerations[i].y = 0;
    accelerations[i].z = 0;

    for (int j = 0; j < bodies; j++) {
        if (i != j) {
            vector sij = { positions[i].x - positions[j].x,
                           positions[i].y - positions[j].y,
                           positions[i].z - positions[j].z };
            double mod = sqrt(sij.x * sij.x + sij.y * sij.y + sij.z * sij.z);
            double mod3 = mod * mod * mod;
            double s = GravConstant * masses[j] / mod3;

            accelerations[i].x -= s * sij.x;
            accelerations[i].y -= s * sij.y;
            accelerations[i].z -= s * sij.z;
        }
    }
}
英文:

In your loop nest, only the iterations of the outer loop are parallelized. Because i is the loop-control variable, each thread gets its own, private copy, but as a matter of style, it would be better to declare i in the loop control block.

j is another matter. It is declared outside the parallel region and it is not the control variable of a parallelized loop. As a result, it is shared among the threads. Because each of the threads executing i-loop iterations manipulates shared variable j, you have a huge problem with data races. This would be resolved (among other alternatives) by moving the declaration of j into the parallel region, preferrably into the control block of its associated loop.

Overall, then:

// int i, j;
#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for (int i = 0; i &lt; bodies; i++) {
accelerations[i].x = 0;
accelerations[i].y = 0;
accelerations[i].z = 0;
for (int j = 0; j &lt; bodies; j++) {
if (i != j) {
//accelerations[i] = addVectors(accelerations[i],scaleVector(GravConstant*masses[j]/pow(mod(subtractVectors(positions[i],positions[j])),3),subtractVectors(positions[j],positions[i])));
vector sij = { positions[i].x - positions[j].x,
positions[i].y - positions[j].y,
positions[i].z - positions[j].z };
vector sji = { positions[j].x - positions[i].x,
positions[j].y - positions[i].y,
positions[j].z - positions[i].z };
double mod = sqrt(sij.x * sij.x + sij.y * sij.y + sij.z * sij.z);
double mod3 = mod * mod * mod;
double s = GravConstant * masses[j] / mod3;
vector S = { s * sji.x, s * sji.y, s * sji.z };
accelerations[i].x += S.x;
accelerations[i].y += S.y;
accelerations[i].z += S.z;
}
}
}

Note also that computing sji appears to be wasteful, as in mathematical terms it is just -sij, and neither sji nor sij is modified. I would probably reduce the above to something more like this:

#pragma omp parallel for num_threads(num_of_threads) schedule(static)
for (int i = 0; i &lt; bodies; i++) {
accelerations[i].x = 0;
accelerations[i].y = 0;
accelerations[i].z = 0;
for (int j = 0; j &lt; bodies; j++) {
if (i != j) {
vector sij = { positions[i].x - positions[j].x,
positions[i].y - positions[j].y,
positions[i].z - positions[j].z };
double mod = sqrt(sij.x * sij.x + sij.y * sij.y + sij.z * sij.z);
double mod3 = mod * mod * mod;
double s = GravConstant * masses[j] / mod3;
accelerations[i].x -= s * sij.x;
accelerations[i].y -= s * sij.y;
accelerations[i].z -= s * sij.z;
}
}
}

huangapple
  • 本文由 发表于 2023年2月16日 04:05:40
  • 转载请务必保留本文链接:https://go.coder-hub.com/75464941.html
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定