Параллельное программирование с OpenMP - ответы на вопросы на СтудИзбе

Найдите ошибку в следующем фрагменте MPI/OpenMP-программы, вычисляющей число Пи:#include #include #define num_steps 100000void main (int argc, char *argv[]){ int numprocs, myid, mysteps; double pi, step, sum = 0.0 ; MPI_Init(&argc, &argv) ; MPI_Comm_Rank(MPI_COMM_WORLD, &myid) ; MPI_Comm_Size(MPI_COMM_WORLD, &numprocs) ; step = 1.0/(double) num_steps ; mysteps = num_steps/numprocs ; #pragma omp parallel shared(myid, mysteps, step) { #pragma omp for reduction(+:sum) for (int i=myid*mysteps; i<(myid+1)*mysteps ; i++){ double x = (i+0.5)*step; sum += 4.0 /(1.0+x*x); } sum *= step ; } MPI_Reduce(&sum, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Finalize();}

• функции MPI_Init, MPI_Comm_Rank, MPI_Comm_Size и MPI_Reduce должны вызываться из параллельной области
• конфликт доступа к данным (race condition), возникающий в результате выполнения оператора sum *= step в параллельной области
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#define N 10int i;#pragma omp parallel firstprivate(i) lastprivate(i){ for (i=0; i

клауза firstprivate не может использоваться в директиве parallel

одна и та же переменная не может быть указана в клаузах firstprivate и lastprivate одновременно

клауза lastprivate не может использоваться в директиве parallel

Найдите ошибку в следующем фрагменте программы:#include double x=1024.0;int n=1024;#pragma omp parallel{ #pragma omp atomic x=sqrt(x); #pragma omp atomic n&=0177;}

• оператор & (побитовое И) не может быть использован в конструкции atomic
• оператор вида x=sqrt(x) не может быть использован в конструкции atomic
• в данном фрагменте программы ошибки нет

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100#include "omp.h"void work(int i);int main () { #pragma omp parallel { omp_set_schedule (omp_sched_dynamic); #pragma omp for for (int i=0;i

динамический (dynamic)

зависит от значения переменной окружения OMP_SCHEDULE

зависит от реализации компилятора

int main (void){ int a, i; #pragma omp parallel shared(a) private(i) { #pragma omp single a = 0; #pragma omp for for (i = 0; i < 10; i++) { a += i; } }}

• перед директивой for отсутствует директива barrier
• в директиве for отсутствует клауза reduction(+:a)
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:int numt=0;#pragma omp parallel{ #pragma omp critical { numt=omp_get_num_threads(); #pragma omp barrier #pragma omp flush (numt) }}

• в данном фрагменте программы ошибки нет
• директива barrier не может быть использована внутри критической секции (конструкции critical)
• директива flush не может быть использована внутри критической секции (конструкции critical)

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N];#pragma omp parallel default(shared){ int i; #pragma omp master for (i=0; i

оператор for не может быть использован внутри конструкции master

оператор, в котором изменяется значение общей переменной B[N-1] выполняется без какой-либо синхронизации

в данном фрагменте программы ошибки нет

Пусть перед входом в параллельную область вызывается функция omp_set_num_threads. Пусть в директиве создания этой параллельной области указана клауза num_threads. Количество создаваемых нитей будет:

• определяться вызовом функции omp_set_num_threads
• определяться клаузой num_threads
• зависеть от реализации компилятора

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); #pragma omp parallel for for (int i=0; i<5; i++) for (int j=0; j<5; j++) sleep (msec);}

• добавить к директиве parallel for клаузу schedule(static,1)
• добавить к директиве parallel for клаузу schedule(dynamic)
• добавить к директиве parallel for клаузу collapse(2)

Найдите ошибку в следующем фрагменте программы:#define N 10int i;#pragma omp parallel{ #pragma omp for private(i) lastprivate(i) for (i=0; i

в данном фрагменте программы ошибки нет

индексная переменная цикла, витки которого распределяются между нитями при помощи директивы for, не может быть указана в клаузе lastprivate

одна и та же переменная не может быть указана в клаузах private и lastprivate одновременно

При реализации компилятором редукционного оператора, описанного при помощи клаузы reduction (*: prod), где переменная prod имеет тип integer, для каждой нити создается локальная копия переменной prod, начальное значение которой будет инициализировано:

• 1
• 0
• MAXINT (максимально возможное целое число)

