teshsuite/smpi/mpich3-test/datatype/segtest.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2001 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6 #include "mpi.h"
   7 #include "mpiimpl.h"
   8 #include <stdio.h>
   9
  10 /*
  11  * Simple segment test, including timing code
  12  */
  13
  14 /*
  15  * Build datatype structures
  16  *
  17  * Contiguous
  18  *     n = 1, 4, 16, 64, 128, 512, 2048, 8196 ints
  19  * Vector
  20  *     blocksize = 1, 4, 64 ints
  21  *     stride    = 1, 64, 127
  22  * Block Indexed
  23  *     blocksize = 1, 4 ints
  24  *     offsets   = i*24 for i = 0 to n, n = 0, 64, 512
  25  * Indexed
  26  *     blocksizes = 1, 2, 4, 3, 7, 5, 6
  27  *     offsets    = i*24 for i = 0 to n, n = 0, 4, 7, 64, 512
  28  *     (Wrap blocksizes to match offsets)
  29  *
  30  * Also need a few nested datatypes, such as vector of vectors
  31  * Do the versions in Using MPI
  32  *
  33  */
  34
  35 /*
  36  * Routines to create dataloops for basic dataloops
  37  */
  38 /*
  39  *  Contig
  40  */
  41 MPID_Dataloop *MPID_Dataloop_init_contig( int count )
  42 {
  43     MPID_Dataloop *ct;
  44
  45     ct = (MPID_Dataloop *)MPIU_Malloc( sizeof(MPID_Dataloop ) );
  46     ct->kind                     = MPID_DTYPE_CONTIG | DATALOOP_FINAL_MASK;
  47     ct->loop_params.c_t.count    = count;
  48     ct->loop_params.c_t.dataloop = 0;
  49     ct->extent                   = count;
  50     ct->handle                       = 0;
  51
  52     return ct;
  53 }
  54
  55 /*
  56  * Vector
  57  */
  58 MPID_Dataloop *MPID_Dataloop_init_vector( int count, int blocksize,
  59                                           int stride )
  60 {
  61     MPID_Dataloop *v;
  62
  63     v = (MPID_Dataloop *)MPIU_Malloc( sizeof(MPID_Dataloop) );
  64     v->kind                      = MPID_DTYPE_VECTOR | DATALOOP_FINAL_MASK;
  65     v->loop_params.v_t.count     = count;
  66     v->loop_params.v_t.blocksize = blocksize;
  67     v->loop_params.v_t.stride    = stride;
  68     v->loop_params.v_t.dataloop  = 0;
  69     v->extent                    = (count-1)*stride + blocksize;
  70     v->handle                        = 0;
  71
  72     return v;
  73 }
  74
  75 /*
  76  * Block indexed
  77  */
  78 MPID_Dataloop *MPID_Dataloop_init_blockindexed( int count, int blocksize,
  79                                                 MPI_Aint *offset )
  80 {
  81     MPID_Dataloop *bi;
  82     MPI_Aint      extent;
  83     int           i;
  84
  85     bi = (MPID_Dataloop *)MPIU_Malloc( sizeof(MPID_Dataloop) );
  86     bi->kind                       = MPID_DTYPE_BLOCKINDEXED | DATALOOP_FINAL_MASK;
  87     bi->loop_params.bi_t.count     = count;
  88     bi->loop_params.bi_t.blocksize = blocksize;
  89     bi->loop_params.bi_t.offset    =
  90         (MPI_Aint *)MPIU_Malloc( sizeof(MPI_Aint) * count );
  91     for (i=0; i<count; i++) {
  92         bi->loop_params.bi_t.offset[i] = offset[i];
  93         if (offset[i] + blocksize > extent)
  94             extent = offset[i] + blocksize;
  95     }
  96     bi->loop_params.bi_t.dataloop  = 0;
  97     bi->extent                     = extent;
  98     bi->handle                         = 0;
  99
 100     return bi;
 101 }
 102
 103 /*
 104  * Indexed
 105  */
 106 MPID_Dataloop *MPID_Dataloop_init_indexed( int count, int *blocksize,
 107                                            MPI_Aint *offset )
 108 {
 109     MPID_Dataloop *it;
 110     MPI_Aint      extent = 0;
 111     int           i;
 112
 113     it = (MPID_Dataloop *)MPIU_Malloc( sizeof(MPID_Dataloop) );
 114     it->kind                      = MPID_DTYPE_INDEXED | DATALOOP_FINAL_MASK;
 115     it->loop_params.i_t.count     = count;
 116     it->loop_params.i_t.blocksize = (int *)MPIU_Malloc( sizeof(int) * count );
 117     it->loop_params.i_t.offset    =
 118         (MPI_Aint *)MPIU_Malloc( sizeof(MPI_Aint) * count );
 119     for (i=0; i<count; i++) {
 120         it->loop_params.i_t.offset[i]    = offset[i];
 121         it->loop_params.i_t.blocksize[i] = blocksize[i];
 122         if (offset[i] + blocksize[i] > extent)
 123             extent = offset[i] + blocksize[i];
 124     }
 125     it->loop_params.i_t.dataloop  = 0;
 126     it->extent                    = extent;
 127     it->handle                        = 0;
 128
 129     return it;
 130 }
 131
 132 int main( int argc, char **argv )
 133 {
 134     /* MPID_Dataloop *vecloop; */
 135     MPI_Datatype vectype;
 136     int count=200, blocksize=4, stride = 7*4;
 137     char *src_buf, *dest_buf;
 138     int  i,j,k;
 139     double r1, r2;
 140
 141     MPI_Init( &argc, &argv );
 142
 143 /*    vecloop = MPID_Dataloop_init_vector( count, blocksize, stride ); */
 144
 145     MPI_Type_vector( count, 1, 7, MPI_INT, &vectype );
 146
 147     /* Initialize the data */
 148     src_buf = (char *)MPIU_Malloc( (count - 1) * stride + blocksize );
 149     for (i=0; i<(count-1)*stride+blocksize; i++)
 150         src_buf[i] = -i;
 151     for (i=0; i<count; i++) {
 152         for (j=0; j<blocksize; j++)
 153             src_buf[i*stride+j] = i*blocksize + j;
 154     }
 155     dest_buf = (char *)MPIU_Malloc( count*blocksize );
 156     for (i=0; i<count*blocksize; i++) {
 157         dest_buf[i] = -i;
 158     }
 159     r1 = MPI_Wtime();
 160     for (i=0; i<100; i++) {
 161         int position = 0;
 162         /*MPID_Segment_pack( vecloop, src_buf, dest_buf );*/
 163         MPI_Pack( src_buf, count, vectype, dest_buf, count*blocksize,
 164                   &position, MPI_COMM_WORLD );
 165     }
 166     r2 = MPI_Wtime();
 167     printf( "Timer for vector pack is %e\n", (r2-r1)/100 );
 168     for (i=0; i<count*blocksize; i++) {
 169         if (dest_buf[i] != (char)i) {
 170             printf( "Error at location %d\n", i );
 171         }
 172     }
 173     r1 = MPI_Wtime();
 174     for (k=0; k<100; k++) {
 175         char *dest=dest_buf, *src=src_buf;
 176         for (i=0; i<count; i++) {
 177             for (j=0; j<blocksize; j++)
 178                 *dest++ = src[j];
 179             src+= stride;
 180         }
 181     }
 182     r2 = MPI_Wtime();
 183     printf( "Timer for hand vector pack is %e\n", (r2-r1)/100 );
 184
 185     r1 = MPI_Wtime();
 186     for (k=0; k<100; k++) {
 187         int *dest=(int*)dest_buf, *src=(int*)src_buf;
 188         int bsize = blocksize >> 2;
 189         int istride = stride >> 2;
 190         if (bsize == 1) {
 191             for (i=0; i<count; i++) {
 192                 *dest++ = *src;
 193                 src+= istride;
 194             }
 195         }
 196         else {
 197             for (i=0; i<count; i++) {
 198                 for (j=0; j<bsize; j++)
 199                     *dest++ = src[j];
 200                 src+= istride;
 201             }
 202         }
 203     }
 204     r2 = MPI_Wtime();
 205     printf( "Timer for hand vector pack (int) is %e\n", (r2-r1)/100 );
 206
 207     MPI_Finalize();
 208     return 0;
 209 }
 210
 211 /*
 212  * Nested vector.
 213  *   The y-z subface is
 214  *   Type_vector( ey-sy+1, 1, nx, MPI_DOUBLE, &newx1 );
 215  *   Type_hvector( ez-sz+1, 1, nx*ny_sizeof(double), newx1, &newx );
 216  * This gives the a(i,sy:ey,sz:ez) of a(nx,ny,nz) (in Fortran notation)
 217  */