New version of Proteo

.gitignore

+#Ignore ini files
+*.ini
+
+#Ignore build files
+/Codes/build/
+/Codes/MaM/build
+/Codes/SAM/build
+
+#Ignore Results files
+/Results/*

Analysis/CreateIterDataframe.py

+import sys
+import glob
+import numpy as np
+import pandas as pd
+from enum import Enum
+
+class G_enum(Enum):
+    TOTAL_RESIZES = 0
+    TOTAL_GROUPS = 1
+    TOTAL_STAGES = 2
+    GRANULARITY = 3
+    SDR = 4
+    ADR = 5
+    DR = 6
+    RED_METHOD = 7
+    RED_STRATEGY = 8
+    SPAWN_METHOD = 9
+    SPAWN_STRATEGY = 10
+    GROUPS = 11
+    FACTOR_S = 12
+    DIST = 13
+    STAGE_TYPES = 14
+    STAGE_TIMES = 15
+    STAGE_BYTES = 16
+    ITERS = 17
+    ASYNCH_ITERS = 18
+    T_ITER = 19
+    T_STAGES = 20
+    T_SPAWN = 21
+    T_SPAWN_REAL = 22
+    T_SR = 23
+    T_AR = 24
+    T_MALLEABILITY = 25
+    T_TOTAL = 26
+    #Malleability specific
+    NP = 0
+    NC = 1
+    #Iteration specific
+    IS_DYNAMIC = 11
+    N_PARENTS = 17
+
+#columnsG = ["Total_Resizes", "Total_Groups", "Total_Stages", "Granularity", "SDR", "ADR", "DR", "Redistribution_Method", \
+#            "Redistribution_Strategy", "Spawn_Method", "Spawn_Strategy", "Groups", "FactorS", "Dist", "Stage_Types", "Stage_Times", \
+#            "Stage_Bytes", "Iters", "Asynch_Iters", "T_iter", "T_stages", "T_spawn", "T_spawn_real", "T_SR", "T_AR", "T_Malleability", "T_total"] #27
+
+columnsL = ["NP", "NC", "Total_Stages", "Granularity", "SDR", "ADR", "DR", "Redistribution_Method", \
+            "Redistribution_Strategy", "Spawn_Method", "Spawn_Strategy", "Is_Dynamic", "FactorS", "Dist", "Stage_Types", "Stage_Times", \
+            "Stage_Bytes", "N_Parents", "Asynch_Iters", "T_iter", "T_stages"] #20
+
+
+def copy_iteration(row, dataL_it, group, iteration, is_asynch):
+  basic_indexes = [G_enum.TOTAL_STAGES.value, G_enum.GRANULARITY.value, \
+          G_enum.STAGE_TYPES.value, G_enum.STAGE_TIMES.value, G_enum.STAGE_BYTES.value]
+  basic_asynch = [G_enum.SDR.value, G_enum.ADR.value, G_enum.DR.value]
+  array_asynch_group = [G_enum.RED_METHOD.value, G_enum.RED_STRATEGY.value, \
+          G_enum.SPAWN_METHOD.value, G_enum.SPAWN_STRATEGY.value, G_enum.DIST.value]
+
+  dataL_it[G_enum.FACTOR_S.value] = row[G_enum.FACTOR_S.value][group]
+  dataL_it[G_enum.NP.value] = row[G_enum.GROUPS.value][group]
+
+  dataL_it[G_enum.ASYNCH_ITERS.value] = is_asynch
+  dataL_it[G_enum.T_ITER.value] = row[G_enum.T_ITER.value][group][iteration]
+  dataL_it[G_enum.T_STAGES.value] = list(row[G_enum.T_STAGES.value][group][iteration])
+  dataL_it[G_enum.IS_DYNAMIC.value] = True if group > 0 else False
+
+  for index in basic_indexes:
+    dataL_it[index] = row[index]
+
+  for index in array_asynch_group:
+    dataL_it[index] = [None, -1]
+    dataL_it[index][0] = row[index][group]
+
+  dataL_it[G_enum.N_PARENTS.value] = -1
+  if group > 0:
+    dataL_it[G_enum.N_PARENTS.value] = row[G_enum.GROUPS.value][group-1]
+
+  if is_asynch:
+    dataL_it[G_enum.NC.value] = row[G_enum.GROUPS.value][group+1]
+
+    for index in basic_asynch:
+      dataL_it[index] = row[index]
+    for index in array_asynch_group:
+      dataL_it[index][1] = row[index][group+1]
+
+  for index in array_asynch_group: # Convert to tuple
+    dataL_it[index] = tuple(dataL_it[index])
+
+#-----------------------------------------------
+def write_iter_dataframe(dataL, name, i, first=False):
+  dfL = pd.DataFrame(dataL, columns=columnsL)
+  dfL.to_pickle(name + str(i) + '.pkl')
+  if first:
+    print(dfL)
+
+#-----------------------------------------------
+
+def create_iter_dataframe(dfG, name, max_it_L):
+  it = -1
+  file_i = 0
+  first = True
+  dataL = []
+
+  for row_index in range(len(dfG)):
+    row = dfG.iloc[row_index]
+    groups = row[G_enum.TOTAL_GROUPS.value]
+
+    for group in range(groups):
+        real_iterations = len(row[G_enum.T_ITER.value][group])
+        real_asynch = row[G_enum.ASYNCH_ITERS.value][group]
+        is_asynch = False
+        for iteration in range(real_iterations-real_asynch):
+            it += 1
+            dataL.append( [None] * len(columnsL) )
+            copy_iteration(row, dataL[it], group, iteration, is_asynch)
+        is_asynch = True
+        for iteration in range(real_iterations-real_asynch, real_iterations):
+            it += 1
+            dataL.append( [None] * len(columnsL) )
+            copy_iteration(row, dataL[it], group, iteration, is_asynch)
+    if it >= max_it_L-1: #Var "it" starts at -1, so one more must be extracted for precise cut
+        write_iter_dataframe(dataL, name, file_i, first)
+        dataL = []
+        file_i += 1
+        first = False
+        it = -1
+
+  if it != -1:
+    write_iter_dataframe(dataL, name, file_i)
+
+
+
+#-----------------------------------------------
+
+if len(sys.argv) < 2:
+    print("The files name is missing\nUsage: python3 CreateIterDataframe.py input_file.pkl output_name [max_rows_per_file]")
+    exit(1)
+
+input_name = sys.argv[1]
+if len(sys.argv) > 2:
+  name = sys.argv[2]
+else:
+  name = "dataL"
+print("File names will be: " + name + ".pkl")
+
+if len(sys.argv) > 3:
+  max_it_L = int(sys.argv[3])
+else:
+  max_it_L = 100000
+
+dfG = pd.read_pickle(input_name)
+print(dfG)
+create_iter_dataframe(dfG, name, max_it_L)
+

Analysis/CreateResizeDataframe.py

+import sys
+import glob
+import numpy as np
+import pandas as pd
+from enum import Enum
+
+class G_enum(Enum):
+    TOTAL_RESIZES = 0
+    TOTAL_GROUPS = 1
+    TOTAL_STAGES = 2
+    GRANULARITY = 3
+    SDR = 4
+    ADR = 5
+    DR = 6
+    RED_METHOD = 7
+    RED_STRATEGY = 8
+    SPAWN_METHOD = 9
+    SPAWN_STRATEGY = 10
+    GROUPS = 11
+    FACTOR_S = 12
+    DIST = 13
+    STAGE_TYPES = 14
+    STAGE_TIMES = 15
+    STAGE_BYTES = 16
+    ITERS = 17
+    ASYNCH_ITERS = 18
+    T_ITER = 19
+    T_STAGES = 20
+    T_SPAWN = 21
+    T_SPAWN_REAL = 22
+    T_SR = 23
+    T_AR = 24
+    T_MALLEABILITY = 25
+    T_TOTAL = 26
+    #Malleability specific
+    NP = 0
+    NC = 1
+    #Iteration specific
+    IS_DYNAMIC = 11
+    N_PARENTS = 17
+
+#columnsG = ["Total_Resizes", "Total_Groups", "Total_Stages", "Granularity", "SDR", "ADR", "DR", "Redistribution_Method", \
+#            "Redistribution_Strategy", "Spawn_Method", "Spawn_Strategy", "Groups", "FactorS", "Dist", "Stage_Types", "Stage_Times", \
+#            "Stage_Bytes", "Iters", "Asynch_Iters", "T_iter", "T_stages", "T_spawn", "T_spawn_real", "T_SR", "T_AR", "T_Malleability", "T_total"] #27
+
+columnsM = ["NP", "NC", "Total_Stages", "Granularity", "SDR", "ADR", "DR", "Redistribution_Method", \
+            "Redistribution_Strategy", "Spawn_Method", "Spawn_Strategy", "FactorS", "Dist", "Stage_Type", "Stage_Time", \
+            "Stage_Bytes", "Iters", "Asynch_Iters", "T_iter", "T_stages", "T_spawn", "T_spawn_real", "T_SR", "T_AR", "T_Malleability"] #25
+
+def copy_resize(row, dataM_it, resize):
+  basic_indexes = [G_enum.TOTAL_STAGES.value, G_enum.GRANULARITY.value, G_enum.SDR.value, \
+          G_enum.ADR.value, G_enum.DR.value]
+  basic_group = [G_enum.STAGE_TYPES.value, G_enum.STAGE_TIMES.value, G_enum.STAGE_BYTES.value]
+  array_actual_group = [G_enum.FACTOR_S.value, G_enum.ITERS.value, G_enum.ASYNCH_ITERS.value, \
+          G_enum.T_SPAWN.value, G_enum.T_SPAWN_REAL.value, G_enum.T_SR.value, \
+          G_enum.T_AR.value, G_enum.T_MALLEABILITY.value, G_enum.T_ITER.value, G_enum.T_STAGES.value]
+  array_next_group = [G_enum.RED_METHOD.value, G_enum.RED_STRATEGY.value, \
+          G_enum.SPAWN_METHOD.value, G_enum.SPAWN_STRATEGY.value]
+
+  dataM_it[G_enum.NP.value] = row[G_enum.GROUPS.value][resize]
+  dataM_it[G_enum.NC.value] = row[G_enum.GROUPS.value][resize+1]
+  dataM_it[G_enum.DIST.value-1] = [None, None]
+  dataM_it[G_enum.DIST.value-1][0] = row[G_enum.DIST.value][resize]
+  dataM_it[G_enum.DIST.value-1][1] = row[G_enum.DIST.value][resize+1]
+
+  for index in basic_indexes:
+    dataM_it[index] = row[index]
+    
+  for index in basic_group:
+    dataM_it[index-1] = row[index]
+
+  for index in array_actual_group:
+    dataM_it[index-1] = row[index][resize] 
+
+  for index in array_next_group:
+    dataM_it[index] = row[index][resize+1]
+
+
+#-----------------------------------------------
+
+def create_resize_dataframe(dfG, dataM):
+  it = -1
+  for row_index in range(len(dfG)):
+    row = dfG.iloc[row_index]
+    resizes = row[G_enum.TOTAL_RESIZES.value]
+
+    for resize in range(resizes):
+      it += 1
+      dataM.append( [None] * len(columnsM) )
+      copy_resize(row, dataM[it], resize)
+
+#-----------------------------------------------
+if len(sys.argv) < 2:
+    print("The files name is missing\nUsage: python3 CreateResizeDataframe.py input_file.pkl output_name")
+    exit(1)
+
+input_name = sys.argv[1]
+if len(sys.argv) > 2:
+  name = sys.argv[2]
+else:
+  name = "dataM"
+print("File name will be: " + name + ".pkl")
+
+
+dfG = pd.read_pickle(input_name)
+dataM = []
+create_resize_dataframe(dfG, dataM)
+
+dfM = pd.DataFrame(dataM, columns=columnsM)
+dfM.to_pickle(name + '.pkl')
+
+print(dfG)
+print(dfM)

Analysis/MallTimes.py

@@ -2,189 +2,299 @@ import sys
 import glob
 import numpy as np
 import pandas as pd
+from enum import Enum
 
-def getData(lineS, outData, tp, hasIter = False):
-  for data in lineS:
-    k_v = data.split('=')
-    if k_v[0] == "time":
-      time = float(k_v[1])
-    elif k_v[0] == "iters" and hasIter:
-      iters = int(k_v[1])
+class G_enum(Enum):
+    TOTAL_RESIZES = 0
+    TOTAL_GROUPS = 1
+    TOTAL_STAGES = 2
+    GRANULARITY = 3
+    SDR = 4
+    ADR = 5
+    DR = 6
+    RED_METHOD = 7
+    RED_STRATEGY = 8
+    SPAWN_METHOD = 9
+    SPAWN_STRATEGY = 10
+    GROUPS = 11
+    FACTOR_S = 12
+    DIST = 13
+    STAGE_TYPES = 14
+    STAGE_TIMES = 15
+    STAGE_BYTES = 16
+    ITERS = 17
+    ASYNCH_ITERS = 18
+    T_ITER = 19
+    T_STAGES = 20
+    T_SPAWN = 21
+    T_SPAWN_REAL = 22
+    T_SR = 23
+    T_AR = 24
+    T_MALLEABILITY = 25
+    T_TOTAL = 26
+    #Malleability specific
+    NP = 0
+    NC = 1
+    #Iteration specific
+    IS_DYNAMIC = 11
+    N_PARENTS = 17
 
-  outData[tp] = time
-  if hasIter:
-    outData[tp+1] = iters
+
+columnsG = ["Total_Resizes", "Total_Groups", "Total_Stages", "Granularity", "SDR", "ADR", "DR", "Redistribution_Method", \
+            "Redistribution_Strategy", "Spawn_Method", "Spawn_Strategy", "Groups", "FactorS", "Dist", "Stage_Types", "Stage_Times", \
+            "Stage_Bytes", "Iters", "Asynch_Iters", "T_iter", "T_stages", "T_spawn", "T_spawn_real", "T_SR", "T_AR", "T_Malleability", "T_total"] #27
 
 #-----------------------------------------------
-def record(f, observation, line):
-  # Record first line - General info
-  lineS = line.split()
-  for j in range(1,7):
-    observation[j] = int(lineS[j].split('=')[1])
+# Obtains the value of a given index in a splited line
+# and returns it as a float values if possible, string otherwise
+def get_value(line, index, separator=True):
+  if separator:
+    value = line[index].split('=')[1].split(',')[0]
+  else:
+    value = line[index]
 
-  # Record procces number
-  line = next(f)
-  lineS = line.split()
-  j = 7
-  for key_values in lineS:
-    k_v = key_values.split('=')
-    observation[j] = int(k_v[1])
-    j+=1
-
-  # Record data
-  j = 9
-  for j in range(9, 13):
-    line = next(f)
-    lineS = line.split()  
-    getData(lineS, observation, j)
+  try:
+    value = float(value)
+    if value.is_integer():
+      value = int(value)
+  except ValueError:
+    return value
+  return value
 
-  line = next(f)
-  lineS = line.split()  
-  #if observation[0] == "A":
-  getData(lineS, observation, 13, True)
-  #else:
-   # getData(lineS, observation, 13)
+#-----------------------------------------------
+# Obtains the general parameters of an execution and
+# stores them for creating a global dataframe
+def record_config_line(lineS, dataG_it):
+  ordered_indexes = [G_enum.TOTAL_RESIZES.value, G_enum.TOTAL_STAGES.value, \
+          G_enum.GRANULARITY.value, G_enum.SDR.value, G_enum.ADR.value]
+  offset_line = 2
+  for i in range(len(ordered_indexes)):
+    value = get_value(lineS, i+offset_line)
+    index = ordered_indexes[i]
+    dataG_it[index] = value
+
+  dataG_it[G_enum.TOTAL_GROUPS.value] = dataG_it[G_enum.TOTAL_RESIZES.value]+1
+
+  #FIXME Modificar cuando ADR ya no sea un porcentaje
+  dataG_it[G_enum.DR.value] = dataG_it[G_enum.SDR.value] + dataG_it[G_enum.ADR.value]
+
+  # Init lists for each column
+  array_groups = [G_enum.GROUPS.value, G_enum.FACTOR_S.value, G_enum.DIST.value, G_enum.ITERS.value, \
+          G_enum.ASYNCH_ITERS.value, G_enum.T_ITER.value, G_enum.T_STAGES.value, G_enum.RED_METHOD.value, \
+          G_enum.RED_STRATEGY.value, G_enum.SPAWN_METHOD.value, G_enum.SPAWN_STRATEGY.value,]
+  array_resizes = [ G_enum.T_SPAWN.value, G_enum.T_SPAWN_REAL.value, G_enum.T_SR.value, G_enum.T_AR.value, G_enum.T_MALLEABILITY.value]
+  array_stages = [G_enum.STAGE_TYPES.value, \
+          G_enum.STAGE_TIMES.value, G_enum.STAGE_BYTES.value]
+  for index in array_groups:
+    dataG_it[index] = [None]*dataG_it[G_enum.TOTAL_GROUPS.value]
+  for group in range(dataG_it[G_enum.TOTAL_GROUPS.value]):
+    dataG_it[G_enum.T_ITER.value][group] = []
+
+  for index in array_resizes:
+    dataG_it[index] = [None]*dataG_it[G_enum.TOTAL_RESIZES.value]
+
+  for index in array_stages:
+    dataG_it[index] = [None]*dataG_it[G_enum.TOTAL_STAGES.value]
+
+#-----------------------------------------------
+# Obtains the parameters of a stage line 
+# and stores it in the dataframe
+# Is needed to indicate in which stage is
+# being performed
+def record_stage_line(lineS, dataG_it, stage):
+  array_stages = [G_enum.STAGE_TYPES.value, \
+          G_enum.STAGE_TIMES.value, G_enum.STAGE_BYTES.value]
+  offset_lines = 2
+  for i in range(len(array_stages)):
+    value = get_value(lineS, i+offset_lines)
+    index = array_stages[i]
+    dataG_it[index][stage] = value
+
+#-----------------------------------------------
+# Obtains the parameters of a resize line
+# and stores them in the dataframe
+# Is needed to indicate to which group refers
+# the resize line
+# Group 0: Iters=3, Procs=80, Factors=0.037500, Dist=2, RM=0, SM=0, RS=0, SS=0
+def record_group_line(lineS, dataG_it, group):
+  array_groups = [G_enum.ITERS.value, G_enum.GROUPS.value, G_enum.FACTOR_S.value, G_enum.DIST.value, \
+          G_enum.RED_METHOD.value, G_enum.SPAWN_METHOD.value, G_enum.RED_STRATEGY.value, G_enum.SPAWN_STRATEGY.value]
+  offset_lines = 2
+  for i in range(len(array_groups)):
+    value = get_value(lineS, i+offset_lines)
+    index = array_groups[i]
+    dataG_it[index][group] = value
+
+#-----------------------------------------------
+def record_time_line(lineS, dataG_it):
+  T_names = ["T_spawn:", "T_spawn_real:", "T_SR:", "T_AR:", "T_Malleability:", "T_total:"]
+  T_values = [G_enum.T_SPAWN.value, G_enum.T_SPAWN_REAL.value, G_enum.T_SR.value, G_enum.T_AR.value, G_enum.T_MALLEABILITY.value, G_enum.T_TOTAL.value]
+  if not (lineS[0] in T_names): # Execute only if line represents a Time
+      return
+
+  index = T_names.index(lineS[0])
+  index = T_values[index]
+  offset_lines = 1
+
+  len_index = 1
+  if dataG_it[index] != None:
+    len_index = len(dataG_it[index])
+    for i in range(len_index):
+      dataG_it[index][i] = get_value(lineS, i+offset_lines, False)
+  else:
+      dataG_it[index] = get_value(lineS, offset_lines, False)
+
+#-----------------------------------------------
+def record_multiple_times_line(lineS, dataG_it, group):
+  T_names = ["T_iter:", "T_stage"]
+  T_values = [G_enum.T_ITER.value, G_enum.T_STAGES.value]
+  if not (lineS[0] in T_names): # Execute only if line represents a Time
+      return
 
+  index = T_names.index(lineS[0])
+  index = T_values[index]
+
+  offset_lines = 1
+  if index == G_enum.T_STAGES.value:
+    offset_lines += 1
+    total_iters = len(lineS)-offset_lines
+    stage = int(lineS[1].split(":")[0])
+    if stage == 0:
+      dataG_it[index][group] = [None] * total_iters
+      for i in range(total_iters):
+        dataG_it[index][group][i] = [None] * dataG_it[G_enum.TOTAL_STAGES.value]
+    for i in range(total_iters):
+        dataG_it[index][group][i][stage] = get_value(lineS, i+offset_lines, False)
+  else:
+    total_iters = len(lineS)-offset_lines
+    for i in range(total_iters):
+      dataG_it[index][group].append(get_value(lineS, i+offset_lines, False))
   
 #-----------------------------------------------
-def read_file(f, dataA, dataB, it):
-  recording = False
-  resizes = 0
-  timer = 0
-  previousNP = 0
+def read_local_file(f, dataG, it, runs_in_file):
+  offset = 0
+  real_it = 0
+  group = 0
+
+  for line in f:
+    lineS = line.split()
+
+    if len(lineS) > 0:
+      if lineS[0] == "Group": # GROUP number
+        offset += 1
+        real_it = it - (runs_in_file-offset)
+        group = int(lineS[1].split(":")[0])
+      elif lineS[0] == "Async_Iters:":
+        offset_line = 1
+        dataG[real_it][G_enum.ASYNCH_ITERS.value][group] = get_value(lineS, offset_line, False)
+      else:
+        record_multiple_times_line(lineS, dataG[real_it], group)
 
+#-----------------------------------------------
+def read_global_file(f, dataG, it):
+  runs_in_file=0
   for line in f: 
     lineS = line.split()
 
     if len(lineS) > 0:
       if lineS[0] == "Config": # CONFIG LINE
-        recording = True
         it += 1
-        dataA.append([None]*13)
-        dataB.append([None]*15)
-        #resizes = int(lineS[2].split('=')[1].split(',')[0])
-        resizes = 2
-        compute_tam = int(lineS[3].split('=')[1].split(',')[0])
-        comm_tam = int(lineS[4].split('=')[1].split(',')[0])
-        sdr = int(lineS[5].split('=')[1].split(',')[0])
-        adr = int(lineS[6].split('=')[1].split(',')[0]) #TODO Que lo tome como porcentaje
-        css = int(lineS[8].split('=')[1].split(',')[0])
-        cst = int(lineS[9].split('=')[1].split(',')[0])
-        # TODO Que obtenga Aib
-        time = float(lineS[10].split('=')[1])
-
-        dataB[it][0] = sdr
-        dataB[it][1] = adr 
-        dataB[it][4] = "" 
-        dataB[it][5] = compute_tam
-        dataB[it][6] = comm_tam
-        dataB[it][7] = cst
-        dataB[it][8] = css
-        dataB[it][9] = time
-        dataB[it][10] = "" 
-
-        dataA[it][0] = sdr
-        dataA[it][1] = adr 
-        dataA[it][5] = ""
-        dataA[it][6] = compute_tam
-        dataA[it][7] = comm_tam
-        dataA[it][8] = cst
-        dataA[it][9] = css
-        dataA[it][10] = time
-        dataA[it][11] = ""
-
-      elif recording and resizes != 0: # RESIZE LINE
-        iters = int(lineS[2].split('=')[1].split(',')[0])
-        npr = int(lineS[3].split('=')[1].split(',')[0])
-        dist = lineS[5].split('=')[1]
-
-        resizes = resizes - 1
-        if resizes == 0:
-          dataB[it][3] = npr
-          dataB[it][4] += dist
-          dataB[it][10] += str(iters)
-
-          dataA[it][4] = npr #FIXME No sera correcta si hay mas de una reconfig
-          dataA[it][2] = str(previousNP) + "," + str(npr)
-          dataA[it][5] += dist
-          dataA[it][11] += str(iters)
-          timer = 4
-        else:
-          dataB[it][2] = npr
-          dataB[it][4] += dist + ","
-          dataB[it][10] += str(iters) + ","
-
-          dataA[it][3] = npr
-          dataA[it][5] += dist + ","
-          dataA[it][11] += str(iters) + ","
-          previousNP = npr
-
-      else: # SAVE TIMES
-        if timer == 4:
-          dataB[it][11] = float(lineS[1])
-        elif timer == 3:
-          dataB[it][12] = float(lineS[1])
-        elif timer == 2:
-          dataB[it][13] = float(lineS[1])
-        elif timer == 1:
-          dataB[it][14] = float(lineS[1])
+        runs_in_file += 1
+        group = 0
+        stage = 0
+
+        dataG.append([None]*len(columnsG))
+        record_config_line(lineS, dataG[it])
+
+      elif lineS[0] == "Stage":
+        record_stage_line(lineS, dataG[it], stage)
+        stage+=1
+      elif lineS[0] == "Group":
+        record_group_line(lineS, dataG[it], group)
+        group+=1
       else:
-          dataA[it][12] = float(lineS[1])
-        timer = timer - 1
-          
-  return it
-#columnsA1 = ["N", "%Async", "Groups", "Dist", "Matrix", "CommTam", "Cst", "Css", "Time", "Iters", "TE"] #8
-#columnsB1 = ["N", "%Async", "NP", "NS", "Dist", "Matrix", "CommTam", "Cst", "Css", "Time", "Iters", "TC", "TS", "TA"] #12
-#Config loaded: resizes=2, matrix=1000, sdr=1000000000, adr=0, aib=0, time=2.000000 || grp=1
-#Resize 0: Iters=100, Procs=2, Factors=1.000000, Phy=2
-#Resize 1: Iters=100, Procs=4, Factors=0.500000, Phy=2
-#Tspawn: 0.249393 
-#Tthread: 0 
-#Tsync: 0.330391 
-#Tasync: 0
-#Tex: 301.428615
-
-#Config loaded: resizes=1, matrix=0, comm_tam=0, sdr=0, adr=0, aib=0, cst=3, css=1, time=1 || grp=1
+        record_time_line(lineS, dataG[it])
+
+  return it,runs_in_file
+
+#-----------------------------------------------
+
+
+#-----------------------------------------------
+def convert_to_tuples(dfG):
+  array_list_items = [G_enum.GROUPS.value, G_enum.FACTOR_S.value, G_enum.DIST.value, G_enum.ITERS.value, \
+          G_enum.ASYNCH_ITERS.value, G_enum.RED_METHOD.value, G_enum.RED_STRATEGY.value, G_enum.SPAWN_METHOD.value, \
+          G_enum.SPAWN_STRATEGY.value, G_enum.T_SPAWN.value, G_enum.T_SPAWN_REAL.value, G_enum.T_SR.value, \
+          G_enum.T_AR.value, G_enum.STAGE_TYPES.value, G_enum.STAGE_TIMES.value, G_enum.STAGE_BYTES.value]
+            #TODO Falta T_malleability?
+  array_multiple_list_items = [G_enum.T_ITER.value, G_enum.T_STAGES.value]
+  for item in array_list_items:
+    name = columnsG[item]
+    values = dfG[name].copy()
+    for index in range(len(values)):
+      values[index] = tuple(values[index])
+    dfG[name] = values
+
+  for item in array_multiple_list_items:
+    name = columnsG[item]
+    values = dfG[name].copy()
+    for i in range(len(values)):
+      for j in range(len(values[i])):
+        if(type(values[i][j][0]) == list):
+          for r in range(len(values[i][j])):
+            values[i][j][r] = tuple(values[i][j][r])
+        values[i][j] = tuple(values[i][j])
+      values[i] = tuple(values[i])
+    dfG[name] = values
+
 #-----------------------------------------------
 
 if len(sys.argv) < 2:
-    print("The files name is missing\nUsage: python3 iterTimes.py resultsName directory csvOutName")
+    print("The files name is missing\nUsage: python3 MallTimes.py commonName directory OutName")
     exit(1)
 
+common_name = sys.argv[1]
 if len(sys.argv) >= 3:
     BaseDir = sys.argv[2]
     print("Searching in directory: "+ BaseDir)
 else:
-    BaseDir = sys.argv[2]
+    BaseDir = "./"
 
 if len(sys.argv) >= 4:
-  print("Csv name will be: " + sys.argv[3] + "G.csv & " + sys.argv[3] + "M.csv")
   name = sys.argv[3]
 else:
   name = "data"
+print("File name will be: " + name + "G.pkl")
 
 insideDir = "Run"
-lista = glob.glob("./" + BaseDir + insideDir + "*/" + sys.argv[1]+ "*Global.o*")
+lista = glob.glob(BaseDir + insideDir + "*/" + common_name + "*_Global.out")
+lista += (glob.glob(BaseDir + common_name + "*_Global.out")) # Se utiliza cuando solo hay un nivel de directorios
 print("Number of files found: "+ str(len(lista)));
 
 it = -1
