ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Improve access to buffers.

Просмотр исходного кода 
This commit was SVN r30745.
Этот коммит содержится в:
Oscar Vega-Gisbert 2014-02-16 22:58:01 +00:00
родитель ea0217c337
Коммит 86e40c568a
9 изменённых файлов: 513 добавлений и 390 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

7
ompi/mpi/java/c/mpiJava.h
Просмотреть файл

@ -60,13 +60,14 @@ extern ompi_java_globals_t ompi_java;
void ompi_java_init_native_Datatype(JNIEnv *env); void ompi_java_init_native_Datatype(JNIEnv *env);
void* ompi_java_getBufPtr( void* ompi_java_getBufPtr(
void** bufBase, JNIEnv *env, jobject buf, int baseType, int offset); void** bufBase, JNIEnv *env,
jobject buf, jboolean db, int baseType, int offset);
void ompi_java_releaseBufPtr( void ompi_java_releaseBufPtr(
JNIEnv *env, jobject buf, void* bufBase, int baseType); JNIEnv *env, jobject buf, jboolean db, void* bufBase, int baseType);
void ompi_java_releaseReadBufPtr( void ompi_java_releaseReadBufPtr(
JNIEnv *env, jobject buf, void *bufBase, int baseType); JNIEnv *env, jobject buf, jboolean db, void *bufBase, int baseType);
void* ompi_java_getDirectBufferAddress(JNIEnv *env, jobject buf); void* ompi_java_getDirectBufferAddress(JNIEnv *env, jobject buf);

274
ompi/mpi/java/c/mpi_Comm.c
Просмотреть файл