Пусть следующая программа скомпилирована компилятором, поддерживающим вложенный параллелизм.#include #include "omp.h"int counter;int main(){ counter=0; omp_set_nested(0); #pragma omp parallel num_threads(2) { #pragma omp parallel num_threads(2) { #pragma omp atomic counter++; } } printf("Counter=%dn",counter);}Определите значение переменной counter по завершении выполнения этой программы:

• 4
• 1
• 2

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N], sum;#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); if (iam ==0) { #pragma omp critical (update_a) #pragma omp critical (update_b) sum +=A[iam]; } else { #pragma omp critical (update_b) #pragma omp critical (update_a) sum +=B[iam]; }}

• критические секции, определяемые директивой critical, не могут быть вложены друг в друга
• дедлок - взаимная блокировка нитей, возникающая при входе master-нитью в критическую секцию с именем update_a и любой другой нитью в секцию с именем update_b (в этом случае вложенные критические секции не смогут быть обработаны)
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:int i=0;int numt = omp_get_max_threads();#pragma omp parallel default (none) private (i){ #pragma omp for for(i=0; i< numt; i++) Work(i);}

• не описан класс для переменной numt. Необходимо добавить спецификацию private(numt)
• не описан класс для переменной numt. Необходимо добавить спецификацию shared(numt)
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#include int main (void){ #pragma omp parallel { int numt; #pragma omp single numt=omp_get_num_threads(); if (numt < 4) do_small_work(); else do_big_work (); }}

• после конструкции single отсутствует директива barrier
• в директиве single отсутствует клауза copyprivate(numt)
• в данном фрагменте программы ошибки нет

Функция omp_get_num_threads возвращает:

• максимально возможное количество нитей, которые могут быть использованы при выполнении всей программы
• количество нитей в текущей параллельной области
• номер нити в группе

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#define N 100omp_set_num_threads (4);#pragma omp parallel shared(a,b,c,x,y,z){ #pragma omp for for (int i=0; i

для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(static,25)

для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(dynamic)

для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу nowait

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100void work(int i);int main () { #pragma omp parallel { #pragma omp for for (int i=0;i

статический (static)

зависит от значения переменной окружения OMP_SCHEDULE

зависит от реализации компилятора

Реализация технологии Intel Cluster OpenMP стала возможной, поскольку в OpenMP используется:

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

Переменные, которые разделяются нитями, и доступ к которым обрабатывается в технологии Intel Cluster OpenMP механизмом DSM, могут быть заданы при помощи:

• клаузы SHARED
• директивы SHARABLE
• опции компилятора

При использовании гибридной модели параллельного программирования MPI/OpenMP:

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

Найдите ошибку в следующем фрагменте программы:int main (void){ int a; #pragma omp parallel private(a) { #pragma omp single a = 0; #pragma omp for reduction(+:a) for (int i = 0; i < 10; i++) { a += i; } }}

• в директиве parallel клауза private (a) должна быть заменена на shared(a)
• перед директивой for отсутствует директива barrier
• в данном фрагменте программы ошибки нет

Определите значение переменной team_size по завершении выполнения следующей программы:#include #include "omp.h"int main(){ int team_size; team_size=0; #pragma omp parallel num_threads(2) { if (omp_get_thread_num() == 0) { team_size=omp_get_team_size(0); } } printf("Team Size=%dn",team_size);}

• 0
• 1
• 2

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define N 100int c[N];int val= 1;int main (void) { omp_set_num_threads (8); #pragma omp parallel shared(val, c) { #pragma omp for for (int i=0; i

вместо директивы critical использовать механизм семафоров (omp_set_lock/omp_unset_lock)

заменить директиву critical на директиву critical (<имя_критической_секции>)

добавить к директиве for клаузу reduction(&&:val) и убрать директиву critical

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N], sum;#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); #pragma omp critical (update_a) #pragma omp critical (update_a) sum +=A[iam];}

• одноименные критические секции не могут быть вложены друг в друга
• в данном фрагменте программы ошибки нет
• критические секции не могут быть вложены друг в друга

Найдите ошибку в следующем фрагменте MPI/OpenMP-программы, вычисляющей число Пи:#include #include #define num_steps 100000void main (int argc, char *argv[]){ int numprocs, myid, mysteps; double pi, step, sum = 0.0 ; MPI_Init(&argc, &argv) ; MPI_Comm_Rank(MPI_COMM_WORLD, &myid) ; MPI_Comm_Size(MPI_COMM_WORLD, &numprocs) ; step = 1.0/(double) num_steps ; mysteps = num_steps/numprocs ; #pragma omp parallel shared(myid, mysteps, step) reduction(+:sum) { #pragma omp for for (int i=myid*mysteps; i<(myid+1)*mysteps ; i++){ double x = (i+0.5)*step; sum += 4.0*step/(1.0+x*x); } MPI_Reduce(&sum, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); } MPI_Finalize();}

• функции MPI_Init, MPI_Comm_Rank, MPI_Comm_Size должны вызываться из параллельной области
• до завершения выполнения редукционного OpenMP-оператора выполняется вызов функции MPI_Reduce
• в данном фрагменте программы ошибки нет

При использовании технологии Intel Cluster OpenMP программист:

• при помощи соответствующих директив распределяет вычисления по узлам кластера. Данные по узлам кластера распределяются в соответствии с распределением вычислений
• при помощи соответствующих директив определяет разделяемые нитями переменные, доступ к которым обрабатывается механизмом DSM. Вычисления распределяются по узлам кластера компилятором
• при помощи соответствующих директив распределяет по узлам кластера разделяемые нитями переменные и вычисления, проводимые над этими переменными

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); for (int i=0; i<80; i++) #pragma omp parallel for for (int j=0; j<80; j++) sleep (msec);}

• добавить к директиве parallel for клаузу schedule(dynamic)
• добавить к директиве parallel for клаузу schedule(static,10)
• переставить директиву parallel for (распределить между нитями выполнение витков цикла по i)

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); #pragma omp parallel { #pragma omp for for(int i=0; i<80;i++) { sleep (i*msec); } #pragma omp for for(int i=0; i<80;i++) { sleep ((80-i)*msec); } }}

