PVMTB (Parallel Virtual Machine Toolbox)

PVTB (Parallel Virtual achine Toolbox) Javier Fernández Baldomero Departamento de Arquitectura y Tecnología de Computadores Universidad de Granada, 18071-GRANADA e-mail: jfernand@ugr.es Resumen Los nuevos tipos de datos a partir de ATLAB 5.0 son muy apropiados para realizar una interfaz EX elegante entre ATLAB y el entorno PV (v3.4-beta7). Esta Toolbox, PVTB, puede ser utilizada como herramienta docente para explicar PV de forma interactiva, ahorrando al estudiante el esfuerzo de editar, compilar y ejecutar separadamente programas con el objetivo de ejercitar cada llamada de la librería. También sirve de base para construir la Toolbox, un Entorno de Cálculo Científico (SCE: Scientific Computing Environment) orientado a tareas paralelizables de alta granularidad. Palabras Clave: Computación Paralela, Paso de ensajes, ATLAB, PV, PVTB, SCE. 1 INTRODUCCIÓN 1.1 LIBRERÍAS DE PASO DE ENSAJES El modelo de comunicación y sincronización de tareas mediante paso de mensajes ha sido profusamente implementado a diversos niveles [1]. En Red de Area Local (LAN), el programador de aplicaciones paralelas puede escoger entre multitud de entornos, de entre los cuales destacan: Parallel Virtual achine [4] [5] [22] Es el más popular en el entorno académico, y estándar de-facto [1 3.4], probablemente debido al cuidado entorno de control de ejecución y otras prestaciones [1 3.5]. Como características principales, sus autores destacan [4 2 p.2-4] [5 2 p.11] [22] que es portable, soporta interoperación en conjunto heterogéneo de ordenadores, es escalable hasta cientos de máquinas, permite modificación dinámica de la configuración, soporta grupos dinámicos de tareas, envío de señales, múltiples buffers de mensajes y trazado, y dispone de ganchos (hooks) para soportar esquemas de tolerancia a fallos y modificar la política de despacho de tareas. essage Passing Interface [6] [16] [17] [18] El estándar PI se concentra en definir la sintaxis y semántica de las rutinas de paso de mensajes que serían de utilidad a los usuarios de procesadores masivamente paralelos (PP) [5 1 p.8]. El objetivo es proveer a los fabricantes con un conjunto claramente definido de rutinas que puedan implementar eficientemente en su arquitectura, basándose en soporte hardware específico. No define ningún entorno software para desarrollo de aplicaciones paralelas, manejo de tareas, configuración del ulti- Computador ó E/S paralela. Algunas implementaciones del estándar PI son LA (Local Area ulticomputer) [8] [9], y PICH (PI Chameleon) [19]. Los autores de PV sugieren que el propio entorno PV podría portarse a PI para explotar la eficiente implementación de las rutinas básicas que éste ofrece [5 1 p.8]. Los autores de LA informan de que el propio PV puede portarse a Trollius/LA, igual que se ha hecho con PI [8 1 p.7]. 1.2 TOOLBOXES ATLAB PARA PASO DE ENSAJES Cleve oler menciona en su columna [15] los tres motivos básicos (en 1995) para no haber continuado el desarrollo de una versión paralela de ATLAB odelo de memoria Granularidad Perspectiva comercial En un Intel ipsc de 128 nodos con 0.5B de memoria distribuida cada uno, la conclusión resultó ser que se tardaba más tiempo en distribuir y reensamblar los datos que en el propio cálculo, al menos para los tamaños de matriz que cabían en memoria del host. El siguiente intento reveló un problema más grave. En el Ardent Titan, con memoria compartida, se puso de manifiesto que una sesión típica de ATLAB emplea más tiempo en tareas no

