UNIVERSIDAD DE ORIENTE NCLEO DE SUCRE ESCUELA DE CIENCIAS DEPARTAMENTO DE MATEMATICA PROGRAMA DE LA LICENCIATURA EN INFORMATICA

TRABAJO DE INVESTIGACIN Luis Jos Tena Rumbos

_________________________ Profa: Ana Fuentes

______________________ Fecha

Cuman, marzo de 2012

MPI_Reduce - Reduce los valores en todos los procesos dentro de un grupo.

C++ Sintaxis
#include <mpi.h> void MPI::Intracomm::Reduce(const void* sendbuf, void* recvbuf, int count, const MPI::Datatype& datatype, const MPI::Op& op, int root) const

Parmetros de Entrada
sendbuf Direccin del buffer de envo (a elegir). count Nmero de elementos en el buffer de envo (nmero entero). datatype Tipo de datos de los elementos del buffer de envo (manejador). op Operacin de reduccin (manejador). root Rango del proceso raz (numero entero). comm Comunicador (manejador).

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (eleccin, slo significativo para la raz).

Descripcin
Las funciones globales de reducir (MPI_Reduce, MPI_Op_create, MPI_Op_free, MPI_Allreduce, MPI_Reduce_scatter, MPI_Scan) realiza una operacin de reduccin (tales como sumar, buscar el mximo, AND lgico, etc.) a travs de todos los miembros de un grupo. La operacin de reduccin puede ser a alguna de una lista predefinida, o una operacin definida por el usuario. Las funciones de reduccin globales vienen en varios sabores: una reduccin que devuelva el resultado de la reduccin a un nodo, un reduccin-total que devuelve este resultado a todos los nodos, y una operacin de escaneo (prefijo paralelo). Adems, una reduccin-dispersa la operacin de dispersin combina la funcionalidad de una reduccin y una operacin de dispersin.

MPI_Reduce combina los elementos previstos en el buffer de entrada de cada proceso en el grupo, utilizando la operacin op, y devuelve el valor combinado en el buffer de salida del proceso con rango raz. El buffer de entrada se define por los argumentos sendbuf, count, y datatype, el buffer de salida se define por los argumentos recvbuf, count, y datatype; ambos tienen el mismo nmero de elementos, y son del mismo tipo. La rutina es llamada por todos los miembros del grupo que usen los mismos argumentos count, datatype, op, root y comm. Por lo tanto, todos los procesos proporcionan buffers de entrada y salida de igual longitud, con elementos del mismo tipo.

Cada proceso puede proporcionar un elemento, o una secuencia de elementos, en cuyo caso la operacin combinada se ejecuta basada en los elementos de cada entrada de la secuencia. Por ejemplo, si la operacin es MPI_MAX y el bfer de envo contiene dos elementos que son nmeros de punto flotante (count = 2 y datatype = MPI_FLOAT), entonces recvbuf(1) = global max (sendbuf(1)) y recvbuf(2) = global max (sendbuf(2)). Ejemplo 1: Una rutina que calcula el producto escalar de dos vectores que se distribuyen a travs de un grupo de procesos y devuelve la respuesta al proceso cero. SUBRUTINA PAR_BLAS1 (m, a, b, c, comm) BIENES a (m), b (m)!segmento local de la matriz C VERDADERO! resultado (en proceso de cero) Suma real INTEGER m, comm, i, IERR ! suma local suma = 0,0 DO i = 1, m suma = suma + a (i) * b (i) END DO ! suma global CONVOCATORIA MPI_REDUCE (suma, c, 1, MPI_REAL, MPI_SUM, 0, comm, IERR) REGRESO

MPI_Alltoall - Todos los procesos envan datos a todos los procesos

C++ Sintaxis
#include <mpi.h>

int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

Parmetros de entrada
sendbuf Direccin inicial del buffer de envo (a elegir). sendcount Nmero de elementos para enviar a cada proceso (nmero entero). sendtype Tipo de dato de los elementos del buffer de envo (manejador). recvcount Nmero de elementos a recibir de cada proceso (nmero entero). recvtype Tipo de dato de los elementos del buffer de entrada (manejador). comm Comunicador sobre el cual los datos se intercambian (manejador).

Parmetros de Salida
recvbuf Direccin inicial del buffer de recepcin (opcin).

