Introducción del código básico sin maleabilidad

Codes/IOcodes/ini.c

+/* inih -- simple .INI file parser
+
+SPDX-License-Identifier: BSD-3-Clause
+
+Copyright (C) 2009-2020, Ben Hoyt
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "ini.h"
+
+#if !INI_USE_STACK
+#if INI_CUSTOM_ALLOCATOR
+#include <stddef.h>
+void* ini_malloc(size_t size);
+void ini_free(void* ptr);
+void* ini_realloc(void* ptr, size_t size);
+#else
+#include <stdlib.h>
+#define ini_malloc malloc
+#define ini_free free
+#define ini_realloc realloc
+#endif
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Used by ini_parse_string() to keep track of string parsing state. */
+typedef struct {
+    const char* ptr;
+    size_t num_left;
+} ini_parse_string_ctx;
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+static char* rstrip(char* s)
+{
+    char* p = s + strlen(s);
+    while (p > s && isspace((unsigned char)(*--p)))
+        *p = '\0';
+    return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+static char* lskip(const char* s)
+{
+    while (*s && isspace((unsigned char)(*s)))
+        s++;
+    return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+   or pointer to NUL at end of string if neither found. Inline comment must
+   be prefixed by a whitespace character to register as a comment. */
+static char* find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+    int was_space = 0;
+    while (*s && (!chars || !strchr(chars, *s)) &&
+           !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+        was_space = isspace((unsigned char)(*s));
+        s++;
+    }
+#else
+    while (*s && (!chars || !strchr(chars, *s))) {
+        s++;
+    }
+#endif
+    return (char*)s;
+}
+
+/* Similar to strncpy, but ensures dest (size bytes) is
+   NUL-terminated, and doesn't pad with NULs. */
+static char* strncpy0(char* dest, const char* src, size_t size)
+{
+    /* Could use strncpy internally, but it causes gcc warnings (see issue #91) */
+    size_t i;
+    for (i = 0; i < size - 1 && src[i]; i++)
+        dest[i] = src[i];
+    dest[i] = '\0';
+    return dest;
+}
+
+/* See documentation in header file. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user)
+{
+    /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+    char line[INI_MAX_LINE];
+    int max_line = INI_MAX_LINE;
+#else
+    char* line;
+    size_t max_line = INI_INITIAL_ALLOC;
+#endif
+#if INI_ALLOW_REALLOC && !INI_USE_STACK
+    char* new_line;
+    size_t offset;
+#endif
+    char section[MAX_SECTION] = "";
+    char prev_name[MAX_NAME] = "";
+
+    char* start;
+    char* end;
+    char* name;
+    char* value;
+    int lineno = 0;
+    int error = 0;
+
+#if !INI_USE_STACK
+    line = (char*)ini_malloc(INI_INITIAL_ALLOC);
+    if (!line) {
+        return -2;
+    }
+#endif
+
+#if INI_HANDLER_LINENO
+#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
+#else
+#define HANDLER(u, s, n, v) handler(u, s, n, v)
+#endif
+
+    /* Scan through stream line by line */
+    while (reader(line, (int)max_line, stream) != NULL) {
+#if INI_ALLOW_REALLOC && !INI_USE_STACK
+        offset = strlen(line);
+        while (offset == max_line - 1 && line[offset - 1] != '\n') {
+            max_line *= 2;
+            if (max_line > INI_MAX_LINE)
+                max_line = INI_MAX_LINE;
+            new_line = ini_realloc(line, max_line);
+            if (!new_line) {
+                ini_free(line);
+                return -2;
+            }
+            line = new_line;
+            if (reader(line + offset, (int)(max_line - offset), stream) == NULL)
+                break;
+            if (max_line >= INI_MAX_LINE)
+                break;
+            offset += strlen(line + offset);
+        }
+#endif
+
+        lineno++;
+
+        start = line;
+#if INI_ALLOW_BOM
+        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+                           (unsigned char)start[1] == 0xBB &&
+                           (unsigned char)start[2] == 0xBF) {
+            start += 3;
+        }
+#endif
+        start = lskip(rstrip(start));
+
+        if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
+            /* Start-of-line comment */
+        }
+#if INI_ALLOW_MULTILINE
+        else if (*prev_name && *start && start > line) {
+            /* Non-blank line with leading whitespace, treat as continuation
+               of previous name's value (as per Python configparser). */
+            if (!HANDLER(user, section, prev_name, start) && !error)
+                error = lineno;
+        }
+#endif
+        else if (*start == '[') {
+            /* A "[section]" line */
+            end = find_chars_or_comment(start + 1, "]");
+            if (*end == ']') {
+                *end = '\0';
+                strncpy0(section, start + 1, sizeof(section));
+                *prev_name = '\0';
+#if INI_CALL_HANDLER_ON_NEW_SECTION
+                if (!HANDLER(user, section, NULL, NULL) && !error)
+                    error = lineno;
+#endif
+            }
+            else if (!error) {
+                /* No ']' found on section line */
+                error = lineno;
+            }
+        }
+        else if (*start) {
+            /* Not a comment, must be a name[=:]value pair */
+            end = find_chars_or_comment(start, "=:");
+            if (*end == '=' || *end == ':') {
+                *end = '\0';
+                name = rstrip(start);
+                value = end + 1;
+#if INI_ALLOW_INLINE_COMMENTS
+                end = find_chars_or_comment(value, NULL);
+                if (*end)
+                    *end = '\0';
+#endif
+                value = lskip(value);
+                rstrip(value);
+
+                /* Valid name[=:]value pair found, call handler */
+                strncpy0(prev_name, name, sizeof(prev_name));
+                if (!HANDLER(user, section, name, value) && !error)
+                    error = lineno;
+            }
+            else if (!error) {
+                /* No '=' or ':' found on name[=:]value line */
+#if INI_ALLOW_NO_VALUE
+                *end = '\0';
+                name = rstrip(start);
+                if (!HANDLER(user, section, name, NULL) && !error)
+                    error = lineno;
+#else
+                error = lineno;
+#endif
+            }
+        }
+
+#if INI_STOP_ON_FIRST_ERROR
+        if (error)
+            break;
+#endif
+    }
+
+#if !INI_USE_STACK
+    ini_free(line);
+#endif
+
+    return error;
+}
+
+/* See documentation in header file. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+    return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+    FILE* file;
+    int error;
+
+    file = fopen(filename, "r");
+    if (!file)
+        return -1;
+    error = ini_parse_file(file, handler, user);
+    fclose(file);
+    return error;
+}
+
+/* An ini_reader function to read the next line from a string buffer. This
+   is the fgets() equivalent used by ini_parse_string(). */
+static char* ini_reader_string(char* str, int num, void* stream) {
+    ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
+    const char* ctx_ptr = ctx->ptr;
+    size_t ctx_num_left = ctx->num_left;
+    char* strp = str;
+    char c;
+
+    if (ctx_num_left == 0 || num < 2)
+        return NULL;
+
+    while (num > 1 && ctx_num_left != 0) {
+        c = *ctx_ptr++;
+        ctx_num_left--;
+        *strp++ = c;
+        if (c == '\n')
+            break;
+        num--;
+    }
+
+    *strp = '\0';
+    ctx->ptr = ctx_ptr;
+    ctx->num_left = ctx_num_left;
+    return str;
+}
+
+/* See documentation in header file. */
+int ini_parse_string(const char* string, ini_handler handler, void* user) {
+    ini_parse_string_ctx ctx;
+
+    ctx.ptr = string;
+    ctx.num_left = strlen(string);
+    return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
+                            user);
+}