paralelizables (intérprete y visualización) que en paralelizables (cálculo). La conclusión es que sólo para tareas de alta granularidad merece la pena paralelizar el cálculo en el lugar obvio: el bucle externo. Realizar los cambios en ATLAB para manejar esto transparentemente no presenta interés comercial para ATLAB, ya que la inmensa mayoría de usuarios preferiría que los esfuerzos se dedicaran a optimizar la versión monoprocesador. Sin embargo, no debe ser difícil para un usuario final incorporar estos cambios en su propio código. Bajo esta perspectiva se han desarrollado multitud de Toolboxes que facilitan dicha paralelización de bucle externo lo más transparentemente posible. Algunas de ellas son 1.2.1 Paralize [10], Enero 1999 Usa sistema de ficheros compartido. Los datos deben ser matrices 3D que se reparten en slices 2D. serve.m anota máquina como servidor paralize.m anota comando, recolecta resultados 1.2.2 PI [10], arzo 1999 Interfaz parcial de PI. aneja las instancias ATLAB como engines. Parallel atlab Interface (PI) Toolbox. Version 1.0 Beta-2 Written by Daniel D. Lee (ddlee@physics.lucent.com), 2/99. Interface functions. PI_Init - Start parallel atlab processes. PI_Finalize - Close parallel atlab processes. PI_Size - Number of active processes. PI_Send - Send matrices to specific process. PI_Recv - Receive matrices from specific process. PI_Bcast - Broadcast matrices to all processes. PI_Eval - Execute string on a remote process. PI_IEval - Non-blocking execute on a remote process. PI_Beval -Broadcast nonblocking exec on all processes. PI_Scatter - Split matrix and send to remote processes. PI_Gather - Get matrices from processes and concat. PI_Reduce - Combine matrix from different processes. engines - Default commands to start processes. Low-level engine routines. engopen - Start a atlab engine session. engclose - Quit a atlab engine session. enggetarray - Copy variables from engine's workspace. engputarray - Put variables into engine's workspace. engevalstring - Evaluate expression in string. engievalstring - Non-blocking evaluation of string. 1.2.3 TCPIP [10], Abril 1999 Interfaz básica para conexión TCP/IP Unix. Requiere que el usuario especifique puerto y dirección. Permite enviar strings y ficheros. No establece mecanismo de ejecución remota. TCPIP Toolbox Version 1.0 Beta 1 1999-04-06 Copyrigtht (C) Peter Rydesäter, itthögskolan, SWEDEN tcpip_close Closes an open tcpip connection. tcpip_open Opens a new tcpip connection. tcpip_read Reads an array of bytes from pipe. tcpip_readln Reads a line of chars if their is a complete. tcpip_sendfile Sends a file throw connection to "getfile" tcpip_getfile Receives a data from sending "tcpip_sendfile" tcpip_sendvar Send matlab variable. tcpip_getvar Get matlab variable. tcpip_servopen Waits for connection from other host-port. tcpip_status Returns status of open connection. tcpip_viewbuff Returns whats in receiving buffer tcpip_write Sends an array of bytes to connection. 1.2.4 Tath [2], [10], Agosto 1997 Interfaz Ptolemy-athematica-atlab. C++ y Tcl requeridos. Permite arrancar procesos ATLAB y evaluar expresiones. aneja los procesos ATLAB como engines. matlab end - terminate a session with ATLAB matlab eval script - evaluate a ATLAB script and print result matlab get name?script? - eval script, get the named matrix matlab getpairs name?script? - eval script,get named matrix matlab send script - evaluate script and suppress the output matlab set name rows cols real?imag? - set real, imag. values matlab start -start a new ATLAB session matlab status - status of the Tcl/ATLAB connection matlab unset name - unset the named ATLAB matrix 1.2.5 PT-Toolbox [7], Abril 1995 Interfaz parcial de PV3.3.7 (unas 20 llamadas). ATLAB Parallel Environment (PT) commands. Extension based on PV. Version 1 09-April-95 Configuring the Parallel Environment (PE). pt_addengines - Add Engine daemons to the current PE. pt_deleteengines - Delete Engine daemons from current PE. pt_hosts - Obtain host names of Engine daemons. pt_status - Obtain wids of current Engine daemons. pt_host2engs - Obtain wids of daemons in given host. pt_erreset - Reset the Error daemon. pt_shutdown - Shutdown the PE. anipulating wids. pt_mywid - Obtain worker id of this engine/session. pt_spawn - Spawn an m-file (worker) in a engine. pt_exit - Exit the PE. Sending and Receiving. pt_send - Send a matrix to a engine/session. pt_mcast - Send a matrix to many engine/sessions. pt_recv - Receive a matrix from a engine/session. pt_trecv - Timeout receive from a engine/session. Forming groups. pt_joingroup - Enroll engine/session into a group. pt_lvgroup - Unroll engine/session from a group. pt_getinst - Get wid of a member of a group. pt_gsize - Get size of a group. pt_getwid - Get wid of a specific member of a group. pt_bcast - Broadcast msg to all members of a group. pt_barrier - Block member of a group- wait all others. pt_kill - Kill a task in PV pt_cleanup - Attempts to clear PE. pt_sendsig - Send a signal to any task 1.2.6 DP-Toolbox [20], [21], arzo 1999 Interfaz parcial de PV (alrededor de 50 llamadas). ultiplataforma y ultiversión (ATLAB 4 ó 5). Incluye entorno de alto nivel (DP). Distributed and Parallel Toolbox - Low Level PV Interface. Version 1.4 PV Control.