-dataA = []
-dataB = []
-columnsA = ["N", "%Async", "Groups", "NP", "NS", "Dist", "Matrix", "CommTam", "Cst", "Css", "Time", "Iters", "TE"] #13
-columnsB = ["N", "%Async", "NP", "NS", "Dist", "Matrix", "CommTam", "Cst", "Css", "Time", "Iters", "TC", "TH", "TS", "TA"] #15
+dataG = []
 
 for elem in lista:
   f = open(elem, "r")
-  it = read_file(f, dataA, dataB, it)
+  id_run = elem.split("_Global.out")[0].split(common_name)[-1] 
+  lista_local = glob.glob(BaseDir + common_name + id_run + "_G*NP*.out")
+
+  it,runs_in_file = read_global_file(f, dataG, it)
   f.close()
+  for elem_local in lista_local:
+    f_local = open(elem_local, "r")
+    read_local_file(f_local, dataG, it, runs_in_file)
+    f_local.close()
+
 
-#print(data)
-dfA = pd.DataFrame(dataA, columns=columnsA)
-dfA.to_csv(name + 'G.csv')
+dfG = pd.DataFrame(dataG, columns=columnsG)
+convert_to_tuples(dfG)
+print(dfG)
+dfG.to_pickle(name + 'G.pkl')
 