Descripcin
MPI_Alltoall es una operacin colectiva en la que todos los procesos envan la misma cantidad de datos entre ellos, y reciben la misma cantidad de datos unos de otros. El funcionamiento de esta rutina se puede representar como sigue, donde cada proceso realiza 2n (n es el nmero de procesos en el comunicador comm) comunicaciones punto-a-punto independientes (incluyendo consigo mismo). MPI_Comm_size (comm, & n); for (i = 0, i <n; i + +) MPI_Send (sendbuf + i * sendcount * extent(sendtype), sendcount, sendtype, i, ..., comm); for (i = 0, i <n; i + +) MPI_Recv (recvbuf + i * sendcount * extent(recvtype), recvcount, recvtype, i, ..., comunicacin personal);

Cada proceso rompe su sendbuf local en n bloques cada uno contiene sendcount elementos de tipo sendtype - y divide su recvbuf similarmente de acuerdo con recvcount y recvtype. El proceso j enva el k-simo bloque de su sendbuf local al proceso k, que coloca los datos en el j-simo bloque de su recvbuf local. La cantidad

de datos enviados debe ser igual a la cantidad de datos recibidos, relacionndose en parejas, entre cada par de procesos.

MPI_Allgather - Recopila datos de todos los procesos y los distribuye a todos los procesos
C + + Sintaxis
#include <mpi.h> void MPI::Comm::Allgather(const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype) const = 0

Parmetros de entrada
sendbuf Direccin inicial del buffer de envo (a elegir). sendcount Nmero de elementos en el buffer de envo (nmero entero). sendtype Tipo de dato de los elementos del buffer de envo (manejador). recvcount Nmero de elementos recibidos de cualquier proceso (nmero entero). recvtype Tipo de dato de los elementos del buffer de recepcin (manejador). comm comunicador (manejador).

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (opcin).

Descripcin
MPI_Allgather es similar a MPI_Gather, excepto que todos los procesos reciben el resultado, en lugar de slo la raz. En otras palabras, todos los procesos contribuyen al resultado, y todos los procesos reciben el resultado.

El tipo signature asociado con sendcount, sendtype en un proceso debe ser igual al tipo signature asociado con recvcount, recvtype en cualquier otro proceso. El resultado de una llamada a MPI_Allgather (...) Es como si todos los procesos de ejecutaran n llamadas a MPI_Gather (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm), para root = 0, ..., n-1. Las reglas para el uso correcto de MPI_Allgather se encuentran fcilmente en las reglas correspondientes para MPI_Gather. Ejemplo: La versin AllGather del ejemplo 1 en MPI_Gather. Usando MPI_Allgather, recolectamos 100 ints de cada proceso en el grupo, para cada proceso. MPI_Comm comm; int gsize, sendarray[100]; int * RBUF; ... MPI_Comm_size (comm, y gsize); RBUF = (int *) malloc(gsize * 100 * sizeof(int)); MPI_Allgather (sendarray, 100, MPI_INT, RBUF, 100, MPI_INT, comm); Despus de la llamada, cada proceso tiene la concatenacin, de todo el grupo, de los conjuntos de datos.

MPI_Gatherv - rene cantidades de datos diversas de todos los procesos para el proceso root
C++ Sintaxis
#include <mpi.h> void MPI::Comm::Gatherv(const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, const int recvcounts[], const int displs[], const MPI::Datatype& recvtype, int root) const = 0

Parmetros de entrada
sendbuf Direccin inicial del buffer de envo (a elegir). sendcount Nmero de elementos en el buffer de envo (nmero entero).

sendtype Tipo de datos de los elementos en el buffer de envo (manejador). recvcounts Arreglo de enteros (de tamao longitud en el grupo) que contiene el nmero de elementos que son recibidos por cada proceso (significativo slo para el root). displs Arreglo de enteros (de tamao longitud en el grupo). Entrada i especifica el desplazamiento relativo en recvbuf en la que colocar los datos de entrada del proceso i (significativo slo para el root). recvtype Tipo de datos de los elementos en el buffer recv (significativo root) (manejador) root comm Rango del proceso de recepcin (entero). Comunicador (manejador). slo para el

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (a eleccin, significativo slo para el root).

