Параллельное программирование с использованием OpenMP

7.3.1. Управление распределением итераций цикла между потоками

При разном объеме вычислений в разных итерациях цикла желательно иметь возможность управлять распределением итераций цикла между потоками - в OpenMP это обеспечивается при помощи параметра schedule директивы for. Поле type параметра schedule может принимать следующие значения:

setenv OMP_SCHEDULE "dynamic,3"

Полезность такого варианта очевидна - способ распределения итераций между потоками можно менять, не корректируя при этом код программы (т.е. без повторной компиляции и сборки программы).

Для демонстрации примера использования параметра schedule предположим, что матрица в примере 7.3 имеет верхний треугольный вид - в этом случае объем вычислений для каждой строки является различным и последовательное распределение итераций поровну приведет к неравномерному распределению вычислительной нагрузки между потоками. Для балансировки расчетов можно применить статическую или динамическую схемы распределения итераций:

#include <omp.h> 
#define CHUNK 100 
#define NMAX 1000 
main () { 
 int i, j, sum; 
 float a[NMAX][NMAX]; 
 <инициализация данных>
 #pragma omp parallel for shared(a) private(i,j,sum) \
                                      schedule (dynamic, CHUNK)
 { 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
} /* Завершение параллельного фрагмента */ 
}

7.3.2. Управление порядком выполнения вычислений

В результате распараллеливания цикла порядок выполнения итераций не фиксирован: в зависимости от состояния среды выполнения очередность выполнения итераций может меняться. Если же для ряда действий в цикле необходимо сохранить первичный порядок вычислений, который соответствует последовательному выполнению итераций в последовательной программе, то желаемого результата можно добиться при помощи директивы ordered (при этом для директивы for должен быть указан параметр ordered ). Поясним сказанное на примере нашей учебной задачи. Для приведенного выше варианта программы печать сумм элементов строк матрицы будет происходить в некотором произвольном порядке; при необходимости печати по порядку расположения строк следует провести следующее изменение программного кода:

#pragma omp parallel for shared(a) private(i,j,sum) \
                     schedule (dynamic, CHUNK) ordered { 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
#pragma omp ordered
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
} /* Завершение параллельного фрагмента */

Поясним дополнительно, что параметр ordered управляет порядком выполнения только тех действий, которые выделены директивой ordered - выполнение оставшихся действий в итерациях цикла по-прежнему может происходить параллельно. Важно помнить также, что директива ordered может быть применена в теле цикла только один раз.

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

7.3.3. Синхронизация вычислений по окончании выполнения цикла

По умолчанию, все потоки, прежде чем перейти к выполнению дальнейших вычислений, ожидают окончания выполнения итераций цикла даже если некоторые из них уже завершили свои вычисления - конец цикла представляет собой некоторый барьер, который потоки могут преодолеть только все вместе. Можно отменить указанную синхронизацию, указав параметр nowait в директиве for - тогда потоки могут продолжить вычисления за переделами цикла, если для них нет итераций цикла для выполнения.

7.3.4. Введение условий при определении параллельных фрагментов (параметр if директивы parallel)

Теперь при наличии учебного примера можно пояснить назначение параметра if директивы parallel.

При разработке параллельных алгоритмов и программ важно понимать, что организация параллельных вычислений приводит к появлению некоторых дополнительных накладных затрат - в частности, в параллельной программе затрачивается время на создание потоков, их активизацию, приостановку при завершении параллельных фрагментов и т.п. Тем самым, для достижения положительного эффекта сокращение времени вычислений за счет параллельного выполнения должно, по крайней мере, превышать временные затраты на организацию параллелизма. Для оценки целесообразности распараллеливания можно использовать параметр if директивы parallel, задавая при его помощи условие создания параллельного фрагмента (если условие параметра if не выполняется, блок директивы parallel выполняется как обычный последовательный код). Так, например, в нашем учебном примере можно ввести условие, определяющее минимальный размер матрицы, при котором осуществляется распараллеливание вычислений - программный код примера в этом случае может выглядеть следующим образом:

#include <omp.h> 
#define NMAX  1000 
#define LIMIT 100 
main () { 
 int i, j, sum; 
 float a[NMAX][NMAX]; 
 <инициализация данных>
 #pragma omp parallel for shared(a) private(i,j,sum) if (NMAX>LIMIT)
 { 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=0; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
 } /* Завершение параллельного фрагмента */ 
}

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

7.4. Управление данными для параллельно-выполняемых потоков