-dfB = pd.DataFrame(dataB, columns=columnsB)
+#dfM = pd.DataFrame(dataM, columns=columnsM)
 
 #Poner en TC el valor real y en TH el necesario para la app
-cond = dfB.TH != 0
-dfB.loc[cond, ['TC', 'TH']] = dfB.loc[cond, ['TH', 'TC']].values
-dfB.to_csv(name + 'M.csv')
+#cond = dfM.TH != 0
+#dfM.loc[cond, ['TC', 'TH']] = dfM.loc[cond, ['TH', 'TC']].values
+#dfM.to_csv(name + 'M.csv')

Analysis/bt_scheme.py

+'''
+Created on Oct 24, 2016
+
+@author: David Llorens (dllorens@uji.es)
+         (c) Universitat Jaume I 2016
+@license: GPL2
+'''
+from abc import ABCMeta, abstractmethod
+infinity = float("infinity")
+
+## Esquema para BT básico --------------------------------------------------------------------------      
+
+class PartialSolution(metaclass=ABCMeta):
+    @abstractmethod
+    def is_solution(self)-> "bool":
+        pass
+    
+    @abstractmethod
+    def get_solution(self)  -> "solution":
+        pass
+    
+    @abstractmethod
+    def successors(self) -> "IEnumerable<PartialSolution>":
+        pass
+
+class BacktrackingSolver(metaclass=ABCMeta):   
+    @staticmethod
+    def solve(initial_ps : "PartialSolution") -> "IEnumerable<Solution>":
+        def bt(ps):
+            if ps.is_solution():
+                yield ps.get_solution()
+            else:
+                for new_ps in ps.successors():
+                    yield from bt(new_ps)
+                    
+        yield from bt(initial_ps)
+
+class BacktrackingSolverOld(metaclass=ABCMeta):   
+    def solve(self, initial_ps : "PartialSolution") -> "IEnumerable<Solution>":
+        def bt(ps):
+            if ps.is_solution():
+                return [ps.get_solution()]
+            else:
+                solutions = []
+                for new_ps in ps.successors():
+                    solutions.extend(bt(new_ps))
+                return solutions
+           
+        return bt(initial_ps)
+        
+## Esquema para BT con control de visitados --------------------------------------------------------      
+
+class PartialSolutionWithVisitedControl(PartialSolution):
+    @abstractmethod
+    def state(self)-> "state": 
+        # the returned object must be of an inmutable type  
+        pass
+
+class BacktrackingVCSolver(metaclass=ABCMeta):
+    @staticmethod   
+    def solve(initial_ps : "PartialSolutionWithVisitedControl") -> "IEnumerable<Solution>":           
+        def bt(ps):
+            seen.add(ps.state())
+            if ps.is_solution():
+                yield ps.get_solution()
+            else:
+                for new_ps in ps.successors():
+                    state = new_ps.state()
+                    if state not in seen:
+                        yield from bt(new_ps)
+      
+        seen = set()
+        yield from bt(initial_ps)
+        
+## Esquema para BT para optimización ----------------------------------------------------------------      
+        
+class PartialSolutionWithOptimization(PartialSolutionWithVisitedControl):
+    @abstractmethod
+    def f(self)-> "int or double":   
+        # result of applying the objective function to the partial solution
+        pass
+
+class BacktrackingOptSolver(metaclass=ABCMeta):   
+    @staticmethod
+    def solve(initial_ps : "PartialSolutionWithOptimization") -> "IEnumerable<Solution>":           
+        def bt(ps):
+            nonlocal best_solution_found_score
+            ps_score = ps.f()
+            best_seen[ps.state()] = ps_score
+            if ps.is_solution() and ps_score < best_solution_found_score: #sólo muestra una solución si mejora la última mostrada
+                best_solution_found_score = ps_score         
+                yield ps.get_solution()
+            else:
+                for new_ps in ps.successors():
+                    state = new_ps.state()
+                    if state not in best_seen or new_ps.f() < best_seen[state]:
+                        yield from bt(new_ps)
+      
+        best_seen = {}
+        best_solution_found_score = infinity
+        yield from bt(initial_ps)