Descripcin
MPI_Gatherv ampla la funcionalidad de MPI_Gather al permitir un nmero variable de datos de cada proceso, ya que recvcounts es ahora un arreglo. Tambin permite una mayor flexibilidad en cuanto a donde se colocan los datos en el root, al proporcionar el nuevo argumento, displs. El resultado es como si cada proceso, incluyendo el proceso raz, enva un mensaje al root, MPI_Send (sendbuf, sendcount, sendtype, root, ...) y el root ejecuta n recives, MPI_Recv (recvbuf + disp[i] * extent(recvtype), \ recvcounts[i], recvtype, i, ...) Los mensajes se guardan en el bfer de recepcin del proceso raz por orden rango, esto es, los datos enviados desde el proceso j se colocan en la j-sima porcin del bfer de recepcin recvbuf en el proceso raz. La porcin j-sima de recvbuf comienza desde el elemento displs[j] (en trminos de recvtype) en recvbuf.

El bfer de recepcin se tiene en cuenta en todos los procesos que no sean el raz. El tipo signature implcito por sendcount, sendtype en el proceso i debe ser igual a el tipo signature de tipo implcito en recvcounts[i], recvtype en el root. Esto implica que la cantidad de datos enviados en pares debe ser igual a la cantidad de datos recibidos, entre cada proceso y la raz.

Mapas de distintos tipos entre el remitente y el receptor son todava permitidos. Todos los argumentos de la funcin son significativos para el proceso raz, mientras que en otros procesos, slo los argumentos sendbuf sendcount, sendtype, root, comm son significativos. Los argumentos root y comm deben tener idnticos valores en todos los procesos. La especificacin de cantidades, tipos y los desplazamientos no deben causar que alguna ubicacin en el root sea escrita ms de una vez. Este provocara un error. Ejemplo 1: Ahora cada proceso ha enviado 100 ints al root, se estableci cada conjunto (de 100) largos ints de separacin en el extremo receptor. Utilice MPI_Gatherv y el argumento displs para lograr este efecto. Supongamos que stride> = 100. MPI_Comm comm; int gsize, sendarray[100], root, *RBUF, stride, *displs, i, *rcounts; ... MPI_Comm_size (comm, y gsize); RBUF = (int *) malloc (gsize * stride * sizeof (int)); displs = (int *) malloc (gsize * sizeof (int)); rcounts = (int *) malloc (gsize * sizeof (int)); for (i = 0; i <gsize, i + +) { displs [i] = i * stride; rcounts [i] = 100; } MPI_Gatherv (sendarray, 100, MPI_INT, RBUF, rcounts, displs, MPI_INT, root, comm); Tenga en cuenta que el programa es errneo si stride <100.

MPI_Scatterv - dispersa un buffer en partes a todas las tareas de un grupo.

C++ Sintaxis
#include <mpi.h> void MPI::Comm::Scatterv(const void* sendbuf, const int sendcounts[], const int displs[], const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype, int root) const

Parmetros de entrada
sendbuf Direccin del buffer de envo (a eleccin, significativo slo para el root). sendcounts Arreglo de enteros (de tamao de la longitud del grupo), que especifica el nmero de elementos a enviar a cada procesador. displs Arreglo de enteros (de tamao de la longitud del grupo). La entrada i especifica el desplazamiento (relativo a sendbuf) del que se tomaran los datos de salida para procesar i. sendtype Tipo de datos de los elementos del buffer de envo (manejador). recvcount Nmero de elementos en el bfer de recepcin (nmero entero). recvtype Tipo de datos de los elementos del buffer de recepcin (manejador). root Rango del proceso raz (nmero entero). comm Comunicador (manejador).

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (opcin).

Descripcin
MPI_Scatterv es la operacin inversa a MPI_Gatherv.