• для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу nowait
• для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(static,10)
• для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(dynamic)

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define N 100float c[N];float sum = 0.0;int main (void) { omp_set_num_threads (8); #pragma omp parallel shared(sum, c) { #pragma omp for for (int i=0; i

заменить директиву critical на директиву atomic

заменить директиву critical на директиву critical (<имя_критической_секции>)

добавить к директиве for клаузу reduction(+:sum) и убрать директиву critical

Выберите наилучшую стратегию распределения витков цикла между нитями, которая для следующего фрагмента программы даст минимальное время выполнения:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); #pragma omp parallel { #pragma omp for schedule (runtime) for(int i=0; i<80;i++) { sleep (msec); } }}

• export OMP_SCHEDULE=”static,20”
• export OMP_SCHEDULE=”static,15”
• export OMP_SCHEDULE=”static,10”

Пусть следующая программа скомпилирована компилятором, поддерживающим вложенный параллелизм.#include #include "omp.h"int counter;int main(){ counter=0; omp_set_nested(0); #pragma omp parallel num_threads(2) { if (omp_get_thread_num() == 0) { #pragma omp parallel num_threads(2) { #pragma omp atomic counter++; } } } printf("Counter=%dn",counter);}Определите значение переменной counter по завершении выполнения этой программы:

• 1
• 2
• 4

Найдите ошибку в следующем фрагменте программы:int numt=0;#pragma omp parallel{ #pragma omp single { #pragma omp critical { numt=omp_get_num_threads(); } #pragma omp barrier }}

• в данном фрагменте программы ошибки нет
• директива critical не может быть использована внутри конструкции single
• директива barrier не может быть использована внутри конструкции single

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i; #pragma omp for schedule(dynamic) for (i=0; i

использование клаузы schedule(dynamic) для цикла for, в котором используется директива ordered запрещено

в директиве for отсутствует клауза ordered

в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i; #pragma omp for lastprivate(i) for (i=0; i

в данном фрагменте программы ошибки нет

индексная переменная цикла, витки которого распределяются между нитями при помощи директивы for, не может быть указана в клаузе lastprivate

изменение значения индексной переменной цикла for внутри цикла (при помощи оператора i+=2) не допускается

Использование оператора exit в структурном блоке OpenMP:

• запрещено в стандарте
• разрешено в стандарте
• возможно в некоторых OpenMP-компиляторах (зависит от реализации)

PRAM модель консистентности памяти определяется следующим условием:

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

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100#include "omp.h"void work(int i);int main () { #pragma omp parallel { omp_set_schedule (omp_sched_dynamic); #pragma omp for schedule(static) for (int i=0;i

