subarray-pack.c

fortran并行计算包

/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */
#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int verbose = 0;

/* tests */
int subarray_1d_c_test1(void);
int subarray_1d_fortran_test1(void);
int subarray_2d_c_test1(void);
int subarray_4d_c_test1(void);
int subarray_2d_c_test2(void);
int subarray_2d_fortran_test1(void);
int subarray_4d_fortran_test1(void);

/* helper functions */
static 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 = subarray_1d_c_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 1d subarray c test 1.\n", err);
    errs += err;

    err = subarray_1d_fortran_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 1d subarray fortran test 1.\n",
				err);
    errs += err;

    err = subarray_2d_c_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 2d subarray c test 1.\n", err);
    errs += err;

    err = subarray_2d_fortran_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 2d subarray fortran test 1.\n",
				err);
    errs += err;

    err = subarray_2d_c_test2();
    if (err && verbose) fprintf(stderr,
				"%d errors in 2d subarray c test 2.\n", err);
    errs += err;

    err = subarray_4d_c_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 4d subarray c test 1.\n", err);
    errs += err;

    err = subarray_4d_fortran_test1();
    if (err && verbose) fprintf(stderr,
				"%d errors in 4d subarray fortran test 1.\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;
}

/* subarray_1d_c_test1()
 *
 * Returns the number of errors encountered.
 */
int subarray_1d_c_test1(void)
{
    MPI_Datatype subarray;
    int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 };
    int array_size[] = {9};
    int array_subsize[] = {3};
    int array_start[] = {1};

    int i, err, errs = 0, sizeoftype;

    /* set up type */
    err = MPI_Type_create_subarray(1, /* dims */
				   array_size,
				   array_subsize,
				   array_start,
				   MPI_ORDER_C,
				   MPI_INT,
				   &subarray);
    if (err != MPI_SUCCESS) {
	errs++;
	if (verbose) {
	    fprintf(stderr,
		    "error in MPI_Type_create_subarray call; aborting after %d errors\n",
		    errs);
	}
	return errs;
    }

    MPI_Type_commit(&subarray);
    MPI_Type_size(subarray, &sizeoftype);
    if (sizeoftype != 3 * sizeof(int)) {
	errs++;
	if (verbose) fprintf(stderr, "size of type = %d; should be %d\n",
			     sizeoftype, (int) (3 * sizeof(int)));
	return errs;
    }

    err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int));

    for (i=0; i < 9; i++) {
	int goodval;
	switch (i) {
	    case 1:
		goodval = 1;
		break;
	    case 2:
		goodval = 2;
		break;
	    case 3:
		goodval = 3;
		break;
	    default:
		goodval = 0; /* pack_and_unpack() zeros before unpacking */
		break;
	}
	if (array[i] != goodval) {
	    errs++;
	    if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n",
				 i, array[i], goodval);
	}
    }

    MPI_Type_free(&subarray);
    return errs;
}

/* subarray_1d_fortran_test1()
 *
 * Returns the number of errors encountered.
 */
int subarray_1d_fortran_test1(void)
{
    MPI_Datatype subarray;
    int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 };
    int array_size[] = {9};
    int array_subsize[] = {3};
    int array_start[] = {1};

    int i, err, errs = 0, sizeoftype;

    /* set up type */
    err = MPI_Type_create_subarray(1, /* dims */
				   array_size,
				   array_subsize,
				   array_start,
				   MPI_ORDER_FORTRAN,
				   MPI_INT,
				   &subarray);
    if (err != MPI_SUCCESS) {
	errs++;
	if (verbose) {
	    fprintf(stderr,
		    "error in MPI_Type_create_subarray call; aborting after %d errors\n",
		    errs);
	}
	return errs;
    }

    MPI_Type_commit(&subarray);
    MPI_Type_size(subarray, &sizeoftype);
    if (sizeoftype != 3 * sizeof(int)) {
	errs++;
	if (verbose) fprintf(stderr, "size of type = %d; should be %d\n",
			     sizeoftype, (int) (3 * sizeof(int)));
	return errs;
    }

    err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int));

    for (i=0; i < 9; i++) {
	int goodval;
	switch (i) {
	    case 1:
		goodval = 1;
		break;
	    case 2:
		goodval = 2;
		break;
	    case 3:
		goodval = 3;
		break;
	    default:
		goodval = 0; /* pack_and_unpack() zeros before unpacking */
		break;
	}
	if (array[i] != goodval) {
	    errs++;
	    if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n",
				 i, array[i], goodval);
	}
    }

    MPI_Type_free(&subarray);
    return errs;
}