@ -132,7 +132,7 @@ static void releaseArrayPtr(JNIEnv *e, jobject buf, void *bufBase,
} }
void* ompi_java_getBufPtr(void** bufBase, JNIEnv *env, jobject buf, void* ompi_java_getBufPtr(void** bufBase, JNIEnv *env, jobject buf,
int baseType, int offset) jboolean db, int baseType, int offset)
{ {
if(buf == NULL) if(buf == NULL)
{ {
@ -140,12 +140,9 @@ void* ompi_java_getBufPtr(void** bufBase, JNIEnv *env, jobject buf,
*bufBase = NULL; *bufBase = NULL;
return NULL; return NULL;
} }
else else if(db)
{ {
*bufBase = (*env)->GetDirectBufferAddress(env, buf); *bufBase = (*env)->GetDirectBufferAddress(env, buf);
if(*bufBase != NULL)
{
assert(offset == 0); assert(offset == 0);
return *bufBase; return *bufBase;
} }
@ -154,19 +151,18 @@ void* ompi_java_getBufPtr(void** bufBase, JNIEnv *env, jobject buf,
return getArrayPtr(bufBase, env, buf, baseType, offset); return getArrayPtr(bufBase, env, buf, baseType, offset);
} }
} }
}
void ompi_java_releaseBufPtr(JNIEnv *env, jobject buf, void ompi_java_releaseBufPtr(JNIEnv *env, jobject buf, jboolean db,
void* bufBase, int baseType) void* bufBase, int baseType)
{ {
if(buf != NULL && (*env)->GetDirectBufferAddress(env, buf) == NULL) if(buf != NULL && !db)
releaseArrayPtr(env, buf, bufBase, baseType, 0); releaseArrayPtr(env, buf, bufBase, baseType, 0);
} }
void ompi_java_releaseReadBufPtr( void ompi_java_releaseReadBufPtr(JNIEnv *env, jobject buf, jboolean db,
JNIEnv *env, jobject buf, void *bufBase, int baseType) void *bufBase, int baseType)
{ {
if(buf != NULL && (*env)->GetDirectBufferAddress(env, buf) == NULL) if(buf != NULL && !db)
releaseArrayPtr(env, buf, bufBase, baseType, JNI_ABORT); releaseArrayPtr(env, buf, bufBase, baseType, JNI_ABORT);
} }
@ -212,13 +208,19 @@ static void* getArrayCritical(void** bufBase, JNIEnv *env,
} }
} }
static void* getBufCritical(void** bufBase, JNIEnv *env, static void* getBufCritical(
jobject buf, int baseType, int offset) void** bufBase, JNIEnv *env,
jobject buf, jboolean db, int baseType, int offset)
{
if(buf == NULL)
{
/* Allow NULL buffers to send/recv 0 items as control messages. */
*bufBase = NULL;
return NULL;
}
else if(db)
{ {
*bufBase = (*env)->GetDirectBufferAddress(env, buf); *bufBase = (*env)->GetDirectBufferAddress(env, buf);
if(*bufBase != NULL)
{
assert(offset == 0); assert(offset == 0);
return *bufBase; return *bufBase;
} }
@ -228,9 +230,10 @@ static void* getBufCritical(void** bufBase, JNIEnv *env,
} }
} }
static void releaseBufCritical(JNIEnv *env, jobject buf, void* bufBase) static void releaseBufCritical(
JNIEnv *env, jobject buf, jboolean db, void* bufBase)
{ {
if((*env)->GetDirectBufferAddress(env, buf) == NULL) if(buf != NULL && !db)
(*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0); (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0);
} }
@ -359,44 +362,46 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_createIntercomm(
} }
JNIEXPORT void JNICALL Java_mpi_Comm_send( JNIEXPORT void JNICALL Java_mpi_Comm_send(
JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jint offset, JNIEnv *env, jobject jthis, jlong jComm,
jint count, jlong jType, jint baseType, jint dest, jint tag) jobject buf, jboolean db, jint offset, jint count,
jlong jType, jint baseType, jint dest, jint tag)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Send(bufPtr, count, type, dest, tag, comm); int rc = MPI_Send(bufPtr, count, type, dest, tag, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, bufBase, baseType); ompi_java_releaseReadBufPtr(env, buf, db, bufBase, baseType);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_recv( JNIEXPORT void JNICALL Java_mpi_Comm_recv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject buf, jint offset, jint count, jlong jType, jint baseType, jobject buf, jboolean db, jint offset, jint count,
jlong jType, jint baseType,
jint source, jint tag, jobject jStatus) jint source, jint tag, jobject jStatus)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_Recv(bufPtr, count, type, source, tag, comm, &status); int rc = MPI_Recv(bufPtr, count, type, source, tag, comm, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, bufBase, baseType); ompi_java_releaseBufPtr(env, buf, db, bufBase, baseType);
ompi_java_status_set(&status, env, jStatus); ompi_java_status_set(&status, env, jStatus);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv( JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sBuf, jint sOffset, jint sCount, jobject sBuf, jboolean sdb, jint sOffset, jint sCount,
jlong sjType, jint sBaseType, jint dest, jint sTag, jlong sjType, jint sBaseType, jint dest, jint sTag,
jobject rBuf, jint rOffset, jint rCount, jobject rBuf, jboolean rdb, jint rOffset, jint rCount,
jlong rjType, jint rBaseType, jint source, jint rTag, jobject jStatus) jlong rjType, jint rBaseType, jint source, jint rTag, jobject jStatus)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -406,8 +411,8 @@ JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv(
void *sBufPtr, *sBufBase, void *sBufPtr, *sBufBase,
*rBufPtr, *rBufBase; *rBufPtr, *rBufBase;
sBufPtr = ompi_java_getBufPtr(&sBufBase, env, sBuf, sBaseType, sOffset); sBufPtr = ompi_java_getBufPtr(&sBufBase, env, sBuf, sdb, sBaseType, sOffset);
rBufPtr = ompi_java_getBufPtr(&rBufBase, env, rBuf, rBaseType, rOffset); rBufPtr = ompi_java_getBufPtr(&rBufBase, env, rBuf, rdb, rBaseType, rOffset);
MPI_Status status; MPI_Status status;
int rc = MPI_Sendrecv(sBufPtr, sCount, sType, dest, sTag, int rc = MPI_Sendrecv(sBufPtr, sCount, sType, dest, sTag,
@ -415,14 +420,15 @@ JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv(
comm, &status); comm, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, sBuf, sBufBase, sBaseType); ompi_java_releaseReadBufPtr(env, sBuf, sdb, sBufBase, sBaseType);
ompi_java_releaseBufPtr(env, rBuf, rBufBase, rBaseType); ompi_java_releaseBufPtr(env, rBuf, rdb, rBufBase, rBaseType);
ompi_java_status_set(&status, env, jStatus); ompi_java_status_set(&status, env, jStatus);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_sendRecvReplace( JNIEXPORT void JNICALL Java_mpi_Comm_sendRecvReplace(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject buf, jint offset, jint count, jlong jType, jint baseType, jobject buf, jboolean db, jint offset,
jint count, jlong jType, jint baseType,
jint dest, jint sTag, jint source, jint rTag, jobject jStatus) jint dest, jint sTag, jint source, jint rTag, jobject jStatus)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -430,59 +436,62 @@ JNIEXPORT void JNICALL Java_mpi_Comm_sendRecvReplace(
MPI_Status status; MPI_Status status;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Sendrecv_replace(bufPtr, count, type, dest, int rc = MPI_Sendrecv_replace(bufPtr, count, type, dest,
sTag, source, rTag, comm, &status); sTag, source, rTag, comm, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, bufBase, baseType); ompi_java_releaseBufPtr(env, buf, db, bufBase, baseType);
ompi_java_status_set(&status, env, jStatus); ompi_java_status_set(&status, env, jStatus);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_bSend( JNIEXPORT void JNICALL Java_mpi_Comm_bSend(
JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jint offset, JNIEnv *env, jobject jthis, jlong jComm,
jobject buf, jboolean db, jint offset,
jint count, jlong jType, jint baseType, jint dest, jint tag) jint count, jlong jType, jint baseType, jint dest, jint tag)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Bsend(bufPtr, count, type, dest, tag, comm); int rc = MPI_Bsend(bufPtr, count, type, dest, tag, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, bufBase, baseType); ompi_java_releaseReadBufPtr(env, buf, db, bufBase, baseType);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_sSend( JNIEXPORT void JNICALL Java_mpi_Comm_sSend(
JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jint offset, JNIEnv *env, jobject jthis, jlong jComm,
jobject buf, jboolean db, jint offset,
jint count, jlong jType, jint baseType, jint dest, jint tag) jint count, jlong jType, jint baseType, jint dest, jint tag)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Ssend(bufPtr, count, type, dest, tag, comm); int rc = MPI_Ssend(bufPtr, count, type, dest, tag, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, bufBase, baseType); ompi_java_releaseReadBufPtr(env, buf, db, bufBase, baseType);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_rSend( JNIEXPORT void JNICALL Java_mpi_Comm_rSend(
JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jint offset, JNIEnv *env, jobject jthis, jlong jComm,
jobject buf, jboolean db, jint offset,
jint count, jlong jType, jint baseType, jint dest, jint tag) jint count, jlong jType, jint baseType, jint dest, jint tag)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Rsend(bufPtr, count, type, dest, tag, comm); int rc = MPI_Rsend(bufPtr, count, type, dest, tag, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, bufBase, baseType); ompi_java_releaseReadBufPtr(env, buf, db, bufBase, baseType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iSend( JNIEXPORT jlong JNICALL Java_mpi_Comm_iSend(
@ -626,7 +635,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_recvInit(
} }
JNIEXPORT jint JNICALL Java_mpi_Comm_pack( JNIEXPORT jint JNICALL Java_mpi_Comm_pack(
JNIEnv *env, jobject jthis, jlong jComm, jobject inBuf, jint offset, JNIEnv *env, jobject jthis, jlong jComm,
jobject inBuf, jboolean indb, jint offset,
jint inCount, jlong jType, jint bType, jbyteArray outBuf, jint position) jint inCount, jlong jType, jint bType, jbyteArray outBuf, jint position)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -635,7 +645,7 @@ JNIEXPORT jint JNICALL Java_mpi_Comm_pack(
void *oBufPtr, *iBufPtr, *iBufBase; void *oBufPtr, *iBufPtr, *iBufBase;
oBufPtr = (*env)->GetPrimitiveArrayCritical(env, outBuf, NULL); oBufPtr = (*env)->GetPrimitiveArrayCritical(env, outBuf, NULL);
iBufPtr = getBufCritical(&iBufBase, env, inBuf, bType, offset); iBufPtr = getBufCritical(&iBufBase, env, inBuf, indb, bType, offset);
if(inCount != 0 && outSize != position) if(inCount != 0 && outSize != position)
{ {
@ -646,14 +656,14 @@ JNIEXPORT jint JNICALL Java_mpi_Comm_pack(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
} }
releaseBufCritical(env, inBuf, iBufBase); releaseBufCritical(env, inBuf, indb, iBufBase);
(*env)->ReleasePrimitiveArrayCritical(env, outBuf, oBufPtr, 0); (*env)->ReleasePrimitiveArrayCritical(env, outBuf, oBufPtr, 0);
return position; return position;
} }
JNIEXPORT jint JNICALL Java_mpi_Comm_unpack( JNIEXPORT jint JNICALL Java_mpi_Comm_unpack(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jbyteArray inBuf, jint position, jobject outBuf, jbyteArray inBuf, jint position, jobject outBuf, jboolean outdb,
jint offset, jint outCount, jlong jType, jint bType) jint offset, jint outCount, jlong jType, jint bType)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -662,14 +672,14 @@ JNIEXPORT jint JNICALL Java_mpi_Comm_unpack(
void *iBufPtr, *oBufPtr, *oBufBase; void *iBufPtr, *oBufPtr, *oBufBase;
iBufPtr = (*env)->GetPrimitiveArrayCritical(env, inBuf, NULL); iBufPtr = (*env)->GetPrimitiveArrayCritical(env, inBuf, NULL);
oBufPtr = getBufCritical(&oBufBase, env, outBuf, bType, offset); oBufPtr = getBufCritical(&oBufBase, env, outBuf, outdb, bType, offset);
int rc = MPI_Unpack(iBufPtr, inSize, &position, int rc = MPI_Unpack(iBufPtr, inSize, &position,
oBufPtr, outCount, type, comm); oBufPtr, outCount, type, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
(*env)->ReleasePrimitiveArrayCritical(env, inBuf, iBufPtr, 0); (*env)->ReleasePrimitiveArrayCritical(env, inBuf, iBufPtr, 0);
releaseBufCritical(env, outBuf, oBufBase); releaseBufCritical(env, outBuf, outdb, oBufBase);
return position; return position;
} }
@ -826,18 +836,18 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iBarrier(
} }
JNIEXPORT void JNICALL Java_mpi_Comm_bcast( JNIEXPORT void JNICALL Java_mpi_Comm_bcast(
JNIEnv *env, jobject jthis, jlong jComm, jobject buf, JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jboolean db,
jint offset, jint count, jlong jType, jint baseType, jint root) jint offset, jint count, jlong jType, jint baseType, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, baseType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, baseType, offset);
int rc = MPI_Bcast(bufPtr, count, type, root, comm); int rc = MPI_Bcast(bufPtr, count, type, root, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, bufBase, baseType); ompi_java_releaseBufPtr(env, buf, db, bufBase, baseType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iBcast( JNIEXPORT jlong JNICALL Java_mpi_Comm_iBcast(
@ -856,9 +866,9 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iBcast(
JNIEXPORT void JNICALL Java_mpi_Comm_gather( JNIEXPORT void JNICALL Java_mpi_Comm_gather(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jobject sendBuf, jboolean sdb, jint sOffset, jint sCount,
jlong sjType, jint sBType, jlong sjType, jint sBType,
jobject recvBuf, jint rOffset, jint rCount, jobject recvBuf, jboolean rdb, jint rOffset, jint rCount,
jlong rjType, jint rBType, jint root) jlong rjType, jint rBType, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -882,7 +892,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gather(
else else
{ {
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
} }
MPI_Datatype rType = (MPI_Datatype)rjType; MPI_Datatype rType = (MPI_Datatype)rjType;
@ -899,7 +909,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gather(
* in all processes, notwithstanding what the spec says.) * in all processes, notwithstanding what the spec says.)
*/ */
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
if(!rootOrInter) if(!rootOrInter)
{ {
@ -918,10 +928,10 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gather(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
if(rootOrInter || sendBuf == NULL) if(rootOrInter || sendBuf == NULL)
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iGather( JNIEXPORT jlong JNICALL Java_mpi_Comm_iGather(
@ -987,8 +997,9 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iGather(
JNIEXPORT void JNICALL Java_mpi_Comm_gatherv( JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jlong sjType, jint sBType, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jint rOffset, jintArray rCounts, jint sCount, jlong sjType, jint sBType,
jobject recvBuf, jboolean rdb, jint rOffset, jintArray rCounts,
jintArray displs, jlong rjType, jint rBType, jint root) jintArray displs, jlong rjType, jint rBType, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1012,7 +1023,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
else else
{ {
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
} }
jint *jRCounts = NULL, *jDispls = NULL; jint *jRCounts = NULL, *jDispls = NULL;
@ -1025,7 +1036,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
ompi_java_getIntArray(env, displs, &jDispls, &cDispls); ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
rType = (MPI_Datatype)rjType; rType = (MPI_Datatype)rjType;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
} }
rc = MPI_Gatherv(sPtr, sCount, sType, rPtr, cRCounts, rc = MPI_Gatherv(sPtr, sCount, sType, rPtr, cRCounts,
@ -1034,11 +1045,11 @@ JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
if(rootOrInter) if(rootOrInter)
{ {
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts); ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
ompi_java_forgetIntArray(env, displs, jDispls, cDispls); ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
} }
@ -1104,9 +1115,9 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iGatherv(
JNIEXPORT void JNICALL Java_mpi_Comm_scatter( JNIEXPORT void JNICALL Java_mpi_Comm_scatter(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jobject sendBuf, jboolean sdb, jint sOffset, jint sCount,
jlong sjType, jint sBType, jlong sjType, jint sBType,
jobject recvBuf, jint rOffset, jint rCount, jobject recvBuf, jboolean rdb, jint rOffset, jint rCount,
jlong rjType, jint rBType, jint root) jlong rjType, jint rBType, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1129,14 +1140,14 @@ JNIEXPORT void JNICALL Java_mpi_Comm_scatter(
else else
{ {
rType = (MPI_Datatype)rjType; rType = (MPI_Datatype)rjType;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
} }
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
if(rootOrInter || rPtr == MPI_IN_PLACE) if(rootOrInter || rPtr == MPI_IN_PLACE)
{ {
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
if(!rootOrInter) if(!rootOrInter)
{ {
@ -1155,10 +1166,10 @@ JNIEXPORT void JNICALL Java_mpi_Comm_scatter(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
if(rootOrInter || recvBuf == NULL) if(rootOrInter || recvBuf == NULL)
ompi_java_releaseBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseBufPtr(env, sendBuf, sdb, sBase, sBType);
if(recvBuf != NULL) if(recvBuf != NULL)
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatter( JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatter(
@ -1214,9 +1225,9 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatter(
JNIEXPORT void JNICALL Java_mpi_Comm_scatterv( JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jintArray sCounts, jobject sendBuf, jboolean sdb, jint sOffset, jintArray sCounts,
jintArray displs, jlong sjType, jint sBType, jintArray displs, jlong sjType, jint sBType,
jobject recvBuf, jint rOffset, jint rCount, jobject recvBuf, jboolean rdb, jint rOffset, jint rCount,
jlong rjType, jint rBType, jint root) jlong rjType, jint rBType, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1240,7 +1251,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
else else
{ {
rType = (MPI_Datatype)rjType; rType = (MPI_Datatype)rjType;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
} }
jint *jSCounts = NULL, *jDispls = NULL; jint *jSCounts = NULL, *jDispls = NULL;
@ -1253,7 +1264,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
ompi_java_getIntArray(env, displs, &jDispls, &cDispls); ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
} }
rc = MPI_Scatterv(sPtr, cSCounts, cDispls, sType, rc = MPI_Scatterv(sPtr, cSCounts, cDispls, sType,
@ -1262,11 +1273,11 @@ JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
if(recvBuf != NULL) if(recvBuf != NULL)
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
if(rootOrInter) if(rootOrInter)
{ {
ompi_java_releaseBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseBufPtr(env, sendBuf, sdb, sBase, sBType);
ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts); ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts);
ompi_java_forgetIntArray(env, displs, jDispls, cDispls); ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
} }
@ -1331,8 +1342,10 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatterv(
JNIEXPORT void JNICALL Java_mpi_Comm_allGather( JNIEXPORT void JNICALL Java_mpi_Comm_allGather(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jlong sjType, jint sBType, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jint rOffset, jint rCount, jlong rjType, jint rBType) jint sCount, jlong sjType, jint sBType,
jobject recvBuf, jboolean rdb, jint rOffset,
jint rCount, jlong rjType, jint rBType)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype sType; MPI_Datatype sType;
@ -1348,18 +1361,18 @@ JNIEXPORT void JNICALL Java_mpi_Comm_allGather(
else else
{ {
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
} }
MPI_Datatype rType = (MPI_Datatype)rjType; MPI_Datatype rType = (MPI_Datatype)rjType;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
int rc = MPI_Allgather(sPtr, sCount, sType, rPtr, rCount, rType, comm); int rc = MPI_Allgather(sPtr, sCount, sType, rPtr, rCount, rType, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGather( JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGather(
@ -1393,9 +1406,10 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGather(
JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv( JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jlong sjType, jint sBType, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jint rOffset, jintArray rCounts, jintArray displs, jint sCount, jlong sjType, jint sBType,
jlong rjType, jint rBType) jobject recvBuf, jboolean rdb, jint rOffset,
jintArray rCounts, jintArray displs, jlong rjType, jint rBType)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
void *sPtr, *sBase, *rPtr, *rBase; void *sPtr, *sBase, *rPtr, *rBase;
@ -1411,7 +1425,7 @@ JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv(
else else
{ {
sType = (MPI_Datatype)sjType; sType = (MPI_Datatype)sjType;
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
} }
MPI_Datatype rType = (MPI_Datatype)rjType; MPI_Datatype rType = (MPI_Datatype)rjType;
@ -1420,16 +1434,16 @@ JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv(
ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts); ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
ompi_java_getIntArray(env, displs, &jDispls, &cDispls); ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
int rc = MPI_Allgatherv(sPtr, sCount, sType, rPtr, int rc = MPI_Allgatherv(sPtr, sCount, sType, rPtr,
cRCounts, cDispls, rType, comm); cRCounts, cDispls, rType, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts); ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
ompi_java_forgetIntArray(env, displs, jDispls, cDispls); ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
@ -1473,22 +1487,24 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGatherv(
JNIEXPORT void JNICALL Java_mpi_Comm_allToAll( JNIEXPORT void JNICALL Java_mpi_Comm_allToAll(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jint sCount, jlong sjType, jint sBType, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jint rOffset, jint rCount, jlong rjType, jint rBType) jint sCount, jlong sjType, jint sBType,
jobject recvBuf, jboolean rdb, jint rOffset,
jint rCount, jlong rjType, jint rBType)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
MPI_Datatype sType = (MPI_Datatype)sjType; MPI_Datatype sType = (MPI_Datatype)sjType;
MPI_Datatype rType = (MPI_Datatype)rjType; MPI_Datatype rType = (MPI_Datatype)rjType;
void *sPtr, *sBase, *rPtr, *rBase; void *sPtr, *sBase, *rPtr, *rBase;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
int rc = MPI_Alltoall(sPtr, sCount, sType, rPtr, rCount, rType, comm); int rc = MPI_Alltoall(sPtr, sCount, sType, rPtr, rCount, rType, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAll( JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAll(
@ -1511,9 +1527,9 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAll(
JNIEXPORT void JNICALL Java_mpi_Comm_allToAllv( JNIEXPORT void JNICALL Java_mpi_Comm_allToAllv(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jintArray sCount, jobject sendBuf, jboolean sdb, jint sOffset, jintArray sCount,
jintArray sDispls, jlong sjType, jint sBType, jintArray sDispls, jlong sjType, jint sBType,
jobject recvBuf, jint rOffset, jintArray rCount, jobject recvBuf, jboolean rdb, jint rOffset, jintArray rCount,
jintArray rDispls, jlong rjType, jint rBType) jintArray rDispls, jlong rjType, jint rBType)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1528,15 +1544,15 @@ JNIEXPORT void JNICALL Java_mpi_Comm_allToAllv(
ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls); ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
void *sPtr, *sBase, *rPtr, *rBase; void *sPtr, *sBase, *rPtr, *rBase;
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rBType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, rBType, rOffset);
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sBType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, sBType, sOffset);
int rc = MPI_Alltoallv(sPtr, cSCount, cSDispls, sType, int rc = MPI_Alltoallv(sPtr, cSCount, cSDispls, sType,
rPtr, cRCount, cRDispls, rType, comm); rPtr, cRCount, cRDispls, rType, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, sBType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, sBType);
ompi_java_releaseBufPtr(env, recvBuf, rBase, rBType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, rBType);
ompi_java_forgetIntArray(env, sCount, jSCount, cSCount); ompi_java_forgetIntArray(env, sCount, jSCount, cSCount);
ompi_java_forgetIntArray(env, rCount, jRCount, cRCount); ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
@ -1575,7 +1591,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAllv(
JNIEXPORT void JNICALL Java_mpi_Comm_reduce( JNIEXPORT void JNICALL Java_mpi_Comm_reduce(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jobject recvBuf, jint rOffset, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jboolean rdb, jint rOffset,
jint count, jlong jType, jint baseType, jobject op, jint root) jint count, jlong jType, jint baseType, jobject op, jint root)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1592,11 +1609,11 @@ JNIEXPORT void JNICALL Java_mpi_Comm_reduce(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, baseType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, baseType, sOffset);
if(rootOrInter || sendBuf == NULL) if(rootOrInter || sendBuf == NULL)
{ {
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, baseType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, baseType, rOffset);
if(!rootOrInter) if(!rootOrInter)
{ {
@ -1614,10 +1631,10 @@ JNIEXPORT void JNICALL Java_mpi_Comm_reduce(
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, baseType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, baseType);
if(rootOrInter || sendBuf == NULL) if(rootOrInter || sendBuf == NULL)
ompi_java_releaseBufPtr(env, recvBuf, rBase, baseType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, baseType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduce( JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduce(
@ -1666,7 +1683,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduce(
JNIEXPORT void JNICALL Java_mpi_Comm_allReduce( JNIEXPORT void JNICALL Java_mpi_Comm_allReduce(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sendOffset, jobject recvBuf, jint recvOffset, jobject sendBuf, jboolean sdb, jint sendOffset,
jobject recvBuf, jboolean rdb, jint recvOffset,
jint count, jlong jType, jint baseType, jobject op) jint count, jlong jType, jint baseType, jobject op)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1676,17 +1694,17 @@ JNIEXPORT void JNICALL Java_mpi_Comm_allReduce(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, baseType, sendOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, baseType, sendOffset);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, baseType, recvOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, baseType, recvOffset);
MPI_Op mpiOp = ompi_java_op_getHandle(env, op, baseType); MPI_Op mpiOp = ompi_java_op_getHandle(env, op, baseType);
int rc = MPI_Allreduce(sPtr, rPtr, count, type, mpiOp, comm); int rc = MPI_Allreduce(sPtr, rPtr, count, type, mpiOp, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, baseType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, baseType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, baseType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, baseType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllReduce( JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllReduce(
@ -1714,7 +1732,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllReduce(
JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter( JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jobject recvBuf, jint rOffset, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jboolean rdb, jint rOffset,
jintArray rCounts, jlong jType, jint bType, jobject op) jintArray rCounts, jlong jType, jint bType, jobject op)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1724,9 +1743,9 @@ JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, bType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, bType, sOffset);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, bType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, bType, rOffset);
MPI_Op mpiOp = ompi_java_op_getHandle(env, op, bType); MPI_Op mpiOp = ompi_java_op_getHandle(env, op, bType);
jint *jRCounts; jint *jRCounts;
@ -1736,11 +1755,11 @@ JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter(
int rc = MPI_Reduce_scatter(sPtr, rPtr, cRCounts, type, mpiOp, comm); int rc = MPI_Reduce_scatter(sPtr, rPtr, cRCounts, type, mpiOp, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, bType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, bType);
ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts); ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, bType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, bType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatter( JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatter(
@ -1773,7 +1792,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatter(
JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatterBlock( JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatterBlock(
JNIEnv *env, jobject jthis, jlong jComm, JNIEnv *env, jobject jthis, jlong jComm,
jobject sendBuf, jint sOffset, jobject recvBuf, jint rOffset, jobject sendBuf, jboolean sdb, jint sOffset,
jobject recvBuf, jboolean rdb, jint rOffset,
jint count, jlong jType, jint bType, jobject op) jint count, jlong jType, jint bType, jobject op)
{ {
MPI_Comm comm = (MPI_Comm)jComm; MPI_Comm comm = (MPI_Comm)jComm;
@ -1783,18 +1803,18 @@ JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatterBlock(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, bType, sOffset); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, bType, sOffset);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, bType, rOffset); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, bType, rOffset);
MPI_Op mpiOp = ompi_java_op_getHandle(env, op, bType); MPI_Op mpiOp = ompi_java_op_getHandle(env, op, bType);
int rc = MPI_Reduce_scatter_block(sPtr, rPtr, count, type, mpiOp, comm); int rc = MPI_Reduce_scatter_block(sPtr, rPtr, count, type, mpiOp, comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, bType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, bType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, bType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, bType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatterBlock( JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatterBlock(
@ -1820,21 +1840,21 @@ JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatterBlock(
} }
JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocal( JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocal(
JNIEnv *env, jclass clazz, jobject inBuf, jint inOff, JNIEnv *env, jclass clazz, jobject inBuf, jboolean idb, jint inOff,
jobject inOutBuf, jint inOutOff, jint count, jobject inOutBuf, jboolean iodb, jint inOutOff, jint count,
jlong jType, jint bType, jobject op) jlong jType, jint bType, jobject op)
{ {
MPI_Datatype type = (MPI_Datatype)jType; MPI_Datatype type = (MPI_Datatype)jType;
void *inPtr, *inBase, *inOutPtr, *inOutBase; void *inPtr, *inBase, *inOutPtr, *inOutBase;
inPtr = getBufCritical(&inBase, env, inBuf, bType, inOff); inPtr = getBufCritical(&inBase, env, inBuf, idb, bType, inOff);
inOutPtr = getBufCritical(&inOutBase, env, inOutBuf, bType, inOutOff); inOutPtr = getBufCritical(&inOutBase, env, inOutBuf, iodb, bType, inOutOff);
int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type, int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type,
ompi_java_op_getHandle(env, op, bType)); ompi_java_op_getHandle(env, op, bType));
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
releaseBufCritical(env, inBuf, inBase); releaseBufCritical(env, inBuf, idb, inBase);
releaseBufCritical(env, inOutBuf, inOutBase); releaseBufCritical(env, inOutBuf, iodb, inOutBase);
} }
JNIEXPORT void JNICALL Java_mpi_Comm_setName( JNIEXPORT void JNICALL Java_mpi_Comm_setName(

75
ompi/mpi/java/c/mpi_File.c
Просмотреть файл

@ -116,81 +116,84 @@ JNIEXPORT void JNICALL Java_mpi_File_setView(
JNIEXPORT void JNICALL Java_mpi_File_readAt( JNIEXPORT void JNICALL Java_mpi_File_readAt(
JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset, JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
jobject buf, jint offset, jint count, jobject jType, jobject stat) jobject buf, jboolean db, jint offset, jint count,
jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
env, jType, ompi_java.DatatypeHandle)); env, jType, ompi_java.DatatypeHandle));
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read_at((MPI_File)fh, (MPI_Offset)fileOffset, int rc = MPI_File_read_at((MPI_File)fh, (MPI_Offset)fileOffset,
ptr, count, (MPI_Datatype)type, &status); ptr, count, (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_readAtAll( JNIEXPORT void JNICALL Java_mpi_File_readAtAll(
JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset, JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
jobject buf, jint offset, jint count, jobject jType, jobject stat) jobject buf, jboolean db, jint offset, jint count,
jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
env, jType, ompi_java.DatatypeHandle)); env, jType, ompi_java.DatatypeHandle));
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read_at_all((MPI_File)fh, (MPI_Offset)fileOffset, int rc = MPI_File_read_at_all((MPI_File)fh, (MPI_Offset)fileOffset,
ptr, count, (MPI_Datatype)type, &status); ptr, count, (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_writeAt( JNIEXPORT void JNICALL Java_mpi_File_writeAt(
JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset, JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
jobject buf, jint offset, jint count, jobject jType, jobject stat) jobject buf, jboolean db, jint offset, jint count,
jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
env, jType, ompi_java.DatatypeHandle)); env, jType, ompi_java.DatatypeHandle));
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write_at((MPI_File)fh, (MPI_Offset)fileOffset, int rc = MPI_File_write_at((MPI_File)fh, (MPI_Offset)fileOffset,
ptr, count, (MPI_Datatype)type, &status); ptr, count, (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_writeAtAll( JNIEXPORT void JNICALL Java_mpi_File_writeAtAll(
JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset, JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
jobject buf, jint offset, jint count, jobject jType, jobject stat) jobject buf, jboolean db, jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
env, jType, ompi_java.DatatypeHandle)); env, jType, ompi_java.DatatypeHandle));
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write_at_all((MPI_File)fh, (MPI_Offset)fileOffset, int rc = MPI_File_write_at_all((MPI_File)fh, (MPI_Offset)fileOffset,
ptr, count, (MPI_Datatype)type, &status); ptr, count, (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
@ -223,7 +226,7 @@ JNIEXPORT jlong JNICALL Java_mpi_File_iWriteAt(
} }
JNIEXPORT void JNICALL Java_mpi_File_read( JNIEXPORT void JNICALL Java_mpi_File_read(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -231,19 +234,19 @@ JNIEXPORT void JNICALL Java_mpi_File_read(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read((MPI_File)fh, ptr, count, int rc = MPI_File_read((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_readAll( JNIEXPORT void JNICALL Java_mpi_File_readAll(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -251,19 +254,19 @@ JNIEXPORT void JNICALL Java_mpi_File_readAll(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read_all((MPI_File)fh, ptr, count, int rc = MPI_File_read_all((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_write( JNIEXPORT void JNICALL Java_mpi_File_write(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -271,19 +274,19 @@ JNIEXPORT void JNICALL Java_mpi_File_write(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write((MPI_File)fh, ptr, count, int rc = MPI_File_write((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_writeAll( JNIEXPORT void JNICALL Java_mpi_File_writeAll(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -291,14 +294,14 @@ JNIEXPORT void JNICALL Java_mpi_File_writeAll(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write_all((MPI_File)fh, ptr, count, int rc = MPI_File_write_all((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
@ -356,7 +359,7 @@ JNIEXPORT jlong JNICALL Java_mpi_File_getByteOffset(
} }
JNIEXPORT void JNICALL Java_mpi_File_readShared( JNIEXPORT void JNICALL Java_mpi_File_readShared(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -364,19 +367,19 @@ JNIEXPORT void JNICALL Java_mpi_File_readShared(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read_shared((MPI_File)fh, ptr, count, int rc = MPI_File_read_shared((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_writeShared( JNIEXPORT void JNICALL Java_mpi_File_writeShared(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -384,14 +387,14 @@ JNIEXPORT void JNICALL Java_mpi_File_writeShared(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write_shared((MPI_File)fh, ptr, count, int rc = MPI_File_write_shared((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
@ -424,7 +427,7 @@ JNIEXPORT jlong JNICALL Java_mpi_File_iWriteShared(
} }
JNIEXPORT void JNICALL Java_mpi_File_readOrdered( JNIEXPORT void JNICALL Java_mpi_File_readOrdered(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -432,19 +435,19 @@ JNIEXPORT void JNICALL Java_mpi_File_readOrdered(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_read_ordered((MPI_File)fh, ptr, count, int rc = MPI_File_read_ordered((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, buf, base, bType); ompi_java_releaseBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
JNIEXPORT void JNICALL Java_mpi_File_writeOrdered( JNIEXPORT void JNICALL Java_mpi_File_writeOrdered(
JNIEnv *env, jobject jthis, jlong fh, jobject buf, JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
jint offset, jint count, jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField( MPI_Datatype type = (MPI_Datatype)((*env)->GetLongField(
@ -452,14 +455,14 @@ JNIEXPORT void JNICALL Java_mpi_File_writeOrdered(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *ptr, *base; void *ptr, *base;
ptr = ompi_java_getBufPtr(&base, env, buf, bType, offset); ptr = ompi_java_getBufPtr(&base, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_File_write_ordered((MPI_File)fh, ptr, count, int rc = MPI_File_write_ordered((MPI_File)fh, ptr, count,
(MPI_Datatype)type, &status); (MPI_Datatype)type, &status);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseReadBufPtr(env, buf, base, bType); ompi_java_releaseReadBufPtr(env, buf, db, base, bType);
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }

22
ompi/mpi/java/c/mpi_Intracomm.c
Просмотреть файл

@ -177,7 +177,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createDistGraphAdjacent(
JNIEXPORT void JNICALL Java_mpi_Intracomm_scan( JNIEXPORT void JNICALL Java_mpi_Intracomm_scan(
JNIEnv *env, jobject jthis, jlong comm, JNIEnv *env, jobject jthis, jlong comm,
jobject sendBuf, jint sendOff, jobject recvBuf, jint recvOff, jobject sendBuf, jboolean sdb, jint sendOff,
jobject recvBuf, jboolean rdb, jint recvOff,
jint count, jlong type, jint baseType, jobject op) jint count, jlong type, jint baseType, jobject op)
{ {
void *sPtr, *sBase, *rPtr, *rBase; void *sPtr, *sBase, *rPtr, *rBase;
@ -185,19 +186,19 @@ JNIEXPORT void JNICALL Java_mpi_Intracomm_scan(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, baseType, sendOff); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, baseType, sendOff);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, baseType, recvOff); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, baseType, recvOff);
int rc = MPI_Scan(sPtr, rPtr, count, (MPI_Datatype)type, int rc = MPI_Scan(sPtr, rPtr, count, (MPI_Datatype)type,
ompi_java_op_getHandle(env, op, baseType), ompi_java_op_getHandle(env, op, baseType),
(MPI_Comm)comm); (MPI_Comm)comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, baseType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, baseType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, baseType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, baseType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iScan( JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iScan(
@ -225,7 +226,8 @@ JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iScan(
JNIEXPORT void JNICALL Java_mpi_Intracomm_exScan( JNIEXPORT void JNICALL Java_mpi_Intracomm_exScan(
JNIEnv *env, jobject jthis, jlong comm, JNIEnv *env, jobject jthis, jlong comm,
jobject sendBuf, jint sendOff, jobject recvBuf, jint recvOff, jobject sendBuf, jboolean sdb, jint sendOff,
jobject recvBuf, jboolean rdb, jint recvOff,
jint count, jlong type, int bType, jobject op) jint count, jlong type, int bType, jobject op)
{ {
void *sPtr, *sBase, *rPtr, *rBase; void *sPtr, *sBase, *rPtr, *rBase;
@ -233,19 +235,19 @@ JNIEXPORT void JNICALL Java_mpi_Intracomm_exScan(
if(sendBuf == NULL) if(sendBuf == NULL)
sPtr = MPI_IN_PLACE; sPtr = MPI_IN_PLACE;
else else
sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, bType, sendOff); sPtr = ompi_java_getBufPtr(&sBase, env, sendBuf, sdb, bType, sendOff);
rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, bType, recvOff); rPtr = ompi_java_getBufPtr(&rBase, env, recvBuf, rdb, bType, recvOff);
int rc = MPI_Exscan(sPtr, rPtr, count, (MPI_Datatype)type, int rc = MPI_Exscan(sPtr, rPtr, count, (MPI_Datatype)type,
ompi_java_op_getHandle(env, op, bType), ompi_java_op_getHandle(env, op, bType),
(MPI_Comm)comm); (MPI_Comm)comm);
ompi_java_exceptionCheck(env, rc); ompi_java_exceptionCheck(env, rc);
ompi_java_releaseBufPtr(env, recvBuf, rBase, bType); ompi_java_releaseBufPtr(env, recvBuf, rdb, rBase, bType);
if(sendBuf != NULL) if(sendBuf != NULL)
ompi_java_releaseReadBufPtr(env, sendBuf, sBase, bType); ompi_java_releaseReadBufPtr(env, sendBuf, sdb, sBase, bType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iExScan( JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iExScan(

8
ompi/mpi/java/c/mpi_Message.c
Просмотреть файл

@ -50,8 +50,8 @@ JNIEXPORT jobject JNICALL Java_mpi_Message_imProbe(
} }
JNIEXPORT void JNICALL Java_mpi_Message_mRecv( JNIEXPORT void JNICALL Java_mpi_Message_mRecv(
JNIEnv *env, jobject jthis, jobject buf, jint offset, jint count, JNIEnv *env, jobject jthis, jobject buf, jboolean db,
jobject jType, jobject stat) jint offset, jint count, jobject jType, jobject stat)
{ {
MPI_Message msg = (MPI_Message)((*env)->GetLongField( MPI_Message msg = (MPI_Message)((*env)->GetLongField(
env, jthis, ompi_java.MessageHandle)); env, jthis, ompi_java.MessageHandle));
@ -61,7 +61,7 @@ JNIEXPORT void JNICALL Java_mpi_Message_mRecv(
int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType); int bType = (*env)->GetIntField(env, jType, ompi_java.DatatypeBaseType);
void *bufPtr, *bufBase; void *bufPtr, *bufBase;
bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, bType, offset); bufPtr = ompi_java_getBufPtr(&bufBase, env, buf, db, bType, offset);
MPI_Status status; MPI_Status status;
int rc = MPI_Mrecv(bufPtr, count, type, &msg, &status); int rc = MPI_Mrecv(bufPtr, count, type, &msg, &status);
@ -72,7 +72,7 @@ JNIEXPORT void JNICALL Java_mpi_Message_mRecv(
ompi_java_status_set(&status, env, stat); ompi_java_status_set(&status, env, stat);
} }
ompi_java_releaseBufPtr(env, buf, bufBase, bType); ompi_java_releaseBufPtr(env, buf, db, bufBase, bType);
} }
JNIEXPORT jlong JNICALL Java_mpi_Message_imRecv( JNIEXPORT jlong JNICALL Java_mpi_Message_imRecv(

355
ompi/mpi/java/java/Comm.java
Просмотреть файл

@ -23,7 +23,6 @@
package mpi; package mpi;
import java.nio.*; import java.nio.*;
import static mpi.MPI.isHeapBuffer;
import static mpi.MPI.assertDirectBuffer; import static mpi.MPI.assertDirectBuffer;
/** /**
@ -240,18 +239,19 @@ public final void send(Object buf, int count, Datatype type, int dest, int tag)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
send(handle, buf, off, count, type.handle, type.baseType, dest, tag); send(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
} }
private native void send( private native void send(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int baseType, int dest, int tag) throws MPIException; long type, int baseType, int dest, int tag) throws MPIException;
/** /**
@ -271,20 +271,24 @@ public final Status recv(Object buf, int count,
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
recv(handle, buf, off, count, type.handle, type.baseType, source, tag, stat);
recv(handle, buf, db, off, count,
type.handle, type.baseType, source, tag, stat);
return stat; return stat;
} }
private native void recv( private native void recv(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int basetype, int source, int tag, Status stat) long type, int basetype, int source, int tag, Status stat)
throws MPIException; throws MPIException;
@ -318,13 +322,16 @@ public final Status sendRecv(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
@ -332,18 +339,18 @@ public final Status sendRecv(
Status stat = new Status(); Status stat = new Status();
sendRecv(handle, sendbuf, sendoff, sendcount, sendRecv(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, dest, sendtag, sendtype.handle, sendtype.baseType, dest, sendtag,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType, source, recvtag, stat); recvtype.handle, recvtype.baseType, source, recvtag, stat);
return stat; return stat;
} }
private native void sendRecv( private native void sendRecv(
long comm, Object sbuf, int soffset, int scount, long comm, Object sbuf, boolean sdb, int soffset, int scount,
long sType, int sBaseType, int dest, int stag, long sType, int sBaseType, int dest, int stag,
Object rbuf, int roffset, int rcount, Object rbuf, boolean rdb, int roffset, int rcount,
long rType, int rBaseType, int source, int rtag, long rType, int rBaseType, int source, int rtag,
Status stat) throws MPIException; Status stat) throws MPIException;
@ -370,8 +377,9 @@ public final Status sendRecvReplace(
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
@ -379,13 +387,13 @@ public final Status sendRecvReplace(
Status stat = new Status(); Status stat = new Status();
sendRecvReplace(handle, buf, off, count, type.handle, type.baseType, sendRecvReplace(handle, buf, db, off, count, type.handle, type.baseType,
dest, sendtag, source, recvtag, stat); dest, sendtag, source, recvtag, stat);
return stat; return stat;
} }
private native void sendRecvReplace( private native void sendRecvReplace(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int baseType, int dest, int stag, long type, int baseType, int dest, int stag,
int source, int rtag, Status stat) throws MPIException; int source, int rtag, Status stat) throws MPIException;
@ -407,18 +415,19 @@ public final void bSend(Object buf, int count, Datatype type, int dest, int tag)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
bSend(handle, buf, off, count, type.handle, type.baseType, dest, tag); bSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
} }
private native void bSend( private native void bSend(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int baseType, int dest, int tag) throws MPIException; long type, int baseType, int dest, int tag) throws MPIException;
/** /**
@ -437,18 +446,19 @@ public final void sSend(Object buf, int count, Datatype type, int dest, int tag)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
sSend(handle, buf, off, count, type.handle, type.baseType, dest, tag); sSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
} }
private native void sSend( private native void sSend(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int baseType, int dest, int tag) throws MPIException; long type, int baseType, int dest, int tag) throws MPIException;
/** /**
@ -467,18 +477,19 @@ public final void rSend(Object buf, int count, Datatype type, int dest, int tag)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
rSend(handle, buf, off, count, type.handle, type.baseType, dest, tag); rSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
} }
private native void rSend( private native void rSend(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int baseType, int dest, int tag) throws MPIException; long type, int baseType, int dest, int tag) throws MPIException;
// Nonblocking communication // Nonblocking communication
@ -775,19 +786,20 @@ public final int pack(Object inbuf, int incount, Datatype type,
{ {
MPI.check(); MPI.check();
int offset = 0; int offset = 0;
boolean indb = false;
if(isHeapBuffer(inbuf)) if(inbuf instanceof Buffer && !(indb = ((Buffer)inbuf).isDirect()))
{ {
offset = ((Buffer)inbuf).arrayOffset(); offset = ((Buffer)inbuf).arrayOffset();
inbuf = ((Buffer)inbuf).array(); inbuf = ((Buffer)inbuf).array();
} }
return pack(handle, inbuf, offset, incount, return pack(handle, inbuf, indb, offset, incount,
type.handle, type.baseType, outbuf, position); type.handle, type.baseType, outbuf, position);
} }
private native int pack( private native int pack(
long comm, Object inbuf, int offset, int incount, long comm, Object inbuf, boolean indb, int offset, int incount,
long type, int baseType, byte[] outbuf, int position) long type, int baseType, byte[] outbuf, int position)
throws MPIException; throws MPIException;
@ -813,19 +825,20 @@ public final int unpack(byte[] inbuf, int position,
{ {
MPI.check(); MPI.check();
int offset = 0; int offset = 0;
boolean outdb = false;
if(isHeapBuffer(outbuf)) if(outbuf instanceof Buffer && !(outdb = ((Buffer)outbuf).isDirect()))
{ {
offset = ((Buffer)outbuf).arrayOffset(); offset = ((Buffer)outbuf).arrayOffset();
outbuf = ((Buffer)outbuf).array(); outbuf = ((Buffer)outbuf).array();
} }
return unpack(handle, inbuf, position, outbuf, return unpack(handle, inbuf, position, outbuf, outdb,
offset, outcount, type.handle, type.baseType); offset, outcount, type.handle, type.baseType);
} }
private native int unpack( private native int unpack(
long comm, byte[] inbuf, int position, Object outbuf, long comm, byte[] inbuf, int position, Object outbuf, boolean outdb,
int offset, int outcount, long type, int baseType) throws MPIException; int offset, int outcount, long type, int baseType) throws MPIException;
/** /**
@ -1095,18 +1108,19 @@ public final void bcast(Object buf, int count, Datatype type, int root)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
bcast(handle, buf, off, count, type.handle, type.baseType, root); bcast(handle, buf, db, off, count, type.handle, type.baseType, root);
} }
private native void bcast( private native void bcast(
long comm, Object buf, int offset, int count, long comm, Object buf, boolean db, int offset, int count,
long type, int basetype, int root) throws MPIException; long type, int basetype, int root) throws MPIException;
/** /**
@ -1154,21 +1168,24 @@ public final void gather(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
gather(handle, sendbuf, sendoff, sendcount, gather(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType, root); recvtype.handle, recvtype.baseType, root);
} }
@ -1189,21 +1206,22 @@ public final void gather(Object buf, int count, Datatype type, int root)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
gather(handle, null, 0, 0, 0, 0, gather(handle, null, false, 0, 0, 0, 0,
buf, off, count, type.handle, type.baseType, root); buf, db, off, count, type.handle, type.baseType, root);
} }
private native void gather( private native void gather(
long comm, Object sendBuf, int sendOff, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOff, int sendCount,
long sendType, int sendBaseType, long sendType, int sendBaseType,
Object recvBuf, int recvOff, int recvCount, Object recvBuf, boolean rdb, int recvOff, int recvCount,
long recvType, int recvBaseType, int root) long recvType, int recvBaseType, int root)
throws MPIException; throws MPIException;
@ -1284,21 +1302,24 @@ public final void gatherv(Object sendbuf, int sendcount, Datatype sendtype,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
gatherv(handle, sendbuf, sendoff, sendcount, gatherv(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, displs, recvbuf, rdb, recvoff, recvcount, displs,
recvtype.handle, recvtype.baseType, root); recvtype.handle, recvtype.baseType, root);
} }
@ -1321,14 +1342,15 @@ public final void gatherv(Object recvbuf, int[] recvcount, int[] displs,
{ {
MPI.check(); MPI.check();
int recvoff = 0; int recvoff = 0;
boolean rdb = false;
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
gatherv(handle, null, 0, 0, 0, 0, recvbuf, recvoff, recvcount, gatherv(handle, null, false, 0, 0, 0, 0, recvbuf, rdb, recvoff, recvcount,
displs, recvtype.handle, recvtype.baseType, root); displs, recvtype.handle, recvtype.baseType, root);
} }
@ -1350,23 +1372,25 @@ public final void gatherv(Object sendbuf, int sendcount,
{ {
MPI.check(); MPI.check();
int sendoff = 0; int sendoff = 0;
boolean sdb = false;
if(isHeapBuffer(sendbuf)) if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
gatherv(handle, sendbuf, sendoff, sendcount, gatherv(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
null, 0, null, null, 0, 0, root); null, false, 0, null, null, 0, 0, root);
} }
private native void gatherv( private native void gatherv(
long comm, Object sendBuf, int sendOffset, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOffset,
long sendType, int sendBaseType, int sendCount, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int[] recvCount, int[] displs, Object recvBuf, boolean rdb, int recvOffset,
long recvType, int recvBaseType, int root) throws MPIException; int[] recvCount, int[] displs, long recvType, int recvBaseType,
int root) throws MPIException;
/** /**
* Extends functionality of {@code gather} by allowing varying * Extends functionality of {@code gather} by allowing varying
@ -1473,21 +1497,24 @@ public final void scatter(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
scatter(handle, sendbuf, sendoff, sendcount, scatter(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType, root); recvtype.handle, recvtype.baseType, root);
} }
@ -1508,21 +1535,22 @@ public final void scatter(Object buf, int count, Datatype type, int root)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
scatter(handle, buf, off, count, type.handle, type.baseType, scatter(handle, buf, db, off, count, type.handle, type.baseType,
null, 0, 0, 0, 0, root); null, false, 0, 0, 0, 0, root);
} }
private native void scatter( private native void scatter(
long comm, Object sendBuf, int sendOffset, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
long sendType, int sendBaseType, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int recvCount, Object recvBuf, boolean rdb, int recvOffset, int recvCount,
long recvType, int recvBaseType, int root) throws MPIException; long recvType, int recvBaseType, int root) throws MPIException;
/** /**
@ -1601,21 +1629,24 @@ public final void scatterv(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
scatterv(handle, sendbuf, sendoff, sendcount, displs, scatterv(handle, sendbuf, sdb, sendoff, sendcount, displs,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType, root); recvtype.handle, recvtype.baseType, root);
} }
@ -1637,16 +1668,17 @@ public final void scatterv(Object sendbuf, int[] sendcount, int[] displs,
{ {
MPI.check(); MPI.check();
int sendoff = 0; int sendoff = 0;
boolean sdb = false;
if(isHeapBuffer(sendbuf)) if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
scatterv(handle, sendbuf, sendoff, sendcount, displs, scatterv(handle, sendbuf, sdb, sendoff, sendcount, displs,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
null, 0, 0, 0, 0, root); null, false, 0, 0, 0, 0, root);
} }
/** /**
@ -1666,22 +1698,23 @@ public final void scatterv(Object recvbuf, int recvcount,
{ {
MPI.check(); MPI.check();
int recvoff = 0; int recvoff = 0;
boolean rdb = false;
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
scatterv(handle, null, 0, null, null, 0, 0, scatterv(handle, null, false, 0, null, null, 0, 0,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType, root); recvtype.handle, recvtype.baseType, root);
} }
private native void scatterv( private native void scatterv(
long comm, Object sendBuf, int sendOffset, long comm, Object sendBuf, boolean sdb, int sendOffset,
int[] sendCount, int[] displs, long sendType, int sendBaseType, int[] sendCount, int[] displs, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int recvCount, Object recvBuf, boolean rdb, int recvOffset, int recvCount,
long recvType, int recvBaseType, int root) long recvType, int recvBaseType, int root)
throws MPIException; throws MPIException;
@ -1784,21 +1817,24 @@ public final void allGather(Object sendbuf, int sendcount, Datatype sendtype,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allGather(handle, sendbuf, sendoff, sendcount, allGather(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType); recvtype.handle, recvtype.baseType);
} }
@ -1816,21 +1852,22 @@ public final void allGather(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
allGather(handle, null, 0, 0, 0, 0, allGather(handle, null, false, 0, 0, 0, 0,
buf, off, count, type.handle, type.baseType); buf, db, off, count, type.handle, type.baseType);
} }
private native void allGather( private native void allGather(
long comm, Object sendBuf, int sendOffset, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
long sendType, int sendBaseType, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int recvCount, Object recvBuf, boolean rdb, int recvOffset, int recvCount,
long recvType, int recvBaseType) throws MPIException; long recvType, int recvBaseType) throws MPIException;
/** /**
@ -1901,21 +1938,24 @@ public final void allGatherv(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allGatherv(handle, sendbuf, sendoff, sendcount, allGatherv(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, displs, recvbuf, rdb, recvoff, recvcount, displs,
recvtype.handle, recvtype.baseType); recvtype.handle, recvtype.baseType);
} }
@ -1935,22 +1975,24 @@ public final void allGatherv(Object recvbuf, int[] recvcount,
{ {
MPI.check(); MPI.check();
int recvoff = 0; int recvoff = 0;
boolean rdb = false;
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allGatherv(handle, null, 0, 0, 0, 0, recvbuf, recvoff, recvcount, allGatherv(handle, null, false, 0, 0, 0, 0,
recvbuf, rdb, recvoff, recvcount,
displs, recvtype.handle, recvtype.baseType); displs, recvtype.handle, recvtype.baseType);
} }
private native void allGatherv( private native void allGatherv(
long comm, Object sendBuf, int sendOffset, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
long sendType, int sendBaseType, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int[] recvCount, int[] displs, Object recvBuf, boolean rdb, int recvOffset, int[] recvCount,
long recvType, int recvBasetype) throws MPIException; int[] displs, long recvType, int recvBasetype) throws MPIException;
/** /**
* Similar to {@code gatherv}, but all processes receive the result. * Similar to {@code gatherv}, but all processes receive the result.
@ -2026,28 +2068,31 @@ public final void allToAll(Object sendbuf, int sendcount, Datatype sendtype,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allToAll(handle, sendbuf, sendoff, sendcount, allToAll(handle, sendbuf, sdb, sendoff, sendcount,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, recvbuf, rdb, recvoff, recvcount,
recvtype.handle, recvtype.baseType); recvtype.handle, recvtype.baseType);
} }
private native void allToAll( private native void allToAll(
long comm, Object sendBuf, int sendOffset, int sendCount, long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
long sendType, int sendBaseType, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, int recvCount, Object recvBuf, boolean rdb, int recvOffset, int recvCount,
long recvType, int recvBaseType) throws MPIException; long recvType, int recvBaseType) throws MPIException;
/** /**
@ -2103,28 +2148,31 @@ public final void allToAllv(
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allToAllv(handle, sendbuf, sendoff, sendcount, sdispls, allToAllv(handle, sendbuf, sdb, sendoff, sendcount, sdispls,
sendtype.handle, sendtype.baseType, sendtype.handle, sendtype.baseType,
recvbuf, recvoff, recvcount, rdispls, recvbuf, rdb, recvoff, recvcount, rdispls,
recvtype.handle, recvtype.baseType); recvtype.handle, recvtype.baseType);
} }
private native void allToAllv( private native void allToAllv(
long comm, Object sendBuf, int sendOffset, long comm, Object sendBuf, boolean sdb, int sendOffset,
int[] sendCount, int[] sdispls, long sendType, int sendBaseType, int[] sendCount, int[] sdispls, long sendType, int sendBaseType,
Object recvBuf, int recvOffset, Object recvBuf, boolean rdb, int recvOffset,
int[] recvCount, int[] rdispls, long recvType, int recvBaseType) int[] recvCount, int[] rdispls, long recvType, int recvBaseType)
throws MPIException; throws MPIException;
@ -2191,20 +2239,23 @@ public final void reduce(Object sendbuf, Object recvbuf, int count,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
reduce(handle, sendbuf, sendoff, recvbuf, recvoff, count, reduce(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
type.handle, type.baseType, op, root); count, type.handle, type.baseType, op, root);
} }
/** /**
@ -2226,19 +2277,21 @@ public final void reduce(Object buf, int count, Datatype type, Op op, int root)
MPI.check(); MPI.check();
op.setDatatype(type); op.setDatatype(type);
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
reduce(handle, null, 0, buf, off, count, reduce(handle, null, false, 0, buf, db, off, count,
type.handle, type.baseType, op, root); type.handle, type.baseType, op, root);
} }
private native void reduce( private native void reduce(
long comm, Object sendbuf, int sendoff, Object recvbuf, int recvoff, long comm, Object sendbuf, boolean sdb, int sendoff,
Object recvbuf, boolean rdb, int recvoff,
int count, long type, int baseType, Op op, int root) int count, long type, int baseType, Op op, int root)
throws MPIException; throws MPIException;
@ -2319,20 +2372,23 @@ public final void allReduce(Object sendbuf, Object recvbuf,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
allReduce(handle, sendbuf, sendoff, recvbuf, recvoff, count, allReduce(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
type.handle, type.baseType, op); count, type.handle, type.baseType, op);
} }
/** /**
@ -2352,18 +2408,21 @@ public final void allReduce(Object buf, int count, Datatype type, Op op)
MPI.check(); MPI.check();
op.setDatatype(type); op.setDatatype(type);
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
allReduce(handle, null, 0, buf, off, count, type.handle, type.baseType, op); allReduce(handle, null, false, 0, buf, db, off,
count, type.handle, type.baseType, op);
} }
private native void allReduce( private native void allReduce(
long comm, Object sendbuf, int sendoff, Object recvbuf, int recvoff, long comm, Object sendbuf, boolean sdb, int sendoff,
Object recvbuf, boolean rdb, int recvoff,
int count, long type, int baseType, Op op) throws MPIException; int count, long type, int baseType, Op op) throws MPIException;
/** /**
@ -2439,20 +2498,23 @@ public final void reduceScatter(Object sendbuf, Object recvbuf,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
reduceScatter(handle, sendbuf, sendoff, recvbuf, recvoff, recvcounts, reduceScatter(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
type.handle, type.baseType, op); recvcounts, type.handle, type.baseType, op);
} }
/** /**
@ -2473,19 +2535,21 @@ public final void reduceScatter(Object buf, int[] counts, Datatype type, Op op)
MPI.check(); MPI.check();
op.setDatatype(type); op.setDatatype(type);
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
reduceScatter(handle, null, 0, buf, off, counts, reduceScatter(handle, null, false, 0, buf, db, off,
type.handle, type.baseType, op); counts, type.handle, type.baseType, op);
} }
private native void reduceScatter( private native void reduceScatter(
long comm, Object sendbuf, int sendoff, Object recvbuf, int recvoff, long comm, Object sendbuf, boolean sdb, int sendoff,
Object recvbuf, boolean rdb, int recvoff,
int[] recvcounts, long type, int baseType, Op op) throws MPIException; int[] recvcounts, long type, int baseType, Op op) throws MPIException;
/** /**
@ -2562,20 +2626,23 @@ public final void reduceScatterBlock(Object sendbuf, Object recvbuf,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
} }
reduceScatterBlock(handle, sendbuf, sendoff, recvbuf, recvoff, recvcount, reduceScatterBlock(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
type.handle, type.baseType, op); recvcount, type.handle, type.baseType, op);
} }
/** /**
@ -2595,19 +2662,21 @@ public final void reduceScatterBlock(
MPI.check(); MPI.check();
op.setDatatype(type); op.setDatatype(type);
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
reduceScatterBlock(handle, null, 0, buf, off, count, reduceScatterBlock(handle, null, false, 0, buf, db, off,
type.handle, type.baseType, op); count, type.handle, type.baseType, op);
} }
private native void reduceScatterBlock( private native void reduceScatterBlock(
long comm, Object sendBuf, int sOffset, Object recvBuf, int rOffset, long comm, Object sendBuf, boolean sdb, int sOffset,
Object recvBuf, boolean rdb, int rOffset,
int rCount, long type, int baseType, Op op) throws MPIException; int rCount, long type, int baseType, Op op) throws MPIException;
/** /**
@ -2682,24 +2751,28 @@ public static void reduceLocal(
int inOff = 0, int inOff = 0,
inOutOff = 0; inOutOff = 0;
if(isHeapBuffer(inBuf)) boolean idb = false,
iodb = false;
if(inBuf instanceof Buffer && !(idb = ((Buffer)inBuf).isDirect()))
{ {
inOff = ((Buffer)inBuf).arrayOffset(); inOff = ((Buffer)inBuf).arrayOffset();
inBuf = ((Buffer)inBuf).array(); inBuf = ((Buffer)inBuf).array();
} }
if(isHeapBuffer(inOutBuf)) if(inOutBuf instanceof Buffer && !(iodb = ((Buffer)inOutBuf).isDirect()))
{ {
inOutOff = ((Buffer)inOutBuf).arrayOffset(); inOutOff = ((Buffer)inOutBuf).arrayOffset();
inOutBuf = ((Buffer)inOutBuf).array(); inOutBuf = ((Buffer)inOutBuf).array();
} }
reduceLocal(inBuf, inOff, inOutBuf, inOutOff, count, reduceLocal(inBuf, idb, inOff, inOutBuf, iodb, inOutOff, count,
type.handle, type.baseType, op); type.handle, type.baseType, op);
} }
private static native void reduceLocal( private static native void reduceLocal(
Object inBuf, int inOff, Object inOutBuf, int inOutOff, Object inBuf, boolean idb, int inOff,
Object inOutBuf, boolean iodb, int inOutOff,
int count, long type, int baseType, Op op) throws MPIException; int count, long type, int baseType, Op op) throws MPIException;
/** /**

104
ompi/mpi/java/java/File.java
Просмотреть файл

@ -236,20 +236,21 @@ public Status readAt(long offset, Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
readAt(handle, offset, buf, off, count, type, stat); readAt(handle, offset, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void readAt( private native void readAt(
long fh, long fileOffset, Object buf, int offset, long fh, long fileOffset, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -266,20 +267,21 @@ public Status readAtAll(long offset, Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
readAtAll(handle, offset, buf, off, count, type, stat); readAtAll(handle, offset, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void readAtAll( private native void readAtAll(
long fh, long fileOffset, Object buf, int offset, long fh, long fileOffset, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -296,20 +298,21 @@ public Status writeAt(long offset, Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
writeAt(handle, offset, buf, off, count, type, stat); writeAt(handle, offset, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void writeAt( private native void writeAt(
long fh, long fileOffset, Object buf, int offset, long fh, long fileOffset, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -326,20 +329,21 @@ public Status writeAtAll(long offset, Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
writeAtAll(handle, offset, buf, off, count, type, stat); writeAtAll(handle, offset, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void writeAtAll( private native void writeAtAll(
long fh, long fileOffset, Object buf, int offset, long fh, long fileOffset, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -396,20 +400,21 @@ public Status read(Object buf, int count, Datatype type) throws MPIException
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
read(handle, buf, off, count, type, stat); read(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void read( private native void read(
long fh, Object buf, int offset, long fh, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -424,20 +429,21 @@ public Status readAll(Object buf, int count, Datatype type) throws MPIException
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
readAll(handle, buf, off, count, type, stat); readAll(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void readAll( private native void readAll(
long fh, Object buf, int offset, long fh, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -452,20 +458,21 @@ public Status write(Object buf, int count, Datatype type) throws MPIException
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
write(handle, buf, off, count, type, stat); write(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void write( private native void write(
long fh, Object buf, int offset, long fh, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -480,20 +487,21 @@ public Status writeAll(Object buf, int count, Datatype type) throws MPIException
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
writeAll(handle, buf, off, count, type, stat); writeAll(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void writeAll( private native void writeAll(
long fh, Object buf, int offset, long fh, Object buf, boolean db, int offset,
int count, Datatype type, Status stat) throws MPIException; int count, Datatype type, Status stat) throws MPIException;
/** /**
@ -586,21 +594,22 @@ public Status readShared(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
readShared(handle, buf, off, count, type, stat); readShared(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void readShared( private native void readShared(
long fh, Object buf, int offset, int count, Datatype type, Status stat) long fh, Object buf, boolean db, int offset, int count,
throws MPIException; Datatype type, Status stat) throws MPIException;
/** /**
* Java binding of {@code MPI_FILE_WRITE_SHARED}. * Java binding of {@code MPI_FILE_WRITE_SHARED}.
@ -615,21 +624,22 @@ public Status writeShared(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
writeShared(handle, buf, off, count, type, stat); writeShared(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void writeShared( private native void writeShared(
long fh, Object buf, int offset, int count, Datatype type, Status stat) long fh, Object buf, boolean db, int offset, int count,
throws MPIException; Datatype type, Status stat) throws MPIException;
/** /**
* Java binding of {@code MPI_FILE_IREAD_SHARED}. * Java binding of {@code MPI_FILE_IREAD_SHARED}.
@ -682,21 +692,22 @@ public Status readOrdered(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
readOrdered(handle, buf, off, count, type, stat); readOrdered(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void readOrdered( private native void readOrdered(
long fh, Object buf, int offset, int count, Datatype type, Status stat) long fh, Object buf, boolean db, int offset, int count,
throws MPIException; Datatype type, Status stat) throws MPIException;
/** /**
* Java binding of {@code MPI_FILE_WRITE_ORDERED}. * Java binding of {@code MPI_FILE_WRITE_ORDERED}.
@ -711,21 +722,22 @@ public Status writeOrdered(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status stat = new Status(); Status stat = new Status();
writeOrdered(handle, buf, off, count, type, stat); writeOrdered(handle, buf, db, off, count, type, stat);
return stat; return stat;
} }
private native void writeOrdered( private native void writeOrdered(
long fh, Object buf, int offset, int count, Datatype type, Status stat) long fh, Object buf, boolean db, int offset, int count,
throws MPIException; Datatype type, Status stat) throws MPIException;
/** /**
* Java binding of {@code MPI_FILE_SEEK_SHARED}. * Java binding of {@code MPI_FILE_SEEK_SHARED}.
@ -783,7 +795,7 @@ public void readAtAllBegin(long offset, Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
readAtAll(handle, offset, buf, off, count, type, stat); readAtAll(handle, offset, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }
@ -845,7 +857,7 @@ public void writeAtAllBegin(long offset, Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
writeAtAll(handle, offset, buf, off, count, type, stat); writeAtAll(handle, offset, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }
@ -906,7 +918,7 @@ public void readAllBegin(Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
readAll(handle, buf, off, count, type, stat); readAll(handle, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }
@ -966,7 +978,7 @@ public void writeAllBegin(Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
writeAll(handle, buf, off, count, type, stat); writeAll(handle, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }
@ -1026,7 +1038,7 @@ public void readOrderedBegin(Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
readOrdered(handle, buf, off, count, type, stat); readOrdered(handle, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }
@ -1087,7 +1099,7 @@ public void writeOrderedBegin(Object buf, int count, Datatype type)
} }
Status stat = new Status(); Status stat = new Status();
writeOrdered(handle, buf, off, count, type, stat); writeOrdered(handle, buf, false, off, count, type, stat);
beginStatus = stat; beginStatus = stat;
} }
} }

37
ompi/mpi/java/java/Intracomm.java
Просмотреть файл

@ -24,7 +24,6 @@
package mpi; package mpi;
import java.nio.*; import java.nio.*;
import static mpi.MPI.isHeapBuffer;
import static mpi.MPI.assertDirectBuffer; import static mpi.MPI.assertDirectBuffer;
/** /**
@ -285,13 +284,16 @@ public final void scan(Object sendbuf, Object recvbuf,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
@ -299,7 +301,7 @@ public final void scan(Object sendbuf, Object recvbuf,
op.setDatatype(type); op.setDatatype(type);
scan(handle, sendbuf, sendoff, recvbuf, recvoff, scan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
count, type.handle, type.baseType, op); count, type.handle, type.baseType, op);
} }
@ -318,8 +320,9 @@ public final void scan(Object recvbuf, int count, Datatype type, Op op)
{ {
MPI.check(); MPI.check();
int recvoff = 0; int recvoff = 0;
boolean rdb = false;
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
@ -327,12 +330,13 @@ public final void scan(Object recvbuf, int count, Datatype type, Op op)
op.setDatatype(type); op.setDatatype(type);
scan(handle, null, 0, recvbuf, recvoff, scan(handle, null, false, 0, recvbuf, rdb, recvoff,
count, type.handle, type.baseType, op); count, type.handle, type.baseType, op);
} }
private native void scan( private native void scan(
long comm, Object sendbuf, int sendoff, Object recvbuf, int recvoff, long comm, Object sendbuf, boolean sdb, int sendoff,
Object recvbuf, boolean rdb, int recvoff,
int count, long type, int baseType, Op op) throws MPIException; int count, long type, int baseType, Op op) throws MPIException;
/** /**
@ -403,13 +407,16 @@ public final void exScan(Object sendbuf, Object recvbuf,
int sendoff = 0, int sendoff = 0,
recvoff = 0; recvoff = 0;
if(isHeapBuffer(sendbuf)) boolean sdb = false,
rdb = false;
if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
{ {
sendoff = ((Buffer)sendbuf).arrayOffset(); sendoff = ((Buffer)sendbuf).arrayOffset();
sendbuf = ((Buffer)sendbuf).array(); sendbuf = ((Buffer)sendbuf).array();
} }
if(isHeapBuffer(recvbuf)) if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
{ {
recvoff = ((Buffer)recvbuf).arrayOffset(); recvoff = ((Buffer)recvbuf).arrayOffset();
recvbuf = ((Buffer)recvbuf).array(); recvbuf = ((Buffer)recvbuf).array();
@ -417,7 +424,7 @@ public final void exScan(Object sendbuf, Object recvbuf,
op.setDatatype(type); op.setDatatype(type);
exScan(handle, sendbuf, sendoff, recvbuf, recvoff, exScan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
count, type.handle, type.baseType, op); count, type.handle, type.baseType, op);
} }
@ -436,19 +443,23 @@ public final void exScan(Object buf, int count, Datatype type, Op op)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
op.setDatatype(type); op.setDatatype(type);
exScan(handle, null, 0, buf, off, count, type.handle, type.baseType, op);
exScan(handle, null, false, 0, buf, db, off,
count, type.handle, type.baseType, op);
} }
private native void exScan( private native void exScan(
long comm, Object sendbuf, int sendoff, Object recvbuf, int recvoff, long comm, Object sendbuf, boolean sdb, int sendoff,
Object recvbuf, boolean rdb, int recvoff,
int count, long type, int baseType, Op op) throws MPIException; int count, long type, int baseType, Op op) throws MPIException;
/** /**

9
ompi/mpi/java/java/Message.java
Просмотреть файл

@ -91,21 +91,22 @@ public Status mRecv(Object buf, int count, Datatype type)
{ {
MPI.check(); MPI.check();
int off = 0; int off = 0;
boolean db = false;
if(isHeapBuffer(buf)) if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
{ {
off = ((Buffer)buf).arrayOffset(); off = ((Buffer)buf).arrayOffset();
buf = ((Buffer)buf).array(); buf = ((Buffer)buf).array();
} }
Status status = new Status(); Status status = new Status();
mRecv(buf, off, count, type, status); mRecv(buf, db, off, count, type, status);
return status; return status;
} }
private native void mRecv( private native void mRecv(
Object buf, int offset, int count, Datatype type, Status status) Object buf, boolean db, int offset, int count,
throws MPIException; Datatype type, Status status) throws MPIException;
/** /**
* Java binding of {@code MPI_IMRECV}. * Java binding of {@code MPI_IMRECV}.