О.В.Сухорослов "Параллельное программирование"

04 Параллельное программирование

О.В. Сухорослов

oleg.sukhoroslov@gmail.com

16.03.2011

О.В. Сухорослов 04 ()
Параллельное программирование 16.03.2011 1 / 66

План лекции

Системы параллельного программирования

Типовые модели программирования и шаблоны

Знакомство с технологией OpenMP


Системы параллельного программирования

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

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

Высокоуровневые абстракции, переносимость

Середина 90-х: зоопарк систем


Текущие стандарты де-факто
Общая память
OpenMP

Распределенная память
MPI (Message Passing Interface)

Гибридные архитектуры
OpenMP + MPI
Только MPI или OpenMP


Другие технологии

POSIX threads
C++11



POSIX threads
C++11
Cilk
Intel Threading Building Blocks
Java Fork-Join Framework
Grand Central Dispatch
.NET Task Parallel Library
Parallel Patterns Library



POSIX threads
C++11
Cilk
PVM
Global Arrays
Uniﬁed Parallel C
X10



POSIX threads
C++11
Cilk
PVM
Global Arrays
Uniﬁed Parallel C
X10
MapReduce
Dryad

Подходы
Расширение “последовательного” языка
OpenMP
Cilk
UPC

Библиотека к “последовательному” языку
Pthreads
MPI
TBB

Язык со встроенной поддержкой многопроцессности
Java, C#, Erlang, Go, X10, C++12


Критерии оценки программы

Ясность

Масштабируемость

Эффективность

Удобство сопровождения

Согласованность с целевой системой

Переносимость

Эквивалентность последовательной программе


Типовые модели программирования и шаблоны

SPMD (Single Program Multiple Data)
Loop Parallelism
Master/Worker
Fork/Join

Тесно пересекаются друг с другом
Допускают комбинирование


Single Program Multiple Data

Все исполнители запускают одну программу
Инициализация
Получение уникального идентификатора
Выполнение программы с учетом идентификатора
Разное поведение: if(myId=...), for(..myId..)
Распределение данных между исполнителями
Идентификаторы входят в правила разбиения данных
(Операции обмена данными между исполнителями)
Завершение программы
Редукция результатов


Пример

1 # include < stdio .h >
2
3 int main ( int argc , char * argv []) {
4 const int num_steps = 1 E9 ;
5 double x , sum = 0.0;
6 const double step = 1.0/ num_steps ;
7 int i ;
8
9 for ( i = 0; i < num_steps ; i ++) {
10 x = ( i +0.5)* step ;
11 sum += 4.0/(1.0+ x * x );
12 }
13
14 printf ( " Pi = %.10 f n " , step * sum );
15 return 0;
16 }


Пример (MPI)
2 // init variables ...
3
4 MPI_Init (& argc , & argv );
5 MPI_Comm_rank ( MPI_COMM_WORLD , & my_id );
6 MPI_Comm_size ( MPI_COMM_WORLD , & numprocs );
7
8 i_start = my_id * ( num_steps / numprocs );
9 i_end = i_start + ( num_steps / numprocs );
10 if ( my_id == ( numprocs -1)) i_end = num_steps ;
11
12 for ( i = i_start ; i < i_end ; i ++)
13 {
14 x = ( i +0.5)* step ;
15 sum += 4.0/(1.0+ x * x );
16 }
17 sum *= step ;
18
19 MPI_Reduce (& sum , & pi , 1 , MPI_DOUBLE , MPI_SUM , 0 , MPI_COMM_WORLD );
20
21 if ( my_id == 0) printf ( " Pi = %.10 f n " , pi );
22
23 MPI_Finalize ();
24
25 return 0;
26 }


SPMD

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

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


Loop Parallelism

Вычислительно интенсивная часть алгоритма скрыта внутри цикла
Есть готовая последовательная программа
Итерации внутри цикла являются независимыми
Требуется распараллелить итерации, минимально модифицируя
при этом код исходной программы


