--- /dev/null
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ * (C) 2001 by Argonne National Laboratory.
+ * See COPYRIGHT in top-level directory.
+ */
+#include "mpi.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "mpitestconf.h"
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+static int verbose = 0;
+
+/* tests */
+int blockindexed_contig_test(void);
+int blockindexed_vector_test(void);
+
+/* helper functions */
+int parse_args(int argc, char **argv);
+static int pack_and_unpack(char *typebuf,
+ int count,
+ MPI_Datatype datatype,
+ int typebufsz);
+
+int main(int argc, char **argv)
+{
+ int err, errs = 0;
+
+ MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */
+ parse_args(argc, argv);
+
+ /* To improve reporting of problems about operations, we
+ change the error handler to errors return */
+ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
+
+ /* perform some tests */
+ err = blockindexed_contig_test();
+ if (err && verbose) fprintf(stderr, "%d errors in blockindexed test.\n",
+ err);
+ errs += err;
+
+ err = blockindexed_vector_test();
+ if (err && verbose) fprintf(stderr, "%d errors in blockindexed vector test.\n",
+ err);
+ errs += err;
+
+ /* print message and exit */
+ if (errs) {
+ fprintf(stderr, "Found %d errors\n", errs);
+ }
+ else {
+ printf(" No Errors\n");
+ }
+ MPI_Finalize();
+ return 0;
+}
+
+/* blockindexed_contig_test()
+ *
+ * Tests behavior with a blockindexed that can be converted to a
+ * contig easily. This is specifically for coverage.
+ *
+ * Returns the number of errors encountered.
+ */
+int blockindexed_contig_test(void)
+{
+ int buf[4] = {7, -1, -2, -3};
+ int err, errs = 0;
+
+ int i, count = 1;
+ int disp = 0;
+ MPI_Datatype newtype;
+
+ int size, int_size;
+ MPI_Aint extent;
+
+ err = MPI_Type_create_indexed_block(count,
+ 1,
+ &disp,
+ MPI_INT,
+ &newtype);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error creating struct type in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ MPI_Type_size(MPI_INT, &int_size);
+
+ err = MPI_Type_size(newtype, &size);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error obtaining type size in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ if (size != int_size) {
+ if (verbose) {
+ fprintf(stderr,
+ "error: size != int_size in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ err = MPI_Type_extent(newtype, &extent);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error obtaining type extent in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ if (extent != int_size) {
+ if (verbose) {
+ fprintf(stderr,
+ "error: extent != int_size in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ MPI_Type_commit(&newtype);
+
+ err = pack_and_unpack((char *) buf, 1, newtype, 4 * sizeof(int));
+ if (err != 0) {
+ if (verbose) {
+ fprintf(stderr,
+ "error packing/unpacking in blockindexed_contig_test()\n");
+ }
+ errs += err;
+ }
+
+ for (i=0; i < 4; i++) {
+ int goodval;
+
+ switch(i) {
+ case 0:
+ goodval = 7;
+ break;
+ default:
+ goodval = 0; /* pack_and_unpack() zeros before unpack */
+ break;
+ }
+ if (buf[i] != goodval) {
+ errs++;
+ if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n",
+ i, buf[i], goodval);
+ }
+ }
+
+ MPI_Type_free( &newtype );
+
+ return errs;
+}
+
+/* blockindexed_vector_test()
+ *
+ * Tests behavior with a blockindexed of some vector types;
+ * this shouldn't be easily convertable into anything else.
+ *
+ * Returns the number of errors encountered.
+ */
+int blockindexed_vector_test(void)
+{
+#define NELT (18)
+ int buf[NELT] = { -1, -1, -1,
+ 1, -2, 2,
+ -3, -3, -3,
+ -4, -4, -4,
+ 3, -5, 4,
+ 5, -6, 6 };
+ int expected[NELT] = {
+ 0, 0, 0,
+ 1, 0, 2,
+ 0, 0, 0,
+ 0, 0, 0,
+ 3, 0, 4,
+ 5, 0, 6 };
+ int err, errs = 0;
+
+ int i, count = 3;
+ int disp[] = {1, 4, 5};
+ MPI_Datatype vectype, newtype;
+
+ int size, int_size;
+
+ /* create a vector type of 2 ints, skipping one in between */
+ err = MPI_Type_vector(2, 1, 2, MPI_INT, &vectype);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error creating vector type in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ err = MPI_Type_create_indexed_block(count,
+ 1,
+ disp,
+ vectype,
+ &newtype);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error creating blockindexed type in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ MPI_Type_size(MPI_INT, &int_size);
+
+ err = MPI_Type_size(newtype, &size);
+ if (err != MPI_SUCCESS) {
+ if (verbose) {
+ fprintf(stderr,
+ "error obtaining type size in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ if (size != 6 * int_size) {
+ if (verbose) {
+ fprintf(stderr,
+ "error: size != 6 * int_size in blockindexed_contig_test()\n");
+ }
+ errs++;
+ }
+
+ MPI_Type_commit(&newtype);
+
+ err = pack_and_unpack((char *) buf, 1, newtype, NELT * sizeof(int));
+ if (err != 0) {
+ if (verbose) {
+ fprintf(stderr,
+ "error packing/unpacking in blockindexed_vector_test()\n");
+ }
+ errs += err;
+ }
+
+ for (i=0; i < NELT; i++) {
+ if (buf[i] != expected[i]) {
+ errs++;
+ if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n",
+ i, buf[i], expected[i]);
+ }
+ }
+
+ MPI_Type_free( &vectype );
+ MPI_Type_free( &newtype );
+ return errs;
+}
+
+
+/* pack_and_unpack()
+ *
+ * Perform packing and unpacking of a buffer for the purposes of checking
+ * to see if we are processing a type correctly. Zeros the buffer between
+ * these two operations, so the data described by the type should be in
+ * place upon return but all other regions of the buffer should be zero.
+ *
+ * Parameters:
+ * typebuf - pointer to buffer described by datatype and count that
+ * will be packed and then unpacked into
+ * count, datatype - description of typebuf
+ * typebufsz - size of typebuf; used specifically to zero the buffer
+ * between the pack and unpack steps
+ *
+ */
+static int pack_and_unpack(char *typebuf,
+ int count,
+ MPI_Datatype datatype,
+ int typebufsz)
+{
+ char *packbuf;
+ int err, errs = 0, pack_size, type_size, position;
+
+ err = MPI_Type_size(datatype, &type_size);
+ if (err != MPI_SUCCESS) {
+ errs++;
+ if (verbose) {
+ fprintf(stderr,
+ "error in MPI_Type_size call; aborting after %d errors\n",
+ errs);
+ }
+ return errs;
+ }
+
+ type_size *= count;
+
+ err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size);
+ if (err != MPI_SUCCESS) {
+ errs++;
+ if (verbose) {
+ fprintf(stderr,
+ "error in MPI_Pack_size call; aborting after %d errors\n",
+ errs);
+ }
+ return errs;
+ }
+ packbuf = (char *) malloc(pack_size);
+ if (packbuf == NULL) {
+ errs++;
+ if (verbose) {
+ fprintf(stderr,
+ "error in malloc call; aborting after %d errors\n",
+ errs);
+ }
+ return errs;
+ }
+
+ position = 0;
+ err = MPI_Pack(typebuf,
+ count,
+ datatype,
+ packbuf,
+ type_size,
+ &position,
+ MPI_COMM_SELF);
+
+ if (position != type_size) {
+ errs++;
+ if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n",
+ position, type_size);
+ }
+
+ memset(typebuf, 0, typebufsz);
+ position = 0;
+ err = MPI_Unpack(packbuf,
+ type_size,
+ &position,
+ typebuf,
+ count,
+ datatype,
+ MPI_COMM_SELF);
+ if (err != MPI_SUCCESS) {
+ errs++;
+ if (verbose) {
+ fprintf(stderr,
+ "error in MPI_Unpack call; aborting after %d errors\n",
+ errs);
+ }
+ return errs;
+ }
+ free(packbuf);
+
+ if (position != type_size) {
+ errs++;
+ if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n",
+ position, type_size);
+ }
+
+ return errs;
+}
+
+int parse_args(int argc, char **argv)
+{
+ /*
+ int ret;
+
+ while ((ret = getopt(argc, argv, "v")) >= 0)
+ {
+ switch (ret) {
+ case 'v':
+ verbose = 1;
+ break;
+ }
+ }
+ */
+ if (argc > 1 && strcmp(argv[1], "-v") == 0)
+ verbose = 1;
+ return 0;
+}
+
