mpy.openmpi - Online en la nube

PROGRAMA:

NOMBRE

mpy - Mensaje que pasa Yorick

SINOPSIS

mpirun -np mp_tamaño mpy [-j pfile1.i [-j pfile2.i [ ... ]]] [ -I archivo1.i [ -I archivo2.i [
...]]]
mpirun -np mp_tamaño mpy -lote archivo.i

DESCRIPCIÓN

Yorick es un lenguaje interpretado como Basic o Lisp, pero mucho más rápido. Ver yorick (1) a
aprenda más sobre esto.
MPy es una versión paralela de Yorick basado en la interfaz de paso de mensajes (MPI). los
La sintaxis exacta para iniciar un trabajo paralelo depende de su entorno MPI. Puede ser
necesario para lanzar un demonio especial antes de llamar mirún o un comando equivalente.

Explicación
El paquete mpy conecta yorick con la biblioteca de programación paralela MPI. MPI significa
Interfaz de paso de mensajes; la idea es conectar múltiples instancias de yorick que
comunicarse entre ellos a través de mensajes. Mpy puede realizar operaciones simples, altamente paralelas
tareas como programas interpretados puros, o puede iniciar y dirigir arbitrariamente complejas compilaciones
paquetes que son gratuitos para usar la API MPI compilada. La API interpretada no está destinada
ser un contenedor MPI; en cambio, se reduce al mínimo.

Esta es la versión 2 de mpy (lanzada en 2010); es incompatible con la versión 1 de mpy
(lanzado a mediados de la década de 1990), porque la versión 1 tenía numerosos defectos de diseño que la hacían muy
Es difícil escribir programas sin condiciones de carrera e imposible de escalar a millones.
de procesadores. Sin embargo, puede ejecutar la mayoría de los programas mpy de la versión 1 en la versión 2 haciendo
mp_include, "mpy1.i" antes de mp_include cualquier archivo que defina una tarea paralela mpy1 (es decir
antes de cualquier archivo que contenga una llamada a mp_task.)

Uso reconoce
El entorno MPI no está realmente especificado por el estándar; los entornos existentes son
muy rudimentarios y favorecen fuertemente los trabajos por lotes no interactivos. El número de procesos es
arreglado antes de que comience MPI; cada proceso tiene un rango, un número de 0 a uno menos que el
número de procesos. Utiliza el rango como una dirección para enviar mensajes, y el proceso
recibir el mensaje puede sondear para ver qué rangos le han enviado mensajes y, por supuesto,
recibir esos mensajes.

Un problema importante al escribir un programa de transmisión de mensajes es el manejo de eventos o mensajes.
llegando en un orden no planificado. MPI garantiza solo que una secuencia de mensajes enviados por
el rango A al rango B llegará en el orden enviado. No hay garantía sobre el pedido de
llegada de esos mensajes en relación con los mensajes enviados a B desde un tercer rango C. En
en particular, supongamos que A envía un mensaje a B, luego A envía un mensaje a C (o incluso intercambia
varios mensajes con C) lo que da como resultado que C envíe un mensaje a B. El mensaje de C
puede llegar a B antes del mensaje de A. Un programa MPI que no permite este
La posibilidad tiene un error llamado "condición de carrera". Las condiciones de carrera pueden ser extremadamente sutiles,
especialmente cuando el número de procesos es grande.

La interfaz básica interpretada por mpy consta de dos variables:
mp_size = número de procesos
mp_rank = rango de este proceso y cuatro funciones:
mp_send, to, msg; // enviar mensaje para clasificar "a"
msg = mp_recv (desde); // recibir mensaje del rango "de"
ranks = mp_probe (bloque); // consulta a los remitentes de los mensajes pendientes
mp_exec, cadena; // analizar y ejecutar cadenas en cada rango

Llamas a mp_exec en el rango 0 para iniciar una tarea paralela. Cuando el programa principal así creado
termina, todos los rangos que no sean el rango 0 vuelven a un ciclo inactivo, esperando el siguiente
mp_exec. El rango 0 toma la siguiente línea de entrada de stdin (es decir, espera la entrada en su
mensaje en una sesión interactiva), o termina todos los procesos si no se reciben más entradas
disponible en una sesión por lotes.

