mpy.mpich2 - Интернет в облаке

ПРОГРАММА:

ИМЯ

mpy - Йорик передает сообщение

СИНТАКСИС

mpirun -np mp_size MPY [-j pfile1.i [-j pfile2.i [...]]] [-i файл1.i [-i файл2.i [
...]]]
mpirun -np mp_size MPY -партия файл.i

ОПИСАНИЕ

Йорик это интерпретируемый язык, такой как Basic или Lisp, но намного быстрее. Видеть Йорик (1) до
узнать больше об этом.
Mpy это параллельная версия Йорик на основе интерфейса передачи сообщений (MPI). В
точный синтаксис для запуска параллельного задания зависит от вашей среды MPI. Это может быть
необходимо запустить специальный демон перед вызовом Мирун или аналогичная команда.

Пояснения
Пакет mpy обеспечивает интерфейс yorick с библиотекой параллельного программирования MPI. MPI означает
Интерфейс передачи сообщений; идея состоит в том, чтобы соединить несколько экземпляров yorick, которые
общаются между собой через сообщения. Mpy может выполнять простые, высокопараллельные
задачи как чисто интерпретируемые программы, или он может запускать и управлять произвольно сложными скомпилированными
пакеты, которые могут бесплатно использовать скомпилированный MPI API. Интерпретируемый API не предназначен
быть оберткой MPI; вместо этого он урезан до минимума.

Это версия 2 программы mpy (выпущена в 2010 году); он несовместим с версией 1 MPY
(выпущен в середине 1990-х годов), поскольку версия 1 имела множество конструктивных недостатков, что делало ее очень
сложно писать программы без условий гонки и невозможно масштабировать до миллионов
процессоров. Однако вы можете запускать большинство программ mpy версии 1 под версией 2, выполнив
mp_include, "mpy1.i" перед тем, как mp_include любого файла, определяющего параллельную задачу mpy1 (то есть
перед любым файлом, содержащим вызов mp_task.)

Применение ноты
Среда MPI на самом деле не определена стандартом; существующие среды
очень грубые и настоятельно рекомендуют неинтерактивные пакетные задания. Количество процессов
исправлено до начала MPI; у каждого процесса есть ранг, число от 0 до одного меньше, чем
количество процессов. Вы используете рейтинг как адрес для отправки сообщений, а процесс
получение сообщения может проверить, какие ранги отправили ему сообщения, и, конечно,
получать эти сообщения.

Основная проблема при написании программы передачи сообщений - это обработка событий или сообщений.
прибытие в незапланированном порядке. MPI гарантирует только то, что последовательность сообщений, отправленных
от ранга A до ранга B прибудут в порядке отправки. Нет никаких гарантий относительно порядка
прибытие этих сообщений относительно сообщений, отправленных в B с третьего ранга C.
в частности, предположим, что A отправляет сообщение B, затем A отправляет сообщение C (или даже обменивается
несколько сообщений с C), в результате чего C отправляет сообщение B. Сообщение от C
может прибыть в B до сообщения от A. Программа MPI, которая не позволяет этого
В возможности есть ошибка, называемая «состояние гонки». Условия гонки могут быть очень сложными,
особенно при большом количестве процессов.

Базовый интерпретируемый интерфейс mpy состоит из двух переменных:
mp_size = количество процессов
mp_rank = ранг этого процесса и четыре функции:
mp_send, to, msg; // отправляем сообщение для ранжирования "до"
msg = mp_recv (от); // получение сообщения из ранга "от"
ранги = mp_probe (блок); // запрашиваем отправителей ожидающих сообщений
mp_exec, строка; // анализировать и выполнять строку для каждого ранга

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

Пакет mpy изменяет способ обработки yorick директивы парсера #include, а параметр include
и требуют функций. А именно, если запущена параллельная задача (то есть запущена функция
by mp_exec), все они становятся коллективными операциями. То есть ранг 0 читает все
содержимое файла и отправляет содержимое другим процессам в виде сообщения MPI (например,
mp_exec содержимого файла). Все процессы, кроме ранга 0, выполняются только во время
параллельные задачи; вне параллельной задачи, когда выполняется только ранг 0 (и все остальные ранги
ждут следующего mp_exec), директиву #include, а также include и require
функции возвращаются к своей обычной последовательной работе, влияя только на ранг 0.

Когда mpy запускается, он находится в параллельном режиме, так что все файлы, которые yorick включает, когда он
start (файлы в Y_SITE / i0) включаются как коллективные операции. Без этого
функция, каждый процесс yorick будет пытаться открыть и прочитать файлы включения запуска,
перегрузка файловой системы до запуска mpy. Передача содержимого этих
файлы в виде сообщений MPI - единственный способ обеспечить достаточную пропускную способность для каждого
процесс чтения содержимого одного файла.

Последним файлом, включенным при запуске, является либо файл, указанный в параметре -batch, либо
файл custom.i. Чтобы избежать проблем с кодом в custom.i, который может быть небезопасным для
При параллельном выполнении mpy ищет не custom.i, а custommp.i. В
инструкции в -batch файле или custommp.i выполняются в последовательном режиме на ранге 0
Только. Точно так же mpy переопределяет обычную функцию process_argv, так что -i и другие
параметры командной строки обрабатываются только на ранге 0 в последовательном режиме. Намерение во всех этих
case - сделать так, чтобы включаемые файлы -batch или custommp.i или -i выполнялись только с рангом 0, так как
если вы набрали их там в интерактивном режиме. Вы можете вызвать mp_exec из любого из этих
файлы для запуска параллельных задач, но сам файл является последовательным.

