mpy - Online na nuvem

PROGRAMA:

NOME

mpy - mensagem passando Yorick

SINOPSE

mpirun -np mp_size mpy [-j pfile1.i [-j pfile2.i [ ... ]]] [ -eu arquivo1.i [ -eu arquivo2.i [
...]]]
mpirun -np mp_size mpy -lote arquivo.i

DESCRIÇÃO

Yorick é uma linguagem interpretada como Basic ou Lisp, mas muito mais rápida. Ver yerick (1) para
aprenda mais sobre isso.
MPY é uma versão paralela de Yorick com base na Message Passing Interface (MPI). o
A sintaxe exata para iniciar um trabalho paralelo depende do seu ambiente MPI. Pode ser
necessário lançar um daemon especial antes de chamar mirun ou um comando equivalente.

Explicações
O pacote mpy faz a interface do yorick com a biblioteca de programação paralela MPI. MPI significa
Interface de passagem de mensagens; a ideia é conectar várias instâncias de yorick que
comunicar-se entre si por meio de mensagens. O Mpy pode realizar tarefas simples e altamente paralelas
tarefas como programas interpretados puros, ou pode iniciar e orientar compilações arbitrariamente complexas
pacotes que são gratuitos para usar a API MPI compilada. A API interpretada não se destina
para ser um wrapper MPI; em vez disso, é reduzido ao mínimo.

Esta é a versão 2 do mpy (lançado em 2010); é incompatível com a versão 1 do mpy
(lançado em meados de 1990), porque a versão 1 tinha inúmeras falhas de design, tornando-a muito
difícil de escrever programas sem condições de corrida e impossível de escalar para milhões
de processadores. No entanto, você pode executar a maioria dos programas mpy da versão 1 sob a versão 2 fazendo
mp_include, "mpy1.i" antes de mp_include qualquer arquivo definindo uma tarefa paralela mpy1 (isto é
antes de qualquer arquivo contendo uma chamada para mp_task.)

Uso notas
O ambiente MPI não é realmente especificado pelo padrão; ambientes existentes são
muito bruto e favorece fortemente trabalhos em lote não interativos. O número de processos é
corrigido antes do início do MPI; cada processo tem uma classificação, um número de 0 a um a menos que o
número de processos. Você usa a classificação como um endereço para enviar mensagens, e o processo
receber a mensagem pode sondar para ver quais postos enviaram mensagens para ela e, claro,
receber essas mensagens.

Um grande problema ao escrever um programa de passagem de mensagens é lidar com eventos ou mensagens
chegando em um pedido não planejado. MPI garante apenas que uma sequência de mensagens enviadas por
A classificação A para a classificação B chegará na ordem enviada. Não há garantia sobre a ordem de
chegada dessas mensagens em relação às mensagens enviadas para B de uma terceira classificação C. Em
particular, suponha que A envie uma mensagem para B, então A envia uma mensagem para C (ou mesmo troca
várias mensagens com C), o que resulta em C enviando uma mensagem para B. A mensagem de C
pode chegar a B antes da mensagem de A. Um programa MPI que não permite isso
possibilidade tem um bug chamado "condição de corrida". As condições da corrida podem ser extremamente sutis,
especialmente quando o número de processos é grande.

A interface interpretada mpy básica consiste em duas variáveis:
mp_size = número de processos
mp_rank = classificação deste processo e quatro funções:
mp_send, to, msg; // enviar msg para classificar "para"
msg = mp_recv (de); // receber msg da classificação "de"
ranks = mp_probe (bloco); // consultar remetentes de mensagens pendentes
mp_exec, string; // analisa e executa a string em cada classificação

Você chama mp_exec na classificação 0 para iniciar uma tarefa paralela. Quando o programa principal assim criado
terminar, todas as classificações, exceto a classificação 0, retornam para um loop ocioso, esperando pelo próximo
mp_exec. O Rank 0 pega a próxima linha de entrada de stdin (isto é, espera pela entrada em seu
prompt em uma sessão interativa), ou encerra todos os processos se nenhuma outra entrada for
disponível em uma sessão em lote.

