teshsuite/smpi/mpich3-test/datatype/subarray-pack.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 <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 static int verbose = 0;
  12
  13 /* tests */
  14 int subarray_1d_c_test1(void);
  15 int subarray_1d_fortran_test1(void);
  16 int subarray_2d_c_test1(void);
  17 int subarray_4d_c_test1(void);
  18 int subarray_2d_c_test2(void);
  19 int subarray_2d_fortran_test1(void);
  20 int subarray_4d_fortran_test1(void);
  21
  22 /* helper functions */
  23 static int parse_args(int argc, char **argv);
  24 static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz);
  25
  26 int main(int argc, char **argv)
  27 {
  28     int err, errs = 0;
  29
  30     MPI_Init(&argc, &argv);     /* MPI-1.2 doesn't allow for MPI_Init(0,0) */
  31     parse_args(argc, argv);
  32
  33     /* To improve reporting of problems about operations, we
  34      * change the error handler to errors return */
  35     MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
  36
  37     /* perform some tests */
  38     err = subarray_1d_c_test1();
  39     if (err && verbose)
  40         fprintf(stderr, "%d errors in 1d subarray c test 1.\n", err);
  41     errs += err;
  42
  43     err = subarray_1d_fortran_test1();
  44     if (err && verbose)
  45         fprintf(stderr, "%d errors in 1d subarray fortran test 1.\n", err);
  46     errs += err;
  47
  48     err = subarray_2d_c_test1();
  49     if (err && verbose)
  50         fprintf(stderr, "%d errors in 2d subarray c test 1.\n", err);
  51     errs += err;
  52
  53     err = subarray_2d_fortran_test1();
  54     if (err && verbose)
  55         fprintf(stderr, "%d errors in 2d subarray fortran test 1.\n", err);
  56     errs += err;
  57
  58     err = subarray_2d_c_test2();
  59     if (err && verbose)
  60         fprintf(stderr, "%d errors in 2d subarray c test 2.\n", err);
  61     errs += err;
  62
  63     err = subarray_4d_c_test1();
  64     if (err && verbose)
  65         fprintf(stderr, "%d errors in 4d subarray c test 1.\n", err);
  66     errs += err;
  67
  68     err = subarray_4d_fortran_test1();
  69     if (err && verbose)
  70         fprintf(stderr, "%d errors in 4d subarray fortran test 1.\n", err);
  71     errs += err;
  72
  73     /* print message and exit */
  74     if (errs) {
  75         fprintf(stderr, "Found %d errors\n", errs);
  76     }
  77     else {
  78         printf(" No Errors\n");
  79     }
  80     MPI_Finalize();
  81     return 0;
  82 }
  83
  84 /* subarray_1d_c_test1()
  85  *
  86  * Returns the number of errors encountered.
  87  */
  88 int subarray_1d_c_test1(void)
  89 {
  90     MPI_Datatype subarray;
  91     int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 };
  92     int array_size[] = { 9 };
  93     int array_subsize[] = { 3 };
  94     int array_start[] = { 1 };
  95
  96     int i, err, errs = 0, sizeoftype;
  97
  98     /* set up type */
  99     err = MPI_Type_create_subarray(1,   /* dims */
 100                                    array_size,
 101                                    array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray);
 102     if (err != MPI_SUCCESS) {
 103         errs++;
 104         if (verbose) {
 105             fprintf(stderr,
 106                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 107         }
 108         return errs;
 109     }
 110
 111     MPI_Type_commit(&subarray);
 112     MPI_Type_size(subarray, &sizeoftype);
 113     if (sizeoftype != 3 * sizeof(int)) {
 114         errs++;
 115         if (verbose)
 116             fprintf(stderr, "size of type = %d; should be %d\n",
 117                     sizeoftype, (int) (3 * sizeof(int)));
 118         return errs;
 119     }
 120
 121     err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int));
 122
 123     for (i = 0; i < 9; i++) {
 124         int goodval;
 125         switch (i) {
 126         case 1:
 127             goodval = 1;
 128             break;
 129         case 2:
 130             goodval = 2;
 131             break;
 132         case 3:
 133             goodval = 3;
 134             break;
 135         default:
 136             goodval = 0;        /* pack_and_unpack() zeros before unpacking */
 137             break;
 138         }
 139         if (array[i] != goodval) {
 140             errs++;
 141             if (verbose)
 142                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 143         }
 144     }
 145
 146     MPI_Type_free(&subarray);
 147     return errs;
 148 }
 149
 150 /* subarray_1d_fortran_test1()
 151  *
 152  * Returns the number of errors encountered.
 153  */
 154 int subarray_1d_fortran_test1(void)
 155 {
 156     MPI_Datatype subarray;
 157     int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 };
 158     int array_size[] = { 9 };
 159     int array_subsize[] = { 3 };
 160     int array_start[] = { 1 };
 161
 162     int i, err, errs = 0, sizeoftype;
 163
 164     /* set up type */
 165     err = MPI_Type_create_subarray(1,   /* dims */
 166                                    array_size,
 167                                    array_subsize,
 168                                    array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray);
 169     if (err != MPI_SUCCESS) {
 170         errs++;
 171         if (verbose) {
 172             fprintf(stderr,
 173                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 174         }
 175         return errs;
 176     }
 177
 178     MPI_Type_commit(&subarray);
 179     MPI_Type_size(subarray, &sizeoftype);
 180     if (sizeoftype != 3 * sizeof(int)) {
 181         errs++;
 182         if (verbose)
 183             fprintf(stderr, "size of type = %d; should be %d\n",
 184                     sizeoftype, (int) (3 * sizeof(int)));
 185         return errs;
 186     }
 187
 188     err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int));
 189
 190     for (i = 0; i < 9; i++) {
 191         int goodval;
 192         switch (i) {
 193         case 1:
 194             goodval = 1;
 195             break;
 196         case 2:
 197             goodval = 2;
 198             break;
 199         case 3:
 200             goodval = 3;
 201             break;
 202         default:
 203             goodval = 0;        /* pack_and_unpack() zeros before unpacking */
 204             break;
 205         }
 206         if (array[i] != goodval) {
 207             errs++;
 208             if (verbose)
 209                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 210         }
 211     }
 212
 213     MPI_Type_free(&subarray);
 214     return errs;
 215 }
 216
 217
 218 /* subarray_2d_test()
 219  *
 220  * Returns the number of errors encountered.
 221  */
 222 int subarray_2d_c_test1(void)
 223 {
 224     MPI_Datatype subarray;
 225     int array[9] = { -1, -2, -3,
 226         -4, 1, 2,
 227         -5, 3, 4
 228     };
 229     int array_size[2] = { 3, 3 };
 230     int array_subsize[2] = { 2, 2 };
 231     int array_start[2] = { 1, 1 };
 232
 233     int i, err, errs = 0, sizeoftype;
 234
 235     /* set up type */
 236     err = MPI_Type_create_subarray(2,   /* dims */
 237                                    array_size,
 238                                    array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray);
 239     if (err != MPI_SUCCESS) {
 240         errs++;
 241         if (verbose) {
 242             fprintf(stderr,
 243                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 244         }
 245         return errs;
 246     }
 247
 248     MPI_Type_commit(&subarray);
 249     MPI_Type_size(subarray, &sizeoftype);
 250     if (sizeoftype != 4 * sizeof(int)) {
 251         errs++;
 252         if (verbose)
 253             fprintf(stderr, "size of type = %d; should be %d\n",
 254                     sizeoftype, (int) (4 * sizeof(int)));
 255         return errs;
 256     }
 257
 258     err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int));
 259
 260     for (i = 0; i < 9; i++) {
 261         int goodval;
 262         switch (i) {
 263         case 4:
 264             goodval = 1;
 265             break;
 266         case 5:
 267             goodval = 2;
 268             break;
 269         case 7:
 270             goodval = 3;
 271             break;
 272         case 8:
 273             goodval = 4;
 274             break;
 275         default:
 276             goodval = 0;
 277             break;
 278         }
 279         if (array[i] != goodval) {
 280             errs++;
 281             if (verbose)
 282                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 283         }
 284     }
 285
 286     MPI_Type_free(&subarray);
 287     return errs;
 288 }
 289
 290 /* subarray_2d_c_test2()
 291  *
 292  * Returns the number of errors encountered.
 293  */
 294 int subarray_2d_c_test2(void)
 295 {
 296     MPI_Datatype subarray;
 297     int array[12] = { -1, -2, -3, -4, 1, 2,
 298         -5, -6, -7, -8, -9, -10
 299     };
 300     int array_size[2] = { 2, 6 };
 301     int array_subsize[2] = { 1, 2 };
 302     int array_start[2] = { 0, 4 };
 303
 304     int i, err, errs = 0, sizeoftype;
 305
 306     /* set up type */
 307     err = MPI_Type_create_subarray(2,   /* dims */
 308                                    array_size,
 309                                    array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray);
 310     if (err != MPI_SUCCESS) {
 311         errs++;
 312         if (verbose) {
 313             fprintf(stderr,
 314                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 315         }
 316         return errs;
 317     }
 318
 319     MPI_Type_commit(&subarray);
 320     MPI_Type_size(subarray, &sizeoftype);
 321     if (sizeoftype != 2 * sizeof(int)) {
 322         errs++;
 323         if (verbose)
 324             fprintf(stderr, "size of type = %d; should be %d\n",
 325                     sizeoftype, (int) (2 * sizeof(int)));
 326         return errs;
 327     }
 328
 329     err = pack_and_unpack((char *) array, 1, subarray, 12 * sizeof(int));
 330
 331     for (i = 0; i < 12; i++) {
 332         int goodval;
 333         switch (i) {
 334         case 4:
 335             goodval = 1;
 336             break;
 337         case 5:
 338             goodval = 2;
 339             break;
 340         default:
 341             goodval = 0;
 342             break;
 343         }
 344         if (array[i] != goodval) {
 345             errs++;
 346             if (verbose)
 347                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 348         }
 349     }
 350
 351     MPI_Type_free(&subarray);
 352     return errs;
 353 }
 354
 355 /* subarray_4d_c_test1()
 356  *
 357  * Returns the number of errors encountered.
 358  */
 359 int subarray_4d_c_test1(void)
 360 {
 361     MPI_Datatype subarray;
 362     int array[] = {
 363         -1111, -1112, -1113, -1114, -1115, -1116,
 364         -1121, -1122, -1123, -1124, -1125, -1126,
 365         -1131, -1132, -1133, -1134, -1135, -1136,
 366         -1211, -1212, -1213, -1214, -1215, -1216,
 367         -1221, -1222, -1223, -1224, -1225, -1226,
 368         -1231, -1232, -1233, -1234, -1235, -1236,
 369         -2111, -2112, -2113, -2114, 1, -2116,
 370         -2121, -2122, -2123, -2124, 2, -2126,
 371         -2131, -2132, -2133, -2134, 3, -2136,
 372         -2211, -2212, -2213, -2214, 4, -2216,
 373         -2221, -2222, -2223, -2224, 5, -2226,
 374         -2231, -2232, -2233, -2234, 6, -2236
 375     };
 376
 377     int array_size[4] = { 2, 2, 3, 6 };
 378     int array_subsize[4] = { 1, 2, 3, 1 };
 379     int array_start[4] = { 1, 0, 0, 4 };
 380
 381     int i, err, errs = 0, sizeoftype;
 382
 383     /* set up type */
 384     err = MPI_Type_create_subarray(4,   /* dims */
 385                                    array_size,
 386                                    array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray);
 387     if (err != MPI_SUCCESS) {
 388         errs++;
 389         if (verbose) {
 390             fprintf(stderr,
 391                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 392         }
 393         return errs;
 394     }
 395
 396     MPI_Type_commit(&subarray);
 397     MPI_Type_size(subarray, &sizeoftype);
 398     if (sizeoftype != 6 * sizeof(int)) {
 399         errs++;
 400         if (verbose)
 401             fprintf(stderr, "size of type = %d; should be %d\n",
 402                     sizeoftype, (int) (6 * sizeof(int)));
 403         return errs;
 404     }
 405
 406     err = pack_and_unpack((char *) array, 1, subarray, 72 * sizeof(int));
 407
 408     for (i = 0; i < 72; i++) {
 409         int goodval;
 410         switch (i) {
 411         case 40:
 412             goodval = 1;
 413             break;
 414         case 46:
 415             goodval = 2;
 416             break;
 417         case 52:
 418             goodval = 3;
 419             break;
 420         case 58:
 421             goodval = 4;
 422             break;
 423         case 64:
 424             goodval = 5;
 425             break;
 426         case 70:
 427             goodval = 6;
 428             break;
 429         default:
 430             goodval = 0;
 431             break;
 432         }
 433         if (array[i] != goodval) {
 434             errs++;
 435             if (verbose)
 436                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 437         }
 438     }
 439
 440     MPI_Type_free(&subarray);
 441     return errs;
 442 }
 443
 444 /* subarray_4d_fortran_test1()
 445  *
 446  * Returns the number of errors encountered.
 447  */
 448 int subarray_4d_fortran_test1(void)
 449 {
 450     MPI_Datatype subarray;
 451     int array[] = {
 452         -1111, -1112, -1113, -1114, -1115, -1116,
 453         -1121, -1122, -1123, -1124, -1125, -1126,
 454         -1131, -1132, -1133, -1134, -1135, -1136,
 455         -1211, -1212, -1213, -1214, -1215, -1216,
 456         -1221, -1222, -1223, -1224, -1225, -1226,
 457         -1231, -1232, -1233, -1234, -1235, -1236,
 458         -2111, -2112, -2113, -2114, 1, -2116,
 459         -2121, -2122, -2123, -2124, 2, -2126,
 460         -2131, -2132, -2133, -2134, 3, -2136,
 461         -2211, -2212, -2213, -2214, 4, -2216,
 462         -2221, -2222, -2223, -2224, 5, -2226,
 463         -2231, -2232, -2233, -2234, 6, -2236
 464     };
 465
 466     int array_size[4] = { 6, 3, 2, 2 };
 467     int array_subsize[4] = { 1, 3, 2, 1 };
 468     int array_start[4] = { 4, 0, 0, 1 };
 469
 470     int i, err, errs = 0, sizeoftype;
 471
 472     /* set up type */
 473     err = MPI_Type_create_subarray(4,   /* dims */
 474                                    array_size,
 475                                    array_subsize,
 476                                    array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray);
 477     if (err != MPI_SUCCESS) {
 478         errs++;
 479         if (verbose) {
 480             fprintf(stderr,
 481                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 482         }
 483         return errs;
 484     }
 485
 486     MPI_Type_commit(&subarray);
 487     MPI_Type_size(subarray, &sizeoftype);
 488     if (sizeoftype != 6 * sizeof(int)) {
 489         errs++;
 490         if (verbose)
 491             fprintf(stderr, "size of type = %d; should be %d\n",
 492                     sizeoftype, (int) (6 * sizeof(int)));
 493         return errs;
 494     }
 495
 496     err = pack_and_unpack((char *) array, 1, subarray, 72 * sizeof(int));
 497
 498     for (i = 0; i < 72; i++) {
 499         int goodval;
 500         switch (i) {
 501         case 40:
 502             goodval = 1;
 503             break;
 504         case 46:
 505             goodval = 2;
 506             break;
 507         case 52:
 508             goodval = 3;
 509             break;
 510         case 58:
 511             goodval = 4;
 512             break;
 513         case 64:
 514             goodval = 5;
 515             break;
 516         case 70:
 517             goodval = 6;
 518             break;
 519         default:
 520             goodval = 0;
 521             break;
 522         }
 523         if (array[i] != goodval) {
 524             errs++;
 525             if (verbose)
 526                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 527         }
 528     }
 529
 530     MPI_Type_free(&subarray);
 531     return errs;
 532 }
 533
 534
 535 /* subarray_2d_fortran_test1()
 536  *
 537  * Returns the number of errors encountered.
 538  */
 539 int subarray_2d_fortran_test1(void)
 540 {
 541     MPI_Datatype subarray;
 542     int array[12] = { -1, -2, -3, -4, 1, 2,
 543         -5, -6, -7, -8, -9, -10
 544     };
 545     int array_size[2] = { 6, 2 };
 546     int array_subsize[2] = { 2, 1 };
 547     int array_start[2] = { 4, 0 };
 548
 549     int i, err, errs = 0, sizeoftype;
 550
 551     /* set up type */
 552     err = MPI_Type_create_subarray(2,   /* dims */
 553                                    array_size,
 554                                    array_subsize,
 555                                    array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray);
 556     if (err != MPI_SUCCESS) {
 557         errs++;
 558         if (verbose) {
 559             fprintf(stderr,
 560                     "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs);
 561         }
 562         return errs;
 563     }
 564
 565     MPI_Type_commit(&subarray);
 566     MPI_Type_size(subarray, &sizeoftype);
 567     if (sizeoftype != 2 * sizeof(int)) {
 568         errs++;
 569         if (verbose)
 570             fprintf(stderr, "size of type = %d; should be %d\n",
 571                     sizeoftype, (int) (2 * sizeof(int)));
 572         return errs;
 573     }
 574
 575     err = pack_and_unpack((char *) array, 1, subarray, 12 * sizeof(int));
 576
 577     for (i = 0; i < 12; i++) {
 578         int goodval;
 579         switch (i) {
 580         case 4:
 581             goodval = 1;
 582             break;
 583         case 5:
 584             goodval = 2;
 585             break;
 586         default:
 587             goodval = 0;
 588             break;
 589         }
 590         if (array[i] != goodval) {
 591             errs++;
 592             if (verbose)
 593                 fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval);
 594         }
 595     }
 596
 597     MPI_Type_free(&subarray);
 598     return errs;
 599 }
 600
 601 /******************************************************************/
 602
 603 /* pack_and_unpack()
 604  *
 605  * Perform packing and unpacking of a buffer for the purposes of checking
 606  * to see if we are processing a type correctly.  Zeros the buffer between
 607  * these two operations, so the data described by the type should be in
 608  * place upon return but all other regions of the buffer should be zero.
 609  *
 610  * Parameters:
 611  * typebuf - pointer to buffer described by datatype and count that
 612  *           will be packed and then unpacked into
 613  * count, datatype - description of typebuf
 614  * typebufsz - size of typebuf; used specifically to zero the buffer
 615  *             between the pack and unpack steps
 616  *
 617  */
 618 static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz)
 619 {
 620     char *packbuf;
 621     int err, errs = 0, pack_size, type_size, position;
 622
 623     err = MPI_Type_size(datatype, &type_size);
 624     if (err != MPI_SUCCESS) {
 625         errs++;
 626         if (verbose) {
 627             fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs);
 628         }
 629         return errs;
 630     }
 631
 632     type_size *= count;
 633
 634     err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size);
 635     if (err != MPI_SUCCESS) {
 636         errs++;
 637         if (verbose) {
 638             fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs);
 639         }
 640         return errs;
 641     }
 642     packbuf = (char *) malloc(pack_size);
 643     if (packbuf == NULL) {
 644         errs++;
 645         if (verbose) {
 646             fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs);
 647         }
 648         return errs;
 649     }
 650
 651     position = 0;
 652     err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF);
 653
 654     if (position != type_size) {
 655         errs++;
 656         if (verbose)
 657             fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size);
 658     }
 659
 660     memset(typebuf, 0, typebufsz);
 661     position = 0;
 662     err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF);
 663     if (err != MPI_SUCCESS) {
 664         errs++;
 665         if (verbose) {
 666             fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs);
 667         }
 668         return errs;
 669     }
 670     free(packbuf);
 671
 672     if (position != type_size) {
 673         errs++;
 674         if (verbose)
 675             fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size);
 676     }
 677
 678     return errs;
 679 }
 680
 681 static int parse_args(int argc, char **argv)
 682 {
 683     /*
 684      * int ret;
 685      *
 686      * while ((ret = getopt(argc, argv, "v")) >= 0)
 687      * {
 688      * switch (ret) {
 689      * case 'v':
 690      * verbose = 1;
 691      * break;
 692      * }
 693      * }
 694      */
 695     if (argc > 1 && strcmp(argv[1], "-v") == 0)
 696         verbose = 1;
 697     return 0;
 698 }