статический (static)

динамический (dynamic)

зависит от значения переменной окружения OMP_SCHEDULE.

Выберите наилучшую стратегию распределения витков цикла между нитями, которая для следующего фрагмента программы даст минимальное время выполнения:#include #include#include#include #define msec 1000int main (void){ srand (time(NULL)); omp_set_num_threads (8); #pragma omp parallel { #pragma omp for schedule (runtime) for(int i=0; i<100;i++) { sleep (rand()*msec); } }}

• export OMP_SCHEDULE=”static”
• export OMP_SCHEDULE=”guided”
• export OMP_SCHEDULE=”dynamic”

Функция omp_get_thread_num возвращает:

• уникальный идентификатор нити
• номер нити в группе
• количество нитей в текущей параллельной области

Директива SHARABLE в технологии Intel Cluster OpenMP:

• задает, какие переменные, на какой узел кластера необходимо отобразить
• определяет разделяемые нитями переменные, доступ к которым возможен только на одном из узлов кластера
• определяет разделяемые нитями переменные, доступ к которым обрабатывается механизмом DSM

Найдите ошибку в следующем фрагменте программы:#define N 10int icount;#pragma omp threadprivate(icount)#pragma omp parallel{ #pragma omp for for (icount=0; icount

только статические переменные могут быть указаны в директиве threadprivate (static int icount)

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

в данном фрагменте программы ошибки нет

Пусть W(x)a – операция записи в переменную x значения a. Пусть R(x)a – операция чтения переменной x, где a – прочитанное значение переменной x. Пусть S - операция синхронизации. Следующая последовательность событий: P1: W(x)aW(x)bSP2:R(x)aR(x)bSP3:R(x)bR(x)aS

• допустима при слабой модели консистентности
• не допустима при слабой модели консистентности
• допустима при модели консистентности по выходу

Найдите ошибку в следующем фрагменте программы:int i, j; #pragma omp parallel default(shared) { #pragma omp for collapse (3) for (i=0; i

в результате использования клаузы default(shared), счетчики циклов - переменные i и j являются общими для всех нитей

количество заголовков циклов не соответствуют значению, указанному в клаузе collapse

в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте MPI/OpenMP-программы, реализующей метод релаксации Якоби:int jacobi(int p, int id, int my_rows, double **u, double **w) { double diff, global_diff, tdiff; int i,j,it; MPI_Status status; it=0; for(;;) { if (id>0) MPI_Send (u[1], N, MPI_DOUBLE, id-1, 0, MPI_COMM_WORLD); if (id0) MPI_Recv (u[0], N, MPI_DOUBLE, id-1, 0, MPI_COMM_WORLD, &status); diff=0.0; #pragma omp parallel private (i,j,tdiff) { tdiff=0.0; #pragma omp for for (i=1; itdiff) tdiff=fabs(w[i][j]-u[i][j]); } #pragma omp for nowait for (i=1; i diff) diff=tdiff; MPI_Allreduce (&diff, &global_diff, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD); } if (global_diff <= EPSILON) break; it++; } return it;}

• в данном фрагменте программы ошибки нет
• обращения к функции MPI_Allreduce в параллельной области должны выполняться одной нитью (например, внутри конструкции single)
• не определен класс для переменных u, w, my_rows, diff, global_diff, используемых в параллельной области -shared(u,w,my_rows,diff,global_diff)

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N];#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); int tmp; tmp=A[iam]; B[iam]=tmp;}

• изменение общей переменной B[iam] выполняется без какой-либо синхронизации
• в данном фрагменте программы ошибки нет
• чтение/изменение переменной tmp выполняется без какой-либо синхронизации

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N];#pragma omp parallel default(shared){ int i;..…#pragma omp master for (i=0; i

оператор for не может быть использован внутри конструкции master

по завершении конструкции master отсутствует директива barrier

в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#define N 1000int main (void){ float a[N], tmp; #pragma omp parallel { int i; #pragma omp for private(i) for(i=0; i

в директиве parallel отсутствует клауза shared(a)

в данном фрагменте программы ошибки нет

в директиве for отсутствует клауза private(tmp)

Последовательная модель консистентности памяти определяется следующим условием:

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

Intel Thread Checker:

• ошибки, которые проявились при выполнении программы на заданном наборе входных тестовых данных
• обнаруживает все возможные ошибки типа datarace и deadlock в программе

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i; #pragma omp for lastprivate(i) for (i=0; i!=n; i++) { work(i); }}

