Discussion :

[xantares]

Bonjour,

Ptite question à propos de la librairie parallèle.

Pour un communicateur cartésienn, y'a-t-il une fonction pour trouver l'index d'un processeur voisin à partir d'un déplacement selon plusieurs directions ?

Il existe bien MPI_Cart_shift qui le permet selon une seule direction à partir du déplacement n pour trouver le processeur (x'=x+n,y'=y,z'=z) par exemple.

Ca existe pour l'index du processeur (x'=x+nx,y'=y+nz,z'=z+nz) ?

x.

[xantares]

Tant pis, j'ai bricolé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
/**
* \brief Generalized cartesian shift
* \param[in] comm communicator with cartesian structure (handle)
* \param[in] maxdims length of vector displ in the calling program (integer) 
* \param[in] displ[maxdims] displacement (array of integer)
* \param[out] source rank of source process (integer)
* \param[out] dest rank of destination process (integer)
*/
void par_Cart_shift_generalized (MPI_Comm comm, int maxdims, int *displ, int *source, int *dest);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
void par_Cart_shift_generalized (MPI_Comm comm, int maxdims, int *displ, int *source, int *dest) {
  int i;
  int *source_coords, *dest_coords;
  int *dims;
  int *periods;
  int source_inside = 1, dest_inside = 1;
 
  source_coords = (int*) malloc(maxdims * sizeof(int));
  dest_coords = (int*) malloc(maxdims * sizeof(int));
  dims = (int*) malloc(maxdims * sizeof(int));
  periods = (int*) malloc(maxdims * sizeof(int));
 
  MPI_Cart_get (comm, maxdims, dims, periods, source_coords);
  memcpy(dest_coords, source_coords, maxdims * sizeof(int));
 
  for(i = 0; i < maxdims; ++ i) {
 
    source_coords[i] -= displ[i];
    if(periods[i]) {
      source_coords[i] %= dims[i];
    }
    else {
      if((source_coords[i] < 0) || (source_coords[i] >= dims[i])) {
        source_inside = 0;
      }
    }
 
    dest_coords[i] += displ[i];
    if(periods[i]) {
      dest_coords[i] %= dims[i];
    }
    else {
      if((dest_coords[i] < 0) || (dest_coords[i] >= dims[i])) {
        dest_inside = 0;
      }
    }
  }
 
  if(source_inside) {
    MPI_Cart_rank (cart_comm, source_coords, source);
  }
  else {
    *source = MPI_PROC_NULL;
  }
 
  if(dest_inside) {
    MPI_Cart_rank (cart_comm, dest_coords, dest);
  }
  else {
    *dest = MPI_PROC_NULL;
  }
 
  free (source_coords);
  free (dest_coords);
  free (dims);
  free (periods);
}