teshsuite/smpi/mpich3-test/coll/opbxor.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *
   4  *  (C) 2003 by Argonne National Laboratory.
   5  *      See COPYRIGHT in top-level directory.
   6  */
   7 #include "mpi.h"
   8 #include "mpitestconf.h"
   9 #include <stdio.h>
  10 #include "mpitest.h"
  11
  12 /*
  13 static char MTEST_Descrip[] = "Test MPI_BXOR operations on optional datatypes dupported by MPICH";
  14 */
  15
  16 /*
  17  * This test looks at the handling of logical and for types that are not
  18  * integers or are not required integers (e.g., long long).  MPICH allows
  19  * these as well.  A strict MPI test should not include this test.
  20  */
  21 int main(int argc, char *argv[])
  22 {
  23     int errs = 0;
  24     int rc;
  25     int rank, size;
  26     MPI_Comm comm;
  27     char cinbuf[3], coutbuf[3];
  28     signed char scinbuf[3], scoutbuf[3];
  29     unsigned char ucinbuf[3], ucoutbuf[3];
  30     short sinbuf[3], soutbuf[3];
  31     unsigned short usinbuf[3], usoutbuf[3];
  32     long linbuf[3], loutbuf[3];
  33     unsigned long ulinbuf[3], uloutbuf[3];
  34     unsigned uinbuf[3], uoutbuf[3];
  35     int iinbuf[3], ioutbuf[3];
  36
  37
  38     MTest_Init(&argc, &argv);
  39
  40     comm = MPI_COMM_WORLD;
  41     /* Set errors return so that we can provide better information
  42      * should a routine reject one of the operand/datatype pairs */
  43     MPI_Errhandler_set(comm, MPI_ERRORS_RETURN);
  44
  45     MPI_Comm_rank(comm, &rank);
  46     MPI_Comm_size(comm, &size);
  47
  48 #ifndef USE_STRICT_MPI
  49     /* char */
  50     MTestPrintfMsg(10, "Reduce of MPI_CHAR\n");
  51     cinbuf[0] = 0xff;
  52     cinbuf[1] = 0;
  53     cinbuf[2] = (rank > 0) ? 0x3c : 0xc3;
  54
  55     coutbuf[0] = 0xf;
  56     coutbuf[1] = 1;
  57     coutbuf[2] = 1;
  58     rc = MPI_Reduce(cinbuf, coutbuf, 3, MPI_CHAR, MPI_BXOR, 0, comm);
  59     if (rc) {
  60         MTestPrintErrorMsg("MPI_BXOR and MPI_CHAR", rc);
  61         errs++;
  62     }
  63     else {
  64         if (rank == 0) {
  65             if (coutbuf[0] != ((size % 2) ? (char) 0xff : (char) 0)) {
  66                 errs++;
  67                 fprintf(stderr, "char BXOR(1) test failed\n");
  68             }
  69             if (coutbuf[1]) {
  70                 errs++;
  71                 fprintf(stderr, "char BXOR(0) test failed\n");
  72             }
  73             if (coutbuf[2] != ((size % 2) ? (char) 0xc3 : (char) 0xff)) {
  74                 errs++;
  75                 fprintf(stderr, "char BXOR(>) test failed\n");
  76             }
  77         }
  78     }
  79 #endif /* USE_STRICT_MPI */
  80
  81     /* signed char */
  82     MTestPrintfMsg(10, "Reduce of MPI_SIGNED_CHAR\n");
  83     scinbuf[0] = 0xff;
  84     scinbuf[1] = 0;
  85     scinbuf[2] = (rank > 0) ? 0x3c : 0xc3;
  86
  87     scoutbuf[0] = 0xf;
  88     scoutbuf[1] = 1;
  89     scoutbuf[2] = 1;
  90     rc = MPI_Reduce(scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_BXOR, 0, comm);
  91     if (rc) {
  92         MTestPrintErrorMsg("MPI_BXOR and MPI_SIGNED_CHAR", rc);
  93         errs++;
  94     }
  95     else {
  96         if (rank == 0) {
  97             if (scoutbuf[0] != ((size % 2) ? (signed char) 0xff : (signed char) 0)) {
  98                 errs++;
  99                 fprintf(stderr, "signed char BXOR(1) test failed\n");
 100             }
 101             if (scoutbuf[1]) {
 102                 errs++;
 103                 fprintf(stderr, "signed char BXOR(0) test failed\n");
 104             }
 105             if (scoutbuf[2] != ((size % 2) ? (signed char) 0xc3 : (signed char) 0xff)) {
 106                 errs++;
 107                 fprintf(stderr, "signed char BXOR(>) test failed\n");
 108             }
 109         }
 110     }
 111
 112     /* unsigned char */
 113     MTestPrintfMsg(10, "Reduce of MPI_UNSIGNED_CHAR\n");
 114     ucinbuf[0] = 0xff;
 115     ucinbuf[1] = 0;
 116     ucinbuf[2] = (rank > 0) ? 0x3c : 0xc3;
 117
 118     ucoutbuf[0] = 0;
 119     ucoutbuf[1] = 1;
 120     ucoutbuf[2] = 1;
 121     rc = MPI_Reduce(ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_BXOR, 0, comm);
 122     if (rc) {
 123         MTestPrintErrorMsg("MPI_BXOR and MPI_UNSIGNED_CHAR", rc);
 124         errs++;
 125     }
 126     else {
 127         if (rank == 0) {
 128             if (ucoutbuf[0] != ((size % 2) ? 0xff : 0)) {
 129                 errs++;
 130                 fprintf(stderr, "unsigned char BXOR(1) test failed\n");
 131             }
 132             if (ucoutbuf[1]) {
 133                 errs++;
 134                 fprintf(stderr, "unsigned char BXOR(0) test failed\n");
 135             }
 136             if (ucoutbuf[2] != ((size % 2) ? (unsigned char) 0xc3 : (unsigned char) 0xff)) {
 137                 errs++;
 138                 fprintf(stderr, "unsigned char BXOR(>) test failed\n");
 139             }
 140         }
 141     }
 142
 143     /* bytes */
 144     MTestPrintfMsg(10, "Reduce of MPI_BYTE\n");
 145     cinbuf[0] = 0xff;
 146     cinbuf[1] = 0;
 147     cinbuf[2] = (rank > 0) ? 0x3c : 0xc3;
 148
 149     coutbuf[0] = 0;
 150     coutbuf[1] = 1;
 151     coutbuf[2] = 1;
 152     rc = MPI_Reduce(cinbuf, coutbuf, 3, MPI_BYTE, MPI_BXOR, 0, comm);
 153     if (rc) {
 154         MTestPrintErrorMsg("MPI_BXOR and MPI_BYTE", rc);
 155         errs++;
 156     }
 157     else {
 158         if (rank == 0) {
 159             if (coutbuf[0] != ((size % 2) ? (char) 0xff : 0)) {
 160                 errs++;
 161                 fprintf(stderr, "byte BXOR(1) test failed\n");
 162             }
 163             if (coutbuf[1]) {
 164                 errs++;
 165                 fprintf(stderr, "byte BXOR(0) test failed\n");
 166             }
 167             if (coutbuf[2] != ((size % 2) ? (char) 0xc3 : (char) 0xff)) {
 168                 errs++;
 169                 fprintf(stderr, "byte BXOR(>) test failed\n");
 170             }
 171         }
 172     }
 173
 174     /* short */
 175     MTestPrintfMsg(10, "Reduce of MPI_SHORT\n");
 176     sinbuf[0] = 0xffff;
 177     sinbuf[1] = 0;
 178     sinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3;
 179
 180     soutbuf[0] = 0;
 181     soutbuf[1] = 1;
 182     soutbuf[2] = 1;
 183     rc = MPI_Reduce(sinbuf, soutbuf, 3, MPI_SHORT, MPI_BXOR, 0, comm);
 184     if (rc) {
 185         MTestPrintErrorMsg("MPI_BXOR and MPI_SHORT", rc);
 186         errs++;
 187     }
 188     else {
 189         if (rank == 0) {
 190             if (soutbuf[0] != ((size % 2) ? (short) 0xffff : 0)) {
 191                 errs++;
 192                 fprintf(stderr, "short BXOR(1) test failed\n");
 193             }
 194             if (soutbuf[1]) {
 195                 errs++;
 196                 fprintf(stderr, "short BXOR(0) test failed\n");
 197             }
 198             if (soutbuf[2] != ((size % 2) ? (short) 0xc3c3 : (short) 0xffff)) {
 199                 errs++;
 200                 fprintf(stderr, "short BXOR(>) test failed\n");
 201             }
 202         }
 203     }
 204
 205     /* unsigned short */
 206     MTestPrintfMsg(10, "Reduce of MPI_UNSIGNED_SHORT\n");
 207     usinbuf[0] = 0xffff;
 208     usinbuf[1] = 0;
 209     usinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3;
 210
 211     usoutbuf[0] = 0;
 212     usoutbuf[1] = 1;
 213     usoutbuf[2] = 1;
 214     rc = MPI_Reduce(usinbuf, usoutbuf, 3, MPI_UNSIGNED_SHORT, MPI_BXOR, 0, comm);
 215     if (rc) {
 216         MTestPrintErrorMsg("MPI_BXOR and MPI_UNSIGNED_SHORT", rc);
 217         errs++;
 218     }
 219     else {
 220         if (rank == 0) {
 221             if (usoutbuf[0] != ((size % 2) ? 0xffff : 0)) {
 222                 errs++;
 223                 fprintf(stderr, "short BXOR(1) test failed\n");
 224             }
 225             if (usoutbuf[1]) {
 226                 errs++;
 227                 fprintf(stderr, "short BXOR(0) test failed\n");
 228             }
 229             if (usoutbuf[2] != ((size % 2) ? 0xc3c3 : 0xffff)) {
 230                 errs++;
 231                 fprintf(stderr, "short BXOR(>) test failed\n");
 232             }
 233         }
 234     }
 235
 236     /* unsigned */
 237     MTestPrintfMsg(10, "Reduce of MPI_UNSIGNED\n");
 238     uinbuf[0] = 0xffffffff;
 239     uinbuf[1] = 0;
 240     uinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3;
 241
 242     uoutbuf[0] = 0;
 243     uoutbuf[1] = 1;
 244     uoutbuf[2] = 1;
 245     rc = MPI_Reduce(uinbuf, uoutbuf, 3, MPI_UNSIGNED, MPI_BXOR, 0, comm);
 246     if (rc) {
 247         MTestPrintErrorMsg("MPI_BXOR and MPI_UNSIGNED", rc);
 248         errs++;
 249     }
 250     else {
 251         if (rank == 0) {
 252             if (uoutbuf[0] != ((size % 2) ? 0xffffffff : 0)) {
 253                 errs++;
 254                 fprintf(stderr, "unsigned BXOR(1) test failed\n");
 255             }
 256             if (uoutbuf[1]) {
 257                 errs++;
 258                 fprintf(stderr, "unsigned BXOR(0) test failed\n");
 259             }
 260             if (uoutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) {
 261                 errs++;
 262                 fprintf(stderr, "unsigned BXOR(>) test failed\n");
 263             }
 264         }
 265     }
 266
 267     /* int */
 268     MTestPrintfMsg(10, "Reduce of MPI_INT\n");
 269     iinbuf[0] = 0xffffffff;
 270     iinbuf[1] = 0;
 271     iinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3;
 272
 273     ioutbuf[0] = 0;
 274     ioutbuf[1] = 1;
 275     ioutbuf[2] = 1;
 276     rc = MPI_Reduce(iinbuf, ioutbuf, 3, MPI_INT, MPI_BXOR, 0, comm);
 277     if (rc) {
 278         MTestPrintErrorMsg("MPI_BXOR and MPI_INT", rc);
 279         errs++;
 280     }
 281     else {
 282         if (rank == 0) {
 283             if (ioutbuf[0] != ((size % 2) ? 0xffffffff : 0)) {
 284                 errs++;
 285                 fprintf(stderr, "int BXOR(1) test failed\n");
 286             }
 287             if (ioutbuf[1]) {
 288                 errs++;
 289                 fprintf(stderr, "int BXOR(0) test failed\n");
 290             }
 291             if (ioutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) {
 292                 errs++;
 293                 fprintf(stderr, "int BXOR(>) test failed\n");
 294             }
 295         }
 296     }
 297
 298     /* long */
 299     MTestPrintfMsg(10, "Reduce of MPI_LONG\n");
 300     linbuf[0] = 0xffffffff;
 301     linbuf[1] = 0;
 302     linbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3;
 303
 304     loutbuf[0] = 0;
 305     loutbuf[1] = 1;
 306     loutbuf[2] = 1;
 307     rc = MPI_Reduce(linbuf, loutbuf, 3, MPI_LONG, MPI_BXOR, 0, comm);
 308     if (rc) {
 309         MTestPrintErrorMsg("MPI_BXOR and MPI_LONG", rc);
 310         errs++;
 311     }
 312     else {
 313         if (rank == 0) {
 314             if (loutbuf[0] != ((size % 2) ? 0xffffffff : 0)) {
 315                 errs++;
 316                 fprintf(stderr, "long BXOR(1) test failed\n");
 317             }
 318             if (loutbuf[1]) {
 319                 errs++;
 320                 fprintf(stderr, "long BXOR(0) test failed\n");
 321             }
 322             if (loutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) {
 323                 errs++;
 324                 fprintf(stderr, "long BXOR(>) test failed\n");
 325             }
 326         }
 327     }
 328
 329     /* unsigned long */
 330     MTestPrintfMsg(10, "Reduce of MPI_UNSIGNED_LONG\n");
 331     ulinbuf[0] = 0xffffffff;
 332     ulinbuf[1] = 0;
 333     ulinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3;
 334
 335     uloutbuf[0] = 0;
 336     uloutbuf[1] = 1;
 337     uloutbuf[2] = 1;
 338     rc = MPI_Reduce(ulinbuf, uloutbuf, 3, MPI_UNSIGNED_LONG, MPI_BXOR, 0, comm);
 339     if (rc) {
 340         MTestPrintErrorMsg("MPI_BXOR and MPI_UNSIGNED_LONG", rc);
 341         errs++;
 342     }
 343     else {
 344         if (rank == 0) {
 345             if (uloutbuf[0] != ((size % 2) ? 0xffffffff : 0)) {
 346                 errs++;
 347                 fprintf(stderr, "unsigned long BXOR(1) test failed\n");
 348             }
 349             if (uloutbuf[1]) {
 350                 errs++;
 351                 fprintf(stderr, "unsigned long BXOR(0) test failed\n");
 352             }
 353             if (uloutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) {
 354                 errs++;
 355                 fprintf(stderr, "unsigned long BXOR(>) test failed\n");
 356             }
 357         }
 358     }
 359
 360 #ifdef HAVE_LONG_LONG
 361     {
 362         long long llinbuf[3], lloutbuf[3];
 363         /* long long */
 364         llinbuf[0] = 0xffffffff;
 365         llinbuf[1] = 0;
 366         llinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3;
 367
 368         lloutbuf[0] = 0;
 369         lloutbuf[1] = 1;
 370         lloutbuf[2] = 1;
 371         if (MPI_LONG_LONG != MPI_DATATYPE_NULL) {
 372             MTestPrintfMsg(10, "Reduce of MPI_LONG_LONG\n");
 373             rc = MPI_Reduce(llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_BXOR, 0, comm);
 374             if (rc) {
 375                 MTestPrintErrorMsg("MPI_BXOR and MPI_LONG_LONG", rc);
 376                 errs++;
 377             }
 378             else {
 379                 if (rank == 0) {
 380                     if (lloutbuf[0] != ((size % 2) ? 0xffffffff : 0)) {
 381                         errs++;
 382                         fprintf(stderr, "long long BXOR(1) test failed\n");
 383                     }
 384                     if (lloutbuf[1]) {
 385                         errs++;
 386                         fprintf(stderr, "long long BXOR(0) test failed\n");
 387                     }
 388                     if (lloutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) {
 389                         errs++;
 390                         fprintf(stderr, "long long BXOR(>) test failed\n");
 391                     }
 392                 }
 393             }
 394         }
 395     }
 396 #endif
 397
 398     MPI_Errhandler_set(comm, MPI_ERRORS_ARE_FATAL);
 399     MTest_Finalize(errs);
 400     MPI_Finalize();
 401     return 0;
 402 }