Analysis/iterTimes.py

-import sys
-import glob
-import numpy as numpy
-import pandas as pd
-
-#-----------------------------------------------
-def read_file(f, dataA, dataB, itA, itB):
-  compute_tam = 0
-  comm_tam = 0
-  sdr = 0
-  adr = 0
-  dist = 0
-  css = 0
-  cst = 0
-  time = 0
-  recording = False
-  it_line = 0
-  aux_itA = 0
-  aux_itB = 0
-  iters = 0
-  np = 0
-  np_par = 0
-  ns = 0
-  array = []
-  columnas = ['Titer','Ttype','Top']
-
-  #print(f)
-  for line in f: 
-    lineS = line.split()
-    if len(lineS) > 1:
-
-        if recording and lineS[0].split(':')[0] in columnas: #Record data
-          aux_itA = 0
-          lineS.pop(0)
-
-          if it_line==0:
-            for observation in lineS:
-              dataA.append([None]*15)
-              dataA[itA+aux_itA][0] = sdr
-              dataA[itA+aux_itA][1] = adr
-              dataA[itA+aux_itA][2] = np
-              dataA[itA+aux_itA][3] = np_par
-              dataA[itA+aux_itA][4] = ns
-              dataA[itA+aux_itA][5] = dist
-              dataA[itA+aux_itA][6] = compute_tam
-              dataA[itA+aux_itA][7] = comm_tam
-              dataA[itA+aux_itA][8] = cst
-              dataA[itA+aux_itA][9] = css
-              dataA[itA+aux_itA][10] = time
-              dataA[itA+aux_itA][11] = iters
-              dataA[itA+aux_itA][12] = float(observation)
-              array.append(float(observation))
-              aux_itA+=1
-          elif it_line==1:
-            deleted = 0
-            for observation in lineS:
-              dataA[itA+aux_itA][13] = float(observation)
-              if float(observation) == 0:
-                  array.pop(aux_itA - deleted)
-                  deleted+=1
-              aux_itA+=1
-          else:
-            for observation in lineS:
-              dataA[itA+aux_itA][14] = float(observation)
-              aux_itA+=1
-
-          it_line += 1
-          if(it_line % 3 == 0): # Comprobar si se ha terminado de mirar esta ejecucion
-            recording = False
-            it_line = 0
-            itA = itA + aux_itA
-            if ns != 0: # Solo obtener datos de grupos con hijos
-                dataB.append([None]*14)
-                dataB[itB][0] = sdr
-                dataB[itB][1] = adr
-                dataB[itB][2] = np
-                dataB[itB][3] = np_par
-                dataB[itB][4] = ns
-                dataB[itB][5] = dist
-                dataB[itB][6] = compute_tam
-                dataB[itB][7] = comm_tam
-                dataB[itB][8] = cst
-                dataB[itB][9] = css
-                dataB[itB][10] = time
-                dataB[itB][11] = iters
-                dataB[itB][12] = tuple(array)
-                dataB[itB][13] = numpy.sum(array)
-                itB+=1
-                array = []
-
-        if lineS[0] == "Config:":
-          compute_tam = int(lineS[1].split('=')[1].split(',')[0])
-          comm_tam = int(lineS[2].split('=')[1].split(',')[0])
-          sdr = int(lineS[3].split('=')[1].split(',')[0])
-          adr = int(lineS[4].split('=')[1].split(',')[0]) 
-          css = int(lineS[6].split('=')[1].split(',')[0])
-          cst = int(lineS[7].split('=')[1].split(',')[0])
-          time = float(lineS[8].split('=')[1])
-        elif lineS[0] == "Config":
-          recording = True
-          iters = int(lineS[2].split('=')[1].split(',')[0])
-          dist = int(lineS[4].split('=')[1].split(',')[0])
-          np = int(lineS[5].split('=')[1].split(',')[0])
-          np_par = int(lineS[6].split('=')[1].split(',')[0])
-          ns = int(float(lineS[7].split('=')[1]))
-
-  return itA,itB
-#-----------------------------------------------
-#Config: matrix=1000, sdr=1000000000, adr=0, aib=0 time=2.000000
-#Config Group: iters=100, factor=1.000000, phy=2, procs=2, parents=0, sons=4
-#Ttype: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
-
-if len(sys.argv) < 2:
-    print("The files name is missing\nUsage: python3 iterTimes.py resultsName directory csvOutName")
-    exit(1)
-
-if len(sys.argv) >= 3:
-    BaseDir = sys.argv[2]
-    print("Searching in directory: "+ BaseDir)
-else: #FIXME
-    BaseDir = sys.argv[2]
-
-if len(sys.argv) >= 4:
-  print("Csv name will be: " + sys.argv[3] + ".csv and "+ sys.argv[3] + "_Total.csv")
-  name = sys.argv[3]
-else:
-  name = "data"
-
-insideDir = "Run"
-lista = glob.glob("./" + BaseDir + insideDir + "*/" + sys.argv[1]+ "*ID*.o*")
-print("Number of files found: "+ str(len(lista)));
-
-itA = itB = 0
-dataA = []
-dataB = []  #0   #1        #2    #3       #4     #5      #6             #7          #8     #9   #10    #11       #12   #13   #14
-columnsA = ["N", "%Async", "NP", "N_par", "NS", "Dist", "Compute_tam", "Comm_tam", "Cst", "Css","Time", "Iters", "Ti", "Tt", "To"] #15
-columnsB = ["N", "%Async", "NP", "N_par", "NS", "Dist", "Compute_tam", "Comm_tam", "Cst", "Css","Time", "Iters", "Ti", "Sum"] #14
-
-for elem in lista:
-  f = open(elem, "r")
-  itA,itB = read_file(f, dataA, dataB, itA, itB)
-  f.close()
-
-#print(data)
-dfA = pd.DataFrame(dataA, columns=columnsA)
-dfB = pd.DataFrame(dataB, columns=columnsB)
-
-dfA['N'] += dfA['%Async']
-dfA['%Async'] = (dfA['%Async'] / dfA['N']) * 100
-dfA.to_csv(name + '.csv')
-
-dfB['N'] += dfB['%Async']
-dfB['%Async'] = (dfB['%Async'] / dfB['N']) * 100
-dfB.to_csv(name + '_Total.csv')

Analysis/joinDf.py

@@ -3,22 +3,19 @@ import glob
 import numpy as numpy
 import pandas as pd
 
-
-
 if len(sys.argv) < 3:
-    print("The files name is missing\nUsage: python3 joinDf.py resultsName1.csv resultsName2.csv csvOutName")
+    print("The files name is missing\nUsage: python3 joinDf.py resultsName1.pkl resultsName2.pkl OutName")
     exit(1)
 
 if len(sys.argv) >= 4:
-  print("Csv name will be: " + sys.argv[3] + ".csv")
   name = sys.argv[3]
 else:
   name = "dataJOINED"
 
-df1 = pd.read_csv( sys.argv[1] )
-df2 = pd.read_csv( sys.argv[2] )
+print("File name will be: " + name + ".pkl")
+df1 = pd.read_pickle( sys.argv[1] )
+df2 = pd.read_pickle( sys.argv[2] )
 frames = [df1, df2]
 df3 = pd.concat(frames)
-df3 = df3.drop(columns=df3.columns[0])
 
-df3.to_csv(name + '.csv')
+df3.to_pickle(name + '.pkl')

