El objetivo de este artículo es servir como introducción a PVM y MPI, dos sistemas de software ampliamente usados para la transmisión de mensajes entre programas en procesamiento paralelo. Estos nos permiten tener diferentes sistemas UNIX/ LINUX conectados por medio de una red, trabajando como si fuesen una única máquina para resolver un problema complejo.
1. Introducción al procesamiento paralelo. El procesamiento paralelo es una forma de computo en la cual un número de actividades se realizan de manera concurrente de tal manera que el tiempo para resolver un problema se reduce. Anteriormente, el procesamiento paralelo se empleaba para resolver problemas que requerían una gran escala de simulación (por ejemplo, simulación molecular, simulación de una explo sión nuclear), un gran número de cálculos y procesamiento de datos (por ejemplo, el computo de los datos de un censo) etc. Como quiera que sea, el costo del hardwarea se ha ido decrementando rápidamente, por lo que el procesamiento en paralelo se esta empleando más y más en tareas comunes. Los servidores con multiples procesadores han existido desde hace ya mucho tiempo. El procesamiento paralelo también se emplea en tu propia PC. Por ejemplo, un procesador gráfico trabajo junto con el pro cesador principal para dibujar l os gráficos sobre tu monitor empleando procesamiento paralelo. A parte de las facilidades del hardware para llevar a cabo procesamiento paralelo, algo de soporte de software también es necesario para poder correr los programas en forma paralela y coordinar su ejecución. La coordinación es necesaria para resolver las dependencias de los programas paralelos puedan tener unos con otros. Esto quedará más claro cuando trabajemos en un ejemplo. El método más empleado para implementar esta coordinación es la transferencia de mensajes en la cual los programas coordinan su ejecución enviando mensajes al resto de los programas. Así, por ejemplo, un programa puede decirle a otro "Ok¡ Este es el resultado intermedio que necesita ser procesado". Si todo esto suena demasiado abstracto, permitanme con un muy sencillo ejemplo.
2. Un problema muy simple. En esta sección, vamos a considerar un proble muy sencillo y consideremos que podemos emplear procesamiento paralelo para incrementar la velocidad de su ejecución. El problema consiste en encontrar la suma de una lista de enteros almacenados en un arreglo. Supongamos que hay 100 enteros almacenados en un arreglo que se llama items. items. Ahora, ¿Como paralelizamos este programa? . Esto es, primero debemos encontrar una forma que el problema pueda ser resuelto por un número de programas trabajando de manera concurrente. En muchas ocasiones. la dependencia de los datots, convierten a la paralelización en un problema difícil. Por ejemplo, si deseamos evaluar (a + b)*c, lo cual involcra dos operaciones, no lo podemos realizar de manera paralela, ya que la suma debe realizarse antes de la multiplicación. Afortunadamente, para el problema seleccionado, la paralelización es sencilla Suponemos que 4 programas o procesadores trabajan simultaneamente para resolver la suma. La estrategia más simple sería dividir el arreglo items. items. 1. 2.
Cuatro programas llamados P0, P1, P2 y P3 van a resolver el problema. P0 encontrará la suma de los elementos del arreglo items[0] a items[24]. De manera similar, P1 sumará de items[25] a items[49], , P2 de items[50] a items[74] y P3 items[75] a items[99] . 3. Después de que estos programas se ejecuten, debe haber otro programa que sume los resultados de los cuatro y de el resultado final. De la misma manera, los elementos del arreglo no son conocidos por los programas P0 a P3, así que algún otro programa deberá indicarle a estos programas los valores de los elementos. Por lo tanto, además de P0 a P3, necesitamos un programa más que distribuya los datos, junte los resultados y coordine la ejecución. Nosostros llamamos a este programa maestro y a los programas P0 a P3 esclavos y a esta or ganización el paradigma el paradigma maestro-esclavo. Con esta organización en la mente, escibiremos los algorimos para los programas maestro y esclavo.
/* Algoritmo para el programa maestro */ inicialización del arreglo 'items'. /* enviamos los datos a los esclavos */ for i = 0 a 3 Enviar items[25*i] a items[25*(i+1)-1] a slave Pi end for /* juntamos los resultados de los esclavos */ for i = 0 a 3 Recibimos el resultado desde el esclavo Pi en result[i] end for /* cálculo del resultado final */ sum = 0 for i = 0 to 3 sum = sum + result[i] end for print sum
El algoritmo para el esclavo puede escribirse de la siguiente manera. /* Algoritmo para el programa esclavo */ Se reciben los 25 elementos desde el maestro en algún arreglo llamado 'items' /* se calcula el resultado intermedio */ sum = 0 for i = 0 to 24 sum = sum + items[i] end for se envia 'sum' como resultdao intermedio al maestro
3. Implementación con PVM Ahora que se tiene diseñado al algoritmo básico, debemos considerar como se implementa. ¿En que hardware podemos correr este programa? De acuerdo, muy pocos de nosotros podemos acceder a máquinas especiales diseñadas para correr programas paralelos. De cualquier forma, no se necesita ningún hardware especial para implementar este programa. Una simple computadora o un grupo de estas interconectadas servirá, gracias a PVM, un sistema de software que nos permite interconectar a varias computadoras para la ejecución de programas en paralelo. PVM acrónimo para Pallel Virtual Machine (Máquina Virtual Paralela) te permite crear un número de programas o procesos que corren de forma concurrente en la misma o en diferentes máquinas y provee funciones con las cuales es posible transmitir mensajes entre los procesos. En el caso de que tengas una única máquina, PVM trabajará de todas formas, aunque de acuerdo no se tratará de "procesamiento paralelo real". De cualquier forma, para propositos de aprendizaje, será más que suficiente. Mas tarde describiré como se lleva a cabo "procesamiento paralelo real"empleando PVM. Para poder usar el sistema PVM, necesitas instalar el software de PVM en tu sistema Linux. En el caso en que estes usando Red Hat Linux, el paquete RPM para PVM se incluye en el CD, así que lo puedes instalar como cualquier otro programa. Asumiendo que tu ya tienes instalado PVM en tu sistema, crea los siguientes directorios en tu directorio home: ~/pvm3/bin/LINUX/ . ¿Por qué? Porque PVM requiere que algunos de los ejecutables que se van a crear se copien a este directorio. Una vez que has hecho esto, estas listo para iniciar. Para probar el funcionamiento de PVM teclea el comando pvm sobre el prompt. Esto debe de iniciar la consola PVM desde la cual se pueden dar comandos para el sistema PVM y consultar el estado de este. Si todo esta bien, veras el prompt pvm>. Ahí teclea el comando conf. La salida debe ser algo similar a esto. pvm> conf conf 1 host, 1 data format HOST joshicomp
DTID 40000
ARCH LINUX
SPEED DSIG 1000 0x00408841
¿Que quiere decir esto? El sistema PVM permite que consideres un grupo de interconectados sistemas LINUX como una "computadora virtual" la cual posees mucho mayores capacidades de computo que las máquinas individuales. De esta manera, PVM va a distribuir los procesos a través de todas las computadoras. No obstante, por default, PVM considera que solamente el host en el que se esta trabajando se encuentra dentro de la máquina, es decir todos los procesos que se creen serán ejecutados en el mismo host. El comando conf muestra que hosts o nodos estan en el PVM. Actualmente, solo existe uno. Más adelante, veremos como agregar más. A continuación, sal de la consola PVM dando el comando halt.
3.1 Un programa de Demostración Ahora que estamos seguros que el sistema PVM está correctamente instalado, veremos como escribir los programas. Los programas para el sistema PVM pueden estar tanto en FORTRAN como en C. Nosotros emplearemos el lenguaje C. Para usar el sistema PVM, se incluyen algunas llamanda a funciones PVM en tu programa en C y se liga la libreria PVM con tus programas. Para introducirnos a PVM, escribiremos un simple programa en el cual hay un maestro y un esclavo. El maestro enviará una cadena al esclavo, a la cual el esclavo convertirá en mayúsculas y enviará de regreso al maestro. El maestro y el esclavo se muestran a continuación. Para compilar los programas, se teclea el comando make -f makefile.demo [Click aquí para obtener el archivo tar que contiene los programas que se listan.]
1 /* -------------------------------------------------------------------2 * master_pvm.c 3 * 4 * Este es el programa maestro para una simple demostración de PVM 5 * -------------------------------------------------------------------6 #include
* * * * */
7 #include 8 #include 9 #include 10 int main() 11 { 12 int mytid; /* nuesto ID de tarea */ 13 int slave_tid; /* el ID del esclavo */ 14 int result; 15 char message[] = "hello pvm"; 16 17 /* nos incluimos al sistema PVM y obtenemos nuestro ID */ 18 mytid = pvm_mytid(); 19 20 21
/* creamos al esclavo */ result = pvm_spawn("slave_pvm", (char**)0, PvmTaskDefault, "", 1, &slave_tid);
22 23 24 25
/* comprobamos que el esclavo se creo adecuadamente if(result != 1) { fprintf(stderr, "Error: Cannot spawn slave.\n");
*/
26 27 28 29
/* salimos del sistema PVM*/ pvm_exit(); exit(EXIT_FAILURE); }
30 31
/* se inicializa el buffer de datos para transmitir los datos al esclavo*/ pvm_initsend(PvmDataDefault);
32 33
/* se "empaqueta'' la cadena dentro del buffer*/ pvm_pkstr(message);
34 35
/* se envia la cadena al esclavo con una etiqueta de mensaje igual a 0 */ pvm_send(slave_tid, 0);
36 37
/* se espera y recibe el resultado del esclavo*/ pvm_recv(slave_tid, 0);
38 39 40
/* se "desempaca'' el resultado del esclavo pvm_upkstr(message);
41 42
/* se muestra el resultado del esclavo*/ printf("Data from the slave : %s\n", message);
*/
43 /* salimos del sistema PVM*/ 44 pvm_exit(); 45 46 exit(EXIT_SUCCESS); 47 } /* fin del main() */ 48 /* fin del master_pvm.c */ 1 2 3 4 5 6 7 8 9
/* -------------------------------------------------------------------* slave_pvm.c * * Este es el program esclavo para una simple demostración de PVM * -------------------------------------------------------------------#include #include #include #include
10 #define MSG_LEN 20 11 void convert_to_upper(char*); 12 int main() 13 { 14 int mytid; 15 int parent_tid; 16 char message[MSG_LEN]; 17 18
/* nos incluimos dentro del sistema PVM mytid = pvm_mytid();
19 20
/* se obtiene el ID del maestro*/ parent_tid = pvm_parent();
21 22 23
/* se recibe la cadena origina del maestro */ pvm_recv(parent_tid, 0); pvm_upkstr(message);
24 25
/* se convierte la cadena a mayúsculas*/ convert_to_upper(message);
26 27
/* se envia la cadena convertida al maestro pvm_initsend(PvmDataDefault);
*/
*/
* * * * */
28 29
pvm_pkstr(message); pvm_send(parent_tid, 0);
30 /* se sale del sistema PVM*/ 31 pvm_exit(); 32 33 exit(EXIT_SUCCESS); 34 } /* fin del main() */ 35 36 37 38 39 40 41 42 43
/* funcion para convertir una cadena dada a mayúsculas */ void convert_to_upper(char* str) { while(*str != '\0') { *str = toupper(*str); str++; } } /* end convert_to_upper() */
44 /* fin del slave_pvm.c */ 1 # Make file para el programa de demostración de PVM 2 3 4 5 6 7 8 9 10
.SILENT : # rutas para incluir archivos y librerias INCDIR=-I/usr/share/pvm3/include LIBDIR=-L/usr/share/pvm3/lib/LINUX # ligas a la libreria de PVM LIBS=-lpvm3 CFLAGS=-Wall CC=gcc TARGET=all
11 # este es el directorio donde se crearán los programas 12 PVM_HOME=$(HOME)/pvm3/bin/LINUX 13 all : $(PVM_HOME)/master_pvm $(PVM_HOME)/slave_pvm 14 $(PVM_HOME)/master_pvm : master_pvm.c 15 $(CC) -o $(PVM_HOME)/master_pvm master_pvm.c $(CFLAGS) $(LIBS) \ 16 $(INCDIR) $(LIBDIR) 17 $(PVM_HOME)/slave_pvm : slave_pvm.c 18 $(CC) -o $(PVM_HOME)/slave_pvm slave_pvm.c $(CFLAGS) $(LIBS) \ 19 $(INCDIR) $(LIBDIR)
Una vez que los programas han sido compilados, se deben copiar dentro del directorio ~/pvm3/bin/LINUX. (El makefile hace esto por default). Ahora correr los programas, para esto primero debes iniciar el sistema PVM. Para hacerlo da el comando pvm para entrar a la consola PVM. Ahora en el prompt pvm>, teclea quit. La salida deber ser como sigue: pvm> quit quit Console: exit handler called pvmd still running.
Nota la última linea, indicando que el demonio PVM (pvmd) esta corr iendo. Para correr los programas PVM, necesitas correr el demonio PVM el cual se encarga de manejar el intercambia de mensajes. Una vez que el demonio esta corriendo, tu puedes correr los programas de la siguiente manera:
[rahul@joshicomp rahul]$ cd ~/pvm3/bin/LINUX/ [rahul@joshicomp LINUX]$ ./master_pvm Data from the slave : HELLO PVM [rahul@joshicomp LINUX]$
Nota como la cadena esta en mayúsculas tal como esperabamos.
3.2 Explicación del programa En esta sección, veremos exactamente como este programa trabaja. Primero de todo para usar las funciones PVM, necesitas incluir el archivo dee cabecera pvm3.h en tus programas. Esto se hace en la línea 8 del master_pvm,c y en la línea 9 del slave_pvm.c También al compilar los programas , necesital ligarlos con la libreri a PVM. Esto se hace especificando la opción -lpvm3 al compil ador, como se hace en la línea 7 del makefile.demo. Además. se necesita especificar al compilador las rutas de los archivos cabecera y las librerias, como se hace en las líneas 4 y 5 del makefile.
En el programa maestro, primero se obtiene el task ID del maestro haciendo una llamada a la función pvm_mytid(). El sistema PVM asigna a cada proceso un identificador único un entero de 32 bits llamado task ID de la misma mandera como Linux asigna a cada proceso un identificador de proceso. De cualquier forma, el maestro no emplea este identificador ( almacenado en mytid). Nuestra intención era solo llamar a la función pvm_mytid(). Esta función enlista al proceso dentro del sistema PVM y genera un identificador único. Si no se enlista explicitamente al proceso, PVM automaticamente agrega a nuestro proceso en la primera llamada de cualquier función PVM. A continuación empleamos pvm_spawn() para crear al proceso esclavo. El primer parámetro de esta, "slave_pvm", es el nombre del ejecutable para el esclavo. El segunto son los argumentos que se desean pasar al esclavo (de manera similar al argv en C) Como no se quieren enviar argumentos, se establece este valor a 0. El tercer parámetro es una bandera con la cual podemos controlar como y donde PVM inicia el esclavo. Como solo tenemos una sola máquina, establecemos esta bandera a PvmTaskDefault, lo cual le indica a PVM que emplee el criterio por omisión para crear al esclavo. El cuarto parámetro es el nombre del host o arquitectura sobre el cual deseamso se corra el programa y en este caso se deja vacío. Solo se emplea cuando se usa una bandera diferente a PvmTaskDefault. El quinto parámetro establece el número de esclavos que se crearán y el sexto es un puntero a un arreglo en el cual se regresan los IDs de los esclavos. Esta función regresa el número de esclavos actualmente creados. Un mensaje en PVM consiste basicamente de dos partes, el dato y una etiqueta que identifica el tipo de mensaje. La etique nos ayuda a distinguir entre diferentes mensajes. Por ejemplo, en el ejemplo de la suma, la cual estamos tratando de implementar, suponemos que esperas que cada esclavo regrese al maestro u n entero el cual es la suma de los ele mentos. También es posible que algun esclavo encuentre un error y envie al maestro un entero el cual indica el tipo de error . ¿Como hace el maestro par distinguir cuando un entero recibido se trata de un resultado intermedio o de un código de error? En esto es donde las etiquetas entran en acción. Puedes asiganr al mensaje para el valor intermedio una etiqueta que diga MSG_RESULT la cual se puede #define en cualquier archivo de cabecera y una etiqueta que diga MSG_ERROT para los mensajes que indiquen error. El maestro observará las etiquetas de los mensajes y determinará a que tipo per tenecen. Para enviar un mensaje, primero se necesita "inicializar" el buffer. Esto se hace llamando a pvm_initsend(). El parámetro para esta función indica el esquema de "codificación" a emplear. Cuando intercambiamos datos entre máquinas de diferentes arquitecturas (entre una máquina Pentium y una estación de trabajo SPARC) se necesita codificar el dato a enviar y decodificar el dato que se recibe de esta manera el dato es confiable. El parámetro para pvm_initsend() indica el esquema de condificación a emplear. El valor PvmDataDefault indica un esquema de codificación en el cual posibilta que el dato pueda ser intercambiado entre arquitecturas heterogeneas. Una vez que el buffer ha sido inicializado, necesitamos colocar el dato dentro del buffer y codificarlo. En nuestro caso, el dato es una cadena, así que empleamos la función pvm_pkstr() para "empacarlo" es decir codificarlo y colocarlo dentro del buffer. Si se requiere enviar un entero, existe la función pvm_pkint(). De forma similar, hay funciónes para otros tipos de datos. Una vez que el dato es empacado, llamamos a pvm_send() para enviar el mensaje. El primer argumento es el ID del proceso al cual esta destinado el mensaje y el segundo es la etiqueta del mensaje. Como solo tenemos un tipo de mensaje, ponemos esta valor a 0. Una vez que el dato se envia al esclavo, el esclavo va a procesarlo y envia el resultado al maestro. Así que ahora llamamos pvm_recv() para recibir el datos del esclavo. De nuevo, el parámetro es le ID del proceso que estamos esperando el mensaje y la etiqueta del mensaje. Si el mensaje deseado aún no es enviado, esta función lo espera y no regresa. Por lo tanto, el maestro espera para que el esclavo procese el dato. Una vez que el mensaje llega, el dato se almacena en el buffer de recepción. Es necesario "desempacar" es decir decodificar para obtener el mensaje original. Esta decodificación se realiza mediante pvm_upkstr(). Por último desplegamos la cadena. Antes que el programa termine, se debe indicar al sistema PVM que se deja este de esta manera los recursos ocupados por el proceso son liberados. Esto se realiza llamando a la función pvm_exit(). Después, el programa termina. El programa esclavo es sencillo de comprender. Primero encontramos el ID del master (el cual es también su padre ya que el maestro creo al esclavo) llamando a la función pvm_parent(). Después recibe la cadena del maestro, la convierte a mayúscula y envia el resultado al maestro.
3.3 El programa de la suma Ahora que conocemos las cuestiones básicas de PVM, implementaremos el algoritom de la suma que desarrollamos empleando PVM, Hay un maestro y 4 esclavos. El maestro crea primero a los 4 esclavos y envia a cada uno de ellos su parte de los datos. El esclavo suma los datos y envia el resultado al maestro. Por lo que, se tienen dos tipos de mensajes, uno cuando el maestro envia un dato a los esclavos, para el cual emplearemos la etiqueta MSG_DATA y otro cuando el esclavo envia el resultado al maestro, para el cual usaremos la etiqueta MSG_RESULT. El resto es simple. Los programas maestro y esclavo se listan a continuación.
1 /* -------------------------------------------------------------------2 * common.h 3 * 4 * Esta cabecera define algunas constantes comunes. 5 * --------------------------------------------------------------------
* * * * */
6 #ifndef COMMON_H 7 #define COMMON_H 8 #define NUM_SLAVES 9 #define SIZE 10 #define DATA_SIZE
4 100 (SIZE/NUM_SLAVES)
/* número de esclavos */ /* tamaño total del dato */ /* tamaño para cada esclavo */
11 #endif 12 /* end common.h */ 1 /* -------------------------------------------------------------------2 * tags.h 3 * 4 * Esta cabecera define las etiquetas empleadas por los mensajes. 5 * -------------------------------------------------------------------6 #ifndef TAGS_H 7 #define TAGS_H 8 #define MSG_DATA 9 #define MSG_RESULT
101 102
* * * * */
/* datos del maestro al esclavo*/ /* resultado del esclavo al maestro*/
10 #endif 11 /* end tags.h */ 1 /* -------------------------------------------------------------------2 * master_add.c 3 * 4 * Programa maestro para implementar la suma de los elementos de un * arreglo usando PVM 5 * -------------------------------------------------------------------6 #include 7 #include 8 #include /* PVM constantes y declaraciones */ 9 #include "tags.h" /* etiquetas para los mensajes 10 #include "common.h" /* constantes comunes */
* * * * * */
*/
11 int get_slave_no(int*, int); 12 int main() 13 { 14 int mytid; 15 int slaves[NUM_SLAVES]; /* arreglo para almacenar los task IDs de los esclavos */ 16 int items[SIZE]; /* datos a ser procesados */ 17 int result, i, sum; 18 int results[NUM_SLAVES]; /* resultados de los esclavos */ 19 20
/* nos enlistamos en el sistema PVM mytid = pvm_mytid();
*/
21 22 23
/* inizilizacion del arreglo 'items' */ for(i = 0; i < SIZE; i++) items[i] = i;
24 25 26
/* se crean los esclavos */ result = pvm_spawn("slave_add", (char**)0, PvmTaskDefault, "", NUM_SLAVES, slaves);
27 28 29 30 31 32 33
/* se comprueba que los esclavos creados sean suficientes if(result != NUM_SLAVES) { fprintf(stderr, "Error: Cannot spawn slaves.\n"); pvm_exit(); exit(EXIT_FAILURE); }
34 35 36 37 38 39 40
/* se distribuyen los datos a los esclavos */ for(i = 0; i < NUM_SLAVES; i++) { pvm_initsend(PvmDataDefault); pvm_pkint(items + i*DATA_SIZE, DATA_SIZE, 1); pvm_send(slaves[i], MSG_DATA); }
41 42 43 44 45 46 47 48
/* se recibe el dato de los esclavos for(i = 0; i < NUM_SLAVES; i++) { int bufid, bytes, type, source; int slave_no;
*/
*/
/* se recibe el mensaje de cualquiera de los esclavos bufid = pvm_recv(-1, MSG_RESULT);
49 50 51 52 53
/* se obtiene información del buffer*/ pvm_bufinfo(bufid, &bytes, &type, &source);
54
/* se desempaca la información del esclavo*/
/* se obtiene el número del esclavo que envio el mensaje*/ slave_no = get_slave_no(slaves, source);
*/
55 56
}
57 58 59 60
/* se obtiene el resultado final */ sum = 0; for(i = 0; i < NUM_SLAVES; i++) sum += results[i];
61
printf("The sum is %d\n", sum);
62 63
/* se sale del sistema pvm_exit();
64 65 66 67 68 69 70 71 72 73
pvm_upkint(results + slave_no, 1, 1);
PVM
*/
exit(EXIT_SUCCESS); } /* end main() */ /* función que regresa el numero del esclavo dado su task ID */ int get_slave_no(int* slaves, int task_id) { int i; for(i = 0; i < NUM_SLAVES; i++) if(slaves[i] == task_id) return i;
74 return -1; 75 } /* end get_slave_no() */ 76 /* end master_add.c */
1 /* -------------------------------------------------------------------2 * slave_add.c 3 * 4 * Programa esclavo para realizar la suma de los elementos de un * arreglo usando PVM 5 * -------------------------------------------------------------------6 #include 7 #include 8 #include "tags.h" 9 #include "common.h" 10 int main() 11 { 12 int mytid, parent_tid; 13 int items[DATA_SIZE]; /* datos para enviar al maestro*/ 14 int sum, i; 15 16 /* nos enlistamos dentro del sistema PVM */ 17 mytid = pvm_mytid(); 18 19
/* se obtiene el identificador del maestro */ parent_tid = pvm_parent();
20 21 22
/* se reciben los datos del maestro */ pvm_recv(parent_tid, MSG_DATA); pvm_upkint(items, DATA_SIZE, 1);
23 24 25 26
/* se encuetra la suma de los elementos*/ sum = 0; for(i = 0; i < DATA_SIZE; i++) sum = sum + items[i];
27 28 29 30
/* se envia el resultado al maestro */ pvm_initsend(PvmDataDefault); pvm_pkint(&sum, 1, 1); pvm_send(parent_tid, MSG_RESULT);
31 /* se sale del PVM*/ 32 pvm_exit(); 33 34 exit(EXIT_SUCCESS); 35 } /* end main() */
1 # Make file para el programa suma del PVM - makefile.add 2 3 4 5 6 7 8 9 10
.SILENT : # rutas para los archivos include y librerias del PVM INCDIR=-I/usr/share/pvm3/include LIBDIR=-L/usr/share/pvm3/lib/LINUX # liga a la libreria PVM LIBS=-lpvm3 CFLAGS=-Wall CC=gcc TARGET=all
11 # el directorio donde se colocaran los ejecutables
* * * * * */
12 PVM_HOME=$(HOME)/pvm3/bin/LINUX 13 all : $(PVM_HOME)/master_add $(PVM_HOME)/slave_add 14 $(PVM_HOME)/master_add : master_add.c common.h tags.h 15 $(CC) -o $(PVM_HOME)/master_add master_add.c $(CFLAGS) $(LIBS) \ 16 $(INCDIR) $(LIBDIR) 17 18 $(PVM_HOME)/slave_add : slave_add.c common.h tags.h 19 $(CC) -o $(PVM_HOME)/slave_add slave_add.c $(CFLAGS) $(LIBS) \ 20 $(INCDIR) $(LIBDIR)
En primer termino analizarermos al programa esclavo, por ser el más sencillo. El esclavo recive los 25 elementos del arreglo del maestro en el arreglo items, obtiene su suma y envia el resultado al maestro con la etiqueta del mensaje MSG_RESULT. Ahora analizemos al maestro. Definimos un arreglo slaves de tamaño igual a NUM_SLAVES el cual contiene los task ID's de los esclavos creados. Existe otro arreglo results en el cual se almacenan los resultados de los esclavos. El maestro primero inicializa el arreglo items y después crea a los esclavos. Después distribuye los datos a los esclavos. En la llamada a la función pvm_pkint() en la línea 38, el primer parámetro es un puntero al arreglo en el cual los datos se almacenan, el segundo es el número de enteros a empacar y el tercero es el "stride". Stride significa cuantos elementos se saltan cuando se empaca. Cuando es 1, los elementos consecutivos son empacados. Cuando es 2, PVM va saltarse a los elementos 2 dando un paquete con los elementos pares (0,2,,4...). De ahí que empleemos el 1. Una vez que los datos han sido distribuidos a los esclavos. el maestro espera que los esclavos regresen el valor del resultado intermedio. Una posibilidad para obtener los resultados es que el maestro obtenga primero el resultado del esclavo 0 (es decir del esclavo cuyo ID esta almacenado en slave[0]), después del esclavo 1 y así sucesivamente. De cualquier forma esta no es una manera óptima. Por ejemplo, puede darse el caso que el esclavo 0 trabaje mas lentamende que la máquina con el esclavo 1, 2 y 3. En este caso, donde el maestro espera el resultado del esclavo 0, los resultados de los esclavos 1, 2 y 3 termina de juntar los datos y realiza las operaciones, esta solución podría ser valida, pero si se considera la situación donde un esclavo, cuando termina una tarea se le asigna otra, deseariamos que se le diera la tarea inmediatamente después que ha terminado la anterior. Por lo que el maestro debe ser capaz de responder a un mensaje de cualquiera de los esclavos. Esto es lo que se hizo. En la llamada a pvm_recv() en la línea 48, sabemos que el primer parámetro es el task ID de la fuente del mensaje. Si este valor es -1, significa una terjeta salvaje es decir los mensajes de cualquier proceso con la etiqueta de mensaje igual a MSG_RESULT van a ser recibidos por el maestro. El mensaje recibido junto con información de control se almacena en un buffer llamado active receive buffer . La llamada regresa un ID único para este bufffer. Ahora, necesitamos conocer quien envió el mensaje para poder almacenar el resultado en el apropiado elemento del arreglor results. La función pvm_bufinfo() regresa información acerca del mensaje en el buffer, como la etiqueta del mensaje, el número de bits y el task ID de quien lo envió. Una vez que se tiene el ID del remitente, se almacena el resultado enviado en su correcto elemento dentro del arreglo results. El resto del programa debe ser fácil de comprender.
Introducción En PVM todas las tareas están identificadas por un número entrero proveido por el pvmd local. En las descripciones futuras éste identificador de tareas será llamado TID. Es similar al identificador de procesos (PID) usado en el sistemaoperativo UNIX y asume ser opaco para el usuario, es decir, el valor del TID no tiene significadopara él. De hecho, PVM codifica información en el TID p ara su uso interno un icamente. Todas las rutimas de PVM estan escritas en C. Aplicaciones de Fortran pueden llamara éstas rutinas a través de una interface de fortran 77 proveida por PVM.Esta interface traduce argumentos en la cual son pasados por referencia en fortran a sus valores sies necesario por las rutinas de C. El modelo de comunicación de PVM asume que cualquier tarea puede enviar un mensaje a cualquier otra tarea en PVM y que no hay limite a su tamaño o número de tales mensajes. Mientras que todo s los anfitriones (hosts) tienen limitaciones de memoriafísica que limita espacio potencial de buffer, el modelo de comunicación no se restringe a las limitaciones de una máquina en particular y asume que hay suficiente memoria disponible. El modelo de comunicación PVM provee funciones de envio asíncrono d e bloques, recibo asíncrono de bloques, recibo de particionado en bloques. Ennuestra terminología, envio de bloque regresa en cuanto el buffer de envio se encuentra libre para ser reusado, envio asíncronico no depende de un llamado del recibo a una pareja recibo antes de pod er el envio regresar. Un recibo no particionado inmediatamente regresa ya sea con datos o una bandera indicando que los datos aun no han llegado, mientras que un recibo particionado regresa únicamente cuando los datos se encuentran en el buffer de recibo. El modelo de PVM garantiza que el orden de los mensajes es preservado. Si la tarea 1 envía un mensaje A a la tarea 2, d espués la tarea 1 envía el mensaje B a la tarea 2, el mensaje A llegará a la tarea 2 antes que el mensaje B. Los buffer de mensajes son asignados d inámicamente. El tamaño máximo del mensaje que se puede enviar o recibir es limitado únicamente por la cantidad de memoria disponible de un anfitrión dado.
1 Control de Proceso int tid = pvm_mytid( void ) La rutina pvm_mytid() regresa el TID de este proceso y puede ser llamado varias veces. Prepara éste proceso en PVM si ésta es la primer llamada de PVM. int info = pvm_exit( void ) La rutina pvm_exit() le dice al pvmd local que éste proceso se retira de PVM. Esta rutina no mata el proceso, la cual puede seguir en ejecutando tareas al igual que cualquier proceso en UNIX. int numt = pvm_spawn( char *task, char **argv, int flag, char *where, int ntask, int *tids ) La rutina pvm_spawn() empieza ntask copias de un archivo de tareas ejecutables en la máquina virtual. argv es un apuntador a un arreglo de argumentos a procesar con el final del arreglo especificado con NULL. Si task no tiene argumentos, entonces argv es NULL. El argumento flag es usado para especificar opciones: Valor Opción
Descripción
0 1 2 4 8 16 32
PVM elige en donde reproducir procesos. el argumento where es un anfitrión en particular a reproducir la tarea el argumento where es un PVM_ARCH a reproducirse inicializa tareas bajo un depurador seguimiento de datos es generado inicializa tareas en MPP front-end complemento de anfitrión definido en where
PvmTaskDefault PvmTaskHost PvmTaskArch PvmTaskDebug PvmTaskTrace PvmMppFront PvmHostCompl
De regreso, numt es un conjunto de tareas que lograron reproducirse o un código d e error si nunguna tarea se pudo ejecutar. Si tareas fueron comenzadas, entonces pvm_spawn() regresa un vector de los tid's de las tareas reproducidas; y si algunas tareas no pudieron ser ejecutadas, los códigos de error correspondiente son puestos en los ultimos ntask - numt posiciones del vector. int info = pvm_kill( int tid ) La rutina pvm_kill() mata alguna otra tarea PVM identificada por el TID. Esta rutina no está diseñada para matar a la tarea llamada, en la cual deberá ser acompañada llamando a pvm_exit() seguido de exit(). int info = pvm_catchout( FILE *ff ) Por omisión PVM escribe el stderr y stdout de las tareas reproducidas al archivo /tmp/pvml.. La rutina pvm_catchout causa a la tarea llamada pescar la salida de tareas posteriormente reproducidas. Caracteres impresos en stdout o en stderr en tareas hijas son colectadas por los pvmds y enviados en mensajes de control a la tarea padre, en la cual va a marcar cada línea y agregarla al archivo especi ficado (en C) o a la salida estándar (en Fortran).
2 Información int info = pvm_parent( void ) La rutina pvm_parent() regresa el TID del proceso que reprodujo esta tarea o el valor de PvmNoParent si no fue creado por pvm_spawn(). int info = pvm_tidtohost( int tid ) La rutina pvm_tidtohost() regresa el TID dtid del demonio corriendo en el mismo anfitrión que TID. Esta rutina es útil para determinar en que anfitrión está ejecutandose cierta tarea. int info = pvm_config( int *nhosts, int *narch, struct pvmhostinfo **hostp ) La rutina pvm_config() regresa información acerca de la máquina virtual incluyendo el número de anfitriones, nhost , el número de los distintos formatos de datos, narch. hostp es un apuntador a un arreglo declarado por el usuario de estructuras pvmhostinfo. El arreglo debe ser por lo menos d e tamaño nhost . De regreso, cada estructura pvmhostinfo contiene el TID pvmd , nombre del anfitrión, nombre de la arquitectura, velocidad relatica de CPU para ese anfitrión en la configuración.
int info = pvm_tasks( int which, int *ntask, struct pvmtaskinfo **taskp ) La rutina pvm_tasks() regresa información acerca de las tareas PVM corriendo en la máquina virtual. El entero which especifica acerca de cual de las tareas regresar infor mación. El número de tareas es regresado en ntask. taskp es un apuntador a un arreglo de estructuras pvmtaskinfo. El arreglo es de tamaño ntask . Cada estructura pvmtaskinfo contiene el TID, pvmd TID, TID padre, bandera de status, y el n ombre del archivo reproducido.
3 Configuración Dinámica int info = pvm_addhosts( char **hosts, int nhost, int *infos ) int info = pvm_delhosts( char **hosts, int nhost, int *infos ) Las rutinas de C agregan o bo rran un conjunto de anfitriones de la máquina virtual. En fortran agregan o borran un solo anfit rión en la máquina virtual. En la versión de C info es devuelto como el valor de anfitriones agregados exitosamente. El argumento <>infos es un arreglo de longitud nhost que contiene el códico de estado para cada anfitrión idividual siendo agregado o borrado. Esto permite al usuario revisar ya sea si únicamente un anfitrióm dentro de un conjunto causó un problema en vez de intentar de nuevo agregar o borrar el conjunto entero de anfitriones. Estas rutinas son usadas algunas veces para configurar la máquina virtual, pero es más común que sean usadas para incrementar la flexibilidad y la tolerancia de fallas de una aplicación grande. Estas rutinas permiten a la aplicación incrementar la potencia de cómputo (agregando anfitriones) si determina que el problema se está poniendo más complejo para resolverse.
4 Señalamiento int info = pvm_sendsig( int tid, int signum ) int info = pvm_notify( int what, int msgtag, int cnt, int tids ) La rutina pvm_sendsig() envía una señal signum a otra tarea de PVM identificada por el TID. La rutina pvm_notify() solicita a PVM a notificar a quien hace la llamada la detección de ciertos eventos. Las opciones p resentes son las siguientes:
PvmTaskExit : notifica si una tarea se retira. PvmHostDelete: notifica si un anfitrión es borrado (o no responde). PvmHostAdd : notifica si un anfitrión es agregado.
En respuesta a una solicitud de notificación, cierto número de mensajes son enviados de vuelta por PVM a la tarea que hace la llamda.
Definiendo y obteniendo opciones int oldval = pmv_setopt( int what, int val ) int val = pvm_getopt( what, val ) La rutina pmv_setopt() es una función de proposito general que permite al usuario definir u obtener opciones en el sistema PVM. pmv_setopt() puede ser usada para definir varias opciones, incluyendo impresión automática de mensajes de error, nivel de depuración, y el método de enrutamiento de comunicación para todas las llamadas posteriores de PVM. pmv_setopt() regresa el valor previo del conjunto en oldval. what puede tener los siguientes valores: Opción
Valor Descripción
PvmRoute PVMDebugMask PvmAutoErr PvmOutputTid PvmOutputCode PvmTraceTid PvmTraceCode PvmFragSize PvmResvTids PvmSelfOutputTid PvmSelfOutputCode PvmSelfTraceTid PvmSelfTraceCode
1 2 3 4 5 6 7 8 9 10 11 12 13
póliza de enrutamiento enmascaramiento del depurador reporte de error automático destino stdout para los hijos salida de msgtag seguimiento de destino para los hijos seguimiento de msgtag tamaño del fragmento del mensaje permitir que los mensajes reserven etiquetas y tids destino stdout para si mismo salida de msgtag seguimiento de destino para si mismo seguimiento de msgtag
El uso más popular de pmv_setopt es de activar una ruta de comunicación directa entre tareas de PVM. Como una regla general, el ancho de banda de comunicación de PVM sobre un a red se dobla haciendo la llamada pmv_setopt( PvmRoute, PvmRouteDirect ); la desventaja es que éste método rápido de comunicación no es escalable bajo UNIX; por con siguiente, puede que no funcione si la aplicación involucra más de 60 tareas que se comunican aleatoriamente entre si. Si no funciona, PVM automáticamente hace el cambio de vuelta al método de comunicación por omisión. Puede ser llamado multiples veces durante la aplicación para definir selectivamente las ligas de comunicación directa entre tareas, pero comunmente se llama una sola vez después de la llamada inicial a pmv_mytid().
5 Envio de mensajes Enviando mensajes en PVM esta compuesto por tres pasos. Primero, un buffer de envío debe ser inicializado con una llamada a pvm_initsend() o pvm_mkbuf(). Segundo, el mensaje debe de ser encapsulado a éste buffer cualquier número de veces y en combinaciones de las rutinas pvm_pk*(). Tercero, el mensaje completo es enviado a otro proceso llamando a la rutina pvm_send() o repartición multiple con la rutina pvm_mcast(). Un mensaje es recibido ya sea llamando a una rutina de recibo de bloques partiocionados o no particionados y después expander cada unos de los paquetes del buffer de recibo. Las ru tinas de recibo pueden estar puestas para recibir cualquier tipo de mensajes, o cualquier mensaje de una fuente específica, o cualquier mensaje con una marca de mensaje especificada, o únicamente mensajes con una cierta marca de mensaje dado de una fuente dada.
Buffers de mensajes inf bufid = pvminitsend( int encoding ) Si el usuario está usndo únicamente un solo buffer (este es el caso típico) entonces pvm_initsend() es la único rutina para el buffer que se requiere. Es llamada antes de encapsular un mensaje nuevo en un buffer. La rutina pvm_initsend limpia el buffer de envío y crea uno nuevo para encapsular el mensaje nuevo. El esquema de codificación usado para la encapsulación es definido por encoding . El identificador del buffer nuevo es devuelto en bufid . Las opciones de codificación son las siguientes:
PvmDataDefault : codificación XDR es empleada por omisión porque PVM no puede determinar si el usuario va a agregar una máquina hetereogena antes de que el mensaje sea enviado. Si el usuario sabe que el siguiente mensaje va a ser enviado solo a una máquina que conoce el formato nativo, entonces se puede usar la codificacióm PvmDataRaw y ahorrarse costos de codificación. PvmDataRaw: no se hace codificación alguna. Mensajes son enviados en su formato original. Si el pro ceso de recibo no p uede leer este formato, regresará un error durante la expanción. PvmDataInPlace: El buffer contiene solo tamaño y apuntadores de los mensajes que se van a enviar. Cuando pvm_send() es llamado, los mensajes son leidos directamente de la memoria del usuario.
Las rutinas de mensajes de buffer siguientes son requeridas solo si el usuario desea manejar multiples buffers de mensaje dentro de la aplicación. Por lo general, multiples buffers de mensajes no son necesarios para el envío de mensajes entre pro cesos. Solo hay un buffer de envío activo y uno buffer de recibo activo por proceso en cualquier tiempo dado. El desorrallador puede crear varios buffer d e mensajes y cambiarse de uno a otro para la encapsulación y envio de datos. Las rutinas encapsulación, envio, recibo, y expanción solo afectan a los buffers activos. int bufid = pvm_mkbuf( int encoding ) La rutina pvm_mkbuf crea un nuevo buffer de envio vacío y especifica el m&eaute;todo de codificación usado para la capsulación de mensajes. Regresa un identificador de buffer bufid . int info = pvm_freebuf( int bufid ) La rutina pvm_freebuf() desecha el buffer con el identificador bufid . Este debe de hacerse después de que un mensaje ha sido enviado y que ya no se ocupará. Llama a pvm_mkbuf() para crear un buffer para un mensaje nuevo si lo requiere. Ninguna de estas llamadas son necesarias cuando se hace la llamada a pvm_initsend(), la cual ejecuta estas llamadas para el usuario. int bufid = pvm_getsbuf( void ) int bufid = pvm_getrbuf( void ) pvm_getsbuf() regresa el identificador del buffer de envio activo. pvm_getrbuf() regresa el identificador del buffer de recibo activo. int oldbuf = pvm_setsbuf( int bufid ) inf oldbuf = pvm_setrbuf( int bufid ) Estas rutinas definen el buffer de envio(o recibo) activo en bufid , guardar el estado del buffer anterior, y regresar el identificador del buffer activo previo oldbuf . Si bufid es puesto a 0 en pvm_setsbuf() o pvm_setrbuf(), entonces el presente buffer es guardado y sin buffer activo. Esta característica puede ser utilizada para guardar el presente estado de los mensajes de la aplicación para que las librerías de matemáticas o gráficos que también envian mensajes no interfieran con el estado de los buffers de la aplicación. Es posible el envio de mensajes sin tener que volver a encapsularlos usando las rutinas de buffer de mensajes. Esto se ilustra en el siguiente fragmento. bufid = pvm_recv( src, tag ); oldid = pvm_setsbuf( bufid );
Encapsulamiento de datos Cada una de las siguientes rutinas en C encapsulan un arreglo del tipo de datos dado en un buffer de envio activo. Pueden ser llamadas varias veces para encapsular datos en un solo mensaje. No hay limite en la complejidad de los mensajes encapsulados, pero una aplicación debe de expander los mensajes exactamente como fueron encapsulados. Los argumentos para cada una de las rutinas es un apuntador al primer dato a ser encapsulado, nitem es el número total de datos a encapsular dentro del arreglo, y STRIDE es el STRIDE a usar en la encapsulación. Un STRIDE de 1 significa que un vector contiguo es
encapsulado, un STRIDE de 2 significa todos los d emás datos son encapsulados, y así sucesivamente. Una escepción es pvm_pkstr() que por definición encapsula una cadena con una caracter terminador NULL y no requiere del parámetro nitem o stride. int info = pvm_pkbyte( char *cp, int nitem, int stride ) int info = pvm_pkcplx( float *xp, int nitem, int stride ) int info = pvm_pkdcplx( double *zp, int nitem, int stride ) int info = pvm_pkdouble( double *dp, int nitem, int stride ) int info = pvm_pkfloat( float *fp, int nitem, int stride ) int info = pvm_pkint( int *np, int nitem, int stride ) int info = pvm_pkilong( long *np, int nitem, int stride ) int info = pvm_pkshort( short *np, int nitem, int stride ) int info = pvm_pk( char *cp ) Todas las variables son pasadas como direcciones is count y stride son especificadas; del caso contrario, a las variables se asume que son valores.
Envio y recibo de datos int info = pvm_send( int tid, int msgtag ) int info = pvm_mcast( int *tids, int ntas k, int msgtag ) La rutina pvm_send() etiqueta el mensaje con un identificador entero msgtag y lo envía al proceso identificado por TID. La rutina pvm_mcast() etiqueta el mensaje con un identificador entero msgtag y transmite el mensaje a todas las tareas especificadas en el arreglo de tids (excepto asi mismo). El arreglo de los tids es de tamañontask . int info = pvm_psend( int tid, int msgtag, void *vp, int cnt, int type) La rutina pvm_psend() encapsula y envía un arreglo de tipo d e datos especificado a la tarea identificada por TID. Los tipos de datos definidos pueden ser cualquiera de los siguientes: PVM_STR PVM_BYTE PVM_SHORT PVM_INT PVM_LONG PVM_USHORT
PVM_FORMAT PVM_CPLX PVM_DOUBLE PVM_DCPLX PVM_UINT PVM_ULONG
int bufid = pvm_recv( int tid, int msgtag ) Esta rutina de recibo de bloques va a esperar hasta que un mensaje con la etiqueta msgtag ha llegado de TID. Un valor de -1 en msgtag o el TID se empareja con cualquier cosa. Entonces pone el mesaje en un nu evo buffer de recibo que es creado. El buffer de recibo previo es vaciado al menos que haya sido guardado con una llamada a pvm_setrbuf(). int bufid = pvm_nrecv( int tid, int msgtag ) Si el mensaje solicitado aún no ha llegado, entonces el recibo sin particiones pvm_nrecv() regresa bufid = 0. Esta rutina puede ser llamada varias veces para el mismo mensaje para verificar si ha llegado o no, mientras ejecuta trabajo útil entre llamadas. Si un mensaje con la etiqueta msgtag ha llegado de TID, pvm_nrecv() coloca el mensaje en un nuevo buffer de recibo activo(el cual crea) y regresa el identificador del buffer. El buffer de recibo activo previo es vaciado al menos de que haya sido guardado con la llamada a pvm_setrbuf(). int bufid = pvm_probe( int tid, int msgtag ) Si el mensaje solicitado aún no ha llegado, entonces pvm_probe() regresa bufid = 0. Del caso contrario, regresa un bufid para ese mensaje, pero no lo recibe. Esta rutina puede ser llamada varias veces para el mismo mensaje para verificar si ha llegado o no, mientras ejecuta trabajo útil entre llamadas. En adición, pvm_bufinfo() puede ser llamada con el bufid devuelto para determinar información acerca del mensaje antes de recibirlo. int bufid = pvm_trecv( int tid, int msgtag, struct timeval *tmout ) Ademas PVM suministra una versión de recibo con expiración de tiempo. Considere el caso donde un mensaje nunca llegará a su destino(debido a un error o falla); la rutina pvm_recv se bloquearia para siempre. Para evitar tales situaciones, el usuario puede retirarse después de un lapso de tiempo fijo. La rutina pvm_trecv() permite al usuario especificar el tiempo de espera. Si el tiempo de espera es puesto bien largo, entonces pvm_trecv actua como pvm_recv. Si el tiempo es puesto a 0, entonces pvm_trecv actua como pvm_nrecv. int info = pvm_bufinfo( int budid, int * bytes, int *msgtag, int *tid ) La rutina pvm_bufinfo() regresa msgtag , TID fuente, y la longitud en bytes del mensaje indentificado por bufid . Puede ser usada para determinar la etiqueta y fuente de un mensaje que fue recibido con comodines(wildcards) especificados. int info = pvm_precv( int tid, int msgtag, void *vp, int cnt, int type, int *rtid, int *rtag, int *rcnt ) La rutina pvm_precv() combina las funciones de un recibo de bloques y expande el buffer de recibo. No regresa un bufid . En su lugar, regresa los valores actuales de TID, msgtag, y cnt . int (*old)() = pvm_recvf( int ( *new )( int buf, int tid, int tag ) ) La rutina pvm_recvf() modifica el contexto de recibo causado por las funciones de recibo y p uede ser empleado para extender PVM. Regresar
Expanción de datos
Las siguientes rutinas en C expanden tipos de datos del bu ffer de recibo activo. En una aplicación deben de corresponder a las rutinas equivalentes de encapsulación en tipo, número de bloques, y progreso. nitem es un número de elementos del tipo d ado a expander, y stride es el progreso. int info = pvm_upkbyte( char *cp, int nitem, int stride ) int info = pvm_upkcplx( float *xp, int nitem, int stride ) int info = pvm_upkdcplx( double *zp, int nitem, int stride ) int info = pvm_upkdouble( double *dp, int nitem, int stride ) int info = pvm_upkfloat( float *fp, int nitem, int stride ) int info = pvm_upkint( int *np, int nitem, int stride ) int info = pvm_upklong( long *np, int nitem, int stride ) int info = pvm_upkshort( short *np, int nitem, int stride ) int info = pvm_upkstr( char *cp ) int info = pvm_unpackf( const char *fmt, ... ) La rutina pvm_unpackf() usa un tipo de formato similar de expresión p rintf para especificar que datos expander y como expander los datos del buffer de recibo.
6 Grupos de procesos dinámicos Las funciones del grupo de procesos dinámicos están construidas en el núcleo de las rutinas de PVM. Una librería separada libgpvm3.a debe de ser encadenada a los programas de los usuarios para hacer uso de cualquiera de las funciones del grupo. El pvmd no ejecuta las funciones del grupo. Esta tarea es manejada por el grupo servidor que es automáticamente empezada cuando el primer grupo d e funciones es invocada. Siguiendo la filosofía de PVM, las funciones de grupo fueron diseñadas para ser muy generales y transparentes al usuario. Cualquier tarea de PVM puede unirse o retirarse de cualquier grupo en cualquier instante sin tener que informarle a las demás tareas en los gru pos afectados. Las tareas pueden transmitir mensajes a grupos en la cual no pertenecen. En general, cualquier tarea de PVM puede hacer un llamado a cualquiera de las funciones del grupo en cualquier instante dado. Las escepciones son pvm_lvgroup(), pvm_barrier(), y pvm_reduce(), que por su naturaleza requieren que la tarea que llama sea miembro de un grupo especificado. int inum = pvm_joingroup( char *group ) int info = pvm_lvgroup( char *group ) Estas rutinas permiten que una tarea se una o deje u n grupo de usuarios. La primer llamada a pvm_joingroup() crea un grupo con el nombre del grupo y coloca a la tarea q ue llama en este grupo. pvm_joingroup()regresa la instancia del número(inum) del proceso de este grupo. Instancias de número tienen un rango de 0 hasta el número de miembros en el grupo menos 1 . Una tarea puede unirse a multiples grupos. Si un proceso se retira de u n grupo y después regresa, el pro ceso puede recibir una instancia de número diferente. Las instancia de números son ciclados para que una tarea que se un e al grupo reciba la instancia de número más bajo disponible. int tid = pvm_gettid( char *group, int inum ) int inum = pvm_getinst( char *group, int tid ) int size = pvm_gsize( char *group ) La rutina pvm_gettid() regresa el TID de un proceso d ado nombre de un grupo y la instancia de número. pvm_gettid() permite que dos tareas sin conocimiento de la otra obtenga el TID de la otra con el simple hecho de unirse al grupo. La rutina pvm_getinst() regresa la instancia de número dado el nombre del grupo y el TID. La rutina pvm_gsize() regresa el número de miembros en el grupo especificado. int info = pvm_barrier( char *group, int count ) En la llamada a pvm_barrier() el proceso se bloquea hasta count miembros del grupo hayan llamado pvm_barrier(). En general count deberá de ser el total de miembros en el grupo. Una cuenta es necesaria ya que en grup os de procesos dinámicos PVM no puede determinar cuantos miembros pertenecen al grupo en un instante dado. int info = pvm_bcast( char *group, int msgtag ) pvm_bcast() etiqueta el mensaje con un identificador entero msgtag y transmite el mensaje a todas las tareas en el grupo especifico excepto a si misma (si es que es d el mismo grupo). Para pvm_bcast() "all tasks" es definido ser todas aquellas tareas que el grupo servidor cree que están dentro del grupo cuando la rutina es llamada. Si una tarea se une al grupo mientras una transmisión, puede que no reciba el mensaje. Si una tarea se retira del grupo mientras una transmisión se lleva a cabo, una copia d el mensaje va a ser enviada a la tarea. int info = pvm_reduce( void (*func)(), void *data, int nite m, int datatype, int msgtag, char *group, int root ) pvm_reduce() realiza operaciones globales aritméticas en el grupo, por ejemplo, global sum o global max. El resultado de la operación de reducción aparece en root. PVM provee cuatro funciones predefinidas que el usuario pueda colocar en func. Estas son:
PvmMax PvmMin PvmProduct
