root/ompi/mpi/java/c/mpi_Win.c

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

DEFINITIONS

This source file includes following definitions.
  1. Java_mpi_Win_createWin
  2. Java_mpi_Win_allocateWin
  3. Java_mpi_Win_allocateSharedWin
  4. Java_mpi_Win_createDynamicWin
  5. Java_mpi_Win_attach
  6. Java_mpi_Win_detach
  7. Java_mpi_Win_getGroup
  8. Java_mpi_Win_put
  9. Java_mpi_Win_get
  10. Java_mpi_Win_accumulate
  11. Java_mpi_Win_fence
  12. Java_mpi_Win_start
  13. Java_mpi_Win_complete
  14. Java_mpi_Win_post
  15. Java_mpi_Win_waitFor
  16. Java_mpi_Win_test
  17. Java_mpi_Win_lock
  18. Java_mpi_Win_unlock
  19. Java_mpi_Win_setErrhandler
  20. Java_mpi_Win_getErrhandler
  21. Java_mpi_Win_callErrhandler
  22. winCopyAttr
  23. winDeleteAttr
  24. Java_mpi_Win_createKeyval_1jni
  25. Java_mpi_Win_freeKeyval_1jni
  26. Java_mpi_Win_setAttr
  27. Java_mpi_Win_getAttr
  28. Java_mpi_Win_deleteAttr
  29. Java_mpi_Win_free
  30. Java_mpi_Win_getInfo
  31. Java_mpi_Win_setInfo
  32. Java_mpi_Win_rPut
  33. Java_mpi_Win_rGet
  34. Java_mpi_Win_rAccumulate
  35. Java_mpi_Win_getAccumulate
  36. Java_mpi_Win_rGetAccumulate
  37. Java_mpi_Win_lockAll
  38. Java_mpi_Win_unlockAll
  39. Java_mpi_Win_sync
  40. Java_mpi_Win_flush
  41. Java_mpi_Win_flushAll
  42. Java_mpi_Win_compareAndSwap
  43. Java_mpi_Win_fetchAndOp
  44. Java_mpi_Win_flushLocal
  45. Java_mpi_Win_flushLocalAll
  46. Java_mpi_Win_setName
  47. Java_mpi_Win_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      Research Organization for Information Science
  13  *                         and Technology (RIST). All rights reserved.
  14  * Copyright (c) 2015      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 #include "ompi_config.h"
  25 
  26 #include <stdlib.h>
  27 #ifdef HAVE_TARGETCONDITIONALS_H
  28 #include <TargetConditionals.h>
  29 #endif
  30 
  31 #include "mpi.h"
  32 #include "mpi_Win.h"
  33 #include "mpiJava.h"
  34 
  35 JNIEXPORT jlong JNICALL Java_mpi_Win_createWin(
  36         JNIEnv *env, jobject jthis, jobject jBase,
  37         jint size, jint dispUnit, jlong info, jlong comm)
  38 {
  39     void *base = (*env)->GetDirectBufferAddress(env, jBase);
  40     MPI_Win win;
  41 
  42     int rc = MPI_Win_create(base, (MPI_Aint)size, dispUnit,
  43                             (MPI_Info)info, (MPI_Comm)comm, &win);
  44 
  45     ompi_java_exceptionCheck(env, rc);
  46     return (jlong)win;
  47 }
  48 
  49 JNIEXPORT jlong JNICALL Java_mpi_Win_allocateWin(JNIEnv *env, jobject jthis,
  50                                                  jint size, jint dispUnit, jlong info, jlong comm, jobject jBase)
  51 {
  52     void *basePtr = (*env)->GetDirectBufferAddress(env, jBase);
  53     MPI_Win win;
  54 
  55     int rc = MPI_Win_allocate((MPI_Aint)size, dispUnit,
  56                               (MPI_Info)info, (MPI_Comm)comm, basePtr, &win);
  57 
  58     ompi_java_exceptionCheck(env, rc);
  59     return (jlong)win;
  60 }
  61 
  62 JNIEXPORT jlong JNICALL Java_mpi_Win_allocateSharedWin(JNIEnv *env, jobject jthis,
  63                                                        jint size, jint dispUnit, jlong info, jlong comm, jobject jBase)
  64 {
  65     void *basePtr = (*env)->GetDirectBufferAddress(env, jBase);
  66     MPI_Win win;
  67 
  68     int rc = MPI_Win_allocate_shared((MPI_Aint)size, dispUnit,
  69                                      (MPI_Info)info, (MPI_Comm)comm, basePtr, &win);
  70 
  71     ompi_java_exceptionCheck(env, rc);
  72     return (jlong)win;
  73 }
  74 
  75 JNIEXPORT jlong JNICALL Java_mpi_Win_createDynamicWin(
  76         JNIEnv *env, jobject jthis,
  77         jlong info, jlong comm)
  78 {
  79     MPI_Win win;
  80 
  81     int rc = MPI_Win_create_dynamic(
  82                             (MPI_Info)info, (MPI_Comm)comm, &win);
  83 
  84     ompi_java_exceptionCheck(env, rc);
  85     return (jlong)win;
  86 }
  87 
  88 JNIEXPORT void JNICALL Java_mpi_Win_attach(
  89         JNIEnv *env, jobject jthis, jlong win, jobject jBase,
  90         jint size)
  91 {
  92     void *base = (*env)->GetDirectBufferAddress(env, jBase);
  93 
  94     int rc = MPI_Win_attach((MPI_Win)win, base, (MPI_Aint)size);
  95 
  96     ompi_java_exceptionCheck(env, rc);
  97 }
  98 
  99 JNIEXPORT void JNICALL Java_mpi_Win_detach(
 100         JNIEnv *env, jobject jthis, jlong win, jobject jBase)
 101 {
 102     void *base = (*env)->GetDirectBufferAddress(env, jBase);
 103 
 104     int rc = MPI_Win_detach((MPI_Win)win, base);
 105 
 106     ompi_java_exceptionCheck(env, rc);
 107 }
 108 
 109 JNIEXPORT jlong JNICALL Java_mpi_Win_getGroup(
 110         JNIEnv *env, jobject jthis, jlong win)
 111 {
 112     MPI_Group group;
 113     int rc = MPI_Win_get_group((MPI_Win)win, &group);
 114     ompi_java_exceptionCheck(env, rc);
 115     return (jlong)group;
 116 }
 117 
 118 JNIEXPORT void JNICALL Java_mpi_Win_put(
 119         JNIEnv *env, jobject jthis, jlong win, jobject origin,
 120         jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
 121         jint targetCount, jlong targetType, jint baseType)
 122 {
 123     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 124 
 125     int rc = MPI_Put(orgPtr, orgCount, (MPI_Datatype)orgType,
 126                      targetRank, (MPI_Aint)targetDisp, targetCount,
 127                      (MPI_Datatype)targetType, (MPI_Win)win);
 128 
 129     ompi_java_exceptionCheck(env, rc);
 130 }
 131 
 132 JNIEXPORT void JNICALL Java_mpi_Win_get(
 133         JNIEnv *env, jobject jthis, jlong win, jobject origin,
 134         jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
 135         jint targetCount, jlong targetType, jint baseType)
 136 {
 137     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 138 
 139     int rc = MPI_Get(orgPtr, orgCount, (MPI_Datatype)orgType,
 140                      targetRank, (MPI_Aint)targetDisp, targetCount,
 141                      (MPI_Datatype)targetType, (MPI_Win)win);
 142 
 143     ompi_java_exceptionCheck(env, rc);
 144 }
 145 
 146 JNIEXPORT void JNICALL Java_mpi_Win_accumulate(
 147         JNIEnv *env, jobject jthis, jlong win,
 148         jobject origin, jint orgCount, jlong orgType,
 149         jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
 150         jobject jOp, jlong hOp, jint baseType)
 151 {
 152     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 153     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
 154 
 155     int rc = MPI_Accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
 156                             targetRank, (MPI_Aint)targetDisp, targetCount,
 157                             (MPI_Datatype)targetType, op, (MPI_Win)win);
 158 
 159     ompi_java_exceptionCheck(env, rc);
 160 }
 161 
 162 JNIEXPORT void JNICALL Java_mpi_Win_fence(
 163         JNIEnv *env, jobject jthis, jlong win, jint assertion)
 164 {
 165     int rc = MPI_Win_fence(assertion, (MPI_Win)win);
 166     ompi_java_exceptionCheck(env, rc);
 167 }
 168 
 169 JNIEXPORT void JNICALL Java_mpi_Win_start(
 170         JNIEnv *env, jobject jthis, jlong win, jlong group, jint assertion)
 171 {
 172     int rc = MPI_Win_start((MPI_Group)group, assertion, (MPI_Win)win);
 173     ompi_java_exceptionCheck(env, rc);
 174 }
 175 
 176 JNIEXPORT void JNICALL Java_mpi_Win_complete(
 177         JNIEnv *env, jobject jthis, jlong win)
 178 {
 179     int rc = MPI_Win_complete((MPI_Win)win);
 180     ompi_java_exceptionCheck(env, rc);
 181 }
 182 
 183 JNIEXPORT void JNICALL Java_mpi_Win_post(
 184         JNIEnv *env, jobject jthis, jlong win, jlong group, jint assertion)
 185 {
 186     int rc = MPI_Win_post((MPI_Group)group, assertion, (MPI_Win)win);
 187     ompi_java_exceptionCheck(env, rc);
 188 }
 189 
 190 JNIEXPORT void JNICALL Java_mpi_Win_waitFor(
 191         JNIEnv *env, jobject jthis, jlong win)
 192 {
 193     int rc = MPI_Win_wait((MPI_Win)win);
 194     ompi_java_exceptionCheck(env, rc);
 195 }
 196 
 197 JNIEXPORT jboolean JNICALL Java_mpi_Win_test(
 198         JNIEnv *env, jobject jthis, jlong win)
 199 {
 200     int flag;
 201     int rc = MPI_Win_test((MPI_Win)win, &flag);
 202     ompi_java_exceptionCheck(env, rc);
 203     return flag ? JNI_TRUE : JNI_FALSE;
 204 }
 205 
 206 JNIEXPORT void JNICALL Java_mpi_Win_lock(
 207         JNIEnv *env, jobject jthis, jlong win,
 208         jint lockType, jint rank, jint assertion)
 209 {
 210     int rc = MPI_Win_lock(lockType, rank, assertion, (MPI_Win)win);
 211     ompi_java_exceptionCheck(env, rc);
 212 }
 213 
 214 JNIEXPORT void JNICALL Java_mpi_Win_unlock(
 215         JNIEnv *env, jobject jthis, jlong win, jint rank)
 216 {
 217     int rc = MPI_Win_unlock(rank, (MPI_Win)win);
 218     ompi_java_exceptionCheck(env, rc);
 219 }
 220 
 221 JNIEXPORT void JNICALL Java_mpi_Win_setErrhandler(
 222         JNIEnv *env, jobject jthis, jlong win, jlong errhandler)
 223 {
 224     int rc = MPI_Win_set_errhandler(
 225              (MPI_Win)win, (MPI_Errhandler)errhandler);
 226 
 227     ompi_java_exceptionCheck(env, rc);
 228 }
 229 
 230 JNIEXPORT jlong JNICALL Java_mpi_Win_getErrhandler(
 231         JNIEnv *env, jobject jthis, jlong win)
 232 {
 233     MPI_Errhandler errhandler;
 234     int rc = MPI_Win_get_errhandler((MPI_Win)win, &errhandler);
 235     ompi_java_exceptionCheck(env, rc);
 236     return (jlong)errhandler;
 237 }
 238 
 239 JNIEXPORT void JNICALL Java_mpi_Win_callErrhandler(
 240         JNIEnv *env, jobject jthis, jlong win, jint errorCode)
 241 {
 242     int rc = MPI_Win_call_errhandler((MPI_Win)win, errorCode);
 243     ompi_java_exceptionCheck(env, rc);
 244 }
 245 
 246 static int winCopyAttr(MPI_Win oldwin, int keyval, void *extraState,
 247                        void *attrValIn, void *attrValOut, int *flag)
 248 {
 249     return ompi_java_attrCopy(attrValIn, attrValOut, flag);
 250 }
 251 
 252 static int winDeleteAttr(MPI_Win oldwin, int keyval,
 253                          void *attrVal, void *extraState)
 254 {
 255     return ompi_java_attrDelete(attrVal);
 256 }
 257 
 258 JNIEXPORT jint JNICALL Java_mpi_Win_createKeyval_1jni(JNIEnv *env, jclass clazz)
 259 {
 260     int rc, keyval;
 261     rc = MPI_Win_create_keyval(winCopyAttr, winDeleteAttr, &keyval, NULL);
 262     ompi_java_exceptionCheck(env, rc);
 263     return keyval;
 264 }
 265 
 266 JNIEXPORT void JNICALL Java_mpi_Win_freeKeyval_1jni(
 267         JNIEnv *env, jclass clazz, jint keyval)
 268 {
 269     int rc = MPI_Win_free_keyval((int*)(&keyval));
 270     ompi_java_exceptionCheck(env, rc);
 271 }
 272 
 273 JNIEXPORT void JNICALL Java_mpi_Win_setAttr(
 274         JNIEnv *env, jobject jthis, jlong win, jint keyval, jbyteArray jval)
 275 {
 276     void *cval = ompi_java_attrSet(env, jval);
 277     int rc = MPI_Win_set_attr((MPI_Win)win, keyval, cval);
 278     ompi_java_exceptionCheck(env, rc);
 279 }
 280 
 281 JNIEXPORT jobject JNICALL Java_mpi_Win_getAttr(
 282         JNIEnv *env, jobject jthis, jlong win, jint keyval)
 283 {
 284     int flag;
 285     void *val;
 286     int rc = MPI_Win_get_attr((MPI_Win)win, keyval, &val, &flag);
 287 
 288     if(ompi_java_exceptionCheck(env, rc) || !flag)
 289         return NULL;
 290 
 291     switch(keyval)
 292     {
 293         case MPI_WIN_SIZE:
 294             return ompi_java_Integer_valueOf(env, (jint)(*((MPI_Aint*)val)));
 295         case MPI_WIN_DISP_UNIT:
 296             return ompi_java_Integer_valueOf(env, (jint)(*((int*)val)));
 297         case MPI_WIN_BASE:
 298             return ompi_java_Long_valueOf(env, (jlong)val);
 299         default:
 300             return ompi_java_attrGet(env, val);
 301     }
 302 }
 303 
 304 JNIEXPORT void JNICALL Java_mpi_Win_deleteAttr(
 305         JNIEnv *env, jobject jthis, jlong win, jint keyval)
 306 {
 307     int rc = MPI_Win_delete_attr((MPI_Win)win, keyval);
 308     ompi_java_exceptionCheck(env, rc);
 309 }
 310 
 311 JNIEXPORT jlong JNICALL Java_mpi_Win_free(
 312         JNIEnv *env, jobject jthis, jlong handle)
 313 {
 314     MPI_Win win = (MPI_Win)handle;
 315     int rc = MPI_Win_free(&win);
 316     ompi_java_exceptionCheck(env, rc);
 317     return (jlong)win;
 318 }
 319 
 320 JNIEXPORT jlong JNICALL Java_mpi_Win_getInfo(
 321         JNIEnv *env, jobject jthis, jlong handle)
 322 {
 323     MPI_Win win = (MPI_Win)handle;
 324     MPI_Info info;
 325     int rc = MPI_Win_get_info((MPI_Win)win, &info);
 326     ompi_java_exceptionCheck(env, rc);
 327     return (jlong)info;
 328 }
 329 
 330 JNIEXPORT void JNICALL Java_mpi_Win_setInfo(
 331         JNIEnv *env, jobject jthis, jlong handle, jlong i)
 332 {
 333     MPI_Win win = (MPI_Win)handle;
 334     MPI_Info info = (MPI_Info)i;
 335     int rc = MPI_Win_set_info(win, info);
 336     ompi_java_exceptionCheck(env, rc);
 337 }
 338 
 339 JNIEXPORT jlong JNICALL Java_mpi_Win_rPut(JNIEnv *env, jobject jthis,
 340     jlong win, jobject origin_addr, jint origin_count, jlong origin_type,
 341     jint target_rank, jint target_disp, jint target_count, jlong target_datatype,
 342     jint basetype)
 343 {
 344     void *origPtr = ompi_java_getDirectBufferAddress(env, origin_addr);
 345     MPI_Request request;
 346 
 347     int rc = MPI_Rput(origPtr, origin_count, (MPI_Datatype)origin_type,
 348                       target_rank, (MPI_Aint)target_disp, target_count, (MPI_Datatype)target_datatype,
 349                       (MPI_Win)win, &request);
 350 
 351     ompi_java_exceptionCheck(env, rc);
 352     return (jlong)request;
 353 }
 354 
 355 JNIEXPORT jlong JNICALL Java_mpi_Win_rGet(JNIEnv *env, jobject jthis, jlong win,
 356     jobject origin, jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
 357     jint targetCount, jlong targetType, jint base)
 358 {
 359     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 360     MPI_Request request;
 361 
 362     int rc = MPI_Rget(orgPtr, orgCount, (MPI_Datatype)orgType,
 363                       targetRank, (MPI_Aint)targetDisp, targetCount,
 364                       (MPI_Datatype)targetType, (MPI_Win)win, &request);
 365 
 366     ompi_java_exceptionCheck(env, rc);
 367     return (jlong)request;
 368 }
 369 
 370 JNIEXPORT jlong JNICALL Java_mpi_Win_rAccumulate(JNIEnv *env, jobject jthis, jlong win,
 371     jobject origin, jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
 372     jint targetCount, jlong targetType, jobject jOp, jlong hOp, jint baseType)
 373 {
 374     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 375     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
 376     MPI_Request request;
 377 
 378     int rc = MPI_Raccumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
 379                             targetRank, (MPI_Aint)targetDisp, targetCount,
 380                             (MPI_Datatype)targetType, op, (MPI_Win)win, &request);
 381 
 382     ompi_java_exceptionCheck(env, rc);
 383     return (jlong)request;
 384 }
 385 
 386 JNIEXPORT void JNICALL Java_mpi_Win_getAccumulate(JNIEnv *env, jobject jthis, jlong win,
 387                             jobject origin, jint orgCount, jlong orgType, jobject resultBuff, jint resultCount,
 388                                                   jlong resultType, jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
 389                                                   jobject jOp, jlong hOp, jint baseType)
 390 {
 391     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 392     void *resultPtr = (*env)->GetDirectBufferAddress(env, resultBuff);
 393     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
 394 
 395     int rc = MPI_Get_accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
 396                                 resultPtr, resultCount, (MPI_Datatype)resultType,
 397                                 targetRank, (MPI_Aint)targetDisp, targetCount,
 398                                 (MPI_Datatype)targetType, op, (MPI_Win)win);
 399 
 400     ompi_java_exceptionCheck(env, rc);
 401 }
 402 
 403 JNIEXPORT jlong JNICALL Java_mpi_Win_rGetAccumulate(JNIEnv *env, jobject jthis, jlong win,
 404                                                     jobject origin, jint orgCount, jlong orgType, jobject resultBuff, jint resultCount,
 405                                                     jlong resultType, jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
 406                                                     jobject jOp, jlong hOp, jint baseType)
 407 {
 408     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 409     void *resultPtr = (*env)->GetDirectBufferAddress(env, resultBuff);
 410     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
 411     MPI_Request request;
 412 
 413     int rc = MPI_Rget_accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
 414                                  resultPtr, resultCount, (MPI_Datatype)resultType,
 415                                  targetRank, (MPI_Aint)targetDisp, targetCount,
 416                                  (MPI_Datatype)targetType, op, (MPI_Win)win, &request);
 417 
 418     ompi_java_exceptionCheck(env, rc);
 419     return (jlong)request;
 420 }
 421 
 422 JNIEXPORT void JNICALL Java_mpi_Win_lockAll(JNIEnv *env, jobject jthis, jlong win, jint assertion)
 423 {
 424     int rc = MPI_Win_lock_all(assertion, (MPI_Win)win);
 425     ompi_java_exceptionCheck(env, rc);
 426 }
 427 
 428 JNIEXPORT void JNICALL Java_mpi_Win_unlockAll(JNIEnv *env, jobject jthis, jlong win)
 429 {
 430     int rc = MPI_Win_unlock_all((MPI_Win)win);
 431     ompi_java_exceptionCheck(env, rc);
 432 }
 433 
 434 JNIEXPORT void JNICALL Java_mpi_Win_sync(JNIEnv *env, jobject jthis, jlong win)
 435 {
 436     int rc = MPI_Win_sync((MPI_Win)win);
 437     ompi_java_exceptionCheck(env, rc);
 438 }
 439 
 440 JNIEXPORT void JNICALL Java_mpi_Win_flush(JNIEnv *env, jobject jthis, jlong win, jint targetRank)
 441 {
 442     int rc = MPI_Win_flush(targetRank, (MPI_Win)win);
 443     ompi_java_exceptionCheck(env, rc);
 444 }
 445 
 446 JNIEXPORT void JNICALL Java_mpi_Win_flushAll(JNIEnv *env, jobject jthis, jlong win)
 447 {
 448     int rc = MPI_Win_flush_all((MPI_Win)win);
 449     ompi_java_exceptionCheck(env, rc);
 450 }
 451 
 452 JNIEXPORT void JNICALL Java_mpi_Win_compareAndSwap (JNIEnv *env, jobject jthis, jlong win, jobject origin,
 453                                                     jobject compareAddr, jobject resultAddr, jlong dataType, jint targetRank, jint targetDisp)
 454 {
 455     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 456     void *compPtr = (*env)->GetDirectBufferAddress(env, compareAddr);
 457     void *resultPtr = (*env)->GetDirectBufferAddress(env, resultAddr);
 458 
 459     int rc = MPI_Compare_and_swap(orgPtr, compPtr, resultPtr, (MPI_Datatype)dataType, 
 460         targetRank, targetDisp, (MPI_Win)win);
 461     ompi_java_exceptionCheck(env, rc);
 462 }
 463 
 464 JNIEXPORT void JNICALL Java_mpi_Win_fetchAndOp(JNIEnv *env, jobject jthis, jlong win, jobject origin,
 465                                                jobject resultAddr, jlong dataType, jint targetRank, jint targetDisp, jobject jOp, jlong hOp, jint baseType)
 466 {
 467     void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
 468     void *resultPtr = (*env)->GetDirectBufferAddress(env, resultAddr);
 469     MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
 470 
 471     int rc = MPI_Fetch_and_op(orgPtr, resultPtr, (MPI_Datatype)dataType, targetRank, 
 472         targetDisp, op, (MPI_Win)win);
 473     ompi_java_exceptionCheck(env, rc);
 474 }
 475 
 476 JNIEXPORT void JNICALL Java_mpi_Win_flushLocal(JNIEnv *env, jobject jthis, jlong win, jint targetRank)
 477 {
 478     int rc = MPI_Win_flush_local(targetRank, (MPI_Win)win);
 479     ompi_java_exceptionCheck(env, rc);
 480 }
 481 
 482 JNIEXPORT void JNICALL Java_mpi_Win_flushLocalAll(JNIEnv *env, jobject jthis, jlong win)
 483 {
 484     int rc = MPI_Win_flush_local_all((MPI_Win)win);
 485     ompi_java_exceptionCheck(env, rc);
 486 }
 487 
 488 JNIEXPORT void JNICALL Java_mpi_Win_setName(
 489         JNIEnv *env, jobject jthis, jlong handle, jstring jname)
 490 {
 491     const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
 492     int rc = MPI_Win_set_name((MPI_Win)handle, (char*)name);
 493     ompi_java_exceptionCheck(env, rc);
 494     (*env)->ReleaseStringUTFChars(env, jname, name);
 495 }
 496 
 497 JNIEXPORT jstring JNICALL Java_mpi_Win_getName(
 498         JNIEnv *env, jobject jthis, jlong handle)
 499 {
 500     char name[MPI_MAX_OBJECT_NAME];
 501     int len;
 502     int rc = MPI_Win_get_name((MPI_Win)handle, name, &len);
 503 
 504     if(ompi_java_exceptionCheck(env, rc))
 505         return NULL;
 506 
 507     return (*env)->NewStringUTF(env, name);
 508 }
/* [<][>][^][v][top][bottom][index][help] */