Codes/IOcodes/read_ini.c

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <mpi.h>
-#include "read_ini.h"
-#include "../malleability/ProcessDist.h"
-#include "ini.h"
-
-
-void malloc_config_arrays(configuration *user_config, int resizes);
-void def_struct_config_file(configuration *config_file, MPI_Datatype *config_type);
-void def_struct_config_file_array(configuration *config_file, MPI_Datatype *config_type);
-
-/*
- * Funcion utilizada para leer el fichero de configuracion
- * y guardarlo en una estructura para utilizarlo en el futuro.
- *
- * Primero lee la seccion "general" y a continuacion cada una
- * de las secciones "resize%d".
- */
-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", "comm_tam")) {
-        pconfig->comm_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", "AIB")) { //TODO Refactor cambiar nombre
-        pconfig->aib = atoi(value);
-    } else if (MATCH("general", "CST")) {
-        pconfig->cst = atoi(value);
-    } else if (MATCH("general", "CSS")) {
-        pconfig->css = 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] = COMM_PHY_NODES;
-	} else {
-          pconfig->phy_dist[act_resize] = COMM_PHY_CPU;
-	}
-
-	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;
-}
-
-/*
- * Crea y devuelve una estructura de configuracion a traves
- * de un nombre de fichero dado.
- *
- * La memoria de la estructura se reserva en la funcion y es conveniente
- * liberarla con la funcion "free_config()"
- */
-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 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
- *  - read_ini_file
- *  - recv_config_file
- */
-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(float) * resizes);
-      user_config->phy_dist = malloc(sizeof(int) * resizes);
-    }
-}
-
-/*
- * Libera toda la memoria de una estructura de configuracion
- */
-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);
-    }
-}
-
-/*
- * Imprime por salida estandar toda la informacion que contiene
- * la configuracion pasada como argumento
- */
-void print_config(configuration *user_config, int grp) {
-  if(user_config != NULL) {
-    int i;
-    printf("Config loaded: resizes=%d, matrix=%d, comm_tam=%d, sdr=%d, adr=%d, aib=%d, css=%d, cst=%d, time=%f || grp=%d\n",
-        user_config->resizes, user_config->matrix_tam, user_config->comm_tam, user_config->sdr, user_config->adr, user_config->aib, user_config->css, user_config->cst, user_config->general_time, grp);
-    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]);
-    }
-  }
-}
-
-
-/*
- * Imprime por salida estandar la informacion relacionada con un
- * solo grupo de procesos en su configuracion.
- */
-void print_config_group(configuration *user_config, int grp) {
-  if(user_config != NULL) {
-    int parents, sons;
-    parents = sons = 0;
-    if(grp > 0) {
-      parents = user_config->procs[grp-1];
-    }
-    if(grp < user_config->resizes - 1) {
-      sons = user_config->procs[grp+1];
-    }
-
-    printf("Config: matrix=%d, comm_tam=%d, sdr=%d, adr=%d, aib=%d, css=%d, cst=%d, time=%f\n",
-        user_config->matrix_tam, user_config->comm_tam, user_config->sdr, user_config->adr, user_config->aib, user_config->css, user_config->cst, user_config->general_time);
-    printf("Config Group: iters=%d, factor=%f, phy=%d, procs=%d, parents=%d, sons=%d\n",
-        user_config->iters[grp], user_config->factors[grp], user_config->phy_dist[grp], user_config->procs[grp], parents, sons);
-  }
-}
-
-//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
-//||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
-//| 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) {
-
-  MPI_Datatype config_type, config_type_array;
-
-  // Obtener un tipo derivado para enviar todos los
-  // datos escalares con una sola comunicacion
-  def_struct_config_file(config_file, &config_type);
-
-
-  // Obtener un tipo derivado para enviar los tres vectores
-  // de enteros con una sola comunicacion
-  def_struct_config_file_array(config_file, &config_type_array);
-
-  MPI_Bcast(config_file, 1, config_type, root, intercomm);
-  MPI_Bcast(config_file, 1, config_type_array, root, intercomm);
-  MPI_Bcast(config_file->factors, config_file->resizes, MPI_FLOAT, root, intercomm);
-
-  //Liberar tipos derivados
-  MPI_Type_free(&config_type);
-  MPI_Type_free(&config_type_array);
-}
-
-/*
- * 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".
- */
-configuration *recv_config_file(int root, MPI_Comm intercomm) {
-
-  MPI_Datatype config_type, config_type_array;
-
-
-  configuration *config_file = malloc(sizeof(configuration) * 1);
-
-  // Obtener un tipo derivado para recibir todos los
-  // datos escalares con una sola comunicacion
-  def_struct_config_file(config_file, &config_type);
-  MPI_Bcast(config_file, 1, config_type, root, intercomm);
-
-  // Obtener un tipo derivado para enviar los tres vectores
-  // de enteros con una sola comunicacion
-  malloc_config_arrays(config_file, config_file->resizes); // Reserva de memoria de los vectores
-  def_struct_config_file_array(config_file, &config_type_array);
-
-  MPI_Bcast(config_file, 1, config_type_array, root, intercomm);
-  MPI_Bcast(config_file->factors, config_file->resizes, MPI_FLOAT, root, intercomm);
-
-  //Liberar tipos derivados
-  MPI_Type_free(&config_type);
-  MPI_Type_free(&config_type_array);
-
-  return config_file;
-}
-
-/*
- * Tipo derivado para enviar 6 elementos especificos
- * de la estructura de configuracion con una sola comunicacion.
- */
-void def_struct_config_file(configuration *config_file, MPI_Datatype *config_type) {
-  int i, counts = 11;
-  int blocklengths[11] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
-  MPI_Aint displs[counts], dir;
-  MPI_Datatype types[counts];
-
-  // Rellenar vector types
-  types[0] = types[1] = types[2] = types[3] = types[4] = types[5] = types[6] = types[7] = types[8] = MPI_INT;
-  types[9] = MPI_FLOAT;
-  types[10] = MPI_DOUBLE;
-
-  // Rellenar vector displs
-  MPI_Get_address(config_file, &dir);
-
-  MPI_Get_address(&(config_file->resizes), &displs[0]);
-  MPI_Get_address(&(config_file->actual_resize), &displs[1]);
-  MPI_Get_address(&(config_file->matrix_tam), &displs[2]);
-  MPI_Get_address(&(config_file->comm_tam), &displs[3]);
-  MPI_Get_address(&(config_file->sdr), &displs[4]);
-  MPI_Get_address(&(config_file->adr), &displs[5]);
-  MPI_Get_address(&(config_file->aib), &displs[6]);
-  MPI_Get_address(&(config_file->css), &displs[7]);
-  MPI_Get_address(&(config_file->cst), &displs[8]);
-  MPI_Get_address(&(config_file->general_time), &displs[9]);
-  MPI_Get_address(&(config_file->Top), &displs[10]);
-
-  for(i=0;i<counts;i++) displs[i] -= dir;
-
-  MPI_Type_create_struct(counts, blocklengths, displs, types, config_type);
-  MPI_Type_commit(config_type);
-}
-
-/*
- * Tipo derivado para enviar tres vectores de enteros
- * de la estructura de configuracion con una sola comunicacion.
- */
-void def_struct_config_file_array(configuration *config_file, MPI_Datatype *config_type) {
-  int i, counts = 3;
-  int blocklengths[3] = {1, 1, 1};
-  MPI_Aint displs[counts], dir;
-  MPI_Datatype aux, types[counts];
-
-  // Rellenar vector types
-  types[0] = types[1] = types[2] = MPI_INT;
-
-  // Modificar blocklengths al valor adecuado
-  blocklengths[0] = blocklengths[1] = blocklengths[2] = config_file->resizes;
-
-  //Rellenar vector displs
-  MPI_Get_address(config_file, &dir);
-
-  MPI_Get_address(config_file->iters, &displs[0]);
-  MPI_Get_address(config_file->procs, &displs[1]);
-  MPI_Get_address(config_file->phy_dist, &displs[2]);
-
-  for(i=0;i<counts;i++) displs[i] -= dir;
-
-  // Tipo derivado para enviar un solo elemento de tres vectores
-  MPI_Type_create_struct(counts, blocklengths, displs, types, &aux);
-  // Tipo derivado para enviar N elementos de tres vectores(3N en total)
-  MPI_Type_create_resized(aux, 0, 1*sizeof(int), config_type); 
-  MPI_Type_commit(config_type);
-}

Codes/IOcodes/results.h

-#include <stdio.h>
-#include <stdlib.h>
-#include <mpi.h>
-
-#define RESULTS_INIT_DATA_QTY 100
-
-typedef struct {
-  // Iters data
-  double *iters_time;
-  int *iters_type, iter_index, iters_size;
-
-  // Spawn, Thread, Sync, Async and Exec time
-  double spawn_start, *spawn_time, *spawn_real_time;
-  double sync_start, sync_end,  *sync_time;
-  double async_start, async_end, *async_time;
-  double exec_start, exec_time;
-  //Overcharge time is time spent in malleability that is from IO modules 
-} results_data;
-
-void send_results(results_data *results, int root, int resizes, MPI_Comm intercomm);
-void recv_results(results_data *results, int root, int resizes, MPI_Comm intercomm);
-
-void set_results_post_reconfig(results_data *results, int grp, int sdr, int adr);
-void reset_results_index(results_data *results);
-
-void compute_results_iter(results_data *results, int myId, int root, MPI_Comm comm);
-
-void print_iter_results(results_data results, int last_normal_iter_index);
-void print_global_results(results_data results, int resizes);
-void init_results_data(results_data *results, int resizes, int iters_size);
-void realloc_results_iters(results_data *results, int needed);
-void free_results_data(results_data *results);

Codes/MaM/MAM.h

+#ifndef MAM_H
+#define MAM_H
+
+#include "MAM_Constants.h"
+#include "MAM_Manager.h"
+#include "MAM_Configuration.h"
+#include "MAM_Times_retrieve.h"
+
+#endif

Codes/MaM/MAM_Configuration.c