Как уже отмечалось ранее, потоки параллельной программы выполняются в общем адресном пространстве и, как результат, все данные (переменные) являются общедоступными для всех параллельно выполняемых потоков. Однако в ряде случаев необходимо наличие переменных, которые были бы локальными для потоков (например, для того, чтобы потоки не оказывали влияния друг на друга). И обратно - при одновременном доступе нескольких потоков к общим данным необходимо обеспечивать условия взаимоисключения (данный аспект организации доступа к общим данным будет рассмотрен в следующем подразделе).

7.4.1. Определение общих и локальных переменных

Параметры shared и private директивы for для управления доступа к переменным уже использовались в примере 7.2. Параметр shared определяет переменные, которые будут общими для всех потоков. Параметр private указывает переменные, для которых в каждом потоке будут созданы локальные копии - они будут доступны только внутри каждого потока в отдельности (значения локальных переменных потока недоступны для других потоков). Параметры shared и private могут повторяться в одной и той же директиве несколько раз, имена переменных должны быть уже ранее определены и не могут повторяться в списках параметров shared и private.

По умолчанию все переменные программы являются общими. Такое соглашение приводит к тому, что компилятор не может указать на ошибочные ситуации, когда программисты забывают описывать локальные переменные потоков в параметре private (отсутствие таких описаний приводит к тому, что переменные будут восприниматься как глобальные). Для выявления таких ошибок можно воспользоваться параметром default директивы parallel для изменения правила по умолчанию:

default ( shared | none )

Как можно видеть, при помощи этого параметра можно отменить действие правила по умолчанию ( default(none) ) или восстановить правило, что по умолчанию переменные программы являются общими ( default(shared) ).

Следует отметить, что начальные значения локальных переменных не определены, а конечные значения теряются при завершении потоков. Для инициализации можно использовать параметр firstprivate директивы for, по которому начальные значения локальных переменных будут устанавливаться в значения, которые существовали в переменных до момента создания локальных копий. Запоминание конечных значений обеспечивается при помощи параметра lastprivate, в соответствии с которым значения локальных переменных копируются из потока, выполнившего последнюю итерацию. Поясним сказанное на примере рис. 7.5. На рисунке показана переменная sum, которая определена как lastprivate в директиве parallel for. Для этой переменной создаются локальные копии в каждом потоке, при завершении параллельного участка программного кода значение локальной переменной потока, выполнившего последнюю итерацию цикла, переписывается в исходную п еременную sum.

7.4.2. Совместная обработка локальных переменных (операция редукции)

Использование параметра lastprivate позволяет сохранить значений локальной переменной одного из потоков, но во многих случаях для обработки могут понадобиться значения всех локальных переменных. Данная возможность может быть обеспечена, например, сохранением этих значений в общих переменных - более подробно правила работы с общими переменными будет рассмотрена в следующем подразделе. Другой подход состоит в использовании коллективных операций над локальными переменными, предусмотренными в OpenMP. Задание коллективной операции происходит при помощи параметра reduction директивы for:

reduction (operator: list)

где список list задает набор локальных переменных (повторное описание в параметре private переменных из списка list не требуется), для которых должна быть выполнена коллективная операция, а поле operator указывает тип этой коллективной операции. Допустимыми значениями для поля operator являются следующие операции (которые не могут быть перегружены):

+, -, *, , |, ^, , ||

Операция редукции обычно применяется к переменным, для которых вычисления задаются в виде выражений следующего вида:

где x есть имя скалярной переменной, выражение expression не должно включать переменную x, возможные операции для поля operator совпадают с выше приведенным списком, а допустимыми значениями для поля op являются операции:

+, -, *, , |, ^

В качестве примера можно добавить в нашу учебную задачу действие по сложению всех сумм элементов строк матрицы - возможный программный код может быть следующим:

total = 0;
#pragma omp parallel for shared(a) private(i,j,sum) reduction (+:total)
{ 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
    total = total + sum;
} /* Завершение параллельного фрагмента */ 
printf ("Общая сумма элементов матрицы равна %f\n",total);

В качестве пояснений добавим, что по параметру reduction для переменной total создаются локальные переменные, затем полученные значения в потоках суммируются и запоминаются в исходной переменной. Подчеркнем, использование общей переменной total без создания локальных копий для накопления общей суммы при использовании в потоках операции

total = total + sum;

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

7.5. Организация взаимоисключения при использовании общих переменных

Как уже неоднократно отмечалось ранее, при изменении общих данных несколькими потоками должны быть обеспечены условия взаимоисключения - изменение значений общих переменных должно осуществляться в каждый конкретный момент времени только одним потоком. Рассмотрим возможные способы организации взаимоисключения.

