Шпаковский Г.И., Серикова Н.В. Программирование для многопроцессорных систем в стандарте MPI

Подождите немного. Документ загружается.

111

void MPI::Intracomm::Gatherv(const void* sendbuf, int sendcount,

const Datatype& sendtype, void* recvbuf, const int recvcounts[], const int displs[],

const Datatype& recvtype, int root) const

По сравнению с MPI_GATHER при использовании функции

MPI_GATHERV разрешается принимать от каждого процесса пере-

менное число элементов данных, поэтому в функции

MPI_GATHERV аргумент recvcount является массивом. Она также

обеспечивает большую гибкость в размещении данных в корневом

процессе. Для этой цели используется новый аргумент

displs.

Выполнение MPI_GATHERV будет давать такой же результат,

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

процессу сообщение:

MPI_Send(sendbuf, sendcount, sendtype, root, …),

и корневой процесс выполнял n операций приема:

MPI_Recv(recvbuf+displs[i]*extern(recvtype), recvcounts[i], recvtype, i, …).

Сообщения помещаются в принимающий буфер корневого про-

цесса в порядке возрастания их номеров, то есть данные, посланные

процессом

j, помещаются в j-ю часть принимающего буфера recvbuf

на корневом процессе. j-я часть recvbuf начинается со смещения

displs[j]. Номер принимающего буфера игнорируется во всех некор-

невых процессах. Сигнатура типа, используемая

sendcount, sendtype

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

recvcounts[i], recvtype в корневом процессе. Это требует, чтобы коли-

чество посланных и полученных данных совпадало попарно для кор-

невого и каждого другого процессов. Разрешается различие в картах

типов между отправителями и получателями.

В корневом процессе используются все аргументы функции

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

аргументы

sendbuf, sendcount, sendtype, root, comm. Переменные

comm и root должны иметь одинаковые значения во всех процессах.

Описанные в функции

MPI_GATHERV количества, типы данных и

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

вого процесса записывалась бы более одного раза.

Пример 4.2. Сбор 100 целых чисел с каждого процесса группы в кор-

невой процесс (рис. 4.2).

MPI_Comm comm;

112

int gsize,sendarray[100];

int root, *rbuf;

MPI_Comm_size( comm, &gsize);

rbuf = (int *)malloc(gsize*100*sizeof(int));

MPI_Gather(sendarray,100, MPI_INT, rbuf,100,MPI_INT,root, comm);

Пример 4.3 Предыдущий пример модифицирован – только корневой

процесс назначает память для буфера приема.

MPI_Comm comm;

int gsize,sendarray[100];

int root, myrank, *rbuf;

MPI_Comm_rank( comm, myrank);

if ( myrank == root)

{

MPI_Comm_size( comm, &gsize);

rbuf = (int *)malloc(gsize*100*sizeof(int));

}

MPI_Gather(sendarray,100,MPI_INT, rbuf,100, MPI_INT, root,comm);

Рис. 4.2. Корневой процесс собирает по 100 целых

чисел из каждого процесса в группе

Пример 4.4. Программа делает то же, что и в предыдущем примере,

но использует производные типы данных.

MPI_Comm comm;

int gsize,sendarray[100];

int root, *rbuf;

MPI_Datatype rtype;

MPI_Comm_size( comm, &gsize);

MPI_Type_contiguous( 100, MPI_INT, &rtype );

MPI_Type_commit( &rtype );

100 100 100

100

rbuf

Все процессы

Корневой процесс

113

rbuf = (int *)malloc(gsize*100*sizeof(int));

MPI_Gather( sendarray, 100, MPI_INT, rbuf, 1, rtype, root, comm);

Пример 4.5. Каждый процесс посылает 100 чисел int корневому про-

цессу, но каждое множество (100 элементов) размещается с некото-

рым шагом (

stride) относительно конца размещения предыдущего

множества. Для этого нужно использовать

MPI_GATHERV и аргу-

мент

displs. Полагаем, что stride ≥ 100 (рис. 4.3).

MPI_Comm comm;

int gsize,sendarray[100], root, *rbuf, stride, *displs,i,*rcounts;

MPI_Comm_size( comm, &gsize);

rbuf = (int *)malloc(gsize*stride*sizeof(int));

