This source file includes following definitions.
- getBufCritical
- releaseBufCritical
- isInter
- getSize
- getGroupSize
- getRank
- getTopo
- getNeighbors
- getSum
- Java_mpi_Comm_init
- Java_mpi_Comm_getComm
- Java_mpi_Comm_dup
- Java_mpi_Comm_iDup
- Java_mpi_Comm_dupWithInfo
- Java_mpi_Comm_getSize
- Java_mpi_Comm_getRank
- Java_mpi_Comm_compare
- Java_mpi_Comm_free
- Java_mpi_Comm_setInfo
- Java_mpi_Comm_getInfo
- Java_mpi_Comm_disconnect
- Java_mpi_Comm_getGroup
- Java_mpi_Comm_isInter
- Java_mpi_Comm_createIntercomm
- Java_mpi_Comm_send
- Java_mpi_Comm_recv
- Java_mpi_Comm_sendRecv
- Java_mpi_Comm_sendRecvReplace
- Java_mpi_Comm_bSend
- Java_mpi_Comm_sSend
- Java_mpi_Comm_rSend
- Java_mpi_Comm_iSend
- Java_mpi_Comm_ibSend
- Java_mpi_Comm_isSend
- Java_mpi_Comm_irSend
- Java_mpi_Comm_iRecv
- Java_mpi_Comm_sendInit
- Java_mpi_Comm_bSendInit
- Java_mpi_Comm_sSendInit
- Java_mpi_Comm_rSendInit
- Java_mpi_Comm_recvInit
- Java_mpi_Comm_pack
- Java_mpi_Comm_unpack
- Java_mpi_Comm_packSize
- Java_mpi_Comm_iProbe
- Java_mpi_Comm_probe
- Java_mpi_Comm_getTopology
- Java_mpi_Comm_abort
- Java_mpi_Comm_setErrhandler
- Java_mpi_Comm_getErrhandler
- Java_mpi_Comm_callErrhandler
- commCopyAttr
- commDeleteAttr
- Java_mpi_Comm_createKeyval_1jni
- Java_mpi_Comm_freeKeyval_1jni
- Java_mpi_Comm_setAttr
- Java_mpi_Comm_getAttr_1predefined
- Java_mpi_Comm_getAttr
- Java_mpi_Comm_deleteAttr
- Java_mpi_Comm_barrier
- Java_mpi_Comm_iBarrier
- Java_mpi_Comm_bcast
- Java_mpi_Comm_iBcast
- Java_mpi_Comm_gather
- Java_mpi_Comm_iGather
- Java_mpi_Comm_gatherv
- Java_mpi_Comm_iGatherv
- Java_mpi_Comm_scatter
- Java_mpi_Comm_iScatter
- Java_mpi_Comm_scatterv
- Java_mpi_Comm_iScatterv
- Java_mpi_Comm_allGather
- Java_mpi_Comm_iAllGather
- Java_mpi_Comm_allGatherv
- Java_mpi_Comm_iAllGatherv
- Java_mpi_Comm_allToAll
- Java_mpi_Comm_iAllToAll
- Java_mpi_Comm_allToAllv
- Java_mpi_Comm_iAllToAllv
- Java_mpi_Comm_allToAllw
- Java_mpi_Comm_iAllToAllw
- Java_mpi_Comm_neighborAllGather
- Java_mpi_Comm_iNeighborAllGather
- Java_mpi_Comm_neighborAllGatherv
- Java_mpi_Comm_iNeighborAllGatherv
- Java_mpi_Comm_neighborAllToAll
- Java_mpi_Comm_iNeighborAllToAll
- Java_mpi_Comm_neighborAllToAllv
- Java_mpi_Comm_iNeighborAllToAllv
- Java_mpi_Comm_reduce
- Java_mpi_Comm_iReduce
- Java_mpi_Comm_allReduce
- Java_mpi_Comm_iAllReduce
- Java_mpi_Comm_reduceScatter
- Java_mpi_Comm_iReduceScatter
- Java_mpi_Comm_reduceScatterBlock
- Java_mpi_Comm_iReduceScatterBlock
- Java_mpi_Comm_reduceLocal
- Java_mpi_Comm_reduceLocalUf
- Java_mpi_Comm_setName
- Java_mpi_Comm_getName
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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"
61
62 static void* getBufCritical(void** bufBase, JNIEnv *env,
63 jobject buf, jboolean db, int offset)
64 {
65 if(buf == NULL)
66 {
67
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
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
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
883
884
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
937
938
939
940
941
942
943
944
945 rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
946
947 if(!rootOrInter)
948 {
949
950
951
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
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
1133
1134
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
1193
1194
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
1953
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
2001
2002
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;
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;
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 }