pvme_is - Test whether PV is running.... pvme_halt - Shuts down the entire PV system. Setting and Getting Options. pvm_getopt - Return various libpvm options. pvm_setopt - Set various libpvm options. Process Control. pvm_spawn - Start new PV process.... pvm_exit - Leave PV. Information. pvm_mytid - Return tid of process.... pvm_version - Return PV version. Signaling. pvm_sendsig - Send signal to PV process. pvm_notify - Request notification of PV event. essage Buffers. pvm_initsend - Clear default send buffer, specify encoding.... pvm_freebuf - Dispose a message buffer. Packing / Unpacking Data. pvm_pkdouble - Pack data double into active send buffer. pvm_upkdouble - Unpack data dbl from active recv buffer. pvme_pkarray - Pack 5 array pvme_upkarray - Unpack 5 array pvme_upkarray_name - Unpack only array name. pvme_upkarray_rest - Unpack rest of array. Sending and Receiving. pvm_send - Send data in active message buffer.... pvm_nrecv - Non-blocking receive. aster Pvmd Database. pvm_putinfo - Store message in global mailbox. pvm_recvinfo - Retrieve message from global mailbox. pvm_getmboxinfo - Return contents of global mailbox. pvm_delinfo - Delete message in global mailbox. atlab Extensions. persistent2 - anaging persistent variables. putenv - Change or add an environment variable. unsetenv - Delete an environment variable. selectstdin - select(2) on stdin 1.2.7 ultiatlab [14], [23], Nov. 1997 Incluye entorno de alto nivel basado en PICH. Desarrollado en colaboración con The athworks. ultiatlab (ATLAB on multiple processes). ost commands can be run only on the interactive process (0) Commands marked by * can be run anywhere (0:Nproc-1). Starting and stopping ultiatlab. Start - Initialize remote processes, ultiatlab session. Interrupt-Interrupt ultiatlab processes during comput. Abort - Abort ultiatlab session remaining. Quit - Terminate remote processes, end ultiatlab sess. Process arrangement and identification. *ID - Task ID of a process. *Nproc - Total number of ultiatlab processes active. Grid - Arrange the processes in a grid. *Gridsize - Dimensions of the grid of processes. *Coord - Coordinates of a process in the grid. Running commands on multiple processes. Eval - Evaluate a command on one or more processes. Communication. *Send - Send data from one process to another. *Recv - Receive data sent from another process. *Probe - Determine if communication has been completed. *Barrier - Synchronize processes. Put -Put data from interactive process onto remote processes. Get - Put data from remote process onto interactive process. Bcast - Transmit data to all processes using a tree structure. Distribution of data. Distribute - Distribute matrix according to Coord. Collect-Coll.matrix according to mask created by Distribute. Shift - Shift data between processes Arithmetic. ax - Find pointwise max. of matrices on several processes. in - Find pointwise min. of matrices on several processes. Sum - Find pointwise sum of matrices on several processes. Prod - Find pointwise prod.of matrices on several processes. Graphics. Window - Arrange figs in grid according to function parms. ResetWindow - Reset window position to ATLAB default. Refresh - Repaint all current figures. 1.2.8 PVTB [3], Junio 1999 Esta Toolbox, PVTB, es una interfaz completa de PV v3.4-beta7 bajo ATLAB 5.x y Unix, similar a DP-Toolbox. Ofrece documentación sobre cómo enlazar dinámicamente las librerías PV al objeto de reducir ocupación en disco y memoria. Reutiliza código intensivamente mediante la clasificación de las llamadas PV según el patrón de llamada. Es ideal como herramienta didáctica para enseñar PV. Es capaz de empaquetar y transmitir todos los tipos de datos ATLAB existentes, así como de recibir mensajes de notificación del propio daemon PV. Soporta incluso la realización de ganchos PV del tipo pvm_reg_hoster/tasker/rm. También se ha programado un entorno de alto nivel (), que evita al usuario final la necesidad de aprender PV. Dicho entorno es similar al ofrecido por DP-Toolbox ó ultiatlab. 1.3 ALICIENTES DE ATLAB 5.x PARA IPLEENTAR UNA TOOLBOX PV A partir de la versión 5.0 ATLAB incorpora mejoras, tanto en la API como en los tipos de datos soportados, que facilitan significativamente la programación sistemática de una Toolbox PV. Las más relevantes a este propósito son [11 3-2]: Auto-diagnóstico en la API Soporte para Depuración y Optimización Estructuras atrices de Celdas (cell-arrays) Número variable de argumentos para funciones (varargin) [11 3-12]

En la versión 5.3 aparece el soporte para tipos de datos enteros [13 1-2]. La práctica totalidad de llamadas PV devuelven un valor entero. En esta Toolbox se ha optado por promocionar dicho int a double. ATLAB no puede operar con enteros salvo con el operador de suma, y las operaciones sobre ellos (p.ej: find) producen resultado double [13 1-6]. No obstante, sí resulta interesante utilizar las estructuras en las llamadas PV que devuelven información de diversos tipos, especialmente teniendo en cuenta que todas las variables usadas quedan anotadas en el espacio de trabajo (workspace); esto hace interesante poder reunir variables relacionadas lógicamente entre sí en una sola variable que las agrupe (estructura), en lugar de tenerlas desordenadas en el espacio de trabajo. Asimismo, las matrices de celdas tienen la ventaja de agrupar un número indeterminado de elementos de tipos cualesquiera. Este tipo de datos es el ideal para emular el tipo char**. 2 IPLEENTACION EX 2.1 JUSTIFICACIÓN Se pretende realizar llamadas a la librería PV desde el entorno interactivo de ATLAB. La única manera posible es desde un programa C, que bajo ATLAB debe ser un fichero EX. Los ficheros EX son enlazados dinámicamente (dynamic link) para que el intérprete del entorno ATLAB pueda cargarlos y ejecutarlos [12 2]. Cada llamada PV se implementa como un fichero EX independiente. La función EX traduce (y a veces reordena) los argumentos especificados desde ATLAB al tipo de datos requerido por la llamada antes de proceder a la llamada en sí, y traduce la información devuelta de manera que sea accesible desde ATLAB. 2.2 OPCIONES DE DISEÑO En algunos casos ha sido interesante modificar el patrón de argumentos de una llamada. La función EX resultante no es idéntica por lo tanto a la original en PV. Cuando esto se ha hecho ha sido motivado por alguna de las siguientes razones: Coerción, cambio o promoción de tipo Como se explicó previamente, en la llamada se coerce double int y en la vuelta se promociona int double. Similar trato reciben los arrays de strings, cambiados a cellarrays bajo ATLAB (pvm_spawn, pvm_start_pvmd). Las estructuras C son respetadas como estructuras ATLAB en las llamadas pvm_config,pvm_tasks,pvm_reg_rm., pvm_getminfo, pvm_getmboxinfo, pvm_setminfo. Además, se crea una estructura ATLAB para agrupar los enteros devueltos por pvm_bufinfo y pvm_precv. La struct timeval se cambia a double bajo pvm_trecv y select(), por ser más cómodo para el usuario ATLAB especificar un tiempo como double, pero se respeta bajo pvm_hostsync, por la semántica especial que tiene para el caso de segundos negativos. Bajo pvm_catchout resulta imprescindible cambiar y promocionar el argumento FILE* a int/double para su uso bajo ATLAB. La promoción se realiza también rutinariamente bajo pvm_getfds y select(). En el manejo de máscaras (pvm_gettmask, pvm_settmask, TEV_ASK_*) se ha cambiado mask de tipo pvmtmask a string ATLAB. Los argumentos who y kind se han cambiado de tipo int a string, para que el usuario no necesite recordar los valores numéricos y pueda usar los símbolos PV. Varios argumentos de retorno El lenguaje C permite que una función devuelva un único valor de retorno. Para devolver varios, se suele recurrir a Devolver un puntero a array ó estructura conteniendo dichos valores Pasar punteros a argumentos adicionales (paso por referencia), de manera que a la vuelta contengan los valores de retorno deseados PV usa ambas técnicas. ATLAB permite devolver varios argumentos de retorno. Se ha seguido el criterio de simplificar la llamada trasladando los argumentos por referencia a la parte izquierda (left-hand-side, plhs[]). Las estructuras C son devueltas como estructuras ATLAB. Esta técnica se usa bajo: addhosts, delhosts, gettmask, config, tasks, getfds, reg_rm, hostsync, siblings, unpack, upkint, upkstr, psend, precv, bufinfo, getminfo, getmboxinfo, tickle Argumentos inferibles Una de las características más útiles de ATLAB como lenguaje de rápido prototipado de sistemas es la ausencia de

