JNIEXPORT void JNICALL Java_mpi_File_writeOrderedBegin(
JNIEnv *env, jobject jthis, jlong fh,
jobject buf, jint count, jlong type)
{
void *ptr = (*env)->GetDirectBufferAddress(env, buf);
int rc = MPI_File_write_ordered_begin(
(MPI_File)fh, ptr, count, (MPI_Datatype)type);
ompi_java_exceptionCheck(env, rc);
}
JNIEXPORT void JNICALL Java_mpi_Prequest_startAll(
JNIEnv *env, jclass clazz, jlongArray prequests)
{
int count = (*env)->GetArrayLength(env, prequests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, prequests, &jReq, (void***)&cReq);
int rc = MPI_Startall(count, cReq);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, prequests, jReq, (void**)cReq);
}
JNIEXPORT void JNICALL Java_mpi_MPI_detachBuffer_1jni(
JNIEnv *env, jclass jthis, jbyteArray buf)
{
int size;
jbyte* bufptr;
int rc = MPI_Buffer_detach(&bufptr, &size);
ompi_java_exceptionCheck(env, rc);
if(buf != NULL)
(*env)->ReleaseByteArrayElements(env,buf,bufptr,0);
}
JNIEXPORT jintArray JNICALL Java_mpi_GraphComm_getNeighbors(
JNIEnv *env, jobject jthis, jlong comm, jint rank)
{
int maxNs;
int rc = MPI_Graph_neighbors_count((MPI_Comm)comm, rank, &maxNs);
if(ompi_java_exceptionCheck(env, rc))
return NULL;
jintArray neighbors = (*env)->NewIntArray(env, maxNs);
jint *jNeighbors;
int *cNeighbors;
ompi_java_getIntArray(env, neighbors, &jNeighbors, &cNeighbors);
rc = MPI_Graph_neighbors((MPI_Comm)comm, rank, maxNs, cNeighbors);
ompi_java_exceptionCheck(env, rc);
ompi_java_releaseIntArray(env, neighbors, jNeighbors, cNeighbors);
return neighbors;
}
JNIEXPORT jlong JNICALL Java_mpi_Message_mProbe(
JNIEnv *env, jobject jthis,
jint source, jint tag, jlong jComm, jlongArray jStatus)
{
MPI_Comm comm = (MPI_Comm)jComm;
MPI_Message message;
MPI_Status status;
int rc = MPI_Mprobe(source, tag, comm, &message, &status);
ompi_java_exceptionCheck(env, rc);
ompi_java_status_set(env, jStatus, &status);
return (jlong)message;
}
JNIEXPORT jlong JNICALL Java_mpi_Win_createDynamicWin(
JNIEnv *env, jobject jthis,
jlong info, jlong comm)
{
MPI_Win win;
int rc = MPI_Win_create_dynamic(
(MPI_Info)info, (MPI_Comm)comm, &win);
ompi_java_exceptionCheck(env, rc);
return (jlong)win;
}
/*
* Class: mpi_MPI
* Method: getProcessorName
* Signature: ([B)I
*/
JNIEXPORT jint JNICALL Java_mpi_MPI_getProcessorName(
JNIEnv *env, jclass obj, jbyteArray buf)
{
int len, rc;
jboolean isCopy;
jbyte* bufc = (jbyte*)((*env)->GetByteArrayElements(env,buf,&isCopy)) ;
rc = MPI_Get_processor_name((char*)bufc, &len);
ompi_java_exceptionCheck(env, rc);
(*env)->ReleaseByteArrayElements(env,buf,bufc,0) ;
return len;
}
JNIEXPORT jobject JNICALL Java_mpi_Datatype_getAttr(
JNIEnv *env, jobject jthis, jlong type, jint keyval)
{
int flag;
void *val;
int rc = MPI_Type_get_attr((MPI_Datatype)type, keyval, &val, &flag);
if(ompi_java_exceptionCheck(env, rc) || !flag)
return NULL;
return ompi_java_attrGet(env, val);
}
JNIEXPORT jint JNICALL Java_mpi_Status_getElements(
JNIEnv *env, jobject jthis, jint source, jint tag,
jint error, jint cancelled, jlong ucount, jlong jType)
{
int count;
MPI_Status stat;
getStatus(&stat, source, tag, error, cancelled, ucount);
MPI_Datatype datatype = (MPI_Datatype)jType;
int rc = MPI_Get_elements(&stat, datatype, &count);
ompi_java_exceptionCheck(env, rc);
return count;
}
JNIEXPORT jstring JNICALL Java_mpi_Datatype_getName(
JNIEnv *env, jobject jthis, jlong handle)
{
char name[MPI_MAX_OBJECT_NAME];
int len;
int rc = MPI_Type_get_name((MPI_Datatype)handle, name, &len);
if(ompi_java_exceptionCheck(env, rc))
return NULL;
return (*env)->NewStringUTF(env, name);
}
JNIEXPORT jlong JNICALL Java_mpi_Datatype_getHVector(
JNIEnv *env, jclass clazz, jint count,
jint blockLength, jint stride, jlong oldType)
{
MPI_Datatype type;
int rc = MPI_Type_hvector(count, blockLength, stride,
(MPI_Datatype)oldType, &type);
ompi_java_exceptionCheck(env, rc);
return (jlong)type;
}
JNIEXPORT jboolean JNICALL Java_mpi_Request_testAll(
JNIEnv *env, jclass jthis, jlongArray requests)
{
int count = (*env)->GetArrayLength(env, requests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
int flag;
int rc = MPI_Testall(count, cReq, &flag, MPI_STATUSES_IGNORE);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
return flag ? JNI_TRUE : JNI_FALSE;
}
JNIEXPORT jlong JNICALL Java_mpi_File_iWriteShared(
JNIEnv *env, jobject jthis, jlong fh,
jobject buf, jint count, jlong type)
{
void *ptr = (*env)->GetDirectBufferAddress(env, buf);
MPI_Request request;
int rc = MPI_File_iwrite_shared((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &request);
ompi_java_exceptionCheck(env, rc);
return (jlong)request;
}
JNIEXPORT jint JNICALL Java_mpi_Request_testAny(
JNIEnv *env, jclass clazz, jlongArray requests)
{
int count = (*env)->GetArrayLength(env, requests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
int index, flag;
int rc = MPI_Testany(count, cReq, &index, &flag, MPI_STATUS_IGNORE);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
return index;
}
JNIEXPORT jlong JNICALL Java_mpi_Datatype_free(
JNIEnv *env, jobject jthis, jlong handle)
{
MPI_Datatype type = (MPI_Datatype)handle;
if(type != MPI_DATATYPE_NULL)
{
int rc = MPI_Type_free(&type);
ompi_java_exceptionCheck(env, rc);
}
return (jlong)type;
}
/*
* Class: mpi_MPI
* Method: isFinalized
* Signature: ()Z
*/
JNIEXPORT jboolean JNICALL Java_mpi_MPI_isFinalized(JNIEnv *env, jclass jthis)
{
int flag, rc;
rc = MPI_Finalized(&flag);
ompi_java_exceptionCheck(env, rc);
if (flag==0) {
return JNI_FALSE;
} else {
return JNI_TRUE;
}
}
JNIEXPORT jobject JNICALL Java_mpi_GraphComm_getDistGraphNeighbors(
JNIEnv *env, jobject jthis, jlong comm)
{
int inDegree, outDegree, weighted;
int rc = MPI_Dist_graph_neighbors_count(
(MPI_Comm)comm, &inDegree, &outDegree, &weighted);
if(ompi_java_exceptionCheck(env, rc))
return NULL;
jintArray sources = (*env)->NewIntArray(env, inDegree),
srcWeights = (*env)->NewIntArray(env, inDegree),
destinations = (*env)->NewIntArray(env, outDegree),
destWeights = (*env)->NewIntArray(env, outDegree);
jint *jSources, *jSrcWeights, *jDestinations, *jDestWeights;
int *cSources, *cSrcWeights, *cDestinations, *cDestWeights;
ompi_java_getIntArray(env, sources, &jSources, &cSources);
ompi_java_getIntArray(env, srcWeights, &jSrcWeights, &cSrcWeights);
ompi_java_getIntArray(env, destinations, &jDestinations, &cDestinations);
ompi_java_getIntArray(env, destWeights, &jDestWeights, &cDestWeights);
rc = MPI_Dist_graph_neighbors((MPI_Comm)comm,
inDegree, cSources, cSrcWeights,
outDegree, cDestinations, cDestWeights);
ompi_java_exceptionCheck(env, rc);
ompi_java_releaseIntArray(env, sources, jSources, cSources);
ompi_java_releaseIntArray(env, srcWeights, jSrcWeights, cSrcWeights);
ompi_java_releaseIntArray(env, destinations, jDestinations, cDestinations);
ompi_java_releaseIntArray(env, destWeights, jDestWeights, cDestWeights);
return (*env)->NewObject(env,
ompi_java.DistGraphNeighborsClass, ompi_java.DistGraphNeighborsInit,
sources, srcWeights, destinations, destWeights,
weighted ? JNI_TRUE : JNI_FALSE);
}
/*
* Class: mpi_Win
* Method: createWin
* Signature: (Ljava/nio/Buffer;IIJJ)J
*/
JNIEXPORT jlong JNICALL Java_mpi_Win_createWin(
JNIEnv *env, jobject jthis, jobject jBase,
jint size, jint dispUnit, jlong info, jlong comm)
{
void *base = (*env)->GetDirectBufferAddress(env, jBase);
MPI_Win win;
int rc = MPI_Win_create(base, (MPI_Aint)size, dispUnit,
(MPI_Info)info, (MPI_Comm)comm, &win);
ompi_java_exceptionCheck(env, rc);
return (jlong)win;
}
JNIEXPORT void JNICALL Java_mpi_Datatype_getLbExtent(
JNIEnv *env, jobject jthis, jlong type, jintArray jLbExt)
{
MPI_Aint lb, extent;
int rc = MPI_Type_get_extent((MPI_Datatype)type, &lb, &extent);
if(ompi_java_exceptionCheck(env, rc))
return;
jint *lbExt = (*env)->GetIntArrayElements(env, jLbExt, NULL);
lbExt[0] = (jint)lb;
lbExt[1] = (jint)extent;
(*env)->ReleaseIntArrayElements(env, jLbExt, lbExt, 0);
}
JNIEXPORT void JNICALL Java_mpi_File_setView(
JNIEnv *env, jobject jthis, jlong fh, jlong disp,
jlong etype, jlong filetype, jstring jdatarep, jlong info)
{
const char* datarep = (*env)->GetStringUTFChars(env, jdatarep, NULL);
int rc = MPI_File_set_view(
(MPI_File)fh, (MPI_Offset)disp, (MPI_Datatype)etype,
(MPI_Datatype)filetype, (char*)datarep, (MPI_Info)info);
ompi_java_exceptionCheck(env, rc);
(*env)->ReleaseStringUTFChars(env, jdatarep, datarep);
}
/*
* Class: mpi_Win
* Method: get
* Signature: (JLjava/lang/Object;IJIIIJI)V
*/
JNIEXPORT void JNICALL Java_mpi_Win_get(
JNIEnv *env, jobject jthis, jlong win, jobject origin,
jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
jint targetCount, jlong targetType, jint baseType)
{
void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
int rc = MPI_Get(orgPtr, orgCount, (MPI_Datatype)orgType,
targetRank, (MPI_Aint)targetDisp, targetCount,
(MPI_Datatype)targetType, (MPI_Win)win);
ompi_java_exceptionCheck(env, rc);
}
JNIEXPORT void JNICALL Java_mpi_File_writeOrdered(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint off, jint count, jlong jType, jint bType, jlongArray stat)
{
MPI_Datatype type = (MPI_Datatype)jType;
void *ptr;
ompi_java_buffer_t *item;
ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
MPI_Status status;
int rc = MPI_File_write_ordered((MPI_File)fh, ptr, count, type, &status);
ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadPtr(ptr, item, buf, db);
ompi_java_status_set(env, stat, &status);
}
JNIEXPORT void JNICALL Java_mpi_Request_waitAnyStatus(
JNIEnv *env, jclass clazz, jlongArray requests, jobject stat)
{
int count = (*env)->GetArrayLength(env, requests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
int index;
MPI_Status status;
int rc = MPI_Waitany(count, cReq, &index, &status);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
ompi_java_status_setIndex(env, stat, &status, index);
}
JNIEXPORT jobject JNICALL Java_mpi_Request_testAnyStatus(
JNIEnv *env, jclass clazz, jlongArray requests)
{
int count = (*env)->GetArrayLength(env, requests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
int index, flag;
MPI_Status status;
int rc = MPI_Testany(count, cReq, &index, &flag, &status);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
return flag ? ompi_java_status_newIndex(env, &status, index) : NULL;
}
JNIEXPORT jlong JNICALL Java_mpi_Message_imRecv(
JNIEnv *env, jobject jthis, jlong jMessage,
jobject buf, jint count, jlong jType)
{
MPI_Message message = (MPI_Message)jMessage;
MPI_Datatype type = (MPI_Datatype)jType;
void *ptr = ompi_java_getDirectBufferAddress(env, buf);
MPI_Request request;
int rc = MPI_Imrecv(ptr, count, type, &message, &request);
ompi_java_exceptionCheck(env, rc);
(*env)->SetLongField(env, jthis, ompi_java.MessageHandle, (jlong)message);
return (jlong)request;
}
JNIEXPORT jlong JNICALL Java_mpi_File_open(
JNIEnv *env, jobject jthis, jlong comm,
jstring jfilename, jint amode, jlong info)
{
const char* filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
MPI_File fh;
int rc = MPI_File_open((MPI_Comm)comm, (char*)filename,
amode, (MPI_Info)info, &fh);
ompi_java_exceptionCheck(env, rc);
(*env)->ReleaseStringUTFChars(env, jfilename, filename);
return (jlong)fh;
}
JNIEXPORT void JNICALL Java_mpi_Win_accumulate(
JNIEnv *env, jobject jthis, jlong win,
jobject origin, jint orgCount, jlong orgType,
jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
jobject jOp, jlong hOp, jint baseType)
{
void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
int rc = MPI_Accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
targetRank, (MPI_Aint)targetDisp, targetCount,
(MPI_Datatype)targetType, op, (MPI_Win)win);
ompi_java_exceptionCheck(env, rc);
}
JNIEXPORT jobject JNICALL Java_mpi_Message_imProbe(
JNIEnv *env, jobject jthis, jint source, jint tag, jlong jComm)
{
MPI_Comm comm = (MPI_Comm)jComm;
MPI_Message message;
MPI_Status status;
int rc, flag;
rc = MPI_Improbe(source, tag, comm, &flag, &message, &status);
if(ompi_java_exceptionCheck(env, rc) || !flag)
return NULL;
(*env)->SetLongField(env, jthis, ompi_java.MessageHandle, (jlong)message);
return ompi_java_status_new(env, &status);
}
JNIEXPORT jobjectArray JNICALL Java_mpi_Request_waitAllStatus(
JNIEnv *env, jclass clazz, jlongArray requests)
{
int count = (*env)->GetArrayLength(env, requests);
jlong* jReq;
MPI_Request *cReq;
ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
MPI_Status *statuses = (MPI_Status*)calloc(count, sizeof(MPI_Status));
int rc = MPI_Waitall(count, cReq, statuses);
ompi_java_exceptionCheck(env, rc);
ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
jobjectArray jStatuses = newStatuses(env, statuses, count);
free(statuses);
return jStatuses;
}
JNIEXPORT jlong JNICALL Java_mpi_Group_excl(
JNIEnv *env, jobject jthis, jlong group, jintArray ranks)
{
jsize n = (*env)->GetArrayLength(env, ranks);
jint *jRanks;
int *cRanks;
ompi_java_getIntArray(env, ranks, &jRanks, &cRanks);
MPI_Group newGroup;
int rc = MPI_Group_excl((MPI_Group)group, n, cRanks, &newGroup);
ompi_java_exceptionCheck(env, rc);
ompi_java_forgetIntArray(env, ranks, jRanks, cRanks);
return (jlong)newGroup;
}