El paquete mpy modifica la forma en que yorick maneja la directiva #include parser, y el include
y requieren funciones. Es decir, si se está ejecutando una tarea paralela (es decir, se inició una función
por mp_exec), todos estos se convierten en operaciones colectivas. Es decir, el rango 0 lee todo
el contenido del archivo y envía el contenido a los otros procesos como un mensaje MPI (como
mp_exec del contenido del archivo). Todos los procesos que no sean de rango 0 solo se ejecutan durante
tareas paralelas; fuera de una tarea paralela cuando solo se ejecuta el rango 0 (y todos los demás rangos
están esperando el próximo mp_exec), la directiva #include y el include y require
las funciones vuelven a su operación serial habitual, afectando solo al rango 0.

Cuando mpy se inicia, es en modo paralelo, de modo que todos los archivos que incluye yorick
Los inicios (los archivos en Y_SITE / i0) se incluyen como operaciones colectivas. Sin esto
característica, cada proceso de yorick intentaría abrir y leer los archivos de inclusión de inicio,
sobrecargar el sistema de archivos antes de que mpy se inicie. Pasando el contenido de estos
archivos como mensajes MPI es la única forma de garantizar que haya suficiente ancho de banda para cada
proceso para leer el contenido de un solo archivo.

El último archivo incluido al inicio es el archivo especificado en la opción -batch, o
el archivo custom.i. Para evitar problemas con el código en custom.i que puede no ser seguro para
ejecución paralela, mpy no busca custom.i, sino custommp.i en su lugar. los
las instrucciones en el archivo -batch o en custommp.i se ejecutan en modo serial en el rango 0
solamente. Del mismo modo, mpy anula la función process_argv habitual, de modo que -i y otros
Las opciones de la línea de comandos se procesan solo en el rango 0 en modo serial. La intención en todos estos
casos es hacer que los archivos -batch o custommp.i o -i include se ejecuten solo en el rango 0, como
si los hubiera escrito allí de forma interactiva. Puede llamar a mp_exec desde cualquiera de estos
archivos para iniciar tareas paralelas, pero el archivo en sí es serial.

Se agrega una opción de línea de comando adicional al conjunto habitual:
mpy -j algúnarchivo.i
incluye somefile.i en modo paralelo en todos los rangos (de nuevo, -i other.i incluye other.i solamente
en rango 0 en modo serial). Si hay varias opciones -j, las inclusiones paralelas ocurren
en el orden de la línea de comandos. Sin embargo, si las opciones -j y -i se mezclan, todas las -j incluyen suceden
antes de cualquier -i incluye.

Como efecto secundario de la complejidad de las funciones de inclusión en mpy, la función de carga automática es
discapacitado; si su código realmente activa una inclusión llamando a una función autocargada, mpy
se detendrá con un error. Debe cargar explícitamente cualquier función necesaria para un paralelo
las tareas que utilizan requieren llamadas de función a sí mismas dentro de una tarea paralela.

La función mp_send puede enviar cualquier matriz yorick numérica (tipos char, short, int, long,
flotante, doble o complejo) o un valor de cadena escalar. El proceso de envío del mensaje
a través de MPI conserva solo el número de elementos, por lo que mp_recv produce solo un valor escalar o
una matriz de valores 1D, sin importar la dimensionalidad que se haya pasado a mp_send.

La función mp_recv requiere que especifique el remitente del mensaje que desea
recibir. Se bloquea hasta que llega un mensaje de ese remitente, poniendo en cola cualquier
mensajes de otros remitentes que puedan llegar de antemano. Los mensajes en cola serán
recuperó el pedido recibido cuando llamas a mp_recv para el remitente coincidente. los
La función de cola hace que sea mucho más fácil evitar los tipos más simples de condición de carrera.
cuando se escribe programas paralelos interpretados.

La función mp_probe devuelve la lista de todos los remitentes de mensajes en cola (o nulo si
la cola está vacía). Llama mp_sonda(0) para volver inmediatamente, incluso si la cola está vacía.
Llama al mp_sonda(1) para bloquear si la cola está vacía, regresando solo cuando al menos un mensaje
está disponible para mp_recv. Llama mp_sonda(2) para bloquear hasta que llegue un nuevo mensaje, incluso si
algunos mensajes están disponibles actualmente.