Пример (OpenMP)

2 # include < omp .h >
3
8 int i ;
9
10 # pragma omp parallel for private ( x ) reduction (+: sum )
11 for ( i = 0; i < num_steps ; i ++) {
12 x = ( i +0.5)* step ;
13 sum += 4.0/(1.0+ x * x );
14 }
15
17 return 0;
18 }


Loop Parallelism

Плюсы
Минимальная модификация последовательной программы с
сохранением семантики
Инкрементальное распараллеливание
Эквивалентность последовательной программе

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


Master/Worker

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


Master/Worker


Master/Worker - Часто встречающиеся вариации

Master становится worker-ом

Неявное распределение итераций в Loop Parallelism

Random work stealing


Master/Worker

Плюсы
Автоматическая балансировка нагрузки, не требует явного
назначения исполнителей
Хорошо работает для задач с независимыми заданиями
Подходит для различных видов платформ

Минусы
Неприменим для задач с зависимыми заданиями (требуется
координация и одновременное выполнение)


Рекурсивный Fork/Join

Задания создаются динамически, между заданиями существуют
сложные зависимости
Divide and Conquer, рекурсивные данные

Подходы
Каждому заданию по исполнителю
Плохо масштабируется
Пул исполнителей
Общая очередь заданий
Work stealing


Пример (Cilk)

1 cilk int fib ( int n )
2 {
3 if ( n < 2) return n ;
4 else
5 {
6 int x , y ;
7
8 x = spawn fib (n -1);
9 y = spawn fib (n -2);
10
11 sync ;
12
13 return ( x + y );
14 }
15 }


Знакомство с OpenMP


OpenMP (Open Multi-Processing)

Интерфейс параллельного программирования для
многопроцессорных систем с общей памятью

Поддерживает языки C/C++ и Fortran

Включает набор директив компилятора, библиотечных функций и
переменных окружения

Разрабатывается в рамках OpenMP Architecture Review Board с
1997 года
http://www.openmp.org/
OpenMP 2.5 (2005), OpenMP 3.0 (2008), OpenMP 3.1 (2011)


Реализации
OpenMP 2.5
GCC 4.2 и выше
Microsoft Visual C++ 2008 / 2010
Intel C/C++ Compiler 10.1 и выше

OpenMP 3.0
GCC 4.4 и выше
Intel C/C++ Compiler 11.0 и выше

См. http://openmp.org/wp/openmp-compilers/


Модель параллельного выполнения (fork/join)


Hello World

1 #include <omp.h>
3
4 int main ( int argc , char ** argv ) {
5 #pragma omp parallel
6 printf ( " Hello , world . n " );
7 return 0;
8 }


Синтаксис прагм OpenMP для C/C++

#pragma omp directive [clause [clause] ... ]


Компиляция и запуск (GCC)

gcc(g++) hello.c -o hello
./hello
1 Hello , world .

gcc(g++) -fopenmp hello.c -o hello
./hello
1 Hello , world .
2 Hello , world .
3 ...


Visual Studio


Eclipse CDT + GCC

Необходимо указать флаг -fopenmp в GCC C Compiler (GCC C
Linker ...) → Miscellaneous → Other ﬂags

Hello World 2

3
4 int main ( int argc , char ** argv ) {
5 int num_threads , thread_id ;
6
7 # pragma omp parallel private ( thread_id )
8 {
9 thread_id = omp_get_thread_num ();
10 printf ( " % d : Hello , world . n " , thread_id );
11
12 if ( thread_id == 0)
13 {
14 num_threads = omp_get_num_threads ();
15 printf ( " Number of threads = % d n " , num_threads );
16 }
17 }
18 return 0;
19 }


Без private(thread_id)

1 0: Hello , world .

2 Number of threads = 2
4 Number of threads = 2


Атрибуты видимости данных

private (list)
ﬁrstprivate (list)
lastprivate (list)
threadprivate (list)
shared (list)
default (shared | none)


Число потоков