• в заголовке цикла, витки которого распределяются между нитями при помощи директивы for вместо оператора отношения (типа <,<=,>,>=) указан оператор сравнения (!=)
• индексная переменная цикла, витки которого распределяются между нитями при помощи директивы for, не может быть указана в клаузе lastprivate
• в данном фрагменте программы ошибки нет

Выберите наилучшую стратегию распределения витков цикла между нитями, которая для следующего фрагмента программы даст минимальное время выполнения:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); #pragma omp parallel { #pragma omp for schedule (runtime) for(int i=0; i<100;i++) { sleep (i*msec); } }}

• export OMP_SCHEDULE=”static”
• export OMP_SCHEDULE=”static,10”
• export OMP_SCHEDULE=”dynamic”

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i, j; #pragma omp for for (i=0; i

в результате использования клаузы private, значение переменных i и n во вложенном параллельном цикле не определено

используются конструкции распределения работ, которые вложены одна в другую

в данном фрагменте программы ошибки нет

При реализации компилятором редукционного оператора, описанного при помощи клаузы reduction (+: sum), где переменная sum имеет тип integer, для каждой нити создается локальная копия переменной sum, начальное значение которой будет инициализировано:

• 0
• -MAXINT (минимально возможное целое число)
• MAXINT (максимально возможное целое число)

Рассмотрим фрагмент OpenMP-программы:#include int n=1;int main (void){ omp_set_nested(1); omp_set_dynamic(1); omp_set_num_threads(2); #pragma omp parallel if (n>10) {/*параллельная область*/ … }}Для выполнения параллельной области будет создана группа нитей, состоящая из:

• нескольких нитей (количество создаваемых нитей зависит от переменной окружения OMP_NUM_THREADS)
• 1-ой нити
• 2-х нитей

Выберите наилучшую стратегию распределения витков цикла между нитями, которая для следующего фрагмента программы даст минимальное время выполнения:#include #include #define msec 1000int main (void){ omp_set_num_threads (4); #pragma omp parallel { #pragma omp for schedule (runtime) for(int i=0; i<60;i++) { sleep (msec); } }}

• export OMP_SCHEDULE=”static,10”
• export OMP_SCHEDULE=”dynamic,15”
• export OMP_SCHEDULE=”static,20”

Определите количество нитей, между которыми будет распределена работа в параллельной области:#include "omp.h"void work(int i);int main () { int n; n=10; #pragma omp parallel num_threads(4) if (n>20) { #pragma omp for for (int i=0;i

зависит от значения переменных окружения OMP_THREAD_LIMIT и OMP_NUM_THREADS

4

1

При использовании гибридной модели параллельного программирования DVM/OpenMP:

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