+#include "MAM_Configuration.h"
+#include "MAM_Init_Configuration.h"
+#include "MAM_DataStructures.h"
+#include <limits.h>
+
+typedef struct {
+    unsigned int *value, default_value;
+    int config_max_length;
+    union {
+      int (*set_config_simple)(unsigned int, unsigned int *);
+      int (*set_config_complex)(unsigned int);
+    };
+    char *env_name;
+} mam_config_setting_t;
+
+int MAM_I_set_method(unsigned int new_method, unsigned int *method);
+int MAM_I_set_spawn_strat(unsigned int strategy, unsigned int *strategies);
+int MAM_I_set_red_strat(unsigned int strategy, unsigned int *strategies);
+int MAM_I_set_target_number(unsigned int new_numC);
+
+int MAM_I_configuration_get_defaults();
+
+int MAM_I_contains_strat(unsigned int comm_strategies, unsigned int strategy);
+int MAM_I_add_strat(unsigned int *comm_strategies, unsigned int strategy);
+int MAM_I_remove_strat(unsigned int *comm_strategies, unsigned int strategy);
+
+mam_config_setting_t configSettings[] = { 
+    {NULL, MAM_SPAWN_MERGE, MAM_METHODS_SPAWN_LEN, {.set_config_simple = MAM_I_set_method }, MAM_SPAWN_METHOD_ENV},
+    {NULL, MAM_STRAT_SPAWN_CLEAR, MAM_STRATS_SPAWN_LEN, {.set_config_simple = MAM_I_set_spawn_strat }, MAM_SPAWN_STRATS_ENV},
+    {NULL, MAM_PHY_DIST_COMPACT, MAM_METHODS_PHYSICAL_DISTRIBUTION_LEN, {.set_config_simple = MAM_I_set_method }, MAM_PHYSICAL_DISTRIBUTION_METHOD_ENV},
+    {NULL, MAM_RED_BASELINE, MAM_METHODS_RED_LEN, {.set_config_simple = MAM_I_set_method }, MAM_RED_METHOD_ENV},
+    {NULL, MAM_STRAT_RED_CLEAR, MAM_STRATS_RED_LEN, {.set_config_simple = MAM_I_set_red_strat }, MAM_RED_STRATS_ENV},
+
+    {NULL, 1, INT_MAX, {.set_config_complex = MAM_I_set_target_number }, MAM_NUM_TARGETS_ENV}
+};
+
+unsigned int masks_spawn[] = {MAM_STRAT_CLEAR_VALUE, MAM_MASK_PTHREAD, MAM_MASK_SPAWN_SINGLE, MAM_MASK_SPAWN_INTERCOMM, MAM_MASK_SPAWN_MULTIPLE, MAM_MASK_SPAWN_PARALLEL};
+unsigned int masks_red[] = {MAM_STRAT_CLEAR_VALUE, MAM_MASK_PTHREAD, MAM_MASK_RED_WAIT_SOURCES, MAM_MASK_RED_WAIT_TARGETS};
+
+/**
+ * @brief Set configuration parameters for MAM.
+ *
+ * This function allows setting various configuration parameters for MAM
+ * such as spawn method, spawn strategies, spawn physical distribution, 
+ * redistribution method, and red strategies.
+ *
+ * @param spawn_method The spawn method reconfiguration.
+ * @param spawn_strategies The spawn strategies reconfiguration.
+ * @param spawn_dist The spawn physical distribution method reconfiguration.
+ * @param red_method The redistribution method reconfiguration.
+ * @param red_strategies The redesitribution strategy for reconfiguration.
+ */
+void MAM_Set_configuration(int spawn_method, int spawn_strategies, int spawn_dist, int red_method, int red_strategies) {
+  int i, aux;
+  int aux_array[] = {spawn_method, spawn_strategies, spawn_dist, red_method, red_strategies};
+  if(state > MAM_I_NOT_STARTED) return;
+
+  mam_config_setting_t *config = NULL;
+  for (i = 0; i < MAM_KEY_COUNT-1; i++) { //FIXME Numero magico para no cambiar num_targets
+    aux = aux_array[i];
+    config = &configSettings[i];
+    if (0 <= aux && aux < config->config_max_length) {
+      if(i == MAM_NUM_TARGETS) {
+        config->set_config_complex(aux);
+      } else {
+        config->set_config_simple(aux, config->value);
+      }
+    } 
+  }
+}
+
+/*
+ * @brief Set the configuration value for a specific key in MAM.
+ *
+ * Modifies the configuration value associated with the given key
+ * to the specified "required" value. The final value set is returned in the
+ * "provided" parameter.
+ *
+ * @param key       The key for which the configuration value is to be modified.
+ * @param required  The required value to set for the specified key.
+ * @param provided  Pointer to an integer where the final value set will be stored.
+ *                  This parameter is updated with the actual value after modification.
+ *                  For strategy keys the value is "MAM_STRATS_ADDED" if "required" has 
+ *                  been added, or "MAM_STRATS_MODIFIED" if multiple strategies of the
+ *                  key have been modified.
+ */
+void MAM_Set_key_configuration(int key, int required, int *provided) {
+  int i, aux;
+
+  if(provided == NULL) provided = &aux;
+  *provided = MAM_DENIED;
+  if(required < 0 || state > MAM_I_NOT_STARTED) return;
+
+  mam_config_setting_t *config = NULL;
+  for (i = 0; i < MAM_KEY_COUNT; i++) { //FIXME A for is not needed -- Check if key < MAM_KEY_COUNT and then just use key as index
+    if (key == i) {
+      config = &configSettings[i];
+      break;
+    }
+  }
+
+  if (config != NULL) {
+    if (required < config->config_max_length) {
+      if(i == MAM_NUM_TARGETS) {
+        *provided = config->set_config_complex(required);
+      } else {
+        *provided = config->set_config_simple(required, config->value);
+      }
+    } else {*provided = *(config->value); }
+  } else { printf("MAM: Key %d does not exist\n", key); }
+}
+
+/*
+ * Retorna si una estrategia aparece o no
+ */
+int MAM_Contains_strat(int key, unsigned int strategy, int *result) {
+  int strategies, aux = MAM_OK;
+  unsigned int len = 0, mask;
+
+  switch(key) {
+    case MAM_SPAWN_STRATEGIES:
+      strategies = mall_conf->spawn_strategies;
+      mask = masks_spawn[strategy];
+      len = MAM_STRATS_SPAWN_LEN;
+      break;
+    case MAM_RED_STRATEGIES:
+      strategies = mall_conf->red_strategies;
+      mask = masks_red[strategy];
+      len = MAM_STRATS_RED_LEN;
+      break;
+    default:
+      aux = MAM_DENIED;
+      break;
+  }
+
+  if(aux == MAM_OK && strategy < len) {
+    aux = MAM_I_contains_strat(strategies, mask);
+  } else {
+    aux = 0;
+  }
+
+  if(result != NULL) *result = aux;
+  return aux;
+}
+
+/*
+ * //TODO
+ * Tiene que ser llamado despues de setear la config
+ */
+int MAM_Set_target_number(unsigned int numC){
+  return MAM_I_set_target_number(numC);
+}
+
+
+/*
+ * //TODO
+ * Tiene que ser llamado fuera de reconfig
+ */
+void MAM_Use_valgrind(int flag) {
+  if(state > MAM_I_NOT_STARTED) return;
+
+  mall_conf->external_usage = flag ? MAM_USE_VALGRIND: 0;
+  #if MAM_DEBUG
+    if(mall->myId == mall->root && flag) DEBUG_FUNC("Settled Valgrind Wrapper", mall->myId, mall->numP); fflush(stdout);
+  #endif
+}
+
+/*
+ * //TODO
+ * Tiene que ser llamado fuera de reconfig
+ */
+void MAM_Use_extrae(int flag) {
+  if(state > MAM_I_NOT_STARTED) return;
+
+  mall_conf->external_usage = flag ? MAM_USE_EXTRAE: 0;
+  #if MAM_DEBUG
+    if(mall->myId == mall->root && flag) DEBUG_FUNC("Settled Extrae Wrapper", mall->myId, mall->numP); fflush(stdout);
+  #endif
+}
+
+//======================================================||
+//===============MAM_INIT FUNCTIONS=====================||
+//======================================================||
+//======================================================||
+
+void MAM_Init_configuration() {
+  if(mall == NULL || mall_conf == NULL) {
+    printf("MAM FATAL ERROR: Setting initial config without previous mallocs\n");
+    fflush(stdout);
+    MPI_Abort(MPI_COMM_WORLD, -50);
+  }
+
+  mall_conf->spawn_method = MAM_STRAT_CLEAR_VALUE;
+  mall_conf->spawn_strategies = MAM_STRAT_CLEAR_VALUE;
+  mall_conf->red_method = MAM_STRAT_CLEAR_VALUE;
+  mall_conf->red_strategies = MAM_STRAT_CLEAR_VALUE;
+  mall_conf->external_usage = 0;
+
+  configSettings[MAM_SPAWN_METHOD].value = &mall_conf->spawn_method;
+  configSettings[MAM_SPAWN_STRATEGIES].value = &mall_conf->spawn_strategies;
+  configSettings[MAM_PHYSICAL_DISTRIBUTION].value = &mall_conf->spawn_dist;
+  configSettings[MAM_RED_METHOD].value = &mall_conf->red_method;
+  configSettings[MAM_RED_STRATEGIES].value = &mall_conf->red_strategies;
+}
+
+void MAM_Set_initial_configuration() {
+  int not_filled = 1;
+  
+  not_filled = MAM_I_configuration_get_defaults();
+  if(not_filled) {
+    if(mall->myId == mall->root) printf("MAM WARNING: Starting configuration not set\n");
+    fflush(stdout);
+    MPI_Abort(mall->comm, -50);
+  }
+
+  #if MAM_DEBUG >= 2
+    if(mall->myId == mall->root) {
+      DEBUG_FUNC("Initial configuration settled", mall->myId, mall->numP); 
+      fflush(stdout); 
+    }
+  #endif
+}
+
+void MAM_Check_configuration() {
+  int global_internodes;
+  if(mall->numC == mall->numP) { // Migrate
+    MAM_Set_key_configuration(MAM_SPAWN_METHOD, MAM_SPAWN_BASELINE, NULL);
+  }
+
+  MPI_Allreduce(&mall->internode_group, &global_internodes, 1, MPI_INT, MPI_MAX, mall->comm);
+  if((MAM_Contains_strat(MAM_SPAWN_STRATEGIES, MAM_STRAT_SPAWN_MULTIPLE, NULL)
+  || MAM_Contains_strat(MAM_SPAWN_STRATEGIES, MAM_STRAT_SPAWN_PARALLEL, NULL) )
+  && global_internodes) { // Remove internode MPI_COMM_WORLDs
+    MAM_Set_key_configuration(MAM_SPAWN_METHOD, MAM_SPAWN_BASELINE, NULL);
+  }
+
+  if(mall_conf->spawn_method == MAM_SPAWN_MERGE) {
+    if(MAM_I_contains_strat(mall_conf->spawn_strategies, MAM_MASK_SPAWN_INTERCOMM)) {
+      MAM_I_remove_strat(&mall_conf->spawn_strategies, MAM_MASK_SPAWN_INTERCOMM);
+    }
+    // FIXME This should not be required to be removed for that case...
+    if(mall->numP > mall->numC && MAM_I_contains_strat(mall_conf->spawn_strategies, MAM_MASK_SPAWN_SINGLE)) {
+      MAM_I_remove_strat(&mall_conf->spawn_strategies, MAM_MASK_SPAWN_SINGLE);
+    }
+  }
+  if(mall_conf->red_method == MAM_RED_RMA_LOCK || mall_conf->red_method == MAM_RED_RMA_LOCKALL) {
+    if(MAM_I_contains_strat(mall_conf->spawn_strategies, MAM_MASK_SPAWN_INTERCOMM)) {
+      MAM_I_remove_strat(&mall_conf->spawn_strategies, MAM_MASK_SPAWN_INTERCOMM);
+    }
+    if(!MAM_I_contains_strat(mall_conf->red_strategies, MAM_MASK_RED_WAIT_TARGETS) &&
+       !MAM_I_contains_strat(mall_conf->red_strategies, MAM_MASK_PTHREAD)) {
+      MAM_I_set_red_strat(MAM_STRAT_RED_WAIT_TARGETS, &mall_conf->red_strategies);
+    }
+  }
+
+  #if MAM_DEBUG >= 2
+    if(mall->myId == mall->root) {
+      DEBUG_FUNC("MaM configuration", mall->myId, mall->numP); 
+      printf("Spawn M=%d S=%d D=%d Redist M=%d S=%d\n", 
+            mall_conf->spawn_method, mall_conf->spawn_strategies, mall_conf->spawn_dist, mall_conf->red_method, mall_conf->red_strategies);
+      fflush(stdout);
+    }
+  #endif
+}
+
+//======================================================||
+//================PRIVATE FUNCTIONS=====================||
+//======================================================||
+//======================================================||
+
+
+int MAM_I_configuration_get_defaults() {
+  size_t i;
+  int set_value;
+  char *tmp = NULL;
+  
+  mam_config_setting_t *config = NULL;
+  for (i = 0; i < MAM_KEY_COUNT; i++) {
+    config = &configSettings[i];
+    tmp = getenv(config->env_name);
+
+    if(tmp != NULL) {
+      set_value = atoi(tmp);
+    } else {
+      set_value = config->default_value;
+    }
+
+    if (0 <= set_value && set_value < config->config_max_length) {
+      if(i == MAM_NUM_TARGETS) {
+        config->set_config_complex(set_value);
+      } else {
+        config->set_config_simple(set_value, config->value);
+      }
+    }
+    tmp = NULL;
+  }
+  return 0;
+}
+
+
+int MAM_I_set_method(unsigned int new_method, unsigned int *method) {
+  *method = new_method;
+  return *method;
+}
+
+//TODO Se podría hacer un par de arrays o dict para obtener la mascara sin un switch
+int MAM_I_set_spawn_strat(unsigned int strategy, unsigned int *strategies) {
+  int result = 0;
+  int strat_removed = 0;
+
+  switch(strategy) {
+    case MAM_STRAT_SPAWN_CLEAR:
+      *strategies = MAM_STRAT_CLEAR_VALUE;
+      result = MAM_STRATS_MODIFIED;
+      break;
+    case MAM_STRAT_SPAWN_PTHREAD:
+      result = MAM_I_add_strat(strategies, MAM_MASK_PTHREAD);
+      break;
+    case MAM_STRAT_SPAWN_SINGLE:
+      result = MAM_I_add_strat(strategies, MAM_MASK_SPAWN_SINGLE);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_SPAWN_PARALLEL);
+      }
+      break;
+    case MAM_STRAT_SPAWN_INTERCOMM:
+      result = MAM_I_add_strat(strategies, MAM_MASK_SPAWN_INTERCOMM);
+      break;
+    case MAM_STRAT_SPAWN_MULTIPLE:
+      result = MAM_I_add_strat(strategies, MAM_MASK_SPAWN_MULTIPLE);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_SPAWN_PARALLEL);
+      }
+      break;
+    case MAM_STRAT_SPAWN_PARALLEL:
+      result = MAM_I_add_strat(strategies, MAM_MASK_SPAWN_PARALLEL);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_SPAWN_MULTIPLE);
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_SPAWN_SINGLE);
+      }
+      break;
+    default:
+      //Unkown strategy
+      result = MAM_DENIED;
+      break;
+  }
+
+  if(strat_removed) {
+    result = MAM_STRATS_MODIFIED;
+  }
+  return result;
+}
+
+int MAM_I_set_red_strat(unsigned int strategy, unsigned int *strategies) {
+  int result = 0;
+  int strat_removed = 0;
+
+  switch(strategy) {
+    case MAM_STRAT_RED_CLEAR:
+      *strategies = MAM_STRAT_CLEAR_VALUE;
+      result = MAM_STRATS_MODIFIED;
+      break;
+    case MAM_STRAT_RED_PTHREAD: //TODO - IMPROVEMENT - This could be done with a single operation instead of 3.
+      result = MAM_I_add_strat(strategies, MAM_MASK_PTHREAD);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_RED_WAIT_SOURCES);
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_RED_WAIT_TARGETS);
+      }
+      break;
+    case MAM_STRAT_RED_WAIT_SOURCES:
+      result = MAM_I_add_strat(strategies, MAM_MASK_RED_WAIT_SOURCES);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_RED_WAIT_TARGETS);
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_PTHREAD);
+      }
+      break;
+    case MAM_STRAT_RED_WAIT_TARGETS:
+      result = MAM_I_add_strat(strategies, MAM_MASK_RED_WAIT_TARGETS);
+      if(result == MAM_STRATS_ADDED) {
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_RED_WAIT_SOURCES);
+        strat_removed += MAM_I_remove_strat(strategies, MAM_MASK_PTHREAD);
+      }
+      break;
+    default:
+      //Unkown strategy
+      result = MAM_DENIED;
+      break;
+  }
+
+  if(strat_removed) {
+    result = MAM_STRATS_MODIFIED;
+  }
+  return result;
+}
+
+int MAM_I_set_target_number(unsigned int new_numC) {
+  if(state > MAM_I_NOT_STARTED || new_numC == 0) return MAM_DENIED;
+
+  mall->numC = (int) new_numC;
+  return new_numC;
+}
+
+
+/*
+ * Returns 1 if strategy is applied, 0 otherwise
+ */
+int MAM_I_contains_strat(unsigned int comm_strategies, unsigned int strategy) {
+  return comm_strategies & strategy;
+}
+
+int MAM_I_add_strat(unsigned int *comm_strategies, unsigned int strategy) {
+  if(MAM_I_contains_strat(*comm_strategies, strategy)) return MAM_OK;
+  *comm_strategies |= strategy;
+  return MAM_STRATS_ADDED;
+}
+
+int MAM_I_remove_strat(unsigned int *comm_strategies, unsigned int strategy) {
+  if(!MAM_I_contains_strat(*comm_strategies, strategy)) return MAM_OK;
+  *comm_strategies &= ~strategy;
+  return MAM_STRATS_MODIFIED;
+}