declaraciones de tipo. Las variables pueden alterar dinámicamente su tamaño y número de dimensiones, y estos atributos pueden ser consultados en cualquier instante. El lenguaje C no fija ningún método para indicar el tamaño de un array. Así, se suele marcar el fin de un string (char*) mediante un carácter ASCII NULL se indica explícitamente el tamaño de una matriz ó vector en su declaración (matriz[]) si una función maneja matrices de diversos tamaños, se suele indicar éste como parámetro adicional (tantos como dimensiones) PV usa todas las técnicas citadas. ATLAB almacena como atributo de cada variable su tamaño y dimensionado actual, de manera que puede ser consultado, haciendo superfluos cualesquiera de los métodos anteriores. Esto se observa en las llamadas: start_pvmd, addhosts, delhosts, spawn, notify, mcast, pkint, upkint, psend, reduce, scatter, gather. A menudo también PV devuelve un int indicando el tamaño de un array. Este argumento se suele respetar, ya que suele ser de interés para el usuario. Esto se hace bajo: getfds, siblings, getmboxinfo, config, tasks 2.3 CONVENIENCIA DE USAR ENLACE DINÁICO PARA LA LIBRERÍA PV Tradicionalmente, PV se ofrece como librería estática, libpvm3.a, libgpvm3.a. Este estilo de enlace se manifiesta en lo siguiente Objetos estáticos: no requieren ningún modificador especial. Pueden optar entre el modo optimizado (-O) y el de depuración (-g). Librerías estáticas: suelen denominarse lib <nombre>.a. Los objetos que la componen están archivados mediante la utilidad ar. Se les suele aplicar la utilidad ranlib para producir un índice que acelera el enlace. Referencia a librería estática: puede indicarse con la opción l<nombre>, ó mencionando el fichero ar, lib<nombre>.a. PV utiliza este último método ocasionalmente. Los ficheros EX deben ser enlazados dinámicamente si han de ser llamados desde ATLAB [12 2]. Usando enlace dinámico también para la propia librería PV, los programas EX resultantes son de menor tamaño en disco que si se enlazaran estáticamente, con el consiguiente ahorro de disco tras la instalación, y de memoria durante la ejecución en un Sistema ultiusuario en el que varios de ellos utilicen la Toolbox simultáneamente (p.ej, una sesión de prácticas). La Toolbox sólo requiere la librería de PV libpvm3 y el programa daemon pvmd3. Si se usan grupos, se requieren también la librería correspondiente libgpvm3 y el programa servidor de grupos pvmgs. Adicionalmente, durante la etapa de depuración es útil disponer de la consola pvm, que a su vez requiere la librería de trazado libpvmtrc. Las modificaciones realizadas siguen los siguientes criterios: Objeto dinámico: el compilador GNU gcc requiere el modificador fpic para producir código independiente de posición, como es necesario para producir librerías dinámicas y enlazar dinámicamente. Librerías dinámicas: suelen denominarse lib<nombre>.so. El compilador gcc requiere el modificador -shared para producir ficheros objeto compartibles que puedan ser posteriormente enlazados con otros objetos para formar ejecutables, como es el caso de las librerías dinámicas. Es costumbre incorporar a la librería el nombre oficial de la misma; nombre bajo el cual la buscarán los ejecutables, lo cual se hace mediante la opción soname. Referencia a librería dinámica: se han sustituido las referencias de la forma lib<nombre>.a a l<nombre>, única forma de referencia válida para dinámicas. Orden de dependencias: en alguna ocasión una librería no ha sido aún copiada al directorio donde se encontraría mediante l cuando ya la necesita algún programa (pvm_gstat) para su enlace. Se ha adelantado la dependencia de manera que la librería esté copiada para cuando se enlaza el ejecutable. Los ficheros afectados, y librerías y programas generados por ellos, son: $PV_ROOT/src/akefile.aimk pvmd3, libpvm3.so $PV_ROOT/pvmgs/akefile.aimk libgpvm3.so, pvmgs, pvm_gstat,pvmgroups $PV_ROOT/tracer/akefile.aimk libpvmtrc.so, tracer, trcsort $PV_ROOT/console/akefile.aimk pvm 2.4 LISTA DE FUNCIONES Se adjunta la tabla 1 enumerando las llamadas PV con el patrón de llamada bajo ATLAB y bajo PV, según los criterios previamente expuestos. La columna ESQ indica el esquema seguido por la llamada, tal y como se explica en [3].

