root/ompi/mpi/java/java/Group.java

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

DEFINITIONS

This source file includes following definitions.
  1. init
  2. getEmpty
  3. getSize
  4. getSize
  5. getRank
  6. getRank
  7. free
  8. free
  9. isNull
  10. translateRanks
  11. translateRanks
  12. compare
  13. compare
  14. intersection
  15. intersection
  16. difference
  17. difference
  18. incl
  19. incl
  20. excl
  21. excl
  22. rangeIncl
  23. rangeIncl
  24. rangeExcl
  25. 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 (c) 2015      Los Alamos National Security, LLC. All rights
  13  *                         reserved.
  14  * $COPYRIGHT$
  15  *
  16  * Additional copyrights may follow
  17  *
  18  * $HEADER$
  19  *
  20  *
  21  * This file is almost a complete re-write for Open MPI compared to the
  22  * original mpiJava package. Its license and copyright are listed below.
  23  * See <path to ompi/mpi/java/README> for more information.
  24  *
  25  *
  26  *  Licensed under the Apache License, Version 2.0 (the "License");
  27  *  you may not use this file except in compliance with the License.
  28  *  You may obtain a copy of the License at
  29  *
  30  *     http://www.apache.org/licenses/LICENSE-2.0
  31  *
  32  *  Unless required by applicable law or agreed to in writing, software
  33  *  distributed under the License is distributed on an "AS IS" BASIS,
  34  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  35  *  See the License for the specific language governing permissions and
  36  *  limitations under the License.
  37  *
  38  *
  39  * File         : Group.java
  40  * Author       : Xinying Li, Bryan Carpenter
  41  * Created      : Thu Apr  9 12:22:15 1998
  42  * Revision     : $Revision: 1.8 $
  43  * Updated      : $Date: 2003/01/16 16:39:34 $
  44  * Copyright: Northeast Parallel Architectures Center
  45  *            at Syracuse University 1998
  46  */
  47 
  48 package mpi;
  49 
  50 /**
  51  * This class represents {@code MPI_Group}.
  52  */
  53 public final class Group implements Freeable
  54 {
  55         protected long handle;
  56         private static long nullHandle;
  57 
  58         static
  59         {
  60                 init();
  61         }
  62 
  63         private static native void init();
  64 
  65         protected static native long getEmpty();
  66 
  67         protected Group(long handle)
  68         {
  69                 this.handle = handle;
  70         }
  71 
  72         /**
  73          * Java binding of the MPI operation {@code MPI_GROUP_SIZE}.
  74          * @return number of processes in the group
  75          * @throws MPIException Signals that an MPI exception of some sort has occurred.
  76          */
  77         public int getSize() throws MPIException
  78         {
  79                 MPI.check();
  80                 return getSize(handle);
  81         }
  82 
  83         private native int getSize(long group) throws MPIException;
  84 
  85         /**
  86          * Rank of this process in the group.
  87          * <p>Java binding of the MPI operation {@code MPI_GROUP_RANK}.
  88          * @return rank of this process in the group, or {@code MPI.UNDEFINED}
  89          *         if this process is not a member of the group.
  90          * @throws MPIException Signals that an MPI exception of some sort has occurred.
  91          */
  92         public int getRank() throws MPIException
  93         {
  94                 MPI.check();
  95                 return getRank(handle);
  96         }
  97 
  98         private native int getRank(long group) throws MPIException;
  99 
 100         /**
 101          * Java binding of the MPI operation {@code MPI_GROUP_FREE}.
 102          */
 103         @Override public void free() throws MPIException
 104         {
 105                 MPI.check();
 106                 handle = free(handle);
 107         }
 108 
 109         private native long free(long group);
 110 
 111         /**
 112          * Test if group object is null.
 113          * @return true if the group object is null.
 114          */
 115         public boolean isNull()
 116         {
 117                 return handle == nullHandle;
 118         }
 119 
 120         /**
 121          * Translate ranks within one group to ranks within another.
 122          * <p>Java binding of the MPI operation {@code MPI_GROUP_TRANSLATE_RANKS}.
 123          * <p>Result elements are {@code MPI.UNDEFINED} where no correspondence exists.
 124          * @param group1 a group
 125          * @param ranks1 array of valid ranks in group1
 126          * @param group2 another group
 127          * @return array of corresponding ranks in group2
 128          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 129          */
 130         public static int[] translateRanks(Group group1, int[] ranks1, Group group2)
 131                         throws MPIException
 132         {
 133                 MPI.check();
 134                 return translateRanks(group1.handle, ranks1, group2.handle);
 135         }
 136 
 137         private static native int[] translateRanks(
 138                         long group1, int[] ranks1, long group2) throws MPIException;
 139 
 140         /**
 141          * Compare two groups.
 142          * <p>Java binding of the MPI operation {@code MPI_GROUP_COMPARE}.
 143          * @param group1 first group
 144          * @param group2 second group
 145          * @return {@code MPI.IDENT} if the group members and group order are exactly
 146          *         the same in both groups, {@code MPI.SIMILAR} if the group members are
 147          *         the same but the order is different, {@code MPI.UNEQUAL} otherwise.
 148          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 149          */
 150         public static int compare(Group group1, Group group2) throws MPIException
 151         {
 152                 MPI.check();
 153                 return compare(group1.handle, group2.handle);
 154         }
 155 
 156         private static native int compare(long group1, long group2) throws MPIException;
 157 
 158         /**
 159          * Set union of two groups.
 160          * <p>Java binding of the MPI operation {@code MPI_GROUP_UNION}.
 161          * @param group1 first group
 162          * @param group2 second group
 163          * @return union group
 164          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 165          */
 166         public static Group union(Group group1, Group group2) throws MPIException
 167         {
 168                 MPI.check();
 169                 return new Group(union(group1.handle, group2.handle));
 170         }
 171 
 172         private static native long union(long group1, long group2);
 173 
 174         /**
 175          * Set intersection of two groups.
 176          * Java binding of the MPI operation {@code MPI_GROUP_INTERSECTION}.
 177          * @param group1 first group
 178          * @param group2 second group
 179          * @return intersection group
 180          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 181          */
 182         public static Group intersection(Group group1, Group group2) throws MPIException
 183         {
 184                 MPI.check();
 185                 return new Group(intersection(group1.handle, group2.handle));
 186         }
 187 
 188         private static native long intersection(long group1, long group2);
 189 
 190         /**
 191          * Set difference of two groups.
 192          * Java binding of the MPI operation {@code MPI_GROUP_DIFFERENCE}.
 193          * @param group1 first group
 194          * @param group2 second group
 195          * @return difference group
 196          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 197          */
 198         public static Group difference(Group group1, Group group2) throws MPIException
 199         {
 200                 MPI.check();
 201                 return new Group(difference(group1.handle, group2.handle));
 202         }
 203 
 204         private static native long difference(long group1, long group2);
 205 
 206         /**
 207          * Create a subset group including specified processes.
 208          * <p>Java binding of the MPI operation {@code MPI_GROUP_INCL}.
 209          * @param ranks ranks from this group to appear in new group
 210          * @return new group
 211          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 212          */
 213         public Group incl(int[] ranks) throws MPIException
 214         {
 215                 MPI.check();
 216                 return new Group(incl(handle, ranks));
 217         }
 218 
 219         private native long incl(long group, int[] ranks);
 220 
 221         /**
 222          * Create a subset group excluding specified processes.
 223          * <p>Java binding of the MPI operation {@code MPI_GROUP_EXCL}.
 224          * @param ranks ranks from this group <em>not</em> to appear in new group
 225          * @return new group
 226          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 227          */
 228         public Group excl(int[] ranks) throws MPIException
 229         {
 230                 MPI.check();
 231                 return new Group(excl(handle, ranks));
 232         }
 233 
 234         private native long excl(long group, int[] ranks);
 235 
 236         /**
 237          * Create a subset group including processes specified
 238          * by strided intervals of ranks.
 239          * <p>Java binding of the MPI operation {@code MPI_GROUP_RANGE_INCL}.
 240          * <p>The triplets are of the form (first rank, last rank, stride)
 241          * indicating ranks in this group to be included in the new group.
 242          * The size of the first dimension of {@code ranges} is the number
 243          * of triplets.  The size of the second dimension is 3.
 244          * @param ranges array of integer triplets
 245          * @return new group
 246          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 247          */
 248         public Group rangeIncl(int[][] ranges) throws MPIException
 249         {
 250                 MPI.check();
 251                 return new Group(rangeIncl(handle, ranges));
 252         }
 253 
 254         private native long rangeIncl(long group, int[][] ranges);
 255 
 256         /**
 257          * Create a subset group excluding processes specified
 258          * by strided intervals of ranks.
 259          * <p>Java binding of the MPI operation {@code MPI_GROUP_RANGE_EXCL}.
 260          * <p>Triplet array is defined as for {@code rangeIncl}, the ranges
 261          * indicating ranks in this group to be excluded from the new group.
 262          * @param ranges array of integer triplets
 263          * @return new group
 264          * @throws MPIException Signals that an MPI exception of some sort has occurred.
 265          */
 266         public Group rangeExcl(int[][] ranges) throws MPIException
 267         {
 268                 MPI.check();
 269                 return new Group(rangeExcl(handle, ranges));
 270         }
 271 
 272         private native long rangeExcl(long group, int[][] ranges);
 273 
 274 } // Group

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