displs = (int *)malloc(gsize*sizeof(int));

rcounts = (int *)malloc(gsize*sizeof(int));

for (i=0; i<gsize; ++i) {

displs[i] = i*stride;

rcounts[i] = 100;

}

MPI_Gatherv( sendarray, 100, MPI_INT, rbuf, rcounts, displs,

MPI_INT, root, comm);

Рис. 4.3. Корневой процесс собирает множество из 100 целых чисел

из каждого процесса в группе, и каждое множество размещается с не-

которым страйдом относительно предыдущего размещения

Программа неверна, если stride < 100.

Пример 4.6. Со стороны процесса-получателя пример такой же, как и

4.5, но посылается 100 чисел типа

int из 0-го столбца массива 100×150

чисел типа

int (рис. 4.4).

MPI_Comm comm;

int gsize,sendarray[100][150], root, *rbuf, stride, *displs,i,*rcounts;

100

rbuf

Страйд

Все процессы

Корневой процесс

114

MPI_Datatype stype;

MPI_Comm_size( comm, &gsize);

rbuf = (int *)malloc(gsize*stride*sizeof(int));

displs = (int *)malloc(gsize*sizeof(int));

rcounts = (int *)malloc(gsize*sizeof(int));

for (i=0; i<gsize; ++i) {

displs[i] = i*stride;

rcounts[i] = 100; }

/* Create datatype for 1 column of array */

MPI_Type_vector( 100, 1, 150, MPI_INT, &stype);

MPI_Type_commit( &stype );

MPI_Gatherv( sendarray, 1, stype, rbuf, rcounts, displs, MPI_INT, root, comm);

Рис. 4.4. Корневой процесс собирает столбец 0 массива 100×150, и каждое

множество размещается с некоторым страйдом по отношению к предыдущему

Пример 4.7. Процесс i посылает 100 чисел типа int из i-го столбца

массива 100×150 чисел типа

int (рис. 4.5)

MPI_Comm comm;

int gsize,sendarray[100][150],*sptr, root, *rbuf, stride, myrank, *displs,i,*rcounts;

MPI_Datatype stype;

MPI_Comm_size( comm, &gsize);

MPI_Comm_rank( comm, &myrank );

rbuf = (int *)malloc(gsize*stride*sizeof(int));

displs = (int *)malloc(gsize*sizeof(int));

rcounts = (int *)malloc(gsize*sizeof(int));

for (i=0; i<gsize; ++i)

{ displs[i] = i*stride;

rcounts[i] = 100-i;

} /* отличие от предыдущего примера */

/* создается тип данных для посылаемого столбца */

MPI_Type_vector( 100-myrank, 1, 150, MPI_INT, &stype);

MPI_Type_commit( &stype );

/* sptr есть адрес начала столбца "myrank" */

150 150 150

100

Все процессы

Корневой процесс

rbuf

Страйд

100

115

sptr = &sendarray[0][myrank];

MPI_Gatherv(sptr,1,stype,rbuf,rcounts,displs,MPI_INT,root,comm);

Из каждого процесса получено различное количество данных.

116

Рис. 4.5. Корневой процесс собирает множество из100-i целых чисел столбца i

массива 100×150, и каждое множество размещается с отдельным страйдом

Пример 4.8. Пример такой же, как и 4.7, но содержит отличие на пе-

редающей стороне. Создается тип данных со страйдом на передающей

стороне для чтения столбца массива.

MPI_Comm comm;

int gsize,sendarray[100][150],*sptr,root, *rbuf, stride, myrank, disp[2], blocklen[2];

MPI_Datatype stype,type[2];

int *displs,i,*rcounts;

MPI_Comm_size( comm, &gsize);

MPI_Comm_rank( comm, &myrank );

rbuf = (int *)malloc(gsize*stride*sizeof(int));

displs = (int *)malloc(gsize*sizeof(int));

rcounts = (int *)malloc(gsize*sizeof(int));

for (i=0; i<gsize; ++i)

{ displs[i] = i*stride;

rcounts[i] = 100-i;

} /* создается тип для числа int с расширением на полную строку */

disp[0] = 0;

disp[1] = 150*sizeof(int);

type[0] = MPI_INT;

type[1] = MPI_UB;

blocklen[0] = 1;

blocklen[1] = 1;

