configuration.c 13 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mpi.h>
#include "../IOcodes/read_ini.h"
#include "configuration.h"
#include "../malleability/spawn_methods/ProcessDist.h"
#include "../malleability/distribution_methods/block_distribution.h"

void malloc_config_resizes(configuration *user_config);
11
void malloc_config_stages(configuration *user_config);
12

13
14
15
void def_struct_config_file(configuration *config_file);
void def_struct_groups(configuration *config_file);
void def_struct_iter_stage(configuration *config_file);
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/*
 * Inicializa una estructura de configuracion
 *
 * Si el parametro "file_name" no es nulo,
 * se obtiene la configuracion a partir de 
 * un fichero .ini
 *
 * En caso de que sea nulo, es el usuario
 * el que tiene que elegir los valores a
 * utilizar.
 */
void init_config(char *file_name, configuration **user_config) {
  if(file_name != NULL) {
    ext_functions_t mallocs;
    mallocs.resizes_f = malloc_config_resizes;
32
    mallocs.stages_f = malloc_config_stages;
33
34
35
36
37
    *user_config = read_ini_file(file_name, mallocs);
  } else {
    configuration *config = NULL;

    config = malloc(sizeof(configuration));
38
39
    config->n_resizes=0;
    config->n_groups=1;
40
41
42
    malloc_config_resizes(config);
    config->n_stages=1;
    malloc_config_stages(config);
43
44
45
46
47
48
49
    if(config == NULL) {
        perror("Error when reserving configuration structure\n");
	MPI_Abort(MPI_COMM_WORLD, -3);
	return;
    }
    *user_config=config;
  }
50
  def_struct_config_file(*user_config);
51
52
53
54
55
56
57
58
59
60
}

/*
 * Reserva de memoria para los vectores de la estructura de configuracion
 *
 * Si se llama desde fuera de este fichero, la memoria de la estructura
 * tiene que reservarse con la siguiente linea:
 * "configuration *config = malloc(sizeof(configuration));"
 *
 * Sin embargo se puede obtener a traves de las funciones
61
 *  - init_config
62
63
64
 *  - recv_config_file
 */
void malloc_config_resizes(configuration *user_config) {
65
  size_t i;
66
  if(user_config != NULL) {
67
68
    user_config->groups = malloc(sizeof(group_config_t) * user_config->n_groups);
    for(i=0; i<user_config->n_groups; i++) {
69
70
71
72
73
      user_config->groups[i].iters = 0;
      user_config->groups[i].procs = 1;
      user_config->groups[i].sm = 0;
      user_config->groups[i].ss = 1;
      user_config->groups[i].phy_dist = 0;
74
75
      user_config->groups[i].rm = 0;
      user_config->groups[i].rs = 1;
76
77
      user_config->groups[i].factor = 1;
    }
78
    def_struct_groups(user_config);
79
80
81
82
83
84
85
86
87
  }
}

/*
 * Inicializa la memoria para las fases de iteraciones.
 * No se reserva memoria, pero si se pone a NULL
 * para poder liberar correctamente cada fase.
 *
 * Se puede obtener a traves de las funciones
88
 *  - init_config
89
90
 *  - recv_config_file
 */
91
void malloc_config_stages(configuration *user_config) {
92
  size_t i;
93
  if(user_config != NULL) {
94
    user_config->stages = malloc(sizeof(iter_stage_t) * user_config->n_stages);
95
96
97
98
99
    for(i=0; i<user_config->n_stages; i++) {
      user_config->stages[i].array = NULL;
      user_config->stages[i].full_array = NULL;
      user_config->stages[i].double_array = NULL;
      user_config->stages[i].counts.counts = NULL;
100
101
      user_config->stages[i].bytes = 0;
      user_config->stages[i].my_bytes = 0;
102
      user_config->stages[i].real_bytes = 0;
103
104
105
106
      user_config->stages[i].operations = 0;
      user_config->stages[i].pt = 0;
      user_config->stages[i].t_op = 0;
      user_config->stages[i].t_stage = 0;
107
      user_config->stages[i].t_capped = 0;
108
    }
109
    def_struct_iter_stage(user_config);
110
  }
111
112
113
114
115
116
117
}