7.5.1. Обеспечение атомарности (неделимости) операций

Действие над общей переменной может быть выполнено как атомарная (неделимая) операция при помощи директивы atomic. Формат директивы имеет вид:

#pragma omp atomic
  <expression>

где expression должно иметь вид:

x++ ; или ++x ; или x-- ; или --x;

где x есть имя любой целой скалярной переменной.

Директива atomic может быть записана и в виде:

#pragma omp atomic
  x <operator>= <expression>

где x есть имя скалярной переменной, выражение expression не должно включать переменную x, а допустимыми значениями для поля operator являются следующие операции (которые не могут быть перегружены):

+, *, -, /, , |, ^, >>, <<

Как следует из названия, операция директивы atomic выполняется как неделимое действие над указанной общей переменной, и, как результат, никакие другие потоки не могут получить доступ к этой переменной в этот момент времени.

Применим рассмотренную директиву для нашей учебной задачи при вычислении общей суммы:

total = 0;
#pragma omp parallel for shared(a) private(i,j,sum)
{ 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
#pragma omp atomic
    total = total + sum;
} /* Завершение параллельного фрагмента */ 
printf ("Общая сумма элементов матрицы равна %f\n",total);

Отметим, что в данном случае потоки работают непосредственно с общей переменной total.

Как можно видеть, директива atomic может быть применена только для простых выражений, но является наиболее эффективным средством организации взаимоисключения, поскольку многие из допустимых для директивы операций на самом деле выполняются как атомарные на аппаратном уровне. Тем не менее, следует отметить, что данный вариант программы в общем случае будет проигрывать варианту 7.6 по эффективности, поскольку теперь синхронизация потоков будет выполняться для каждой строки обрабатываемой матрицы, а в примере 7.6 количество моментов синхронизации ограничено числом потоков.

7.5.2. Использование критических секций

Действия над общими переменными могут быть организованы в виде критической секции, т.е. как блок программного кода, который может выполняться только одним потоком в каждый конкретный момент времени. При попытке входа в критическую секцию, которая уже исполняется одним из потоков используется, все другие потоки приостанавливаются ( блокируются ). Как только критическая секция освобождается, один из приостановленных потоков (если они имеются) активизируется для выполнения критической секции.

Определение критической секции в OpenMP осуществляется при помощи директивы critical, формат записи которой имеет вид:

#pragma omp critical [(name)]
  <block>

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

Покажем использование механизма критических секций на примере нахождения максимальной суммы элементов строк матрицы. Одна из возможных реализаций состоит в следующем:

smax = -DBL_MAX;
#pragma omp parallel for shared(a) private(i,j,sum)
{ 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
    if ( sum > smax )
#pragma omp criticalif ( sum > smax )
        smax = sum;
} /* Завершение параллельного фрагмента */ 
printf ("Максимальная сумма элементов строк матрицы равна %f\n",smax);

Следует обратить внимание на реализацию проверки суммы элементов строки на максимум. Директиву critical можно записать до первого оператора if, однако это приведет к тому, что критическая секция будет задействована для каждой строки и это приведет к дополнительным блокировкам потоков. Лучший вариант - организовать критическую секцию только тогда, когда необходимо осуществить запись в общую переменную smax (т.е. когда сумма элементов строки превышает значение максимума). Отметим особо, что после входа в критическую секцию необходимо повторно проверить переменную sum на максимум, поскольку после первого оператора if и до входа в критическую секцию значение smax может быть изменено другими потоками. Отсутствие второго оператора if приведет к появлению трудно-выявляемой ошибки, учет подобных моментов представляет определенную трудность параллельного программирования.

7.5.3. Применение переменных семафорного типа (замков)

В OpenMP поддерживается специальный тип данных omp_lock_t, который близок к классическому понятию семафоров. Для переменных этого типа определены функции библиотеки OpenMP:

void omp_init_lock(omp_lock_t *lock);

void omp_set_lock (omp_lock_t lock);

void omp_unset_lock (omp_lock_t lock);

После освобождения замка при наличие блокированных на этом замке потоков один из них активизируется и замок снова отмечается как закрытый.

int omp_test_lock (omp_lock_t lock);

void omp_destroy_lock(omp_lock_t lock)

Переработаем пример 7.8 так, чтобы для организации взаимного исключения при доступе к общим данным использовался механизм замков:

omp_lock_t lock;
omp_init_lock(lock);
smax = -DBL_MAX;
#pragma omp parallel for shared(a) private(i,j,sum)
{ 
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
    if ( sum > smax ) {
      omp_set_lock (lock);if ( sum > smax )
        smax = sum;
      omp_unset_lock (lock);
    }
} /* Завершение параллельного фрагмента */ 
printf ("Максимальная сумма элементов строк матрицы равна %f\n",smax);
omp_destroy_lock (lock);

В OpenMP поддерживаются также и вложенные замки, которые предназначены для использования в ситуациях, когда внутри критических секций осуществляется вызов одних и тех же замков. Механизм работы с вложенными замками является тем же самым (в наименование функций добавляется поле nest ), т.е. их использование обеспечивается при помощи функций:

void omp_init_nest_lock(omp_nest_lock_t *lock);
void omp_set_nest_lock (omp_nest_lock_t lock);
void omp_unset_nest_lock (omp_nest_lock_t lock);
int  omp_test_nest_lock (omp_nest_lock_t lock);
void omp_destroy_nest_lock(omp_nest_lock_t lock)

Как можно заметить, для описания вложенных замков используется тип omp_nest_lock_t.

7.6. Распределение вычислительной нагрузки между потоками (распараллеливание по задачам при помощи директивы sections)

Напомним, что в рассмотренном ранее учебном материале для построения параллельных программ был изложен подход (см. подразделы 7.2 - 7.3), обычно именуемый распараллеливанием по данным, в рамках которого обеспечивается одновременное (параллельное) выполнение одних и тех же вычислительных действий над разными наборами обрабатываемых данных (например, как в нашем учебном примере, суммирование элементов разных строк матрицы). Другая также широко встречающаяся ситуация состоит в том, что для решения поставленной задачи необходимо выполнить разные процедуры обработки данных, при этом данные процедуры или полностью не зависят друг от друга, или же являются слабо связанными. В этом случае такие процедуры можно выполнить параллельно; такой подход обычно именуется распараллеливанием по задачам. Для поддержки такого способа организации п араллельных вычислений в OpenMP для параллельного фрагмента программы, создаваемого при помощи директивы parallel, можно выделять параллельно выполняемые программные секции (директива sections ).

Формат директивы sections имеет вид:

#pragma omp sections [<параметр> ...]
{ 
 #pragma omp section
   <блок_программы>
 #pragma omp section
   <блок_программы>
   
}

При помощи директивы sections выделяется программный код, который далее будет разделен на параллельно выполняемые секции. Директивы section определяют секции, которые могут быть выполнены параллельно (для первой по порядку секции директива section не является обязательной) - см. рис. 7.6. В зависимости от взаимного сочетания количества потоков и количества определяемых секций, каждый поток может выполнить одну или несколько секций (вместе с тем, при малом количестве секций некоторые потоки могут оказаться и без секций и окажутся незагруженными). Как результат, можно отметить, что использование секций достаточно сложно поддается масштабированию (настройке на число имеющихся потоков). Кроме того, важно помнить, что в соответствии со стандартом, порядок выполнения программных секций не определен, т.е. секции могут быть выполнены потоками в произвольном порядке.

В качестве примера использования директивы расширим нашу учебную задачу действиями по копированию обрабатываемой матрицы (в качестве исходного варианта используется пример 7.6):

total = 0;
#pragma omp parallel shared(a,b) private(i,j)
{ 
#pragma omp sections  /* Вычисление сумм элементов строк и общей суммы */
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
    total = total + sum;
  }
#pragma omp section
  /* Копирование матрицы */
  for (i=0; i < NMAX; i++) {
    for (j=i; j < NMAX; j++)
      b[i][j] = a[i][j]; 
  }
} /* Завершение параллельного фрагмента */ 
printf ("Общая сумма элементов матрицы равна %f\n",total);

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

В качестве параметров директивы sections могут использоваться:

Все перечисленные параметры уже были рассмотрены ранее. Отметим, что по умолчанию выполнение директивы sections синхронизировано, т.е. потоки, завершившие свои вычисления, ожидают окончания работы всех потоков для одновременного завершения директивы.

В заключение можно добавить, что также как и для директивы for, в случае если в блоке директивы parallel присутствует только директива sections, то данные директивы могут быть объединены. С использованием данной возможности пример 7.11 может быть переработан к виду:

total = 0;
#pragma omp parallel sections shared(a,b) private(i,j)
{ 
  /* Вычисление сумм элементов строк и общей суммы */
  for (i=0; i < NMAX; i++) {
    sum = 0;
    for (j=i; j < NMAX; j++)
      sum += a[i][j]; 
    printf ("Сумма элементов строки %d равна %f\n",i,sum);
    total = total + sum;
  }
#pragma omp section
  /* Копирование матрицы */
  for (i=0; i < NMAX; i++) {
    for (j=i; j < NMAX; j++)
      b[i][j] = a[i][j]; 
  }
} /* Завершение параллельного фрагмента */ 
printf ("Общая сумма элементов матрицы равна %f\n",total);

7.7. Расширенные возможности OpenMP

7.7.1. Определение однопотоковых участков для параллельных фрагментов (директивы single и master)

При выполнении параллельных фрагментов может оказаться необходимым реализовать часть программного кода только одним потоком (например, открытие файла). Данную возможность в OpenMP обеспечивают директивы single и master.

Формат директивы single имеет вид:

#pragma omp single [<параметр> ...]
  <блок_программы>

Директива single определяет блок параллельного фрагмента, который должен быть выполнен только одним потоком; все остальные потоки ожидают завершения выполнения данного блока (если не указан параметр nowait ) - см. рис. 7.7.

В качестве параметров директивы могут использоваться:

Новым в приведенном списке является только параметр copyprivate, который обеспечивает копирование переменных, указанных в списке list, после выполнения блока директивы single в локальные переменные всех остальных потоков.

Формат директивы master имеет вид:

#pragma omp master 
  <блок_программы>

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

7.7.2. Выполнение барьерной синхронизации (директива barrier)

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

Формат директивы barrier имеет вид:

#pragma omp barrier

7.7.3. Синхронизация состояния памяти (директива flush)

Директива flush позволяетопределить точку синхронизации, в которой системой должно быть обеспечено единое для всех потоков состояние памяти (т.е. если потоком какое-либо значение извлекалось из памяти для модификации, измененное значение обязательно должно быть записано в общую память).

Формат директивы flush имеет вид:

#pragma omp flush [(list)]

Как показывает формат, директива содержит список list с перечнем переменных, для которых выполняется синхронизация; при отсутствии списка синхронизация выполняется для всех переменных потока.

Следует отметить, что директива flush неявным образом присутствует в директивах barrier, critical, ordered, parallel, for, sections, single.

7.7.4. Определение постоянных локальных переменных потоков (директива threadprivate и параметр copyin директивы parallel)

Как описывалось при рассмотрении директивы parallel, для потоков могут быть определены локальные переменные (при помощи параметров private, firstprivate, lastprivate ), которые создаются в начале соответствующего параллельного фрагмента и удаляются при завершении потоков. В OpenMP имеется возможность создания и постоянно существующих локальных переменных для потоков при помощи директивы threadprivate.

Формат директивы threadprivate имеет вид:

#pragma omp threadprivate (list)

Список list определяет набор определяемых переменных. Созданные локальные копии не видимы в последовательных участках выполнения программы (т.е. вне параллельных фрагментов), но существуют в течение всего времени выполнения программы. Указываемые в списке переменные должны быть уже определены в программе; объявление переменных в директиве должно предшествовать использованию переменных в потоках.

Следует отметить, что использование директивы threadprivate позволяет решить еще одну проблему. Дело в том, что действие параметров private распространяется только на программный код параллельных фрагментов, но не параллельных областей - т.е., например, любая локальная переменная, определенная в параллельном фрагменте функции root на рис. 7.3, будет недоступна в параллельной области функции node. Выход из такой ситуации может быть или в передаче значений локальных переменных через параметры функций или же в использовании постоянных локальных переменных директивы threadprivate.

Отметим еще раз, что полученные в потоках значения постоянных переменных сохраняются между параллельными фрагментами программы. Значения этих переменных можно переустановить при начале параллельного фрагмента по значениям из основного потока при помощи параметра copyin директивы parallel.

Формат параметра copyin директивы parallel имеет вид:

copyin (list)

Для демонстрации рассмотренных понятий приведем пример A.32.1c из стандарта OpenMP 2.5.

#include <stdlib.h>
float* work;
int size;
float tol;
#pragma omp threadprivate(work,size,tol)
void a32( float t, int n )
{
  tol = t;
  size = n;
#pragma omp parallel copyin(tol,size)
  {
    build();
  }
}
void build()
{
  int i;
  work = (float*)malloc( sizeof(float)*size );
  for( i = 0; i < size; ++i ) work[i] = tol;
}

В приведенном примере определяются постоянно существующие локальные переменные work, size, tol для потоков (директива threadprivate ). Перед началом параллельного фрагмента значения этих переменных из основного потока копируются во все потоки (параметр copyin ). Значения постоянно существующих локальных переменных доступны в параллельной области функции build (для обычных локальных переменных потоков их значения пришлось бы передавать через параметры функции).