По умолчанию обычно равно числу процессоров

Может быть задано явно
Переменная окружения OMP_NUM_THREADS
Функция omp_set_num_threads()
Директива #pragma omp parallel ... num_threads(N)

Может изменяться от секции к секции


Вычисление π

2
4
8 int i ;
9
10 for ( i = 0; i < num_steps ; i ++) {
11 x = ( i +0.5)* step ;
12 sum += 4.0/(1.0+ x * x );
13 }
14
16 return 0;
17 }


Вариант 1 (SMPD)
3
5 double start = omp_get_wtime ();
6
10 int i ;
11
12 int num_threads = omp _ge t_m a x _t h re a ds ();
13 double sum_tmp [ num_threads ];
14
15 # pragma omp parallel private (i , x )
16 {
17 int id = omp_get_threa d_n um ();
18 for ( i = id ; i < num_steps ; i = i + num_threads ) {
19 x = (i -0.5)* step ;
20 sum_tmp [ id ] += 4.0/(1.0+ x * x );
21 }
22 }
23 for ( i = 0; i < num_threads ; i ++) {
24 sum += sum_tmp [ i ];
25 }
26
28 printf ( " Time : % f n " , omp_get_wtime () - start );
29 return 0;
30 }


Вариант 2 (for, critical, nowait)

1 # pragma omp parallel
2 {
3 int id = om p_ get_thread_num ();
4 # pragma omp for private ( x ) nowait
5 for ( i = 0; i < num_steps ; i ++) {
6 x = ( i +0.5)* step ;
7 sum_tmp [ id ] += 4.0/(1.0+ x * x );
8 }
9 # pragma omp critical
10 sum += sum_tmp [ id ];
11 }


Ложное разделение данных (false sharing)

1 # pragma omp parallel for private (j , i )
2 for ( j =0; j < N ; j ++){
3 for ( i =0; i < M ; i ++){
4 A [ j ] += work (i , j );
5 }
6 }

1 double temp ;
2
3 # pragma omp parallel for private (j ,i , temp )
4 for ( j =0; j < N ; j ++){
5 temp = 0.0;
6 for ( i =0; i < M ; i ++){
7 temp += work (i , j );
8 }
9 A [ j ] += temp ;
10 }


Вариант 3 (борьба с false sharing)

1 double sum_tmp [ num_threads *8];
2
4 {
5 int id = om p_ get_thread_num ();
6 int pos = id *8;
7 # pragma omp for private ( x ) nowait
8 for ( i = 0; i < num_steps ; i ++) {
9 x = ( i +0.5)* step ;
10 sum_tmp [ pos ] += 4.0/(1.0+ x * x );
11 }
12 # pragma omp critical
13 sum += sum_tmp [ pos ];
14 }


Оптимизация при компиляции

gcc -O1(2,3) ...

gcc: компиляция на форсаже с турбо-наддувом (Крис Касперски)
http://www.insidepro.com/kk/231/231r.shtml


Вариант 4 (for + reduction)

3
5 double start = omp_get_wtime ();
6
10 int i ;
11
12 # pragma omp parallel for private ( x ) reduction (+: sum )
13 for ( i = 1; i <= num_steps ; i ++) {
14 x = (i -0.5)* step ;
15 sum += 4.0/(1.0+ x * x );
16 }
17
19 printf ( " Time : % f n " , omp_get_wtime () - start );
20 return 0;
21 }


Допустимые операторы для reduction


Оптимизация циклов

Объединение циклов (укрупнение итераций)
Развертывание вложенных циклов (увеличение кол-ва итераций)


Объединение циклов
1 for ( i =0; i < N ; i ++) {
2 FFT ( Npoints , A , B );
3 filter ( Npoints , B , H );
4 invFFT ( Npoints , B , A );
5 }
6 for ( i =0; i < N ; i ++) {
7 FFT ( Npoints , C , B );
9 invFFT ( Npoints , B , C );
10 }

