Resolviendo ejercicios de MPI (y tambien en erlang) Parte 3

enunciado del problema:

In this assignment, you will modify your arguement broadcast routine to communicate different datatypes with a single MPI broadcast (MPI_Bcast) call. Have your program read an integer and a double-precision value from standard input (from process 0, as before), and communicate this to all of the other processes with an MPI_Bcast call. Use MPI datatypes.

Have all processes exit when a negative integer is read.

aca esta la resolucion en C:

#include <stdio.h>
#include <mpi.h>

MPI_Datatype IntDoubleType = 0;

typedef struct {
      int value_int;
      double value_double;
}IntDouble;

MPI_Datatype create_int_double_type() {
      if(IntDoubleType == 0) {
              MPI_Aint array_of_displacements[2];
      MPI_Datatype array_of_types[2];
      int array_of_blocklengths[2];

      array_of_displacements[0] = 0;
      array_of_types[0] = MPI_INT;
      array_of_blocklengths[0] = 1;

      array_of_displacements[1] = 1;
      array_of_types[1] = MPI_DOUBLE;
      array_of_blocklengths[1] = 1;

      MPI_Type_struct(1, array_of_blocklengths, array_of_displacements,
                      array_of_types, &IntDoubleType);
      MPI_Type_commit(&IntDoubleType);

      }

      return IntDoubleType;
}

int main (int argc, char** argv) {
      int rank, size, value_int, i;
      double value_double;
      IntDouble value;
      MPI_Status status;

      MPI_Init (&argc, &argv);   /* starts MPI */
      MPI_Comm_rank (MPI_COMM_WORLD, &rank);        /* get current process id */
      MPI_Comm_size (MPI_COMM_WORLD, &size);        /* get number of processes */
      create_int_double_type();
      printf("process %d of %d\n", rank, size);

      do {
              if(rank == 0) {
                      printf("give me an int value: ");
                      scanf("%d", &value_int);
                      printf("give me a double value: ");
                      scanf("%lf", &value_double);
                      value.value_int = value_int;
                      value.value_double = value_double;
                      MPI_Bcast(&value, 1, IntDoubleType, 0, MPI_COMM_WORLD);
              }
              else {
                      MPI_Recv(&value, 1, IntDoubleType, 0, 1, MPI_COMM_WORLD, &status);
                      printf("process %d received %d %lf\n", rank, value.value_int,
                                      value.value_double);
                      fflush(stdout);
              }
      } while(value.value_int >= 0);
      printf("negative value, closing\n");

      MPI_Finalize();
      return 0;
}

aca la resolucion en erlang:

-module(ej3).
-export([run/1]).

run(Total) ->
      Pids = spawn_listeners(Total),
      get_values(Pids).

spawn_listeners(Count) -> spawn_listeners(Count, []).

spawn_listeners(0, Pids) -> Pids;
spawn_listeners(Count, Pids) ->
      Pid = spawn(fun() -> listener() end),
      spawn_listeners(Count - 1, [Pid|Pids]).

listener() ->
      receive
              {Int, Double} ->
                      io:format("process ~p received ~p ~p~n", [self(), Int, Double]),
                      if
                              Int >= 0 -> listener();
                              true ->
                                      io:format("negative value, closing ~p~n", [self()])
                      end
      end.

get_value(Message, ConversionFun) ->
      case io:get_line(Message) of
              {error, Reason} -> {error, Reason};
              eof -> {error, eof};
              Value -> ConversionFun(Value)
      end.

get_values(Pids) ->
      case get_value("give me an int value (negative to quit): ", fun(Val) -> string:to_integer(Val) end) of
              {error, Reason} ->
                      io:format("error reading int value (~p)~n", [Reason]),
                      get_values(Pids);
              {IntValue, _Rest} ->
                      case get_value("give me a double value): ", fun(Val) -> string:to_float(Val) end) of
                              {error, Reason} ->
                                      io:format("error reading double value (~p)~n", [Reason]),
                                      get_values(Pids);
                              {DoubleValue, _Rest} ->
                                      send_values({IntValue, DoubleValue}, Pids),
                                      if
                                              IntValue >= 0 -> get_values(Pids);
                                              true -> io:format("negative value, closing~n")
                                      end
                      end
      end.

send_values(Value, Pids) ->
      lists:foreach(fun(Pid) -> Pid ! Value end, Pids).
    

Algunas observaciones.
Cuando el problema empieza a escalar en complejidad de los tipos de datos enviados vemos que erlang empieza a hacernos las tareas mas faciles sin tener que declarar tipos complejos antes de enviarlos.
Otra cosa que note es que erlang un poco nos obliga a tratar los errores con el tema de pattern matching por lo que si bien el codigo erlang es un poco mas largo en realidad esta teniendo en cuenta todos los posibles casos de fallo, en el de C por ejemplo si no entro un entero o un float, el comportamiento es indeterminado (en mi maquina se mete en un loop infinito haciendo printf). Ya se que deberia usar algo como un buffer de string y despues usar atoi o similar pero para algo esta scanf :D.