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