[mpich-commits] [mpich] MPICH primary repository branch, master, updated. v3.1.1-90-g5b67454
Service Account
noreply at mpich.org
Mon Jul 14 13:16:36 CDT 2014
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "MPICH primary repository".
The branch, master has been updated
via 5b674543acfc345abd174577761a35651c740d69 (commit)
via 817ed6b79c29a3d4efba016f2d16fdaac3947e58 (commit)
via 9371bd4a6d167e5ea14f468b0bb993e7ac3ad6d7 (commit)
via e598963c31f2175ace9ba0c2341a83d6828f4c43 (commit)
via dde707c81aeff82f4b7318953797bea9b62b34aa (commit)
via 46642f9a9cb787d2118cc15fc1268bfb83ec655f (commit)
from 5d444444734834f65927e473ba559d026a83b449 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.mpich.org/mpich.git/commitdiff/5b674543acfc345abd174577761a35651c740d69
commit 5b674543acfc345abd174577761a35651c740d69
Author: Rob Latham <robl at mcs.anl.gov>
Date: Fri Jul 11 04:59:26 2014 -0500
ROMIO: some platforms unhappy when passed 2 GiB counts
On FreeBSD and Darwin, the read and write system calls think 2147483648 (2^31:
larger than a signed 32 bit integer can hold) is an invalid amount of data.
Maybe, despite taking a size_t parameter, something internally treats the count
as an int. Fine, we'll take measures to never write more than 2^31-1 bytes.
Signed-off-by: Ken Raffenetti <raffenet at mcs.anl.gov>
diff --git a/src/mpi/romio/adio/common/ad_read.c b/src/mpi/romio/adio/common/ad_read.c
index b03f69b..544ccf4 100644
--- a/src/mpi/romio/adio/common/ad_read.c
+++ b/src/mpi/romio/adio/common/ad_read.c
@@ -21,6 +21,10 @@
# include "adio/ad_gpfs/ad_gpfs_tuning.h"
#endif
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
void ADIOI_GEN_ReadContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status,
@@ -59,6 +63,10 @@ void ADIOI_GEN_ReadContig(ADIO_File fd, void *buf, int count,
MPE_Log_event( ADIOI_MPE_read_a, 0, NULL );
#endif
rd_count = len - bytes_xfered;
+ /* stupid FreeBSD and Darwin do not like a count larger than a signed
+ int, even though size_t is eight bytes... */
+ if (rd_count > INT_MAX)
+ rd_count = INT_MAX;
#ifdef ROMIO_GPFS
if (gpfsmpio_devnullio)
err = pread(fd->null_fd, p, rd_count, offset+bytes_xfered);
diff --git a/src/mpi/romio/adio/common/ad_write.c b/src/mpi/romio/adio/common/ad_write.c
index 129cb1c..ad318e4 100644
--- a/src/mpi/romio/adio/common/ad_write.c
+++ b/src/mpi/romio/adio/common/ad_write.c
@@ -22,6 +22,10 @@
#include "adio/ad_gpfs/ad_gpfs_tuning.h"
#endif
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
void ADIOI_GEN_WriteContig(ADIO_File fd, const void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
@@ -62,6 +66,10 @@ void ADIOI_GEN_WriteContig(ADIO_File fd, const void *buf, int count,
MPE_Log_event( ADIOI_MPE_write_a, 0, NULL );
#endif
wr_count = len - bytes_xfered;
+ /* Frustrating! FreeBSD and OS X do not like a count larger than 2^31 */
+ if (wr_count > INT_MAX)
+ wr_count = INT_MAX;
+
#ifdef ROMIO_GPFS
if (gpfsmpio_devnullio)
err = pwrite(fd->null_fd, p, wr_count, offset+bytes_xfered);
http://git.mpich.org/mpich.git/commitdiff/817ed6b79c29a3d4efba016f2d16fdaac3947e58
commit 817ed6b79c29a3d4efba016f2d16fdaac3947e58
Author: Mohamad Chaarawi <chaarawi at hdfgroup.org>
Date: Fri Jul 11 04:54:59 2014 -0500
ROMIO: big-datatypes: Update overly conservative assertion
Commit [e527fa1d] missed an update to an assertion in the read path: with
bufcount promoted to MPI_Count, making sure it does not overflow an
'unsigned' is incorrect.
Signed-off-by: Rob Latham <robl at mcs.anl.gov>
diff --git a/src/mpi/romio/adio/common/ad_read_str.c b/src/mpi/romio/adio/common/ad_read_str.c
index a9be2ae..bec361b 100644
--- a/src/mpi/romio/adio/common/ad_read_str.c
+++ b/src/mpi/romio/adio/common/ad_read_str.c
@@ -99,7 +99,7 @@ void ADIOI_GEN_ReadStrided(ADIO_File fd, void *buf, int count,
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
- ADIOI_Assert((buftype_size * count) == ((ADIO_Offset)(unsigned)buftype_size * (ADIO_Offset)count));
+ ADIOI_Assert((buftype_size * count) == ((ADIO_Offset)(MPI_Count)buftype_size * (ADIO_Offset)count));
bufsize = buftype_size * count;
/* get max_bufsize from the info object. */
diff --git a/src/mpi/romio/adio/common/ad_write_str.c b/src/mpi/romio/adio/common/ad_write_str.c
index cbf7cbc..f3b6c89 100644
--- a/src/mpi/romio/adio/common/ad_write_str.c
+++ b/src/mpi/romio/adio/common/ad_write_str.c
@@ -169,7 +169,7 @@ void ADIOI_GEN_WriteStrided(ADIO_File fd, const void *buf, int count,
MPI_Type_extent(datatype, &buftype_extent);
etype_size = fd->etype_size;
- ADIOI_Assert((buftype_size * count) == ((ADIO_Offset)buftype_size * (ADIO_Offset)count));
+ ADIOI_Assert((buftype_size * count) == ((MPI_Count)buftype_size * (ADIO_Offset)count));
bufsize = buftype_size * count;
/* get max_bufsize from the info object. */
http://git.mpich.org/mpich.git/commitdiff/9371bd4a6d167e5ea14f468b0bb993e7ac3ad6d7
commit 9371bd4a6d167e5ea14f468b0bb993e7ac3ad6d7
Author: Rob Latham <robl at mcs.anl.gov>
Date: Thu Jul 10 15:27:19 2014 -0500
test for RMA with "struct of struct"
Testcase for "RMA fails with derived type containing struct of struct"
See #2115
diff --git a/test/mpi/datatype/Makefile.am b/test/mpi/datatype/Makefile.am
index 03c13b5..b19321a 100644
--- a/test/mpi/datatype/Makefile.am
+++ b/test/mpi/datatype/Makefile.am
@@ -79,7 +79,8 @@ noinst_PROGRAMS = \
unusual-noncontigs \
vecblklen \
zeroblks \
- zeroparms
+ zeroparms \
+ get-struct
# Some of the tests use a more comprehensive set of datatype tests.
# These must specify a different LDADD that includes the object file
diff --git a/test/mpi/datatype/get-struct.c b/test/mpi/datatype/get-struct.c
new file mode 100644
index 0000000..8970008
--- /dev/null
+++ b/test/mpi/datatype/get-struct.c
@@ -0,0 +1,171 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ * (C) 2014 by Argonne National Laboratory.
+ * See COPYRIGHT in top-level directory.
+ */
+#include "mpi.h"
+#include "mpitest.h"
+#include <stdio.h>
+#include <string.h>
+
+/* Communicating a datatype built out of structs
+ * This test was motivated by the failure of an example program for
+ * RMA involving simple operations on a struct that included a struct
+ *
+ * The observed failure was a SEGV in the MPI_Get
+ *
+ *
+ */
+#define MAX_KEY_SIZE 64
+#define MAX_VALUE_SIZE 256
+typedef struct {
+ MPI_Aint disp;
+ int rank;
+ void *lptr;
+} Rptr;
+typedef struct {
+ Rptr next;
+ char key[MAX_KEY_SIZE], value[MAX_VALUE_SIZE];
+} ListElm;
+Rptr nullDptr = {0,-1,0};
+
+int testCases = -1;
+#define BYTE_ONLY 0x1
+#define TWO_STRUCT 0x2
+int isOneLevel = 0;
+
+int main(int argc, char **argv)
+{
+ int errors=0;
+ Rptr headDptr;
+ ListElm *headLptr=0;
+ int i, wrank;
+ MPI_Datatype dptrType, listelmType;
+ MPI_Win listwin;
+
+ MTest_Init(&argc, &argv);
+ MPI_Comm_rank(MPI_COMM_WORLD,&wrank);
+
+ for (i=1; i<argc; i++) {
+ if (strcmp(argv[i], "-byteonly") == 0) {
+ testCases = BYTE_ONLY;
+ }
+ else if (strcmp(argv[i], "-twostruct") == 0) {
+ testCases = TWO_STRUCT;
+ }
+ else if (strcmp(argv[i], "-onelevel") == 0) {
+ isOneLevel = 1;
+ }
+ else {
+ printf("Unrecognized argument %s\n", argv[i] );
+ }
+ }
+
+ /* Create the datatypes that we will use to move the data */
+ {
+ int blens[3];
+ MPI_Aint displ[3];
+ MPI_Datatype dtypes[3];
+ ListElm sampleElm;
+
+ blens[0] = 1; blens[1] = 1;
+ MPI_Get_address( &nullDptr.disp, &displ[0] );
+ MPI_Get_address( &nullDptr.rank, &displ[1] );
+ displ[1] = displ[1] - displ[0];
+ displ[0] = 0;
+ dtypes[0] = MPI_AINT;
+ dtypes[1] = MPI_INT;
+ MPI_Type_create_struct(2, blens, displ, dtypes, &dptrType);
+ MPI_Type_commit(&dptrType);
+
+ if (isOneLevel) {
+ blens[0] = sizeof(nullDptr); dtypes[0] = MPI_BYTE;
+ }
+ else {
+ blens[0] = 1; dtypes[0] = dptrType;
+ }
+ blens[1] = MAX_KEY_SIZE; dtypes[1] = MPI_CHAR;
+ blens[2] = MAX_VALUE_SIZE; dtypes[2] = MPI_CHAR;
+ MPI_Get_address(&sampleElm.next,&displ[0]);
+ MPI_Get_address(&sampleElm.key[0],&displ[1]);
+ MPI_Get_address(&sampleElm.value[0],&displ[2]);
+ displ[2] -= displ[0];
+ displ[1] -= displ[0];
+ displ[0] = 0;
+ for (i=0; i<3; i++) {
+ MTestPrintfMsg(0,"%d:count=%d,disp=%ld\n",i, blens[i], displ[i]);
+ }
+ MPI_Type_create_struct(3, blens, displ, dtypes, &listelmType);
+ MPI_Type_commit(&listelmType);
+ }
+
+ MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &listwin);
+
+ headDptr.rank = 0;
+ if (wrank == 0) {
+ /* Create 1 list element (the head) and initialize it */
+ MPI_Alloc_mem(sizeof(ListElm), MPI_INFO_NULL, &headLptr);
+ MPI_Get_address(headLptr, &headDptr.disp);
+ headLptr->next.rank = -1;
+ headLptr->next.disp = (MPI_Aint)MPI_BOTTOM;
+ headLptr->next.lptr = 0;
+ strncpy(headLptr->key,"key1",MAX_KEY_SIZE);
+ strncpy(headLptr->value,"value1",MAX_VALUE_SIZE);
+ MPI_Win_attach(listwin, headLptr, sizeof(ListElm));
+ }
+ MPI_Bcast(&headDptr.disp, 1, MPI_AINT, 0, MPI_COMM_WORLD);
+
+ MPI_Barrier(MPI_COMM_WORLD);
+
+ if (wrank == 1) {
+ ListElm headcopy;
+
+ MPI_Win_lock_all(0, listwin);
+ /* Get head element with simple get of BYTES */
+ if (testCases & BYTE_ONLY) {
+ headcopy.next.rank=100;
+ headcopy.next.disp=0xefefefef;
+ MPI_Get(&headcopy, sizeof(ListElm), MPI_BYTE,
+ headDptr.rank, headDptr.disp,
+ sizeof(ListElm), MPI_BYTE, listwin);
+ MPI_Win_flush(headDptr.rank, listwin);
+ if (headcopy.next.rank != -1 &&
+ headcopy.next.disp != (MPI_Aint)MPI_BOTTOM) {
+ errors++;
+ printf("MPI_BYTE: headcopy contains incorrect next:<%d,%ld>\n",
+ headcopy.next.rank, (long)headcopy.next.disp);
+ }
+ }
+
+ if (testCases & TWO_STRUCT) {
+ headcopy.next.rank=100;
+ headcopy.next.disp=0xefefefef;
+ /* Get head element using struct of struct type. This is
+ not an identical get to the simple BYTE one above but should
+ work */
+ MPI_Get(&headcopy, 1, listelmType, headDptr.rank, headDptr.disp,
+ 1, listelmType, listwin);
+ MPI_Win_flush(headDptr.rank, listwin);
+ if (headcopy.next.rank != -1 &&
+ headcopy.next.disp != (MPI_Aint)MPI_BOTTOM) {
+ errors++;
+ printf("ListelmType: headcopy contains incorrect next:<%d,%ld>\n",
+ headcopy.next.rank, (long)headcopy.next.disp);
+ }
+ }
+
+ MPI_Win_unlock_all(listwin);
+ }
+ MPI_Barrier(MPI_COMM_WORLD);
+ if (wrank == 0) {
+ MPI_Win_detach(listwin,headLptr);
+ MPI_Free_mem(headLptr);
+ }
+ MPI_Win_free(&listwin);
+ MPI_Type_free(&dptrType);
+ MPI_Type_free(&listelmType);
+
+ MTest_Finalize( errors );
+ MPI_Finalize();
+ return MTestReturnValue( errors );
+}
diff --git a/test/mpi/datatype/testlist.in b/test/mpi/datatype/testlist.in
index 549c3eb..b2875b2 100644
--- a/test/mpi/datatype/testlist.in
+++ b/test/mpi/datatype/testlist.in
@@ -59,3 +59,4 @@ cxx-types 1 mpiversion=3.0
@largetest at large_type 1 mpiversion=3.0
@largetest at large_type_sendrec 2 arg=31 mpiversion=3.0
@largetest at large_type_sendrec 2 arg=32 mpiversion=3.0 timeLimit=360
+get-struct 2
http://git.mpich.org/mpich.git/commitdiff/e598963c31f2175ace9ba0c2341a83d6828f4c43
commit e598963c31f2175ace9ba0c2341a83d6828f4c43
Author: Rob Latham <robl at mcs.anl.gov>
Date: Wed Jul 9 12:36:05 2014 -0500
constify string handling
declare "handle_error" with a const string to make compiler happy
diff --git a/src/mpi/romio/test/misc.c.in b/src/mpi/romio/test/misc.c.in
index 6ff0e9b..5fad396 100644
--- a/src/mpi/romio/test/misc.c.in
+++ b/src/mpi/romio/test/misc.c.in
@@ -11,9 +11,7 @@
/* tests various miscellaneous functions. */
#define VERBOSE 0
-void handle_error(int errcode, char *str);
-
-void handle_error(int errcode, char *str)
+static void handle_error(int errcode, const char *str)
{
char msg[MPI_MAX_ERROR_STRING];
int resultlen;
http://git.mpich.org/mpich.git/commitdiff/dde707c81aeff82f4b7318953797bea9b62b34aa
commit dde707c81aeff82f4b7318953797bea9b62b34aa
Author: Rob Latham <robl at mcs.anl.gov>
Date: Wed Jul 9 14:24:05 2014 -0500
additional test case for large datatype i/o
diff --git a/test/mpi/io/Makefile.am b/test/mpi/io/Makefile.am
index 31e6c87..12dd69d 100644
--- a/test/mpi/io/Makefile.am
+++ b/test/mpi/io/Makefile.am
@@ -23,7 +23,8 @@ noinst_PROGRAMS = \
async_any \
userioerr \
resized \
- resized2
+ resized2 \
+ bigtype
clean-local:
-rm -f testfile testfile.*
diff --git a/test/mpi/io/bigtype.c b/test/mpi/io/bigtype.c
new file mode 100644
index 0000000..571a0a3
--- /dev/null
+++ b/test/mpi/io/bigtype.c
@@ -0,0 +1,137 @@
+#include <mpi.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <assert.h>
+
+//#define NUM_X 536870911
+#define NUM_X 536870912
+#define NUM_Y 1
+
+//#define BIGDT 2147483643
+#define BIGDT 2147483647
+
+int main(int argc, char** argv)
+{
+
+ MPI_File fh;
+ int i, j;
+ size_t k;
+ MPI_Datatype inner_type, rem_type, mem_type;
+ MPI_Datatype int_type, file_type;
+ int *buf_write, *buf_read;
+ int rc;
+ MPI_Aint disp[2];
+ int block_len[2];
+ MPI_Datatype type[2];
+
+ MPI_Init (&argc, &argv);
+
+ if (sizeof(MPI_Aint) <= sizeof(int)) {
+ /* can't test on this platform... */
+ goto exit;
+ }
+
+ k = 0;
+ /* create a large buffer 2*/
+ buf_write = malloc (NUM_X*NUM_Y*sizeof(int));
+ buf_read = malloc (NUM_X*NUM_Y*sizeof(int));
+ memset(buf_read, 0, NUM_X*NUM_Y*sizeof(int));
+
+ for (i=0; i<NUM_X ; i++) {
+ for (j=0 ; j<NUM_Y ; j++) {
+ buf_write[k] = k;
+ k++;
+ }
+ }
+
+ /* Big Datatype (2^31 - 1 bytes) */
+ MPI_Type_contiguous (BIGDT, MPI_BYTE, &inner_type);
+ /* Small Datatype (1 byte) */
+ MPI_Type_contiguous (1, MPI_BYTE, &rem_type);
+
+ type[0] = inner_type;
+ type[1] = rem_type;
+ block_len[0] = 1;
+ block_len[1] = 1;
+ disp[0] = 0;
+ disp[1] = BIGDT;
+
+ /* combine both types*/
+ MPI_Type_struct(2, block_len, disp, type, &mem_type);
+
+ MPI_Type_commit(&mem_type);
+ MPI_Type_free(&rem_type);
+ MPI_Type_free(&inner_type);
+
+ MPI_Type_contiguous (4, MPI_BYTE, &int_type);
+ {
+ /* This creates a big type that is actually contituous, touching an
+ * optimization that was at one point buggy */
+ MPI_Type_vector(1, NUM_X, 1, int_type, &file_type);
+ }
+
+ MPI_Type_commit(&file_type);
+ MPI_Type_free(&int_type);
+
+ if(MPI_File_open (MPI_COMM_WORLD, "testfile", MPI_MODE_RDWR | MPI_MODE_CREATE,
+ MPI_INFO_NULL, &fh) != 0) {
+ printf("Can't open file: %s\n","testfile");
+ exit(1);
+ }
+
+ if (MPI_SUCCESS != MPI_File_set_view(fh, 2144, MPI_BYTE,
+ file_type, "native", MPI_INFO_NULL)) {
+ printf ("ERROR SET VIEW\n");
+ exit(1);
+ }
+
+ /* write everything */
+ rc = MPI_File_write_at_all (fh,
+ 0,
+ buf_write,
+ 1,
+ mem_type,
+ MPI_STATUS_IGNORE);
+ if (rc != MPI_SUCCESS){
+ printf ("%d ERROR WRITE AT ALL\n", rc);
+ exit(1);
+ }
+
+ if (MPI_SUCCESS != MPI_File_set_view(fh, 2144, MPI_BYTE,
+ file_type, "native", MPI_INFO_NULL)) {
+ printf ("ERROR SET VIEW\n");
+ exit(1);
+ }
+
+ /* read everything */
+ rc = MPI_File_read_at_all (fh,
+ 0,
+ buf_read,
+ 1,
+ mem_type,
+ MPI_STATUS_IGNORE);
+ if (rc != MPI_SUCCESS) {
+ printf ("%d ERROR READ AT ALL\n", rc);
+ exit(1);
+ }
+
+ for (k=0 ; k<NUM_X*NUM_Y ; k++) {
+ if(buf_read[k] != buf_write[k]) {
+ fprintf(stderr, "Verfiy Failed at index %zu\n", k);
+ assert(0);
+ }
+ }
+
+ MPI_File_close(&fh);
+
+ MPI_Type_free (&mem_type);
+ MPI_Type_free(&file_type);
+
+exit:
+ MPI_Finalize ();
+ printf(" No Errors\n");
+
+ return 0;
+}
diff --git a/test/mpi/io/testlist b/test/mpi/io/testlist
index dfad3f0..6dfaafb 100644
--- a/test/mpi/io/testlist
+++ b/test/mpi/io/testlist
@@ -9,3 +9,4 @@ async_any 4
userioerr 1
resized 1
resized2 1 xfail=ticket2088
+bigtype 1
http://git.mpich.org/mpich.git/commitdiff/46642f9a9cb787d2118cc15fc1268bfb83ec655f
commit 46642f9a9cb787d2118cc15fc1268bfb83ec655f
Author: Rob Latham <robl at mcs.anl.gov>
Date: Wed Jul 9 11:55:09 2014 -0500
deal better with large user-defined types
this optimization in ROMIO's noncontigous type handling detects if a
user-defined type will fit into a single write request (e.g. a call to
MPI_Type_create_subarray that was actually the entire array). Code was
passing in a count of bytes, which can overflow an int. since we know
the type is contiguous, simply pass a count of that type (not bytes) to
write_contig
Signed-off-by: Mohamad Chaarawi <chaarawi at hdfgroup.org>
diff --git a/src/mpi/romio/adio/common/ad_read_str.c b/src/mpi/romio/adio/common/ad_read_str.c
index fb5699a..a9be2ae 100644
--- a/src/mpi/romio/adio/common/ad_read_str.c
+++ b/src/mpi/romio/adio/common/ad_read_str.c
@@ -218,7 +218,8 @@ void ADIOI_GEN_ReadStrided(ADIO_File fd, void *buf, int count,
* block e.g. with subarray types that actually describe the whole
* array */
if (buftype_is_contig && bufsize <= frd_size) {
- ADIO_ReadContig(fd, buf, bufsize, MPI_BYTE, ADIO_EXPLICIT_OFFSET,
+ /* a count of bytes can overflow. operate on original type instead */
+ ADIO_ReadContig(fd, buf, count, datatype, ADIO_EXPLICIT_OFFSET,
offset, status, error_code);
if (file_ptr_type == ADIO_INDIVIDUAL) {
diff --git a/src/mpi/romio/adio/common/ad_write_str.c b/src/mpi/romio/adio/common/ad_write_str.c
index 839feca..cbf7cbc 100644
--- a/src/mpi/romio/adio/common/ad_write_str.c
+++ b/src/mpi/romio/adio/common/ad_write_str.c
@@ -285,9 +285,11 @@ void ADIOI_GEN_WriteStrided(ADIO_File fd, const void *buf, int count,
if (buftype_is_contig && bufsize <= fwr_size) {
/* though MPI api has an integer 'count' parameter, derived
* datatypes might describe more bytes than can fit into an integer.
+ * if we've made it this far, we can pass a count of original
+ * datatypes, instead of a count of bytes (which might overflow)
* Other WriteContig calls in this path are operating on data
* sieving buffer */
- ADIO_WriteContig(fd, buf, bufsize, MPI_BYTE, ADIO_EXPLICIT_OFFSET,
+ ADIO_WriteContig(fd, buf, count, datatype, ADIO_EXPLICIT_OFFSET,
offset, status, error_code);
if (file_ptr_type == ADIO_INDIVIDUAL) {
-----------------------------------------------------------------------
Summary of changes:
src/mpi/romio/adio/common/ad_read.c | 8 ++
src/mpi/romio/adio/common/ad_read_str.c | 5 +-
src/mpi/romio/adio/common/ad_write.c | 8 ++
src/mpi/romio/adio/common/ad_write_str.c | 6 +-
src/mpi/romio/test/misc.c.in | 4 +-
test/mpi/datatype/Makefile.am | 3 +-
test/mpi/datatype/get-struct.c | 171 ++++++++++++++++++++++++++++++
test/mpi/datatype/testlist.in | 1 +
test/mpi/io/Makefile.am | 3 +-
test/mpi/io/bigtype.c | 137 ++++++++++++++++++++++++
test/mpi/io/testlist | 1 +
11 files changed, 338 insertions(+), 9 deletions(-)
create mode 100644 test/mpi/datatype/get-struct.c
create mode 100644 test/mpi/io/bigtype.c
hooks/post-receive
--
MPICH primary repository
More information about the commits
mailing list