1 for ( i =0; i < N ; i ++) {
2 FFT ( Npoints , A , B );
4 invFFT ( Npoints , B , A );
5 FFT ( Npoints , C , B );
7 invFFT ( Npoints , B , C );
8 }

Развертывание вложенных циклов

1 for ( j =0; j < N ; j ++) {
2 for ( i =0; i < M ; i ++) {
3 A [ i ][ j ] = work (i , j );
4 }
5 }

1 # pragma omp parallel for private ( ij , j , i )
2 for ( ij =0; ij < N * M ; ij ++) {
3 j = ij / N ;
4 i = ij % M ;
5 A [ i ][ j ] = work (i , j );
6 }


Распределение итераций между потоками

Атрибут schedule(type, chunk)

Type
static
Статическое распределение по принципу round-robin
dynamic
Динамическое распределение по принципу master-worker
guided
Динамическое распределение с уменьшающимися порциями
runtime
Значение берется из переменной окружения OMP_SCHEDULE


Пример


Множество Мандельброта

Z (n + 1) = Z (n)2 + C , Z (0) = 0


Вариант 1 (static)

1 #pragma omp parallel for
2 for ( int pix =0; pix < num_pixels ; ++ pix )
3 {
4 const int x = pix % width , y = pix / width ;
5 complex c = begin + complex ( x ... , y ..);
6 int n = M a nd e l brotCalculate (c , maxiter );
7 if ( n == maxiter ) n = 0;
8 pixels [ pix ] = n ;
9 }


Вариант 2 (dynamic)

1 #pragma omp parallel for schedule(dynamic,16)
3 {
7 if ( n == maxiter ) n = 0;
9 }


Вариант 1* (static + chunk)

1 #pragma omp parallel for schedule(static,1)
3 {
7 if ( n == maxiter ) n = 0;
9 }


Вариант 3 (ordered)

1 #pragma omp parallel for ordered schedule(static,1)
2
4 {
8 if ( n == maxiter ) n = 0;
9
10 # pragma omp ordered
11 {
12 // print pixel on screen
13 }
14 }


Quicksort
1 void quicksort_serial ( int arr [] , int low , int high ) {
2 int i = low ;
3 int j = high ;
4 int y = 0;
5 int z = arr [( low + high ) / 2];
6 do {
7 while ( arr [ i ] < z ) i ++;
8 while ( arr [ j ] > z ) j - -;
9 if ( i < j ) {
10 y = arr [ i ];
11 arr [ i ] = arr [ j ];
12 arr [ j ] = y ;
13 i ++;
14 j - -;
15 }
16 } while ( i <= j );
17
18 if ( low < j )
19 quicksort_serial ( arr , low , j );
20 if ( i < high )
21 quicksort_serial ( arr , i , high );
22 }


Вариант 1.1 (sections)

1 # pragma omp parallel sections
2 {
3 # pragma omp section
4 {
5 if ( low < j )
6 quicksort_nested ( arr , low , j );
7 }
9 {
10 if ( i < high )
11 quicksort_nested ( arr , i , high );
12 }
13 }


Вариант 1.2 (sections + nested)

1 omp_set_nested (1);
2 ...
3
5 {
7 {
8 if ( low < j )
10 }
12 {
13 if ( i < high )
15 }
16 }


Вариант 1.3 (max_active_levels)

1 omp_set_nested (1);
2 o m p _ s e t _ m a x _ a c t i v e _ l e v e l s (4);
3 ...
4
6 {
8 {
9 if ( low < j )
11 }
13 {
14 if ( i < high )
16 }
17 }


Вариант 1.4 (порог)
1 if ( high - low < THRESHOLD ||
2 (j - low < THRESHOLD || high - i < THRESHOLD )) {
3 if ( low < j )
5 if ( i < high )
7 } else {
8
10 {
12 {
13 if ( low < j )
15 }
17 {
18 if ( i < high )
20 }
21 }
22 }


Вариант 2 (tasks, OpenMP 3.0)