К обычному набору добавляется дополнительная опция командной строки:
mpy -j какой-то файл.i
включает somefile.i в параллельном режиме для всех рангов (опять же, -i other.i включает только other.i
на ранге 0 в последовательном режиме). Если есть несколько опций -j, параллельное включение происходит
в порядке командной строки. Однако, если параметры -j и -i смешаны, все -j включает в себя
перед любым -i включает.

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

Функция mp_send может отправлять любой числовой массив yorick (типы char, short, int, long,
float, double или complex) или скалярное строковое значение. Процесс отправки сообщения
через MPI сохраняет только количество элементов, поэтому mp_recv производит только скалярное значение или
одномерный массив значений, независимо от того, какой размерности был передан в mp_send.

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

Функция mp_probe возвращает список всех отправителей сообщений в очереди (или ноль, если
очередь пуста). Вызов mp_probe(0) для немедленного возврата, даже если очередь пуста.
Позвонить mp_probe(1) блокировать, если очередь пуста, возвращать только когда хотя бы одно сообщение
доступен для mp_recv. Вызов mp_probe(2) блокировать до прихода нового сообщения, даже если
некоторые сообщения в настоящее время доступны.

Функция mp_exec использует логарифмическое разветвление - ранг 0 отправляется F процессам, каждый из
который отправляет F еще, и так далее, пока все процессы не получат сообщение. Однажды процесс
завершает все свои операции отправки, анализирует и выполняет содержимое сообщения.
Алгоритм разветвления достигает N процессов в журнале до базы F из N шагов. F-процессы
ранг 0 отправляет в ранги 1, 2, 3, ..., F. Как правило, процесс с рангом r отправляет в
ранги r * F + 1, r * F + 2, ..., r * F + F (когда они меньше N-1 для N процессов). Этот набор
называется «посохом» ранга r. Ранги с r> 0 получают сообщение с ранга (r-1) / F,
которую называют «боссом» г. Вызов mp_exec взаимодействует с очередью mp_recv;
другими словами, сообщения другого ранга, кроме босса, во время разветвления mp_exec будут
поставлен в очередь для последующего извлечения с помощью mp_recv. (Без этой функции любая параллельная задача, которая
использовал шаблон сообщения, отличный от логарифмического разветвления, будет восприимчив к гонке
условия.)

Логарифмическое разветвление и его внутренний эквивалент настолько полезны, что mpy предоставляет пару
функций более высокого уровня, которые используют тот же шаблон разветвления, что и mp_exec:
mp_handout, сообщение;
total = mp_handin (значение);
Чтобы использовать mp_handout, ранг 0 вычисляет сообщение, затем все ранги вызывают mp_handout, который отправляет сообщение
(вывод для всех рангов, кроме 0) везде тем же разветвлением, что и mp_exec. Использовать
mp_handin, каждый процесс вычисляет значение, затем вызывает mp_handin, который возвращает сумму
их собственное значение и весь их персонал, так что на ранге 0 mp_handin возвращает сумму
ценности из каждого процесса.

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

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

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

Наконец, примечание о восстановлении после ошибок. В случае ошибки во время параллельной задачи,
mpy пытается корректно выйти из mp_exec, так что при возврате ранга 0 все остальные ранги
известны как простаивающие, готовые к следующему mp_exec. Эта процедура будет висеть навсегда, если
один из процессов находится в бесконечном цикле или в состоянии, в котором он никогда не будет
вызовите mp_send, mp_recv или mp_probe, потому что MPI не предоставляет средств для отправки сигнала, который
прерывает все процессы. (Это один из способов, которыми среда MPI
"грубый".) Процесс с рангом 0 остается с рангом первого процесса, сообщившего о
сбоя, плюс подсчет количества процессов, которые вышли из строя по причине, отличной от
отправил сообщение, что другой ранг ошибся. Первый сбойный процесс может попасть в dbug
режим через mp_connect; используйте mp_disconnect или dbexit, чтобы вернуться в последовательный режим на ранге 0.

Возможности
-j файл.i включает исходный файл Yorick файл.i поскольку mpy запускается в параллельном режиме
по всем рангам. Это эквивалентно функции mp_include после mpy
началось.

-i файл.i включает исходный файл Yorick файл.i при запуске mpy в последовательном режиме.
Это эквивалентно директиве #include после запуска mpy.

-партия файл.i включает исходный файл Yorick файл.i при запуске mpy в последовательном режиме.
Ваш файл настройки custommp.i, если он есть, читать, и mpy
помещен в пакетный режим. Используйте команду справки для пакетной функции
(помощь, пакетный), чтобы узнать больше о пакетном режиме. В пакетном режиме все
ошибки фатальны; обычно mpy останавливает выполнение и ждет
ввод после ошибки.

Используйте mpy.mpich2 в Интернете с помощью сервисов onworks.net