7.7.5. Управление количеством потоков

По умолчанию количество создаваемых потоков определяется реализацией и обычно совпадает с числом имеющихся вычислительных элементов в системе (процессоров и/или ядер )Определение количества имеющихся вычислительных элементов осуществляется операционной системой. При этом следует понимать, что при аппаратной поддержке процессором технологии многопоточности (hyperthreading, HT) ОС будет воспринимать каждый процессор как несколько логических вычислительных элементов (по числу аппаратно поддерживаемых потоков).. При необходимости количество создаваемых потоков может быть изменено - для этой цели в OpenMP предусмотрено несколько способов действий.

Прежде всего, количество создаваемых потоков может быть задано при помощи параметра num_threads директивы parallel.

Количество необходимых потоков может быть также задано при помощи функции omp_set_num_threads библиотеки OpenMP.

Формат функции omp_set_num_threads имеет вид:

void omp_set_num_threads (int num_threads);

Вызов функции omp_set_num_threads должен осуществляться из последовательной части программы.

Для задания необходимого количества потоков можно воспользоваться и переменной окружения OMP_NUM_THREADS. При использовании нескольких способов задания наибольший приоритет имеет параметр num_threads директивы parallel, затем функция библиотеки, затем переменная окружения.

Изменение количества создаваемых потоков может быть полезно и для целей отладки разрабатываемой параллельной программы для проверки ее работоспособности при разном количестве потоков.

Приведем здесь также дополнительные функции библиотеки OpenMP, которые могут быть использованы при работе с потоками:

int omp_get_max_threads(void)

int omp_get_num_threads(void)

int omp_get_thread_num(void)

int omp_get_num_procs(void)

7.7.6. Задание динамического режима при создании потоков

Количество создаваемых потоков в параллельных фрагментах программы по умолчанию является фиксированным (см. также предыдущий пункт), однако стандартом предусматривается возможность динамического режима, когда количество потоков может определяться реализацией для оптимизации функционирования вычислительной системы. Разрешение динамического режима и его отключение осуществляется при помощи функции omp_set_dynamic библиотеки OpenMP.

Формат функции omp_set_ dynamic имеет вид:

void omp_set_dynamic (int dynamic);

Вызов функции omp_set_dynamic должен осуществляться из последовательной части программы. Функция разрешает ( dynamic=true )илиотключает ( dynamic=false )динамический режим создания потоков.

Для управления динамическим режимом создания потоков можно воспользоваться и переменной окружения OMP_DYNAMIC. При использовании нескольких способов задания наибольший приоритет имеет функция библиотеки, затем переменная окружения.

Для получения состояния динамического режима можно воспользоваться функций omp_get_dynamic библиотеки OpenMP:

int omp_get_dynamic (void);

7.7.7. Управление вложенностью параллельных фрагментов

Параллельные фрагменты программы могут быть вложенными - такая возможность определяется реализацией OpenMP. По умолчанию для выполнения вложенных параллельных фрагментов создается столько же потоков, как и для параллельных фрагментов верхнего уровня..

Управление режимом выполнения вложенных фрагментов осуществляется при помощи функции omp_set_nested библиотеки OpenMP.

Формат функции omp_set_nested имеет вид:

void omp_set_nested (int nested);

Вызов функции omp_set_nested должен осуществляться из последовательной части программы. Функция разрешает (nested=true)илиотключает (nested=false)режим поддержки вложенных параллельных фрагментов.

Для управления режимом поддержки вложенных параллельных фрагментов можно воспользоваться и переменной окружения OMP_NESTED. При использовании нескольких способов задания наибольший приоритет имеет функция библиотеки, затем переменная окружения.

Для получения состояния режима поддержки вложенных параллельных фрагментов можно воспользоваться функций omp_get_nested библиотеки OpenMP:

int omp_get_nested (void);

7.8. Дополнительные сведения

Итак, возможности технологии OpenMP рассмотрены практически полностью. В данном подразделе дополнительно рассматриваются правила разработки параллельных программ с использованием OpenMP на алгоритмическом языке Fortran, описывается возможность компиляции программы как обычного последовательного программного кода и приводится краткий перечень компиляторов, обеспечивающих поддержку OpenMP

7.8.1. Разработка параллельных программ с использованием OpenMP на алгоритмическом языке Fortran

Между разработкой параллельных программ с использованием OpenMP на алгоритмическом языке С и алгоритмических языках семейства Fortran (Fortran 77, Fortran 90 и Fortran 95) существует не так много различий.