/*
 * Libera toda la memoria de una estructura de configuracion
 */
void free_config(configuration *user_config) {
118
    size_t i;
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
    if(user_config != NULL) {
      for(i=0; i < user_config->n_stages; i++) {
	
        if(user_config->stages[i].array != NULL) {
          free(user_config->stages[i].array);
          user_config->stages[i].array = NULL;
	}
        if(user_config->stages[i].full_array != NULL) {
          free(user_config->stages[i].full_array);
          user_config->stages[i].full_array = NULL;
	}
        if(user_config->stages[i].double_array != NULL) {
          free(user_config->stages[i].double_array);
          user_config->stages[i].double_array = NULL;
	}
        if(user_config->stages[i].counts.counts != NULL) {
	  freeCounts(&(user_config->stages[i].counts));
	}
      }
138
      //Liberar tipos derivados
139
140
141
142
143
144
145
146
      MPI_Type_free(&(user_config->config_type));
      user_config->config_type = MPI_DATATYPE_NULL;

      MPI_Type_free(&(user_config->group_type));
      user_config->group_type = MPI_DATATYPE_NULL;

      MPI_Type_free(&(user_config->iter_stage_type));
      user_config->iter_stage_type = MPI_DATATYPE_NULL;
147
      
148
      free(user_config->groups);
149
      free(user_config->stages);
150
151
152
153
154
155
156
157
158
      free(user_config);
    }
}


/*
 * Imprime por salida estandar toda la informacion que contiene
 * la configuracion pasada como argumento
 */
159
void print_config(configuration *user_config) {
160
  if(user_config != NULL) {
161
    size_t i;
162
    printf("Config loaded: R=%zu, S=%zu, granularity=%d, SDR=%zu, ADR=%zu\n",
163
        user_config->n_resizes, user_config->n_stages, user_config->granularity, user_config->sdr, user_config->adr);
164
    for(i=0; i<user_config->n_stages; i++) {
165
166
      printf("Stage %zu: PT=%d, T_stage=%lf, bytes=%d, T_capped=%d\n",
        i, user_config->stages[i].pt, user_config->stages[i].t_stage, user_config->stages[i].real_bytes, user_config->stages[i].t_capped);
167
    }
168
    for(i=0; i<user_config->n_groups; i++) {
169
      printf("Group %zu: Iters=%d, Procs=%d, Factors=%f, Dist=%d, RM=%d, RS=%d, SM=%d, SS=%d\n",
170
        i, user_config->groups[i].iters, user_config->groups[i].procs, user_config->groups[i].factor, 
171
172
	user_config->groups[i].phy_dist, user_config->groups[i].rm, user_config->groups[i].rs,
	user_config->groups[i].sm, user_config->groups[i].ss);
173
174
175
176
177
178
179
180
181
    }
  }
}


/*
 * Imprime por salida estandar la informacion relacionada con un
 * solo grupo de procesos en su configuracion.
 */
182
183
void print_config_group(configuration *user_config, size_t grp) {
  size_t i;
184
185
186
187
  if(user_config != NULL) {
    int parents, sons;
    parents = sons = 0;
    if(grp > 0) {
188
      parents = user_config->groups[grp-1].procs;
189
    }
190
    if(grp < user_config->n_groups - 1) {
191
      sons = user_config->groups[grp+1].procs;
192
193
    }

194
    printf("Config: granularity=%d, SDR=%zu, ADR=%zu\n",
195
        user_config->granularity, user_config->sdr, user_config->adr);
196
    for(i=0; i<user_config->n_stages; i++) {
197
198
      printf("Stage %zu: PT=%d, T_stage=%lf, bytes=%d, T_capped=%d\n",
        i, user_config->stages[i].pt, user_config->stages[i].t_stage, user_config->stages[i].real_bytes, user_config->stages[i].t_capped);
199
    }
200
    printf("Group %zu: Iters=%d, Procs=%d, Factors=%f, Dist=%d, RM=%d, RS=%d, SM=%d, SS=%d, parents=%d, children=%d\n",
201
      grp, user_config->groups[grp].iters, user_config->groups[grp].procs, user_config->groups[grp].factor,
202
203
      user_config->groups[grp].phy_dist, user_config->groups[grp].rm, user_config->groups[grp].rs,
      user_config->groups[grp].sm, user_config->groups[grp].ss, parents, sons);
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
  }
}