Codes/MaM/MAM_Configuration.h

+#ifndef MAM_CONFIGURATION_H
+#define MAM_CONFIGURATION_H
+
+#include <mpi.h>
+#include "MAM_Constants.h"
+
+#define MAM_STRAT_CLEAR_VALUE 0
+
+#define MAM_STRATS_ADDED 1
+#define MAM_STRATS_MODIFIED 2
+
+#define MAM_MASK_PTHREAD 0x01
+#define MAM_MASK_SPAWN_SINGLE 0x02
+#define MAM_MASK_SPAWN_INTERCOMM 0x04
+#define MAM_MASK_SPAWN_MULTIPLE 0x08
+#define MAM_MASK_SPAWN_PARALLEL 0x10
+#define MAM_MASK_RED_WAIT_SOURCES 0x02
+#define MAM_MASK_RED_WAIT_TARGETS 0x04
+
+int MAM_Contains_strat(int key, unsigned int strategy, int *result);
+void MAM_Set_configuration(int spawn_method, int spawn_strategies, int spawn_dist, int red_method, int red_strategies);
+void MAM_Set_key_configuration(int key, int required, int *provided);
+int MAM_Set_target_number(unsigned int numC);
+
+void MAM_Use_valgrind(int flag);
+void MAM_Use_extrae(int flag);
+#endif

Codes/MaM/MAM_Constants.h

+#ifndef MAM_CONSTANTS_H
+#define MAM_CONSTANTS_H
+
+//States
+#define MAM_DENIED -1
+#define MAM_OK 0
+
+enum mam_states{MAM_UNRESERVED, MAM_NOT_STARTED, MAM_PENDING, MAM_USER_PENDING, MAM_COMPLETED};
+enum mam_proc_states{MAM_PROC_CONTINUE, MAM_PROC_NEW_RANK, MAM_PROC_ZOMBIE};
+
+enum mam_spawn_methods{MAM_SPAWN_BASELINE, MAM_SPAWN_MERGE, MAM_METHODS_SPAWN_LEN};
+enum mam_spawn_strategies{MAM_STRAT_SPAWN_CLEAR, MAM_STRAT_SPAWN_PTHREAD, MAM_STRAT_SPAWN_SINGLE, MAM_STRAT_SPAWN_INTERCOMM, MAM_STRAT_SPAWN_MULTIPLE, MAM_STRAT_SPAWN_PARALLEL, MAM_STRATS_SPAWN_LEN};
+
+enum mam_phy_dist_methods{MAM_PHY_DIST_SPREAD = 1, MAM_PHY_DIST_COMPACT, MAM_METHODS_PHYSICAL_DISTRIBUTION_LEN};
+enum mam_phy_info_methods{MAM_PHY_TYPE_STRING = 1, MAM_PHY_TYPE_HOSTFILE};
+
+enum mam_redistribution_methods{MAM_RED_BASELINE, MAM_RED_POINT, MAM_RED_RMA_LOCK, MAM_RED_RMA_LOCKALL, MAM_METHODS_RED_LEN};
+enum mam_red_strategies{MAM_STRAT_RED_CLEAR, MAM_STRAT_RED_PTHREAD, MAM_STRAT_RED_WAIT_SOURCES, MAM_STRAT_RED_WAIT_TARGETS, MAM_STRATS_RED_LEN};
+
+/* KEYS & VALUES for config*/
+enum mam_key_values{MAM_SPAWN_METHOD=0, MAM_SPAWN_STRATEGIES, MAM_PHYSICAL_DISTRIBUTION, MAM_RED_METHOD, MAM_RED_STRATEGIES, MAM_NUM_TARGETS, MAM_KEY_COUNT};
+#define MAM_SPAWN_METHOD_ENV                 "MAM_SPAWN_METHOD"
+#define MAM_SPAWN_STRATS_ENV                 "MAM_SPAWN_STRATS"
+#define MAM_PHYSICAL_DISTRIBUTION_METHOD_ENV "MAM_PHYSICAL_DISTRIBUTION_METHOD"
+#define MAM_RED_METHOD_ENV                   "MAM_RED_METHOD"
+#define MAM_RED_STRATS_ENV                   "MAM_RED_STRATS"
+#define MAM_NUM_TARGETS_ENV                  "MAM_NUM_TARGETS"
+
+#define MAM_CHECK_COMPLETION 0
+#define MAM_WAIT_COMPLETION 1
+
+#define MAM_SOURCES 0
+#define MAM_TARGETS 1
+
+#define MAM_DATA_DISTRIBUTED 0
+#define MAM_DATA_REPLICATED 1
+#define MAM_DATA_VARIABLE 0
+#define MAM_DATA_CONSTANT 1
+
+// Tags for messages in spawn strategies
+#define MAM_MPITAG_STRAT_SINGLE 130
+#define MAM_MPITAG_STRAT_MULTIPLE 131
+
+#endif