O pacote mpy modifica a forma como o yorick lida com a diretiva do analisador #include e o include
e requerem funções. Ou seja, se uma tarefa paralela estiver em execução (ou seja, uma função iniciada
por mp_exec), todos se tornam operações coletivas. Ou seja, a classificação 0 lê todo o
conteúdo do arquivo, e envia o conteúdo para os outros processos como uma mensagem MPI (como
mp_exec do conteúdo do arquivo). Todos os processos, exceto a classificação 0, estão em execução apenas durante
tarefas paralelas; fora de uma tarefa paralela quando apenas a classificação 0 está em execução (e todas as outras classificações
estão esperando pelo próximo mp_exec), a diretiva #include e o include e require
as funções retornam à operação serial normal, afetando apenas a classificação 0.

Quando o mpy é iniciado, ele está em modo paralelo, de modo que todos os arquivos que o yorick inclui quando ele
inícios (os arquivos em Y_SITE / i0) são incluídos como operações coletivas. Sem isso
recurso, cada processo yorick tentaria abrir e ler os arquivos de inclusão de inicialização,
sobrecarregando o sistema de arquivos antes que o mpy seja iniciado. Passando o conteúdo destes
arquivos como mensagens MPI é a única maneira de garantir que haja largura de banda suficiente para cada
processo para ler o conteúdo de um único arquivo.

O último arquivo incluído na inicialização é o arquivo especificado na opção -batch ou
o arquivo custom.i. Para evitar problemas com o código em custom.i que pode não ser seguro para
execução paralela, mpy não procura custom.i, mas custommp.i. o
as instruções no arquivo -batch ou em custommp.i são executadas no modo serial na classificação 0
só. Da mesma forma, mpy substitui a função usual process_argv, de modo que -i e outros
as opções de linha de comando são processadas apenas na classificação 0 no modo serial. A intenção em todos esses
casos é fazer com que os arquivos -batch ou custommp.i ou -i incluam executem apenas na classificação 0, como
se você os tivesse digitado lá interativamente. Você pode ligar para mp_exec a partir de qualquer um destes
arquivos para iniciar tarefas paralelas, mas o próprio arquivo é serial.

Uma opção de linha de comando adicional é adicionada ao conjunto usual:
mpy -j algumarquivo.i
inclui algumarquivo.i no modo paralelo em todas as classificações (novamente, -i outro.i inclui apenas outro.i
na classificação 0 no modo serial). Se houver várias opções -j, o paralelo inclui acontecer
na ordem da linha de comando. Se as opções -j e -i forem misturadas, no entanto, todas as inclusões -j acontecem
antes de qualquer -i incluir.

Como um efeito colateral da complexidade das funções de inclusão em mpy, o recurso autoload é
Desativado; se o seu código realmente acionar um include chamando uma função carregada automaticamente, mpy
irá parar com um erro. Você deve carregar explicitamente todas as funções necessárias para um paralelo
tarefas que usam a função de requerer chamam a si mesmas dentro de uma tarefa paralela.

A função mp_send pode enviar qualquer array numérico Yorick (tipos char, short, int, long,
float, double ou complex) ou um valor de string escalar. O processo de envio da mensagem
via MPI preserva apenas o número de elementos, então mp_recv produz apenas um valor escalar ou
um array 1D de valores, não importa qual dimensionalidade foi passada para mp_send.

A função mp_recv requer que você especifique o remetente da mensagem que você pretende
receber. Ele bloqueia até que uma mensagem realmente chegue desse remetente, colocando qualquer
mensagens de outros remetentes que podem chegar com antecedência. As mensagens na fila serão
recuperou o pedido recebido quando você chama mp_recv para o remetente correspondente. o
recurso de enfileiramento torna muito mais fácil evitar os tipos mais simples de condição de corrida
quando você está escrevendo programas paralelos interpretados.

A função mp_probe retorna a lista de todos os remetentes de mensagens na fila (ou nulo se
a fila está vazia). Ligar mp_probe(0) para retornar imediatamente, mesmo se a fila estiver vazia.
Ligar mp_probe(1) para bloquear se a fila estiver vazia, retornando apenas quando houver pelo menos uma mensagem
está disponível para mp_recv. Ligar mp_probe(2) bloquear até que uma nova mensagem chegue, mesmo que
algumas mensagens estão disponíveis no momento.