Прежде всего формат директив OpenMP на алгоритмическом языке Fortran имеет следующий вид:

<маркер> <имя_директивы> [<параметр>…]

Вид маркера зависит от формата записи программы:

!$omp или c$omp или *$omp

В качестве основных отличий параллельных программ с использованием OpenMP на алгоритмическом языке Fortran отметим следующее:

end critical
end do
end master
end ordered
end parallel
end sections
end single
end workshare

В качестве принятых соглашений при разработке программ на языке Fortran рекомендуется записывать имена подпрограмм с использованием прописных символов.

В качестве примера приведем вариант программы из примера 7.6 на алгоритмическом языке Fortran.

PROGRAM Example
INCLUDE "omp_lib.h" 
INTEGER NMAX  1000 
INTEGER LIMIT 100 
INTEGER I, J, SUM 
REAL A(NMAX,NMAX) 
 <инициализация данных>
!$OMP PARALLEL DO SHARED(A) PRIVATE(I,J,SUM) IF (NMAX>LIMIT)
  DO I = 1, NMAX
    SUM = 0
    DO J = 1, NMAX
      SUM = SUM + A(I,J)
    ENDDO
    PRINT * "Сумма элементов строки ", I, "равна ", SUM
  ENDDO
!$OMP END PARALLEL DO ! Завершение параллельного фрагмента
STOP
END

7.8.2. Сохранение возможности последовательного выполнения программы

При разработке параллельной программы с использованием OpenMP в общем случае целесообразно сохранить возможность компиляции программы как обычного последовательного кода (обычно говорят о единственности программного кода для последовательного и параллельного вариантов программ). При соблюдении такого подхода значительно снижаются затраты на сопровождение и развитие программ - так, например, при необходимости изменений в общей части алгоритмов последовательных и параллельных вычислений не требуется проводить корректировку программного кода в разных вариантах программ. Указанный подход полезен и при использовании компиляторов, которые все еще не поддерживают технологию OpenMP. И, наконец, последовательный вариант программы часто необходим для проведения вычислительных экспериментов при определении получаемого ускорения параллельных вычислений.

Поддержка единственности программного кода относится к числу важных положительных качеств технологии OpenMP - формат директив был специально подобран таким образом, чтобы "обычные" компиляторы без поддержки OpenMP воспринимали директивы как комментарии.

Однако проблемы поддержки единственности программного кода возникают при использовании в параллельной программе функций и переменных окружения OpenMP в явном виде. Данные проблемы могут быть решены с помощью директив условной компиляции средств препроцессирования. Стандартом OpenMP предусматривается, что компиляторы с поддержкой технологии OpenMP должны определять макропеременную _OPENMP, значением которой является дата поддерживаемого стандарта в формате ГГГГММ (год, месяц). Как результат, для обеспечения единственности программного кода последовательного и параллельного вариантов программ, все OpenMP-зависимые расширения параллельного варианта программы следует окружать директивами условной компиляции в виде:

#ifdef _OPENMP
  <OpenMP-зависимый программный код>
#endif

Последовательный вариант программы может порождаться и компиляторами с поддержкой OpenMP - для обеспечения такой возможности в составе OpenMP имеются функции-заглушки для всех функций библиотеки OpenMP. Указание подобного режима компиляции осуществляется при помощи соответствующих параметров компилятора.

7.8.3. Краткий перечень компиляторов с поддержкой OpenMP

Среди компиляторов с поддержкой OpenMP прежде всего следует отметить компиляторы компании Intel для алгоритмических языков Fortran и C/C++ для операционных систем семейств Unix и Windows. В следующей таблице приведены параметры этих компиляторов для управления возможностями OpenMP.

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

Среди других компиляторов можно отметить:

Полный перечень компиляторов, поддерживающих OpenMP представлен на портале www.openmp.org.

7.9. Краткий обзор раздела

Данный раздел посвящен рассмотрению методов параллельного программирования для вычислительных систем с общей памятью с использованием технологии OpenMP.

В самом начале раздела отмечается, что технология OpenMP является в настоящий момент времени одним из основных подходов для разработки параллельных программ для вычислительных систем с общей памятью (в т.ч. и для систем с активно развиваемыми в последнее время многоядерными процессорами ). В рамках данной технологии программист при разработке параллельной программы добавляет в программный код специальные директивы параллелизма для выделения в программе параллельных фрагментов, в которых последовательный исполняемый код может быть разделен на несколько раздельных командных потоков ( threads ). Далее эти потоки могут исполняться на разных процессорах (процессорных ядрах) вычислительной системы.

