[sonar] Less implicit casts.

[simgrid.git] / src / smpi / internals / smpi_replay.cpp

diff --git a/src/smpi/internals/smpi_replay.cpp b/src/smpi/internals/smpi_replay.cpp
index 1c64f67..116b5ad 100644 (file)
--- a/src/smpi/internals/smpi_replay.cpp
+++ b/src/smpi/internals/smpi_replay.cpp
@@ -70,10 +70,29 @@ void log_timed_action(const simgrid::xbt::ReplayAction& action, double clock)
   }
 }
 
-/* Helper function */
+/* Helper functions */
 static double parse_double(const std::string& string)
 {
-  return xbt_str_parse_double(string.c_str(), "%s is not a double");
+  return xbt_str_parse_double(string.c_str(), "not a double");
+}
+
+template <typename T> static T parse_integer(const std::string& string)
+{
+  double val = trunc(xbt_str_parse_double(string.c_str(), "not a double"));
+  xbt_assert(static_cast<double>(std::numeric_limits<T>::min()) <= val &&
+                 val <= static_cast<double>(std::numeric_limits<T>::max()),
+             "out of range: %g", val);
+  return static_cast<T>(val);
+}
+
+static int parse_root(const simgrid::xbt::ReplayAction& action, unsigned i)
+{
+  return i < action.size() ? std::stoi(action[i]) : 0;
+}
+
+static MPI_Datatype parse_datatype(const simgrid::xbt::ReplayAction& action, unsigned i)
+{
+  return i < action.size() ? simgrid::smpi::Datatype::decode(action[i]) : simgrid::smpi::replay::MPI_DEFAULT_TYPE;
 }
 
 namespace simgrid {
@@ -147,9 +166,8 @@ void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, const std::string
   CHECK_ACTION_PARAMS(action, 3, 1)
   partner = std::stoi(action[2]);
   tag     = std::stoi(action[3]);
-  size    = parse_double(action[4]);
-  if (action.size() > 5)
-    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
+  size      = parse_integer<size_t>(action[4]);
+  datatype1 = parse_datatype(action, 5);
 }
 
 void ComputeParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
@@ -174,46 +192,36 @@ void LocationParser::parse(simgrid::xbt::ReplayAction& action, const std::string
 void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 1, 2)
-  size = parse_double(action[2]);
-  root = (action.size() > 3) ? std::stoi(action[3]) : 0;
-  if (action.size() > 4)
-    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
+  size      = parse_integer<size_t>(action[2]);
+  root      = parse_root(action, 3);
+  datatype1 = parse_datatype(action, 4);
 }
 
 void ReduceArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 2)
-  double arg2 = trunc(parse_double(action[2]));
-  xbt_assert(0.0 <= arg2 && arg2 <= static_cast<double>(std::numeric_limits<unsigned>::max()));
-  comm_size = static_cast<unsigned>(arg2);
+  comm_size = parse_integer<unsigned>(action[2]);
   comp_size = parse_double(action[3]);
-  root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
-  if (action.size() > 5)
-    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
+  root      = parse_root(action, 4);
+  datatype1 = parse_datatype(action, 5);
 }
 
 void AllReduceArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 1)
-  double arg2 = trunc(parse_double(action[2]));
-  xbt_assert(0.0 <= arg2 && arg2 <= static_cast<double>(std::numeric_limits<unsigned>::max()));
-  comm_size = static_cast<unsigned>(arg2);
+  comm_size = parse_integer<unsigned>(action[2]);
   comp_size = parse_double(action[3]);
-  if (action.size() > 4)
-    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
+  datatype1 = parse_datatype(action, 4);
 }
 
 void AllToAllArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
 {
   CHECK_ACTION_PARAMS(action, 2, 1)
   comm_size = MPI_COMM_WORLD->size();
-  send_size = parse_double(action[2]);
-  recv_size = parse_double(action[3]);
-
-  if (action.size() > 4)
-    datatype1 = simgrid::smpi::Datatype::decode(action[4]);
-  if (action.size() > 5)
-    datatype2 = simgrid::smpi::Datatype::decode(action[5]);
+  send_size = parse_integer<int>(action[2]);
+  recv_size = parse_integer<int>(action[3]);
+  datatype1 = parse_datatype(action, 4);
+  datatype2 = parse_datatype(action, 5);
 }
 
 void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string& name)