A função mp_exec usa um fanout logarítmico - classificação 0 envia para processos F, cada um dos
que envia para F mais, e assim por diante, até que todos os processos tenham a mensagem. Uma vez que um processo
completa todas as suas operações de envio, analisa e executa o conteúdo da mensagem.
O algoritmo fanout atinge N processos em log para a base F de N etapas. Os processos F
a classificação 0 envia para as classificações 1, 2, 3, ..., F. Em geral, o processo com classificação r envia para
classifica r * F + 1, r * F + 2, ..., r * F + F (quando estes são menores que N-1 para N processos). Este conjunto
é chamado de "bastão" de nível r. Os postos com r> 0 recebem a mensagem do posto (r-1) / F,
que é chamado de "chefe" de r. A chamada mp_exec interopera com a fila mp_recv;
em outras palavras, as mensagens de um posto diferente do chefe durante um fanout mp_exec serão
enfileirado para recuperação posterior por mp_recv. (Sem esse recurso, qualquer tarefa paralela que
usado um padrão de mensagem diferente de fanout logarítmico seria suscetível a raça
condições.)

O fanout logarítmico e seu equivalente interno são tão úteis que mpy fornece alguns
de funções de nível superior que usam o mesmo padrão de fanout que mp_exec:
folheto_mp, msg;
total = mp_handin (valor);
Para usar mp_handout, a classificação 0 calcula uma mensagem, então todas as classificações chamam mp_handout, que envia a mensagem
(uma saída em todas as classificações diferentes de 0) em todos os lugares pelo mesmo fanout que mp_exec. Usar
mp_handin, cada processo calcula o valor e, em seguida, chama mp_handin, que retorna a soma de
seu próprio valor e toda a sua equipe, de modo que no posto 0 mp_handin retorna a soma dos
valores de cada processo.

Você pode chamar mp_handin como uma função sem argumentos para atuar como uma sincronização; quando
a classificação 0 continua após tal chamada, você sabe que todas as outras classificações alcançaram esse ponto.
Todas as tarefas paralelas (qualquer coisa iniciada com mp_exec) devem terminar com uma chamada para mp_handin,
ou uma garantia equivalente de que todos os processos voltaram a um estado ocioso quando a tarefa
termina na classificação 0.

Você pode recuperar ou alterar o parâmetro fanout F usando a função mp_nfan. O padrão
o valor é 16, o que deve ser razoável mesmo para um grande número de processos.

Uma tarefa paralela especial é chamada mp_connect, que você pode usar para alimentar interpretado
linhas de comando para qualquer classificação diferente de 0, enquanto todas as outras classificações permanecem inativas. Rank 0 fica em um
loop lendo o teclado e enviando as linhas para o posto "conectado", que executa
e envia uma confirmação de volta para a classificação 0. Você executa a função mp_disconnect para
complete a tarefa paralela e volte para a classificação 0.

Finalmente, uma nota sobre a recuperação de erros. No caso de um erro durante uma tarefa paralela,
mpy tenta sair normalmente do mp_exec, de modo que quando a classificação 0 retornar, todas as outras classificações
são conhecidos por estarem inativos, prontos para o próximo mp_exec. Este procedimento ficará suspenso para sempre se houver
um dos processos está em um loop infinito, ou de outra forma em um estado onde nunca
chame mp_send, mp_recv ou mp_probe, porque MPI não fornece meios para enviar um sinal que
interrompe todos os processos. (Esta é uma das maneiras em que o ambiente MPI é
"bruto".) O processo de classificação 0 é deixado com a classificação do primeiro processo que relatou um
falha, além de uma contagem do número de processos que falharam por um motivo diferente de ser
enviou uma mensagem de que outro posto havia falhado. O primeiro processo de falha pode entrar no dbug
modo via mp_connect; use mp_disconnect ou dbexit para voltar ao modo serial na classificação 0.

Opções
-j arquivo.i inclui o arquivo fonte Yorick arquivo.i quando mpy inicia em modo paralelo
em todas as fileiras. Isso é equivalente à função mp_include após mpy
começou.

-i arquivo.i inclui o arquivo fonte Yorick arquivo.i quando o mpy é iniciado, no modo serial.
Isso é equivalente à diretiva #include após o início do mpy.

-lote arquivo.i inclui o arquivo fonte Yorick arquivo.i quando o mpy é iniciado, no modo serial.
Seu arquivo de personalização custommp.i, se houver, é não ler, e mpy é
colocado em modo de lote. Use o comando help na função batch
(ajuda, lote) para saber mais sobre o modo de lote. No modo batch, todos
os erros são fatais; normalmente, mpy irá parar a execução e esperar por mais
entrada após um erro.

Use mpy online usando serviços onworks.net