Найдите ошибку в следующем фрагменте MPI/OpenMP-программы, реализующей метод релаксации Якоби:int jacobi(int p, int id, int my_rows, double **u, double **w) { double diff, global_diff, tdiff; int i,j,it; MPI_Status status; it=0; #pragma omp parallel private (i,j,tdiff) { for(;;) { #pragma omp master { diff=0.0; if (id>0) MPI_Send (u[1], N, MPI_DOUBLE, id-1, 0, MPI_COMM_WORLD); if (id0) MPI_Recv (u[0], N, MPI_DOUBLE, id-1, 0, MPI_COMM_WORLD, &status); } /*end of master*/ tdiff=0.0; #pragma omp for for (i=1; itdiff) tdiff=fabs(w[i][j]-u[i][j]); } #pragma omp for nowait for (i=1; i diff) diff=tdiff; #pragma omp barrier #pragma omp single { it++; MPI_Allreduce (&diff, &global_diff, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD); } /*end of single*/ if (global_diff <= EPSILON) break; } return it;}

• не определен класс для переменных my_rows, diff, id, p, status, u, w, it, global_diff, используемых в параллельной области -shared(my_rows,diff,diff,id,p,status,u,w,it,global_diff)
• отсутствует барьерная синхронизация нитей (директива barrier) по завершении конструкции master
• в данном фрагменте программы ошибки нет

Технология OpenMP по сравнению с MPI имеет следующие преимущества (отметьте все подходящие варианты):

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

Для выделения памяти для SHARABLE-переменных в технологии Intel Cluster OpenMP требуется использовать:

• обычные функции malloc, realloc и т.д
• специальные функции kmp_sharable_malloc, kmp_sharable_realloc и т.д
• как обычные, так и специальные функции. Доступ к переменным, для которых память выделена при помощи специальных функций осуществляется быстрее

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#define N 80omp_set_num_threads (8);#pragma omp parallel shared(a,b,c,x,y,z){ #pragma omp for for (int i=0; i

для первого цикла, выполнение витков которого распределяется между нитями при помощи директивы for, добавить клаузу nowait

для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(dynamic)

для циклов, выполнение витков которых распределяется между нитями при помощи директивы for, добавить клаузу schedule(static,10)

Выберите наиболее походящую оптимизацию, которая позволит сократить время выполнения следующего фрагмента программы:#include #include #define N 100int c[N];int val = 0;int main (void) { omp_set_num_threads (8); #pragma omp parallel shared(val, c) { #pragma omp for for (int i=0; i

заменить директиву critical на директиву critical (<имя_критической_секции>)

заменить директиву critical на директиву atomic

добавить к директиве for клаузу reduction(^:val) и убрать директиву critical

Выберите наилучшую стратегию распределения витков цикла между нитями, которая для следующего фрагмента программы даст минимальное время выполнения:#include #include #define msec 1000int main (void){ omp_set_num_threads (8); #pragma omp parallel { #pragma omp for schedule (runtime) for(int i=0; i<100;i++) { sleep ((100-i)*msec); } }}

• export OMP_SCHEDULE=”dynamic”
• export OMP_SCHEDULE=”static”
• export OMP_SCHEDULE=”static,10”

Поиск ошибок в OpenMP-программе, выполняемый Intel Thread Checker, основан на:

• методе динамического анализа корректности программы
• методе статического анализа кода программы
• методе сравнительной отладки нескольких запусков одной программы

#define N 10int A[N],B[N], sum;#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); if (iam ==0) { #pragma omp critical (update_a) #pragma omp critical (update_b) sum +=A[iam]; } else { #pragma omp critical (update_b) #pragma omp critical (update_a) sum +=B[iam]; }}

• критические секции, определяемые директивой critical, не могут быть вложены друг в друга
• дедлок - взаимная блокировка нитей, возникающая при входе master-нитью в критическую секцию с именем update_a и любой другой нитью в секцию с именем update_b (в этом случае вложенные критические секции не смогут быть обработаны)
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#include int numproc;#pragma omp threadprivate(numproc)int main (void){ numproc=omp_get_num_procs(); #pragma omp parallel { if (numproc < 4) do_small_work(); else do_big_work (); }}

• в данном фрагменте программы ошибки нет
• в директиве parallel отсутствует клауза copyin(numproc)
• функция omp_get_num_procs не может быть вызвана вне параллельной области

Найдите ошибку в следующем фрагменте программы:#define N 1000int main (void){ float a[N]; #pragma omp parallel { #pragma omp for for(int i=0; i

в данном фрагменте программы ошибки нет

в директиве for отсутствует клауза private(i)

в директиве for отсутствует клауза private(tmp)

Определите значение переменной team_size по завершении выполнения следующей программы:#include #include "omp.h"int main(){ int team_size; team_size=0; #pragma omp parallel num_threads(2) { if (omp_get_thread_num() == 0) { team_size=omp_get_team_size(omp_get_level ()); } } printf("Team Size=%dn",team_size);}

• 1
• 2
• 0

Определите количество нитей, между которыми будет распределена работа в параллельной области:#define N 100#include "omp.h"void work(int i);int main () { omp_set_num_threads(2); #pragma omp parallel num_threads(4) { #pragma omp for for (int i=0;i

4

2

зависит от значения переменной окружения OMP_NUM _THREADS

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100#include "omp.h"void work(int i);int main () { #pragma omp parallel { omp_set_schedule (omp_sched_guided); #pragma omp for for (int i=0;i

зависит от реализации компилятора

зависит от значения переменной окружения OMP_SCHEDULE

управляемый(guided)

Найдите ошибку в следующем фрагменте программы:int x=0;omp_lock_t lcka, lckb;omp_init_lock (&lcka);omp_init_lock (&lckb);#pragma omp parallel{ int iam=omp_get_thread_num(); if (iam ==0) { omp_set_lock (&lcka); omp_set_lock (&lckb); x = x + 1; omp_unset_lock (&lckb); omp_unset_lock (&lcka); } else { omp_set_lock (&lckb); omp_set_lock (&lcka); x = x + 2; omp_unset_lock (&lcka); omp_unset_lock (&lckb); } }}omp_destroy_lock (&lcka);omp_destroy_lock (&lckb);

• дедлок - взаимная блокировка нитей, возникающая, в случае если master-нить, выполнила omp_set_lock (&lcka), а другая нить выполнила omp_set_lock (&lckb)
• в данном фрагменте программы ошибки нет
• после установки блокировки в результате вызова функции omp_set_lock(&lcka), повторное обращение нитью к функции omp_set_lock(&lckb) некорректно (повторное обращение omp_set_lock(&lckb) должно быть заменено на omp_set_nest_lock(&lckb))

Найдите ошибку в следующем фрагменте программы:int numt=0;#pragma omp parallel{ #pragma omp master { #pragma omp critical { numt=omp_get_num_threads(); } #pragma omp barrier }}

• директива barrier не может быть использована внутри конструкции master
• директива critical не может быть использована внутри конструкции master;
• в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N], sum;#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); if (A[iam] > 0) { #pragma omp critical (update_a) sum +=A[iam]; } if (B[iam] > 0) { #pragma omp critical (update_b) sum +=B[iam]; }}