@@ -229,20 +237,17 @@ void GatherArgParser::parse(simgrid::xbt::ReplayAction& action, const std::strin
   */
   CHECK_ACTION_PARAMS(action, 2, 3)
   comm_size = MPI_COMM_WORLD->size();
-  send_size = parse_double(action[2]);
-  recv_size = parse_double(action[3]);
+  send_size = parse_integer<int>(action[2]);
+  recv_size = parse_integer<int>(action[3]);
 
   if (name == "gather") {
-    root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
-    if (action.size() > 5)
-      datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-    if (action.size() > 6)
-      datatype2 = simgrid::smpi::Datatype::decode(action[6]);
+    root      = parse_root(action, 4);
+    datatype1 = parse_datatype(action, 5);
+    datatype2 = parse_datatype(action, 6);
   } else {
-    if (action.size() > 4)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4]);
-    if (action.size() > 5)
-      datatype2 = simgrid::smpi::Datatype::decode(action[5]);
+    root      = 0;
+    datatype1 = parse_datatype(action, 4);
+    datatype2 = parse_datatype(action, 5);
   }
 }
 
@@ -259,37 +264,39 @@ void GatherVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::stri
   */
   comm_size = MPI_COMM_WORLD->size();
   CHECK_ACTION_PARAMS(action, comm_size + 1, 2)
-  send_size  = parse_double(action[2]);
+  send_size  = parse_integer<int>(action[2]);
   disps      = std::vector<int>(comm_size, 0);
   recvcounts = std::make_shared<std::vector<int>>(comm_size);
 
   if (name == "gatherv") {
-    root = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
-    if (action.size() > 4 + comm_size)
-      datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
-    if (action.size() > 5 + comm_size)
-      datatype2 = simgrid::smpi::Datatype::decode(action[5 + comm_size]);
+    root      = parse_root(action, 3 + comm_size);
+    datatype1 = parse_datatype(action, 4 + comm_size);
+    datatype2 = parse_datatype(action, 5 + comm_size);
   } else {
-    int disp_index     = 0;
+    root                = 0;
+    unsigned disp_index = 0;
     /* The 3 comes from "0 gather <sendcount>", which must always be present.
      * The + comm_size is the recvcounts array, which must also be present
      */
-    if (action.size() > 3 + comm_size + comm_size) { /* datatype + disp are specified */
-      int datatype_index = 3 + comm_size;
-      disp_index     = datatype_index + 1;
-      datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-      datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-    } else if (action.size() >
-               3 + comm_size + 2) { /* disps specified; datatype is not specified; use the default one */
+    if (action.size() > 3 + comm_size + comm_size) {
+      // datatype + disp are specified
+      datatype1  = parse_datatype(action, 3 + comm_size);
+      datatype2  = parse_datatype(action, 4 + comm_size);
+      disp_index = 5 + comm_size;
+    } else if (action.size() > 3 + comm_size + 2) {
+      // disps specified; datatype is not specified; use the default one
+      datatype1  = MPI_DEFAULT_TYPE;
+      datatype2  = MPI_DEFAULT_TYPE;
       disp_index = 3 + comm_size;
-    } else if (action.size() > 3 + comm_size) { /* only datatype, no disp specified */
-      int datatype_index = 3 + comm_size;
-      datatype1      = simgrid::smpi::Datatype::decode(action[datatype_index]);
-      datatype2      = simgrid::smpi::Datatype::decode(action[datatype_index]);
+    } else {
+      // no disp specified, maybe only datatype,
+      datatype1 = parse_datatype(action, 3 + comm_size);
+      datatype2 = parse_datatype(action, 4 + comm_size);
     }
 
     if (disp_index != 0) {
-      for (unsigned int i = 0; i < comm_size; i++)
+      xbt_assert(disp_index + comm_size <= action.size());
+      for (unsigned i = 0; i < comm_size; i++)
         disps[i]          = std::stoi(action[disp_index + i]);
     }
   }
@@ -313,13 +320,11 @@ void ScatterArgParser::parse(simgrid::xbt::ReplayAction& action, const std::stri
   */
   CHECK_ACTION_PARAMS(action, 2, 3)
   comm_size = MPI_COMM_WORLD->size();
-  send_size = parse_double(action[2]);
-  recv_size = parse_double(action[3]);
-  root      = (action.size() > 4) ? std::stoi(action[4]) : 0;
-  if (action.size() > 5)
-    datatype1 = simgrid::smpi::Datatype::decode(action[5]);
-  if (action.size() > 6)
-    datatype2 = simgrid::smpi::Datatype::decode(action[6]);
+  send_size = parse_integer<int>(action[2]);
+  recv_size = parse_integer<int>(action[3]);
+  root      = parse_root(action, 4);
+  datatype1 = parse_datatype(action, 5);
+  datatype2 = parse_datatype(action, 6);
 }
 
 void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
@@ -334,20 +339,18 @@ void ScatterVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::str
       5) 0 is the recv datatype id, see simgrid::smpi::Datatype::decode()
   */
   CHECK_ACTION_PARAMS(action, comm_size + 1, 2)
