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

Пример 3.6. Пример корректного обмена сообщениями.

CALL MPI_COMM_RANK(comm, rank, ierr) IF (rank.EQ.0) THEN

CALL MPI_SEND(sendbuf, count, MPI_REAL, 1, tag, comm, ierr) CALL MPI_RECV(recvbuf,count,MPI_REAL,1,tag, comm, status, ierr)

ELSE

CALL MPI_RECV(recvbuf,count,MPI_REAL,0,tag, comm, status, ierr) CALL MPI_SEND(sendbuf, count, MPI_REAL, 0, tag, comm, ierr)

END IF

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

Пример 3.7. Пример некорректного обмена сообщениями.

CALL MPI_COMM_RANK(comm, rank, ierr) IF (rank.EQ.0) THEN

CALL MPI_RECV(recvbuf,count,MPI_REAL,1,tag, comm, status, ierr) CALL MPI_SEND(sendbuf, count, MPI_REAL, 1, tag, comm, ierr)

ELSE

CALL MPI_RECV(recvbuf,count,MPI_REAL,0,tag, comm, status, ierr) CALL MPI_SEND(sendbuf, count, MPI_REAL, 0, tag, comm, ierr)

END IF

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

Пример 3.8. Пример обмена: результат зависит от буферизации.

CALL MPI_COMM_RANK(comm, rank, ierr) IF (rank.EQ.0) THEN

CALL MPI_SEND(sendbuf, count, MPI_REAL, 1, tag, comm, ierr) CALL MPI_RECV(recvbuf,count,MPI_REAL,1, tag, comm, status, ierr)

! rank.EQ.1 ELSE

CALL MPI_SEND(sendbuf, count, MPI_REAL, 0, tag, comm, ierr) CALL MPI_RECV(recvbuf,count,MPI_REAL, 0, tag, comm, status, ierr)

END IF

61

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

3.6. РАСПРЕДЕЛЕНИЕ И ИСПОЛЬЗОВАНИЕ БУФЕРОВ

Пользователь может описать буфера, используемые для буферизации сообщений, посылаемых в режиме буферизации. Буферизация выполняется отправителем.

MPI_BUFFER_ATTACH (buffer, size)

int MPI_Buffer_attach (void* buffer, int size)

MPI_BUFFER_ATTACH (BUFFER, SIZE, IERROR) <type> BUFFER(*)

INTEGER SIZE, IERROR

void MPI::Attach_buffer(void* buffer, int size)

Предусмотренный в MPI буфер в памяти пользователя используется для буферизации исходящих сообщений. Буфер используется только сообщениями, посланными в буферизованном режиме. Только один буфер может быть присоединен к процессу за один раз.

MPI_BUFFER_DETACH ( buffer_addr, size)

int MPI_Buffer_detach(void* buffer_addr, int * size)

MPI_BUFFER_DETACH(BUFFER_ADDR, SIZE, IERROR) <type> BUFFER_ADDR(*)

INTEGER SIZE, IERROR

Int MPI :: Detach_buffer (void*& buffer)

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

62

Пример 3.9. Обращение к функциям использования буферов.

#define BUFFSIZE 10000 int size

char *buff;