В подразделе 7.1 рассматривается ряд понятий и определений, являющихся основополагающими для стандарта OpenMP. Так, дается представление параллельной программы как набора последовательных ( однопотоковых ) и параллельных ( многопотоковых ) участков программного кода. Далее обсуждаются вопросы организации взаимодействия потоков с использованием общих данных и связанные с этим многие классические аспекты параллельного программирования - гонка потоков, взаимное исключение, критические секции, синхронизация. В подразделе приводится также структура и формат директив OpenMP.

В подразделе 7.2 проводится быстрое и простое введение в разработку параллельных программ с использованием OpenMP. Дается описание директивы parallel и приводится пример первой параллельной программы с использованием OpenMP. В подразделе обсуждаются важные для дальнейшего рассмотрения понятия фрагмента, области и секции параллельной программы.

В подразделе 7.3 рассматриваются вопросы распределения вычислительной нагрузки между потоками на примере распараллеливания циклов по данным. Дается описание директивы for и описываются способы управления распределением итераций цикла между потоками.

В подразделе 7.4 подробно обсуждаются вопросы управления данными для параллельно выполняемых потоков. Дается понятие общих и локальных переменных для потоков. Приводится описание важной и часто встречающейся при обработке общих данных операции редукции.

В подразделе 7.5 рассматриваются вопросы организации взаимоисключения при использовании общих переменных. Среди описываемых подходов - использование атомарных ( неделимых ) операций, определение критических секций, применение семафоров специального типа ( замков ).

В подразделе 7.6 излагаются вопросы распределения вычислительной нагрузки между потоками на основе распараллеливания задач. Дается описание директивы sections, приводятся примеры использования данной директивы.

В подразделе 7.7 рассматриваются расширенные возможности технологии OpenMP. Дается описание ряда новых директив ( master, single, barrier, flush, threadprivate, copyin ), обсуждаются возможности управления потоками (количество создаваемых потоков, динамический режим создания потоков, вложенность параллельных фрагментов).

В завершающем подразделе 7.8 даются дополнительные сведения о технологии OpenMP - рассматриваются правила разработки параллельных программ с использованием OpenMP на алгоритмическом языке Fortran, описывается возможность компиляции программы как обычного последовательного программного кода и приводится краткий перечень компиляторов, обеспечивающих поддержку OpenMP.

7.10. Обзор литературы

В наиболее полном виде информация по параллельному программированию для вычислительных систем с общей памятью с использованием OpenMP содержится в Chandra et al. (2000). Краткое описание OpenMP приводится в Воеводин В.В. и Воеводин Вл.В. (2002) и Немнюгин и Стесик (2002), полезная информация представлена также в Kumar et al. (1994), Quinn (2004).

Достаточно много информации о технологии OpenMP содержится в сети Интернет. Так, могут быть рекомендованы информационно-аналитический портал www.parallel.ru и, конечно же, ресурс www.openmp.org.

Для рассмотрения общих вопросов параллельного программирования для вычислительных систем с общей памятью может быть рекомендована работа Andrews (2000).

7.11. Контрольные вопросы

7.12. Задачи и упражнения

(описание методов интегрирования дано, например, в Kahaner, Moler and Nash (1988)).

Приложение: Справочные сведения об OpenMP

П1. Сводный перечень директив OpenMP

Для справки приведем перечень директив OpenMP с кратким пояснением их назначения.

П2. Сводный перечень параметров директив OpenMP

Для справки приведем перечень параметров директив OpenMP с кратким пояснением их назначения.

Приведем для наглядности сводную таблицу использования параметров в директивах OpenMP.

П3. Сводный перечень функций OpenMP

Для справки приведем перечень функций библиотеки OpenMP с кратким пояснением их назначения.

void omp_init_lock (omp_lock_t *lock) 
void omp_init_nest_lock(omp_nest_lock_t *lock)

void omp_set_lock (omp_lock_t lock)
void omp_set_nest_lock (omp_nest_lock_t lock)

void omp_unset_lock (omp_lock_t lock)
void omp_unset_nest_lock (omp_nest_lock_t lock)

int omp_test_lock (omp_lock_t lock)
int  omp_test_nest_lock (omp_nest_lock_t lock)

void omp_destroy_lock(omp_lock_t lock)
void omp_destroy_nest_lock(omp_nest_lock_t lock)

П4. Сводный перечень переменных окружения OpenMP

Для справки приведем перечень переменных окружения OpenMP с кратким пояснением их назначения.