-  recv_size  = parse_double(action[2 + comm_size]);
+  recv_size  = parse_integer<int>(action[2 + comm_size]);
   disps      = std::vector<int>(comm_size, 0);
   sendcounts = std::make_shared<std::vector<int>>(comm_size);
 
-  if (action.size() > 5 + comm_size)
-    datatype1 = simgrid::smpi::Datatype::decode(action[4 + comm_size]);
-  if (action.size() > 5 + comm_size)
-    datatype2 = simgrid::smpi::Datatype::decode(action[5]);
+  root      = parse_root(action, 3 + comm_size);
+  datatype1 = parse_datatype(action, 4 + comm_size);
+  datatype2 = parse_datatype(action, 5 + comm_size);
 
   for (unsigned int i = 0; i < comm_size; i++) {
     (*sendcounts)[i] = std::stoi(action[i + 2]);
   }
   send_size_sum = std::accumulate(sendcounts->begin(), sendcounts->end(), 0);
-  root          = (action.size() > 3 + comm_size) ? std::stoi(action[3 + comm_size]) : 0;
 }
 
 void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
@@ -363,8 +366,7 @@ void ReduceScatterArgParser::parse(simgrid::xbt::ReplayAction& action, const std
   CHECK_ACTION_PARAMS(action, comm_size + 1, 1)
   comp_size  = parse_double(action[2 + comm_size]);
   recvcounts = std::make_shared<std::vector<int>>(comm_size);
-  if (action.size() > 3 + comm_size)
-    datatype1 = simgrid::smpi::Datatype::decode(action[3 + comm_size]);
+  datatype1  = parse_datatype(action, 3 + comm_size);
 
   for (unsigned int i = 0; i < comm_size; i++) {
     recvcounts->push_back(std::stoi(action[i + 2]));
@@ -389,13 +391,11 @@ void AllToAllVArgParser::parse(simgrid::xbt::ReplayAction& action, const std::st
   senddisps  = std::vector<int>(comm_size, 0);
   recvdisps  = std::vector<int>(comm_size, 0);
 
-  if (action.size() > 5 + 2 * comm_size)
-    datatype1 = simgrid::smpi::Datatype::decode(action[4 + 2 * comm_size]);
-  if (action.size() > 5 + 2 * comm_size)
-    datatype2 = simgrid::smpi::Datatype::decode(action[5 + 2 * comm_size]);
+  datatype1 = parse_datatype(action, 4 + 2 * comm_size);
+  datatype2 = parse_datatype(action, 5 + 2 * comm_size);
 
-  send_buf_size = parse_double(action[2]);
-  recv_buf_size = parse_double(action[3 + comm_size]);
+  send_buf_size = parse_integer<int>(action[2]);
+  recv_buf_size = parse_integer<int>(action[3 + comm_size]);
   for (unsigned int i = 0; i < comm_size; i++) {
     (*sendcounts)[i] = std::stoi(action[3 + i]);
     (*recvcounts)[i] = std::stoi(action[4 + comm_size + i]);
@@ -466,8 +466,8 @@ void RecvAction::kernel(simgrid::xbt::ReplayAction&)
 
   MPI_Status status;
   // unknown size from the receiver point of view
-  double arg_size = args.size;
-  if (arg_size <= 0.0) {
+  size_t arg_size = args.size;
+  if (arg_size == 0.0) {
     Request::probe(args.partner, args.tag, MPI_COMM_WORLD, &status);
     arg_size = status.count;
   }
@@ -637,8 +637,8 @@ void AllToAllAction::kernel(simgrid::xbt::ReplayAction&)
                                                     Datatype::encode(args.datatype1),
                                                     Datatype::encode(args.datatype2)));
 
-  colls::alltoall(send_buffer(args.send_size * args.comm_size * args.datatype1->size()), args.send_size, args.datatype1,
-                  recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()), args.recv_size, args.datatype2,
+  colls::alltoall(send_buffer(args.datatype1->size() * args.send_size * args.comm_size), args.send_size, args.datatype1,
+                  recv_buffer(args.datatype2->size() * args.recv_size * args.comm_size), args.recv_size, args.datatype2,
                   MPI_COMM_WORLD);
 
   TRACE_smpi_comm_out(get_pid());
@@ -655,7 +655,7 @@ void GatherAction::kernel(simgrid::xbt::ReplayAction&)
   if (get_name() == "gather") {
     int rank = MPI_COMM_WORLD->rank();
     colls::gather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,
-                  (rank == args.root) ? recv_buffer(args.recv_size * args.comm_size * args.datatype2->size()) : nullptr,
+                  (rank == args.root) ? recv_buffer(args.datatype2->size() * args.recv_size * args.comm_size) : nullptr,
                   args.recv_size, args.datatype2, args.root, MPI_COMM_WORLD);
   } else
     colls::allgather(send_buffer(args.send_size * args.datatype1->size()), args.send_size, args.datatype1,