MPI_Buffer_attach( malloc(buf, BUFFSIZE);

/* буфер может теперь быть использован MPI_Bsend */

Если никакого буфера не подключено, то MPI ведет себя, как если бы с процессом был связан буфер нулевого размера.

3.7. НЕБЛОКИРУЮЩИЙ ОБМЕН

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

кирующий обмен.

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

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

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

63

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

Вызов завершения посылки заканчивается, когда данные извлечены из буфера отправителя. Если режим передачи синхронный, тогда передача может завершиться, только если соответствующий прием стартовал, то есть прием инициирован и соответствует передаче. В этом случае вызов send является нелокальным. Синхронная неблокирующая передача может быть завершена, если перед вызовом receive имеет место соответствующий неблокирующий прием. Если используется режим буферизуемой передачи, то сообщение должно быть буферизовано, если не имеется ждущего приема. В этом случае вызов send является локальным и обязан быть успешным независимо от состояния соответствующего приема. Если используется стандартный режим передачи, тогда вызов send может заканчиваться перед тем, как имеет место соответствующий прием, если сообщение буферизованное. С другой стороны, send может не завершаться до тех пор, пока имеет место соответствующий прием и сообщение было скопировано в приемный буфер. Неблокирующие передачи могут соответствовать блокирующим приемам и наоборот.

3.7.1. Коммуникационные объекты

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

64

3.7.2. Инициация обмена

Далее используются те же обозначения, что и для блокирующего обмена: преффикс B, S или R используются для буферизованного, синхронного режима или для режима готовности, преффикс I – для неблокирующего обмена.

MPI_ISEND(buf, count, datatype, dest, tag, comm, request)

int MPI_Isend (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

MPI_ISEND (BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)

<type> BUF(*)

INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR

MPI::Request Comm::Isend(const void* buf, int count, const MPI::Datatype& datatype, int dest, int tag) const

MPI_IBSEND(buf, count, datatype, dest, tag, comm, request)

int MPI_Ibsend (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

MPI_IBSEND (BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)

<type> BUF(*)

INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR

MPI::Request MPI::Comm::Ibsend(const void* buf, int count,

const MPI::Datatype& datatype, int dest, int tag) const

65

MPI_ISSEND (buf, count, datatype, dest, tag, comm, request)

int MPI_Issend (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

MPI_ISSEND (BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)

<type> BUF(*)

INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR

MPI::Request MPI::Comm::Issend(const void* buf, int count,

const MPI::Datatype& datatype, int dest, int tag) const

MPI_IRSEND (buf, count, datatype, dest, tag, comm, request)

int MPI_Irsend (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

MPI_IRSEND (BUF, COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR)

<type> BUF(*)

INTEGER COUNT, DATATYPE, DEST, TAG, COMM, REQUEST, IERROR

MPI::Request MPI::Comm::Irsend(const void* buf, int count,

const MPI::Datatype& datatype, int dest, int tag) const

MPI_IRECV(buf, count, datatype, source, tag, comm, request)

int MPI_Irecv (void* buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)

MPI_IRECV (BUF, COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR)

<type> BUF(*)

INTEGER COUNT, DATATYPE, SOURCE, TAG, COMM, REQUEST, IERROR

MPI::Request MPI::Comm::Irecv(void* buf, int count, const MPI::Datatype& datatype, int source, int tag) const

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

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

3.7.3. Завершение обмена

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

Завершение операции приема указывает, что приемный буфер содержит принятое сообщение, что процесс-получатель теперь может обращаться к нему и что статусный объект установлен. Это не означает, что операция посылки завершена.

Нулевой дескриптор имеет значение MPI_REQUEST_NULL. Дескриптор является активным, если он не является нулевым или неак-

67

тивным. Состояние empty (пусто) возвращает tag = MPI_ANY_TAG, error = MPI_SUCCESS, source = MPI_ANY_SOURCE, вызов MPI_GET_ELEMENTS и MPI_TEST_CANCELLED возвращают false, а вызов MPI_GET_COUNT возвращает count = 0. Переменная состояния устанавливается на empty, когда возвращаемое ею значение несущественно. Состояние устанавливается таким образом, чтобы предупредить ошибки из-за устаревшей информации.

MPI_WAIT (request, status)

int MPI_Wait (MPI_Request *request, MPI_Status *status)

MPI_WAIT(REQUEST, STATUS, IERROR)

INTEGER REQUEST, STATUS(MPI_STATUS_SIZE), IERROR void MPI::Request::Wait (MPI::Status& status)

Обращение к MPI_WAIT заканчивается, когда завершена операция, указанная в запросе. Если коммуникационный объект, связанный с этим запросом, был создан вызовом неблокирующей посылки или приема, тогда этот объект удаляется при обращении к MPI_WAIT, и дескриптор запроса устанавливается в MPI_REQUEST_NULL. MPI_WAIT является нелокальной операцией.

Вызов возвращает в status информацию о завершенной операции. Содержание статусного объекта для приемной операции может быть получено, как описано в параграфе 3.2.5.

Разрешается вызывать MPI_WAIT с нулевым или неактивным аргументом запроса. В этом случае операция заканчивается немедленно со статусом empty.

MPI_TEST (request, flag, status)

int MPI_Test (MPI_Request *request, int *flag, MPI_Status *status)

MPI_TEST(REQUEST, FLAG, STATUS, IERROR) LOGICAL FLAG

INTEGER REQUEST, STATUS(MPI_STATUS_SIZE), IERROR bool MPI::Request::Test (MPI::Status& status)

68

Обращение к MPI_TEST возвращает flag = true, если операция, указанная в запросе, завершена. В таком случае статусный объект содержит информацию о завершенной операции; если коммуникационный объект был создан неблокирующей посылкой или приемом, то он входит в состояние дедлока, и обработка запроса устанавливается в MPI_REQUEST_NULL. Другими словами, вызов возвращает flag = false. В этом случае значение статуса не определено. MPI_TEST является локальной операцией.

Возвращенный статус для операции приема несет информацию, которая может быть получена, как описано в параграфе 3.2.5. Статусный объект для операции посылки несет информацию, которая может быть получена обращением к MPI_TEST_CANCELLED (параграф 3.8). Можно вызывать MPI_TEST с нулевым или неактивным аргументом запроса. В таком случае операция возвращает flag = true и empty для status.

Функции MPI_WAIT и MPI_TEST могут быть использованы как для завершения, так и для приема.

Пример 3.10. Простое использование неблокируемой операции.

CALL MPI_COMM_RANK(comm, rank, ierr) IF(rank.EQ.0) THEN

CALL MPI_ISEND(a(1), 10, MPI_REAL, 1, tag, comm, request, ierr) ! выполним вычисления до завершения операции посылки

CALL MPI_WAIT(request, status, ierr) ELSE

CALL MPI_IRECV(a(1), 15, MPI_REAL, 0, tag, comm, request, ierr) ! выполним вычисления до завершения операции приема

CALL MPI_WAIT(request, status, ierr)

END IF

3.7.4. Семантика неблокирующих коммуникаций

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

Пример 3.11. Установление очереди для неблокирующих операций.

CALL MPI_COMM_RANK(comm, rank, ierr)

IF (RANK.EQ.0) THEN

CALL MPI_ISEND(a, 1, MPI_REAL, 1, 0, comm, r1, ierr)

69

CALL MPI_ISEND(b, 1, MPI_REAL, 1, 0, comm, r2, ierr) ELSE

CALL MPI_IRECV(a,1,MPI_REAL,0,MPI_ANY_TAG, comm, r1, ierr) CALL MPI_IRECV(b, 1, MPI_REAL, 0, 0, comm, r2, ierr)

END IF

CALL MPI_WAIT(r1,status)

CALL MPI_WAIT(r2,status)

Первая посылка процесса с номером 0 будет соответствовать первому приему процесса с номером 1, даже если оба сообщения посланы до того, как процесс с номером 1 выполнит тот или другой прием.

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

Пример 3.12. Иллюстрация семантики продвижения.

CALL MPI_COMM_RANK(comm, rank, ierr)

IF (RANK.EQ.0) THEN

CALL MPI_SSEND(a, 1, MPI_REAL, 1, 0, comm, ierr)

CALL MPI_SEND(b, 1, MPI_REAL, 1, 1, comm, ierr)

ELSE

CALL MPI_IRECV(a, 1, MPI_REAL, 0, 0, comm, r, ierr)

CALL MPI_RECV(b, 1, MPI_REAL, 0, 1, comm, ierr)

CALL MPI_WAIT(r, status, ierr)

END IF

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

Если MPI_TEST, который завершает прием, вызывается повторно с тем же аргументом и соответствующая посылка стартовала, тогда вызов рано или поздно возвратит flag = true, если посылка не закрыта другим приемом. Если MPI_TEST, который завершает посылку, по-

70