2 # pragma omp single
3 {
4 ...
5
6 # pragma omp task
7 {
8 quicksort_tasks ( arr , low , j );
9 }
10
11 quicksort_tasks ( arr , i , high );
12
13 }


Адаптивная квадратура

1 long double quad ( double left , double right ,
2 long double f_left , long double f_right ,
3 long double lr_area ) {
4 double mid = ( left + right ) / 2;
5 long double f_mid = f ( mid );
6 long double l_area = ( f_left + f_mid ) * ( mid - left ) / 2;
7 long double r_area = ( f_mid + f_right ) * ( right - mid ) / 2;
8 if ( fabs (( l_area + r_area ) - lr_area ) > EPSILON ) {
9 l_area = quad ( left , mid , f_left , f_mid , l_area );
10 r_area = quad ( mid , right , f_mid , f_right , r_area );
11 }
12 return ( l_area + r_area );
13 }


Адаптивная квадратура
1 long double quad_tasks ( double left , double right ,
2 long double f_left , long double f_right ,
3 long double lr_area ) {
4 double mid = ( left + right ) / 2;
5 long double f_mid = f ( mid );
6 long double l_area = ( f_left + f_mid ) * ( mid - left ) / 2;
7 long double r_area = ( f_mid + f_right ) * ( right - mid ) / 2;
8 if ( fabs (( l_area + r_area ) - lr_area ) > EPSILON ) {
9 if ( right - left < THRESHOLD ) {
10 l_area = quad_tasks ( left , mid , f_left , f_mid , l_area );
11 r_area = quad_tasks ( mid , right , f_mid , f_right , r_area );
12 } else {
13 # pragma omp task shared ( l_area )
14 l_area = quad_tasks ( left , mid , f_left , f_mid , l_area );
15 r_area = quad_tasks ( mid , right , f_mid , f_right , r_area );
16 # pragma omp taskwait
17 }
18 }
19 return ( l_area + r_area );
20 }


Другие возможности
Синхронизация
critical, atomic, ordered, barrier, nowait

ﬂush

master


Накладные расходы


Привязка потоков к ядрам

OpenMP <3.1
Переменные окружения, зависящие от компилятора
gcc
export OMP_NUM_THREADS=8
export GOMP_CPU_AFFINITY="0 1 2 3 4 5 6 7"
Windows API
SetThreadAﬃnityMask(thread, mask)

OpenMP 3.1
export OMP_PROC_BIND=true


Преимущества и недостатки OpenMP?


Домашнее задание (ДЗ №2, Задача 1)

Реализуйте параллельную версию алгоритма K-средних1 с
использованием OpenMP

Измерьте время выполнения, ускорение и эффективность для
различного числа потоков и размера задачи
Ускорение следует измерять относительно последовательной
программы без OpenMP
Время работы последовательной программы на тестовом наборе
должно быть не менее 10 секунд
Для всех запусков с одним размером задачи следует использовать
одинаковый набор данных

Прокомментируйте полученные результаты

1
http://en.wikipedia.org/wiki/K-means_clustering#Standard_algorithm

Учебный кластер
Железо
20 узлов (4 x Xeon E5645 2.40 GHz, 32 Gb RAM, 4 x 1 Tb)
Дисковое пространство ∼ 4 Tb
Gigabit Ethernet

Все что нужно для компиляции и запуска OpenMP-программ
gcc 4.4.3
Запуск программ на узлах кластера через систему очередей

Для доступа к кластеру пришлите на oleg.sukhoroslov@gmail.com
письмо:
Тема: "Учебный кластер"
Содержание: Ваша фамилия в транслите с маленькой буквы
(например, pupkin)

Инструкция по работе на кластере
Coming soon, см. на вики


О.В.Сухорослов "Параллельное программирование"

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a О.В.Сухорослов "Параллельное программирование"

Similar a О.В.Сухорослов "Параллельное программирование" (20)

Más de Yandex

Más de Yandex (20)

О.В.Сухорослов "Параллельное программирование"