• изменение общей переменной sum внутри критических секций update_a и update_b может выполняться одновременно несколькими нитями, поскольку названия критических секций отличаются
• в данном фрагменте программы ошибки нет
• чтение общих переменных А[iam] и B[iam] в операторах вида A[iam]>0 и B[iam]>0 выполняется без какой-либо синхронизации

Найдите ошибку в следующем фрагменте программы:#define N 10int A[N],B[N],tmp;#pragma omp parallel default(shared) num_threads(10){ int iam=omp_get_thread_num(); tmp=A[iam]; B[iam]=tmp;}

• в данном фрагменте программы ошибки нет
• чтение/изменение общей переменной tmp выполняется без какой-либо синхронизации
• изменение общей переменной B[iam] выполняется без какой-либо синхронизации

Директива master

• определяет блок операторов в программе, который будет выполнен master-нитью. Остальные нити группы не дожидаются завершения выполнения этого блока
• определяет блок операторов в программе, который будет выполнен master-нитью. Остальные нити группы дожидаются завершения выполнения этого блока
• определяет блок операторов в программе, который будет выполнен одной нитью группы. Остальные нити группы дожидаются завершения выполнения этого блока

Способ распределения витков цикла между нитями группы задается при помощи клаузы schedule(<алгоритм планирования>[,<число итераций>]).Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i; #pragma omp for schedule(dynamic, omp_get_thread_num()) for (i=0; i

значение параметра <число итераций> клаузы schedule отличается для каждой нити группы

при динамическом планировании, задаваемом клаузой schedule(dynamic), параметр <число итераций> задать нельзя

в данном фрагменте программы ошибки нет

Найдите ошибку в следующем фрагменте программы:#define N 10int i;#pragma omp parallel{ #pragma omp for firstprivate(i) lastprivate(i) for (i=0; i

индексная переменная цикла, витки которого распределяются между нитями при помощи директивы for, не может быть указана в клаузе firstprivate

индексная переменная цикла, витки которого распределяются между нитями при помощи директивы for, не может быть указана в клаузе lastprivate

одна и та же переменная не может быть указана в клаузах firstprivate и lastprivate одновременно

Найдите ошибку в следующем фрагменте программы:int i, j; #pragma omp parallel default(shared) { #pragma omp for collapse (2) for (i=0; i

в результате использования клаузы default(shared), счетчики циклов - переменные i и j являются общими для всех нитей

в данном фрагменте программы ошибки нет

между заголовками циклов указан вызов процедуры work_with_i (клауза collapsе может быть использована только распределения витков тесно-вложенных циклов)

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i, j; #pragma omp for for (i=0; i

клауза shared не может быть использована в директиве for

используются конструкции распределения работ, которые вложены одна в другую

в данном фрагменте программы ошибки нет

Рассмотрим фрагмент OpenMP-программы:#include int main (void){ omp_set_nested(0); omp_set_max_active_levels(8); omp_set_num_threads(2); #pragma omp parallel { omp_set_num_threads(2); #pragma omp parallel { /*вложенная параллельная область*/ … } }}Для выполнения вложенной параллельной области будет создана группа нитей, состоящая из:

• 2-х нитей
• нескольких нитей (количество создаваемых нитей зависит от переменной окружения OMP_NUM_THREADS)
• 1-ой нити