Tabla 1: Llamadas PV. ESQ ATLAB PV Control de la áquina Virtual Paralela SP info = pvm_start_pvmd ({ arg...}, block) int info = pvm_start_pvmd (int argc, char**argv, int block) H_9 [numh, infos] = pvm_addhosts ( host...) int info = pvm_addhosts (char**hosts, int nhost, int*infos) H_9 [numh, infos] = pvm_delhosts ( host...) int info = pvm_delhosts (char**hosts, int nhost, int*infos) SP [numt, tids] = pvm_spawn ( task,{ arg...}, flag, where,ntask) int numt = pvm_spawn (char*task, char**argv, int flag, char*where, int ntask, int*tids) H_2 info = pvm_kill (tid) int info = pvm_kill (int tid) H_4 info = pvm_sendsig (tid, signum) int info = pvm_sendsig (int tid, int signum) SP info = pvm_notify (what, msgtag, (cnt tids) ) int info = pvm_notify (int what, int msgtag, int cnt, int*tids) H_1 info = pvm_exit int info = pvm_exit (void) H_1 info = pvm_halt int info = pvm_halt (void) SP info = pvm_catchout [ (fildes) ] int info = pvm_catchout (FILE*ff) H_2 val = pvm_getopt (what) int val = pvm_getopt (int what) H_4 oldval = pvm_setopt (what, val) int oldval = pvm_setopt (int what, int val) SK [info, mask] = pvm_gettmask ( who ) int info = pvm_gettmask (int who, pvmtmask mask) SK info = pvm_settmask ( who, mask) int info = pvm_settmask (int who, pvmtmask mask) SK TEV_ASK_INIT (mask) TEV_ASK_INIT (mask) SK TEV_ASK_SET (mask, kind ) TEV_ASK_SET (mask, kind) SK TEV_ASK_UNSET (mask, kind ) TEV_ASK_UNSET (mask, kind) SK TEV_ASK_CHECK (mask, kind ) TEV_ASK_CHECK (mask. kind) Información de la áquina Virtual Paralela SP [nhost, narch, hostinfo] = pvm_config int info = pvm_config (int*nhost, int*narch, struct pvmhostinfo**hostp) H_6 mstat = pvm_mstat ( host ) int mstat = pvm_mstat (char*host) SP [ntask, tinfo] = pvm_tasks (where) int info = pvm_tasks (int where, int*ntask, struct pvmtaskinfo**taskp) H_2 stat = pvm_pstat (tid) int status = pvm_pstat (int tid) H_1 tid = pvm_mytid int tid = pvm_mytid (void) H_1 tid = pvm_parent int tid = pvm_parent (void) H_2 dtid = pvm_tidtohost (tid) int dtid = pvm_tidtohost (int tid) H_6 info = pvm_perror ( msg ) int info = pvm_perror (char*msg) SP version = pvm_version char*version = pvm_version (void) H_6 cod = pvm_archcode ( arch ) int cod = pvm_archcode (char*arch) H_5 [nfds, fds] = pvm_getfds int nfds = pvm_getfds (int**fds) H_5 [ntids, tids] = pvm_siblings int ntids = pvm_siblings (int**tids) SP [info clk dlt] = pvm_hostsync (htid) int info = pvm_hostsync (int host, struct timeval*clk, struct timeval*dlt) Envío y Recepción de ensajes H_3 bufid = pvm_initsend [ (encoding) ] int bufid = pvm_initsend (int encoding) PCK info = pvm_pack (var...) int info = pvm_packf (const char*fmt,...) PCK [info, names] = pvm_unpack [ ( vnam...) ] int info = pvm_unpackf (const char*fmt,...) H_4 info = pvm_send (tid, msgtag) int info = pvm_send (int tid, int msgtag) H_4 bufid = pvm_recv (tid, msgtag) int bufid = pvm_recv (int tid, int msgtag) SP bufid = pvm_trecv (tid, msgtag, tmout) int bufid = pvm_trecv (int tid, int msgtag, struct timeval*tmout) H_4 bufid = pvm_nrecv (tid, msgtag) int bufid = pvm_nrecv (int tid, int msgtag) H_4 bufid = pvm_probe (tid, msgtag) int bufid = pvm_probe (int tid, int msgtag) SP info = pvm_mcast (tids, msgtag) int info = pvm_mcast (int*tids, int ntask, int msgtag) SP info = pvm_pkint (n) int info = pvm_pkint (int*ip, int nitem, int stride) SP [info, n] = pvm_upkint int info = pvm_upkint (int*ip, int nitem, int stride) SP info = pvm_pkstr ( str ) int info = pvm_pkstr (char*sp) SP [info, str ] = pvm_upkstr int info = pvm_upkstr (char*sp) H_2 info = pvm_pkmesg (bufid) int info = pvm_pkmesg (int bufid) H_1 bufid = pvm_upkmesg int newbufid = pvm_upkmesg (void) H_2 info = pvm_pkmesgbody (bufid) int info = pvm_pkmesgbody (int bufid) SP [info, len] = pvm_psend (tid, msgtag, data) int info = pvm_psend (int tid, int msgtag, char*buf, int len, int datatype) SP [info, bufinfo]=pvm_precv (tid, msgtag, vnam, len) int info = pvm_precv (int tid, int msgtag, char*buf, int len, int datatype, int atid, int atag, int alen) Buffers de Envío y Recepción H_3 bufid = pvm_mkbuf [ (encoding) ] int bufid = pvm_mkbuf (int encoding) H_2 info = pvm_freebuf (bufid) int info = pvm_freebuf (int bufid) SP [info bufinfo] = pvm_bufinfo (bufid) int info = pvm_bufinfo (int bufid, int*bytes, int*msgtag, int*tid) SP [info msginfo] = pvm_getminfo (bufid) int info = pvm_getminfo (int bufid, struct pvmminfo*msginfo) SP info = pvm_setminfo (bufid, msginfo) int info = pvm_setminfo (int bufid, struct pvmminfo*msginfo) H_1 bufid = pvm_getrbuf int bufid = pvm_getrbuf (void) H_1 bufid = pvm_getsbuf int bufid = pvm_getsbuf (void)

