root/ompi/mpi/java/c/mpi_Group.c

DEFINITIONS

1. Java_mpi_Group_init
2. Java_mpi_Group_getEmpty
3. Java_mpi_Group_getSize
4. Java_mpi_Group_getRank
5. Java_mpi_Group_free
6. Java_mpi_Group_translateRanks
7. Java_mpi_Group_compare
8. Java_mpi_Group_union
9. Java_mpi_Group_intersection
10. Java_mpi_Group_difference
11. Java_mpi_Group_incl
12. Java_mpi_Group_excl
13. Java_mpi_Group_rangeIncl
14. Java_mpi_Group_rangeExcl

   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$
  13  *
  14  * Additional copyrights may follow
  15  *
  16  * $HEADER$
  17  */
  18 /*
  19  * This file is almost a complete re-write for Open MPI compared to the
  20  * original mpiJava package. Its license and copyright are listed below.
  21  * See <path to ompi/mpi/java/README> for more information.
  22  */
  23 /*
  24     Licensed under the Apache License, Version 2.0 (the "License");
  25     you may not use this file except in compliance with the License.
  26     You may obtain a copy of the License at
  27 
  28        http://www.apache.org/licenses/LICENSE-2.0
  29 
  30     Unless required by applicable law or agreed to in writing, software
  31     distributed under the License is distributed on an "AS IS" BASIS,
  32     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  33     See the License for the specific language governing permissions and
  34     limitations under the License.
  35 */
  36 /*
  37  * File         : mpi_Group.c
  38  * Headerfile   : mpi_Group.h
  39  * Author       : Xinying Li
  40  * Created      : Thu Apr  9 12:22:15 1998
  41  * Revision     : $Revision: 1.3 $
  42  * Updated      : $Date: 2003/01/16 16:39:34 $
  43  * Copyright: Northeast Parallel Architectures Center
  44  *            at Syracuse University 1998
  45  */
  46 
  47 #include "ompi_config.h"
  48 
  49 #include <stdlib.h>
  50 #ifdef HAVE_TARGETCONDITIONALS_H
  51 #include <TargetConditionals.h>
  52 #endif
  53 
  54 #include "mpi.h"
  55 #include "mpi_Group.h"
  56 #include "mpiJava.h"
  57 
  58 JNIEXPORT void JNICALL Java_mpi_Group_init(JNIEnv *env, jclass clazz)
  59 {
  60     ompi_java_setStaticLongField(env, clazz,
  61             "nullHandle", (jlong)MPI_GROUP_NULL);
  62 
  63     ompi_java.GroupHandle = (*env)->GetFieldID(env, clazz, "handle", "J");
  64 }
  65 
  66 JNIEXPORT jlong JNICALL Java_mpi_Group_getEmpty(JNIEnv *env, jclass clazz)
  67 {
  68     return (jlong)MPI_GROUP_EMPTY;
  69 }
  70 
  71 JNIEXPORT jint JNICALL Java_mpi_Group_getSize(
  72         JNIEnv *env, jobject jthis, jlong group)
  73 {
  74     int size, rc;
  75     rc = MPI_Group_size((MPI_Group)group, &size);
  76     ompi_java_exceptionCheck(env, rc);
  77     return size;
  78 }
  79 
  80 JNIEXPORT jint JNICALL Java_mpi_Group_getRank(
  81         JNIEnv *env, jobject jthis, jlong group)
  82 {
  83     int rank, rc;
  84     rc = MPI_Group_rank((MPI_Group)group, &rank);
  85     ompi_java_exceptionCheck(env, rc);
  86     return rank;
  87 }
  88 
  89 JNIEXPORT jlong JNICALL Java_mpi_Group_free(
  90         JNIEnv *env, jobject jthis, jlong handle)
  91 {
  92     MPI_Group group = (MPI_Group)handle;
  93     int rc = MPI_Group_free(&group);
  94     ompi_java_exceptionCheck(env, rc);
  95     return (jlong)group;
  96 }
  97 
  98 JNIEXPORT jintArray JNICALL Java_mpi_Group_translateRanks(
  99         JNIEnv *env, jclass jthis, jlong group1,
 100         jintArray ranks1, jlong group2)
 101 {
 102     jsize n = (*env)->GetArrayLength(env, ranks1);
 103     jintArray ranks2 = (*env)->NewIntArray(env,n);
 104     jint *jRanks1, *jRanks2;
 105     int  *cRanks1, *cRanks2;
 106     ompi_java_getIntArray(env, ranks1, &jRanks1, &cRanks1);
 107     ompi_java_getIntArray(env, ranks2, &jRanks2, &cRanks2);
 108 
 109     int rc = MPI_Group_translate_ranks((MPI_Group)group1, n, cRanks1,
 110                                        (MPI_Group)group2, cRanks2);
 111     ompi_java_exceptionCheck(env, rc);
 112     ompi_java_forgetIntArray(env, ranks1, jRanks1, cRanks1);
 113     ompi_java_releaseIntArray(env, ranks2, jRanks2, cRanks2);
 114     return ranks2;
 115 }
 116 
 117 JNIEXPORT jint JNICALL Java_mpi_Group_compare(
 118         JNIEnv *env, jclass jthis, jlong group1, jlong group2)
 119 {
 120     int result, rc;
 121     rc = MPI_Group_compare((MPI_Group)group1, (MPI_Group)group2, &result);
 122     ompi_java_exceptionCheck(env, rc);
 123     return result;
 124 }
 125 
 126 JNIEXPORT jlong JNICALL Java_mpi_Group_union(
 127         JNIEnv *env, jclass jthis, jlong group1, jlong group2)
 128 {
 129     MPI_Group newGroup;
 130     int rc = MPI_Group_union((MPI_Group)group1, (MPI_Group)group2, &newGroup);
 131     ompi_java_exceptionCheck(env, rc);
 132     return (jlong)newGroup;
 133 }
 134 
 135 JNIEXPORT jlong JNICALL Java_mpi_Group_intersection(
 136         JNIEnv *env, jclass jthis, jlong group1, jlong group2)
 137 {
 138     MPI_Group newGroup;
 139 
 140     int rc = MPI_Group_intersection(
 141              (MPI_Group)group1, (MPI_Group)group2, &newGroup);
 142 
 143     ompi_java_exceptionCheck(env, rc);
 144     return (jlong)newGroup;
 145 }
 146 
 147 JNIEXPORT jlong JNICALL Java_mpi_Group_difference(
 148         JNIEnv *env, jclass jthis, jlong group1, jlong group2)
 149 {
 150     MPI_Group newGroup;
 151 
 152     int rc = MPI_Group_difference(
 153              (MPI_Group)group1, (MPI_Group)group2, &newGroup);
 154 
 155     ompi_java_exceptionCheck(env, rc);
 156     return (jlong)newGroup;
 157 }
 158 
 159 JNIEXPORT jlong JNICALL Java_mpi_Group_incl(
 160         JNIEnv *env, jobject jthis, jlong group, jintArray ranks)
 161 {
 162     jsize n = (*env)->GetArrayLength(env, ranks);
 163     jint *jRanks;
 164     int  *cRanks;
 165     ompi_java_getIntArray(env, ranks, &jRanks, &cRanks);
 166 
 167     MPI_Group newGroup;
 168     int rc = MPI_Group_incl((MPI_Group)group, n, cRanks, &newGroup);
 169     ompi_java_exceptionCheck(env, rc);
 170 
 171     ompi_java_forgetIntArray(env, ranks, jRanks, cRanks);
 172     return (jlong)newGroup;
 173 }
 174 
 175 JNIEXPORT jlong JNICALL Java_mpi_Group_excl(
 176         JNIEnv *env, jobject jthis, jlong group, jintArray ranks)
 177 {
 178     jsize n = (*env)->GetArrayLength(env, ranks);
 179     jint *jRanks;
 180     int  *cRanks;
 181     ompi_java_getIntArray(env, ranks, &jRanks, &cRanks);
 182 
 183     MPI_Group newGroup;
 184     int rc = MPI_Group_excl((MPI_Group)group, n, cRanks, &newGroup);
 185     ompi_java_exceptionCheck(env, rc);
 186 
 187     ompi_java_forgetIntArray(env, ranks, jRanks, cRanks);
 188     return (jlong)newGroup;
 189 }
 190 
 191 JNIEXPORT jlong JNICALL Java_mpi_Group_rangeIncl(
 192         JNIEnv *env, jobject jthis, jlong group, jobjectArray ranges)
 193 {
 194     int i;
 195     MPI_Group newGroup;
 196     jsize n = (*env)->GetArrayLength(env, ranges);
 197     int (*cRanges)[3] = (int(*)[3])calloc(n, sizeof(int[3]));
 198 
 199     for(i = 0; i < n; i++)
 200     {
 201         jintArray ri = (*env)->GetObjectArrayElement(env, ranges, i);
 202         jint *jri = (*env)->GetIntArrayElements(env, ri, NULL);
 203         cRanges[i][0] = jri[0];
 204         cRanges[i][1] = jri[1];
 205         cRanges[i][2] = jri[2];
 206         (*env)->ReleaseIntArrayElements(env, ri, jri, JNI_ABORT);
 207         (*env)->DeleteLocalRef(env, ri);
 208     }
 209 
 210     int rc = MPI_Group_range_incl((MPI_Group)group, n, cRanges, &newGroup);
 211     ompi_java_exceptionCheck(env, rc);
 212     free(cRanges);
 213     return (jlong)newGroup;
 214 }
 215 
 216 JNIEXPORT jlong JNICALL Java_mpi_Group_rangeExcl(
 217         JNIEnv *env, jobject jthis, jlong group, jobjectArray ranges)
 218 {
 219     int i;
 220     MPI_Group newGroup;
 221     jsize n = (*env)->GetArrayLength(env, ranges);
 222     int (*cRanges)[3] = (int(*)[3])calloc(n, sizeof(int[3]));
 223 
 224     for(i = 0; i < n; i++)
 225     {
 226         jintArray ri = (*env)->GetObjectArrayElement(env, ranges, i);
 227         jint *jri = (*env)->GetIntArrayElements(env, ri, NULL);
 228         cRanges[i][0] = jri[0];
 229         cRanges[i][1] = jri[1];
 230         cRanges[i][2] = jri[2];
 231         (*env)->ReleaseIntArrayElements(env, ri, jri, JNI_ABORT);
 232         (*env)->DeleteLocalRef(env, ri);
 233     }
 234 
 235     int rc = MPI_Group_range_excl((MPI_Group)group, n, cRanges, &newGroup);
 236     ompi_java_exceptionCheck(env, rc);
 237     free(cRanges);
 238     return (jlong)newGroup;
 239 }