//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
//| FUNCIONES DE INTERCOMUNICACION DE ESTRUCTURA DE CONFIGURACION ||
//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| |/

/*
 * Envia una estructura de configuracion al grupo de procesos al que se 
 * enlaza este grupo a traves del intercomunicador pasado como argumento.
 *
 * Esta funcion tiene que ser llamada por todos los procesos del mismo grupo
 * e indicar cual es el proceso raiz que se encargara de enviar la
 * configuracion al otro grupo.
 */
void send_config_file(configuration *config_file, int root, MPI_Comm intercomm) {
223
224
225
  MPI_Bcast(config_file, 1, config_file->config_type, root, intercomm);
  MPI_Bcast(config_file->groups, config_file->n_groups, config_file->group_type, root, intercomm);
  MPI_Bcast(config_file->stages, config_file->n_stages, config_file->iter_stage_type, root, intercomm);
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
}



/*
 * Recibe una estructura de configuracion desde otro grupo de procesos
 * y la devuelve. La memoria de la estructura se reserva en esta funcion.
 *
 * Esta funcion tiene que ser llamada por todos los procesos del mismo grupo
 * e indicar cual es el proceso raiz del otro grupo que se encarga de enviar
 * la configuracion a este grupo.
 *
 * La memoria de la configuracion devuelta tiene que ser liberada con
 * la funcion "free_config".
 */
void recv_config_file(int root, MPI_Comm intercomm, configuration **config_file_out) {
242
243
  configuration *config_file = malloc(sizeof(configuration));
  def_struct_config_file(config_file);
244

245
  MPI_Bcast(config_file, 1, config_file->config_type, root, intercomm);
246
247

  //Inicializado de estructuras internas
248
  config_file->n_resizes = config_file->n_groups-1;
249
250
  malloc_config_resizes(config_file); // Inicializar valores de grupos
  malloc_config_stages(config_file); // Inicializar a NULL vectores stage
251

252
253
  MPI_Bcast(config_file->groups, config_file->n_groups, config_file->group_type, root, intercomm);
  MPI_Bcast(config_file->stages, config_file->n_stages, config_file->iter_stage_type, root, intercomm);
254
255
256
257
258
259

  *config_file_out = config_file;
}


/*
260
 * Tipo derivado para enviar 6 elementos especificos
261
262
 * de la estructura de configuracion con una sola comunicacion.
 */
263
void def_struct_config_file(configuration *config_file) {
264
265
  int i, counts = 6;
  int blocklengths[6] = {1, 1, 1, 1, 1, 1};
266
267
268
269
  MPI_Aint displs[counts], dir;
  MPI_Datatype types[counts];

  // Rellenar vector types
270
271
  types[0] = types[1] = types[2] = types[3] = MPI_UNSIGNED_LONG;
  types[4] = types[5] = MPI_INT;
272
273
274
275

  // Rellenar vector displs
  MPI_Get_address(config_file, &dir);

276
  MPI_Get_address(&(config_file->n_groups), &displs[0]);
277
  MPI_Get_address(&(config_file->n_stages), &displs[1]);
278
279
280
  MPI_Get_address(&(config_file->sdr), &displs[2]);
  MPI_Get_address(&(config_file->adr), &displs[3]);
  MPI_Get_address(&(config_file->granularity), &displs[4]);
281
  MPI_Get_address(&(config_file->rigid_times), &displs[5]);
282
283
284

  for(i=0;i<counts;i++) displs[i] -= dir;

285
286
  MPI_Type_create_struct(counts, blocklengths, displs, types, &(config_file->config_type));
  MPI_Type_commit(&(config_file->config_type));
287
288
289
}