La función mp_exec usa un fanout logarítmico: el rango 0 envía a F procesos, cada uno de
que envía a F más, y así sucesivamente, hasta que todos los procesos tengan el mensaje. Una vez que un proceso
completa todas sus operaciones de envío, analiza y ejecuta el contenido del mensaje.
El algoritmo de fanout alcanza N procesos en log a la base F de N pasos. Los procesos F
el rango 0 envía a los rangos 1, 2, 3, ..., F.En general, el proceso con rango r envía a
rangos r * F + 1, r * F + 2, ..., r * F + F (cuando estos son menores que N-1 para N procesos). Este conjunto
se llama el "personal" de rango r. Los rangos con r> 0 reciben el mensaje del rango (r-1) / F,
que se llama el "jefe" de r. La llamada mp_exec interopera con la cola mp_recv;
en otras palabras, los mensajes de un rango que no sea el jefe durante un fanout mp_exec serán
en cola para su posterior recuperación por mp_recv. (Sin esta característica, cualquier tarea paralela que
usó un patrón de mensaje diferente al fanout logarítmico sería susceptible a la raza
condiciones.)

El abanico logarítmico y su equivalente interno son tan útiles que mpy proporciona un par
de funciones de nivel superior que utilizan el mismo patrón de distribución que mp_exec:
mp_handout, mensaje;
total = mp_handin (valor);
Para usar mp_handout, el rango 0 calcula un mensaje, luego todos los rangos llaman a mp_handout, que envía el mensaje.
(una salida en todos los rangos distintos de 0) en todas partes por el mismo fanout que mp_exec. Usar
mp_handin, cada proceso calcula el valor, luego llama a mp_handin, que devuelve la suma de
su propio valor y todo su personal, de modo que en el rango 0 mp_handin devuelve la suma de los
valores de cada proceso.

Puede llamar a mp_handin como una función sin argumentos para que actúe como sincronización; cuando
el rango 0 continúa después de tal llamada, usted sabe que todos los demás rangos han alcanzado ese punto.
Todas las tareas paralelas (cualquier cosa que comience con mp_exec) deben terminar con una llamada a mp_handin,
o una garantía equivalente de que todos los procesos han vuelto a un estado inactivo cuando la tarea
termina en el rango 0.

Puede recuperar o cambiar el parámetro fanout F usando la función mp_nfan. El valor por defecto
El valor es 16, que debería ser razonable incluso para un gran número de procesos.

Una tarea paralela especial se llama mp_connect, que puede utilizar para alimentar interpretados
líneas de comando a cualquier rango único que no sea 0, mientras que todos los demás rangos permanecen inactivos. El rango 0 se ubica en un
bucle leyendo el teclado y enviando las líneas al rango "conectado", que ejecuta
ellos, y envía un acuse de recibo al rango 0. Ejecuta la función mp_disconnect para
Completa la tarea paralela y vuelve al rango 0.

Finalmente, una nota sobre la recuperación de errores. En caso de error durante una tarea paralela,
mpy intenta salir elegantemente de mp_exec, de modo que cuando regrese el rango 0, todos los demás rangos
se sabe que están inactivos, listos para el próximo mp_exec. Este procedimiento se colgará para siempre si lo hay.
uno de los procesos está en un bucle infinito, o en un estado en el que nunca
llamar a mp_send, mp_recv o mp_probe, porque MPI no proporciona ningún medio para enviar una señal que
interrumpe todos los procesos. (Esta es una de las formas en que el entorno MPI se
"crudo".) El proceso de rango 0 se deja con el rango del primer proceso que informó un
falla, más un recuento de la cantidad de procesos que fallaron por una razón que no sea
envió un mensaje de que otro rango había fallado. El primer proceso de fallas puede ingresar a dbug
modo a través de mp_connect; use mp_disconnect o dbexit para volver al modo serial en el rango 0.

De Seguros
-j archivo.i incluye el archivo fuente de Yorick archivo.i como mpy comienza en modo paralelo
en todos los rangos. Esto es equivalente a la función mp_include después de mpy
ha empezado.

-i archivo.i incluye el archivo fuente de Yorick archivo.i cuando mpy se inicia, en modo serie.
Esto es equivalente a la directiva #include después de que se haya iniciado mpy.

-lote archivo.i incluye el archivo fuente de Yorick archivo.i cuando mpy se inicia, en modo serie.
Su archivo de personalización custommp.i, si lo hay, es no leer, y mpy es
colocado en modo por lotes. Utilice el comando de ayuda en la función por lotes
(ayuda, lote) para obtener más información sobre el modo por lotes. En modo por lotes, todos
los errores son fatales; normalmente, mpy detendrá la ejecución y esperará más
entrada después de un error.

Utilice mpy.openmpi en línea utilizando los servicios de onworks.net