问题

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

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

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;
            }
        }
    }
}

我尝试做类似的事情：

```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&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;
        }
    }
}

自然而然地添加#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.xsij.x + sij.ysij.y + sij.zsij.z);
double mod3 = mod * mod * mod;
double s = GravConstantmasses[j]/mod3;
vector S = {ssji.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;
}
}
}

通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。

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

问题

Golang：为什么 goroutines 不会并行运行？

股票统计计算，时间和空间复杂度均为O(1)。

静态结构初始化线程安全

这为什么会报错（多线程或ArrayList）？

What's the correct way to type hint an empty list as a literal in python?

如何在Highcharts Gantt中更改本地化的星期名称

如何在同一个流中使用多个过滤器和映射函数？

如何使用Map/Set来将代码优化到O(n)？

.NET MAUI Android在GitHub Actions上构建失败，错误代码为1。

如何在Playwright视觉比较中屏蔽多个定位器？

在C++中，可以使用可变模板参数来检索类型的内部类型。

selenium.common.exceptions.StaleElementReferenceException: Message: stale element reference: stale element not found

Creating and opening a URL to log in to Website via Basic Auth with Robot Framework/Selenium (Python)

AG Grid 在上下文菜单中以大文本形式打开

发表评论