int MPI_Alltoallv(void *sendbuf, int *sendcounts,
int *sdispls, MPI_Datatype sendtype,
void *recvbuf, int *recvcounts,
int *rdispls, MPI_Datatype recvtype,
MPI_Comm comm)
{
int send_offset;
int recv_offset;
MPI_Aint st_extent;
MPI_Aint rt_extent;
MPI_Type_extent(sendtype, &st_extent);
MPI_Type_extent(recvtype, &rt_extent);
send_offset=sdispls[0]*st_extent;
recv_offset=rdispls[0]*rt_extent;
copy_data2((char*)sendbuf+send_offset, sendcounts[0], sendtype,
(char*)recvbuf+recv_offset, recvcounts[0], recvtype);
// memcpy( (char *)recvbuf+recv_offset, (char *)sendbuf+send_offset,
// sendcounts[0] * sendtype);
return(MPI_SUCCESS);
}
/* simple linear Alltoallv */
int ompi_coll_libnbc_ialltoallv_inter (void* sendbuf, int *sendcounts, int *sdispls,
MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int *rdispls,
MPI_Datatype recvtype, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_0_0_t *module)
{
int rank, res, i, rsize;
MPI_Aint sndext, rcvext;
NBC_Schedule *schedule;
char *rbuf, *sbuf;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Type_extent(sendtype, &sndext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_extent(recvtype, &rcvext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
MPI_Comm_remote_size (comm, &rsize);
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc() (%i)\n", res); return res; }
handle->tmpbuf=NULL;
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
for (i = 0; i < rsize; i++) {
/* post all sends */
if(sendcounts[i] != 0) {
sbuf = ((char *) sendbuf) + (sdispls[i] * sndext);
res = NBC_Sched_send(sbuf, false, sendcounts[i], sendtype, i, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_send() (%i)\n", res); return res; }
}
/* post all receives */
if(recvcounts[i] != 0) {
rbuf = ((char *) recvbuf) + (rdispls[i] * rcvext);
res = NBC_Sched_recv(rbuf, false, recvcounts[i], recvtype, i, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_recv() (%i)\n", res); return res; }
}
}
/*NBC_PRINT_SCHED(*schedule);*/
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { printf("Error in NBC_Start() (%i)\n", res); return res; }
return NBC_OK;
}
static int MTestTypeContigCheckbuf( MTestDatatype *mtype )
{
unsigned char *p;
unsigned char expected;
int i, totsize, err = 0, merr;
MPI_Aint size;
p = (unsigned char *)mtype->buf;
if (p) {
merr = MPI_Type_extent( mtype->datatype, &size );
if (merr) MTestPrintError( merr );
totsize = size * mtype->count;
for (i=0; i<totsize; i++) {
expected = (0xff ^ (i & 0xff));
if (p[i] != expected) {
err++;
if (mtype->printErrors && err < 10) {
printf( "Data expected = %x but got p[%d] = %x\n",
expected, i, p[i] );
fflush( stdout );
}
}
}
}
return err;
}
/*
* 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;
}
/*@
MPI_File_get_type_extent - Returns the extent of datatype in the file
Input Parameters:
. fh - file handle (handle)
. datatype - datatype (handle)
Output Parameters:
. extent - extent of the datatype (nonnegative integer)
.N fortran
@*/
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype,
MPI_Aint *extent)
{
#ifndef PRINT_ERR_MSG
int error_code;
static char myname[] = "MPI_FILE_GET_TYPE_EXTENT";
#endif
#ifdef PRINT_ERR_MSG
if ((fh <= (MPI_File) 0) || (fh->cookie != ADIOI_FILE_COOKIE)) {
FPRINTF(stderr, "MPI_File_get_type_extent: Invalid file handle\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
#else
ADIOI_TEST_FILE_HANDLE(fh, myname);
#endif
if (datatype == MPI_DATATYPE_NULL) {
#ifdef PRINT_ERR_MSG
FPRINTF(stderr, "MPI_File_get_type_extent: Invalid datatype\n");
MPI_Abort(MPI_COMM_WORLD, 1);
#else
error_code = MPIR_Err_setmsg(MPI_ERR_TYPE, MPIR_ERR_TYPE_NULL,
myname, (char *) 0, (char *) 0);
return ADIOI_Error(fh, error_code, myname);
#endif
}
return MPI_Type_extent(datatype, extent);
}
/*
* 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;
}
int MPI_Scatterv(void* sendbuf, int *sendcounts, int *displs,
MPI_Datatype sendtype, void* recvbuf, int recvcount,
MPI_Datatype recvtype, int root, MPI_Comm comm)
{
int offset;
MPI_Aint st_extent;
if (recvbuf==MPI_IN_PLACE)
return(MPI_SUCCESS);
if (root==MPI_ROOT)
return(MPI_SUCCESS);
if (root!=0)
{
fprintf(stderr,"MPI_Scatterv: bad root = %d\n",root);
abort();
}
MPI_Type_extent(sendtype, &st_extent);
offset=displs[0]*st_extent;
copy_data2((char*)sendbuf+offset, sendcounts[0], sendtype,
recvbuf, recvcount, recvtype);
// memcpy(recvbuf,(char *)sendbuf+offset,sendcounts[0] * sendtype);
return(MPI_SUCCESS);
}
/* derived_resized_test()
*
* Tests behavior with resizing of a simple derived type.
*
* Returns the number of errors encountered.
*/
int derived_resized_test(void)
{
int err, errs = 0;
int count = 2;
MPI_Datatype newtype, resizedtype;
int size;
MPI_Aint extent;
err = MPI_Type_contiguous(count, MPI_INT, &newtype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error creating type in derived_resized_test()\n");
}
errs++;
}
err = MPI_Type_create_resized(newtype,
(MPI_Aint) 0, (MPI_Aint) (2 * sizeof(int) + 10), &resizedtype);
err = MPI_Type_size(resizedtype, &size);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error obtaining type size in derived_resized_test()\n");
}
errs++;
}
if (size != 2 * sizeof(int)) {
if (verbose) {
fprintf(stderr,
"error: size != %d in derived_resized_test()\n", (int) (2 * sizeof(int)));
}
errs++;
}
err = MPI_Type_extent(resizedtype, &extent);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr, "error obtaining type extent in derived_resized_test()\n");
}
errs++;
}
if (extent != 2 * sizeof(int) + 10) {
if (verbose) {
fprintf(stderr,
"error: invalid extent (%d) in derived_resized_test(); should be %d\n",
(int) extent, (int) (2 * sizeof(int) + 10));
}
errs++;
}
MPI_Type_free(&newtype);
MPI_Type_free(&resizedtype);
return errs;
}
/* contig_test()
*
* Tests behavior with a zero-count contig.
*
* Returns the number of errors encountered.
*/
int contig_test(void)
{
int err, errs = 0;
int count = 0;
MPI_Datatype newtype;
int size;
MPI_Aint extent;
err = MPI_Type_contiguous(count,
MPI_INT,
&newtype);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error creating type in contig_test()\n");
}
errs++;
}
err = MPI_Type_size(newtype, &size);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error obtaining type size in contig_test()\n");
}
errs++;
}
if (size != 0) {
if (verbose) {
fprintf(stderr,
"error: size != 0 in contig_test()\n");
}
errs++;
}
err = MPI_Type_extent(newtype, &extent);
if (err != MPI_SUCCESS) {
if (verbose) {
fprintf(stderr,
"error obtaining type extent in contig_test()\n");
}
errs++;
}
if (extent != 0) {
if (verbose) {
fprintf(stderr,
"error: extent != 0 in contig_test()\n");
}
errs++;
}
MPI_Type_free( &newtype );
return errs;
}
int main (int argc, char *argv[]){
int i,
numtasks, rank;
int tag=1;
float a[16] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0};
float b[SIZE];
int blockcounts[2] ={4, 2};
MPI_Datatype oldtypes[2] = {MPI_FLOAT, MPI_INT};
int offsets[2];
MPI_Aint extent;
MPI_Status status;
MPI_Datatype particletype;
Particle particles[NELEMENTS], p[NELEMENTS];
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Type_extent(MPI_FLOAT,&extent);
offsets[0]=0;
offsets[1]=4*extent;
MPI_Type_struct(2,blockcounts,offsets,oldtypes,&particletype);
MPI_Type_commit(&particletype);
if (rank == RANK_MASTER) {
for(i=0;i<NELEMENTS;i++){
particles[i].x=1;
particles[i].y=2;
particles[i].z=3;
particles[i].velocity=4;
particles[i].n=5;
particles[i].type=6;
}
for (i=0; i<numtasks; i++)
MPI_Send(particles,NELEMENTS, particletype, i, tag, MPI_COMM_WORLD);
}
MPI_Recv(p, NELEMENTS, particletype, 0, tag, MPI_COMM_WORLD, &status);
for(i=0;i<NELEMENTS;i++)
printf("RANK #%d: %.1f %.1f %.1f %.1f %d %d\n", rank,p[i].x,
p[i].y,p[i].z,p[i].velocity,p[i].n,p[i].type);
MPI_Type_free(&particletype);
MPI_Finalize();
return 0;
} /* end of main */
int ompi_coll_libnbc_igatherv_inter (void* sendbuf, int sendcount, MPI_Datatype sendtype,
void* recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype,
int root, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_0_0_t *module) {
int rank, p, res, i, rsize;
MPI_Aint rcvext;
NBC_Schedule *schedule;
char *rbuf;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Comm_size(comm, &p);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_size() (%i)\n", res); return res; }
res = MPI_Comm_remote_size (comm, &rsize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_remote_size() (%i)\n", res); return res; }
if (MPI_ROOT == root) {
res = MPI_Type_extent(recvtype, &rcvext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
}
handle->tmpbuf = NULL;
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc() (%i)\n", res); return res; }
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
/* send to root */
if (MPI_ROOT != root && MPI_PROC_NULL != root) {
/* send msg to root */
res = NBC_Sched_send(sendbuf, false, sendcount, sendtype, root, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_send() (%i)\n", res); return res; }
} else if (MPI_ROOT == root) {
for (i = 0 ; i < rsize ; ++i) {
rbuf = ((char *)recvbuf) + (displs[i]*rcvext);
/* root receives message to the right buffer */
res = NBC_Sched_recv(rbuf, false, recvcounts[i], recvtype, i, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_recv() (%i)\n", res); return res; }
}
}
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { printf("Error in NBC_Start() (%i)\n", res); return res; }
return NBC_OK;
}
int ompi_coll_libnbc_iallgatherv_inter(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int *displs,
MPI_Datatype recvtype, struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_1_0_t *module)
{
int rank, res, r, rsize;
MPI_Aint rcvext;
NBC_Schedule *schedule;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Comm_remote_size(comm, &rsize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_remote_size() (%i)\n", res); return res; }
res = MPI_Type_extent(recvtype, &rcvext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc() (%i)\n", res); return res; }
handle->tmpbuf=NULL;
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create, (%i)\n", res); return res; }
/* do rsize rounds */
for (r = 0 ; r < rsize ; ++r) {
char *rbuf = ((char *)recvbuf) + (displs[r]*rcvext);
if (recvcounts[r]) {
res = NBC_Sched_recv(rbuf, false, recvcounts[r], recvtype, r, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_recv() (%i)\n", res); return res; }
}
}
if (sendcount) {
for (r = 0 ; r < rsize ; ++r) {
res = NBC_Sched_send(sendbuf, false, sendcount, sendtype, r, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_send() (%i)\n", res); return res; }
}
}
res = NBC_Sched_commit(schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
res = NBC_Start(handle, schedule);
if (NBC_OK != res) { printf("Error in NBC_Start() (%i)\n", res); return res; }
return NBC_OK;
}
void mpi_type_extent_f(MPI_Fint *type, MPI_Fint *extent, MPI_Fint *ierr)
{
MPI_Datatype c_type = MPI_Type_f2c(*type);
MPI_Aint c_extent;
*ierr = OMPI_INT_2_FINT(MPI_Type_extent(c_type, &c_extent));
if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr)) {
*extent = (MPI_Fint)c_extent;
}
}
/*
* This function sends the results collected by one worker back to
* the master. It first assembles a result_buf in order to send
* everything in one single operation.
*/
void p_vegasrewrite(binAccu r_Ab[FNMX], double r_d[NDMX][MXDIM], double r_di[NDMX][MXDIM])
{
int i, j;
/* assemble the send-buffer */
for (j=0; j<functions; j++) {
result_buf[j] = r_Ab[j].ti;
}
for (j=0; j<functions; j++) {
result_buf[j+functions] = r_Ab[j].tsi;
}
for (j=0; j<gndim; j++) {
for (i=0; i<nd; i++)
result_buf[2*functions + j*nd + i] = r_d[i][j];
for (i=0; i<nd; i++)
result_buf[2*functions + gndim*nd + j*nd + i] = r_di[i][j];
}
MPI_Send(result_buf, (2*functions + 2*(gndim*nd)), MPI_DOUBLE, 0, 1, MPI_COMM_WORLD);
// MARKUS: define MPI_HISTO for transmitting C histogram structs
MPI_Datatype MPI_HISTO, oldtypes[2];
int blockcounts[2];
MPI_Aint offsets[2], extent;
offsets[0] = 0;
oldtypes[0] = MPI_DOUBLE;
blockcounts[0] = 2*MXHISTOBINS;
MPI_Type_extent(MPI_DOUBLE, &extent);
offsets[1] = blockcounts[0] * extent;
oldtypes[1] = MPI_INT;
blockcounts[1] = 1*MXHISTOBINS;
MPI_Type_struct(2, blockcounts, offsets, oldtypes, &MPI_HISTO);
MPI_Type_commit(&MPI_HISTO);
ReducedCHistogram CHisto[NUMHISTO]; /* MARKUS: declare C hisograms */
int SelectHisto;
for(SelectHisto=1; SelectHisto<=NUMHISTO; SelectHisto++) { /* MARKUS: loop over all histograms and copy fortran type into C struct */
modkinematics_mp_getredhisto_(&CHisto[SelectHisto-1],&SelectHisto);
};
// printf("Printing final CHistograms \n");
// for (j=0; j<NUMHISTO; j++) {
// for (i=0; i<MXHISTOBINS; i++) {
// printf(" %i %i %20.8e \n",j+1,i+1,CHisto[j].Value[i]);
// };
// };
// printf("worker sending histo struct: %20.6e \n",CHisto.Value[0]);
MPI_Send(CHisto,NUMHISTO,MPI_HISTO,0,2,MPI_COMM_WORLD); /* MARKUS: send the array of C histogram structs back to the master */
}
/*
* Class: mpi_Datatype
* Method: extent
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_mpi_Datatype_extent
(JNIEnv *env, jobject jthis)
{
MPI_Aint result;
clearFreeList(env) ;
MPI_Type_extent(
(MPI_Datatype)((*env)->GetLongField(env,jthis,DatatypehandleID)),
&result);
return result;
}
/*
* 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;
}
int get_datatypes( int *grid, int *start, int *end, \
MPI_Datatype *faces, int msg_fac )
{
int count, blocklength;
int stride;
MPI_Aint extent, i;
MPI_Datatype z_row, oneface[3];
/* set up datatype for x_faces */
count = end[1] - start[1] + 1;
blocklength = end[2] - start[2] + 1;
stride = grid[2];
MPI_Type_vector( count, blocklength, stride, MPI_DOUBLE, \
&oneface[0] );
/* set up datatype for y_faces */
count = end[0] - start[0] + 1;
blocklength = end[2] - start[2] + 1;
stride = grid[1] * grid[2];
MPI_Type_vector( count, blocklength, stride, MPI_DOUBLE, \
&oneface[1] );
/* set up datatype for z_faces */
count = end[1] - start[1] + 1;
blocklength = 1;
stride = grid[2];
MPI_Type_vector( count, blocklength, stride, MPI_DOUBLE, \
&z_row );
MPI_Type_commit( &z_row );
count = end[0] - start[0] + 1;
blocklength = 1;
MPI_Type_extent( MPI_DOUBLE, &extent );
extent = grid[1] * grid[2] * extent;
MPI_Type_hvector( count, blocklength, extent, z_row, \
&oneface[2] );
for( i=0 ; i<3 ; i++ )
{
MPI_Type_commit( &oneface[i] );
MPI_Type_vector( msg_fac, 1, 0, oneface[i], &faces[i] );
MPI_Type_commit( &faces[i] );
MPI_Type_free( &oneface[i] );
}
/* Free the z_row Type */
MPI_Type_free( &z_row );
return 0;
}
int main( int argc, char **argv )
{
int i, errs;
int size;
MPI_Aint extent, lb, ub;
MPI_Init( &argc, &argv );
/* This should be run by a single process */
SetupBasicTypes();
errs = 0;
for (i=0; i<ntypes; i++) {
MPI_Type_size( BasicTypes[i], &size );
MPI_Type_extent( BasicTypes[i], &extent );
MPI_Type_lb( BasicTypes[i], &lb );
MPI_Type_ub( BasicTypes[i], &ub );
if (size != extent) {
errs++;
printf( "size (%d) != extent (%ld) for basic type %s\n", size,
(long) extent, BasicTypesName[i] );
}
if (size != BasicSizes[i]) {
errs++;
printf( "size(%d) != C size (%d) for basic type %s\n", size,
BasicSizes[i], BasicTypesName[i] );
}
if (lb != 0) {
errs++;
printf( "Lowerbound of %s was %d instead of 0\n",
BasicTypesName[i], (int)lb );
}
if (ub != extent) {
errs++;
printf( "Upperbound of %s was %d instead of %d\n",
BasicTypesName[i], (int)ub, (int)extent );
}
}
if (errs) {
printf( "Found %d errors in testing C types\n", errs );
}
else {
printf( "Found no errors in basic C types\n" );
}
MPI_Finalize( );
return 0;
}
int main( int argc, char **argv)
{
int blockcnt[2], rank;
MPI_Aint offsets[2], lb, ub, extent;
MPI_Datatype tmp_type, newtype;
MPI_Init(&argc, &argv);
/* Set some values in locations that should not be accessed */
blockcnt[1] = -1;
offsets[1] = -1;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if (rank == 0) {
blockcnt[0] = 1;
offsets[0] = 3;
MPI_Type_hindexed(1, blockcnt, offsets, MPI_BYTE, &tmp_type);
blockcnt[0] = 1;
offsets[0] = 1;
MPI_Type_hindexed(1, blockcnt, offsets, tmp_type, &newtype);
MPI_Type_commit(&newtype);
MPI_Type_lb(newtype, &lb);
MPI_Type_extent(newtype, &extent);
MPI_Type_ub(newtype, &ub);
/* Check that the results are correct */
#ifdef DEBUG
printf("lb=%ld, ub=%ld, extent=%ld\n", lb, ub, extent);
printf("Should be lb=4, ub=5, extent=1\n");
#endif
if (lb != 4 || ub != 5 || extent != 1) {
printf ("lb = %d (should be 4), ub = %d (should be 5) extent = %d should be 1\n", (int)lb, (int)ub, (int)extent) ;
}
else {
printf( " No Errors\n" );
}
MPI_Type_free(&tmp_type);
MPI_Type_free(&newtype);
}
MPI_Finalize();
return 0;
}
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;
}
void ADIOI_Get_position(ADIO_File fd, ADIO_Offset *offset)
{
ADIOI_Flatlist_node *flat_file;
int i, n_filetypes, flag, frd_size;
int filetype_size, etype_size, filetype_is_contig;
MPI_Aint filetype_extent;
ADIO_Offset disp, byte_offset, sum, size_in_file;
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
etype_size = fd->etype_size;
if (filetype_is_contig) *offset = (fd->fp_ind - fd->disp)/etype_size;
else {
/* filetype already flattened in ADIO_Open */
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype) flat_file = flat_file->next;
MPI_Type_size(fd->filetype, &filetype_size);
MPI_Type_extent(fd->filetype, &filetype_extent);
disp = fd->disp;
byte_offset = fd->fp_ind;
n_filetypes = -1;
flag = 0;
while (!flag) {
sum = 0;
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i]
>= byte_offset) {
frd_size = (int) (disp + flat_file->indices[i] +
(ADIO_Offset) n_filetypes*filetype_extent
+ flat_file->blocklens[i] - byte_offset);
sum -= frd_size;
flag = 1;
break;
}
}
}
size_in_file = (ADIO_Offset) n_filetypes*filetype_size + sum;
*offset = size_in_file/etype_size;
}
}
/* simple chained MPI_Ibcast */
static inline int bcast_sched_chain(int rank, int p, int root, NBC_Schedule *schedule, void *buffer, int count, MPI_Datatype datatype, int fragsize, int size) {
int res, vrank, rpeer, speer, numfrag, fragnum, fragcount, thiscount;
MPI_Aint ext;
char *buf;
RANK2VRANK(rank, vrank, root);
VRANK2RANK(rpeer, vrank-1, root);
VRANK2RANK(speer, vrank+1, root);
res = MPI_Type_extent(datatype, &ext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
if(count == 0) return NBC_OK;
numfrag = count*size/fragsize;
if((count*size)%fragsize != 0) numfrag++;
fragcount = count/numfrag;
/*if(!rank) printf("numfrag: %i, count: %i, size: %i, fragcount: %i\n", numfrag, count, size, fragcount);*/
for(fragnum = 0; fragnum < numfrag; fragnum++) {
buf = (char*)buffer+fragnum*fragcount*ext;
thiscount = fragcount;
if(fragnum == numfrag-1) {
/* last fragment may not be full */
thiscount = count-fragcount*fragnum;
}
/* root does not receive */
if(vrank != 0) {
res = NBC_Sched_recv(buf, false, thiscount, datatype, rpeer, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_recv() (%i)\n", res); return res; }
res = NBC_Sched_barrier(schedule);
}
/* last rank does not send */
if(vrank != p-1) {
res = NBC_Sched_send(buf, false, thiscount, datatype, speer, schedule);
if (NBC_OK != res) { printf("Error in NBC_Sched_send() (%i)\n", res); return res; }
/* this barrier here seems awaward but isn't!!!! */
if(vrank == 0) res = NBC_Sched_barrier(schedule);
}
}
return NBC_OK;
}
void ADIOI_Get_position(ADIO_File fd, ADIO_Offset *offset)
{
ADIOI_Flatlist_node *flat_file;
int i, flag;
MPI_Count filetype_size, etype_size;
int filetype_is_contig;
MPI_Aint filetype_extent;
ADIO_Offset disp, byte_offset, sum=0, size_in_file, n_filetypes, frd_size;
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
etype_size = fd->etype_size;
if (filetype_is_contig) *offset = (fd->fp_ind - fd->disp)/etype_size;
else {
flat_file = ADIOI_Flatten_and_find(fd->filetype);
MPI_Type_size_x(fd->filetype, &filetype_size);
MPI_Type_extent(fd->filetype, &filetype_extent);
disp = fd->disp;
byte_offset = fd->fp_ind;
n_filetypes = -1;
flag = 0;
while (!flag) {
sum = 0;
n_filetypes++;
for (i=0; i<flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (disp + flat_file->indices[i] +
n_filetypes* ADIOI_AINT_CAST_TO_OFFSET filetype_extent + flat_file->blocklens[i]
>= byte_offset) {
frd_size = disp + flat_file->indices[i] +
n_filetypes * ADIOI_AINT_CAST_TO_OFFSET filetype_extent
+ flat_file->blocklens[i] - byte_offset;
sum -= frd_size;
flag = 1;
break;
}
}
}
size_in_file = n_filetypes * (ADIO_Offset)filetype_size + sum;
*offset = size_in_file/etype_size;
}
}
int ompi_coll_libnbc_iallreduce_inter(void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
struct ompi_communicator_t *comm, ompi_request_t ** request,
struct mca_coll_base_module_2_0_0_t *module)
{
int rank, res, size, rsize;
MPI_Aint ext;
NBC_Schedule *schedule;
NBC_Handle *handle;
ompi_coll_libnbc_request_t **coll_req = (ompi_coll_libnbc_request_t**) request;
ompi_coll_libnbc_module_t *libnbc_module = (ompi_coll_libnbc_module_t*) module;
res = NBC_Init_handle(comm, coll_req, libnbc_module);
if(res != NBC_OK) { printf("Error in NBC_Init_handle(%i)\n", res); return res; }
handle = (*coll_req);
res = MPI_Comm_rank(comm, &rank);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_rank() (%i)\n", res); return res; }
res = MPI_Comm_remote_size(comm, &rsize);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Comm_remote_size() (%i)\n", res); return res; }
res = MPI_Type_extent(datatype, &ext);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_extent() (%i)\n", res); return res; }
res = MPI_Type_size(datatype, &size);
if (MPI_SUCCESS != res) { printf("MPI Error in MPI_Type_size() (%i)\n", res); return res; }
handle->tmpbuf = malloc(ext*count);
if(handle->tmpbuf == NULL) { printf("Error in malloc() (%i)\n", res); return NBC_OOR; }
schedule = (NBC_Schedule*)malloc(sizeof(NBC_Schedule));
if (NULL == schedule) { printf("Error in malloc()\n"); return res; }
res = NBC_Sched_create(schedule);
if(res != NBC_OK) { printf("Error in NBC_Sched_create (%i)\n", res); return res; }
res = allred_sched_linear(rank, rsize, sendbuf, recvbuf, count, datatype, op, ext, size, schedule, handle);
if (NBC_OK != res) { printf("Error in Schedule creation() (%i)\n", res); return res; }
res = NBC_Sched_commit(schedule);
if(res != NBC_OK) { free(handle->tmpbuf); printf("Error in NBC_Sched_commit() (%i)\n", res); return res; }
res = NBC_Start(handle, schedule);
if(res != NBC_OK) { free(handle->tmpbuf); printf("Error in NBC_Start() (%i)\n", res); return res; }
/* tmpbuf is freed with the handle */
return NBC_OK;
}
int MPI_Allgatherv(void* sendbuf, int sendcount, MPI_Datatype sendtype,
void* recvbuf, int *recvcounts, int *displs,
MPI_Datatype recvtype, MPI_Comm comm)
{
int offset;
MPI_Aint rt_extent;
if (sendbuf==MPI_IN_PLACE)
return(MPI_SUCCESS);
MPI_Type_extent(recvtype, &rt_extent);
offset=displs[0]*rt_extent;
copy_data2(sendbuf, sendcount, sendtype,
(char*)recvbuf+offset, recvcounts[0], recvtype);
// memcpy( (char *)recvbuf+offset, sendbuf, recvcounts[0] * recvtype);
return(MPI_SUCCESS);
}
void
avtWholeImageCompositerWithZ::InitializeMPIStuff(void)
{
#define UCH MPI_UNSIGNED_CHAR
#define FLT MPI_FLOAT
int lengths[] = { 1, 1, 1, 1};
MPI_Aint displacements[] = { 0, 0, 0, 0};
MPI_Datatype types[] = {FLT, UCH, UCH, UCH};
ZFPixel_t onePixel;
#undef UCH
#undef FLT
// create the MPI data type for ZFPixel
MPI_Address(&onePixel.z, &displacements[0]);
MPI_Address(&onePixel.r, &displacements[1]);
MPI_Address(&onePixel.g, &displacements[2]);
MPI_Address(&onePixel.b, &displacements[3]);
for (int i = 3; i >= 0; --i)
displacements[i] -= displacements[0];
MPI_Type_create_struct(4, lengths, displacements, types,
&avtWholeImageCompositerWithZ::mpiTypeZFPixel);
// check that the datatype has the correct extent
MPI_Aint ext;
MPI_Type_extent(avtWholeImageCompositerWithZ::mpiTypeZFPixel, &ext);
if (ext != sizeof(onePixel))
{
MPI_Datatype tmp = avtWholeImageCompositerWithZ::mpiTypeZFPixel;
MPI_Type_create_resized(tmp, 0, sizeof(ZFPixel_t),
&avtWholeImageCompositerWithZ::mpiTypeZFPixel);
MPI_Type_free(&tmp);
}
MPI_Type_commit(&avtWholeImageCompositerWithZ::mpiTypeZFPixel);
MPI_Op_create((MPI_User_function *)MergeZFPixelBuffers, 1,
&avtWholeImageCompositerWithZ::mpiOpMergeZFPixelBuffers);
}
/*@
MPI_File_get_type_extent - Returns the extent of datatype in the file
Input Parameters:
. fh - file handle (handle)
. datatype - datatype (handle)
Output Parameters:
. extent - extent of the datatype (nonnegative integer)
.N fortran
@*/
int MPI_File_get_type_extent(MPI_File mpi_fh, MPI_Datatype datatype,
MPI_Aint *extent)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_TYPE_EXTENT";
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
MPIO_CHECK_DATATYPE(fh, datatype, myname, error_code);
/* --END ERROR HANDLING-- */
/* FIXME: handle other file data representations */
error_code = MPI_Type_extent(datatype, extent);
fn_exit:
return error_code;
}
void ADIOI_Get_byte_offset(ADIO_File fd, ADIO_Offset offset, ADIO_Offset * disp)
{
ADIOI_Flatlist_node *flat_file;
int i;
ADIO_Offset n_filetypes, etype_in_filetype, sum, abs_off_in_filetype = 0, size_in_filetype;
MPI_Count n_etypes_in_filetype, filetype_size, etype_size;
int filetype_is_contig;
MPI_Aint filetype_extent;
ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig);
etype_size = fd->etype_size;
if (filetype_is_contig)
*disp = fd->disp + etype_size * offset;
else {
flat_file = ADIOI_Flatten_and_find(fd->filetype);
MPI_Type_size_x(fd->filetype, &filetype_size);
n_etypes_in_filetype = filetype_size / etype_size;
n_filetypes = offset / n_etypes_in_filetype;
etype_in_filetype = offset % n_etypes_in_filetype;
size_in_filetype = etype_in_filetype * etype_size;
sum = 0;
for (i = 0; i < flat_file->count; i++) {
sum += flat_file->blocklens[i];
if (sum > size_in_filetype) {
abs_off_in_filetype = flat_file->indices[i] +
size_in_filetype - (sum - flat_file->blocklens[i]);
break;
}
}
/* abs. offset in bytes in the file */
MPI_Type_extent(fd->filetype, &filetype_extent);
*disp =
fd->disp + n_filetypes * ADIOI_AINT_CAST_TO_OFFSET filetype_extent +
abs_off_in_filetype;
}
}
int main(int argc, char *argv[])
{
int rank, size;
MPI_Datatype type;
int errclass, errs = 0, mpi_errno;
MTest_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
/* Checking type_extent for NULL variable */
type = MPI_INT;
mpi_errno = MPI_Type_extent(type, NULL);
MPI_Error_class(mpi_errno, &errclass);
if (errclass != MPI_ERR_ARG)
++errs;
MTest_Finalize(errs);
return 0;
}
static void opIntercept(void *invec, void *inoutvec, int *count,
MPI_Datatype *datatype, int baseType,
void *jnienv, void *object)
{
JNIEnv *env = jnienv;
jobject jthis = object;
jobject jin, jio;
MPI_Aint extent;
int rc = MPI_Type_extent(*datatype, &extent);
if(ompi_java_exceptionCheck(env, rc))
return;
int len = (*count) * extent;
if(baseType == 4)
{
jin = setBooleanArray(env, invec, len);
jio = setBooleanArray(env, inoutvec, len);
}
else
{
jin = (*env)->NewDirectByteBuffer(env, invec, len);
jio = (*env)->NewDirectByteBuffer(env, inoutvec, len);
}
if((*env)->ExceptionCheck(env))
return;
(*env)->CallVoidMethod(env, jthis, ompi_java.OpCall, jin, jio, *count);
if(baseType == 4)
getBooleanArray(env, jio, inoutvec, len);
(*env)->DeleteLocalRef(env, jin);
(*env)->DeleteLocalRef(env, jio);
}
