root/ompi/mpi/java/c/mpi_Comm.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. getBufCritical
  2. releaseBufCritical
  3. isInter
  4. getSize
  5. getGroupSize
  6. getRank
  7. getTopo
  8. getNeighbors
  9. getSum
  10. Java_mpi_Comm_init
  11. Java_mpi_Comm_getComm
  12. Java_mpi_Comm_dup
  13. Java_mpi_Comm_iDup
  14. Java_mpi_Comm_dupWithInfo
  15. Java_mpi_Comm_getSize
  16. Java_mpi_Comm_getRank
  17. Java_mpi_Comm_compare
  18. Java_mpi_Comm_free
  19. Java_mpi_Comm_setInfo
  20. Java_mpi_Comm_getInfo
  21. Java_mpi_Comm_disconnect
  22. Java_mpi_Comm_getGroup
  23. Java_mpi_Comm_isInter
  24. Java_mpi_Comm_createIntercomm
  25. Java_mpi_Comm_send
  26. Java_mpi_Comm_recv
  27. Java_mpi_Comm_sendRecv
  28. Java_mpi_Comm_sendRecvReplace
  29. Java_mpi_Comm_bSend
  30. Java_mpi_Comm_sSend
  31. Java_mpi_Comm_rSend
  32. Java_mpi_Comm_iSend
  33. Java_mpi_Comm_ibSend
  34. Java_mpi_Comm_isSend
  35. Java_mpi_Comm_irSend
  36. Java_mpi_Comm_iRecv
  37. Java_mpi_Comm_sendInit
  38. Java_mpi_Comm_bSendInit
  39. Java_mpi_Comm_sSendInit
  40. Java_mpi_Comm_rSendInit
  41. Java_mpi_Comm_recvInit
  42. Java_mpi_Comm_pack
  43. Java_mpi_Comm_unpack
  44. Java_mpi_Comm_packSize
  45. Java_mpi_Comm_iProbe
  46. Java_mpi_Comm_probe
  47. Java_mpi_Comm_getTopology
  48. Java_mpi_Comm_abort
  49. Java_mpi_Comm_setErrhandler
  50. Java_mpi_Comm_getErrhandler
  51. Java_mpi_Comm_callErrhandler
  52. commCopyAttr
  53. commDeleteAttr
  54. Java_mpi_Comm_createKeyval_1jni
  55. Java_mpi_Comm_freeKeyval_1jni
  56. Java_mpi_Comm_setAttr
  57. Java_mpi_Comm_getAttr_1predefined
  58. Java_mpi_Comm_getAttr
  59. Java_mpi_Comm_deleteAttr
  60. Java_mpi_Comm_barrier
  61. Java_mpi_Comm_iBarrier
  62. Java_mpi_Comm_bcast
  63. Java_mpi_Comm_iBcast
  64. Java_mpi_Comm_gather
  65. Java_mpi_Comm_iGather
  66. Java_mpi_Comm_gatherv
  67. Java_mpi_Comm_iGatherv
  68. Java_mpi_Comm_scatter
  69. Java_mpi_Comm_iScatter
  70. Java_mpi_Comm_scatterv
  71. Java_mpi_Comm_iScatterv
  72. Java_mpi_Comm_allGather
  73. Java_mpi_Comm_iAllGather
  74. Java_mpi_Comm_allGatherv
  75. Java_mpi_Comm_iAllGatherv
  76. Java_mpi_Comm_allToAll
  77. Java_mpi_Comm_iAllToAll
  78. Java_mpi_Comm_allToAllv
  79. Java_mpi_Comm_iAllToAllv
  80. Java_mpi_Comm_allToAllw
  81. Java_mpi_Comm_iAllToAllw
  82. Java_mpi_Comm_neighborAllGather
  83. Java_mpi_Comm_iNeighborAllGather
  84. Java_mpi_Comm_neighborAllGatherv
  85. Java_mpi_Comm_iNeighborAllGatherv
  86. Java_mpi_Comm_neighborAllToAll
  87. Java_mpi_Comm_iNeighborAllToAll
  88. Java_mpi_Comm_neighborAllToAllv
  89. Java_mpi_Comm_iNeighborAllToAllv
  90. Java_mpi_Comm_reduce
  91. Java_mpi_Comm_iReduce
  92. Java_mpi_Comm_allReduce
  93. Java_mpi_Comm_iAllReduce
  94. Java_mpi_Comm_reduceScatter
  95. Java_mpi_Comm_iReduceScatter
  96. Java_mpi_Comm_reduceScatterBlock
  97. Java_mpi_Comm_iReduceScatterBlock
  98. Java_mpi_Comm_reduceLocal
  99. Java_mpi_Comm_reduceLocalUf
  100. Java_mpi_Comm_setName
  101. Java_mpi_Comm_getName

   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2005 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2015-2018 Research Organization for Information Science
  13  *                         and Technology (RIST). All rights reserved.
  14  * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
  15  *                         reserved.
  16  * Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
  17  * $COPYRIGHT$
  18  *
  19  * Additional copyrights may follow
  20  *
  21  * $HEADER$
  22  */
  23 /*
  24  * This file is almost a complete re-write for Open MPI compared to the
  25  * original mpiJava package. Its license and copyright are listed below.
  26  * See <path to ompi/mpi/java/README> for more information.
  27  */
  28 /*
  29     Licensed under the Apache License, Version 2.0 (the "License");
  30     you may not use this file except in compliance with the License.
  31     You may obtain a copy of the License at
  32 
  33        http://www.apache.org/licenses/LICENSE-2.0
  34 
  35     Unless required by applicable law or agreed to in writing, software
  36     distributed under the License is distributed on an "AS IS" BASIS,
  37     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  38     See the License for the specific language governing permissions and
  39     limitations under the License.
  40 */
  41 /*
  42  * File         : mpi_Comm.c
  43  * Headerfile   : mpi_Comm.h
  44  * Author       : Sung-Hoon Ko, Xinying Li, Sang Lim, Bryan Carpenter
  45  * Created      : Thu Apr  9 12:22:15 1998
  46  * Revision     : $Revision: 1.17 $
  47  * Updated      : $Date: 2003/01/16 16:39:34 $
  48  * Copyright: Northeast Parallel Architectures Center
  49  *            at Syracuse University 1998
  50  */
  51 #include "ompi_config.h"
  52 #include <stdlib.h>
  53 #include <assert.h>
  54 #ifdef HAVE_TARGETCONDITIONALS_H
  55 #include <TargetConditionals.h>
  56 #endif
  57 
  58 #include "mpi.h"
  59 #include "mpi_Comm.h"
  60 #include "mpiJava.h"  /* must come AFTER the related .h so JNI is included */
  61 
  62 static void* getBufCritical(void** bufBase, JNIEnv *env,
  63                             jobject buf, jboolean db, int offset)
  64 {
  65     if(buf == NULL)
  66     {
  67         /* Allow NULL buffers to send/recv 0 items as control messages. */
  68         *bufBase = NULL;
  69         return NULL;
  70     }
  71     else if(db)
  72     {
  73         *bufBase = (*env)->GetDirectBufferAddress(env, buf);
  74         assert(offset == 0);
  75         return *bufBase;
  76     }
  77     else
  78     {
  79         return ompi_java_getArrayCritical(bufBase, env, buf, offset);
  80     }
  81 }
  82 
  83 static void releaseBufCritical(
  84         JNIEnv *env, jobject buf, jboolean db, void* bufBase)
  85 {
  86     if(!db && buf)
  87         (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0);
  88 }
  89 
  90 static int isInter(JNIEnv *env, MPI_Comm comm)
  91 {
  92     int rc, flag;
  93     rc = MPI_Comm_test_inter(comm, &flag);
  94     ompi_java_exceptionCheck(env, rc);
  95     return flag;
  96 }
  97 
  98 static int getSize(JNIEnv *env, MPI_Comm comm, int inter)
  99 {
 100     int rc, size;
 101 
 102     if(inter)
 103         rc = MPI_Comm_remote_size(comm, &size);
 104     else
 105         rc = MPI_Comm_size(comm, &size);
 106 
 107     ompi_java_exceptionCheck(env, rc);
 108     return size;
 109 }
 110 
 111 static int getGroupSize(JNIEnv *env, MPI_Comm comm)
 112 {
 113     int rc, size;
 114     rc = MPI_Comm_size(comm, &size);
 115     ompi_java_exceptionCheck(env, rc);
 116     return size;
 117 }
 118 
 119 static int getRank(JNIEnv *env, MPI_Comm comm)
 120 {
 121     int rc, rank;
 122     rc = MPI_Comm_rank(comm, &rank);
 123     ompi_java_exceptionCheck(env, rc);
 124     return rank;
 125 }
 126 
 127 static int getTopo(JNIEnv *env, MPI_Comm comm)
 128 {
 129     int rc, status;
 130     rc = MPI_Topo_test(comm, &status);
 131     ompi_java_exceptionCheck(env, rc);
 132     return status;
 133 }
 134 
 135 static void getNeighbors(JNIEnv *env, MPI_Comm comm, int *out, int *in)
 136 {
 137     int rc, weighted;
 138 
 139     switch(getTopo(env, comm))
 140     {
 141         case MPI_CART:
 142             rc = MPI_Cartdim_get(comm, in);
 143             *in *= 2;
 144             *out = *in;
 145             break;
 146         case MPI_GRAPH:
 147             rc = MPI_Graph_neighbors_count(comm, getRank(env, comm), in);
 148             *out = *in;
 149             break;
 150         case MPI_DIST_GRAPH:
 151             rc = MPI_Dist_graph_neighbors_count(comm, in, out, &weighted);
 152             break;
 153         default:
 154             rc = MPI_ERR_TOPOLOGY;
 155             break;
 156     }
 157 
 158     ompi_java_exceptionCheck(env, rc);
 159 }
 160 
 161 static int getSum(int *counts, int size)
 162 {
 163     int i, s = 0;
 164 
 165     for(i = 0; i < size; i++)
 166         s += counts[i];
 167 
 168     return s;
 169 }
 170 
 171 JNIEXPORT void JNICALL Java_mpi_Comm_init(JNIEnv *env, jclass clazz)
 172 {
 173     jfieldID nullHandleID = (*env)->GetStaticFieldID(
 174                             env, clazz, "nullHandle", "J");
 175 
 176     (*env)->SetStaticLongField(env, clazz, nullHandleID, (jlong)MPI_COMM_NULL);
 177     ompi_java.CommHandle = (*env)->GetFieldID(env,clazz,"handle","J");
 178 }
 179 
 180 JNIEXPORT void JNICALL Java_mpi_Comm_getComm(JNIEnv *env, jobject jthis,
 181                                              jint type)
 182 {
 183     switch (type) {
 184     case 0:
 185         (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_NULL);
 186         break;
 187     case 1:
 188         (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_SELF);
 189         break;
 190     case 2:
 191         (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_WORLD);
 192         break;
 193     }
 194 }
 195 
 196 JNIEXPORT jlong JNICALL Java_mpi_Comm_dup(
 197         JNIEnv *env, jobject jthis, jlong comm)
 198 {
 199     MPI_Comm newcomm;
 200     int rc = MPI_Comm_dup((MPI_Comm)comm, &newcomm);
 201     ompi_java_exceptionCheck(env, rc);
 202     return (jlong)newcomm;
 203 }
 204 
 205 JNIEXPORT jlongArray JNICALL Java_mpi_Comm_iDup(
 206         JNIEnv *env, jobject jthis, jlong comm)
 207 {
 208     MPI_Comm newcomm;
 209     MPI_Request request;
 210     int rc = MPI_Comm_idup((MPI_Comm)comm, &newcomm, &request);
 211     
 212     if(ompi_java_exceptionCheck(env, rc))
 213         return NULL;
 214     
 215     jlongArray jcr = (*env)->NewLongArray(env, 2);
 216     jlong *cr = (jlong*)(*env)->GetPrimitiveArrayCritical(env, jcr, NULL);
 217     cr[0] = (jlong)newcomm;
 218     cr[1] = (jlong)request;
 219     (*env)->ReleasePrimitiveArrayCritical(env, jcr, cr, 0);
 220     return jcr;
 221 }
 222 
 223 JNIEXPORT jlong JNICALL Java_mpi_Comm_dupWithInfo(
 224         JNIEnv *env, jobject jthis, jlong comm, jlong info)
 225 {
 226     MPI_Comm newcomm;
 227     int rc = MPI_Comm_dup_with_info((MPI_Comm)comm, (MPI_Info)info, &newcomm);
 228     ompi_java_exceptionCheck(env, rc);
 229     return (jlong)newcomm;
 230 }
 231 
 232 JNIEXPORT jint JNICALL Java_mpi_Comm_getSize(
 233         JNIEnv *env, jobject jthis, jlong comm)
 234 {
 235     int rc, size;
 236     rc = MPI_Comm_size((MPI_Comm)comm, &size);
 237     ompi_java_exceptionCheck(env, rc);
 238     return size;
 239 }
 240 
 241 JNIEXPORT jint JNICALL Java_mpi_Comm_getRank(
 242         JNIEnv *env, jobject jthis, jlong comm)
 243 {
 244     return getRank(env, (MPI_Comm)comm);
 245 }
 246 
 247 JNIEXPORT jint JNICALL Java_mpi_Comm_compare(
 248         JNIEnv *env, jclass jthis, jlong comm1, jlong comm2)
 249 {
 250     int rc, result;
 251     rc = MPI_Comm_compare((MPI_Comm)comm1, (MPI_Comm)comm2, &result);
 252     ompi_java_exceptionCheck(env, rc);
 253     return result;
 254 }
 255 
 256 JNIEXPORT jlong JNICALL Java_mpi_Comm_free(
 257         JNIEnv *env, jobject jthis, jlong handle)
 258 {
 259     MPI_Comm comm = (MPI_Comm)handle;
 260     int rc = MPI_Comm_free(&comm);
 261     ompi_java_exceptionCheck(env, rc);
 262     return (jlong)comm;
 263 }
 264 
 265 JNIEXPORT void JNICALL Java_mpi_Comm_setInfo(
 266         JNIEnv *env, jobject jthis, jlong comm, jlong info)
 267 {
 268     int rc = MPI_Comm_set_info((MPI_Comm)comm, (MPI_Info)info);
 269     ompi_java_exceptionCheck(env, rc);
 270 }
 271 
 272 JNIEXPORT jlong JNICALL Java_mpi_Comm_getInfo(
 273         JNIEnv *env, jobject jthis, jlong comm)
 274 {
 275     MPI_Info info;
 276     int rc = MPI_Comm_get_info((MPI_Comm)comm, &info);
 277     ompi_java_exceptionCheck(env, rc);
 278     return (jlong)info;
 279 }
 280 
 281 JNIEXPORT jlong JNICALL Java_mpi_Comm_disconnect(
 282         JNIEnv *env, jobject jthis, jlong handle)
 283 {
 284     MPI_Comm comm = (MPI_Comm)handle;
 285     int rc = MPI_Comm_disconnect(&comm);
 286     ompi_java_exceptionCheck(env, rc);
 287     return (jlong)comm;
 288 }
 289 
 290 JNIEXPORT jlong JNICALL Java_mpi_Comm_getGroup(
 291         JNIEnv *env, jobject jthis, jlong comm)
 292 {
 293     MPI_Group group;
 294     int rc = MPI_Comm_group((MPI_Comm)comm, &group);
 295     ompi_java_exceptionCheck(env, rc);
 296     return (jlong)group;
 297 }
 298 
 299 JNIEXPORT jboolean JNICALL Java_mpi_Comm_isInter(
 300         JNIEnv *env, jobject jthis, jlong comm)
 301 {
 302     return isInter(env, (MPI_Comm)comm) ? JNI_TRUE : JNI_FALSE;
 303 }
 304 
 305 JNIEXPORT jlong JNICALL Java_mpi_Comm_createIntercomm(
 306         JNIEnv *env, jobject jthis, jlong comm, jlong localComm,
 307         jint localLeader, jint remoteLeader, jint tag)
 308 {
 309     MPI_Comm newintercomm;
 310 
 311     int rc = MPI_Intercomm_create(
 312              (MPI_Comm)localComm, localLeader,
 313              (MPI_Comm)comm, remoteLeader, tag, &newintercomm);
 314 
 315     ompi_java_exceptionCheck(env, rc);
 316     return (jlong)newintercomm;
 317 }
 318 
 319 JNIEXPORT void JNICALL Java_mpi_Comm_send(
 320         JNIEnv *env, jobject jthis, jlong jComm,
 321         jobject buf, jboolean db, jint offset, jint count,
 322         jlong jType, jint bType, jint dest, jint tag)
 323 {
 324     MPI_Comm     comm = (MPI_Comm)jComm;
 325     MPI_Datatype type = (MPI_Datatype)jType;
 326 
 327     void *ptr;
 328     ompi_java_buffer_t *item;
 329     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 330 
 331     int rc = MPI_Send(ptr, count, type, dest, tag, comm);
 332     ompi_java_exceptionCheck(env, rc);
 333     ompi_java_releaseReadPtr(ptr, item, buf, db);
 334 }
 335 
 336 JNIEXPORT void JNICALL Java_mpi_Comm_recv(
 337         JNIEnv *env, jobject jthis, jlong jComm,
 338         jobject buf, jboolean db, jint offset, jint count,
 339         jlong jType, jint bType, jint source, jint tag, jlongArray jStatus)
 340 {
 341     jboolean exception;
 342     MPI_Comm     comm = (MPI_Comm)jComm;
 343     MPI_Datatype type = (MPI_Datatype)jType;
 344 
 345     void *ptr;
 346     ompi_java_buffer_t *item;
 347     ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
 348 
 349     MPI_Status status;
 350     int rc = MPI_Recv(ptr, count, type, source, tag, comm, &status);
 351     exception = ompi_java_exceptionCheck(env, rc);
 352 
 353     ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
 354     
 355     if(!exception)
 356         ompi_java_status_set(env, jStatus, &status);
 357 }
 358 
 359 JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv(
 360         JNIEnv *env, jobject jthis, jlong jComm,
 361         jobject sBuf, jboolean sdb, jint sOff, jint sCount,
 362         jlong sjType, jint sBType, jint dest, jint sTag,
 363         jobject rBuf, jboolean rdb, jint rOff, jint rCount,
 364         jlong rjType, jint rBType, jint source, jint rTag,
 365         jlongArray jStatus)
 366 {
 367     jboolean exception;
 368     MPI_Comm     comm  = (MPI_Comm)jComm;
 369     MPI_Datatype sType = (MPI_Datatype)sjType;
 370     MPI_Datatype rType = (MPI_Datatype)rjType;
 371 
 372     void *sPtr, *rPtr;
 373     ompi_java_buffer_t *sItem, *rItem;
 374     MPI_Status status;
 375 
 376     ompi_java_getReadPtr(&sPtr,&sItem, env, sBuf,sdb,sOff,sCount,sType,sBType);
 377     ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
 378 
 379     int rc = MPI_Sendrecv(sPtr, sCount, sType, dest, sTag,
 380                           rPtr, rCount, rType, source, rTag, comm, &status);
 381 
 382     exception = ompi_java_exceptionCheck(env, rc);
 383     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
 384     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rCount,rType,rBType);
 385     
 386     if(!exception)
 387         ompi_java_status_set(env, jStatus, &status);
 388 }
 389 
 390 JNIEXPORT void JNICALL Java_mpi_Comm_sendRecvReplace(
 391         JNIEnv *env, jobject jthis, jlong jComm,
 392         jobject buf, jboolean db, jint offset,
 393         jint count, jlong jType, jint bType,
 394         jint dest, jint sTag, jint source, jint rTag, jlongArray jStatus)
 395 {
 396     MPI_Comm     comm = (MPI_Comm)jComm;
 397     MPI_Datatype type = (MPI_Datatype)jType;
 398 
 399     void *ptr;
 400     ompi_java_buffer_t *item;
 401     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 402     MPI_Status status;
 403 
 404     int rc = MPI_Sendrecv_replace(ptr, count, type, dest,
 405                                   sTag, source, rTag, comm, &status);
 406 
 407     if(!ompi_java_exceptionCheck(env, rc))
 408         ompi_java_status_set(env, jStatus, &status);
 409 
 410     ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
 411 }
 412 
 413 JNIEXPORT void JNICALL Java_mpi_Comm_bSend(
 414         JNIEnv *env, jobject jthis, jlong jComm,
 415         jobject buf, jboolean db, jint offset,
 416         jint count, jlong jType, jint bType, jint dest, jint tag)
 417 {
 418     MPI_Comm     comm = (MPI_Comm)jComm;
 419     MPI_Datatype type = (MPI_Datatype)jType;
 420 
 421     void *ptr;
 422     ompi_java_buffer_t *item;
 423     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 424 
 425     int rc = MPI_Bsend(ptr, count, type, dest, tag, comm);
 426     ompi_java_exceptionCheck(env, rc);
 427     ompi_java_releaseReadPtr(ptr, item, buf, db);
 428 }
 429 
 430 JNIEXPORT void JNICALL Java_mpi_Comm_sSend(
 431         JNIEnv *env, jobject jthis, jlong jComm,
 432         jobject buf, jboolean db, jint offset,
 433         jint count, jlong jType, jint bType, jint dest, jint tag)
 434 {
 435     MPI_Comm     comm = (MPI_Comm)jComm;
 436     MPI_Datatype type = (MPI_Datatype)jType;
 437 
 438     void *ptr;
 439     ompi_java_buffer_t *item;
 440     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 441 
 442     int rc = MPI_Ssend(ptr, count, type, dest, tag, comm);
 443     ompi_java_exceptionCheck(env, rc);
 444     ompi_java_releaseReadPtr(ptr, item, buf, db);
 445 }
 446 
 447 JNIEXPORT void JNICALL Java_mpi_Comm_rSend(
 448         JNIEnv *env, jobject jthis, jlong jComm,
 449         jobject buf, jboolean db, jint offset,
 450         jint count, jlong jType, jint bType, jint dest, jint tag)
 451 {
 452     MPI_Comm     comm = (MPI_Comm)jComm;
 453     MPI_Datatype type = (MPI_Datatype)jType;
 454 
 455     void *ptr;
 456     ompi_java_buffer_t *item;
 457     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 458 
 459     int rc = MPI_Rsend(ptr, count, type, dest, tag, comm);
 460     ompi_java_exceptionCheck(env, rc);
 461     ompi_java_releaseReadPtr(ptr, item, buf, db);
 462 }
 463 
 464 JNIEXPORT jlong JNICALL Java_mpi_Comm_iSend(
 465         JNIEnv *env, jobject jthis, jlong comm,
 466         jobject buf, jint count, jlong type, jint dest, jint tag)
 467 {
 468     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 469     MPI_Request request;
 470 
 471     int rc = MPI_Isend(ptr, count, (MPI_Datatype)type,
 472                        dest, tag, (MPI_Comm)comm, &request);
 473 
 474     ompi_java_exceptionCheck(env, rc);
 475     return (jlong)request;
 476 }
 477 
 478 JNIEXPORT jlong JNICALL Java_mpi_Comm_ibSend(
 479         JNIEnv *env, jobject jthis, jlong comm,
 480         jobject buf, jint count, jlong type, jint dest, jint tag)
 481 {
 482     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 483     MPI_Request request;
 484 
 485     int rc = MPI_Ibsend(ptr, count, (MPI_Datatype)type,
 486                         dest, tag, (MPI_Comm)comm, &request);
 487 
 488     ompi_java_exceptionCheck(env, rc);
 489     return (jlong)request;
 490 }
 491 
 492 JNIEXPORT jlong JNICALL Java_mpi_Comm_isSend(
 493         JNIEnv *env, jobject jthis, jlong comm,
 494         jobject buf, jint count, jlong type, jint dest, jint tag)
 495 {
 496     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 497     MPI_Request request;
 498 
 499     int rc = MPI_Issend(ptr, count, (MPI_Datatype)type,
 500                         dest, tag, (MPI_Comm)comm, &request);
 501 
 502     ompi_java_exceptionCheck(env, rc);
 503     return (jlong)request;
 504 }
 505 
 506 JNIEXPORT jlong JNICALL Java_mpi_Comm_irSend(
 507         JNIEnv *env, jobject jthis, jlong comm,
 508         jobject buf, jint count, jlong type, jint dest, jint tag)
 509 {
 510     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 511     MPI_Request request;
 512 
 513     int rc = MPI_Irsend(ptr, count, (MPI_Datatype)type,
 514                         dest, tag, (MPI_Comm)comm, &request);
 515 
 516     ompi_java_exceptionCheck(env, rc);
 517     return (jlong)request;
 518 }
 519 
 520 JNIEXPORT jlong JNICALL Java_mpi_Comm_iRecv(
 521         JNIEnv *env, jobject jthis, jlong comm,
 522         jobject buf, jint count, jlong type, jint source, jint tag)
 523 {
 524     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 525     MPI_Request request;
 526 
 527     int rc = MPI_Irecv(ptr, count, (MPI_Datatype)type,
 528                        source, tag, (MPI_Comm)comm, &request);
 529 
 530     ompi_java_exceptionCheck(env, rc);
 531     return (jlong)request;
 532 }
 533 
 534 JNIEXPORT jlong JNICALL Java_mpi_Comm_sendInit(
 535         JNIEnv *env, jobject jthis, jlong comm,
 536         jobject buf, jint count, jlong type, jint dest, jint tag)
 537 {
 538     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 539     MPI_Request request;
 540 
 541     int rc = MPI_Send_init(ptr, count, (MPI_Datatype)type,
 542                            dest, tag, (MPI_Comm)comm, &request);
 543 
 544     ompi_java_exceptionCheck(env, rc);
 545     return (jlong)request;
 546 }
 547 
 548 JNIEXPORT jlong JNICALL Java_mpi_Comm_bSendInit(
 549         JNIEnv *env, jobject jthis, jlong comm,
 550         jobject buf, jint count, jlong type, jint dest, jint tag)
 551 {
 552     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 553     MPI_Request request;
 554 
 555     int rc = MPI_Bsend_init(ptr, count, (MPI_Datatype)type,
 556                             dest, tag, (MPI_Comm)comm, &request);
 557 
 558     ompi_java_exceptionCheck(env, rc);
 559     return (jlong)request;
 560 }
 561 
 562 JNIEXPORT jlong JNICALL Java_mpi_Comm_sSendInit(
 563         JNIEnv *env, jobject jthis, jlong comm,
 564         jobject buf, jint count, jlong type, jint dest, jint tag)
 565 {
 566     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 567     MPI_Request request;
 568 
 569     int rc = MPI_Ssend_init(ptr, count, (MPI_Datatype)type,
 570                             dest, tag, (MPI_Comm)comm, &request);
 571 
 572     ompi_java_exceptionCheck(env, rc);
 573     return (jlong)request;
 574 }
 575 
 576 JNIEXPORT jlong JNICALL Java_mpi_Comm_rSendInit(
 577         JNIEnv *env, jobject jthis, jlong comm,
 578         jobject buf, jint count, jlong type, jint dest, jint tag)
 579 {
 580     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 581     MPI_Request request;
 582 
 583     int rc = MPI_Rsend_init(ptr, count, (MPI_Datatype)type,
 584                             dest, tag, (MPI_Comm)comm, &request);
 585 
 586     ompi_java_exceptionCheck(env, rc);
 587     return (jlong)request;
 588 }
 589 
 590 JNIEXPORT jlong JNICALL Java_mpi_Comm_recvInit(
 591         JNIEnv *env, jobject jthis, jlong comm,
 592         jobject buf, jint count, jlong type, jint source, jint tag)
 593 {
 594     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 595     MPI_Request request;
 596 
 597     int rc = MPI_Recv_init(ptr, count, (MPI_Datatype)type,
 598                            source, tag, (MPI_Comm)comm, &request);
 599 
 600     ompi_java_exceptionCheck(env, rc);
 601     return (jlong)request;
 602 }
 603 
 604 JNIEXPORT jint JNICALL Java_mpi_Comm_pack(
 605         JNIEnv *env, jobject jthis, jlong jComm,
 606         jobject inBuf, jboolean indb, jint offset,
 607         jint inCount, jlong jType, jbyteArray outBuf, jint position)
 608 {
 609     MPI_Comm     comm = (MPI_Comm)jComm;
 610     MPI_Datatype type = (MPI_Datatype)jType;
 611     int outSize = (*env)->GetArrayLength(env, outBuf);
 612 
 613     void *oBufPtr, *iBufPtr, *iBufBase;
 614     oBufPtr = (*env)->GetPrimitiveArrayCritical(env, outBuf, NULL);
 615     iBufPtr = getBufCritical(&iBufBase, env, inBuf, indb, offset);
 616 
 617     if(inCount != 0 && outSize != position)
 618     {
 619         /* LAM doesn't like count = 0 */
 620         int rc = MPI_Pack(iBufPtr, inCount, type,
 621                           oBufPtr, outSize, &position, comm);
 622 
 623         ompi_java_exceptionCheck(env, rc);
 624     }
 625 
 626     releaseBufCritical(env, inBuf, indb, iBufBase);
 627     (*env)->ReleasePrimitiveArrayCritical(env, outBuf, oBufPtr, 0);
 628     return position;
 629 }
 630 
 631 JNIEXPORT jint JNICALL Java_mpi_Comm_unpack(
 632         JNIEnv *env, jobject jthis, jlong jComm,
 633         jbyteArray inBuf, jint position, jobject outBuf, jboolean outdb,
 634         jint offset, jint outCount, jlong jType)
 635 {
 636     MPI_Comm     comm = (MPI_Comm)jComm;
 637     MPI_Datatype type = (MPI_Datatype)jType;
 638     int inSize = (*env)->GetArrayLength(env, inBuf);
 639 
 640     void *iBufPtr, *oBufPtr, *oBufBase;
 641     iBufPtr = (*env)->GetPrimitiveArrayCritical(env, inBuf, NULL);
 642     oBufPtr = getBufCritical(&oBufBase, env, outBuf, outdb, offset);
 643 
 644     int rc = MPI_Unpack(iBufPtr, inSize, &position,
 645                         oBufPtr, outCount, type, comm);
 646 
 647     ompi_java_exceptionCheck(env, rc);
 648     (*env)->ReleasePrimitiveArrayCritical(env, inBuf, iBufPtr, 0);
 649     releaseBufCritical(env, outBuf, outdb, oBufBase);
 650     return position;
 651 }
 652 
 653 JNIEXPORT jint JNICALL Java_mpi_Comm_packSize(
 654         JNIEnv *env, jobject jthis, jlong comm, jint incount, jlong type)
 655 {
 656     int rc, size;
 657     rc = MPI_Pack_size(incount, (MPI_Datatype)type, (MPI_Comm)comm, &size);
 658     ompi_java_exceptionCheck(env, rc);
 659     return size;
 660 }
 661 
 662 JNIEXPORT jobject JNICALL Java_mpi_Comm_iProbe(
 663         JNIEnv *env, jobject jthis, jlong comm, jint source, jint tag)
 664 {
 665     int flag;
 666     MPI_Status status;
 667     int rc = MPI_Iprobe(source, tag, (MPI_Comm)comm, &flag, &status);
 668     ompi_java_exceptionCheck(env, rc);
 669     return flag ? ompi_java_status_new(env, &status) : NULL;
 670 }
 671 
 672 JNIEXPORT void JNICALL Java_mpi_Comm_probe(
 673         JNIEnv *env, jobject jthis, jlong comm,
 674         jint source, jint tag, jlongArray jStatus)
 675 {
 676     MPI_Status status;
 677     int rc = MPI_Probe(source, tag, (MPI_Comm)comm, &status);
 678     
 679     if(!ompi_java_exceptionCheck(env, rc))
 680         ompi_java_status_set(env, jStatus, &status);
 681 }
 682 
 683 JNIEXPORT jint JNICALL Java_mpi_Comm_getTopology(
 684         JNIEnv *env, jobject jthis, jlong comm)
 685 {
 686     return getTopo(env, (MPI_Comm)comm);
 687 }
 688 
 689 JNIEXPORT void JNICALL Java_mpi_Comm_abort(
 690         JNIEnv *env, jobject jthis, jlong comm, jint errorcode)
 691 {
 692     int rc = MPI_Abort((MPI_Comm)comm, errorcode);
 693     ompi_java_exceptionCheck(env, rc);
 694 }
 695 
 696 JNIEXPORT void JNICALL Java_mpi_Comm_setErrhandler(
 697         JNIEnv *env, jobject jthis, jlong comm, jlong errhandler)
 698 {
 699     int rc = MPI_Comm_set_errhandler((MPI_Comm)comm, (MPI_Errhandler)errhandler);
 700     ompi_java_exceptionCheck(env, rc);
 701 }
 702 
 703 JNIEXPORT jlong JNICALL Java_mpi_Comm_getErrhandler(
 704         JNIEnv *env, jobject jthis, jlong comm)
 705 {
 706     MPI_Errhandler errhandler;
 707     int rc = MPI_Comm_get_errhandler((MPI_Comm)comm, &errhandler);
 708     ompi_java_exceptionCheck(env, rc);
 709     return (jlong)errhandler;
 710 }
 711 
 712 JNIEXPORT void JNICALL Java_mpi_Comm_callErrhandler(
 713         JNIEnv *env, jobject jthis, jlong comm, jint errorCode)
 714 {
 715     int rc = MPI_Comm_call_errhandler((MPI_Comm)comm, errorCode);
 716     ompi_java_exceptionCheck(env, rc);
 717 }
 718 
 719 static int commCopyAttr(MPI_Comm oldcomm, int keyval, void *extraState,
 720                         void *attrValIn, void *attrValOut, int *flag)
 721 {
 722     return ompi_java_attrCopy(attrValIn, attrValOut, flag);
 723 }
 724 
 725 static int commDeleteAttr(MPI_Comm oldcomm, int keyval,
 726                           void *attrVal, void *extraState)
 727 {
 728     return ompi_java_attrDelete(attrVal);
 729 }
 730 
 731 JNIEXPORT jint JNICALL Java_mpi_Comm_createKeyval_1jni(
 732                        JNIEnv *env, jclass clazz)
 733 {
 734     int rc, keyval;
 735     rc = MPI_Comm_create_keyval(commCopyAttr, commDeleteAttr, &keyval, NULL);
 736     ompi_java_exceptionCheck(env, rc);
 737     return keyval;
 738 }
 739 
 740 JNIEXPORT void JNICALL Java_mpi_Comm_freeKeyval_1jni(
 741                        JNIEnv *env, jclass clazz, jint keyval)
 742 {
 743     int rc = MPI_Comm_free_keyval((int*)(&keyval));
 744     ompi_java_exceptionCheck(env, rc);
 745 }
 746 
 747 JNIEXPORT void JNICALL Java_mpi_Comm_setAttr(
 748         JNIEnv *env, jobject jthis, jlong comm, jint keyval, jbyteArray jval)
 749 {
 750     void *cval = ompi_java_attrSet(env, jval);
 751     int rc = MPI_Comm_set_attr((MPI_Comm)comm, keyval, cval);
 752     ompi_java_exceptionCheck(env, rc);
 753 }
 754 
 755 JNIEXPORT jobject JNICALL Java_mpi_Comm_getAttr_1predefined(
 756         JNIEnv *env, jobject jthis, jlong comm, jint keyval)
 757 {
 758     int flag, *val;
 759     int rc = MPI_Comm_get_attr((MPI_Comm)comm, keyval, &val, &flag);
 760 
 761     if(ompi_java_exceptionCheck(env, rc) || !flag)
 762         return NULL;
 763 
 764     return ompi_java_Integer_valueOf(env, (jint)(*val));
 765 }
 766 
 767 JNIEXPORT jbyteArray JNICALL Java_mpi_Comm_getAttr(
 768         JNIEnv *env, jobject jthis, jlong comm, jint keyval)
 769 {
 770     int flag;
 771     void *cval;
 772     int rc = MPI_Comm_get_attr((MPI_Comm)comm, keyval, &cval, &flag);
 773 
 774     if(ompi_java_exceptionCheck(env, rc) || !flag)
 775         return NULL;
 776 
 777     return ompi_java_attrGet(env, cval);
 778 }
 779 
 780 JNIEXPORT void JNICALL Java_mpi_Comm_deleteAttr(
 781         JNIEnv *env, jobject jthis, jlong comm, jint keyval)
 782 {
 783     int rc = MPI_Comm_delete_attr((MPI_Comm)comm, keyval);
 784     ompi_java_exceptionCheck(env, rc);
 785 }
 786 
 787 JNIEXPORT void JNICALL Java_mpi_Comm_barrier(
 788         JNIEnv *env, jobject jthis, jlong comm)
 789 {
 790     int rc = MPI_Barrier((MPI_Comm)comm);
 791     ompi_java_exceptionCheck(env, rc);
 792 }
 793 
 794 JNIEXPORT jlong JNICALL Java_mpi_Comm_iBarrier(
 795         JNIEnv *env, jobject jthis, jlong comm)
 796 {
 797     MPI_Request request;
 798     int rc = MPI_Ibarrier((MPI_Comm)comm, &request);
 799     ompi_java_exceptionCheck(env, rc);
 800     return (jlong)request;
 801 }
 802 
 803 JNIEXPORT void JNICALL Java_mpi_Comm_bcast(
 804         JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jboolean db,
 805         jint offset, jint count, jlong jType, jint bType, jint root)
 806 {
 807     MPI_Comm     comm = (MPI_Comm)jComm;
 808     MPI_Datatype type = (MPI_Datatype)jType;
 809 
 810     void *ptr;
 811     ompi_java_buffer_t *item;
 812     ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
 813 
 814     int rc = MPI_Bcast(ptr, count, type, root, comm);
 815     ompi_java_exceptionCheck(env, rc);
 816     ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
 817 }
 818 
 819 JNIEXPORT jlong JNICALL Java_mpi_Comm_iBcast(
 820         JNIEnv *env, jobject jthis, jlong comm,
 821         jobject buf, jint count, jlong type, jint root)
 822 {
 823     void *ptr = ompi_java_getDirectBufferAddress(env, buf);
 824     MPI_Request request;
 825 
 826     int rc = MPI_Ibcast(ptr, count, (MPI_Datatype)type,
 827                         root, (MPI_Comm)comm, &request);
 828 
 829     ompi_java_exceptionCheck(env, rc);
 830     return (jlong)request;
 831 }
 832 
 833 JNIEXPORT void JNICALL Java_mpi_Comm_gather(
 834         JNIEnv *env, jobject jthis, jlong jComm,
 835         jobject sBuf, jboolean sdb, jint sOff, jint sCount,
 836         jlong sjType, jint sBType,
 837         jobject rBuf, jboolean rdb, jint rOff, jint rCount,
 838         jlong rjType, jint rBType, jint root)
 839 {
 840     MPI_Comm comm = (MPI_Comm)jComm;
 841     int rank  = getRank(env, comm);
 842     int inter = isInter(env, comm);
 843     int rootOrInter = rank == root || inter;
 844 
 845     void *sPtr, *rPtr = NULL;
 846     ompi_java_buffer_t *sItem, *rItem;
 847     MPI_Datatype sType;
 848 
 849     if(sjType == 0)
 850     {
 851         assert(sBuf == NULL);
 852         sType = MPI_DATATYPE_NULL;
 853         sPtr  = MPI_IN_PLACE;
 854     }
 855     else
 856     {
 857         sType = (MPI_Datatype)sjType;
 858 
 859         ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
 860                              sOff, sCount, sType, sBType);
 861     }
 862 
 863     MPI_Datatype rType = (MPI_Datatype)rjType;
 864     int rCountTotal = rootOrInter ? rCount * getSize(env, comm, inter) : rCount;
 865 
 866     if(rootOrInter || sPtr == MPI_IN_PLACE)
 867     {
 868         if(sPtr == MPI_IN_PLACE)
 869         {
 870             /* We use the receive buffer as the send buffer. */
 871             ompi_java_getReadPtr(&rPtr, &rItem, env, rBuf, rdb,
 872                                  rOff, rCountTotal, rType, rBType);
 873         }
 874         else
 875         {
 876             ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb,
 877                                   rCountTotal, rType);
 878         }
 879 
 880         if(!rootOrInter)
 881         {
 882             /* The receive buffer is ignored for all non-root processes.
 883              * As we are using MPI_IN_PLACE version, we use the receive
 884              * buffer as the send buffer.
 885              */
 886             assert(sBuf == NULL);
 887             sPtr   = rPtr;
 888             sCount = rCount;
 889             sType  = rType;
 890         }
 891     }
 892 
 893     int rc = MPI_Gather(sPtr, sCount, sType, rPtr, rCount, rType, root, comm);
 894     ompi_java_exceptionCheck(env, rc);
 895 
 896     if(rootOrInter)
 897     {
 898         ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
 899                                   rOff, rCountTotal, rType, rBType);
 900     }
 901     else if(sBuf == NULL)
 902     {
 903         ompi_java_releaseReadPtr(rPtr, rItem, rBuf, rdb);
 904     }
 905 
 906     if(sBuf != NULL)
 907         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
 908 }
 909 
 910 JNIEXPORT jlong JNICALL Java_mpi_Comm_iGather(
 911         JNIEnv *env, jobject jthis, jlong jComm,
 912         jobject sendBuf, jint sCount, jlong sType,
 913         jobject recvBuf, jint rCount, jlong rType, jint root)
 914 {
 915     MPI_Comm comm = (MPI_Comm)jComm;
 916     int rank = getRank(env, comm);
 917     int rootOrInter = rank == root || isInter(env, comm);
 918 
 919     MPI_Request request;
 920     void *sPtr, *rPtr = NULL;
 921 
 922     if(sType == 0)
 923     {
 924         assert(sendBuf == NULL);
 925         sType = (jlong)MPI_DATATYPE_NULL;
 926         sPtr  = MPI_IN_PLACE;
 927     }
 928     else
 929     {
 930         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
 931     }
 932 
 933     if(rootOrInter || sPtr == MPI_IN_PLACE)
 934     {
 935         /*
 936          * In principle need the "id == root" check here and elsewere for
 937          * correctness, in case arguments that are not supposed to be
 938          * significant except on root are legitimately passed in as `null',
 939          * say.  Shouldn't produce null pointer exception.
 940          *
 941          * (However in this case MPICH complains if `mpi_rtype' is not defined
 942          * in all processes, notwithstanding what the spec says.)
 943          */
 944 
 945         rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
 946 
 947         if(!rootOrInter)
 948         {
 949             /* The receive buffer is ignored for all non-root processes.
 950              * As we are using MPI_IN_PLACE version, we use the receive
 951              * buffer as the send buffer.
 952              */
 953             assert(sendBuf == NULL);
 954             sPtr   = rPtr;
 955             sCount = rCount;
 956             sType  = rType;
 957         }
 958     }
 959 
 960     int rc = MPI_Igather(sPtr, sCount, (MPI_Datatype)sType,
 961                          rPtr, rCount, (MPI_Datatype)rType,
 962                          root, comm, &request);
 963 
 964     ompi_java_exceptionCheck(env, rc);
 965     return (jlong)request;
 966 }
 967 
 968 JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
 969         JNIEnv *env, jobject jthis, jlong jComm,
 970         jobject sBuf, jboolean sdb, jint sOff,
 971         jint sCount, jlong sjType, jint sBType,
 972         jobject rBuf, jboolean rdb, jint rOff, jintArray rCounts,
 973         jintArray displs, jlong rjType, jint rBType, jint root)
 974 {
 975     MPI_Comm comm = (MPI_Comm)jComm;
 976     int rank  = getRank(env, comm);
 977     int inter = isInter(env, comm);
 978     int rootOrInter = rank == root || inter;
 979     int size = rootOrInter ? getSize(env, comm, inter) : 0;
 980 
 981     void *sPtr, *rPtr = NULL;
 982     ompi_java_buffer_t *sItem, *rItem;
 983     MPI_Datatype sType;
 984 
 985     if(sjType == 0)
 986     {
 987         assert(sBuf == NULL);
 988         sType = MPI_DATATYPE_NULL;
 989         sPtr  = MPI_IN_PLACE;
 990     }
 991     else
 992     {
 993         sType = (MPI_Datatype)sjType;
 994 
 995         ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
 996                              sOff, sCount, sType, sBType);
 997     }
 998 
 999     jint *jRCounts = NULL, *jDispls = NULL;