H_2 oldbuf = pvm_setrbuf (bufid) int oldbuf = pvm_setrbuf (bufid) H_2 oldbuf = pvm_setsbuf (bufid) int oldbuf = pvm_setsbuf (bufid) ailbox global H_8 index = pvm_putinfo ( name, bufid, flags) int index = pvm_putinfo (char*name, int bufid, int flags) H_8 bufid = pvm_recvinfo ( name, index, flags) int bufid = pvm_recvinfo (char*name, int index, int flags) H_8 info = pvm_delinfo ( name, index, flags) int info = pvm_delinfo (char*name, int index, int flags) SP [info,mbinfo] = pvm_getmboxinfo ( pattern ) int info = pvm_getmboxinfo (char*pattern, int*nclasses, struct pvmmboxinfo**classes) Grupos H_6 inum = pvm_joingroup ( group ) int inum = pvm_joingroup (char*group) H_7 info = pvm_freezegroup ( group, size) int info = pvm_freezegroup (char*group, int size) H_6 info = pvm_lvgroup ( group ) int info = pvm_lvgroup (char*group) H_7 info = pvm_barrier ( group, count) int info = pvm_barrier (char*group, int count) H_7 inum = pvm_getinst ( group, tid) int inum = pvm_getinst (char*group, int tid) H_7 tid = pvm_gettid ( group, inum) int tid = pvm_gettid (char*group, int inum) H_6 size = pvm_gsize ( group ) int size = pvm_gsize (char*group) H_7 info = pvm_bcast ( group, msgtag) int info = pvm_bcast (char*group, int msgtag) COL info = pvm_reduce ( op, var, msgtag, group, inst) int info = pvm_reduce (void(*func)(), void*data, int count, int datatype, int msgtag, char*group, int rootginst) COL info = pvm_scatter (porcion, var, int info = pvm_scatter (void*result, void*data, int count, int datatype, COL msgtag, group, inst) info = pvm_gather (var, porcion, msgtag, group, inst) Entorno H_6 cc = pvm_export ( name ) int cc = pvm_export (char*name) H_6 cc = pvm_unexport ( name ) int cc = pvm_unexport (char*name) int msgtag, char*group, int rootginst) int info = pvm_gather (void*result, void*data, int count, int datatype, int msgtag, char*group, int rootginst) Contexto H_1 ctx = pvm_getcontext int ctx = pvm_getcontext (void) H_1 ctx = pvm_newcontext int ctx = pvm_newcontext (void) H_2 old_ctx = pvm_setcontext (new_ctx) int old_ctx = pvm_setcontext (int new_ctx) H_2 info = pvm_freecontext (ctx) int info = pvm_freecontext (int ctx) Registro de anejadores REG info = pvm_reg_hoster int cc = pvm_reg_hoster (void) REG info = pvm_reg_tasker int cc = pvm_reg_tasker (void) REG [info, hostinfo] = pvm_reg_rm int cc = pvm_reg_rm (struct pvmhostinfo**hip) FUN mhid = pvm_addmhf (src, tag, ctx, atlab_cd ) int mhid = pvm_addmhf (int src, int tag, int ctx, int(*func)(int bufid)) FUN info = pvm_delmhf (mhid) int info = pvm_delmhf (int mhid) FUN pvm_recvf [ ( atlab_cd ) ] int(*old)(void) = pvm_recvf ( int(*new)(int bufid, int tid, int tag) ) info = pvme_default_config [ ( hostfile ) ] info = pvme_start_pvmd [ ( arg...) ] info = pvme_kill(tids) info = pvme_is tids = pvme_gids ( group ) info = pvme_pack (var...) [info, msg] = pvme_upkntfy str = hostname str = uid Extensiones Utilidades NR putenv ( var=valor ) int putenv(const char*string) NR unsetenv ( var ) int unsetenv(const char*string) NR info = select [ (fildes [, timeout]) ] int select(int n, fd_set*readfs, fd_set*writefs, fd_set*exceptfs, struct timeval*timeout) No documentadas SP [info, resp] = pvm_tickle ( how [,arg] ) tickle how [ arg... ] Obsoletas pero documentadas info = pvm_advise (route) oldset = pvm_serror (set) info = pvm_getmwid (bufid) info = pvm_setmwid (bufid) cc = pvm_delete ( name, index) cc = pvm_insert ( name, index, data) [cc data] = pvm_lookup ( name, index)