/* subarray_2d_test()
 *
 * Returns the number of errors encountered.
 */
int subarray_2d_c_test1(void)
{
    MPI_Datatype subarray;
    int array[9] = { -1, -2, -3,
		     -4,  1,  2,
		     -5,  3,  4 };
    int array_size[2] = {3, 3};
    int array_subsize[2] = {2, 2};
    int array_start[2] = {1, 1};

    int i, err, errs = 0, sizeoftype;

    /* set up type */
    err = MPI_Type_create_subarray(2, /* dims */
				   array_size,
				   array_subsize,
				   array_start,
				   MPI_ORDER_C,
				   MPI_INT,
				   &subarray);
    if (err != MPI_SUCCESS) {
	errs++;
	if (verbose) {
	    fprintf(stderr,
		    "error in MPI_Type_create_subarray call; aborting after %d errors\n",
		    errs);
	}
	return errs;
    }

    MPI_Type_commit(&subarray);
    MPI_Type_size(subarray, &sizeoftype);
    if (sizeoftype != 4*sizeof(int)) {
	errs++;
	if (verbose) fprintf(stderr, "size of type = %d; should be %d\n",
			     sizeoftype, (int) (4*sizeof(int)));
	return errs;
    }

    err = pack_and_unpack((char *) array, 1, subarray, 9*sizeof(int));

    for (i=0; i < 9; i++) {
	int goodval;
	switch (i) {
	    case 4:
		goodval = 1;
		break;
	    case 5:
		goodval = 2;
		break;
	    case 7:
		goodval = 3;
		break;
	    case 8:
		goodval = 4;
		break;
	    default:
		goodval = 0;
		break;
	}
	if (array[i] != goodval) {
	    errs++;
	    if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n",
				 i, array[i], goodval);
	}
    }

    MPI_Type_free(&subarray);
    return errs;
}

/* subarray_2d_c_test2()
 *
 * Returns the number of errors encountered.
 */
int subarray_2d_c_test2(void)
{
    MPI_Datatype subarray;
    int array[12] = { -1, -2, -3, -4,  1,   2,
		      -5, -6, -7, -8, -9, -10 };
    int array_size[2] = {2, 6};
    int array_subsize[2] = {1, 2};
    int array_start[2] = {0, 4};

    int i, err, errs = 0, sizeoftype;

    /* set up type */
    err = MPI_Type_create_subarray(2, /* dims */
				   array_size,
				   array_subsize,
				   array_start,
				   MPI_ORDER_C,
				   MPI_INT,
				   &subarray);
    if (err != MPI_SUCCESS) {
	errs++;
	if (verbose) {
	    fprintf(stderr,
		    "error in MPI_Type_create_subarray call; aborting after %d errors\n",
		    errs);
	}
	return errs;
    }

    MPI_Type_commit(&subarray);
    MPI_Type_size(subarray, &sizeoftype);
    if (sizeoftype != 2*sizeof(int)) {
	errs++;
	if (verbose) fprintf(stderr, "size of type = %d; should be %d\n",
			     sizeoftype, (int) (2*sizeof(int)));
	return errs;
    }

    err = pack_and_unpack((char *) array, 1, subarray, 12*sizeof(int));

    for (i=0; i < 12; i++) {
	int goodval;
	switch (i) {
	    case 4:
		goodval = 1;
		break;
	    case 5:
		goodval = 2;
		break;
	    default:
		goodval = 0;
		break;
	}
	if (array[i] != goodval) {
	    errs++;
	    if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n",
				 i, array[i], goodval);
	}
    }

    MPI_Type_free(&subarray);
    return errs;
}

/* subarray_4d_c_test1()
 *
 * Returns the number of errors encountered.