/*
* Setup indexed buffers for 1 copy of a datatype. Initialize for
* reception (e.g., set initial data to detect failure)
*/
static void *MTestTypeIndexedInitRecv( MTestDatatype *mtype )
{
MPI_Aint totsize;
int merr;
if (mtype->count > 1) {
MTestError( "This datatype is supported only for a single count" );
}
if (mtype->count == 1) {
signed char *p;
int i;
merr = MPI_Type_extent( mtype->datatype, &totsize );
if (merr) MTestPrintError( merr );
if (!mtype->buf) {
mtype->buf = (void *) malloc( totsize );
}
p = (signed char *)(mtype->buf);
if (!p) {
/* Error - out of memory */
MTestError( "Out of memory in type buffer init\n" );
}
for (i=0; i<totsize; i++) {
p[i] = 0xff;
}
}
else {
/* count == 0 */
if (mtype->buf) {
free( mtype->buf );
}
mtype->buf = 0;
}
return mtype->buf;
}
/*
* Setup a buffer for one copy of an indexed datatype.
*/
static void *MTestTypeIndexedInit( MTestDatatype *mtype )
{
MPI_Aint totsize;
int merr;
if (mtype->count > 1) {
MTestError( "This datatype is supported only for a single count" );
}
if (mtype->count == 1) {
signed char *p;
int i, k, offset, j;
/* Allocate the send/recv buffer */
merr = MPI_Type_extent( mtype->datatype, &totsize );
if (merr) MTestPrintError( merr );
if (!mtype->buf) {
mtype->buf = (void *) malloc( totsize );
}
p = (signed char *)(mtype->buf);
if (!p) {
MTestError( "Out of memory in type buffer init\n" );
}
/* Initialize the elements */
/* First, set to -1 */
for (i=0; i<totsize; i++) p[i] = 0xff;
/* Now, set the actual elements to the successive values.
We require that the base type is a contiguous type */
k = 0;
for (i=0; i<mtype->nelm; i++) {
int b;
/* Compute the offset: */
offset = mtype->displs[i] * mtype->basesize;
/* For each element in the block */
for (b=0; b<mtype->index[i]; b++) {
for (j=0; j<mtype->basesize; j++) {
p[offset+j] = 0xff ^ (k++ & 0xff);
}
offset += mtype->basesize;
}
}
}
else {
/* count == 0 */
if (mtype->buf) {
free( mtype->buf );
}
mtype->buf = 0;
}
return mtype->buf;
}
/* Free the storage associated with a window object */
void MTestFreeWin(MPI_Win * win)
{
void *addr;
int flag, merr;
merr = MPI_Win_get_attr(*win, MPI_WIN_BASE, &addr, &flag);
if (merr)
MTestPrintError(merr);
if (!flag) {
MTestError("Could not get WIN_BASE from window");
}
if (addr) {
void *val;
merr = MPI_Win_get_attr(*win, mem_keyval, &val, &flag);
if (merr)
MTestPrintError(merr);
if (flag) {
if (val == (void *) 1) {
free(addr);
}
else if (val == (void *) 2) {
merr = MPI_Free_mem(addr);
if (merr)
MTestPrintError(merr);
}
/* if val == (void *)0, then static data that must not be freed */
}
}
merr = MPI_Win_free(win);
if (merr)
MTestPrintError(merr);
}
/*
* Setup contiguous buffers of n copies of a datatype. Initialize for
* reception (e.g., set initial data to detect failure)
*/
static void *MTestTypeContigInitRecv( MTestDatatype *mtype )
{
MPI_Aint size;
int merr;
if (mtype->count > 0) {
signed char *p;
int i, totsize;
merr = MPI_Type_extent( mtype->datatype, &size );
if (merr) MTestPrintError( merr );
totsize = size * mtype->count;
if (!mtype->buf) {
mtype->buf = (void *) malloc( totsize );
}
p = (signed char *)(mtype->buf);
if (!p) {
/* Error - out of memory */
MTestError( "Out of memory in type buffer init" );
}
for (i=0; i<totsize; i++) {
p[i] = 0xff;
}
}
else {
if (mtype->buf) {
free( mtype->buf );
}
mtype->buf = 0;
}
return mtype->buf;
}
/*
* Initialize buffer of basic datatype
*/
static void *MTestTypeContigInit(MTestDatatype * mtype)
{
MPI_Aint extent = 0, lb = 0, size;
int merr;
if (mtype->count > 0) {
unsigned char *p;
MPI_Aint i, totsize;
merr = MPI_Type_get_extent(mtype->datatype, &lb, &extent);
if (merr)
MTestPrintError(merr);
size = extent + lb;
totsize = size * mtype->count;
if (!mtype->buf) {
mtype->buf = (void *) malloc(totsize);
}
p = (unsigned char *) (mtype->buf);
if (!p) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
for (i = 0; i < totsize; i++) {
p[i] = (unsigned char) (0xff ^ (i & 0xff));
}
}
else {
if (mtype->buf) {
free(mtype->buf);
}
mtype->buf = 0;
}
return mtype->buf;
}
/*
* Initialize buffer of indexed-block datatype
*/
static void *MTestTypeIndexedBlockInit(MTestDatatype * mtype)
{
MPI_Aint extent = 0, lb = 0, size, totsize, offset, dt_offset;
int merr;
if (mtype->count > 0) {
unsigned char *p;
MPI_Aint k, j;
int i, nc;
/* Allocate the send/recv buffer */
merr = MPI_Type_get_extent(mtype->datatype, &lb, &extent);
if (merr)
MTestPrintError(merr);
size = extent + lb;
totsize = size * mtype->count;
if (!mtype->buf) {
mtype->buf = (void *) malloc(totsize);
}
p = (unsigned char *) (mtype->buf);
if (!p) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
/* First, set to -1 */
for (k = 0; k < totsize; k++)
p[k] = 0xff;
/* Now, set the actual elements to the successive values.
* We require that the base type is a contiguous type */
nc = 0;
dt_offset = 0;
/* For each datatype */
for (k = 0; k < mtype->count; k++) {
/* For each block */
for (i = 0; i < mtype->nblock; i++) {
offset = dt_offset + mtype->displ_in_bytes[i];
/* For each byte in the block */
for (j = 0; j < mtype->blksize; j++) {
p[offset + j] = (unsigned char) (0xff ^ (nc++ & 0xff));
}
}
dt_offset += size;
}
}
else {
/* count == 0 */
if (mtype->buf) {
free(mtype->buf);
}
mtype->buf = 0;
}
return mtype->buf;
}
/*
* Setup struct type info and handlers.
*
* A struct datatype is created by using following parameters.
* nblock: Number of blocks.
* blocklen: Number of elements in each block. Each block has the same length.
* stride: Strided number of elements between two adjacent blocks. The byte
* displacement of each block is set as (index of current block * stride * size of oldtype).
* lb: Lower bound of the new datatype.
* oldtype: Datatype of element. Each block has the same oldtype.
*/
static int MTestTypeStructCreate(MPI_Aint nblock, MPI_Aint blocklen, MPI_Aint stride, MPI_Aint lb,
MPI_Datatype oldtype, const char *typename_prefix,
MTestDatatype * mtype)
{
int merr;
char type_name[128];
int i;
MTestTypeReset(mtype);
merr = MPI_Type_size(oldtype, &mtype->basesize);
if (merr)
MTestPrintError(merr);
mtype->old_datatypes = (MPI_Datatype *) malloc(nblock * sizeof(MPI_Datatype));
mtype->displ_in_bytes = (MPI_Aint *) malloc(nblock * sizeof(MPI_Aint));
mtype->index = (int *) malloc(nblock * sizeof(int));
if (!mtype->displ_in_bytes || !mtype->old_datatypes) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
mtype->nblock = nblock;
mtype->blksize = blocklen * mtype->basesize;
for (i = 0; i < nblock; i++) {
mtype->displ_in_bytes[i] = (lb + stride * i) * mtype->basesize;
mtype->old_datatypes[i] = oldtype;
mtype->index[i] = blocklen;
}
/* Struct uses displacement in bytes */
merr = MPI_Type_create_struct(nblock, mtype->index, mtype->displ_in_bytes,
mtype->old_datatypes, &mtype->datatype);
if (merr)
MTestPrintError(merr);
merr = MPI_Type_commit(&mtype->datatype);
if (merr)
MTestPrintError(merr);
memset(type_name, 0, sizeof(type_name));
sprintf(type_name, "%s %s (%ld nblock %ld blocklen %ld stride %ld lb)", typename_prefix,
"struct", nblock, blocklen, stride, lb);
merr = MPI_Type_set_name(mtype->datatype, (char *) type_name);
if (merr)
MTestPrintError(merr);
/* Reuse indexed functions, because they use the same displ_in_bytes and index */
mtype->InitBuf = MTestTypeIndexedInit;
mtype->FreeBuf = MTestTypeFree;
mtype->CheckBuf = MTestTypeIndexedCheckbuf;
return merr;
}
/*
* Initialize buffer of vector datatype
*/
static void *MTestTypeVectorInit(MTestDatatype * mtype)
{
MPI_Aint extent = 0, lb = 0, size, totsize, dt_offset, byte_offset;
int merr;
if (mtype->count > 0) {
unsigned char *p;
MPI_Aint k, j;
int i, nc;
merr = MPI_Type_get_extent(mtype->datatype, &lb, &extent);
if (merr)
MTestPrintError(merr);
size = extent + lb;
totsize = mtype->count * size;
if (!mtype->buf) {
mtype->buf = (void *) malloc(totsize);
}
p = (unsigned char *) (mtype->buf);
if (!p) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
/* First, set to -1 */
for (k = 0; k < totsize; k++)
p[k] = 0xff;
/* Now, set the actual elements to the successive values.
* We require that the base type is a contiguous type */
nc = 0;
dt_offset = 0;
/* For each datatype */
for (k = 0; k < mtype->count; k++) {
/* For each block */
for (i = 0; i < mtype->nblock; i++) {
byte_offset = dt_offset + i * mtype->stride;
/* For each byte */
for (j = 0; j < mtype->blksize; j++) {
p[byte_offset + j] = (unsigned char) (0xff ^ (nc & 0xff));
nc++;
}
}
dt_offset += size;
}
}
else {
mtype->buf = 0;
}
return mtype->buf;
}
/*
* Setup indexed-block type info and handlers.
*
* A indexed-block datatype is created by using following parameters.
* nblock: Number of blocks.
* blocklen: Number of elements in each block.
* stride: Strided number of elements between two adjacent blocks. The
* displacement of each block is set as (index of current block * stride).
* lb: Lower bound of the new datatype.
* oldtype: Datatype of element.
*/
static int MTestTypeIndexedBlockCreate(MPI_Aint nblock, MPI_Aint blocklen, MPI_Aint stride,
MPI_Aint lb, MPI_Datatype oldtype,
const char *typename_prefix, MTestDatatype * mtype)
{
int merr;
char type_name[128];
int i;
MTestTypeReset(mtype);
merr = MPI_Type_size(oldtype, &mtype->basesize);
if (merr)
MTestPrintError(merr);
mtype->displs = (int *) malloc(nblock * sizeof(int));
mtype->displ_in_bytes = (MPI_Aint *) malloc(nblock * sizeof(MPI_Aint));
if (!mtype->displs || !mtype->displ_in_bytes) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
mtype->nblock = nblock;
mtype->blksize = blocklen * mtype->basesize;
for (i = 0; i < nblock; i++) {
mtype->displs[i] = lb + stride * i;
mtype->displ_in_bytes[i] = (lb + stride * i) * mtype->basesize;
}
/* Indexed-block uses displacement in oldtypes */
merr = MPI_Type_create_indexed_block(nblock, blocklen, mtype->displs,
oldtype, &mtype->datatype);
if (merr)
MTestPrintError(merr);
merr = MPI_Type_commit(&mtype->datatype);
if (merr)
MTestPrintError(merr);
memset(type_name, 0, sizeof(type_name));
sprintf(type_name, "%s %s (%ld nblock %ld blocklen %ld stride %ld lb)", typename_prefix,
"index_block", nblock, blocklen, stride, lb);
merr = MPI_Type_set_name(mtype->datatype, (char *) type_name);
if (merr)
MTestPrintError(merr);
mtype->InitBuf = MTestTypeIndexedBlockInit;
mtype->FreeBuf = MTestTypeFree;
mtype->CheckBuf = MTestTypeIndexedBlockCheckbuf;
return merr;
}
static void *MTestTypeVectorInit( MTestDatatype *mtype )
{
MPI_Aint size;
int merr;
if (mtype->count > 0) {
unsigned char *p;
int i, j, k, nc, totsize;
merr = MPI_Type_extent( mtype->datatype, &size );
if (merr) MTestPrintError( merr );
totsize = mtype->count * size;
if (!mtype->buf) {
mtype->buf = (void *) malloc( totsize );
}
p = (unsigned char *)(mtype->buf);
if (!p) {
/* Error - out of memory */
MTestError( "Out of memory in type buffer init" );
}
/* First, set to -1 */
for (i=0; i<totsize; i++) p[i] = 0xff;
/* Now, set the actual elements to the successive values.
To do this, we need to run 3 loops */
nc = 0;
/* count is usually one for a vector type */
for (k=0; k<mtype->count; k++) {
/* For each element (block) */
for (i=0; i<mtype->nelm; i++) {
/* For each value */
for (j=0; j<mtype->blksize; j++) {
p[j] = (0xff ^ (nc & 0xff));
nc++;
}
p += mtype->stride;
}
}
}
else {
mtype->buf = 0;
}
return mtype->buf;
}
/*
Create a range of datatypes with a given count elements.
This uses a selection of types, rather than an exhaustive collection.
It allocates both send and receive types so that they can have the same
type signature (collection of basic types) but different type maps (layouts
in memory)
*/
int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
int count )
{
int merr;
int i;
sendtype->InitBuf = 0;
sendtype->FreeBuf = 0;
sendtype->CheckBuf = 0;
sendtype->datatype = 0;
sendtype->isBasic = 0;
sendtype->printErrors = 0;
recvtype->InitBuf = 0;
recvtype->FreeBuf = 0;
recvtype->CheckBuf = 0;
recvtype->datatype = 0;
recvtype->isBasic = 0;
recvtype->printErrors = 0;
sendtype->buf = 0;
recvtype->buf = 0;
/* Set the defaults for the message lengths */
sendtype->count = count;
recvtype->count = count;
/* Use datatype_index to choose a datatype to use. If at the end of the
list, return 0 */
switch (datatype_index) {
case 0:
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
break;
case 1:
sendtype->datatype = MPI_DOUBLE;
sendtype->isBasic = 1;
recvtype->datatype = MPI_DOUBLE;
recvtype->isBasic = 1;
break;
case 2:
sendtype->datatype = MPI_FLOAT_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_FLOAT_INT;
recvtype->isBasic = 1;
break;
case 3:
merr = MPI_Type_dup( MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"dup of MPI_INT" );
if (merr) MTestPrintError( merr );
merr = MPI_Type_dup( MPI_INT, &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( recvtype->datatype,
(char*)"dup of MPI_INT" );
if (merr) MTestPrintError( merr );
/* dup'ed types are already committed if the original type
was committed (MPI-2, section 8.8) */
break;
case 4:
/* vector send type and contiguous receive type */
/* These sizes are in bytes (see the VectorInit code) */
sendtype->stride = 3 * sizeof(int);
sendtype->blksize = sizeof(int);
sendtype->nelm = recvtype->count;
merr = MPI_Type_vector( recvtype->count, 1, 3, MPI_INT,
&sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-vector" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
sendtype->InitBuf = MTestTypeVectorInit;
recvtype->InitBuf = MTestTypeContigInitRecv;
sendtype->FreeBuf = MTestTypeVectorFree;
recvtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = 0;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 5:
/* Indexed send using many small blocks and contig receive */
sendtype->blksize = sizeof(int);
sendtype->nelm = recvtype->count;
sendtype->basesize = sizeof(int);
sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) );
sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) );
if (!sendtype->displs || !sendtype->index) {
MTestError( "Out of memory in type init\n" );
}
/* Make the sizes larger (4 ints) to help push the total
size to over 256k in some cases, as the MPICH code as of
10/1/06 used large internal buffers for packing non-contiguous
messages */
for (i=0; i<sendtype->nelm; i++) {
sendtype->index[i] = 4;
sendtype->displs[i] = 5*i;
}
merr = MPI_Type_indexed( sendtype->nelm,
sendtype->index, sendtype->displs,
MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-indexed(4-int)" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
sendtype->InitBuf = MTestTypeIndexedInit;
sendtype->FreeBuf = MTestTypeIndexedFree;
sendtype->CheckBuf = 0;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
recvtype->count = count * 4;
recvtype->InitBuf = MTestTypeContigInitRecv;
recvtype->FreeBuf = MTestTypeContigFree;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 6:
/* Indexed send using 2 large blocks and contig receive */
sendtype->blksize = sizeof(int);
sendtype->nelm = 2;
sendtype->basesize = sizeof(int);
sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) );
sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) );
if (!sendtype->displs || !sendtype->index) {
MTestError( "Out of memory in type init\n" );
}
/* index -> block size */
sendtype->index[0] = (recvtype->count + 1) / 2;
sendtype->displs[0] = 0;
sendtype->index[1] = recvtype->count - sendtype->index[0];
sendtype->displs[1] = sendtype->index[0] + 1;
/* There is a deliberate gap here */
merr = MPI_Type_indexed( sendtype->nelm,
sendtype->index, sendtype->displs,
MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-indexed(2 blocks)" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
sendtype->InitBuf = MTestTypeIndexedInit;
sendtype->FreeBuf = MTestTypeIndexedFree;
sendtype->CheckBuf = 0;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
recvtype->count = sendtype->index[0] + sendtype->index[1];
recvtype->InitBuf = MTestTypeContigInitRecv;
recvtype->FreeBuf = MTestTypeContigFree;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 7:
/* Indexed receive using many small blocks and contig send */
recvtype->blksize = sizeof(int);
recvtype->nelm = recvtype->count;
recvtype->basesize = sizeof(int);
recvtype->displs = (int *)malloc( recvtype->nelm * sizeof(int) );
recvtype->index = (int *)malloc( recvtype->nelm * sizeof(int) );
if (!recvtype->displs || !recvtype->index) {
MTestError( "Out of memory in type recv init\n" );
}
/* Make the sizes larger (4 ints) to help push the total
size to over 256k in some cases, as the MPICH code as of
10/1/06 used large internal buffers for packing non-contiguous
messages */
/* Note that there are gaps in the indexed type */
for (i=0; i<recvtype->nelm; i++) {
recvtype->index[i] = 4;
recvtype->displs[i] = 5*i;
}
merr = MPI_Type_indexed( recvtype->nelm,
recvtype->index, recvtype->displs,
MPI_INT, &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( recvtype->datatype,
(char*)"recv-int-indexed(4-int)" );
if (merr) MTestPrintError( merr );
recvtype->count = 1;
recvtype->InitBuf = MTestTypeIndexedInitRecv;
recvtype->FreeBuf = MTestTypeIndexedFree;
recvtype->CheckBuf = MTestTypeIndexedCheckbuf;
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
sendtype->count = count * 4;
sendtype->InitBuf = MTestTypeContigInit;
sendtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = 0;
break;
/* Less commonly used but still simple types */
case 8:
sendtype->datatype = MPI_SHORT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_SHORT;
recvtype->isBasic = 1;
break;
case 9:
sendtype->datatype = MPI_LONG;
sendtype->isBasic = 1;
recvtype->datatype = MPI_LONG;
recvtype->isBasic = 1;
break;
case 10:
sendtype->datatype = MPI_CHAR;
sendtype->isBasic = 1;
recvtype->datatype = MPI_CHAR;
recvtype->isBasic = 1;
break;
case 11:
sendtype->datatype = MPI_UINT64_T;
sendtype->isBasic = 1;
recvtype->datatype = MPI_UINT64_T;
recvtype->isBasic = 1;
break;
case 12:
sendtype->datatype = MPI_FLOAT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_FLOAT;
recvtype->isBasic = 1;
break;
#ifndef USE_STRICT_MPI
/* MPI_BYTE may only be used with MPI_BYTE in strict MPI */
case 13:
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_BYTE;
recvtype->isBasic = 1;
recvtype->count *= sizeof(int);
break;
#endif
default:
datatype_index = -1;
}
if (!sendtype->InitBuf) {
sendtype->InitBuf = MTestTypeContigInit;
recvtype->InitBuf = MTestTypeContigInitRecv;
sendtype->FreeBuf = MTestTypeContigFree;
recvtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = MTestTypeContigCheckbuf;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
}
datatype_index++;
if (dbgflag && datatype_index > 0) {
int typesize;
fprintf( stderr, "%d: sendtype is %s\n", wrank, MTestGetDatatypeName( sendtype ) );
merr = MPI_Type_size( sendtype->datatype, &typesize );
if (merr) MTestPrintError( merr );
fprintf( stderr, "%d: sendtype size = %d\n", wrank, typesize );
fprintf( stderr, "%d: recvtype is %s\n", wrank, MTestGetDatatypeName( recvtype ) );
merr = MPI_Type_size( recvtype->datatype, &typesize );
if (merr) MTestPrintError( merr );
fprintf( stderr, "%d: recvtype size = %d\n", wrank, typesize );
fflush( stderr );
}
else if (verbose && datatype_index > 0) {
printf( "Get new datatypes: send = %s, recv = %s\n",
MTestGetDatatypeName( sendtype ),
MTestGetDatatypeName( recvtype ) );
fflush( stdout );
}
return datatype_index;
}
int main(int argc, char **argv)
{
int rank, nproc;
int errs = 0;
int array[1024];
int val = 0;
int target_rank;
MPI_Aint bases[2];
MPI_Aint disp, offset;
MPI_Win win;
MTest_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (rank == 0 && nproc != 2) {
MTestError("Must run with 2 ranks\n");
}
/* Get the base address in the middle of the array */
if (rank == 0) {
target_rank = 1;
array[0] = 1234;
MPI_Get_address(&array[512], &bases[0]);
} else if (rank == 1) {
target_rank = 0;
array[1023] = 1234;
MPI_Get_address(&array[512], &bases[1]);
}
/* Exchange bases */
MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, bases, 1, MPI_AINT, MPI_COMM_WORLD);
MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &win);
MPI_Win_attach(win, array, sizeof(int)*1024);
/* Do MPI_Aint addressing arithmetic */
if (rank == 0) {
disp = sizeof(int)*511;
offset = MPIX_Aint_add(bases[1], disp); /* offset points to array[1023]*/
} else if (rank == 1) {
disp = sizeof(int)*512;
offset = MPIX_Aint_diff(bases[0], disp); /* offset points to array[0] */
}
/* Get val and verify it */
MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
MPI_Get(&val, 1, MPI_INT, target_rank, offset, 1, MPI_INT, win);
MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
if (val != 1234) {
errs++;
printf("%d -- Got %d, expected 1234\n", rank, val);
}
MPI_Win_detach(win, array);
MPI_Win_free(&win);
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
/*
* Initialize buffer of subarray datatype.
*/
static void *MTestTypeSubarrayInit(MTestDatatype * mtype)
{
MPI_Aint extent = 0, lb = 0, size, totsize, offset, dt_offset, byte_offset;
int merr;
if (mtype->count > 0) {
unsigned char *p;
MPI_Aint k;
int j, b, i, nc;
/* Allocate the send/recv buffer */
merr = MPI_Type_get_extent(mtype->datatype, &lb, &extent);
if (merr)
MTestPrintError(merr);
size = extent + lb;
totsize = size * mtype->count;
if (!mtype->buf) {
mtype->buf = (void *) malloc(totsize);
}
p = (unsigned char *) (mtype->buf);
if (!p) {
char errmsg[128] = { 0 };
sprintf(errmsg, "Out of memory in %s", __FUNCTION__);
MTestError(errmsg);
}
/* First, set to -1 */
for (k = 0; k < totsize; k++)
p[k] = 0xff;
/* Now, set the actual elements to the successive values.
* We require that the base type is a contiguous type. */
int ncol, sub_ncol, sub_nrow, sub_col_start, sub_row_start;
ncol = mtype->arr_sizes[1];
sub_nrow = mtype->arr_subsizes[0];
sub_ncol = mtype->arr_subsizes[1];
sub_row_start = mtype->arr_starts[0];
sub_col_start = mtype->arr_starts[1];
nc = 0;
dt_offset = 0;
/* For each datatype */
for (k = 0; k < mtype->count; k++) {
/* For each row */
for (i = 0; i < sub_nrow; i++) {
offset = (sub_row_start + i) * ncol + sub_col_start;
/* For each element in row */
for (j = 0; j < sub_ncol; j++) {
byte_offset = dt_offset + (offset + j) * mtype->basesize;
/* For each byte in element */
for (b = 0; b < mtype->basesize; b++)
p[byte_offset + b] = (unsigned char) (0xff ^ (nc++ & 0xff));
}
}
dt_offset += size;
}
}
else {
/* count == 0 */
if (mtype->buf) {
free(mtype->buf);
}
mtype->buf = 0;
}
return mtype->buf;
}
