root/ompi/group/group_strided.c

DEFINITIONS

1. ompi_group_calc_strided
2. ompi_group_translate_ranks_strided
3. ompi_group_translate_ranks_strided_reverse
4. check_stride
5. ompi_group_incl_strided

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2005 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2006-2007 University of Houston. All rights reserved.
  14  * Copyright (c) 2007      Cisco Systems, Inc. All rights reserved.
  15  * Copyright (c) 2013      Los Alamos National Security, LLC.  All rights
  16  *                         reserved.
  17  * $COPYRIGHT$
  18  *
  19  * Additional copyrights may follow
  20  *
  21  * $HEADER$
  22  */
  23 
  24 #include "ompi_config.h"
  25 #include "ompi/group/group.h"
  26 #include "ompi/constants.h"
  27 #include "mpi.h"
  28 
  29 static int check_stride(const int[],int);
  30 
  31 int ompi_group_calc_strided ( int n , const int *ranks ) {
  32     if(-1 == check_stride(ranks,n)) {
  33         return -1;
  34     }
  35     else {
  36         return (sizeof(int)*3);
  37     }
  38 }
  39 
  40 /* from parent group to child group*/
  41 int ompi_group_translate_ranks_strided (ompi_group_t *parent_group,
  42                                         int n_ranks, const int *ranks1,
  43                                         ompi_group_t *child_group,
  44                                         int *ranks2)
  45 {
  46     int s,o,l,i;
  47     s = child_group->sparse_data.grp_strided.grp_strided_stride;
  48     o = child_group->sparse_data.grp_strided.grp_strided_offset;
  49     l = child_group->sparse_data.grp_strided.grp_strided_last_element;
  50     for (i = 0; i < n_ranks; i++) {
  51         if ( MPI_PROC_NULL == ranks1[i]) {
  52             ranks2[i] = MPI_PROC_NULL;
  53         }
  54         else {
  55             ranks2[i] = MPI_UNDEFINED;
  56 
  57             if ( (ranks1[i]-o) >= 0  && (ranks1[i]-o)%s == 0 && ranks1[i] <= l) {
  58                 ranks2[i] = (ranks1[i] - o)/s;
  59             }
  60         }
  61     }
  62     return OMPI_SUCCESS;
  63 }
  64 
  65 /* from child group to parent group*/
  66 int ompi_group_translate_ranks_strided_reverse (ompi_group_t *child_group,
  67                                                 int n_ranks, const int *ranks1,
  68                                                 ompi_group_t *parent_group,
  69                                                 int *ranks2)
  70 {
  71     int s,o,i;
  72     s = child_group->sparse_data.grp_strided.grp_strided_stride;
  73     o = child_group->sparse_data.grp_strided.grp_strided_offset;
  74     for (i = 0; i < n_ranks; i++) {
  75         if ( MPI_PROC_NULL == ranks1[i]) {
  76             ranks2[i] = MPI_PROC_NULL;
  77         }
  78         else {
  79             ranks2[i] =s*ranks1[i] + o;
  80         }
  81     }
  82     return OMPI_SUCCESS;
  83 }
  84 
  85 static int check_stride(const int incl[],int incllen) {
  86     int s,i;
  87     if (incllen > 1) {
  88         s = incl[1] - incl[0];
  89     }
  90     else {
  91         s = 1;
  92     }
  93     if( s < 0 ) {
  94         return -1;
  95     }
  96     for(i=0 ; i < incllen-1 ; i++) {
  97         if(incl[i+1] - incl[i] != s) {
  98             return -1;
  99         }
 100     }
 101     return s;
 102 }
 103 
 104 int ompi_group_incl_strided(ompi_group_t* group, int n, const int *ranks,
 105                             ompi_group_t **new_group)
 106 {
 107     /* local variables */
 108     int my_group_rank,stride;
 109     ompi_group_t *group_pointer, *new_group_pointer;
 110 
 111     group_pointer = (ompi_group_t *)group;
 112 
 113     if ( 0 == n ) {
 114         *new_group = MPI_GROUP_EMPTY;
 115         OBJ_RETAIN(MPI_GROUP_EMPTY);
 116         return OMPI_SUCCESS;
 117     }
 118 
 119     stride = check_stride(ranks,n);
 120     new_group_pointer = ompi_group_allocate_strided();
 121     if( NULL == new_group_pointer ) {
 122         return MPI_ERR_GROUP;
 123     }
 124     new_group_pointer -> grp_parent_group_ptr = group_pointer;
 125 
 126     OBJ_RETAIN(new_group_pointer -> grp_parent_group_ptr);
 127     ompi_group_increment_proc_count(new_group_pointer -> grp_parent_group_ptr);
 128 
 129     new_group_pointer -> sparse_data.grp_strided.grp_strided_stride = stride;
 130     new_group_pointer -> sparse_data.grp_strided.grp_strided_offset = ranks[0];
 131     new_group_pointer -> sparse_data.grp_strided.grp_strided_last_element = ranks[n-1];
 132     new_group_pointer -> grp_proc_count = n;
 133 
 134     ompi_group_increment_proc_count(new_group_pointer);
 135     my_group_rank = group_pointer->grp_my_rank;
 136     ompi_group_translate_ranks (new_group_pointer->grp_parent_group_ptr,1,&my_group_rank,
 137                                 new_group_pointer,&new_group_pointer->grp_my_rank);
 138 
 139     *new_group = (MPI_Group)new_group_pointer;
 140 
 141     return OMPI_SUCCESS;
 142 }