Codes/MaM/MAM_DataStructures.c

+#include "MAM_DataStructures.h"
+
+malleability_config_t *mall_conf = NULL;
+malleability_t *mall = NULL;
+int state = MAM_I_UNRESERVED;
+
+/*
+ * Crea un tipo derivado para mandar las dos estructuras principales
+ * de MaM.
+ */
+void MAM_Def_main_datatype() {
+  int i, counts = 12;
+  int blocklengths[counts];
+  MPI_Aint displs[counts];
+  MPI_Datatype types[counts];
+
+  for(i=0; i<5; i++) {
+    blocklengths[i] = 1;
+    types[i] = MPI_UNSIGNED;
+  }
+  for(i=5; i<counts; i++) {
+    blocklengths[i] = 1;
+    types[i] = MPI_INT;
+  }
+
+  // Obtain base direction
+  MPI_Get_address(&(mall_conf->spawn_method), &displs[0]);
+  MPI_Get_address(&(mall_conf->spawn_strategies), &displs[1]);
+  MPI_Get_address(&(mall_conf->spawn_dist), &displs[2]);
+  MPI_Get_address(&(mall_conf->red_method), &displs[3]);
+  MPI_Get_address(&(mall_conf->red_strategies), &displs[4]);
+
+  MPI_Get_address(&(mall->root_parents), &displs[5]);
+  MPI_Get_address(&(mall->num_parents), &displs[6]); //TODO Add only when Single strat active?
+  MPI_Get_address(&(mall->numC), &displs[7]); //TODO Add only when MultipleSpawn strat active?
+  MPI_Get_address(&(mall->gid), &displs[8]); //TODO Add only when ParallelSpawn strat active?
+  MPI_Get_address(&(mall->num_cpus), &displs[9]);
+  MPI_Get_address(&(mall->num_nodes), &displs[10]);
+  MPI_Get_address(&(mall->nodelist_len), &displs[11]);
+
+  MPI_Type_create_struct(counts, blocklengths, displs, types, &mall->struct_type);
+  MPI_Type_commit(&mall->struct_type);
+}
+
+void MAM_Free_main_datatype() {
+  if(mall->struct_type != MPI_DATATYPE_NULL) {
+    MPI_Type_free(&mall->struct_type);
+  }
+}
+
+/*
+ * Comunica datos necesarios de las estructuras
+ * principales de MAM de sources a targets.
+ */
+void MAM_Comm_main_structures(MPI_Comm comm, int rootBcast) {
+
+  MPI_Bcast(MPI_BOTTOM, 1, mall->struct_type, rootBcast, comm);
+
+  if(mall->nodelist == NULL) {
+    mall->nodelist = malloc((mall->nodelist_len) * sizeof(char));
+    mall->nodelist[mall->nodelist_len-1] = '\0';
+  }
+  MPI_Bcast(mall->nodelist, mall->nodelist_len, MPI_CHAR, rootBcast, comm);
+}
+
+/*
+ * Muestra por pantalla el estado actual de todos los comunicadores
+ */
+void MAM_print_comms_state() {
+  int tester;
+  char *comm_name = malloc(MPI_MAX_OBJECT_NAME * sizeof(char));
+
+  MPI_Comm_get_name(mall->comm, comm_name, &tester);
+  printf("P%d Comm=%d Name=%s\n", mall->myId, mall->comm, comm_name);
+  MPI_Comm_get_name(*(mall->user_comm), comm_name, &tester);
+  printf("P%d Comm=%d Name=%s\n", mall->myId, *(mall->user_comm), comm_name);
+  if(mall->intercomm != MPI_COMM_NULL) {
+    MPI_Comm_get_name(mall->intercomm, comm_name, &tester);
+    printf("P%d Comm=%d Name=%s\n", mall->myId, mall->intercomm, comm_name);
+  }
+  free(comm_name);
+}
+
+/*
+ * Función para modificar los comunicadores principales de MaM
+ */
+void MAM_comms_update(MPI_Comm comm) {
+  if(mall->thread_comm != MPI_COMM_WORLD) MPI_Comm_disconnect(&(mall->thread_comm));
+  if(mall->comm != MPI_COMM_WORLD) MPI_Comm_disconnect(&(mall->comm));
+
+  MPI_Comm_dup(comm, &(mall->thread_comm));
+  MPI_Comm_dup(comm, &(mall->comm));
+
+  MPI_Comm_set_name(mall->thread_comm, "MAM_THREAD");
+  MPI_Comm_set_name(mall->comm, "MAM_MAIN");
+}

Codes/MaM/MAM_DataStructures.h

+#ifndef MAM_DATA_STRUCTURES_H
+#define MAM_DATA_STRUCTURES_H
+
+/*
+ * Shows available data structures for inner ussage.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <mpi.h>
+#include <pthread.h>
+#include "MAM_Constants.h"
+
+#define DEBUG_FUNC(debug_string, rank, numP) printf("MaM [P%d/%d]: %s -- %s:%s:%d\n", rank, numP, debug_string, __FILE__, __func__, __LINE__)
+
+/* --- MAM INNER CONSTANTS --- */
+#define MAM_ROOT 0
+enum mam_inner_states{MAM_I_UNRESERVED, MAM_I_NOT_STARTED, MAM_I_RMS_COMPLETED, MAM_I_SPAWN_PENDING, MAM_I_SPAWN_SINGLE_PENDING, 
+	MAM_I_SPAWN_SINGLE_COMPLETED, MAM_I_SPAWN_ADAPT_POSTPONE, MAM_I_SPAWN_COMPLETED, MAM_I_DIST_PENDING, MAM_I_DIST_COMPLETED, 
+	MAM_I_SPAWN_ADAPT_PENDING, MAM_I_USER_START, MAM_I_USER_PENDING, MAM_I_USER_COMPLETED, MAM_I_SPAWN_ADAPTED, MAM_I_COMPLETED};
+
+#define MAM_USE_VALGRIND 1
+#define MAM_USE_EXTRAE 2
+
+#define MAM_VALGRIND_SCRIPT "./worker_valgrind.sh"
+#define MAM_EXTRAE_SCRIPT "./worker_extrae.sh"
+
+/* --- TIME CAPTURE STRUCTURE --- */
+typedef struct {
+  // Spawn, Sync and Async time
+  double spawn_start, spawn_time;
+  double sync_start,  sync_end;
+  double async_start, async_end;
+  double user_start, user_end;
+  double malleability_start, malleability_end;
+
+  MPI_Datatype times_type;
+} malleability_times_t;
+
+/* --- GLOBAL STRUCTURES --- */
+typedef struct {
+  unsigned int spawn_method;
+  unsigned int spawn_dist;
+  unsigned int spawn_strategies;
+  unsigned int red_method;
+  unsigned int red_strategies;
+
+  int external_usage; // Whether a different application should be called by Spawn and which
+
+  malleability_times_t *times;
+} malleability_config_t;
+
+typedef struct { 
+  int myId, numP, numC, zombie;
+  int root, root_collectives;
+  int num_parents, root_parents, gid;
+  pthread_t async_thread;
+  MPI_Comm comm, thread_comm, original_comm;
+  MPI_Comm intercomm, tmp_comm;
+  MPI_Comm *user_comm;
+  MPI_Datatype struct_type;
+
+  // Specific vars for Wait_targets strat
+  int wait_targets_posted;
+  MPI_Request wait_targets;
+  
+  char *name_exec, *nodelist;
+  int num_cpus, num_nodes, nodelist_len;
+  int internode_group;
+} malleability_t;
+
+/* --- VARIABLES --- */
+extern malleability_config_t *mall_conf;
+extern malleability_t *mall;
+extern int state;
+
+/* --- FUNCTIONS --- */
+void MAM_Def_main_datatype();
+void MAM_Free_main_datatype();
+void MAM_Comm_main_structures(MPI_Comm comm, int rootBcast);
+
+void MAM_print_comms_state();
+void MAM_comms_update(MPI_Comm comm);
+
+#endif

Codes/MaM/MAM_Init_Configuration.h

+#ifndef MAM_INIT_CONFIGURATION_H
+#define MAM_INIT_CONFIGURATION_H
+
+#include <mpi.h>
+#include "MAM_Constants.h"
+
+void MAM_Init_configuration();
+void MAM_Set_initial_configuration();
+void MAM_Check_configuration();
+
+#endif

Codes/MaM/MAM_Manager.h

+#ifndef MAM_MANAGER_H
+#define MAM_MANAGER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <mpi.h>
+
+typedef struct {
+  int numS, numT;
+  int rank_state;
+  MPI_Comm comm;
+} mam_user_reconf_t;
+
+int MAM_Init(int root, MPI_Comm *comm, char *name_exec, void (*user_function)(void *), void *user_args);
+int MAM_Finalize();
+int MAM_Checkpoint(int *mam_state, int wait_completed, void (*user_function)(void *), void *user_args);
+void MAM_Resume_redistribution(int *mam_state);
+
+
+int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info);
+
+void MAM_Data_add(void *data, size_t *index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
+void MAM_Data_modify(void *data, size_t index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
+void MAM_Data_get_entries(int is_replicated, int is_constant, size_t *entries);
+void MAM_Data_get_pointer(void **data, size_t index, size_t *total_qty, MPI_Datatype *type, int is_replicated, int is_constant);
+#endif