Проблема воспроизводимости вывода openMP

Я считаю, что проблема заключается в объявлении int i и float argg вне параллельного цикла.

Происходит то, что все ваши 200 потоков перезаписывают i и argg, поэтому иногда argg потока перезаписывается argg из другого потока, что приводит к непредсказуемой ошибке, которую вы наблюдаете.

Вот рабочий код, который всегда печатает одно и то же значение (до 6 знаков после запятой или около того):

void main()
{
    int nb = 200, blob;
    float summ = 0, dx;// , argg;
    dx = 1. / nb;

    printf("\n dx------------: %f \n", dx);

    omp_set_num_threads(nb);
#pragma omp parallel
    {

        blob = omp_get_num_threads();

        printf("\n we have now %d number of threads...\n", blob);

        int i = omp_get_thread_num();
        printf("\n i is now: %d \n", i);

        float argg = (4. / (1. + i * dx*i*dx))*dx;
        summ = summ + argg;
        printf("\t\t and summ is %f \n", summ);
    }

    printf("\ntotal summ after loop: %f\n", summ);
}

Однако изменение последней строки на %.9f показывает, что на самом деле это не то же самое число с плавающей запятой. Это связано с числовыми ошибками в сложениях с плавающей запятой. a+b+c не гарантирует того же результата, что и a+c+b. Вы можете попробовать это в следующем примере:

Сначала добавьте float* arr = new float[nb];до параллельный цикл И arr[i] = argg;в пределах параллельный цикл, после того, как argg определено, конечно. Затем добавьте следующий после параллельный цикл:

float testSum = 0;
for (int i = 0; i < nb; i++)
    testSum += arr[i];
printf("random sum: %.9f\n", testSum);

std::sort(arr, arr + nb);
testSum = 0;

for (int i = 0; i < nb; i++)
    testSum += arr[i];
printf("sorted sum: %.9f\n", testSum);

testSum = 0;
for (int i = nb-1; i >= 0; i--)
    testSum += arr[i];
printf("reversed sum: %.9f\n", testSum);

Скорее всего, отсортированная сумма и обратная сумма немного отличаются, хотя они составлены путем сложения одних и тех же 200 чисел.

Еще одна вещь, которую вы, возможно, захотите отметить, это то, что вы вряд ли найдете процессор, который может фактически выполнять 200 потоков параллельно. Наиболее распространенные процессоры могут обрабатывать от 4 до 32 потоков, в то время как специализированные серверные процессоры могут обрабатывать до 112 потоков с Xeon Platinum 9282 за 15 тысяч долларов.

Поэтому мы обычно делаем следующее:

Убираем omp_set_num_threads(nb);, чтобы использовать рекомендуемое количество потоков

Мы удаляем int i = omp_get_thread_num();, чтобы использовать int i из цикла for

Перепишем цикл как цикл for:

#pragma omp parallel for
for (int i = 0; i < nb; i++)
    {...}

Результат должен быть идентичным, но теперь вы используете столько потоков, сколько доступно на реальном оборудовании. Это уменьшает переключение контекста между потоками и должно повысить производительность кода.

Проблема связана с переменными summ, argg и i. Они относятся к глобальной последовательной области видимости и не могут быть изменены без соблюдения мер предосторожности. У вас будут гонки между потоками, и это может привести к неожиданным значениям в этих var. Гонки совершенно недетерминированы, и это объясняет разные результаты, которые вы получаете. Вы также можете получить правильный результат или любой неправильный результат в зависимости от временных вхождений чтения и записи в эти переменные.

Правильный способ решения этой проблемы:

• для переменных argg и i: они объявлены в глобальной области видимости, но используются для выполнения временных вычислений в потоках. Вы должны: либо объявить их в параллельном домене, чтобы сделать их частными потоками, либо добавить private(argg,i) в директиву omp. Обратите внимание, что существует также потенциальная проблема для blob, но его значение одинаково во всех потоках, и это не должно влиять на поведение программы.

• для переменной summ ситуация иная. Это В самом деле — глобальная переменная, которая накапливает некоторые значения из потоков. Он должен оставаться глобальным, но вы должны добавить директиву atomic openmp при его изменении. Полная операция чтения-модификации-записи для переменной станет нерушимой, и это обеспечит модификацию без гонок.

Вот модифицированная версия вашего кода, которая дает согласованный результат (но поплавки не являются ассоциативными, и последнее десятичное число может измениться).

#include<stdio.h>
#include<stdlib.h>
#include<omp.h>

void main()

{
  int nb=200,i,blob;
  float summ=0,dx,argg;
  dx=1./nb;

  printf("\n dx------------: %f \n",dx);

  omp_set_num_threads(nb);
# pragma omp parallel private(argg,i)
  {
    blob=omp_get_num_threads();

    printf("\n we have now %d number of threads...\n",blob);

    int ID=omp_get_thread_num();
    i=ID;
    printf("\n i is now: %d \n",i);

    argg=(4./(1.+i*dx*i*dx))*dx;
    #pragma omp atomic
    summ=summ+argg;

    printf("\t\t and summ is %f \n",summ);
  }

  printf("\ntotal summ after loop: %f\n",summ);

}

Как уже отмечалось, это не лучший способ использования потоков. Создание и синхронизация потоков требует больших затрат, и редко требуется иметь больше потоков, чем количество ядер.