Codes/IOcodes/ini.h

+/* inih -- simple .INI file parser
+
+SPDX-License-Identifier: BSD-3-Clause
+
+Copyright (C) 2009-2020, Ben Hoyt
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#ifndef INI_H
+#define INI_H
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Nonzero if ini_handler callback should accept lineno parameter. */
+#ifndef INI_HANDLER_LINENO
+#define INI_HANDLER_LINENO 0
+#endif
+
+/* Typedef for prototype of handler function. */
+#if INI_HANDLER_LINENO
+typedef int (*ini_handler)(void* user, const char* section,
+                           const char* name, const char* value,
+                           int lineno);
+#else
+typedef int (*ini_handler)(void* user, const char* section,
+                           const char* name, const char* value);
+#endif
+
+/* Typedef for prototype of fgets-style reader function. */
+typedef char* (*ini_reader)(char* str, int num, void* stream);
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+   (whitespace stripped), and comments starting with ';' (semicolon). Section
+   is "" if name=value pair parsed before any section heading. name:value
+   pairs are also supported as a concession to Python's configparser.
+
+   For each name=value pair parsed, call handler function with given user
+   pointer as well as section, name, and value (data only valid for duration
+   of handler call). Handler should return nonzero on success, zero on error.
+
+   Returns 0 on success, line number of first error on parse error (doesn't
+   stop on first error), -1 on file open error, or -2 on memory allocation
+   error (only when INI_USE_STACK is zero).
+*/
+int ini_parse(const char* filename, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+   close the file when it's finished -- the caller must do that. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes an ini_reader function pointer instead of
+   filename. Used for implementing custom or string-based I/O (see also
+   ini_parse_string). */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user);
+
+/* Same as ini_parse(), but takes a zero-terminated string with the INI data
+instead of a file. Useful for parsing INI data from a network socket or
+already in memory. */
+int ini_parse_string(const char* string, ini_handler handler, void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+   configparser. If allowed, ini_parse() will call the handler with the same
+   name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+   the file. See https://github.com/benhoyt/inih/issues/21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+/* Chars that begin a start-of-line comment. Per Python configparser, allow
+   both ; and # comments at the start of a line by default. */
+#ifndef INI_START_COMMENT_PREFIXES
+#define INI_START_COMMENT_PREFIXES ";#"
+#endif
+
+/* Nonzero to allow inline comments (with valid inline comment characters
+   specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
+   Python 3.2+ configparser behaviour. */
+#ifndef INI_ALLOW_INLINE_COMMENTS
+#define INI_ALLOW_INLINE_COMMENTS 1
+#endif
+#ifndef INI_INLINE_COMMENT_PREFIXES
+#define INI_INLINE_COMMENT_PREFIXES ";"
+#endif
+
+/* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
+#ifndef INI_USE_STACK
+#define INI_USE_STACK 1
+#endif
+
+/* Maximum line length for any line in INI file (stack or heap). Note that
+   this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
+#ifndef INI_MAX_LINE
+#define INI_MAX_LINE 200
+#endif
+
+/* Nonzero to allow heap line buffer to grow via realloc(), zero for a
+   fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
+   zero. */
+#ifndef INI_ALLOW_REALLOC
+#define INI_ALLOW_REALLOC 0
+#endif
+
+/* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
+   is zero. */
+#ifndef INI_INITIAL_ALLOC
+#define INI_INITIAL_ALLOC 200
+#endif
+
+/* Stop parsing on first error (default is to keep parsing). */
+#ifndef INI_STOP_ON_FIRST_ERROR
+#define INI_STOP_ON_FIRST_ERROR 0
+#endif
+
+/* Nonzero to call the handler at the start of each new section (with
+   name and value NULL). Default is to only call the handler on
+   each name=value pair. */
+#ifndef INI_CALL_HANDLER_ON_NEW_SECTION
+#define INI_CALL_HANDLER_ON_NEW_SECTION 0
+#endif
+
+/* Nonzero to allow a name without a value (no '=' or ':' on the line) and
+   call the handler with value NULL in this case. Default is to treat
+   no-value lines as an error. */
+#ifndef INI_ALLOW_NO_VALUE
+#define INI_ALLOW_NO_VALUE 0
+#endif
+
+/* Nonzero to use custom ini_malloc, ini_free, and ini_realloc memory
+   allocation functions (INI_USE_STACK must also be 0). These functions must
+   have the same signatures as malloc/free/realloc and behave in a similar
+   way. ini_realloc is only needed if INI_ALLOW_REALLOC is set. */
+#ifndef INI_CUSTOM_ALLOCATOR
+#define INI_CUSTOM_ALLOCATOR 0
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INI_H */

Codes/IOcodes/read_ini.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "read_ini.h"
+#include "ini.h"
+
+static int handler(void* user, const char* section, const char* name,
+                   const char* value) {
+    configuration* pconfig = (configuration*)user;
+
+    char *resize_name = malloc(10 * sizeof(char));
+    int act_resize = pconfig->actual_resize;
+    snprintf(resize_name, 10, "resize%d", act_resize);
+
+    #define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0
+    if (MATCH("general", "resizes")) {
+        pconfig->resizes = atoi(value) + 1;
+        malloc_config_arrays(pconfig, pconfig->resizes);
+
+    } else if (MATCH("general", "matrix_tam")) {
+        pconfig->matrix_tam = atoi(value);
+    } else if (MATCH("general", "SDR")) {
+        pconfig->sdr = atoi(value);
+    } else if (MATCH("general", "ADR")) {
+        pconfig->adr = atoi(value);
+    } else if (MATCH("general", "time")) {
+        pconfig->general_time = atof(value);
+
+    // Resize	
+    } else if (MATCH(resize_name, "iters")) {
+        pconfig->iters[act_resize] = atoi(value);
+    } else if (MATCH(resize_name, "procs")) {
+        pconfig->procs[act_resize] = atoi(value);
+    } else if (MATCH(resize_name, "factor")) {
+        pconfig->factors[act_resize] = atof(value);
+    } else if (MATCH(resize_name, "physical_dist")) {
+
+	char *aux = strdup(value);
+        if (strcmp(aux, "node") == 0) {
+          pconfig->phy_dist[act_resize] = 1; //FIXME MAGICAL NUM
+	} else {
+          pconfig->phy_dist[act_resize] = 2; //FIXME MAGICAL NUM
+	}
+	free(aux);
+        pconfig->actual_resize = pconfig->actual_resize+1; // Ultimo elemento del grupo
+
+    } else {
+        return 0;  /* unknown section or name, error */
+    }
+ 
+    free(resize_name);
+    return 1;
+}
+
+configuration *read_ini_file(char *file_name) {
+    configuration *config = NULL;
+
+    config = malloc(sizeof(configuration) * 1);
+    if(config == NULL) {
+        printf("Error when reserving configuration structure\n");
+	return NULL;
+    }
+    config->actual_resize=0;
+
+    if(ini_parse(file_name, handler, config) < 0) { // Obtener configuracion
+        printf("Can't load '%s'\n", file_name);
+        return NULL;
+    }
+    return config;
+}
+
+/*
+ * Reserva de memoria para los vectores de la estructura de configuracion
+ *
+ * Si se llama desde fuera de este codigo, tiene que reservarse la estructura
+ */
+void malloc_config_arrays(configuration *user_config, int resizes) {
+    if(user_config != NULL) {
+      user_config->iters = malloc(sizeof(int) * resizes);
+      user_config->procs = malloc(sizeof(int) * resizes);
+      user_config->factors = malloc(sizeof(int) * resizes);
+      user_config->phy_dist = malloc(sizeof(int) * resizes);
+    }
+}
+
+void free_config(configuration *user_config) {
+    if(user_config != NULL) {
+      free(user_config->iters);
+      free(user_config->procs);
+      free(user_config->factors);
+      free(user_config->phy_dist);
+
+      free(user_config);
+    }
+}
+
+void print_config(configuration *user_config) {
+  if(user_config != NULL) {
+    int i;
+    printf("Config loaded: resizes=%d, matrix=%d, sdr=%d, adr=%d, time=%f\n",
+        user_config->resizes, user_config->matrix_tam, user_config->sdr, user_config->adr, user_config->general_time);
+    for(i=0; i<user_config->resizes; i++) {
+      printf("Resize %d: Iters=%d, Procs=%d, Factors=%f, Phy=%d\n",
+        i, user_config->iters[i], user_config->procs[i], user_config->factors[i], user_config->phy_dist[i]);
+    }
+  }
+}

Codes/IOcodes/read_ini.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct
+{
+    int resizes;
+    int actual_resize;
+    int matrix_tam, sdr, adr;
+    float general_time;
+
+    int *iters, *procs, *phy_dist;
+    float *factors;
+
+} configuration;
+
+
+configuration *read_ini_file(char *file_name);
+
+void malloc_config_arrays(configuration *user_config, int resizes);
+void free_config(configuration *user_config);
+
+void print_config(configuration *user_config);

Codes/Main/Main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "../IOcodes/read_ini.h"
+
+#define ROOT 0
+
+int work(int n);
+void iterate(double *matrix, int n);
+void computeMatrix(double *matrix, int n);
+void initMatrix(double **matrix, int n);
+
+int main(int argc, char *argv[]) {
+    int numP, myId;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &numP);
+    MPI_Comm_rank(MPI_COMM_WORLD, &myId);    
+/*    
+    MPI_Comm_get_parent(&comm_parents);
+    if(comm_parents != MPI_COMM_NULL ) { // Si son procesos hijos deben recoger la distribucion
+      if(myId == ROOT) {
+        printf("Nuevo set de procesos de %d\n", numP);
+      }
+    } else { // Primer set de procesos inicializan valores
+
+    }
+*/
+    int res = work(10000);
+
+    if(res) { // Ultimo set de procesos comprueba resultados
+	    //RESULTADOS
+    }
+
+    configuration *config_file = read_ini_file("test.ini");
+    print_config(config_file);
+
+    free_config(config_file);
+
+
+
+    MPI_Finalize();
+    return 0;
+}
+
+/*
+ * Bucle de computo principal
+ */
+int work(int n) {
+  int iter, MAXITER=5; //FIXME BORRAR MAXITER
+  double *matrix;
+
+  initMatrix(&matrix, n);
+  for(iter=0; iter<MAXITER; iter++) {
+    iterate(matrix, n);
+  }
+  return 0;
+}
+
+/*
+ * Simula la ejecucción de una iteración de computo en la aplicación
+ */
+void iterate(double *matrix, int n) {
+  double start_time, actual_time;
+  int TIME=10; //FIXME BORRAR
+
+  start_time = actual_time = MPI_Wtime();
+  while (actual_time - start_time > TIME) {
+    computeMatrix(matrix, n);
+    actual_time = MPI_Wtime();
+  }
+}
+
+/*
+ * Realiza una multiplicación de matrices de tamaño n
+ */
+void computeMatrix(double *matrix, int n) {
+  int row, col, i, aux;
+
+  for(row=0; i<n; row++) {
+    /* COMPUTE */
+    for(col=0; col<n; col++) {
+      aux=0;
+      for(i=0; i<n; i++) {
+        aux += matrix[row*n + i] * matrix[i*n + col];
+      }
+    }
+  }
+}
+
+/*
+ * Init matrix
+ */
+void initMatrix(double **matrix, int n) {
+  int i, j;
+
+  // Init matrix
+  if(matrix != NULL) {
+    *matrix = malloc(n * n * sizeof(double));
+    if(*matrix == NULL) { MPI_Abort(MPI_COMM_WORLD, -1);}
+    for(i=0; i < n; i++) {
+      for(j=0; j < n; j++) {
+        (*matrix)[i*n + j] = i+j;
+      }
+    }
+  }
+}