/*
290
291
292
 * Tipo derivado para enviar elementos especificos
 * de la estructuras de la configuracion de cada grupo 
 * en una sola comunicacion.
293
 */
294
void def_struct_groups(configuration *config_file) {
295
296
  int i, counts = 8;
  int blocklengths[8] = {1, 1, 1, 1, 1, 1, 1, 1};
297
298
  MPI_Aint displs[counts], dir;
  MPI_Datatype aux, types[counts];
299
  group_config_t *groups = config_file->groups;
300
301

  // Rellenar vector types
302
303
  types[0] = types[1] = types[2] = types[3] = types[4] = types[5] = types[6] = MPI_INT;
  types[7] = MPI_FLOAT;
304

305
306
  // Rellenar vector displs
  MPI_Get_address(groups, &dir);
307

308
309
310
311
312
  MPI_Get_address(&(groups->iters), &displs[0]);
  MPI_Get_address(&(groups->procs), &displs[1]);
  MPI_Get_address(&(groups->sm), &displs[2]);
  MPI_Get_address(&(groups->ss), &displs[3]);
  MPI_Get_address(&(groups->phy_dist), &displs[4]);
313
314
315
  MPI_Get_address(&(groups->rm), &displs[5]);
  MPI_Get_address(&(groups->rs), &displs[6]);
  MPI_Get_address(&(groups->factor), &displs[7]);
316
317
318

  for(i=0;i<counts;i++) displs[i] -= dir;

319
320
321
  if (config_file->n_groups == 1) {
    MPI_Type_create_struct(counts, blocklengths, displs, types, &(config_file->group_type));
    MPI_Type_commit(&(config_file->group_type));
322
323
324
  } else { // Si hay mas de una fase(estructura), el "extent" se modifica.
    MPI_Type_create_struct(counts, blocklengths, displs, types, &aux);
    // Tipo derivado para enviar N elementos de la estructura
325
326
    MPI_Type_create_resized(aux, 0, sizeof(group_config_t), &(config_file->group_type));
    MPI_Type_commit(&(config_file->group_type));
327
    MPI_Type_free(&aux);
328
  }
329
330
331
332
333
334
}

/*
 * Tipo derivado para enviar elementos especificos
 * de la estructuras de fases de iteracion en una sola comunicacion.
 */
335
void def_struct_iter_stage(configuration *config_file) {
336
337
  int i, counts = 5;
  int blocklengths[5] = {1, 1, 1, 1, 1};
338
339
  MPI_Aint displs[counts], dir;
  MPI_Datatype aux, types[counts];
340
  iter_stage_t *stages = config_file->stages;
341
342

  // Rellenar vector types
343
344
  types[0] = types[1] = types[2] = MPI_INT;
  types[3] = types[4] = MPI_DOUBLE;
345
346
347
348
349

  // Rellenar vector displs
  MPI_Get_address(stages, &dir);

  MPI_Get_address(&(stages->pt), &displs[0]);
350
351
352
353
  MPI_Get_address(&(stages->bytes), &displs[1]);
  MPI_Get_address(&(stages->t_capped), &displs[2]);
  MPI_Get_address(&(stages->t_stage), &displs[3]);
  MPI_Get_address(&(stages->t_op), &displs[4]);
354
355
356

  for(i=0;i<counts;i++) displs[i] -= dir;

357
358
359
  if (config_file->n_stages == 1) {
    MPI_Type_create_struct(counts, blocklengths, displs, types, &(config_file->iter_stage_type));
    MPI_Type_commit(&(config_file->iter_stage_type));
360
361
362
  } else { // Si hay mas de una fase(estructura), el "extent" se modifica.
    MPI_Type_create_struct(counts, blocklengths, displs, types, &aux);
    // Tipo derivado para enviar N elementos de la estructura
363
364
    MPI_Type_create_resized(aux, 0, sizeof(iter_stage_t), &(config_file->iter_stage_type)); 
    MPI_Type_commit(&(config_file->iter_stage_type));
365
    MPI_Type_free(&aux);
366
367
  }
}