/*
* Class: mpi_Datatype
* Method: uB
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_mpi_Datatype_uB
(JNIEnv *env, jobject jthis)
{
MPI_Aint result;
clearFreeList(env) ;
MPI_Type_ub(
(MPI_Datatype)((*env)->GetLongField(env,jthis,DatatypehandleID)),
&result);
return result;
}
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;
}
void mpi_type_ub_(int* datatype, MPI_Aint * disp, int* ierr){
*ierr= MPI_Type_ub(get_datatype(*datatype), disp);
}
int main( int argc, char **argv )
{
int nsize, n2size;
MPI_Aint nlb, nub, n2lb, n2ub;
MPI_Datatype ntype, n2type;
MPI_Aint displs[2];
MPI_Datatype types[2];
int blockcounts[2];
double myarray[10];
int err = 0;
MPI_Init( &argc, &argv );
MPI_Address( &myarray[0], &displs[0] );
MPI_Address( &myarray[3], &displs[1] );
blockcounts[0] = 3;
blockcounts[1] = 1;
displs[1] = displs[1] - displs[0];
displs[0] = 0;
types[0] = MPI_DOUBLE;
types[1] = MPI_DOUBLE;
MPI_Type_struct( 2, blockcounts, displs, types, &ntype );
MPI_Type_commit( &ntype );
MPI_Type_size( ntype, &nsize );
MPI_Type_lb( ntype, &nlb );
MPI_Type_ub( ntype, &nub );
if (nlb != 0) {
err++;
printf( "LB for struct is %d\n", (int)nlb );
}
if (nub != 4 * sizeof(double)) {
err++;
printf( "UB for struct is %d != %d\n", (int)nub,
4 * (int)sizeof(double) );
}
if (nsize != 4 * sizeof(double)) {
err++;
printf( "Size for struct %d != %d\n", nsize, 4 * (int)sizeof(double) );
}
MPI_Type_contiguous( 3, ntype, &n2type );
MPI_Type_commit( &n2type );
MPI_Type_size( n2type, &n2size );
MPI_Type_lb( n2type, &n2lb );
MPI_Type_ub( n2type, &n2ub );
if (n2size != 3 * nsize) {
err++;
printf( "Size of contig type %d != %d\n", n2size, 3*nsize );
}
if (n2lb != 0) {
err++;
printf( "LB for contig is %d\n", (int)n2lb );
}
if (n2ub != 3 * nub) {
err++;
printf( "UB for contig %d != %d\n", (int)n2ub, 3 * (int)nub );
}
if (err) {
printf( "Found %d errors\n", err );
}
else {
printf( " No Errors\n" );
}
MPI_Type_free( &ntype );
MPI_Type_free( &n2type );
MPI_Finalize();
return 0;
}
void declareBindings (void)
{
/* === Point-to-point === */
void* buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
MPI_Send (buf, count, datatype, dest, tag, comm); // L12
int source;
MPI_Status status;
MPI_Recv (buf, count, datatype, source, tag, comm, &status); // L15
MPI_Get_count (&status, datatype, &count);
MPI_Bsend (buf, count, datatype, dest, tag, comm);
MPI_Ssend (buf, count, datatype, dest, tag, comm);
MPI_Rsend (buf, count, datatype, dest, tag, comm);
void* buffer;
int size;
MPI_Buffer_attach (buffer, size); // L22
MPI_Buffer_detach (buffer, &size);
MPI_Request request;
MPI_Isend (buf, count, datatype, dest, tag, comm, &request); // L25
MPI_Ibsend (buf, count, datatype, dest, tag, comm, &request);
MPI_Issend (buf, count, datatype, dest, tag, comm, &request);
MPI_Irsend (buf, count, datatype, dest, tag, comm, &request);
MPI_Irecv (buf, count, datatype, source, tag, comm, &request);
MPI_Wait (&request, &status);
int flag;
MPI_Test (&request, &flag, &status); // L32
MPI_Request_free (&request);
MPI_Request* array_of_requests;
int index;
MPI_Waitany (count, array_of_requests, &index, &status); // L36
MPI_Testany (count, array_of_requests, &index, &flag, &status);
MPI_Status* array_of_statuses;
MPI_Waitall (count, array_of_requests, array_of_statuses); // L39
MPI_Testall (count, array_of_requests, &flag, array_of_statuses);
int incount;
int outcount;
int* array_of_indices;
MPI_Waitsome (incount, array_of_requests, &outcount, array_of_indices,
array_of_statuses); // L44--45
MPI_Testsome (incount, array_of_requests, &outcount, array_of_indices,
array_of_statuses); // L46--47
MPI_Iprobe (source, tag, comm, &flag, &status); // L48
MPI_Probe (source, tag, comm, &status);
MPI_Cancel (&request);
MPI_Test_cancelled (&status, &flag);
MPI_Send_init (buf, count, datatype, dest, tag, comm, &request);
MPI_Bsend_init (buf, count, datatype, dest, tag, comm, &request);
MPI_Ssend_init (buf, count, datatype, dest, tag, comm, &request);
MPI_Rsend_init (buf, count, datatype, dest, tag, comm, &request);
MPI_Recv_init (buf, count, datatype, source, tag, comm, &request);
MPI_Start (&request);
MPI_Startall (count, array_of_requests);
void* sendbuf;
int sendcount;
MPI_Datatype sendtype;
int sendtag;
void* recvbuf;
int recvcount;
MPI_Datatype recvtype;
MPI_Datatype recvtag;
MPI_Sendrecv (sendbuf, sendcount, sendtype, dest, sendtag,
recvbuf, recvcount, recvtype, source, recvtag,
comm, &status); // L67--69
MPI_Sendrecv_replace (buf, count, datatype, dest, sendtag, source, recvtag,
comm, &status); // L70--71
MPI_Datatype oldtype;
MPI_Datatype newtype;
MPI_Type_contiguous (count, oldtype, &newtype); // L74
int blocklength;
{
int stride;
MPI_Type_vector (count, blocklength, stride, oldtype, &newtype); // L78
}
{
MPI_Aint stride;
MPI_Type_hvector (count, blocklength, stride, oldtype, &newtype); // L82
}
int* array_of_blocklengths;
{
int* array_of_displacements;
MPI_Type_indexed (count, array_of_blocklengths, array_of_displacements,
oldtype, &newtype); // L87--88
}
{
MPI_Aint* array_of_displacements;
MPI_Type_hindexed (count, array_of_blocklengths, array_of_displacements,
oldtype, &newtype); // L92--93
MPI_Datatype* array_of_types;
MPI_Type_struct (count, array_of_blocklengths, array_of_displacements,
array_of_types, &newtype); // L95--96
}
void* location;
MPI_Aint address;
MPI_Address (location, &address); // L100
MPI_Aint extent;
MPI_Type_extent (datatype, &extent); // L102
MPI_Type_size (datatype, &size);
MPI_Aint displacement;
MPI_Type_lb (datatype, &displacement); // L105
MPI_Type_ub (datatype, &displacement);
MPI_Type_commit (&datatype);
MPI_Type_free (&datatype);
MPI_Get_elements (&status, datatype, &count);
void* inbuf;
void* outbuf;
int outsize;
int position;
MPI_Pack (inbuf, incount, datatype, outbuf, outsize, &position, comm); // L114
int insize;
MPI_Unpack (inbuf, insize, &position, outbuf, outcount, datatype,
comm); // L116--117
MPI_Pack_size (incount, datatype, comm, &size);
/* === Collectives === */
MPI_Barrier (comm); // L121
int root;
MPI_Bcast (buffer, count, datatype, root, comm); // L123
MPI_Gather (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
root, comm); // L124--125
int* recvcounts;
int* displs;
MPI_Gatherv (sendbuf, sendcount, sendtype,
recvbuf, recvcounts, displs, recvtype,
root, comm); // L128--130
MPI_Scatter (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
root, comm); // L131--132
int* sendcounts;
MPI_Scatterv (sendbuf, sendcounts, displs, sendtype,
recvbuf, recvcount, recvtype, root, comm); // L134--135
MPI_Allgather (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
comm); // L136--137
MPI_Allgatherv (sendbuf, sendcount, sendtype,
recvbuf, recvcounts, displs, recvtype,
comm); // L138--140
MPI_Alltoall (sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype,
comm); // L141--142
int* sdispls;
int* rdispls;
MPI_Alltoallv (sendbuf, sendcounts, sdispls, sendtype,
recvbuf, recvcounts, rdispls, recvtype,
comm); // L145--147
MPI_Op op;
MPI_Reduce (sendbuf, recvbuf, count, datatype, op, root, comm); // L149
#if 0
MPI_User_function function;
int commute;
MPI_Op_create (function, commute, &op); // L153
#endif
MPI_Op_free (&op); // L155
MPI_Allreduce (sendbuf, recvbuf, count, datatype, op, comm);
MPI_Reduce_scatter (sendbuf, recvbuf, recvcounts, datatype, op, comm);
MPI_Scan (sendbuf, recvbuf, count, datatype, op, comm);
/* === Groups, contexts, and communicators === */
MPI_Group group;
MPI_Group_size (group, &size); // L162
int rank;
MPI_Group_rank (group, &rank); // L164
MPI_Group group1;
int n;
int* ranks1;
MPI_Group group2;
int* ranks2;
MPI_Group_translate_ranks (group1, n, ranks1, group2, ranks2); // L170
int result;
MPI_Group_compare (group1, group2, &result); // L172
MPI_Group newgroup;
MPI_Group_union (group1, group2, &newgroup); // L174
MPI_Group_intersection (group1, group2, &newgroup);
MPI_Group_difference (group1, group2, &newgroup);
int* ranks;
MPI_Group_incl (group, n, ranks, &newgroup); // L178
MPI_Group_excl (group, n, ranks, &newgroup);
extern int ranges[][3];
MPI_Group_range_incl (group, n, ranges, &newgroup); // L181
MPI_Group_range_excl (group, n, ranges, &newgroup);
MPI_Group_free (&group);
MPI_Comm_size (comm, &size);
MPI_Comm_rank (comm, &rank);
MPI_Comm comm1;
MPI_Comm comm2;
MPI_Comm_compare (comm1, comm2, &result);
MPI_Comm newcomm;
MPI_Comm_dup (comm, &newcomm);
MPI_Comm_create (comm, group, &newcomm);
int color;
int key;
MPI_Comm_split (comm, color, key, &newcomm); // L194
MPI_Comm_free (&comm);
MPI_Comm_test_inter (comm, &flag);
MPI_Comm_remote_size (comm, &size);
MPI_Comm_remote_group (comm, &group);
MPI_Comm local_comm;
int local_leader;
MPI_Comm peer_comm;
int remote_leader;
MPI_Comm newintercomm;
MPI_Intercomm_create (local_comm, local_leader, peer_comm, remote_leader, tag,
&newintercomm); // L204--205
MPI_Comm intercomm;
MPI_Comm newintracomm;
int high;
MPI_Intercomm_merge (intercomm, high, &newintracomm); // L209
int keyval;
#if 0
MPI_Copy_function copy_fn;
MPI_Delete_function delete_fn;
void* extra_state;
MPI_Keyval_create (copy_fn, delete_fn, &keyval, extra_state); // L215
#endif
MPI_Keyval_free (&keyval); // L217
void* attribute_val;
MPI_Attr_put (comm, keyval, attribute_val); // L219
MPI_Attr_get (comm, keyval, attribute_val, &flag);
MPI_Attr_delete (comm, keyval);
/* === Environmental inquiry === */
char* name;
int resultlen;
MPI_Get_processor_name (name, &resultlen); // L226
MPI_Errhandler errhandler;
#if 0
MPI_Handler_function function;
MPI_Errhandler_create (function, &errhandler); // L230
#endif
MPI_Errhandler_set (comm, errhandler); // L232
MPI_Errhandler_get (comm, &errhandler);
MPI_Errhandler_free (&errhandler);
int errorcode;
char* string;
MPI_Error_string (errorcode, string, &resultlen); // L237
int errorclass;
MPI_Error_class (errorcode, &errorclass); // L239
MPI_Wtime ();
MPI_Wtick ();
int argc;
char** argv;
MPI_Init (&argc, &argv); // L244
MPI_Finalize ();
MPI_Initialized (&flag);
MPI_Abort (comm, errorcode);
}
