Author: gropp Date: 2012-11-19 10:51:55 -0600 (Mon, 19 Nov 2012) New Revision: 10618 Added: mpich2/trunk/test/mpi/datatype/darray-cyclic.c Modified: mpich2/trunk/test/mpi/datatype/Makefile.am mpich2/trunk/test/mpi/datatype/testlist Log: Added test for Darray cyclic options Modified: mpich2/trunk/test/mpi/datatype/Makefile.am =================================================================== --- mpich2/trunk/test/mpi/datatype/Makefile.am 2012-11-19 16:28:07 UTC (rev 10617) +++ mpich2/trunk/test/mpi/datatype/Makefile.am 2012-11-19 16:51:55 UTC (rev 10618) @@ -25,6 +25,7 @@ contigstruct \ cxx-types \ darray-pack \ + darray-cyclic \ gaddress \ get-elements \ get-elements-pairtype \ Added: mpich2/trunk/test/mpi/datatype/darray-cyclic.c =================================================================== --- mpich2/trunk/test/mpi/datatype/darray-cyclic.c (rev 0) +++ mpich2/trunk/test/mpi/datatype/darray-cyclic.c 2012-11-19 16:51:55 UTC (rev 10618) @@ -0,0 +1,252 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ +/* + * (C) 2012 by Argonne National Laboratory. + * See COPYRIGHT in top-level directory. + */ +#include "mpi.h" +#include <stdio.h> +#include <stdlib.h> +#include "mpitest.h" + +int AllocateGrid( int nx, int ny, int **srcArray, int **destArray ); +int PackUnpack( MPI_Datatype, const int [], int[], int ); + +int main( int argc, char *argv[] ) +{ + int errs = 0; + int wrank, wsize; + int gsizes[3], distribs[3], dargs[3], psizes[3]; + int px, py, nx, ny, rx, ry, bx, by; + int *srcArray, *destArray; + int i, j, ii, jj, loc; + MPI_Datatype darraytype; + + MTest_Init( 0, 0 ); + MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); + MPI_Comm_size( MPI_COMM_WORLD, &wsize ); + + /* Test 1: Simple, 1-D cyclic decomposition */ + if (AllocateGrid( 1, 3*wsize, &srcArray, &destArray ) ) { + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + /* Simple cyclic with 1-dim global array */ + gsizes[0] = 3*wsize; + distribs[0] = MPI_DISTRIBUTE_CYCLIC; + dargs[0] = 1; + psizes[0] = wsize; + MPI_Type_create_darray( wsize, wrank, 1, + gsizes, distribs, dargs, psizes, + MPI_ORDER_C, MPI_INT, &darraytype ); + + /* Check the created datatype. Because cyclic, should represent + a strided type */ + if (PackUnpack( darraytype, srcArray, destArray, 3 )) { + fprintf( stderr, "Error in pack/unpack check\n" ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + /* Now, check for correct data */ + for (i=0; i<3; i++) { + if (destArray[i] != wrank + i * wsize) { + fprintf( stderr, "1D: %d: Expected %d but saw %d\n", + i, wrank + i * wsize, destArray[i] ); + errs++; + } + } + + free( destArray ); + free( srcArray ); + MPI_Type_free( &darraytype ); + + /* Test 2: Simple, 1-D cyclic decomposition, with block size=2 */ + if (AllocateGrid( 1, 4*wsize, &srcArray, &destArray ) ) { + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + /* Simple cyclic with 1-dim global array */ + gsizes[0] = 4*wsize; + distribs[0] = MPI_DISTRIBUTE_CYCLIC; + dargs[0] = 2; + psizes[0] = wsize; + MPI_Type_create_darray( wsize, wrank, 1, + gsizes, distribs, dargs, psizes, + MPI_ORDER_C, MPI_INT, &darraytype ); + + /* Check the created datatype. Because cyclic, should represent + a strided type */ + if (PackUnpack( darraytype, srcArray, destArray, 4 )) { + fprintf( stderr, "Error in pack/unpack check\n" ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + loc = 0; + /* for each cyclic element */ + for (i=0; i<2; i++) { + /* For each element in block */ + for (j=0; j<2; j++) { + if (destArray[loc] != 2*wrank + i * 2*wsize + j) { + fprintf( stderr, "1D(2): %d: Expected %d but saw %d\n", + i, 2*wrank + i * 2*wsize+j, destArray[loc] ); + errs++; + } + loc++; + } + } + + free( destArray ); + free( srcArray ); + MPI_Type_free( &darraytype ); + + /* 2D: Create some 2-D decompositions */ + px = wsize/2; + py = 2; + rx = wrank % px; + ry = wrank / px; + + if (px * py != wsize) { + fprintf( stderr, "An even number of processes is required\n" ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + /* Cyclic/Cyclic */ + if (AllocateGrid( 5*px, 7*py, &srcArray, &destArray )) { + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + /* Simple cyclic/cyclic. Note in C order, the [1] index varies most + rapidly */ + gsizes[0] = ny = 7*py; + gsizes[1] = nx = 5*px; + distribs[0] = MPI_DISTRIBUTE_CYCLIC; + distribs[1] = MPI_DISTRIBUTE_CYCLIC; + dargs[0] = 1; + dargs[1] = 1; + psizes[0] = py; + psizes[1] = px; + MPI_Type_create_darray( wsize, wrank, 2, + gsizes, distribs, dargs, psizes, + MPI_ORDER_C, MPI_INT, &darraytype ); + + /* Check the created datatype. Because cyclic, should represent + a strided type */ + if (PackUnpack( darraytype, srcArray, destArray, 5*7 )) { + fprintf( stderr, "Error in pack/unpack check\n" ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + loc = 0; + for (j=0; j<7; j++) { + for (i=0; i<5; i++) { + int expected = rx + ry * nx + i * px + j * nx * py; + if (destArray[loc] != expected) { + errs++; + fprintf( stderr, "2D(cc): [%d,%d] = %d, expected %d\n", + i, j, destArray[loc], expected ); + } + loc++; + } + } + + free( srcArray ); + free( destArray ); + MPI_Type_free( &darraytype ); + + /* Cyclic(2)/Cyclic(3) */ + if (AllocateGrid( 6*px, 4*py, &srcArray, &destArray )) { + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + /* Block cyclic/cyclic. Note in C order, the [1] index varies most + rapidly */ + gsizes[0] = ny = 4*py; + gsizes[1] = nx = 6*px; + distribs[0] = MPI_DISTRIBUTE_CYCLIC; + distribs[1] = MPI_DISTRIBUTE_CYCLIC; + dargs[0] = by = 2; + dargs[1] = bx = 3; + psizes[0] = py; + psizes[1] = px; + MPI_Type_create_darray( wsize, wrank, 2, + gsizes, distribs, dargs, psizes, + MPI_ORDER_C, MPI_INT, &darraytype ); + + /* Check the created datatype. Because cyclic, should represent + a strided type */ + if (PackUnpack( darraytype, srcArray, destArray, 4*6 )) { + fprintf( stderr, "Error in pack/unpack check\n" ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + + loc = 0; + for (j=0; j<4/by; j++) { + for (jj=0; jj<by; jj++) { + for (i=0; i<6/bx; i++) { + for (ii=0; ii<bx; ii++) { + int expected = rx * bx + ry * by * nx + i * bx * px + ii + + (j * by * py + jj) * nx; + if (destArray[loc] != expected) { + errs++; + fprintf( stderr, "2D(c(2)c(3)): [%d,%d] = %d, expected %d\n", + i*bx+ii, j*by+jj, destArray[loc], expected ); + } + loc++; + } + } + } + } + + free( srcArray ); + free( destArray ); + MPI_Type_free( &darraytype ); + + MTest_Finalize( errs ); + MPI_Finalize(); + + return 0; +} + +int AllocateGrid( int nx, int ny, int **srcArray, int **destArray ) +{ + int *src, *dest; + int i, j; + src = (int *)malloc( nx*ny*sizeof(int) ); + dest = (int *)malloc( nx*ny*sizeof(int) ); + if (!src || !dest) { + fprintf( stderr, "Unable to allocate test arrays of size (%d x %d)\n", + nx, ny ); + return 1; + } + for (i=0; i<nx*ny; i++) { + src[i] = i; + dest[i] = -i-1; + } + *srcArray = src; + *destArray = dest; + return 0; +} + +/* Extract the source array into the dest array using the DARRAY datatype. + "count" integers are returned in destArray */ +int PackUnpack( MPI_Datatype darraytype, const int srcArray[], int destArray[], + int count ) +{ + int packsize, position; + int *packArray; + + MPI_Type_commit( &darraytype ); + MPI_Pack_size( 1, darraytype, MPI_COMM_SELF, &packsize ); + packArray = (int *)malloc( packsize ); + if (!packArray) { + fprintf( stderr, "Unable to allocate pack array of size %d\n", + packsize ); + MPI_Abort( MPI_COMM_WORLD, 1 ); + } + position = 0; + MPI_Pack( (int*)srcArray, 1, darraytype, packArray, packsize, &position, + MPI_COMM_SELF ); + packsize = position; + position = 0; + MPI_Unpack( packArray, packsize, &position, destArray, count, MPI_INT, + MPI_COMM_SELF ); + free( packArray ); + return 0; +} Modified: mpich2/trunk/test/mpi/datatype/testlist =================================================================== --- mpich2/trunk/test/mpi/datatype/testlist 2012-11-19 16:28:07 UTC (rev 10617) +++ mpich2/trunk/test/mpi/datatype/testlist 2012-11-19 16:51:55 UTC (rev 10618) @@ -27,6 +27,7 @@ darray-pack 1 darray-pack 9 # darray-pack 72 +darray-cyclic 12 pairtype-size-extent 1 simple-commit 1 simple-size-extent 1