root/ompi/mpi/java/c/mpi_Datatype.c

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

DEFINITIONS

This source file includes following definitions.
  1. Java_mpi_Datatype_init
  2. Java_mpi_Datatype_getDatatype
  3. Java_mpi_Datatype_getLbExtent
  4. Java_mpi_Datatype_getTrueLbExtent
  5. Java_mpi_Datatype_getSize
  6. Java_mpi_Datatype_commit
  7. Java_mpi_Datatype_free
  8. Java_mpi_Datatype_dup
  9. Java_mpi_Datatype_getContiguous
  10. Java_mpi_Datatype_getVector
  11. Java_mpi_Datatype_getHVector
  12. Java_mpi_Datatype_getIndexed
  13. Java_mpi_Datatype_getHIndexed
  14. Java_mpi_Datatype_getStruct
  15. Java_mpi_Datatype_getResized
  16. Java_mpi_Datatype_setName
  17. Java_mpi_Datatype_getName
  18. typeCopyAttr
  19. typeDeleteAttr
  20. Java_mpi_Datatype_createKeyval_1jni
  21. Java_mpi_Datatype_freeKeyval_1jni
  22. Java_mpi_Datatype_setAttr
  23. Java_mpi_Datatype_getAttr
  24. Java_mpi_Datatype_deleteAttr
   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) 2016      Los Alamos National Security, LLC. All rights
  13  *                         reserved.
  14  * Copyright (c) 2018      Research Organization for Information Science
  15  *                         and Technology (RIST).  All rights reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 /*
  23  * This file is almost a complete re-write for Open MPI compared to the
  24  * original mpiJava package. Its license and copyright are listed below.
  25  * See <path to ompi/mpi/java/README> for more information.
  26  */
  27 /*
  28     Licensed under the Apache License, Version 2.0 (the "License");
  29     you may not use this file except in compliance with the License.
  30     You may obtain a copy of the License at
  31 
  32        http://www.apache.org/licenses/LICENSE-2.0
  33 
  34     Unless required by applicable law or agreed to in writing, software
  35     distributed under the License is distributed on an "AS IS" BASIS,
  36     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  37     See the License for the specific language governing permissions and
  38     limitations under the License.
  39 */
  40 /*
  41  * File         : mpi_Datatype.c
  42  * Headerfile   : mpi_Datatype.h
  43  * Author       : Sung-Hoon Ko, Xinying Li, Sang Lim, Bryan Carpenter
  44  * Created      : Thu Apr  9 12:22:15 1998
  45  * Revision     : $Revision: 1.10 $
  46  * Updated      : $Date: 2003/01/16 16:39:34 $
  47  * Copyright: Northeast Parallel Architectures Center
  48  *            at Syracuse University 1998
  49  */
  50 #include "ompi_config.h"
  51 
  52 #include <stdlib.h>
  53 #ifdef HAVE_TARGETCONDITIONALS_H
  54 #include <TargetConditionals.h>
  55 #endif
  56 
  57 #include "mpi.h"
  58 #include "mpi_Datatype.h"
  59 #include "mpiJava.h"
  60 
  61 MPI_Datatype Dts[] = { MPI_DATATYPE_NULL,  /* NULL */
  62                        MPI_UINT8_T,  /* BYTE */
  63                        MPI_UINT16_T, /* CHAR */
  64                        MPI_INT16_T,  /* SHORT */
  65                        MPI_UINT8_T,  /* BOOLEAN (let's hope Java is
  66                                         one byte..) */
  67                        MPI_INT32_T,  /* INT */
  68                        MPI_INT64_T,  /* LONG */
  69                        MPI_FLOAT,    /* FLOAT (let's hope it's the same!) */
  70                        MPI_DOUBLE,   /* DOUBLE (let's hoe it's the same!) */
  71                        MPI_PACKED,   /* PACKED */
  72                        MPI_2INT,
  73                        MPI_SHORT_INT,
  74                        MPI_LONG_INT,
  75                        MPI_FLOAT_INT,
  76                        MPI_DOUBLE_INT,
  77                        MPI_C_FLOAT_COMPLEX,
  78                        MPI_C_DOUBLE_COMPLEX
  79 };
  80 
  81 JNIEXPORT void JNICALL Java_mpi_Datatype_init(JNIEnv *e, jclass clazz)
  82 {
  83     ompi_java.DatatypeHandle   = (*e)->GetFieldID(e, clazz, "handle",   "J");
  84     ompi_java.DatatypeBaseType = (*e)->GetFieldID(e, clazz, "baseType", "I");
  85     ompi_java.DatatypeBaseSize = (*e)->GetFieldID(e, clazz, "baseSize", "I");
  86 }
  87 
  88 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getDatatype(
  89                         JNIEnv *e, jobject jthis, jint type)
  90 {
  91     return (jlong)Dts[type];
  92 }
  93 
  94 JNIEXPORT void JNICALL Java_mpi_Datatype_getLbExtent(
  95         JNIEnv *env, jobject jthis, jlong type, jintArray jLbExt)
  96 {
  97     MPI_Aint lb, extent;
  98     int rc = MPI_Type_get_extent((MPI_Datatype)type, &lb, &extent);
  99     if(ompi_java_exceptionCheck(env, rc))
 100         return;
 101 
 102     jint *lbExt = (*env)->GetIntArrayElements(env, jLbExt, NULL);
 103     lbExt[0] = (jint)lb;
 104     lbExt[1] = (jint)extent;
 105     (*env)->ReleaseIntArrayElements(env, jLbExt, lbExt, 0);
 106 }
 107 
 108 JNIEXPORT void JNICALL Java_mpi_Datatype_getTrueLbExtent(
 109         JNIEnv *env, jobject jthis, jlong type, jintArray jLbExt)
 110 {
 111     MPI_Aint lb, extent;
 112     int rc = MPI_Type_get_true_extent((MPI_Datatype)type, &lb, &extent);
 113     if(ompi_java_exceptionCheck(env, rc))
 114         return;
 115 
 116     jint *lbExt = (*env)->GetIntArrayElements(env, jLbExt, NULL);
 117     lbExt[0] = (jint)lb;
 118     lbExt[1] = (jint)extent;
 119     (*env)->ReleaseIntArrayElements(env, jLbExt, lbExt, 0);
 120 }
 121 
 122 JNIEXPORT jint JNICALL Java_mpi_Datatype_getSize(
 123         JNIEnv *env, jobject jthis, jlong type)
 124 {
 125     int rc, result;
 126     rc = MPI_Type_size((MPI_Datatype)type, &result);
 127     ompi_java_exceptionCheck(env, rc);
 128     return result;
 129 }
 130 
 131 JNIEXPORT void JNICALL Java_mpi_Datatype_commit(
 132         JNIEnv *env, jobject jthis, jlong handle)
 133 {
 134     MPI_Datatype type = (MPI_Datatype)handle;
 135     int rc = MPI_Type_commit(&type);
 136     ompi_java_exceptionCheck(env, rc);
 137 }
 138 
 139 JNIEXPORT jlong JNICALL Java_mpi_Datatype_free(
 140         JNIEnv *env, jobject jthis, jlong handle)
 141 {
 142     MPI_Datatype type = (MPI_Datatype)handle;
 143 
 144     if(type != MPI_DATATYPE_NULL)
 145     {
 146         int rc = MPI_Type_free(&type);
 147         ompi_java_exceptionCheck(env, rc);
 148     }
 149 
 150     return (jlong)type;
 151 }
 152 
 153 JNIEXPORT jlong JNICALL Java_mpi_Datatype_dup(
 154         JNIEnv *env, jobject jthis, jlong oldType)
 155 {
 156     MPI_Datatype newType;
 157     int rc = MPI_Type_dup((MPI_Datatype)oldType, &newType);
 158     ompi_java_exceptionCheck(env, rc);
 159     return (jlong)newType;
 160 }
 161 
 162 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getContiguous(
 163         JNIEnv *env, jclass clazz, jint count, jlong oldType)
 164 {
 165     MPI_Datatype type;
 166     int rc = MPI_Type_contiguous(count, (MPI_Datatype)oldType, &type);
 167     ompi_java_exceptionCheck(env, rc);
 168     return (jlong)type;
 169 }
 170 
 171 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getVector(
 172             JNIEnv *env, jclass clazz, jint count,
 173             jint blockLength, jint stride, jlong oldType)
 174 {
 175     MPI_Datatype type;
 176 
 177     int rc = MPI_Type_vector(count, blockLength, stride,
 178                              (MPI_Datatype)oldType, &type);
 179 
 180     ompi_java_exceptionCheck(env, rc);
 181     return (jlong)type;
 182 }
 183 
 184 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getHVector(
 185         JNIEnv *env, jclass clazz, jint count,
 186         jint blockLength, jint stride, jlong oldType)
 187 {
 188     MPI_Datatype type;
 189 
 190     int rc = MPI_Type_create_hvector(count, blockLength, stride,
 191                                      (MPI_Datatype)oldType, &type);
 192 
 193     ompi_java_exceptionCheck(env, rc);
 194     return (jlong)type;
 195 }
 196 
 197 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getIndexed(
 198         JNIEnv *env, jclass clazz, jintArray blockLengths,
 199         jintArray disps, jlong oldType)
 200 {
 201     MPI_Datatype type;
 202     int count = (*env)->GetArrayLength(env, blockLengths);
 203 
 204     jint *jBlockLengths, *jDispl;
 205     int  *cBlockLengths, *cDispl;
 206     ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
 207     ompi_java_getIntArray(env, disps, &jDispl, &cDispl);
 208 
 209     int rc = MPI_Type_indexed(count, cBlockLengths, cDispl,
 210                               (MPI_Datatype)oldType, &type);
 211 
 212     ompi_java_exceptionCheck(env, rc);
 213     ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
 214     ompi_java_forgetIntArray(env, disps, jDispl, cDispl);
 215     return (jlong)type;
 216 }
 217 
 218 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getHIndexed(
 219         JNIEnv *env, jclass clazz, jintArray blockLengths,
 220         jintArray disps, jlong oldType)
 221 {
 222     MPI_Datatype type;
 223     int count = (*env)->GetArrayLength(env, blockLengths);
 224     jint *jBlockLengths;
 225     int  *cBlockLengths;
 226     ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
 227 
 228     jint     *jDisps = (*env)->GetIntArrayElements(env, disps, NULL);
 229     MPI_Aint *cDisps = (MPI_Aint*)calloc(count, sizeof(MPI_Aint));
 230     int i;
 231 
 232     for(i = 0; i < count; i++)
 233         cDisps[i] = jDisps[i];
 234 
 235     int rc = MPI_Type_create_hindexed(count, cBlockLengths, cDisps,
 236                                (MPI_Datatype)oldType, &type);
 237 
 238     ompi_java_exceptionCheck(env, rc);
 239     free(cDisps);
 240     ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
 241     (*env)->ReleaseIntArrayElements(env, disps, jDisps, JNI_ABORT);
 242     return (jlong)type;
 243 }
 244 
 245 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getStruct(
 246         JNIEnv *env, jclass clazz, jintArray blockLengths,
 247         jintArray disps, jobjectArray datatypes)
 248 {
 249     int count = (*env)->GetArrayLength(env, blockLengths);
 250     jint *jBlockLengths;
 251     int  *cBlockLengths;
 252     ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
 253 
 254     jint     *jDisps = (*env)->GetIntArrayElements(env, disps, NULL);
 255     MPI_Aint *cDisps = (MPI_Aint*)calloc(count, sizeof(MPI_Aint));
 256 
 257     MPI_Datatype *cTypes = (MPI_Datatype*)calloc(count, sizeof(MPI_Datatype));
 258     int i;
 259 
 260     for(i = 0; i < count; i++)
 261     {
 262         cDisps[i] = jDisps[i];
 263         jobject type = (*env)->GetObjectArrayElement(env, datatypes, i);
 264 
 265         cTypes[i] = (MPI_Datatype)(*env)->GetLongField(
 266                     env, type, ompi_java.DatatypeHandle);
 267 
 268         (*env)->DeleteLocalRef(env, type);
 269     }
 270 
 271     MPI_Datatype type;
 272     int rc = MPI_Type_create_struct(count, cBlockLengths, cDisps, cTypes, &type);
 273     ompi_java_exceptionCheck(env, rc);
 274 
 275     free(cDisps);
 276     free(cTypes);
 277     ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
 278     (*env)->ReleaseIntArrayElements(env, disps, jDisps, JNI_ABORT);
 279     return (jlong)type;
 280 }
 281 
 282 JNIEXPORT jlong JNICALL Java_mpi_Datatype_getResized(
 283         JNIEnv *env, jclass clazz, jlong oldType, jint lb, jint extent)
 284 {
 285     MPI_Datatype type;
 286     int rc = MPI_Type_create_resized((MPI_Datatype)oldType, lb, extent, &type);
 287     ompi_java_exceptionCheck(env, rc);
 288     return (jlong)type;
 289 }
 290 
 291 JNIEXPORT void JNICALL Java_mpi_Datatype_setName(
 292         JNIEnv *env, jobject jthis, jlong handle, jstring jname)
 293 {
 294     const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
 295     int rc = MPI_Type_set_name((MPI_Datatype)handle, (char*)name);
 296     ompi_java_exceptionCheck(env, rc);
 297     (*env)->ReleaseStringUTFChars(env, jname, name);
 298 }
 299 
 300 JNIEXPORT jstring JNICALL Java_mpi_Datatype_getName(
 301         JNIEnv *env, jobject jthis, jlong handle)
 302 {
 303     char name[MPI_MAX_OBJECT_NAME];
 304     int len;
 305     int rc = MPI_Type_get_name((MPI_Datatype)handle, name, &len);
 306 
 307     if(ompi_java_exceptionCheck(env, rc))
 308         return NULL;
 309 
 310     return (*env)->NewStringUTF(env, name);
 311 }
 312 
 313 static int typeCopyAttr(MPI_Datatype oldType, int keyval, void *extraState,
 314                         void *attrValIn, void *attrValOut, int *flag)
 315 {
 316     return ompi_java_attrCopy(attrValIn, attrValOut, flag);
 317 }
 318 
 319 static int typeDeleteAttr(MPI_Datatype oldType, int keyval,
 320                           void *attrVal, void *extraState)
 321 {
 322     return ompi_java_attrDelete(attrVal);
 323 }
 324 
 325 JNIEXPORT jint JNICALL Java_mpi_Datatype_createKeyval_1jni(
 326                        JNIEnv *env, jclass clazz)
 327 {
 328     int rc, keyval;
 329     rc = MPI_Type_create_keyval(typeCopyAttr, typeDeleteAttr, &keyval, NULL);
 330     ompi_java_exceptionCheck(env, rc);
 331     return keyval;
 332 }
 333 
 334 JNIEXPORT void JNICALL Java_mpi_Datatype_freeKeyval_1jni(
 335                        JNIEnv *env, jclass clazz, jint keyval)
 336 {
 337     int rc = MPI_Type_free_keyval((int*)(&keyval));
 338     ompi_java_exceptionCheck(env, rc);
 339 }
 340 
 341 JNIEXPORT void JNICALL Java_mpi_Datatype_setAttr(
 342         JNIEnv *env, jobject jthis, jlong type, jint keyval, jbyteArray jval)
 343 {
 344     void *cval = ompi_java_attrSet(env, jval);
 345     int rc = MPI_Type_set_attr((MPI_Datatype)type, keyval, cval);
 346     ompi_java_exceptionCheck(env, rc);
 347 }
 348 
 349 JNIEXPORT jobject JNICALL Java_mpi_Datatype_getAttr(
 350         JNIEnv *env, jobject jthis, jlong type, jint keyval)
 351 {
 352     int flag;
 353     void *val;
 354     int rc = MPI_Type_get_attr((MPI_Datatype)type, keyval, &val, &flag);
 355 
 356     if(ompi_java_exceptionCheck(env, rc) || !flag)
 357         return NULL;
 358 
 359     return ompi_java_attrGet(env, val);
 360 }
 361 
 362 JNIEXPORT void JNICALL Java_mpi_Datatype_deleteAttr(
 363         JNIEnv *env, jobject jthis, jlong type, jint keyval)
 364 {
 365     int rc = MPI_Type_delete_attr((MPI_Datatype)type, keyval);
 366     ompi_java_exceptionCheck(env, rc);
 367 }
/* [<][>][^][v][top][bottom][index][help] */