This source file includes following definitions.
- Java_mpi_Intracomm_split
- Java_mpi_Intracomm_splitType
- Java_mpi_Intracomm_create
- Java_mpi_Intracomm_createGroup
- Java_mpi_Intracomm_createCart
- Java_mpi_Intracomm_createGraph
- Java_mpi_Intracomm_createDistGraph
- Java_mpi_Intracomm_createDistGraphAdjacent
- Java_mpi_Intracomm_scan
- Java_mpi_Intracomm_iScan
- Java_mpi_Intracomm_exScan
- Java_mpi_Intracomm_iExScan
- Java_mpi_Intracomm_openPort
- Java_mpi_Intracomm_closePort_1jni
- Java_mpi_Intracomm_accept
- Java_mpi_Intracomm_connect
- Java_mpi_Intracomm_publishName
- Java_mpi_Intracomm_unpublishName
- Java_mpi_Intracomm_lookupName
- Java_mpi_Intracomm_spawn
- Java_mpi_Intracomm_spawnMultiple
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 #include "ompi_config.h"
50
51 #include <stdlib.h>
52 #include <string.h>
53 #ifdef HAVE_TARGETCONDITIONALS_H
54 #include <TargetConditionals.h>
55 #endif
56
57 #include "mpi.h"
58 #include "mpi_Comm.h"
59 #include "mpi_Intracomm.h"
60 #include "mpiJava.h"
61
62 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_split(
63 JNIEnv *env, jobject jthis, jlong comm, jint colour, jint key)
64 {
65 MPI_Comm newcomm;
66 int rc = MPI_Comm_split((MPI_Comm)comm, colour, key, &newcomm);
67 ompi_java_exceptionCheck(env, rc);
68 return (jlong)newcomm;
69 }
70
71 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_splitType(
72 JNIEnv *env, jobject jthis, jlong comm, jint splitType, jint key, jlong info)
73 {
74 MPI_Comm newcomm;
75 int rc = MPI_Comm_split_type((MPI_Comm)comm, splitType, key, (MPI_Info)info, &newcomm);
76 ompi_java_exceptionCheck(env, rc);
77 return (jlong)newcomm;
78 }
79
80 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_create(
81 JNIEnv *env, jobject jthis, jlong comm, jlong group)
82 {
83 MPI_Comm newcomm;
84 int rc = MPI_Comm_create((MPI_Comm)comm, (MPI_Group)group, &newcomm);
85 ompi_java_exceptionCheck(env, rc);
86 return (jlong)newcomm;
87 }
88
89 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createGroup(
90 JNIEnv *env, jobject jthis, jlong comm, jlong group, int tag)
91 {
92 MPI_Comm newcomm;
93 int rc = MPI_Comm_create_group((MPI_Comm)comm, (MPI_Group)group, tag, &newcomm);
94 ompi_java_exceptionCheck(env, rc);
95 return (jlong)newcomm;
96 }
97
98 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createCart(
99 JNIEnv *env, jobject jthis, jlong comm,
100 jintArray dims, jbooleanArray periods, jboolean reorder)
101 {
102 jint *jDims;
103 int *cDims;
104 ompi_java_getIntArray(env, dims, &jDims, &cDims);
105
106 jboolean *jPeriods;
107 int *cPeriods;
108 ompi_java_getBooleanArray(env, periods, &jPeriods, &cPeriods);
109
110 int ndims = (*env)->GetArrayLength(env, dims);
111 MPI_Comm cart;
112
113 int rc = MPI_Cart_create((MPI_Comm)comm, ndims, cDims,
114 cPeriods, reorder, &cart);
115
116 ompi_java_exceptionCheck(env, rc);
117 ompi_java_forgetIntArray(env, dims, jDims, cDims);
118 ompi_java_forgetBooleanArray(env, periods, jPeriods, cPeriods);
119 return (jlong)cart;
120 }
121
122 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createGraph(
123 JNIEnv *env, jobject jthis, jlong comm,
124 jintArray index, jintArray edges, jboolean reorder)
125 {
126 MPI_Comm graph;
127 int nnodes = (*env)->GetArrayLength(env, index);
128
129 jint *jIndex, *jEdges;
130 int *cIndex, *cEdges;
131 ompi_java_getIntArray(env, index, &jIndex, &cIndex);
132 ompi_java_getIntArray(env, edges, &jEdges, &cEdges);
133
134 int rc = MPI_Graph_create((MPI_Comm)comm,
135 nnodes, cIndex, cEdges, reorder, &graph);
136
137 ompi_java_exceptionCheck(env, rc);
138 ompi_java_forgetIntArray(env, index, jIndex, cIndex);
139 ompi_java_forgetIntArray(env, edges, jEdges, cEdges);
140 return (jlong)graph;
141 }
142
143 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createDistGraph(
144 JNIEnv *env, jobject jthis, jlong comm, jintArray sources,
145 jintArray degrees, jintArray destins, jintArray weights,
146 jlong info, jboolean reorder, jboolean weighted)
147 {
148 MPI_Comm graph;
149 int nnodes = (*env)->GetArrayLength(env, sources);
150
151 jint *jSources, *jDegrees, *jDestins, *jWeights = NULL;
152 int *cSources, *cDegrees, *cDestins, *cWeights = MPI_UNWEIGHTED;
153 ompi_java_getIntArray(env, sources, &jSources, &cSources);
154 ompi_java_getIntArray(env, degrees, &jDegrees, &cDegrees);
155 ompi_java_getIntArray(env, destins, &jDestins, &cDestins);
156
157 if(weighted)
158 ompi_java_getIntArray(env, weights, &jWeights, &cWeights);
159
160 int rc = MPI_Dist_graph_create((MPI_Comm)comm,
161 nnodes, cSources, cDegrees, cDestins, cWeights,
162 (MPI_Info)info, reorder, &graph);
163
164 ompi_java_exceptionCheck(env, rc);
165 ompi_java_forgetIntArray(env, sources, jSources, cSources);
166 ompi_java_forgetIntArray(env, degrees, jDegrees, cDegrees);
167 ompi_java_forgetIntArray(env, destins, jDestins, cDestins);
168
169 if(weighted)
170 ompi_java_forgetIntArray(env, weights, jWeights, cWeights);
171
172 return (jlong)graph;
173 }
174
175 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createDistGraphAdjacent(
176 JNIEnv *env, jobject jthis, jlong comm, jintArray sources,
177 jintArray srcWeights, jintArray destins, jintArray desWeights,
178 jlong info, jboolean reorder, jboolean weighted)
179 {
180 MPI_Comm graph;
181
182 int inDegree = (*env)->GetArrayLength(env, sources),
183 outDegree = (*env)->GetArrayLength(env, destins);
184
185 jint *jSources, *jDestins, *jSrcWeights, *jDesWeights;
186 int *cSources, *cDestins, *cSrcWeights, *cDesWeights;
187 ompi_java_getIntArray(env, sources, &jSources, &cSources);
188 ompi_java_getIntArray(env, destins, &jDestins, &cDestins);
189
190 if(weighted)
191 {
192 ompi_java_getIntArray(env, srcWeights, &jSrcWeights, &cSrcWeights);
193 ompi_java_getIntArray(env, desWeights, &jDesWeights, &cDesWeights);
194 }
195 else
196 {
197 jSrcWeights = jDesWeights = NULL;
198 cSrcWeights = cDesWeights = MPI_UNWEIGHTED;
199 }
200
201 int rc = MPI_Dist_graph_create_adjacent((MPI_Comm)comm,
202 inDegree, cSources, cSrcWeights, outDegree, cDestins,
203 cDesWeights, (MPI_Info)info, reorder, &graph);
204
205 ompi_java_exceptionCheck(env, rc);
206 ompi_java_forgetIntArray(env, sources, jSources, cSources);
207 ompi_java_forgetIntArray(env, destins, jDestins, cDestins);
208
209 if(weighted)
210 {
211 ompi_java_forgetIntArray(env, srcWeights, jSrcWeights, cSrcWeights);
212 ompi_java_forgetIntArray(env, desWeights, jDesWeights, cDesWeights);
213 }
214
215 return (jlong)graph;
216 }
217
218 JNIEXPORT void JNICALL Java_mpi_Intracomm_scan(
219 JNIEnv *env, jobject jthis, jlong jComm,
220 jobject sBuf, jboolean sdb, jint sOff,
221 jobject rBuf, jboolean rdb, jint rOff, jint count,
222 jlong jType, jint bType, jobject jOp, jlong hOp)
223 {
224 MPI_Comm comm = (MPI_Comm)jComm;
225 MPI_Datatype type = (MPI_Datatype)jType;
226
227 void *sPtr, *rPtr;
228 ompi_java_buffer_t *sItem, *rItem;
229
230 if(sBuf == NULL)
231 {
232 sPtr = MPI_IN_PLACE;
233 ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
234 }
235 else
236 {
237 ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
238 ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
239 }
240
241 MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
242 int rc = MPI_Scan(sPtr, rPtr, count, type, op, comm);
243 ompi_java_exceptionCheck(env, rc);
244
245 if(sBuf != NULL)
246 ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
247
248 ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
249 }
250
251 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iScan(
252 JNIEnv *env, jobject jthis, jlong comm,
253 jobject sendBuf, jobject recvBuf, jint count,
254 jlong type, int baseType, jobject jOp, jlong hOp)
255 {
256 void *sPtr, *rPtr;
257 MPI_Request request;
258
259 if(sendBuf == NULL)
260 sPtr = MPI_IN_PLACE;
261 else
262 sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
263
264 rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
265
266 int rc = MPI_Iscan(sPtr, rPtr, count, (MPI_Datatype)type,
267 ompi_java_op_getHandle(env, jOp, hOp, baseType),
268 (MPI_Comm)comm, &request);
269
270 ompi_java_exceptionCheck(env, rc);
271 return (jlong)request;
272 }
273
274 JNIEXPORT void JNICALL Java_mpi_Intracomm_exScan(
275 JNIEnv *env, jobject jthis, jlong jComm,
276 jobject sBuf, jboolean sdb, jint sOff,
277 jobject rBuf, jboolean rdb, jint rOff, jint count,
278 jlong jType, int bType, jobject jOp, jlong hOp)
279 {
280 MPI_Comm comm = (MPI_Comm)jComm;
281 MPI_Datatype type = (MPI_Datatype)jType;
282
283 void *sPtr, *rPtr;
284 ompi_java_buffer_t *sItem, *rItem;
285
286 if(sBuf == NULL)
287 {
288 sPtr = MPI_IN_PLACE;
289 ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
290 }
291 else
292 {
293 ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
294 ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
295 }
296
297 MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
298 int rc = MPI_Exscan(sPtr, rPtr, count, type, op, comm);
299 ompi_java_exceptionCheck(env, rc);
300
301 if(sBuf != NULL)
302 ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
303
304 ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
305 }
306
307 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iExScan(
308 JNIEnv *env, jobject jthis, jlong comm,
309 jobject sendBuf, jobject recvBuf, jint count,
310 jlong type, int bType, jobject jOp, jlong hOp)
311 {
312 void *sPtr, *rPtr;
313
314 if(sendBuf == NULL)
315 sPtr = MPI_IN_PLACE;
316 else
317 sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
318
319 rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
320 MPI_Request request;
321
322 int rc = MPI_Iexscan(sPtr, rPtr, count, (MPI_Datatype)type,
323 ompi_java_op_getHandle(env, jOp, hOp, bType),
324 (MPI_Comm)comm, &request);
325
326 ompi_java_exceptionCheck(env, rc);
327 return (jlong)request;
328 }
329
330 JNIEXPORT jstring JNICALL Java_mpi_Intracomm_openPort(
331 JNIEnv *env, jclass clazz, jlong info)
332 {
333 char port[MPI_MAX_PORT_NAME + 1];
334 int rc = MPI_Open_port((MPI_Info)info, port);
335
336 return ompi_java_exceptionCheck(env, rc)
337 ? NULL : (*env)->NewStringUTF(env, port);
338 }
339
340 JNIEXPORT void JNICALL Java_mpi_Intracomm_closePort_1jni(
341 JNIEnv *env, jclass clazz, jstring jport)
342 {
343 const char *port = (*env)->GetStringUTFChars(env, jport, NULL);
344 int rc = MPI_Close_port((char*)port);
345 ompi_java_exceptionCheck(env, rc);
346 (*env)->ReleaseStringUTFChars(env, jport, port);
347 }
348
349 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_accept(
350 JNIEnv *env, jobject jthis, jlong comm,
351 jstring jport, jlong info, jint root)
352 {
353 const char *port = jport == NULL ? NULL :
354 (*env)->GetStringUTFChars(env, jport, NULL);
355 MPI_Comm newComm;
356
357 int rc = MPI_Comm_accept((char*)port, (MPI_Info)info,
358 root, (MPI_Comm)comm, &newComm);
359
360 ompi_java_exceptionCheck(env, rc);
361
362 if(jport != NULL)
363 (*env)->ReleaseStringUTFChars(env, jport, port);
364
365 return (jlong)newComm;
366 }
367
368 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_connect(
369 JNIEnv *env, jobject jthis, jlong comm,
370 jstring jport, jlong info, jint root)
371 {
372 const char *port = jport == NULL ? NULL :
373 (*env)->GetStringUTFChars(env, jport, NULL);
374 MPI_Comm newComm;
375
376 int rc = MPI_Comm_connect((char*)port, (MPI_Info)info,
377 root, (MPI_Comm)comm, &newComm);
378
379 ompi_java_exceptionCheck(env, rc);
380
381 if(jport != NULL)
382 (*env)->ReleaseStringUTFChars(env, jport, port);
383
384 return (jlong)newComm;
385 }
386
387 JNIEXPORT void JNICALL Java_mpi_Intracomm_publishName(
388 JNIEnv *env, jclass clazz, jstring jservice, jlong info, jstring jport)
389 {
390 const char *service = (*env)->GetStringUTFChars(env, jservice, NULL),
391 *port = (*env)->GetStringUTFChars(env, jport, NULL);
392
393 int rc = MPI_Publish_name((char*)service, (MPI_Info)info, (char*)port);
394 ompi_java_exceptionCheck(env, rc);
395
396 (*env)->ReleaseStringUTFChars(env, jservice, service);
397 (*env)->ReleaseStringUTFChars(env, jport, port);
398 }
399
400 JNIEXPORT void JNICALL Java_mpi_Intracomm_unpublishName(
401 JNIEnv *env, jclass clazz, jstring jservice, jlong info, jstring jport)
402 {
403 const char *service = (*env)->GetStringUTFChars(env, jservice, NULL),
404 *port = (*env)->GetStringUTFChars(env, jport, NULL);
405
406 int rc = MPI_Unpublish_name((char*)service, (MPI_Info)info, (char*)port);
407 ompi_java_exceptionCheck(env, rc);
408
409 (*env)->ReleaseStringUTFChars(env, jservice, service);
410 (*env)->ReleaseStringUTFChars(env, jport, port);
411 }
412
413 JNIEXPORT jstring JNICALL Java_mpi_Intracomm_lookupName(
414 JNIEnv *env, jclass clazz, jstring jservice, jlong info)
415 {
416 char port[MPI_MAX_PORT_NAME + 1];
417 const char *service = (*env)->GetStringUTFChars(env, jservice, NULL);
418
419 int rc = MPI_Lookup_name((char*)service, (MPI_Info)info, port);
420 (*env)->ReleaseStringUTFChars(env, jservice, service);
421
422 return ompi_java_exceptionCheck(env, rc)
423 ? NULL : (*env)->NewStringUTF(env, port);
424 }
425
426 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_spawn(
427 JNIEnv *env, jobject jthis, jlong comm, jstring jCommand,
428 jobjectArray jArgv, jint maxprocs, jlong info, jint root,
429 jintArray errCodes)
430 {
431 int i, rc;
432 MPI_Comm intercomm;
433 const char* command = (*env)->GetStringUTFChars(env, jCommand, NULL);
434
435 jint *jErrCodes;
436 int *cErrCodes = MPI_ERRCODES_IGNORE;
437
438 if(errCodes != NULL)
439 ompi_java_getIntArray(env, errCodes, &jErrCodes, &cErrCodes);
440
441 char **argv = MPI_ARGV_NULL;
442
443 if(jArgv != NULL)
444 {
445 jsize argvLength = (*env)->GetArrayLength(env, jArgv);
446 argv = (char**)calloc(argvLength + 1, sizeof(char*));
447
448 for(i = 0; i < argvLength; i++)
449 {
450 jstring a = (*env)->GetObjectArrayElement(env, jArgv, i);
451 argv[i] = strdup((*env)->GetStringUTFChars(env, a, NULL));
452 (*env)->DeleteLocalRef(env, a);
453 }
454
455 argv[argvLength] = NULL;
456 }
457
458 rc = MPI_Comm_spawn((char*)command, argv, maxprocs, (MPI_Info)info,
459 root, (MPI_Comm)comm, &intercomm, cErrCodes);
460
461 ompi_java_exceptionCheck(env, rc);
462
463 if(jArgv != NULL)
464 {
465 jsize argvLength = (*env)->GetArrayLength(env, jArgv);
466
467 for(i = 0; i < argvLength; i++)
468 {
469 jstring a = (*env)->GetObjectArrayElement(env, jArgv, i);
470 (*env)->ReleaseStringUTFChars(env, a, argv[i]);
471 (*env)->DeleteLocalRef(env, a);
472 }
473
474 free(argv);
475 }
476
477 if(errCodes != NULL)
478 ompi_java_releaseIntArray(env, errCodes, jErrCodes, cErrCodes);
479
480 (*env)->ReleaseStringUTFChars(env, jCommand, command);
481 return (jlong)intercomm;
482 }
483
484 JNIEXPORT jlong JNICALL Java_mpi_Intracomm_spawnMultiple(
485 JNIEnv *env, jobject jthis, jlong comm, jobjectArray jCommands,
486 jobjectArray jArgv, jintArray maxProcs, jlongArray info,
487 jint root, jintArray errCodes)
488 {
489 int i, rc;
490 MPI_Comm intercomm;
491 jlong *jInfo = (*env)->GetLongArrayElements(env, info, NULL);
492
493 jint *jMaxProcs, *jErrCodes;
494 int *cMaxProcs, *cErrCodes = MPI_ERRCODES_IGNORE;
495 ompi_java_getIntArray(env, maxProcs, &jMaxProcs, &cMaxProcs);
496
497 if(errCodes != NULL)
498 ompi_java_getIntArray(env, errCodes, &jErrCodes, &cErrCodes);
499
500 int commandsLength = (*env)->GetArrayLength(env, jCommands),
501 infoLength = (*env)->GetArrayLength(env, info);
502
503 char **commands = calloc(commandsLength, sizeof(char*)),
504 ***argv = MPI_ARGVS_NULL;
505 MPI_Info *cInfo = calloc(infoLength, sizeof(MPI_Info));
506
507 for(i = 0; i < infoLength; i++)
508 cInfo[i] = (MPI_Info)jInfo[i];
509
510 for(i = 0; i < commandsLength; i++)
511 {
512 jstring a = (*env)->GetObjectArrayElement(env, jCommands, i);
513 commands[i] = (char*)(*env)->GetStringUTFChars(env, a, NULL);
514 (*env)->DeleteLocalRef(env, a);
515 }
516
517 if(jArgv != NULL)
518 {
519 int argvLength = (*env)->GetArrayLength(env, jArgv);
520 argv = calloc(argvLength, sizeof(char**));
521
522 for(i = 0; i < argvLength; i++)
523 {
524 jobjectArray arr = (*env)->GetObjectArrayElement(env, jArgv, i);
525 int j, length = (*env)->GetArrayLength(env, arr);
526 argv[i] = calloc(length + 1, sizeof(char*));
527
528 for(j = 0; j < length; j++)
529 {
530 jstring a = (*env)->GetObjectArrayElement(env, arr, j);
531 argv[i][j] = (char*)(*env)->GetStringUTFChars(env, a, NULL);
532 (*env)->DeleteLocalRef(env, a);
533 }
534
535 argv[i][length] = NULL;
536 (*env)->DeleteLocalRef(env, arr);
537 }
538 }
539
540 rc = MPI_Comm_spawn_multiple(
541 commandsLength, commands, argv, cMaxProcs, cInfo,
542 root, (MPI_Comm)comm, &intercomm, cErrCodes);
543
544 ompi_java_exceptionCheck(env, rc);
545
546 if(jArgv != NULL)
547 {
548 int argvLength = (*env)->GetArrayLength(env, jArgv);
549
550 for(i = 0; i < argvLength; i++)
551 {
552 jobjectArray arr = (*env)->GetObjectArrayElement(env, jArgv, i);
553 int j, length = (*env)->GetArrayLength(env, arr);
554
555 for(j = 0; j < length; j++)
556 {
557 jstring a = (*env)->GetObjectArrayElement(env, arr, j);
558 (*env)->ReleaseStringUTFChars(env, a, argv[i][j]);
559 (*env)->DeleteLocalRef(env, a);
560 }
561
562 (*env)->DeleteLocalRef(env, arr);
563 free(argv[i]);
564 }
565
566 free(argv);
567 }
568
569 for(i = 0; i < commandsLength; i++)
570 {
571 jstring a = (*env)->GetObjectArrayElement(env, jCommands, i);
572 (*env)->ReleaseStringUTFChars(env, a, commands[i]);
573 (*env)->DeleteLocalRef(env, a);
574 }
575
576 if(errCodes != NULL)
577 ompi_java_releaseIntArray(env, errCodes, jErrCodes, cErrCodes);
578
579 free(cInfo);
580 free(commands);
581 (*env)->ReleaseLongArrayElements(env, info, jInfo, JNI_ABORT);
582 ompi_java_forgetIntArray(env, maxProcs, jMaxProcs, cMaxProcs);
583 return (jlong)intercomm;
584 }