1000     int  *cRCounts = NULL, *cDispls = NULL;
1001     MPI_Datatype rType = sType;
1002 
1003     if(rootOrInter)
1004     {
1005         ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
1006         ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1007         rType = (MPI_Datatype)rjType;
1008 
1009         if(sPtr == MPI_IN_PLACE)
1010         {
1011             /* We use the receive buffer as the send buffer. */
1012             ompi_java_getReadPtrv(&rPtr, &rItem, env, rBuf, rdb, rOff,
1013                                   cRCounts, cDispls, size, root, rType, rBType);
1014         }
1015         else
1016         {
1017             ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
1018                                    cRCounts, cDispls, size, rType);
1019         }
1020     }
1021 
1022     int rc = MPI_Gatherv(sPtr, sCount, sType, rPtr, cRCounts,
1023                          cDispls, rType, root, comm);
1024 
1025     ompi_java_exceptionCheck(env, rc);
1026 
1027     if(sBuf != NULL)
1028         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1029 
1030     if(rootOrInter)
1031     {
1032         ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
1033                                    cRCounts, cDispls, size, rType, rBType);
1034 
1035         ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
1036         ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1037     }
1038 }
1039 
1040 JNIEXPORT jlong JNICALL Java_mpi_Comm_iGatherv(
1041         JNIEnv *env, jobject jthis, jlong jComm,
1042         jobject sendBuf, jint sCount, jlong sType,
1043         jobject recvBuf, jintArray rCounts,
1044         jintArray displs, jlong rType, jint root)
1045 {
1046     MPI_Comm comm = (MPI_Comm)jComm;
1047     int rank = getRank(env, comm);
1048     int rootOrInter = rank == root || isInter(env, comm);
1049 
1050     MPI_Request request;
1051     void *sPtr, *rPtr = NULL;
1052 
1053     if(sType == 0)
1054     {
1055         assert(sendBuf == NULL);
1056         sType = (jlong)MPI_DATATYPE_NULL;
1057         sPtr  = MPI_IN_PLACE;
1058     }
1059     else
1060     {
1061         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
1062     }
1063 
1064     jint *jRCounts, *jDispls;
1065     int  *cRCounts, *cDispls;
1066 
1067     if(rootOrInter)
1068     {
1069         ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
1070         ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1071         rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1072     }
1073     else
1074     {
1075         jRCounts = jDispls = NULL;
1076         cRCounts = cDispls = NULL;
1077         rType = sType;
1078     }
1079 
1080     int rc = MPI_Igatherv(sPtr, sCount, (MPI_Datatype)sType, rPtr,
1081                           cRCounts, cDispls, (MPI_Datatype)rType,
1082                           root, comm, &request);
1083 
1084     ompi_java_exceptionCheck(env, rc);
1085 
1086     if(rootOrInter)
1087     {
1088         ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
1089         ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1090     }
1091 
1092     return (jlong)request;
1093 }
1094 
1095 JNIEXPORT void JNICALL Java_mpi_Comm_scatter(
1096         JNIEnv *env, jobject jthis, jlong jComm,
1097         jobject sBuf, jboolean sdb, jint sOff, jint sCount,
1098         jlong sjType, jint sBType,
1099         jobject rBuf, jboolean rdb, jint rOff, jint rCount,
1100         jlong rjType, jint rBType, jint root)
1101 {
1102     MPI_Comm comm = (MPI_Comm)jComm;
1103     int rank  = getRank(env, comm);
1104     int inter = isInter(env, comm);
1105     int rootOrInter = rank == root || inter;
1106 
1107     void *sPtr = NULL, *rPtr;
1108     ompi_java_buffer_t *sItem, *rItem = NULL;
1109     MPI_Datatype rType;
1110 
1111     if(rjType == 0)
1112     {
1113         assert(rBuf == NULL);
1114         rType = MPI_DATATYPE_NULL;
1115         rPtr  = MPI_IN_PLACE;
1116     }
1117     else
1118     {
1119         rType = (MPI_Datatype)rjType;
1120         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
1121     }
1122 
1123     MPI_Datatype sType = (MPI_Datatype)sjType;
1124     int sCountTotal = rootOrInter ? sCount * getSize(env, comm, inter) : sCount;
1125 
1126     if(rootOrInter || rPtr == MPI_IN_PLACE)
1127     {
1128         ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb, sOff,
1129                              sCountTotal, sType, sBType);
1130         if(!rootOrInter)
1131         {
1132             /* The send buffer is ignored for all non-root processes.
1133              * As we are using MPI_IN_PLACE version, we use the send
1134              * buffer as the receive buffer.
1135              */
1136             assert(rBuf == NULL);
1137             rPtr   = sPtr;
1138             rCount = sCount;
1139             rType  = sType;
1140         }
1141     }
1142 
1143     int rc = MPI_Scatter(sPtr, sCount, sType, rPtr, rCount, rType, root, comm);
1144     ompi_java_exceptionCheck(env, rc);
1145 
1146     if(rootOrInter)
1147     {
1148         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1149     }
1150     else if(rBuf == NULL)
1151     {
1152         ompi_java_releaseWritePtr(sPtr, sItem, env, sBuf, sdb,
1153                                   sOff, sCount, sType, sBType);
1154     }
1155 
1156     if(rItem != NULL && rBuf != NULL)
1157     {
1158         ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
1159                                   rOff, rCount, rType, rBType);
1160     }
1161 }
1162 
1163 JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatter(
1164         JNIEnv *env, jobject jthis, jlong jComm,
1165         jobject sendBuf, jint sCount, jlong sType,
1166         jobject recvBuf, jint rCount, jlong rType, jint root)
1167 {
1168     MPI_Comm comm = (MPI_Comm)jComm;
1169     int rank = getRank(env, comm);
1170     int rootOrInter = rank == root || isInter(env, comm);
1171 
1172     void *sPtr = NULL, *rPtr;
1173     MPI_Request request;
1174 
1175     if(rType == 0)
1176     {
1177         assert(recvBuf == NULL);
1178         rType = (jlong)MPI_DATATYPE_NULL;
1179         rPtr  = MPI_IN_PLACE;
1180     }
1181     else
1182     {
1183         rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1184     }
1185 
1186     if(rootOrInter || rPtr == MPI_IN_PLACE)
1187     {
1188         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
1189 
1190         if(!rootOrInter)
1191         {
1192             /* The send buffer is ignored for all non-root processes.
1193              * As we are using MPI_IN_PLACE version, we use the send
1194              * buffer as the receive buffer.
1195              */
1196             assert(recvBuf == NULL);
1197             rPtr   = sPtr;
1198             rCount = sCount;
1199             rType  = sType;
1200         }
1201     }
1202 
1203     int rc = MPI_Iscatter(sPtr, sCount, (MPI_Datatype)sType,
1204                           rPtr, rCount, (MPI_Datatype)rType,
1205                           root, comm, &request);
1206 
1207     ompi_java_exceptionCheck(env, rc);
1208     return (jlong)request;
1209 }
1210 
1211 JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
1212         JNIEnv *env, jobject jthis, jlong jComm,
1213         jobject sBuf, jboolean sdb, jint sOff, jintArray sCounts,
1214         jintArray displs, jlong sjType, jint sBType,
1215         jobject rBuf, jboolean rdb, jint rOff, jint rCount,
1216         jlong rjType, jint rBType, jint root)
1217 {
1218     MPI_Comm comm = (MPI_Comm)jComm;
1219     int rank  = getRank(env, comm);
1220     int inter = isInter(env, comm);
1221     int rootOrInter = rank == root || inter;
1222     int size = rootOrInter ? getSize(env, comm, inter) : 0;
1223 
1224     void *sPtr = NULL, *rPtr;
1225     ompi_java_buffer_t *sItem, *rItem = NULL;
1226     MPI_Datatype rType;
1227 
1228     if(rjType == 0)
1229     {
1230         assert(rBuf == NULL);
1231         rType = MPI_DATATYPE_NULL;
1232         rPtr  = MPI_IN_PLACE;
1233     }
1234     else
1235     {
1236         rType = (MPI_Datatype)rjType;
1237         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
1238     }
1239 
1240     jint *jSCounts = NULL, *jDispls = NULL;
1241     int  *cSCounts = NULL, *cDispls = NULL;
1242     MPI_Datatype sType = rType;
1243 
1244     if(rootOrInter)
1245     {
1246         ompi_java_getIntArray(env, sCounts, &jSCounts, &cSCounts);
1247         ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1248         sType = (MPI_Datatype)sjType;
1249 
1250         ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
1251                               cSCounts, cDispls, size, -1, sType, sBType);
1252     }
1253 
1254     int rc = MPI_Scatterv(sPtr, cSCounts, cDispls, sType,
1255                           rPtr, rCount, rType, root, comm);
1256 
1257     ompi_java_exceptionCheck(env, rc);
1258 
1259     if(rItem != NULL && rBuf != NULL)
1260     {
1261         ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
1262                                   rOff, rCount, rType, rBType);
1263     }
1264 
1265     if(rootOrInter)
1266     {
1267         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1268         ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts);
1269         ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1270     }
1271 }
1272 
1273 JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatterv(
1274         JNIEnv *env, jobject jthis, jlong jComm,
1275         jobject sendBuf, jintArray sCounts, jintArray displs, jlong sType,
1276         jobject recvBuf, jint rCount, jlong rType, jint root)
1277 {
1278     MPI_Comm comm = (MPI_Comm)jComm;
1279     int rank = getRank(env, comm);
1280     int rootOrInter = rank == root || isInter(env, comm);
1281 
1282     MPI_Request request;
1283     void *sPtr = NULL, *rPtr;
1284 
1285     if(rType == 0)
1286     {
1287         assert(recvBuf == NULL);
1288         rType = (jlong)MPI_DATATYPE_NULL;
1289         rPtr  = MPI_IN_PLACE;
1290     }
1291     else
1292     {
1293         rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1294     }
1295 
1296     jint *jSCounts, *jDispls;
1297     int  *cSCounts, *cDispls;
1298 
1299     if(rootOrInter)
1300     {
1301         ompi_java_getIntArray(env, sCounts, &jSCounts, &cSCounts);
1302         ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1303         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
1304     }
1305     else
1306     {
1307         jSCounts = jDispls = NULL;
1308         cSCounts = cDispls = NULL;
1309         sType = rType;
1310     }
1311 
1312     int rc = MPI_Iscatterv(sPtr, cSCounts, cDispls, (MPI_Datatype)sType,
1313                            rPtr, rCount, (MPI_Datatype)rType, root,
1314                            comm, &request);
1315 
1316     ompi_java_exceptionCheck(env, rc);
1317 
1318     if(rootOrInter)
1319     {
1320         ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts);
1321         ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1322     }
1323 
1324     return (jlong)request;
1325 }
1326 
1327 JNIEXPORT void JNICALL Java_mpi_Comm_allGather(
1328         JNIEnv *env, jobject jthis, jlong jComm,
1329         jobject sBuf, jboolean sdb, jint sOff,
1330         jint sCount, jlong sjType, jint sBType,
1331         jobject rBuf, jboolean rdb, jint rOff,
1332         jint rCount, jlong rjType, jint rBType)
1333 {
1334     MPI_Comm     comm  = (MPI_Comm)jComm;
1335     MPI_Datatype sType,
1336                  rType = (MPI_Datatype)rjType;
1337 
1338     int inter  = isInter(env, comm),
1339         size   = getSize(env, comm, inter),
1340         rTotal = rCount * size;
1341 
1342     void *sPtr, *rPtr;
1343     ompi_java_buffer_t *sItem, *rItem;
1344 
1345     if(sjType == 0)
1346     {
1347         assert(sBuf == NULL);
1348         sType = MPI_DATATYPE_NULL;
1349         sPtr  = MPI_IN_PLACE;
1350         int rank = getRank(env, comm);
1351 
1352         ompi_java_getReadPtrRank(&rPtr, &rItem, env, rBuf, rdb, rOff,
1353                                  rCount, size, rank, rType, rBType);
1354     }
1355     else
1356     {
1357         sType = (MPI_Datatype)sjType;
1358 
1359         ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
1360                              sOff, sCount, sType, sBType);
1361 
1362         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
1363     }
1364 
1365     int rc = MPI_Allgather(sPtr, sCount, sType, rPtr, rCount, rType, comm);
1366     ompi_java_exceptionCheck(env, rc);
1367 
1368     ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
1369                               rOff, rTotal, rType, rBType);
1370     if(sBuf != NULL)
1371         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1372 }
1373 
1374 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGather(
1375         JNIEnv *env, jobject jthis, jlong comm,
1376         jobject sendBuf, jint sCount, jlong sType,
1377         jobject recvBuf, jint rCount, jlong rType)
1378 {
1379     void *sPtr, *rPtr;
1380     MPI_Request request;
1381 
1382     if(sType == 0)
1383     {
1384         assert(sendBuf == NULL);
1385         sType = (jlong)MPI_DATATYPE_NULL;
1386         sPtr  = MPI_IN_PLACE;
1387     }
1388     else
1389     {
1390         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
1391     }
1392 
1393     rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1394 
1395     int rc = MPI_Iallgather(sPtr, sCount, (MPI_Datatype)sType,
1396                             rPtr, rCount, (MPI_Datatype)rType,
1397                             (MPI_Comm)comm, &request);
1398 
1399     ompi_java_exceptionCheck(env, rc);
1400     return (jlong)request;
1401 }
1402 
1403 JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv(
1404         JNIEnv *env, jobject jthis, jlong jComm,
1405         jobject sBuf, jboolean sdb, jint sOff,
1406         jint sCount, jlong sjType, jint sBType,
1407         jobject rBuf, jboolean rdb, jint rOff,
1408         jintArray rCounts, jintArray displs, jlong rjType, jint rBType)
1409 {
1410     MPI_Comm comm = (MPI_Comm)jComm;
1411     int inter = isInter(env, comm),
1412         size  = getSize(env, comm, inter);
1413 
1414     MPI_Datatype sType,
1415                  rType = (MPI_Datatype)rjType;
1416 
1417     void *sPtr, *rPtr;
1418     ompi_java_buffer_t *sItem, *rItem;
1419     jint *jRCounts, *jDispls;
1420     int  *cRCounts, *cDispls;
1421     ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
1422     ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1423 
1424     if(sjType == 0)
1425     {
1426         assert(sBuf == NULL);
1427         sType = MPI_DATATYPE_NULL;
1428         sPtr  = MPI_IN_PLACE;
1429         int rank = getRank(env, comm);
1430 
1431         ompi_java_getReadPtrv(&rPtr, &rItem, env, rBuf, rdb, rOff,
1432                               cRCounts, cDispls, size, rank, rType, rBType);
1433     }
1434     else
1435     {
1436         sType = (MPI_Datatype)sjType;
1437 
1438         ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
1439                              sOff, sCount, sType, sBType);
1440 
1441         ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
1442                                cRCounts, cDispls, size, rType);
1443     }
1444 
1445     int rc = MPI_Allgatherv(sPtr, sCount, sType, rPtr,
1446                             cRCounts, cDispls, rType, comm);
1447 
1448     ompi_java_exceptionCheck(env, rc);
1449 
1450     ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
1451                                cRCounts, cDispls, size, rType, rBType);
1452     if(sBuf != NULL)
1453         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1454 
1455     ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
1456     ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1457 }
1458 
1459 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGatherv(
1460         JNIEnv *env, jobject jthis, jlong comm,
1461         jobject sendBuf, jint sCount, jlong sType,
1462         jobject recvBuf, jintArray rCounts, jintArray displs, jlong rType)
1463 {
1464     MPI_Request request;
1465     void *sPtr, *rPtr;
1466 
1467     if(sType == 0)
1468     {
1469         assert(sendBuf == NULL);
1470         sType = (jlong)MPI_DATATYPE_NULL;
1471         sPtr  = MPI_IN_PLACE;
1472     }
1473     else
1474     {
1475         sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
1476     }
1477 
1478     jint *jRCounts, *jDispls;
1479     int  *cRCounts, *cDispls;
1480     ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
1481     ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1482 
1483     rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1484 
1485     int rc = MPI_Iallgatherv(sPtr, sCount, (MPI_Datatype)sType,
1486                              rPtr, cRCounts, cDispls, (MPI_Datatype)rType,
1487                              (MPI_Comm)comm, &request);
1488 
1489     ompi_java_exceptionCheck(env, rc);
1490     ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
1491     ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1492     return (jlong)request;
1493 }
1494 
1495 JNIEXPORT void JNICALL Java_mpi_Comm_allToAll(
1496         JNIEnv *env, jobject jthis, jlong jComm,
1497         jobject sBuf, jboolean sdb, jint sOff,
1498         jint sCount, jlong sjType, jint sBType,
1499         jobject rBuf, jboolean rdb, jint rOff,
1500         jint rCount, jlong rjType, jint rBType)
1501 {
1502     MPI_Comm     comm  = (MPI_Comm)jComm;
1503     MPI_Datatype sType = (MPI_Datatype)sjType;
1504     MPI_Datatype rType = (MPI_Datatype)rjType;
1505 
1506     int inter  = isInter(env, comm),
1507         size   = getSize(env, comm, inter),
1508         sTotal = sCount * size,
1509         rTotal = rCount * size;
1510 
1511     void *sPtr, *rPtr;
1512     ompi_java_buffer_t *sItem, *rItem;
1513     ompi_java_getReadPtr(&sPtr, &sItem, env,sBuf,sdb,sOff,sTotal,sType,sBType);
1514     ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
1515 
1516     int rc = MPI_Alltoall(sPtr, sCount, sType, rPtr, rCount, rType, comm);
1517     ompi_java_exceptionCheck(env, rc);
1518 
1519     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1520     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
1521 }
1522 
1523 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAll(
1524         JNIEnv *env, jobject jthis, jlong comm,
1525         jobject sendBuf, jint sCount, jlong sType,
1526         jobject recvBuf, jint rCount, jlong rType)
1527 {
1528     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1529          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1530 
1531     MPI_Request request;
1532 
1533     int rc = MPI_Ialltoall(sPtr, sCount, (MPI_Datatype)sType,
1534                            rPtr, rCount, (MPI_Datatype)rType,
1535                            (MPI_Comm)comm, &request);
1536 
1537     ompi_java_exceptionCheck(env, rc);
1538     return (jlong)request;
1539 }
1540 
1541 JNIEXPORT void JNICALL Java_mpi_Comm_allToAllv(
1542         JNIEnv *env, jobject jthis, jlong jComm,
1543         jobject sBuf, jboolean sdb, jint sOff, jintArray sCount,
1544         jintArray sDispl, jlong sjType, jint sBType,
1545         jobject rBuf, jboolean rdb, jint rOff, jintArray rCount,
1546         jintArray rDispl, jlong rjType, jint rBType)
1547 {
1548     MPI_Comm     comm  = (MPI_Comm)jComm;
1549     MPI_Datatype sType = (MPI_Datatype)sjType;
1550     MPI_Datatype rType = (MPI_Datatype)rjType;
1551 
1552     int inter = isInter(env, comm),
1553         size  = getSize(env, comm, inter);
1554 
1555     jint *jSCount, *jRCount, *jSDispl, *jRDispl;
1556     int  *cSCount, *cRCount, *cSDispl, *cRDispl;
1557     ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
1558     ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
1559     ompi_java_getIntArray(env, sDispl, &jSDispl, &cSDispl);
1560     ompi_java_getIntArray(env, rDispl, &jRDispl, &cRDispl);
1561 
1562     void *sPtr, *rPtr;
1563     ompi_java_buffer_t *sItem, *rItem;
1564 
1565     ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
1566                           cSCount, cSDispl, size, -1, sType, sBType);
1567     ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
1568                            cRCount, cRDispl, size, rType);
1569 
1570     int rc = MPI_Alltoallv(sPtr, cSCount, cSDispl, sType,
1571                            rPtr, cRCount, cRDispl, rType, comm);
1572 
1573     ompi_java_exceptionCheck(env, rc);
1574     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1575 
1576     ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
1577                                cRCount, cRDispl, size, rType, rBType);
1578 
1579     ompi_java_forgetIntArray(env, sCount, jSCount, cSCount);
1580     ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
1581     ompi_java_forgetIntArray(env, sDispl, jSDispl, cSDispl);
1582     ompi_java_forgetIntArray(env, rDispl, jRDispl, cRDispl);
1583 }
1584 
1585 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAllv(
1586         JNIEnv *env, jobject jthis, jlong comm,
1587         jobject sendBuf, jintArray sCount, jintArray sDispls, jlong sType,
1588         jobject recvBuf, jintArray rCount, jintArray rDispls, jlong rType)
1589 {
1590     jint *jSCount, *jRCount, *jSDispls, *jRDispls;
1591     int  *cSCount, *cRCount, *cSDispls, *cRDispls;
1592     ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
1593     ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
1594     ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
1595     ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
1596 
1597     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1598          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1599 
1600     MPI_Request request;
1601 
1602     int rc = MPI_Ialltoallv(sPtr, cSCount, cSDispls, (MPI_Datatype)sType,
1603                             rPtr, cRCount, cRDispls, (MPI_Datatype)rType,
1604                             (MPI_Comm)comm, &request);
1605 
1606     ompi_java_exceptionCheck(env, rc);
1607     ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
1608     ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
1609     ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
1610     ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
1611     return (jlong)request;
1612 }
1613 
1614 JNIEXPORT void JNICALL Java_mpi_Comm_allToAllw(
1615                 JNIEnv *env, jobject jthis, jlong jComm,
1616                 jobject sendBuf, jintArray sCount, jintArray sDispls, jlongArray sTypes,
1617                 jobject recvBuf, jintArray rCount, jintArray rDispls, jlongArray rTypes)
1618 {
1619         MPI_Comm     comm  = (MPI_Comm)jComm;
1620 
1621         jlong* jSTypes, *jRTypes;
1622         MPI_Datatype *cSTypes, *cRTypes;
1623 
1624         ompi_java_getDatatypeArray(env, sTypes, &jSTypes, &cSTypes);
1625         ompi_java_getDatatypeArray(env, rTypes, &jRTypes, &cRTypes);
1626 
1627         jint *jSCount, *jRCount, *jSDispls, *jRDispls;
1628         int  *cSCount, *cRCount, *cSDispls, *cRDispls;
1629         ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
1630         ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
1631         ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
1632         ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
1633 
1634         void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1635              *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1636 
1637         int rc = MPI_Alltoallw(
1638                         sPtr, cSCount, cSDispls, cSTypes,
1639                         rPtr, cRCount, cRDispls, cRTypes, comm);
1640 
1641         ompi_java_exceptionCheck(env, rc);
1642         ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
1643         ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
1644         ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
1645         ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
1646         ompi_java_forgetDatatypeArray(env, sTypes, jSTypes, cSTypes);
1647         ompi_java_forgetDatatypeArray(env, rTypes, jRTypes, cRTypes);
1648 }
1649 
1650 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAllw(
1651                 JNIEnv *env, jobject jthis, jlong jComm,
1652                                 jobject sendBuf, jintArray sCount, jintArray sDispls, jlongArray sTypes,
1653                                 jobject recvBuf, jintArray rCount, jintArray rDispls, jlongArray rTypes)
1654 {
1655         MPI_Comm     comm  = (MPI_Comm)jComm;
1656 
1657         jlong* jSTypes, *jRTypes;
1658         MPI_Datatype *cSTypes, *cRTypes;
1659 
1660         ompi_java_getDatatypeArray(env, sTypes, &jSTypes, &cSTypes);
1661         ompi_java_getDatatypeArray(env, rTypes, &jRTypes, &cRTypes);
1662 
1663         jint *jSCount, *jRCount, *jSDispls, *jRDispls;
1664         int  *cSCount, *cRCount, *cSDispls, *cRDispls;
1665         ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
1666         ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
1667         ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
1668         ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
1669 
1670         void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1671              *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1672 
1673         MPI_Request request;
1674 
1675         int rc = MPI_Ialltoallw(
1676                         sPtr, cSCount, cSDispls, cSTypes,
1677                         rPtr, cRCount, cRDispls, cRTypes, comm, &request);
1678 
1679         ompi_java_exceptionCheck(env, rc);
1680         ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
1681         ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
1682         ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
1683         ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
1684         ompi_java_forgetDatatypeArray(env, sTypes, jSTypes, cSTypes);
1685         ompi_java_forgetDatatypeArray(env, rTypes, jRTypes, cRTypes);
1686 
1687         return (jlong)request;
1688 }
1689 
1690 JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllGather(
1691         JNIEnv *env, jobject jthis, jlong jComm,
1692         jobject sBuf, jboolean sdb, jint sOff,
1693         jint sCount, jlong sjType, jint sBType,
1694         jobject rBuf, jboolean rdb, jint rOff,
1695         jint rCount, jlong rjType, jint rBType)
1696 {
1697     MPI_Comm     comm  = (MPI_Comm)jComm;
1698     MPI_Datatype sType = (MPI_Datatype)sjType;
1699     MPI_Datatype rType = (MPI_Datatype)rjType;
1700 
1701     int sSize, rSize;
1702     getNeighbors(env, comm, &sSize, &rSize);
1703     int rTotal = rCount * rSize;
1704 
1705     void *sPtr, *rPtr;
1706     ompi_java_buffer_t *sItem, *rItem;
1707     ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,sCount,sType,sBType);
1708     ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
1709 
1710     int rc = MPI_Neighbor_allgather(
1711              sPtr, sCount, sType, rPtr, rCount, rType, comm);
1712 
1713     ompi_java_exceptionCheck(env, rc);
1714     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1715     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
1716 }
1717 
1718 JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllGather(
1719         JNIEnv *env, jobject jthis, jlong jComm,
1720         jobject sendBuf, jint sCount, jlong sjType,
1721         jobject recvBuf, jint rCount, jlong rjType)
1722 {
1723     MPI_Comm     comm  = (MPI_Comm)jComm;
1724     MPI_Datatype sType = (MPI_Datatype)sjType;
1725     MPI_Datatype rType = (MPI_Datatype)rjType;
1726 
1727     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1728          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1729 
1730     MPI_Request request;
1731 
1732     int rc = MPI_Ineighbor_allgather(
1733              sPtr, sCount, sType, rPtr, rCount, rType, comm, &request);
1734 
1735     ompi_java_exceptionCheck(env, rc);
1736     return (jlong)request;
1737 }
1738 
1739 JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllGatherv(
1740         JNIEnv *env, jobject jthis, jlong jComm,
1741         jobject sBuf, jboolean sdb, jint sOff,
1742         jint sCount, jlong sjType, jint sBType,
1743         jobject rBuf, jboolean rdb, jint rOff,
1744         jintArray rCount, jintArray displs, jlong rjType, jint rBType)
1745 {
1746     MPI_Comm     comm  = (MPI_Comm)jComm;
1747     MPI_Datatype sType = (MPI_Datatype)sjType;
1748     MPI_Datatype rType = (MPI_Datatype)rjType;
1749 
1750     int sSize, rSize;
1751     getNeighbors(env, comm, &sSize, &rSize);
1752 
1753     jint *jRCount, *jDispls;
1754     int  *cRCount, *cDispls;
1755     ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
1756     ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1757 
1758     void *sPtr, *rPtr;
1759     ompi_java_buffer_t *sItem, *rItem;
1760     ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,sCount,sType,sBType);
1761 
1762     ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
1763                            cRCount, cDispls, rSize, rType);
1764 
1765     int rc = MPI_Neighbor_allgatherv(
1766              sPtr, sCount, sType, rPtr, cRCount, cDispls, rType, comm);
1767 
1768     ompi_java_exceptionCheck(env, rc);
1769     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1770 
1771     ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
1772                                cRCount, cDispls, rSize, rType, rBType);
1773 
1774     ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
1775     ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1776 }
1777 
1778 JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllGatherv(
1779         JNIEnv *env, jobject jthis, jlong jComm,
1780         jobject sendBuf, jint sCount, jlong sjType,
1781         jobject recvBuf, jintArray rCount, jintArray displs, jlong rjType)
1782 {
1783     MPI_Comm     comm  = (MPI_Comm)jComm;
1784     MPI_Datatype sType = (MPI_Datatype)sjType;
1785     MPI_Datatype rType = (MPI_Datatype)rjType;
1786 
1787     jint *jRCount, *jDispls;
1788     int  *cRCount, *cDispls;
1789     ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
1790     ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
1791 
1792     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1793          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1794 
1795     MPI_Request request;
1796 
1797     int rc = MPI_Ineighbor_allgatherv(sPtr, sCount, sType, rPtr, cRCount,
1798                                       cDispls, rType, comm, &request);
1799 
1800     ompi_java_exceptionCheck(env, rc);
1801     ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
1802     ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
1803     return (jlong)request;
1804 }
1805 
1806 JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllToAll(
1807         JNIEnv *env, jobject jthis, jlong jComm,
1808         jobject sBuf, jboolean sdb, jint sOff,
1809         jint sCount, jlong sjType, jint sBType,
1810         jobject rBuf, jboolean rdb, jint rOff,
1811         jint rCount, jlong rjType, jint rBType)
1812 {
1813     MPI_Comm     comm  = (MPI_Comm)jComm;
1814     MPI_Datatype sType = (MPI_Datatype)sjType;
1815     MPI_Datatype rType = (MPI_Datatype)rjType;
1816 
1817     int sSize, rSize;
1818     getNeighbors(env, comm, &sSize, &rSize);
1819     int sTotal = sCount * sSize;
1820     int rTotal = rCount * rSize;
1821 
1822     void *sPtr, *rPtr;
1823     ompi_java_buffer_t *sItem, *rItem;
1824     ompi_java_getReadPtr(&sPtr, &sItem, env,sBuf,sdb,sOff,sTotal,sType,sBType);
1825     ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
1826 
1827     int rc = MPI_Neighbor_alltoall(
1828              sPtr, sCount, sType, rPtr, rCount, rType, comm);
1829 
1830     ompi_java_exceptionCheck(env, rc);
1831     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1832     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
1833 }
1834 
1835 JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllToAll(
1836         JNIEnv *env, jobject jthis, jlong jComm,
1837         jobject sendBuf, jint sCount, jlong sjType,
1838         jobject recvBuf, jint rCount, jlong rjType)
1839 {
1840     MPI_Comm     comm  = (MPI_Comm)jComm;
1841     MPI_Datatype sType = (MPI_Datatype)sjType;
1842     MPI_Datatype rType = (MPI_Datatype)rjType;
1843 
1844     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1845          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1846 
1847     MPI_Request request;
1848 
1849     int rc = MPI_Ineighbor_alltoall(
1850              sPtr, sCount, sType, rPtr, rCount, rType, comm, &request);
1851 
1852     ompi_java_exceptionCheck(env, rc);
1853     return (jlong)request;
1854 }
1855 
1856 JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllToAllv(
1857         JNIEnv *env, jobject jthis, jlong jComm,
1858         jobject sBuf, jboolean sdb, jint sOff,
1859         jintArray sCount, jintArray sDispl, jlong sjType, jint sBType,
1860         jobject rBuf, jboolean rdb, jint rOff,
1861         jintArray rCount, jintArray rDispl, jlong rjType, jint rBType)
1862 {
1863     MPI_Comm     comm  = (MPI_Comm)jComm;
1864     MPI_Datatype sType = (MPI_Datatype)sjType;
1865     MPI_Datatype rType = (MPI_Datatype)rjType;
1866 
1867     int sSize, rSize;
1868     getNeighbors(env, comm, &sSize, &rSize);
1869 
1870     jint *jSCount, *jRCount, *jSDispl, *jRDispl;
1871     int  *cSCount, *cRCount, *cSDispl, *cRDispl;
1872     ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
1873     ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
1874     ompi_java_getIntArray(env, sDispl, &jSDispl, &cSDispl);
1875     ompi_java_getIntArray(env, rDispl, &jRDispl, &cRDispl);
1876 
1877     void *sPtr, *rPtr;
1878     ompi_java_buffer_t *sItem, *rItem;
1879 
1880     ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
1881                           cSCount, cSDispl, sSize, -1, sType, sBType);
1882     ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
1883                            cRCount, cRDispl, rSize, rType);
1884 
1885     int rc = MPI_Neighbor_alltoallv(sPtr, cSCount, cSDispl, sType,
1886                                     rPtr, cRCount, cRDispl, rType, comm);
1887 
1888     ompi_java_exceptionCheck(env, rc);
1889     ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1890 
1891     ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
1892                                cRCount, cRDispl, rSize, rType, rBType);
1893 
1894     ompi_java_forgetIntArray(env, sCount, jSCount, cSCount);
1895     ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
1896     ompi_java_forgetIntArray(env, sDispl, jSDispl, cSDispl);
1897     ompi_java_forgetIntArray(env, rDispl, jRDispl, cRDispl);
1898 }
1899 
1900 JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllToAllv(
1901         JNIEnv *env, jobject jthis, jlong jComm,
1902         jobject sendBuf, jintArray sCount, jintArray sDispls, jlong sjType,
1903         jobject recvBuf, jintArray rCount, jintArray rDispls, jlong rjType)
1904 {
1905     MPI_Comm     comm  = (MPI_Comm)jComm;
1906     MPI_Datatype sType = (MPI_Datatype)sjType;
1907     MPI_Datatype rType = (MPI_Datatype)rjType;
1908 
1909     jint *jSCount, *jRCount, *jSDispls, *jRDispls;
1910     int  *cSCount, *cRCount, *cSDispls, *cRDispls;
1911     ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
1912     ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
1913     ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
1914     ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
1915 
1916     void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
1917          *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
1918 
1919     MPI_Request request;
1920 
1921     int rc = MPI_Ineighbor_alltoallv(
1922              sPtr, cSCount, cSDispls, sType,
1923              rPtr, cRCount, cRDispls, rType, comm, &request);
1924 
1925     ompi_java_exceptionCheck(env, rc);
1926     ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
1927     ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
1928     ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
1929     ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
1930     return (jlong)request;
1931 }
1932 
1933 JNIEXPORT void JNICALL Java_mpi_Comm_reduce(
1934         JNIEnv *env, jobject jthis, jlong jComm,
1935         jobject sBuf, jboolean sdb, jint sOff,
1936         jobject rBuf, jboolean rdb, jint rOff, jint count,
1937         jlong jType, jint bType, jobject jOp, jlong hOp, jint root)
1938 {
1939     MPI_Comm     comm = (MPI_Comm)jComm;
1940     MPI_Datatype type = (MPI_Datatype)jType;
1941 
1942     int rank = getRank(env, comm);
1943     int rootOrInter = rank == root || isInter(env, comm);
1944 
1945     void *sPtr, *rPtr = NULL;
1946     ompi_java_buffer_t *sItem, *rItem;
1947 
1948     if(sBuf == NULL)
1949     {
1950         ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
1951         sPtr = rootOrInter ? MPI_IN_PLACE : rPtr;
1952         /* The receive buffer is ignored for all non-root processes.
1953          * On MPI_IN_PLACE version we use receive buffer as the send buffer.
1954          */
1955     }
1956     else
1957     {
1958         ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
1959 
1960         if(rootOrInter)
1961             ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
1962     }
1963 
1964     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
1965     int rc = MPI_Reduce(sPtr, rPtr, count, type, op, root, comm);
1966     ompi_java_exceptionCheck(env, rc);
1967 
1968     if(sBuf != NULL)
1969         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
1970 
1971     if(rootOrInter)
1972         ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
1973     else if(sBuf == NULL)
1974         ompi_java_releaseReadPtr(rPtr, rItem, rBuf, rdb);
1975 }
1976 
1977 JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduce(
1978         JNIEnv *env, jobject jthis, jlong jComm,
1979         jobject sendBuf, jobject recvBuf, int count,
1980         jlong type, jint baseType, jobject jOp, jlong hOp, jint root)
1981 {
1982     MPI_Comm comm = (MPI_Comm)jComm;
1983     int rank = getRank(env, comm);
1984     int rootOrInter = rank == root || isInter(env, comm);
1985 
1986     void *sPtr, *rPtr = NULL;
1987     MPI_Request request;
1988 
1989     if(sendBuf == NULL)
1990         sPtr = MPI_IN_PLACE;
1991     else
1992         sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
1993 
1994     if(rootOrInter || sendBuf == NULL)
1995     {
1996         rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
1997 
1998         if(!rootOrInter)
1999         {
2000             /* The receive buffer is ignored for all non-root processes.
2001              * As we are using MPI_IN_PLACE version, we use the receive
2002              * buffer as the send buffer.
2003              */
2004             assert(sendBuf == NULL);
2005             sPtr = rPtr;
2006         }
2007     }
2008 
2009     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
2010 
2011     int rc = MPI_Ireduce(sPtr, rPtr, count, (MPI_Datatype)type,
2012                          op, root, comm, &request);
2013 
2014     ompi_java_exceptionCheck(env, rc);
2015     return (jlong)request;
2016 }
2017 
2018 JNIEXPORT void JNICALL Java_mpi_Comm_allReduce(
2019         JNIEnv *env, jobject jthis, jlong jComm,
2020         jobject sBuf, jboolean sdb, jint sOff,
2021         jobject rBuf, jboolean rdb, jint rOff,
2022         jint count, jlong jType, jint bType, jobject jOp, jlong hOp)
2023 {
2024     MPI_Comm     comm = (MPI_Comm)jComm;
2025     MPI_Datatype type = (MPI_Datatype)jType;
2026 
2027     void *sPtr, *rPtr;
2028     ompi_java_buffer_t *sItem, *rItem;
2029 
2030     if(sBuf == NULL)
2031     {
2032         sPtr = MPI_IN_PLACE;
2033         ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
2034     }
2035     else
2036     {
2037         ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
2038         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
2039     }
2040 
2041     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2042     int rc = MPI_Allreduce(sPtr, rPtr, count, type, op, comm);
2043     ompi_java_exceptionCheck(env, rc);
2044 
2045     if(sBuf != NULL)
2046         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
2047 
2048     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
2049 }
2050 
2051 JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllReduce(
2052         JNIEnv *env, jobject jthis, jlong comm,
2053         jobject sendBuf, jobject recvBuf, jint count,
2054         jlong type, jint baseType, jobject jOp, jlong hOp)
2055 {
2056     MPI_Request request;
2057     void *sPtr, *rPtr;
2058 
2059     if(sendBuf == NULL)
2060         sPtr = MPI_IN_PLACE;
2061     else
2062         sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
2063 
2064     rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
2065     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
2066 
2067     int rc = MPI_Iallreduce(sPtr, rPtr, count, (MPI_Datatype)type,
2068                             op, (MPI_Comm)comm, &request);
2069 
2070     ompi_java_exceptionCheck(env, rc);
2071     return (jlong)request;
2072 }
2073 
2074 JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter(
2075         JNIEnv *env, jobject jthis, jlong jComm,
2076         jobject sBuf, jboolean sdb, jint sOff,
2077         jobject rBuf, jboolean rdb, jint rOff,
2078         jintArray rCounts, jlong jType, jint bType, jobject jOp, jlong hOp)
2079 {
2080     MPI_Comm     comm = (MPI_Comm)jComm;
2081     MPI_Datatype type = (MPI_Datatype)jType;
2082 
2083     jint *jRCounts;
2084     int  *cRCounts;
2085     ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
2086 
2087     int size  = getGroupSize(env, comm),
2088         count = getSum(cRCounts, size),
2089         rbCnt; /* Receive buffer count */
2090 
2091     void *sPtr, *rPtr;
2092     ompi_java_buffer_t *sItem, *rItem;
2093 
2094     if(sBuf == NULL)
2095     {
2096         sPtr  = MPI_IN_PLACE;
2097         rbCnt = count;
2098         ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
2099     }
2100     else
2101     {
2102         ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
2103         rbCnt = cRCounts[getRank(env, comm)];
2104         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rbCnt, type);
2105     }
2106 
2107     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2108     int rc = MPI_Reduce_scatter(sPtr, rPtr, cRCounts, type, op, comm);
2109     ompi_java_exceptionCheck(env, rc);
2110 
2111     if(sBuf != NULL)
2112         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
2113 
2114     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rbCnt,type,bType);
2115     ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
2116 }
2117 
2118 JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatter(
2119         JNIEnv *env, jobject jthis, jlong comm,
2120         jobject sendBuf, jobject recvBuf, jintArray rCounts,
2121         jlong type, int bType, jobject jOp, jlong hOp)
2122 {
2123     void *sPtr, *rPtr;
2124 
2125     if(sendBuf == NULL)
2126         sPtr = MPI_IN_PLACE;
2127     else
2128         sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
2129 
2130     rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
2131     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2132     MPI_Request request;
2133 
2134     jint *jRCounts;
2135     int  *cRCounts;
2136     ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
2137 
2138     int rc = MPI_Ireduce_scatter(sPtr, rPtr, cRCounts, (MPI_Datatype)type,
2139                                  op, (MPI_Comm)comm, &request);
2140 
2141     ompi_java_exceptionCheck(env, rc);
2142     ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
2143     return (jlong)request;
2144 }
2145 
2146 JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatterBlock(
2147         JNIEnv *env, jobject jthis, jlong jComm,
2148         jobject sBuf, jboolean sdb, jint sOff,
2149         jobject rBuf, jboolean rdb, jint rOff,
2150         jint rCount, jlong jType, jint bType, jobject jOp, jlong hOp)
2151 {
2152     MPI_Comm     comm = (MPI_Comm)jComm;
2153     MPI_Datatype type = (MPI_Datatype)jType;
2154 
2155     void *sPtr, *rPtr;
2156     ompi_java_buffer_t *sItem, *rItem;
2157 
2158     int count = rCount * getGroupSize(env, comm),
2159         rbCnt; /* Receive buffer count */
2160 
2161     if(sBuf == NULL)
2162     {
2163         sPtr  = MPI_IN_PLACE;
2164         rbCnt = count;
2165         ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
2166     }
2167     else
2168     {
2169         ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
2170         rbCnt = rCount;
2171         ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rbCnt, type);
2172     }
2173 
2174     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2175     int rc = MPI_Reduce_scatter_block(sPtr, rPtr, rCount, type, op, comm);
2176     ompi_java_exceptionCheck(env, rc);
2177 
2178     if(sBuf != NULL)
2179         ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
2180 
2181     ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rbCnt,type,bType);
2182 }
2183 
2184 JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatterBlock(
2185         JNIEnv *env, jobject jthis, jlong comm, jobject sendBuf,
2186         jobject recvBuf, jint count, jlong type, jint bType,
2187         jobject jOp, jlong hOp)
2188 {
2189     void *sPtr, *rPtr;
2190 
2191     if(sendBuf == NULL)
2192         sPtr = MPI_IN_PLACE;
2193     else
2194         sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
2195 
2196     rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
2197     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2198     MPI_Request request;
2199 
2200     int rc = MPI_Ireduce_scatter_block(sPtr, rPtr, count, (MPI_Datatype)type,
2201                                        op, (MPI_Comm)comm, &request);
2202 
2203     ompi_java_exceptionCheck(env, rc);
2204     return (jlong)request;
2205 }
2206 
2207 JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocal(
2208         JNIEnv *env, jclass clazz, jobject inBuf, jboolean idb, jint inOff,
2209         jobject inOutBuf, jboolean iodb, jint inOutOff, jint count,
2210         jlong jType, jlong op)
2211 {
2212     MPI_Datatype type = (MPI_Datatype)jType;
2213     void *inPtr, *inBase, *inOutPtr, *inOutBase;
2214     inPtr = getBufCritical(&inBase, env, inBuf, idb, inOff);
2215     inOutPtr = getBufCritical(&inOutBase, env, inOutBuf, iodb, inOutOff);
2216     int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type, (MPI_Op)op);
2217     ompi_java_exceptionCheck(env, rc);
2218     releaseBufCritical(env, inBuf, idb, inBase);
2219     releaseBufCritical(env, inOutBuf, iodb, inOutBase);
2220 }
2221 
2222 JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocalUf(
2223         JNIEnv *env, jclass clazz, jobject inBuf, jboolean idb, jint inOff,
2224         jobject inOutBuf, jboolean iodb, jint inOutOff, jint count,
2225         jlong jType, jint bType, jobject jOp, jlong hOp)
2226 {
2227     MPI_Datatype type = (MPI_Datatype)jType;
2228     void *inPtr, *inOutPtr;
2229     ompi_java_buffer_t *inItem, *inOutItem;
2230 
2231     ompi_java_getReadPtr(&inPtr, &inItem, env, inBuf,
2232                          idb, inOff, count, type, bType);
2233     ompi_java_getReadPtr(&inOutPtr, &inOutItem, env, inOutBuf,
2234                          iodb, inOutOff, count, type, bType);
2235 
2236     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
2237     int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type, op);
2238 
2239     ompi_java_exceptionCheck(env, rc);
2240     ompi_java_releaseReadPtr(inPtr, inItem, inBuf, idb);
2241 
2242     ompi_java_releaseWritePtr(inOutPtr, inOutItem, env, inOutBuf,
2243                               iodb, inOutOff, count, type, bType);
2244 }
2245 
2246 JNIEXPORT void JNICALL Java_mpi_Comm_setName(
2247         JNIEnv *env, jobject jthis, jlong handle, jstring jname)
2248 {
2249     const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
2250     int rc = MPI_Comm_set_name((MPI_Comm)handle, (char*)name);
2251     ompi_java_exceptionCheck(env, rc);
2252     (*env)->ReleaseStringUTFChars(env, jname, name);
2253 }
2254 
2255 JNIEXPORT jstring JNICALL Java_mpi_Comm_getName(
2256         JNIEnv *env, jobject jthis, jlong handle)
2257 {
2258     char name[MPI_MAX_OBJECT_NAME];
2259     int len;
2260     int rc = MPI_Comm_get_name((MPI_Comm)handle, name, &len);
2261 
2262     if(ompi_java_exceptionCheck(env, rc))
2263         return NULL;
2264 
2265     return (*env)->NewStringUTF(env, name);
2266 }

/* [<][>][^][v][top][bottom][index][help] */