2.5 DISCUSIÓN Y DETALLES La interfaz procura ser lo más transparente y sistemática posible. A dicho efecto se redacta un fichero include (header.h) con los patrones de llamada más comunes. /* * Todas las pvm_*.mexlx necesitan <mex.h> y <pvm3.h> */ #include <mex.h> /* atlab */ #include <pvm3.h> /* pvm_lo-que-sea */ /* * Patrones Entrada ATLAB->PV Salida PV->ATLAB */... /*--------------------------------------------------------------------------*/ void mexfunction( int nlhs, mxarray *plhs[], int nrhs, const mxarray *prhs[]){ /*--------------------------------------------------------------------------*/ Incorporar el prototipo de función EX evita duplicarlo en cada fichero fuente. 2.5.1 Patrones de llamada generales (H_*) Las funciones se clasifican según los parámetros que aceptan y valores de retorno que producen. El patrón se codifica en el include y se usa en el fichero fuente correspondiente a la llamada, que suele quedar reducido a la directiva #include y uso del patrón apropiado. H_1: int = f (void) El patrón es #define INT_F_VOID(NAE) \ *mxgetpr(plhs[0]=mxcreatedoubleatrix(1,1,mxreal)) = \ NAE(); Se crea el primer argumento de retorno como array1x1 (plhs[0]), y en su primer elemento (*mgetpr()) se almacena el int devuelto por la función. Un ejemplo de función con este patrón es /* * info = pvm_exit */ #include "header.h" INT_F_VOID(pvm_exit) } Los demás esquemas siguen la misma dinámica. H_2: int = f (int) H_3: int = f[(int)] H_4: int = f (int, int) H_5: [int, int[]] = f (void) H_6: int = f ( str ) H_7: int = f ( str,int) H_8: int = f ( str,int,int) H_9: [int, int[]] = f (str[]) 2.5.2 Funciones de manejo de máscaras (SK) Las funciones y macros de máscara de trazado admiten un parámetro de máscara y otro entero ( who ó kind ). Se ha preferido tratar este segundo parámetro como string. Se redactan las funciones de apoyo en header_msk.h. También se deja la cabecera incluida. 2.5.3 Llamadas PV colectivas (COL) Las funciones de grupo colectivas pueden compartir la comprobación de parámetros y el tratamiento de los argumentos msgtag, group, y rootginst, en header_col.h. El resto del código es específico a cada llamada. 2.5.4 Funciones de registro (REG) Las 3 funciones de registro usan pvmproto.h. pvm_reg_hoster, pvm_reg_tasker siguen el mismo esquema INT_F_VOID mencionado anteriormente. pvm_reg_rm no lo sigue, ya que debe devolver struct pvmhostinfo. 2.5.5 Funciones sin patrón (SP) El resto de llamadas sólo tienen en común los #include ATLAB y PV, y el prototipo mexfunction. Se redacta una sola vez en header_smp.h y se incluye en cada fichero fuente. Un ejemplo es /* * 'version' = pvm_version */ #include "header_smp.h" plhs[0]=mxcreatestring(pvm_version()); /* wrap/argout */ } 2.5.6 Funciones relacionadas (FUN,PCK,NR) Tampoco siguen ningún esquema. No comparten fichero include. Se han clasificado en categorías separadas para facilitar su comprensión. # Fuentes a mano, sin sistema FUNSRCS = pvm_mhf.c pvm_recvf.c PCKSRCS = pvm_pack.c pvm_unpack.c NRSRCS= putenv.c unsetenv.c select.c Las funciones normales (NR) son funciones de apoyo para esta Toolbox, que no utilizan PV. Aunque ATLAB dispone de una función getenv, no permite crear o borrar variables de entorno. Tampoco permite comprobar si hay caracteres pendientes de lectura. Las funciones de empaquetamiento (PCK) son la clave de la integración PV-ATLAB. Cada variable es empaquetada con una cabecera identificando su clase, nombre y dimensiones, de manera que en la recepción se pueda reproducir una variable idéntica a la original.

También es necesario realizar la interfaz con pvm_upkint para poder desempaquetar los mensajes de notificación a esperar tras pvm_notify. Naturalmente, el int se coerce a double. Por complitud, se decide hacer también la interfaz para pvm_upkint, pvm_pkstr y pvm_upkstr, al ser el string tipo básico ATLAB. También por complitud se realiza la interfaz con pvm_psend y pvm_precv, limitados al tipo array double. Las funciones de funciones (FUN) tienen bajo C un argumento puntero a función. Bajo ATLAB, la única forma de referenciar código es textualmente, como string a ejecutar mediante eval() desde fichero ó mexcallatlab() desde fichero EX. Se requiere pues interponer una función C (puntero a la cual se pasará a la llamada PV) que evalúe el texto ATLAB indicado por el usuario pvm_addmhf y pvm_delmhf son un poco más complicadas que pvm_recvf, ya que requieren declarar múltiples wrappers y mantener una lista con los identificadores de los que se vayan creando (add), para liberarlos después (del). Ambas rutinas se implementan en un mismo fichero EX para mantener el array en memoria sin perder su valor entre llamadas. 2.5.7 Extensiones Las extensiones se nombran con el prefijo pvme_* y están programadas como ficheros. pvme_start_pvmd simplifica el número de argumentos de llamada, pudiendo llegar a usar un fichero de configuración por defecto, indicado por pvme_default_config. pvme_is comprueba si está ejecutándose pvmd. pvme_kill admite un array como argumento, en vez de un escalar. pvme_gids devuelve todos los tids en un grupo, no sólo el de una instancia indicada. pvme_pack permite agrupar las variables empaquetadas de manera que se conozca su número al desempaquetarlas. pvme_upkntfy permite desempaquetar mensajes de notificación desde ATLAB, promocionando los datos de tipo int del mensaje. 2.5.8 akefile La clasificación de funciones realizada permite controlar con precisión las dependencias.c.h include akefile.env... SRCS = \ $(PVSRCS) $(COLSRCS) $(SKSRCS) $(REGSRCS) \ $(SPSRCS) $(FUNSRCS) $(PCKSRCS) $(NRSRCS)... EXS = $(patsubst.c,.mexlx, $(SRCS))... $(EXS):.mexlx:.o $(CC) $(LDFLAGS) $(LDLIBS) $< -o $@... $(PVOBJS): header.h $(COLOBJS): header_col.h $(SKOBJS): header_msk.h $(REGOBJS): header_reg.h $(SPOBJS): header_smp.h Los flags en akefile.env son sencillamente EXCPPFLAGS = -I$(5_ROOT)/extern/include \ -DATLAB_EX_FILE DEBUGFLAGS = -g OPTIFLAGS = -O -DNDEBUG EXLDFLAGS = -shared PVCPPFLAGS = -I$(PV_ROOT)/include PVLDFLAGS = -L$(PV_ROOT)/lib/$(PV_ARCH) PVLIBS = -lpvm3 -lgpvm3 CPPFLAGS = $(EXCPPFLAGS) $(PVCPPFLAGS) # CFLAGS = $(OPTIFLAGS) CFLAGS = $(DEBUGFLAGS) LDFLAGS = $(EXLDFLAGS) $(PVLDFLAGS) LDLIBS = $(PVLIBS) Observar que basta con cambiar el último CFLAGS para pasar de modo depuración a optimizado. 3 TUTORIAL La Toolbox PVTB se acompaña de una extensa relación de pruebas a realizar para comprobar su correcto funcionamiento. Está redactada en estilo tutorial, sirviendo pues para familiarizarse con las llamadas PV y con los conceptos asociados al paso de mensajes. Las pruebas incluyen el uso del entorno de alto nivel mencionado (). Dicho entorno está íntegramente programado en ficheros, y se explica también detalladamente en [3]. PVTB sólo ha sido comprobada bajo sistemas UNIX. El paso de mensajes entre varios ATLAB requiere naturalmente el correspondiente número de licencias. Se incluyen programas C para ejercitar el paso de mensajes sin necesidad de ejecutar instancias adicionales de ATLAB. Agradecimientos El autor agradece al Departamento de Arquitectura y Tecnología de Computadores de la Universidad de Granada el uso de su instalación de ATLAB. Este trabajo ha sido financiado por los Proyectos CICYT TIC97-1149 y TAP97-1166. Referencias

