Ejemplo. Integración numérica #include #include #include /*Gather.c*/float integral(float ai, float h, int n);
int main(int argc, char* argv[]) { int n, p, myid, tag, proc, ierr, i; float h, integral_sum, a, b, ai, pi, my_int, buf[50]; int master = 0; /* processor performing total sum */ MPI_Comm comm;
comm = MPI_COMM_WORLD; ierr = MPI_Init(&argc, &argv); MPI_Comm_rank(comm, &myid); MPI_Comm_size(comm, &p);
Ejemplo. Integración numérica pi = acos(-1.0); /* = 3.14159… */ a = 0.; /* lower limit of integration */ b = pi*1./2.; /* upper limit of integration */ n = 500; /* number of increment within each process */ h = (b-a)/n/p; /* length of increment */ ai = a + myid*n*h; /* lower limit of integration for partition myid */ my_int = integral(ai, h, n);
printf("Process %d has the partial sum of %fn", myid,my_int);
MPI_Gather( &my_int, 1, MPI_FLOAT, buf, 1, MPI_FLOAT, master, comm);
Ejemplo. Integración numérica if(myid == master) { integral_sum = 0.0; for (i=0; i #define SIZE 4 int main(int argc,char *argv[]) { nt numtasks, rank, sendcount, recvcount, source; float sendbuf[SIZE][SIZE] = {{1.0, 2.0, 3.0, 4.0}, {5.0, 6.0,7.0,8.0}, {9.0, 10.0, 11.0, 12.0}, {13.0, 14.0, 15.0, 16.0}}; float recvbuf[SIZE]; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &numtasks); if (numtasks == SIZE) { source = 1; sendcount = SIZE; recvcount = SIZE; MPI_Scatter(sendbuf,sendcount,MPI_FLOAT,recvbuf,recvcount, MPI_FLOAT,source,MPI_COMM_WORLD); printf("rank= %d Results: %f %f %f %fn",rank,recvbuf[0], recvbuf[1],recvbuf[2],recvbuf[3]); } else printf("Must specify %d processors.Terminating.n",SIZE); MPI_Finalize(); }
Ejemplos Scatter en las filas de una matriz. Salida del programa rank= 0 Results: 1.000000 2.000000 3.000000 4.000000 rank= 1 Results: 5.000000 6.000000 7.000000 8.000000 rank= 2 Results: 9.000000 10.000000 11.000000 12.000000 rank= 3 Results: 13.000000 14.000000 15.000000 16.000000
Comunicaciones colectivas. Distribución all-to-all La comunicación de todos con todos supone que, inicialmente, cada proceso tiene un vector con tantos elementos como procesos hay en el comunicador.
Para i, j y k entre 0 y N-1 (donde N es el número de procesos del comunicador), cada proceso i envía una copia de sendbuf[j] al proceso j, y recibe del proceso k un elemento, que almacena en recvbuf[k].
MPI_Alltoall() equivale, por tanto, a una sucesión de N operaciones de distribución, en cada una de las cuales el proceso i toma el rol de raíz.
int MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm);
int MPI_Alltoallv(void* sendbuf, int *sendcounts, int *sdispls, MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int *rdispls, MPI_Datatype recvtype, MPI_Comm comm);
Comunicaciones colectivas. Distribución all-to-all
Comunicaciones colectivas. Reducción Una reducción es una operación realizada de forma cooperativa entre todos los procesos de un comunicador, de tal forma que se obtiene un resultado final que se almacena en el proceso raíz.
int MPI_Reduce(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm);
Ejemplo. Integración numérica #include #include #include /*reduce.c*/
float fct(float x) { return cos(x); } float integral(float ai, float h, int n);
int main(int argc, char* argv[]) { int n, p, myid, tag, proc, ierr; float h, integral_sum, a, b, ai, pi, my_int; char line[10]; int master = 0; MPI_Comm comm; comm = MPI_COMM_WORLD;
Ejemplo. Integración numérica ierr = MPI_Init(&argc,&argv); MPI_Comm_rank(comm, &myid); MPI_Comm_size(comm, &p);
pi = acos(-1.0); /* = 3.14159… */ a = 0.; /* lower limit of integration */ b = pi*1./2.; /* upper limit of integration */
if(myid == master) { printf("The requested number of processors is %dn",p); printf("Enter number of increments within each processn"); (void) fgets(line, sizeof(line), stdin); (void) sscanf(line, "%d", &n); }
Ejemplo. Integración numérica /* Broadcast "n" to all processes */ MPI_Bcast( &n, 1, MPI_INT, master, comm);
h = (b-a)/n/p; /* length of increment */ ai = a + myid*n*h; /* lower limit of integration for partition myid */ my_int = integral(ai, h, n); /* 0<=myid<=p-1 */
printf("Process %d has the partial result of %fn", myid,my_int);
MPI_Reduce( &my_int, &integral_sum, 1, MPI_FLOAT, MPI_SUM, master, comm);
if(myid == 0) { printf("The result =%fn",integral_sum); } MPI_Finalize(); }
Ejemplo. Integración numérica float integral(float ai, float h, int n) { int j; float aij, integ; integ = 0.0; /* initialize */ for (j=0;j #include
/* Run with four processes */
void main(int argc, char *argv[]) { int rank; MPI_Status status; struct { int x; int y; int z; } point; MPI_Datatype ptype;
MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Type_contiguous(3,MPI_INT,&ptype); MPI_Type_commit(&ptype); if(rank==3){ point.x=15; point.y=23; point.z=6; MPI_Send(&point,1,ptype,1,52,MPI_COMM_WORLD); } else if(rank==1) { MPI_Recv(&point,1,ptype,3,52,MPI_COMM_WORLD,&status); printf("P:%dreceived coordsare (%d,%d,%d) n",rank,point.x,point.y,point.z); } MPI_Finalize(); }
Ejemplos. vector.c #include #include #include
void main(int argc, char *argv[]) { int rank,i,j; MPI_Status status; double x[4][8]; MPI_Datatype coltype;
MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Type_vector(4,1,8,MPI_DOUBLE,&coltype); MPI_Type_commit(&coltype);
if(rank==3){ for(i=0;i<4;++i) for(j=0;j<8;++j) x[i][j]=pow(10.0,i+1)+j; MPI_Send(&x[0][7],1,coltype,1,52,MPI_COMM_WORLD); } else if(rank==1) { MPI_Recv(&x[0][2],1,coltype,3,52,MPI_COMM_WORLD,&status); for(i=0;i<4;++i) printf("P:%d my x[%d][2]=%1fn",rank,i,x[i][2]); } MPI_Finalize(); }
Ejemplos. extent.c #include #include
void main(intargc, char *argv[]) { int rank,i; MPI_Status status; struct{ int num; float x; double data[4]; } a;
int blocklengths[3]={1,1,4}; MPI_Datatype types[3]={MPI_INT,MPI_FLOAT,MPI_DOUBLE}; MPI_Aint displacements[3]; MPI_Datatype restype; MPI_Aint intex,floatex;
MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Type_extent(MPI_INT,&intex); MPI_Type_extent(MPI_FLOAT,&floatex);
Ejemplos displacements[0]= (MPI_Aint)0; displacements[1]=intex; displacements[2]=intex+floatex; MPI_Type_struct(3,blocklengths,displacements,types,&restype); MPI_Type_commit(&restype);
if (rank==3){ a.num=6; a.x=3.14; for(i=0;i<4;++i) a.data[i]=(double) i; MPI_Send(&a,1,restype,1,52,MPI_COMM_WORLD); } else if(rank==1) { MPI_Recv(&a,1,restype,3,52,MPI_COMM_WORLD,&status); printf("P:%dmy a is %d %f %lf %lf %lf %lfn", rank,a.num,a.x,a.data[0],a.data[1],a.data[2],a.data[3]); } MPI_Finalize(); }
Ejemplos. bcast.c #include #include
void main (int argc, char *argv[]) { int rank; double param;
MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); if(rank==5) param=23.0; MPI_Bcast(¶m,1,MPI_DOUBLE,5,MPI_COMM_WORLD); printf("P:%d after broadcast parameter is %fn",rank,param); MPI_Finalize(); }
Ejemplos. scatterdos.c #include #include void main (int argc, char *argv[]) { int rank,size,i,j; double param[4],mine; int sndcnt,revcnt;
MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Comm_size(MPI_COMM_WORLD,&size);
revcnt=1; if(rank==3){ for(i=0;i<4;i++) param[i]=23.0+i; sndcnt=1; } MPI_Scatter(param,sndcnt,MPI_DOUBLE,&mine,revcnt,MPI_DOUBLE,3,MPI_COMM_WORLD); printf("P:%dmine is %fn",rank,mine); MPI_Finalize(); }
Ejemplos. reducedos.c #include #include
void main (int argc, char *argv[]) { int rank; struct{ double value; int rank;} in, out; int root;
MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); in.value=rank+1; in.rank=rank; root=7; MPI_Reduce(&in,&out,1,MPI_DOUBLE_INT,MPI_MAXLOC,root,MPI_COMM_WORLD); if(rank==root) printf("PE:%dmax=%lf at rank %dn",rank,out.value,out.rank); MPI_Reduce(&in,&out,1,MPI_DOUBLE_INT,MPI_MINLOC,root,MPI_COMM_WORLD); if(rank==root) printf("PE:%dmin=%lf at rank %dn",rank,out.value,out.rank); MPI_Finalize(); }
Ejemplos. create.c #include #include /*Con 4 procesadores*/
#define TRUE 1 typedef struct{ double real,imag; } complex; void cprod(complex *in, complex *inout, int *len, MPI_Datatype *dptr) { int i; complex c; for (i=0; i<*len; ++i) { c.real=(*in).real * (*inout).real-(*in).imag* (*inout).imag; c.imag=(*in).real * (*inout).imag+ (*in).imag* (*inout).real; *inout=c; in++; inout++; } }
Ejemplos. create.c void main (int argc, char *argv[]) { int rank; int root; complex source,result; MPI_Op myop; MPI_Datatypectype;
MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Type_contiguous(2,MPI_DOUBLE,&ctype); MPI_Type_commit(&ctype); MPI_Op_create(cprod,TRUE,&myop);
root=2; source.real=rank+1; source.imag=rank+2; MPI_Reduce(&source,&result,1,ctype,myop,root,MPI_COMM_WORLD); if(rank==root) printf("PE:%d result is %lf + %lfin",rank, result.real, result.imag); MPI_Finalize(); } ——————————————– P:2 result is -185.000000 + -180.000000i
| Página siguiente |