MPI_Type_struct( 2, blocklen, disp, type, &stype );

MPI_Type_commit( &stype );

sptr = &sendarray[0][myrank];

MPI_Gatherv( sptr, 100-myrank, stype, rbuf, rcounts, displs, MPI_INT,

root, comm);

150

150 150

100

100 100

100

100 100

98100

Все процессы

Корневой процесс

rbuf

Страйд

117

Пример 4.9. Аналогичен примеру 4.7 на передающей стороне, но на

приемной стороне устанавливается страйд между принимаемыми бло-

ками, изменяющийся от блока к блоку (рис. 4.6).

Рис. 4.6. Корневой процесс собирает множество 100-i целых чисел из столбца i

массива 100×150, и каждое множество размещает с переменным страйдом [i]

MPI_Comm comm;

int gsize,sendarray[100][150],*sptr;

int root, *rbuf, *stride, myrank, bufsize;

MPI_Datatype stype;

int *displs,i,*rcounts,offset;

MPI_Comm_size( comm, &gsize);

MPI_Comm_rank( comm, &myrank );

stride = (int *)malloc(gsize*sizeof(int));

/* сначала устанавливаются вектора displs и rcounts */

displs = (int *)malloc(gsize*sizeof(int));

rcounts = (int *)malloc(gsize*sizeof(int));

offset = 0;

for (i=0; i<gsize; ++i)

{ displs[i] = offset;

offset += stride[i];

rcounts[i] = 100-i;

}

/* теперь легко получается требуемый размер буфера для rbuf */

bufsize = displs[gsize-1]+rcounts[gsize-1];

rbuf = (int *)malloc(bufsize*sizeof(int));

/* создается тип данных для посылаемого столбца */

MPI_Type_vector( 100-myrank, 1, 150, MPI_INT, &stype);

MPI_Type_commit( &stype );

sptr = &sendarray[0][myrank];

MPI_Gatherv(sptr,1,stype,rbuf, rcounts, displs, MPI_INT,root,comm);

150

150 150

100

100 100

100

100 100

98100

Все процессы

Корневой процесс

rbuf

Страйд [i]

118

Пример 4.10. В этом примере процесс i посылает num чисел типа int

из i-го столбца массива 100× 150 чисел типа int. Усложнение состоит

в том, что различные значения

num неизвестны корневому процессу,

поэтому требуется выполнить отдельную операцию

gather, чтобы

найти их. Данные на приемной стороне размещаются непрерывно.

MPI_Comm comm;

int gsize,sendarray[100][150],*sptr,root, *rbuf, stride, myrank, disp[2], blocklen[2];

MPI_Datatype stype,types[2];

int *displs,i,*rcounts,num;

MPI_Comm_size( comm, &gsize);

MPI_Comm_rank( comm, &myrank );

/* сначала собираются nums для root */

rcounts = (int *)malloc(gsize*sizeof(int));

MPI_Gather( &num, 1, MPI_INT, rcounts, 1, MPI_INT, root, comm);

/* root теперь имеет правильные rcounts, это позволяет установить displs[]

так, чтобы данные на приемной стороне размещались непрерывно */

displs = (int *)malloc(gsize*sizeof(int));

displs[0] = 0;

for (i=1; i<gsize; ++i)

displs[i] = displs[i-1]+rcounts[i-1];

/* создается буфер получения */

rbuf=(int*)malloc(gsize*(displs[gsize-1]+rcounts[gsize-1])*sizeof(int));

/* создается тип данных для одного int с расширением на полную строку */

disp[0] = 0;

disp[1] = 150*sizeof(int);

type[0] = MPI_INT;

type[1] = MPI_UB;

blocklen[0] = 1;

blocklen[1] = 1;

MPI_Type_struct( 2, blocklen, disp, type, &stype );

MPI_Type_commit( &stype );

sptr = &sendarray[0][myrank];

MPI_Gatherv(sptr,num,stype,rbuf, rcounts, displs, MPI_INT,root, comm);

4.2.4. Рассылка

Операция MPI_SCATTER обратна операции MPI_GATHER. Ре-

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

n операций посылки:

MPI_Send(senbuf + i * extent(sendtype), sendcount, sendtype, i, …),

и каждый процесс выполнит приtм:

MPI_Recv(recvbuf, recvcount, recvtype, i, …).

119

MPI_SCATTER (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,

root, comm)

IN sendbuf

начальный адрес буфера рассылки (альтернатива, использу-

ется только корневым процессом)

IN sendcount

количество элементов, посылаемых каждому процессу (це-

лое, используется только корневым процессом)

IN sendtype

тип данных элементов в буфере посылки (дескриптор, ис-

пользуется только корневым процессом)

OUT recvbuf адрес буфера процесса-получателя (альтернатива)

IN recvcount количество элементов в буфере корневого процесса (целое)

IN recvtype тип данных элементов приемного буфера (дескриптор)

IN root номер процесса-получателя (целое)

IN comm коммуникатор (дескриптор)

int MPI_Scatter (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,

int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

MPI_SCATTER (SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF,

RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR)

<type> SENDBUF(*), RECVBUF(*)

INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, ROOT,

COMM, IERROR

void MPI::Intracomm::Scatter(const void* sendbuf, int sendcount, const Datatype&

sendtype, void* recvbuf, int recvcount, const Datatype& recvtype, int root) const

Буфер отправки игнорируется всеми некорневыми процессами.

Сигнатура типа, связанная с

sendcount, sendtype, должна быть оди-

наковой

для корневого процесса и всех других процессов. Это требу-

ет, чтобы количество посланных и полученных данных совпадало по-

парно для корневого и каждого другого процессов. Корневой процесс

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

только аргументы

recvbuf, recvcount, recvtype, root, comm. Аргумен-

ты

root и comm должны быть одинаковыми во всех процессах. Опи-

санные в функции

MPI_SCATTER количества и типы данных не

должны являться причиной того, чтобы любая ячейка корневого про-

цесса записывалfсь бы более одного раза. Такой вызов является не-

верным.

Операция MPI_SCATERV обратна операции MPI_GATHERV.

Аргумент

sendbuf игнорируется во всех некорневых процессах. Сиг-

натура типа, связанная с

sendcount [i], sendtype в главном процессе,

должна быть той же, что и сигнатура, связанная с

recvcount, recvtype

в процессе i. Это требует, чтобы количество посланных и полученных

данных совпадало попарно для корневого и каждого другого процес

120

сов. Разрешается различие в картах типов между отправителями и по-

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

другие процессы используют только аргументы

recvbuf, recvcount,

recvtype, root, comm

. Аргументы root и comm должны быть одинако-

выми во всех процессах. Описанные в функции

MPI_SCATTER ко-

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

область корневого процесса записывалfсь бы более одного раза.

MPI_SCATTERV(sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount,

recvtype, root, comm)

IN sendbuf

адрес буфера посылки (альтернатива, используется только кор-

невым процессом)

IN sendcounts

целочисленный массив (размера группы), определяющий число

элементов, для отправки каждому процессу

IN displs

целочисленный массив (размера группы). Элемент i указывает

смещение (относительно sendbuf, из которого берутся данные

для процесса )

IN sendtype тип элементов посылающего буфера (дескриптор)

OUT recvbuf адрес принимающего буфера (альтернатива)

IN recvcount число элементов в посылающем буфере (целое)

IN recvtype тип данных элементов принимающего буфера (дескриптор)

IN root номер посылающего процесса (целое)

IN comm коммуникатор (дескриптор)

int MPI_Scatterv(void* sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype,

void* recvbuf, recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

MPI_SCATTERV(SENDBUF, SENDCOUNTS, DISPLS, SENDTYPE, RECVBUF,

RECVCOUNT, RECVTYPE, ROOT, COMM, IERROR)

<type> SENDBUF(*), RECVBUF(*)

INTEGER SENDCOUNTS(*), DISPLS(*), SENDTYPE, RECVCOUNT,

RECVTYPE, ROOT, COMM, IERROR

void MPI::Intracomm::Scatterv(const void* sendbuf, const int sendcounts[],

const int displs[], const Datatype& sendtype, void* recvbuf, int recvcount,

const Datatype& recvtype, int root) const

Пример 4.11. Обратен примеру 4.2, MPI_SCATTER рассылает 100

чисел из корневого процесса каждому процессу в группе (рис. 4.7).

MPI_Comm comm;