MPI_Scatterv ampla la funcionalidad de MPI_Scatter al permitir una cantidad variable de datos a ser enviados a cada proceso, ya que sendcounts es ahora un arreglo. Tambin permite mayor flexibilidad en cuanto a donde los datos pueden ser tomados de la raz, proporcionando el nuevo argumento, displs. El resultado es como si la raz hubiese ejecutado n operaciones de envo, MPI_Send (sendbuf + displs[i] * extent(sendtype), \ sendcounts [i], sendtype, i, ...) y cada proceso ejecuto una recepcin, MPI_Recv (recvbuf, recvcount, recvtype, root, ...) El buffer de envo es ignorado por todos los procesos que no sean raz. La firma de tipo implcito en sendcount[i], sendtype en el root debe ser igual a la firma del tipo implcito por recvcount, recvtype en el proceso i (sin embargo, los mapas de tipos pueden ser diferentes). Esto implica que la cantidad de datos enviados debe ser igual a la cantidad de datos recibidos, por pares, entre cada proceso y el root. Mapas de distinto tipo entre remitente y el receptor se permiten todava. Todos los argumentos de la funcin son significativos para el proceso root, mientras que en otros procesos slo los argumentos recvbuf recvcount, recvtype, root, comm son significativos. Los argumentos root y comm deben tener valores idnticos en todos los procesos. La especificacin de las cantidades, tipos y los desplazamientos no deben causar que alguna ubicacin del root sea ledo ms de una vez. Ejemplo 1: Tenemos un stride que vara entre bloques del lado de envo (root), del lado que recibe tenemos 100 - i elementos en la columna i-sima de un arreglo 100x150 en C para el proceso i. MPI_Comm comm; int gsize, recvarray[100][150], * rptr; int root, * sendbuf, myrank, bufsize, *stride; MPI_Datatype RTYPE; int i, * displs, *scounts , offset; ... MPI_Comm_size (comm, &gsize); MPI_Comm_rank (comm, &myrank); step = (int *) malloc (gsize * sizeof (int)); ... / * stride[i] para i = 0 hasta gsize-1 se establece de alguna manera

* sendbuf viene de otra parte */ ... displs = (int *) malloc (gsize * sizeof (int)); scounts = (int *) malloc (gsize * sizeof (int)); offset = 0; for (i = 0; i <gsize, i + +) { displs[i] = stride; offset + = stride[i]; scounts[i] = 100 - i; } / * Crear tipo de dato para la columna que estamos recibiendo */ MPI_Type_vector (100-myrank, 1, 150, MPI_INT, y &RTYPE); MPI_Type_commit (&RTYPE); rptr = &recvarray[0][myrank]; MPI_Scatterv (sendbuf, scounts, displs, MPI_INT, rptr, 1, RTYPE, root, comm);

MPI_Scatter - Enva datos a partir de una tarea a todas las tareas de un grupo.
C++ Sintaxis
#include <mpi.h> void MPI::Comm::Scatter(const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype, int root) const

Parmetros de Entrada
sendbuf Direccin del buffer de envo (de seleccin, significativo slo para el root). sendcount Nmero de elementos enviados a cada proceso (numero entero, significativo slo para el root). sendtype Tipo de dato de los elementos de bfer de emisin (manejador, significativo slo para el root). recvcount Nmero de elementos en bfer de recepcin (nmero entero).

recvtype Tipo de dato de los elementos del buffer que recibe (manejador). root comm Rango de el proceso de envo (nmero entero). Comunicador (manejador).

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (opcin).

Descripcin
MPI_Scatter es la operacin inversa a MPI_Gather. El resultado es como si la raz ejecutara n operaciones de envo, MPI_Send (sendbuf + i * sendcount * extent(sendtype), sendcount, sendtype, i, ...) y cada proceso haya ejecutado un receive, MPI_Recv (recvbuf, recvcount, recvtype, i, ...). Una descripcin alternativa es que la raz enva un mensaje con MPI_Send (sendbuf, sendcount * n, sendtype, ...).Este mensaje se divide en n segmentos iguales, el i-simo segmento se enva al proceso de orden i en el grupo, y cada proceso recibe este mensaje como anteriormente. El buffer de envo se ignora por todos los procesos que no sean raz. La firma de tipo asociado con sendcount, sendtype en la raz debe ser igual a la firma del tipo asociado con recvcount, recvtype en todos los procesos (sin embargo, los mapas de tipo pueden ser diferentes). Esto implica que la cantidad de datos enviados debe ser igual a la cantidad de datos recibidos, por pares, entre cada proceso y la raz. Mapas de tipo distintos entre el remitente y el receptor todava se permiten. Todos los argumentos de la funcin son significativos para el proceso raz, mientras que en otros procesos solo los argumentos recvbuf, recvcount, recvtype, root, comm son significativos. Los argumentos root y comm deben tener valores idnticos en todos los procesos. La especificacin de los cargos y los tipos no debera causar que algn localizacin en el root sea ledo ms de una vez. Justificacin: Aunque no es necesario, la ltima restriccin es impuesta a fin de lograr la simetra con MPI_Gather, donde la restriccin correspondiente Una restriccin de mltiple escritura) es necesario.

