[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