/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #include "dtpools.h" /* static char MTEST_Descrip[] = "Put with Post/Start/Complete/Wait"; */ typedef struct { const char *typename; MPI_Datatype type; } Type_t; Type_t typelist[] = { {"MPI_CHAR", MPI_CHAR}, {"MPI_BYTE", MPI_BYTE}, {"MPI_WCHAR", MPI_WCHAR}, {"MPI_SHORT", MPI_SHORT}, {"MPI_INT", MPI_INT}, {"MPI_LONG", MPI_LONG}, {"MPI_LONG_LONG_INT", MPI_LONG_LONG_INT}, {"MPI_UNSIGNED_CHAR", MPI_UNSIGNED_CHAR}, {"MPI_UNSIGNED_SHORT", MPI_UNSIGNED_SHORT}, {"MPI_UNSIGNED", MPI_UNSIGNED}, {"MPI_UNSIGNED_LONG", MPI_UNSIGNED_LONG}, {"MPI_UNSIGNED_LONG_LONG", MPI_UNSIGNED_LONG_LONG}, {"MPI_FLOAT", MPI_FLOAT}, {"MPI_DOUBLE", MPI_DOUBLE}, {"MPI_LONG_DOUBLE", MPI_LONG_DOUBLE}, {"MPI_INT8_T", MPI_INT8_T}, {"MPI_INT16_T", MPI_INT16_T}, {"MPI_INT32_T", MPI_INT32_T}, {"MPI_INT64_T", MPI_INT64_T}, {"MPI_UINT8_T", MPI_UINT8_T}, {"MPI_UINT16_T", MPI_UINT16_T}, {"MPI_UINT32_T", MPI_UINT32_T}, {"MPI_UINT64_T", MPI_UINT64_T}, {"MPI_C_COMPLEX", MPI_C_COMPLEX}, {"MPI_C_FLOAT_COMPLEX", MPI_C_FLOAT_COMPLEX}, {"MPI_C_DOUBLE_COMPLEX", MPI_C_DOUBLE_COMPLEX}, {"MPI_C_LONG_DOUBLE_COMPLEX", MPI_C_LONG_DOUBLE_COMPLEX}, {"MPI_FLOAT_INT", MPI_FLOAT_INT}, {"MPI_DOUBLE_INT", MPI_DOUBLE_INT}, {"MPI_LONG_INT", MPI_LONG_INT}, {"MPI_2INT", MPI_2INT}, {"MPI_SHORT_INT", MPI_SHORT_INT}, {"MPI_LONG_DOUBLE_INT", MPI_LONG_DOUBLE_INT}, {"MPI_DATATYPE_NULL", MPI_DATATYPE_NULL} }; int main(int argc, char *argv[]) { int errs = 0, err; int rank, size, orig, target; int minsize = 2, count; int i, j, len; MPI_Aint origcount, targetcount; MPI_Comm comm; MPI_Win win; MPI_Aint extent, lb; MPI_Group wingroup, neighbors; MPI_Datatype origtype, targettype; DTP_t orig_dtp, target_dtp; char orig_name[MPI_MAX_OBJECT_NAME] = { 0 }; char target_name[MPI_MAX_OBJECT_NAME] = { 0 }; void *origbuf, *targetbuf; MTest_Init(&argc, &argv); #ifndef USE_DTP_POOL_TYPE__STRUCT /* set in 'test/mpi/structtypetest.txt' to split tests */ MPI_Datatype basic_type; char type_name[MPI_MAX_OBJECT_NAME] = { 0 }; /* TODO: parse input parameters using optarg */ if (argc < 3) { fprintf(stdout, "Usage: %s -type=[TYPE] -count=[COUNT]\n", argv[0]); return MTestReturnValue(1); } else { for (i = 1; i < argc; i++) { if (!strncmp(argv[i], "-type=", strlen("-type="))) { j = 0; while (strcmp(typelist[j].typename, "MPI_DATATYPE_NULL") && strcmp(argv[i] + strlen("-type="), typelist[j].typename)) { j++; } if (strcmp(typelist[j].typename, "MPI_DATATYPE_NULL")) { basic_type = typelist[j].type; } else { fprintf(stdout, "Error: datatype not recognized\n"); return MTestReturnValue(1); } } else if (!strncmp(argv[i], "-count=", strlen("-count="))) { count = atoi(argv[i] + strlen("-count=")); /* TODO: make sure count is valid */ } } } err = DTP_pool_create(basic_type, count, &orig_dtp); if (err != DTP_SUCCESS) { MPI_Type_get_name(basic_type, type_name, &len); fprintf(stdout, "Error while creating orig pool (%s,%d)\n", type_name, count); fflush(stdout); } err = DTP_pool_create(basic_type, count, &target_dtp); if (err != DTP_SUCCESS) { MPI_Type_get_name(basic_type, type_name, &len); fprintf(stdout, "Error while creating target pool (%s,%d)\n", type_name, count); fflush(stdout); } #else MPI_Datatype *basic_types = NULL; int *basic_type_counts = NULL; int basic_type_num; int k; char *input_string, *token; /* TODO: parse input parameters using optarg */ if (argc < 4) { fprintf(stdout, "Usage: %s -numtypes=[NUM] -types=[TYPES] -counts=[COUNTS]\n", argv[0]); return MTestReturnValue(1); } else { for (i = 1; i < argc; i++) { if (!strncmp(argv[i], "-numtypes=", strlen("-numtypes="))) { basic_type_num = atoi(argv[i] + strlen("-numtypes=")); /* allocate arrays */ basic_type_counts = (int *) malloc(basic_type_num * sizeof(int)); basic_types = (MPI_Datatype *) malloc(basic_type_num * sizeof(MPI_Datatype)); } else if (!strncmp(argv[i], "-types=", strlen("-type="))) { input_string = strdup(argv[i] + strlen("-types=")); for (k = 0, token = strtok(input_string, ","); token; token = strtok(NULL, ",")) { j = 0; while (strcmp(typelist[j].typename, "MPI_DATATYPE_NULL") && strcmp(token, typelist[j].typename)) { j++; } if (strcmp(typelist[j].typename, "MPI_DATATYPE_NULL")) { basic_types[k++] = typelist[j].type; } else { fprintf(stdout, "Error: datatype not recognized\n"); return MTestReturnValue(1); } } free(input_string); } else if (!strncmp(argv[i], "-counts=", strlen("-counts="))) { input_string = strdup(argv[i] + strlen("-counts=")); for (k = 0, token = strtok(input_string, ","); token; token = strtok(NULL, ",")) { basic_type_counts[k++] = atoi(token); } free(input_string); } } } err = DTP_pool_create_struct(basic_type_num, basic_types, basic_type_counts, &orig_dtp); if (err != DTP_SUCCESS) { fprintf(stdout, "Error while creating struct pool\n"); fflush(stdout); } err = DTP_pool_create_struct(basic_type_num, basic_types, basic_type_counts, &target_dtp); if (err != DTP_SUCCESS) { fprintf(stdout, "Error while creating struct pool\n"); fflush(stdout); } /* this is ignored */ count = 0; #endif /* The following illustrates the use of the routines to * run through a selection of communicators and datatypes. * Use subsets of these for tests that do not involve combinations * of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral(&comm, minsize, 1)) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); orig = 0; target = size - 1; for (i = 0; i < target_dtp->DTP_num_objs; i++) { err = DTP_obj_create(target_dtp, i, 0, 0, 0); if (err != DTP_SUCCESS) { errs++; break; } targetcount = target_dtp->DTP_obj_array[i].DTP_obj_count; targettype = target_dtp->DTP_obj_array[i].DTP_obj_type; targetbuf = target_dtp->DTP_obj_array[i].DTP_obj_buf; MPI_Type_extent(targettype, &extent); MPI_Type_lb(targettype, &lb); MPI_Win_create(targetbuf, targetcount * extent + lb, (int) extent, MPI_INFO_NULL, comm, &win); MPI_Win_get_group(win, &wingroup); for (j = 0; j < orig_dtp->DTP_num_objs; j++) { err = DTP_obj_create(orig_dtp, j, 0, 1, count); if (err != DTP_SUCCESS) { errs++; break; } origcount = orig_dtp->DTP_obj_array[j].DTP_obj_count; origtype = orig_dtp->DTP_obj_array[j].DTP_obj_type; origbuf = orig_dtp->DTP_obj_array[j].DTP_obj_buf; /* To improve reporting of problems about operations, we * change the error handler to errors return */ MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN); if (rank == orig) { /* Neighbor is target only */ MPI_Group_incl(wingroup, 1, &target, &neighbors); err = MPI_Win_start(neighbors, 0, win); if (err) { errs++; if (errs < 10) { MTestPrintError(err); } } MPI_Group_free(&neighbors); err = MPI_Put(origbuf, origcount, origtype, target, 0, targetcount, targettype, win); if (err) { errs++; MTestPrintError(err); } err = MPI_Win_complete(win); if (err) { errs++; if (errs < 10) { MTestPrintError(err); } } } else if (rank == target) { MPI_Group_incl(wingroup, 1, &orig, &neighbors); MPI_Win_post(neighbors, 0, win); MPI_Group_free(&neighbors); MPI_Win_wait(win); /* This should have the same effect, in terms of * transfering data, as a send/recv pair */ err = DTP_obj_buf_check(target_dtp, i, 0, 1, count); if (err != DTP_SUCCESS) { errs++; if (errs < 10) { MPI_Type_get_name(origtype, orig_name, &len); MPI_Type_get_name(targettype, target_name, &len); fprintf(stdout, "Data received with type %s does not match data sent with type %s\n", target_name, orig_name); fflush(stdout); } } } else { /* Nothing; the other processes need not call any * MPI routines */ ; } DTP_obj_free(orig_dtp, j); } MPI_Win_free(&win); MPI_Group_free(&wingroup); DTP_obj_free(target_dtp, i); } MTestFreeComm(&comm); } DTP_pool_free(orig_dtp); DTP_pool_free(target_dtp); #ifdef USE_DTP_POOL_TYPE__STRUCT /* cleanup array if any */ if (basic_types) { free(basic_types); } if (basic_type_counts) { free(basic_type_counts); } #endif MTest_Finalize(errs); return MTestReturnValue(errs); }