Ejemplo: Dispersar conjuntos de 100 ints desde el root hacia cada proceso en el grupo. MPI_Comm comm; gsize int, * sendbuf; root int, RBUF [100]; ... MPI_Comm_size (comm, y gsize); sendbuf = (int *)malloc(gsize*100*sizeof(int)); ... MPI_Scatter (sendbuf, 100, MPI_INT, RBUF, 100, MPI_INT, root, comm);

MPI_Comm_free - Marcar un objeto comunicador para desasignar.

C++ Sintaxis
# include <mpi.h> void Comm :: Free()

Parmetros de Entrada
comm Comunicador a ser destruido (manejador).

Descripcin
Esta operacin marca el objeto comunicador para desasignar. El manejador se establece en MPI_COMM_NULL. Todas las operaciones pendientes que utilicen este comunicador se completar con normalidad, el objeto es realmente desasignado slo si no hay otras referencias activas a la misma. Esta llamada se aplica a intracomunicadores e intercomunicadores. Tras la des asignacin real, las funciones de retorno para eliminar a todos los atributos almacenados en cach son llamados en orden arbitrario.

MPI_Barrier - Bloquea hasta que todos los procesos han llegado a esta rutina.
C++ Sintaxis
# include <mpi.h> void MPI:: Comm :: Barrier() const = 0

Parmetros de Entrada
comm Comunicador (manejador).

Descripcin
Bloquea al que inicia la llamada hasta que todos los miembros del grupo la han llamado, la llamada retorna a cualquier proceso slo despus de que todos los miembros del grupo han hecho la llamada.

MPI_Bsend Envi Bsico con bfer especificado por el usuario.

C++ Sintaxis
# include <mpi.h> void Comm :: Bsend (const void * buf, int count, const Datatype& datatype, int dest, int tag) const

Parmetros de Entrada
buf count Direccin inicial del buffer de envo (a elegir). Nmero de entradas en la memoria de envo (entero no negativo).

datatype Tipo de dato de cada elemento en el bfer de emisin (manejador). dest tag Rango del destino (nmero entero). Etiqueta de mensaje (nmero entero).

comm Comunicador (manejador).

Descripcin
MPI_Bsend Realiza un bloqueo de envo usando un buffer.

MPI_Ssend - Envi estndar sncrono.

Sintaxis C
#include <mpi.h> int MPI_Ssend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Parmetros de entrada
buf count Direccin inicial del buffer de envo (a elegir). Nmero de elementos en el buffer de envo (entero no negativo).

datatype Tipo de dato de cada elemento en el bfer de emisin (manejar). dest tag comm Rango del destino (nmero entero). Etiqueta de mensaje (nmero entero). Comunicador (manejador).

Descripcin
MPI_Ssend realiza de un modo sncrono, un bloqueo al enviar.

MPI_Gather - Recoge los valores de un grupo de procesos.

Sintaxis C
#include <mpi.h> int MPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

Parmetros de entrada
sendbuf Direccin inicial del buffer de envo (a elegir).

sendcount Nmero de elementos en el buffer de envo (nmero entero). sendtype Tipo de datos de los elementos del buffer de envo (manejador). recvcount Nmero de elementos para cualquier receive individual (numero entero, significativo slo para el root). recvtype Tipo de datos de los elementos de recvbuffer (manejador, significativo slo para el root) root comm Rango del proceso que recibe (numero entero). Comunicador (manejador).

Parmetros de Salida
recvbuf Direccin del buffer de recepcin (a elegir, significativo slo para el root).

Descripcin
Cada proceso (proceso raz inclusive) enva el contenido de su buffer de envo al proceso raz. El proceso raz recibe los mensajes y los almacena por orden de rango. El resultado es como si cada uno de los n procesos en el grupo (incluyendo el proceso raz) hubiese ejecutado una llamada a MPI_Send (sendbuf, sendcount, sendtype, root, ...) y la raz haya ejecutado n llamadas a MPI_Recv (recfbuf + i * recvcount *extent (recvtype), recvcount, recvtype, i, ...) donde extent(recvtype) es el tipo extent obtenido a partir de una llamada a MPI_Type_extent () Una descripcin alternativa es que los n mensajes enviados por los procesos en el grupo estn concatenados por orden de rango, y el mensaje resultante es recibido por el root como tal por una llamada a MPI_Recv (recvbuf, recvcount *n , recvtype,. . .).