Codes/Main/test.ini

+[general]
+resizes=1              ; Numero de redistribuciones
+matrix_tam=20000       ; Tamaño en bytes de la matriz de computo
+SDR=10000              ; Tamaño en bytes a redistribuir de forma sincrona
+ADR=10000              ; Tamaño en bytes a redistribuir de forma asincrona
+time=30                ; Tiempo necesario para realizar una iteracion
+
+[resize0]              ; Grupo inicial(mpirun)
+iters=100              ; Numero de iteraciones a realizar por este grupo
+procs=10               ; Cantidad de procesos en el grupo
+factor=1               ; Factor de coste 
+physical_dist=node     ; Tipo de redistribución física de los procesos
+
+[resize1]              ; Grupo de hijos 1
+iters=100
+procs=8
+factor=1.1
+physical_dist=cpu
+

Codes/malleability/BaseCode.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <mpi.h>
+#include <pthread.h>
+#include <math.h>
+#include <string.h>
+#include <slurm/slurm.h>
+#include "ProcessDist.h"
+
+#define ROOT 0
+#define MAXGRP 3
+
+#define TYPE_D 1
+// 1 Es nodos
+// 2 Es por nucleos
+
+// Función para crear un fichero con el formato GxNPyIDz.o{jobId}.
+// El proceso que llama a la función pasa a tener como salida estandar
+// dicho fichero.
+int create_out_file(int myId, int numP, int grp, char *jobId);
+int create_out_file(int myId, int numP, int grp, char *jobId) {
+  int ptr, err;
+  char *file_name;
+
+  file_name = NULL;
+  file_name = malloc(40 * sizeof(char));
+  if(file_name == NULL) return -1; // No ha sido posible alojar la memoria
+  err = snprintf(file_name, 40, "G%dNP%dID%d.o%s", grp, numP, myId, jobId);
+  if(err < 0) return -2; // No ha sido posible obtener el nombre de fichero
+
+  ptr = open(file_name, O_WRONLY | O_CREAT | O_APPEND, 0644);
+  if(ptr < 0) return -3; // No ha sido posible crear el fichero
+  err = close(1);
+  if(err < 0) return -4; // No es posible modificar la salida estandar
+  err = dup(ptr);
+  if(err < 0) return -4; // No es posible modificar la salida estandar
+
+  return 0;
+}
+
+// Se realizan varios tests de ancho de banda
+// al mandar N datos a los procesos impares desde el
+// par inmediatamente anterior. Tras esto, los impares
+// vuelven a enviar los N datos al proceso par.
+//
+// Tras las pruebas se imprime el ancho de banda, todo
+// el tiempo necesario para realizar todas las pruebas y
+// finalmente el tiempo medio por prueba.
+void bandwidth(int myId, double latency, int n);
+void bandwidth(int myId, double latency, int n) {
+  int i, loop_count = 100, n_bytes;
+  double start_time, stop_time, elapsed_time, bw, time;
+  char *aux;
+
+  n_bytes = n * sizeof(char);
+  aux = malloc(n_bytes);
+  elapsed_time = 0;
+
+  for(i=0; i<loop_count; i++){
+    
+    MPI_Barrier(MPI_COMM_WORLD);
+    start_time = MPI_Wtime();
+    if(myId %2 == 0){
+      MPI_Ssend(aux, n, MPI_CHAR, myId+1, 99, MPI_COMM_WORLD);
+      MPI_Recv(aux, n, MPI_CHAR, myId+1, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    }
+    else if(myId %2 == 1){
+      MPI_Recv(aux, n, MPI_CHAR, myId-1, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Ssend(aux, n, MPI_CHAR, myId-1, 99, MPI_COMM_WORLD);
+    }
+    MPI_Barrier(MPI_COMM_WORLD);
+    stop_time = MPI_Wtime();
+    elapsed_time += stop_time - start_time;
+  }
+
+  if(myId %2 == 0) {
+    time = elapsed_time / loop_count - latency;
+    bw = ((double)n_bytes * 2) / time;
+    printf("MyId %d Bw=%lf GB/s\nTot time=%lf\nTime=%lf\n", myId, bw/ 1000000000.0, elapsed_time, time);
+  }
+}
+
+// Se realizan varios tests de latencia al 
+// mandar un único dato de tipo CHAR a los procesos impares
+// desde el par inmediatamente anterior. Tras esto, los impares
+// vuelven a enviar el dato al proceso par.
+//
+// Tras las pruebas se imprime el tiempo necesario para realizar
+// TODAS las pruebas y se devuleve el tiempo medio (latencia) de
+// las pruebas
+double ping_pong(int myId, int start);
+double ping_pong(int myId, int start) {
+  int i, loop_count = 100;
+  double start_time, stop_time, elapsed_time;
+  char aux;
+
+  aux = '0';
+  elapsed_time = 0;
+
+  for(i=0; i<loop_count; i++){
+    
+    MPI_Barrier(MPI_COMM_WORLD);
+    start_time = MPI_Wtime();
+    if(myId % 2 == 0){
+      MPI_Ssend(&aux, 1, MPI_CHAR, myId+1, 99, MPI_COMM_WORLD);
+      MPI_Recv(&aux, 1, MPI_CHAR, myId+1, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    }
+    else if(myId % 2 == 1){
+      MPI_Recv(&aux, 1, MPI_CHAR, myId-1, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Ssend(&aux, 1, MPI_CHAR, myId-1, 99, MPI_COMM_WORLD);
+    }
+    MPI_Barrier(MPI_COMM_WORLD);
+    stop_time = MPI_Wtime();
+    elapsed_time += stop_time - start_time;
+  }
+
+  if(myId %2 == 0 && start != 0) {
+    printf("MyId %d Ping=%lf\n", myId, elapsed_time);
+    elapsed_time/=loop_count;
+  }
+  MPI_Bcast(&elapsed_time, 1, MPI_DOUBLE, ROOT, MPI_COMM_WORLD);
+  return elapsed_time;
+}
+
+// Trabajo común para todos los grupos de procesos
+int work(int myId, int numP, char **argv, char *job_id) {
+  int grp, n_value, aux=0;
+  double latency;
+  MPI_Comm comm = MPI_COMM_NULL, comm_par= MPI_COMM_NULL;
+
+  int rootBcast = MPI_PROC_NULL;
+  if(myId == ROOT) rootBcast = MPI_ROOT;
+
+  //     1.000.000.00 1GB
+  n_value = 400000000;
+  grp = 0;
+
+  // Obtener que grupo de procesos soy de los padres
+  MPI_Comm_get_parent(&comm_par);
+  if(comm_par != MPI_COMM_NULL) {
+    MPI_Bcast(&grp, 1, MPI_INT, ROOT, comm_par);
+    grp+=1;
+    MPI_Barrier(comm_par);
+    MPI_Bcast(&aux, 1, MPI_INT, rootBcast, comm_par);
+    //MPI_Comm_free(&comm_par);
+    MPI_Comm_disconnect(&comm_par);
+  }
+
+  // Dividir los resultados por procesos
+  //create_out_file(myId, numP, grp, job_id);
+
+  /*----- PRUEBAS PRESTACIONES -----*/
+  // Asegurar que se ha inicializado la comunicación de MPI
+  ping_pong(myId, 0);
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  // Obtener la latencia de la red
+  latency = ping_pong(myId, 1);
+  // Obtener el ancho de banda
+  bandwidth(myId, latency, n_value);
+
+  /*----- CREACIÓN DE PROCESOS -----*/
+
+  // Creación de un nuevo grupo de procesos
+  // Para evitar que se creen más grupos hay que asignar
+  // el valor 0 en la variable MAXGRP
+  if(grp != MAXGRP) {
+
+    // Inicialización de la comunicación con SLURM
+    int aux = numP;
+    init_slurm_comm(argv, myId, aux, ROOT, TYPE_D, COMM_SPAWN_SERIAL);
+
+    // Esperar a que la comunicación y creación de procesos
+    // haya finalizado
+    int test = -1;
+    while(test != MPI_SUCCESS) {
+      test = check_slurm_comm(myId, ROOT, MPI_COMM_WORLD, &comm);
+    }
+
+    // Enviar a los hijos que grupo de procesos son
+    MPI_Bcast(&grp, 1, MPI_INT, rootBcast, comm);
+    MPI_Barrier(comm);
+    MPI_Bcast(&aux, 1, MPI_INT, ROOT, comm);
+
+    // Desconectar intercomunicador con los hijos
+    MPI_Comm_disconnect(&comm);
+    //MPI_Comm_free(&comm);
+  } //IF GRP
+
+  if(comm != MPI_COMM_NULL || comm_par != MPI_COMM_NULL) {
+    printf("GRP=%d || El comunicador no esta a NULO\n", grp);
+    fflush(stdout);
+  }
+
+  return grp;
+}
+
+int main(int argc, char ** argv) {
+  int rank, numP, grp, len, pid;
+  char *tmp;
+
+  MPI_Init(&argc, &argv);
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &numP);  
+  pid = getpid();
+
+  // Imprimir datos sobre el comunicador de
+  // este grupo de procesos
+  tmp = getenv("SLURM_JOB_ID");
+  if(rank == ROOT) {
+
+    //system("printenv"); // Imprime todas las variables de entorno
+    printf("DATA\n");
+    //print_Info(MPI_COMM_WORLD);
+  }
+
+  
+  // Imprimir nombre del nodo en el que se encuentra el proceso
+  char *name = malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
+  MPI_Get_processor_name(name,&len);
+  printf("ID=%d Name %s PID=%d\n", rank, name, pid); 
+  fflush(stdout);
+  MPI_Barrier(MPI_COMM_WORLD);
+  
+  // Se manda el trabajo a los hijos
+  grp = work(rank, numP, argv, tmp);
+  fflush(stdout);
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  MPI_Finalize();
+  
+  return 0;
+  
+}

Codes/malleability/ProcessDist.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <mpi.h>
+#include <string.h>
+#include <slurm/slurm.h>
+#include "ProcessDist.h"
+
+#define ROOT 0
+
+int commSlurm = COMM_UNRESERVED;
+struct Slurm_data *slurm_data;  
+pthread_t slurm_thread;
+
+struct Slurm_data {
+  char *cmd; // Executable name
+  int qty_procs;
+  MPI_Info info;
+  int type_creation;
+};
+
+struct Creation_data {
+  char **argv;
+  int numP_childs, type_dist;
+};
+
+//--------------PRIVATE SPAWN TYPE DECLARATIONS---------------//
+void* thread_work(void* creation_data_arg);
+
+//--------------PRIVATE DECLARATIONS---------------//
+
+void processes_dist(char *argv[], int numP_childs, int type_dist);
+int create_processes(int myId, int root, MPI_Comm *child, MPI_Comm comm);
+void node_dist(slurm_job_info_t job_record, int type, int total_procs, int **qty, int *used_nodes);
+
+int create_hostfile(char *jobId, char **file_name);
+int write_hostfile_node(int ptr, int qty, char *node_name);
+void fill_hostfile(slurm_job_info_t job_record, int ptr, int *qty, int used_nodes, MPI_Info *info_array);
+
+void print_Info(MPI_Info info);
+
+//--------------PUBLIC FUNCTIONS---------------//
+
+int init_slurm_comm(char **argv, int myId, int numP, int root, int type_dist, int type_creation) {
+
+  slurm_data = malloc(sizeof(struct Slurm_data));
+
+  if(myId == root) {
+    slurm_data->type_creation = type_creation;
+    if(type_creation == COMM_SPAWN_SERIAL) {
+
+      processes_dist(argv, numP, type_dist);
+      commSlurm = COMM_FINISHED;
+
+    } else if(type_creation == COMM_SPAWN_PTHREAD) {
+      commSlurm = COMM_IN_PROGRESS;
+
+      struct Creation_data *creation_data = malloc(sizeof(struct Creation_Data*));
+      creation_data->argv = argv;
+      creation_data->numP_childs = numP;
+      creation_data->type_dist = type_dist;
+
+      if(pthread_create(&slurm_thread, NULL, thread_work, creation_data)) {
+        printf("Error al crear el hilo de contacto con SLURM\n");
+        MPI_Abort(MPI_COMM_WORLD, -1);
+        return -1;
+      }
+
+    }
+  }
+    
+  return 0;
+}
+
+int check_slurm_comm(int myId, int root, MPI_Comm comm, MPI_Comm *child) {
+  int spawn_err = COMM_IN_PROGRESS;
+
+  if(myId == root && commSlurm == COMM_FINISHED && slurm_data->type_creation == COMM_SPAWN_PTHREAD) {
+    if(pthread_join(slurm_thread, NULL)) {
+      printf("Error al esperar al hilo\n");
+      MPI_Abort(MPI_COMM_WORLD, -1);
+      return -2;
+    }  
+  }
+
+  MPI_Bcast(&commSlurm, 1, MPI_INT, root, comm);
+
+  if(commSlurm == COMM_FINISHED) {
+    spawn_err = create_processes(myId, root, child, comm);
+    free(slurm_data);
+  }
+
+  return spawn_err;
+}
+
+//--------------PRIVATE SPAWN TYPE FUNCTIONS---------------//
+void* thread_work(void* creation_data_arg) {
+  struct Creation_data *creation_data = (struct Creation_data*) creation_data_arg;
+ 
+  processes_dist(creation_data->argv, creation_data->numP_childs, creation_data->type_dist);
+  commSlurm = COMM_FINISHED;
+
+  free(creation_data);
+  pthread_exit(NULL);
+}
+
+//--------------PRIVATE SPAWN CREATION FUNCTIONS---------------//
+
+void processes_dist(char *argv[], int numP_childs, int type) {
+    int jobId, ptr;
+    char *tmp;
+    job_info_msg_t *j_info;
+    slurm_job_info_t last_record;
+
+    int used_nodes=0;
+    int *procs_array;
+    char *hostfile_name;
+
+    // Get Slurm job info
+    tmp = getenv("SLURM_JOB_ID");
+    jobId = atoi(tmp);
+    slurm_load_job(&j_info, jobId, 1);
+    last_record = j_info->job_array[j_info->record_count - 1];
+
+    //COPY PROGRAM NAME
+    slurm_data->cmd = malloc(strlen(argv[0]) * sizeof(char));
+    strcpy(slurm_data->cmd, argv[0]);
+
+    // GET NEW DISTRIBUTION 
+    node_dist(last_record, type, numP_childs, &procs_array, &used_nodes);
+    slurm_data->qty_procs = numP_childs;
+
+    // CREATE/UPDATE HOSTFILE
+    ptr = create_hostfile(tmp, &hostfile_name);
+    MPI_Info_create(&(slurm_data->info));
+    MPI_Info_set(slurm_data->info, "hostfile", hostfile_name);
+    free(hostfile_name);
+
+    // SET NEW DISTRIBUTION 
+    fill_hostfile(last_record, ptr, procs_array, used_nodes, &(slurm_data->info));
+    close(ptr);
+
+    // Free JOB INFO
+    slurm_free_job_info_msg(j_info); 
+}
+
+
+int create_processes(int myId, int root, MPI_Comm *child, MPI_Comm comm) {
+  int spawn_err = MPI_Comm_spawn(slurm_data->cmd, MPI_ARGV_NULL, slurm_data->qty_procs, slurm_data->info, root, comm, child, MPI_ERRCODES_IGNORE); 
+
+  if(spawn_err != MPI_SUCCESS) {
+    printf("Error creating new set of %d procs.\n", slurm_data->qty_procs);
+  }
+
+  if(myId == root) {
+    MPI_Info_free(&(slurm_data->info));
+    free(slurm_data->cmd);
+  }
+
+  return spawn_err;
+}
+
+void node_dist(slurm_job_info_t job_record, int type, int total_procs, int **qty, int *used_nodes) {
+  int i, asigCores;
+  int tamBl, remainder;
+  int *procs;
+
+  procs = calloc(job_record.num_nodes, sizeof(int)); // Numero de procesos por nodo
+
+  /* GET NEW DISTRIBUTION  */
+  if(type == 1) { // DIST NODES
+    *used_nodes = job_record.num_nodes;
+    tamBl = total_procs / job_record.num_nodes;
+    remainder = total_procs % job_record.num_nodes;
+    for(i=0; i<remainder; i++) {
+      procs[i] = tamBl + 1; 
+    }
+    for(i=remainder; i<job_record.num_nodes; i++) {
+      procs[i] = tamBl; 
+    }
+  } else if (type == 2) { // DIST CPUs
+    tamBl = job_record.num_cpus / job_record.num_nodes;
+    asigCores = 0;
+    i = 0;
+    *used_nodes = 0;
+
+    while(asigCores+tamBl <= total_procs) {
+      asigCores += tamBl;
+      procs[i] += tamBl;
+      i = (i+1) % job_record.num_nodes;
+      (*used_nodes)++;
+    }
+    if(asigCores < total_procs) {
+      procs[i] += total_procs - asigCores;
+      (*used_nodes)++;
+    }
+    if(*used_nodes > job_record.num_nodes) *used_nodes = job_record.num_nodes;
+  }
+
+  *qty = calloc(*used_nodes, sizeof(int)); // Numero de procesos por nodo
+  for(i=0; i< *used_nodes; i++) {
+    (*qty)[i] = procs[i];
+  }
+  free(procs);
+}
+
+int create_hostfile(char *jobId, char **file_name) {
+  int ptr, err, len;
+
+  len = strlen(jobId) + 11;
+
+  *file_name = NULL;
+  *file_name = malloc( len * sizeof(char));
+  if(*file_name == NULL) return -1; // No ha sido posible alojar la memoria
+  err = snprintf(*file_name, len, "hostfile.o%s", jobId);
+  if(err < 0) return -2; // No ha sido posible obtener el nombre de fichero
+
+  ptr = open(*file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+  if(ptr < 0) return -3; // No ha sido posible crear el fichero
+
+  return ptr; // Devolver puntero a fichero
+}
+
+void fill_hostfile(slurm_job_info_t job_record, int ptr, int *qty, int used_nodes, MPI_Info *info_array) {
+  int i=0;
+  char *host;
+  hostlist_t hostlist;
+  
+  hostlist = slurm_hostlist_create(job_record.nodes);
+  while ( (host = slurm_hostlist_shift(hostlist)) && i < used_nodes) {
+    write_hostfile_node(ptr, qty[i], host);
+    i++;
+    free(host);
+  }
+  slurm_hostlist_destroy(hostlist);
+
+}
+
+int write_hostfile_node(int ptr, int qty, char *node_name) {
+  int err, len_node, len_int, len;
+  char *line;
+
+  len_node = strlen(node_name);
+  len_int = snprintf(NULL, 0, "%d", qty);
+
+  len = len_node + len_int + 3;
+  line = malloc(len * sizeof(char));
+  if(line == NULL) return -1; // No ha sido posible alojar la memoria
+  err = snprintf(line, len, "%s:%d\n", node_name, qty);
+
+  if(err < 0) return -2; // No ha sido posible escribir en el fichero
+
+  write(ptr, line, len-1);
+  free(line);
+
+  return 0;
+}

Codes/malleability/ProcessDist.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include <string.h>
+#include <slurm/slurm.h>
+
+#define COMM_UNRESERVED -2
+#define COMM_IN_PROGRESS -1
+#define COMM_FINISHED 0
+
+#define COMM_PHY_NODES 1
+#define COMM_PHY_CPU 2
+
+#define COMM_SPAWN_SERIAL 0
+#define COMM_SPAWN_PTHREAD 1
+
+int init_slurm_comm(char **argv, int myId, int numP, int root, int type_dist, int type_creation);
+int check_slurm_comm(int myId, int root, MPI_Comm comm, MPI_Comm *child);

Codes/malleability/runBase.sh

+#!/bin/bash
+
+#SBATCH -N 2
+
+#module load gcc/6.4.0
+#module load openmpi/1.10.7
+
+#module load /home/martini/ejemplos_Mod/modulefiles/mpi/openmpi_aliaga_1_10_7
+
+
+echo "OPENMPI"
+#module load /home/martini/MODULES/modulefiles/openmpi4.1.0
+
+#mpirun -mca btl_openib_allow_ib 1 -npernode 10 -np 20 ./batch5.out
+
+echo "MPICH"
+module load /home/martini/MODULES/modulefiles/mpich3.4
+#export HYDRA_DEBUG=1
+#-disable-hostname-propagation -disable-auto-cleanup -pmi-port -hosts n00,n01
+
+mpirun -hostfile hostfile.o2785 -np 20 ./test.out
+
+
+echo "Intel"
+#module load /home/martini/MODULES/modulefiles/intel64.module
+
+#export I_MPI_OFI_PROVIDER=tcp
+#export I_MPI_DEBUG=6
+#export I_MPI_FABRICS=shm:ofi
+
+#mpirun -print-all-exitcodes -np 2 --ppn 1 ./batch.out
+#mpirun -genv I_MPI_FABRICS=shm:ofi -print-all-exitcodes -iface ib0 -np 16 ./batch4.out
+#mpirun -genv I_MPI_FABRICS=shm:ofi -iface enp59s0f0 -np 20 ./batch4.out