Клауза num_threads задает:

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

Исполняемыми директивами в OpenMP являются:

• barrier
• taskwait
• threadprivate

Определите класс по умолчанию для переменной numt:int i=0;int numt = omp_get_max_threads();#pragma omp parallel forfor(i=0; i< numt; i++) Work(i);

• shared
• private
• threadprivate

Найдите ошибку в следующем фрагменте программы:#define N 10int i;#pragma omp parallel{ int tmp = 0; #pragma omp for private(tmp) for (i=0; i

не определен класс для переменной i (отсутствует клауза private (i))

начальное значение переменной tmp в параллельном цикле не определено

в данном фрагменте программы ошибки нет

Пусть W(x)a – операция записи в переменную x значения a. Пусть R(x)a – операция чтения переменной x, где a – прочитанное значение переменной x. Пусть S - операция синхронизации. Следующая последовательность событий: P1: W(x)aW(x)bSP2:SR(x)a

• допустима при модели консистентности по выходу
• допустима при слабой модели консистентности
• не допустима при слабой модели консистентности

Слабая модель консистентности памяти определяется следующим условием:

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

Строгая модель консистентности памяти определяется следующим условием:

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

Найдите ошибку в следующем фрагменте программы:#define N 10float c[N];float sum = 0.0;#pragma omp parallel shared(sum, c){ #pragma omp for reduction (+: sum) nowait for (int i=0; i

редукционная переменная sum объявлена общей(shared)

в директиве for нельзя одновременно указать клаузу reduction и клаузу nowait

до использования значения редукционной переменной sum в операторе печати в блоке single отсутствует барьерная синхронизация нитей

Клауза copyin:

• может быть использована только для переменных, указанных в клаузе private
• может быть использована только для переменных, указанных в директиве threadprivate
• может быть использована как для переменных указанных в директиве threadprivate, так и для переменных, указанных в клаузе private

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel default(shared){ int i, j; #pragma omp for for (i=0; i

используются конструкции распределения работ, которые непосредственно вложены одна в другую

в результате использования клаузы default(shared), счетчики циклов i и j являются общими для всех нитей

в данном фрагменте программы ошибки нет

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100#include "omp.h"void work(int i);int main () { #pragma omp parallel { omp_set_schedule (omp_sched_static); #pragma omp for for (int i=0;i

зависит от значения переменной окружения OMP_SCHEDULE

зависит от реализации компилятора

статический (static)

Причинная модель консистентности памяти определяется следующим условием:

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

Процессорная модель консистентности памяти определяется следующим условием:

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

Использование технологии Intel Cluster OpenMP целесообразно:

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

Определите количество нитей, между которыми будет распределена работа в параллельной области:#include "omp.h"void work(int i);int main () { int n; n=10; omp_set_num_threads(2); #pragma omp parallel num_threads(4) if (n>20) { #pragma omp for for (int i=0;i

1

2

4

Определите способ распределения витков цикла между нитями для следующего фрагмента программы:#define N 100#include "omp.h"void work(int i);int main () { #pragma omp parallel { omp_set_schedule (omp_sched_static); #pragma omp for schedule(dynamic) for (int i=0;i

статический (static)

динамический (dynamic)

зависит от значения переменной окружения OMP_SCHEDULE

Найдите ошибку в следующем фрагменте программы:#define N 10int i;int tmp = 0;#pragma omp parallel{ #pragma omp for firstprivate(tmp) lastprivate(tmp) for (i=0; i

не определен класс для переменной i (отсутствует клауза private (i))

по завершении выполнения цикла значение переменой tmp не определено

одна и та же переменная не может быть указана в клаузах firstprivate и lastprivate одновременно

Использование операторов перехода (goto) в структурном блоке OpenMP возможно:

• если оператор перехода не выводит за пределы блока
• поскольку в стандарте нет никаких ограничений на операторы перехода
• в некоторых OpenMP-компиляторах (зависит от реализации)

Найдите ошибку в следующем фрагменте программы:#pragma omp parallel{ int me; me = omp_get_thread_num (); if (me == 0) goto Master; #pragma omp barrierMaster: #pragma omp single}

• оператор goto не может быть использован внутри конструкции parallel
• в директиве parallel отсутствует клауза private(me)
• дедлок - взаимная блокировка нитей, возникающая в результате того что master-нить не попадает на директиву barrier