El bfer de recepcin es ignorado por todos los procesos que no sean raz. En general, tipos de datos derivados son permitidos para ambos sendtype y recvtype. La firma de tipo de sendcount, sendtype en el proceso i debe ser igual a la firma de tipo de recvcount, recvtype en la raz. Esto implica que la cantidad de datos enviados debe ser igual a la cantidad de datos recibidos, por pares, entre cada proceso y la raz. Mapas de tipo diferentes entre el remitente y el receptor se permiten todava. Todos los argumentos de la funcin son significativos para el proceso raz, mientras que en otros procesos solo los argumentos sendbuf, sendcount, sendtype, root, comm son significativos. Los argumentos root y comm deben tener valores iguales en todos los procesos. La especificacin de las cantidades y los tipos no debera causar que alguna ubicacin de la raz sea escrita ms de una vez. Esta llamada es errnea. Tenga en cuenta que el argumento recvcount en la raz indica el nmero de artculos que recibe de cada proceso, no el nmero total de elementos que recibe. Ejemplo 1: Agrupar en la raz, 100 ints de cada proceso en el grupo. MPI_Comm comm; int gsize, sendarray[100]; int root, *rbuf; ... MPI_Comm_size( comm, &gsize); rbuf = (int *)malloc(gsize*100*sizeof(int)); MPI_Gather( sendarray, 100, MPI_INT, rbuf, 100, MPI_INT, root, comm);

MPI_Bcast - Difunde un mensaje desde el proceso con rango raz, a todos los otros procesos
del grupo.

Sintaxis C
#include <mpi.h> int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm)

Entrada / Salida de Parmetros

buffer count datatype root comm Direccin inicial del buffer (a elegir). Nmero de entradas en el buffer (entero). Tipo de datos del buffer (manejador). Rango del root que difunde los datos (entero). Comunicador (manejador).

Descripcin
MPI_Bcast difunde un mensaje desde el proceso con rango root hacia los otros procesos del grupo, incluyendo el mismo. Es llamado por todos los miembros del grupo que usan los mismos argumentos para comm, root. Cuando retornan, el contenido del buffer de comunicacin del root se ha copiado a todos los procesos. En general, tipos de datos derivados son permitidos como tipo de dato. La firma de tipo de count, datatype en cualquier proceso debe ser igual a la firma de tipo de count, datatype en la raz. Esto implica que la cantidad de datos enviados debe ser igual a la cantidad recibida, en pares, entre cada proceso y la raz. MPI_Bcast y todas las dems rutinas colectivas de movimientos-de-datos hacen esta restriccin. Mapas de tipo distintito entre el remitente y receptor todava se permiten. Ejemplo: Emitir 100 ints desde el proceso 0 a cada proceso en el Grupo MPI_Comm comm; int array[100]; int root = 0; ... MPI_Bcast (array, 100, MPI_INT, root, comm);

MPI_Wtime - Devuelve el tiempo transcurrido en el proceso de llamada. (Tiempo en

segundos desde un tiempo arbitrario en el pasado.)

Sintaxis C
# Include <mpi.h> MPI_Wtime doble ()

Descripcin
MPI_Wtime devuelve un nmero punto flotante de segundos, que representa el tiempo transcurrido en el reloj desde algn tiempo en el pasado. El "tiempo en el pasado" se garantiza que no cambia durante la vida del proceso. El usuario es responsable de convertir un gran nmero de segundo a otras unidades si son los preferidos. Esta funcin es portable (Regresa segundos, no "tics"), permite alta resolucin, y no lleva paquete innecesario. Uno podra usarlo de esta manera: { double starttime, endtime; starttime = MPI_Wtime(); .... cdigo ... endtime = MPI_Wtime(); printf("Eso tomo %f segundos\n", endtime-starttime); } El tiempo devuelto son locales al nodo que los llam. No hay requisito de que diferentes nodos devuelvan el "mismo" tiempo.