src/smpi/internals/instr_smpi.cpp

   1 /* Copyright (c) 2010-2018. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "private.hpp"
   8 #include <boost/algorithm/string.hpp>
   9 #include <simgrid/s4u/Actor.hpp>
  10 #include <cctype>
  11 #include <cstdarg>
  12 #include <cwchar>
  13 #include <deque>
  14 #include <simgrid/sg_config.hpp>
  15 #include <simgrid/s4u/Host.hpp>
  16 #include <string>
  17 #include <vector>
  18 #include "smpi_process.hpp"
  19
  20
  21 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_smpi, instr, "Tracing SMPI");
  22
  23 static std::unordered_map<std::string, std::deque<std::string>*> keys;
  24
  25 static std::map<std::string, std::string> smpi_colors = {{"recv", "1 0 0"},
  26   {"irecv", "1 0.52 0.52"},
  27   {"send", "0 0 1"},
  28   {"isend", "0.52 0.52 1"},
  29   {"sendrecv", "0 1 1"},
  30   {"wait", "1 1 0"},
  31   {"waitall", "0.78 0.78 0"},
  32   {"waitany", "0.78 0.78 0.58"},
  33   {"test", "0.52 0.52 0"},
  34
  35   {"allgather", "1 0 0"},
  36   {"allgatherv", "1 0.52 0.52"},
  37   {"allreduce", "1 0 1"},
  38   {"alltoall", "0.52 0 1"},
  39   {"alltoallv", "0.78 0.52 1"},
  40   {"barrier", "0 0.78 0.78"},
  41   {"bcast", "0 0.78 0.39"},
  42   {"gather", "1 1 0"},
  43   {"gatherv", "1 1 0.52"},
  44   {"reduce", "0 1 0"},
  45   {"reducescatter", "0.52 1 0.52"},
  46   {"scan", "1 0.58 0.23"},
  47   {"exscan", "1 0.54 0.25"},
  48   {"scatterv", "0.52 0 0.52"},
  49   {"scatter", "1 0.74 0.54"},
  50
  51   {"computing", "0 1 1"},
  52   {"sleeping", "0 0.5 0.5"},
  53
  54   {"init", "0 1 0"},
  55   {"finalize", "0 1 0"},
  56
  57   {"put", "0.3 1 0"},
  58   {"get", "0 1 0.3"},
  59   {"accumulate", "1 0.3 0"},
  60   {"migration", "0.2 0.5 0.2"},
  61   {"rput", "0.3 1 0"},
  62   {"rget", "0 1 0.3"},
  63   {"raccumulate", "1 0.3 0"},
  64   {"compare_and_swap", "0.3 1 0"},
  65   {"get_accumulate", "0 1 0.3"},
  66   {"rget_accumulate", "1 0.3 0"},
  67   {"win_fence", "1 0 0.3"},
  68   {"win_post", "1 0 0.8"},
  69   {"win_wait", "1 0.8 0"},
  70   {"win_start", "0.8 0 1"},
  71   {"win_complete", "0.8 1 0"},
  72   {"win_lock", "1 0 0.3"},
  73   {"win_unlock", "1 0 0.3"},
  74   {"win_lock_all", "1 0 0.8"},
  75   {"win_unlock_all", "1 0.8 0"},
  76   {"win_flush", "1 0 0.3"},
  77   {"win_flush_local", "1 0 0.8"},
  78   {"win_flush_all", "1 0.8 0"},
  79   {"win_flush_local_all", "1 0 0.3"}
  80 };
  81
  82 static const char* instr_find_color(std::string state)
  83 {
  84   boost::algorithm::to_lower(state);
  85   if (state.substr(0, 5) == "pmpi_")
  86     state = state.substr(5, std::string::npos); // Remove pmpi_ to allow for exact matches
  87
  88   if (smpi_colors.find(state) != smpi_colors.end()) { // Exact match in the map?
  89     return smpi_colors.find(state)->second.c_str();
  90   }
  91   for (const auto& pair : smpi_colors) { // Is an entry of our map a substring of this state name?
  92     if (std::strstr(state.c_str(), pair.first.c_str()) != 0)
  93       return pair.second.c_str();
  94   }
  95
  96   return "0.5 0.5 0.5"; // Just in case we find nothing in the map ...
  97 }
  98
  99 XBT_PRIVATE container_t smpi_container(int rank)
 100 {
 101   return simgrid::instr::Container::by_name(std::string("rank-") + std::to_string(rank));
 102 }
 103
 104 static std::string TRACE_smpi_put_key(int src, int dst, int tag, int send)
 105 {
 106   // get the deque for src#dst
 107   std::string aux =
 108       std::to_string(src) + "#" + std::to_string(dst) + "#" + std::to_string(tag) + "#" + std::to_string(send);
 109   auto it = keys.find(aux);
 110   std::deque<std::string>* d;
 111
 112   if (it == keys.end()) {
 113     d         = new std::deque<std::string>;
 114     keys[aux] = d;
 115   } else
 116     d = it->second;
 117
 118   //generate the key
 119   static unsigned long long counter = 0;
 120   counter++;
 121   std::string key =
 122       std::to_string(src) + "_" + std::to_string(dst) + "_" + std::to_string(tag) + "_" + std::to_string(counter);
 123
 124   //push it
 125   d->push_back(key);
 126
 127   return key;
 128 }
 129
 130 static std::string TRACE_smpi_get_key(int src, int dst, int tag, int send)
 131 {
 132   std::string key;
 133   std::string aux = std::to_string(src) + "#" + std::to_string(dst) + "#" + std::to_string(tag) + "#" +
 134                     std::to_string(send == 1 ? 0 : 1);
 135   auto it = keys.find(aux);
 136   if (it == keys.end()) {
 137     // first posted
 138     key = TRACE_smpi_put_key(src, dst, tag, send);
 139   } else {
 140     key = it->second->front();
 141     it->second->pop_front();
 142   }
 143   return key;
 144 }
 145
 146 static std::unordered_map<smx_actor_t, std::string> process_category;
 147
 148 void TRACE_internal_smpi_set_category (const char *category)
 149 {
 150   if (not TRACE_smpi_is_enabled())
 151     return;
 152
 153   //declare category
 154   TRACE_category (category);
 155
 156   if (category != nullptr)
 157     process_category[SIMIX_process_self()] = category;
 158 }
 159
 160 const char *TRACE_internal_smpi_get_category ()
 161 {
 162   if (not TRACE_smpi_is_enabled())
 163     return nullptr;
 164
 165   auto it = process_category.find(SIMIX_process_self());
 166   return (it == process_category.end()) ? nullptr : it->second.c_str();
 167 }
 168
 169 void TRACE_smpi_release()
 170 {
 171   for (auto const& elm : keys)
 172     delete elm.second;
 173 }
 174
 175 void TRACE_smpi_setup_container(int rank, sg_host_t host)
 176 {
 177   container_t father = simgrid::instr::Container::get_root();
 178   if (TRACE_smpi_is_grouped()) {
 179     father = simgrid::instr::Container::by_name_or_null(host->get_name());
 180     xbt_assert(father != nullptr, "Could not find a parent for mpi rank 'rank-%d' at function %s", rank, __func__);
 181   }
 182   father->create_child(std::string("rank-") + std::to_string(rank), "MPI"); // This container is of type MPI
 183 }
 184
 185 void TRACE_smpi_init(int rank)
 186 {
 187   if (not TRACE_smpi_is_enabled())
 188     return;
 189
 190   TRACE_smpi_setup_container(rank, sg_host_self());
 191 #if HAVE_PAPI
 192   container_t container   = smpi_container(rank);
 193   papi_counter_t counters = smpi_process()->papi_counters();
 194
 195   for (auto const& it : counters) {
 196     /**
 197      * Check whether this variable already exists or not. Otherwise, it will be created
 198      * multiple times but only the last one would be used...
 199      */
 200     container->type_->by_name_or_create(it.first, "");
 201   }
 202 #endif
 203 }
 204
 205 void TRACE_smpi_finalize(int rank)
 206 {
 207   if (not TRACE_smpi_is_enabled())
 208     return;
 209
 210   smpi_container(rank)->remove_from_parent();
 211 }
 212
 213 void TRACE_smpi_computing_init(int rank)
 214 {
 215  //first use, initialize the color in the trace
 216  if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
 217    smpi_container(rank)->get_state("MPI_STATE")->add_entity_value("computing", instr_find_color("computing"));
 218 }
 219
 220 void TRACE_smpi_sleeping_init(int rank)
 221 {
 222  //first use, initialize the color in the trace
 223  if (TRACE_smpi_is_enabled() && TRACE_smpi_is_sleeping())
 224    smpi_container(rank)->get_state("MPI_STATE")->add_entity_value("sleeping", instr_find_color("sleeping"));
 225 }
 226
 227 void TRACE_smpi_computing_in(int rank, double amount)
 228 {
 229   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
 230     smpi_container(rank)
 231         ->get_state("MPI_STATE")
 232         ->push_event("computing", new simgrid::instr::CpuTIData("compute", amount));
 233 }
 234
 235 void TRACE_smpi_computing_out(int rank)
 236 {
 237   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
 238     smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 239 }
 240
 241 void TRACE_smpi_sleeping_in(int rank, double duration)
 242 {
 243   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_sleeping())
 244     smpi_container(rank)
 245         ->get_state("MPI_STATE")
 246         ->push_event("sleeping", new simgrid::instr::CpuTIData("sleep", duration));
 247 }
 248
 249 void TRACE_smpi_sleeping_out(int rank)
 250 {
 251   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_sleeping())
 252     smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 253 }
 254
 255 void TRACE_smpi_comm_in(int rank, const char* operation, simgrid::instr::TIData* extra)
 256 {
 257   if (not TRACE_smpi_is_enabled()) {
 258     delete extra;
 259     return;
 260   }
 261
 262   simgrid::instr::StateType* state = smpi_container(rank)->get_state("MPI_STATE");
 263   state->add_entity_value(operation, instr_find_color(operation));
 264   state->push_event(operation, extra);
 265 }
 266
 267 void TRACE_smpi_comm_out(int rank)
 268 {
 269   if (TRACE_smpi_is_enabled())
 270     smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 271 }
 272
 273 void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
 274 {
 275   if (not TRACE_smpi_is_enabled())
 276     return;
 277
 278   std::string key = TRACE_smpi_get_key(src, dst, tag, 1);
 279
 280   XBT_DEBUG("Send tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
 281   simgrid::instr::Container::get_root()->get_link("MPI_LINK")->start_event(smpi_container(rank), "PTP", key, size);
 282 }
 283
 284 void TRACE_smpi_recv(int src, int dst, int tag)
 285 {
 286   if (not TRACE_smpi_is_enabled())
 287     return;
 288
 289   std::string key = TRACE_smpi_get_key(src, dst, tag, 0);
 290
 291   XBT_DEBUG("Recv tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
 292   simgrid::instr::Container::get_root()->get_link("MPI_LINK")->end_event(smpi_container(dst), "PTP", key);
 293 }
 294
 295 /**************** Functions to trace the migration of tasks. *****************/
 296 void TRACE_smpi_send_process_data_in(int rank)
 297 {
 298   if (not TRACE_smpi_is_enabled()) return;
 299
 300   smpi_container(rank)->get_state("MIGRATE_STATE")->add_entity_value("migration", instr_find_color("migration"));
 301   smpi_container(rank)->get_state("MIGRATE_STATE")->push_event("migration");
 302 }
 303
 304 void TRACE_smpi_send_process_data_out(int rank)
 305 {
 306   if (not TRACE_smpi_is_enabled()) return;
 307
 308   /* Clean the process state. */
 309   smpi_container(rank)->get_state("MIGRATE_STATE")->pop_event();
 310 }
 311
 312 void TRACE_smpi_process_change_host(int rank, sg_host_t new_host)
 313 {
 314   if (!TRACE_smpi_is_enabled()) return;
 315
 316   /** The key is (most likely) used to match the events in the trace */
 317   static long long int counter = 0;
 318   std::string key              = std::to_string(counter);
 319   counter++;
 320
 321   // start link (= tell the trace that this rank moves from A to B)
 322   container_t cont = smpi_container(rank);
 323   simgrid::instr::Container::get_root()->get_link("MIGRATE_LINK")->start_event(cont, "M", key);
 324
 325   // Destroy container of this rank on this host
 326   cont->remove_from_parent();
 327
 328   // Setup container on new host
 329   TRACE_smpi_setup_container(rank, new_host);
 330
 331   // end link
 332   cont = smpi_container(rank); // This points to the newly created container
 333   simgrid::instr::Container::get_root()->get_link("MIGRATE_LINK")->end_event(cont, "M", key);
 334 }