[1] H. Dietz (1998) Linux Parallel Processing HOWTO. http://metalab.unc.edu/mdw/ HOWTO/Parallel-Processing-HOWTO.html [2] B.L. Evans, S.X. Gu (1997) Tath 0.2: A Tcl Interface to ATLAB and athematica. http://www.ece.utexas.edu/~bevans/projects/ tmath.html [3] J. Fernández (1999) Toolbox PV. Informe Técnico 1999-1. Depto. de Arquitectura y Tecn. Comp. Universidad de Granada. [4] A. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. anchek, V. Sunderam, (1994) PV 3 Users Guide and Reference anual. Oak Ridge National Laboratory. Oak Ridge, Tennessee 37831. http://www.netlib.org/pvm3/ug.ps [5] A. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. anchek, V. Sunderam, (1994) PV: Parallel Virtual achine. A Users Guide and Tutorial for Networked Parallel Computing. The IT Press. Cambridge, assachusetts. http://www.netlib.org/pvm3/book/pvmbook.html [6] W. Gropp, E. Lusk, A. Skjelum (1994) Using PI: Portable Parallel Programming with the essage-passing Interface, The IT Press ISBN 0-262-57104-8. http://www.mcs.anl.gov/mpi/usingmpi/index. html [7] J. Hollingsworth, K. Liu, P. Pauca (1996) PT v.1.00 anual and Reference Pages, Technical report, athematics and Computer Science Department, Wake Forest University. http://www.mthcsc.wfu.edu/pt/pt.html [8] LA Group (1996) PI Primer / Developing with LA, Ohio Supercomputer Center, The Ohio State University, http://www.mpi.nd.edu/ downloads/lam/lam61.doc.ps.z [9] LA HomePage, http://www.mpi.nd.edu/lam [10] The athworks Home Downloads, ATLAB 5 User Contributed -Files, miscelaneous, http://www.mathworks.com/support/ftp/ miscv5.shtml [11] The athworks, Inc. (1998) ATLAB 5.2 Product Family New Features [12] The athworks, Inc. (1998) ATLAB Application Program Interface Guide. http://www.mathworks.com/access/helpdesk/ help/pdf_doc/matlab/api/apiguide.pdf [13] The athworks, Inc. (1999) Release 11 New Features. http://www.mathworks.com/access/ helpdesk/help/pdf_doc/matlab/newfeat.pdf [14] V.S. enon, A.E. Trefethen (1997) ultiatlab: Integrating ATLAB with High-Performance Parallel Computing. Supercomputing 97 AC SIGARCH and IEEE Computer Society http://www.cs.cornell.edu/info/people/vsm/ papers/sc97 http://www.supercomp.org/sc97/proceedings/ TECH/ENON/INDEX.HT [15] C. oler (1995) Why there isn t a parallel ATLAB. athworks Newsletter. Spring 1995. http://www.mathworks.com/company/ newsletter/pdf/spr95cleve.pdf [16] PI Forum (1994) PI: A essage-passing Interface standard, International Journal of Supercomputer Applications and High Performance Computing, vol.8. numb.3/4. http://www.mpi-forum.org/docs/mpi-11- html/mpi-report.html [17] PI Forum (1997) PI-2: Extensions to the esssage-passing Interface, Technical report. http://www.mpi-forum.org/docs/mpi- 20-html/mpi2-report.html [18] PI HomePage, http://www.mcs.anl.gov/mpi [19] PICH, http://www.mcs.anl.gov/mpi/mpich [20] S. Pawletta (1998) Extensions of a Scientific and Technical Computation and Visualization System to a Development Environment for Parallel Applications Ph.D.Thesis, University of Rostock. http://netti.e-technik.uni-rostock.de/~pawelj [21] S. Pawletta et al (1999) Distributed and Parallel Application Toolbox v1.4 Technical report, Institute of Automatic Control, Department of echanical Engineering, University of Rostock, Germany. http://www-at.e-technik.uni-rostock.de/dp [22] PV Group (1994) The PV Project. http://www.netlib.org/pvm3/writeup.ps [23] A.E. Trefethen, V.S. enon, C. Chang, G.J. Czajkowski, C. yers, L.N. Trefethen (1996) ultiatlab: ATLAB on ultiple Processors. Technical Report 96-239, Cornell Theory Center, University of Cornell http://www.cs.cornell.edu/info/people/lnt/ multimatlab.html