src/smpi/instr_smpi.c

   1 /* Copyright (c) 2010, 2012-2013. 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.h"
   8 #include <ctype.h>
   9 #include <wchar.h>
  10
  11
  12 #ifdef HAVE_TRACING
  13
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_smpi, instr, "Tracing SMPI");
  15
  16 static xbt_dict_t keys;
  17
  18 static const char *smpi_colors[] ={
  19     "recv",     "1 0 0",
  20     "irecv",    "1 0.52 0.52",
  21     "send",     "0 0 1",
  22     "isend",    "0.52 0.52 1",
  23     "sendrecv", "0 1 1",
  24     "wait",     "1 1 0",
  25     "waitall",  "0.78 0.78 0",
  26     "waitany",  "0.78 0.78 0.58",
  27
  28     "allgather",     "1 0 0",
  29     "allgatherv",    "1 0.52 0.52",
  30     "allreduce",     "1 0 1",
  31     "alltoall",      "0.52 0 1",
  32     "alltoallv",     "0.78 0.52 1",
  33     "barrier",       "0 0.78 0.78",
  34     "bcast",         "0 0.78 0.39",
  35     "gather",        "1 1 0",
  36     "gatherv",       "1 1 0.52",
  37     "reduce",        "0 1 0",
  38     "reducescatter", "0.52 1 0.52",
  39     "scan",          "1 0.58 0.23",
  40     "exscan",          "1 0.54 0.25",
  41     "scatterv",      "0.52 0 0.52",
  42     "scatter",       "1 0.74 0.54",
  43     "computing",     "0 1 1",
  44     NULL, NULL,
  45 };
  46
  47 static char *str_tolower (const char *str)
  48 {
  49   char *ret = xbt_strdup (str);
  50   int i, n = strlen (ret);
  51   for (i = 0; i < n; i++)
  52     ret[i] = tolower (str[i]);
  53   return ret;
  54 }
  55
  56 static const char *instr_find_color (const char *state)
  57 {
  58   char *target = str_tolower (state);
  59   const char *ret = NULL;
  60   const char *current;
  61   unsigned int i = 0;
  62   while ((current = smpi_colors[i])){
  63     if (strcmp (state, current) == 0){ ret = smpi_colors[i+1]; break; } //exact match
  64     if (strstr(target, current)) { ret = smpi_colors[i+1]; break; }; //as substring
  65     i+=2;
  66   }
  67   free (target);
  68   return ret;
  69 }
  70
  71
  72 static char *smpi_container(int rank, char *container, int n)
  73 {
  74   snprintf(container, n, "rank-%d", rank);
  75   return container;
  76 }
  77
  78 static char *TRACE_smpi_put_key(int src, int dst, char *key, int n)
  79 {
  80   //get the dynar for src#dst
  81   char aux[INSTR_DEFAULT_STR_SIZE];
  82   snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d", src, dst);
  83   xbt_dynar_t d = xbt_dict_get_or_null(keys, aux);
  84   if (d == NULL) {
  85     d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
  86     xbt_dict_set(keys, aux, d, NULL);
  87   }
  88   //generate the key
  89   static unsigned long long counter = 0;
  90
  91   snprintf(key, n, "%d_%d_%llu", src, dst, counter++);
  92
  93   //push it
  94   char *a = (char*)xbt_strdup(key);
  95   xbt_dynar_push_as(d, char *, a);
  96
  97   return key;
  98 }
  99
 100 static char *TRACE_smpi_get_key(int src, int dst, char *key, int n)
 101 {
 102   char aux[INSTR_DEFAULT_STR_SIZE];
 103   snprintf(aux, INSTR_DEFAULT_STR_SIZE, "%d#%d", src, dst);
 104   xbt_dynar_t d = xbt_dict_get_or_null(keys, aux);
 105
 106   xbt_assert(!xbt_dynar_is_empty(d),
 107       "Trying to get a link key (for message reception) that has no corresponding send (%s).", __FUNCTION__);
 108   char *s = xbt_dynar_get_as (d, 0, char *);
 109   snprintf (key, n, "%s", s);
 110   xbt_dynar_remove_at (d, 0, NULL);
 111   return key;
 112 }
 113
 114 static xbt_dict_t process_category;
 115
 116 void TRACE_internal_smpi_set_category (const char *category)
 117 {
 118   if (!TRACE_smpi_is_enabled()) return;
 119
 120   //declare category
 121   TRACE_category (category);
 122
 123   char processid[INSTR_DEFAULT_STR_SIZE];
 124   snprintf (processid, INSTR_DEFAULT_STR_SIZE, "%p", SIMIX_process_self());
 125   if (xbt_dict_get_or_null (process_category, processid))
 126     xbt_dict_remove (process_category, processid);
 127   if (category != NULL)
 128     xbt_dict_set (process_category, processid, xbt_strdup(category), NULL);
 129 }
 130
 131 const char *TRACE_internal_smpi_get_category (void)
 132 {
 133   if (!TRACE_smpi_is_enabled()) return NULL;
 134
 135   char processid[INSTR_DEFAULT_STR_SIZE];
 136   snprintf (processid, INSTR_DEFAULT_STR_SIZE, "%p", SIMIX_process_self());
 137   return xbt_dict_get_or_null (process_category, processid);
 138 }
 139
 140 void TRACE_smpi_alloc()
 141 {
 142   keys = xbt_dict_new_homogeneous(xbt_dynar_free_voidp);
 143   process_category = xbt_dict_new_homogeneous(xbt_free);
 144 }
 145
 146 void TRACE_smpi_release(void)
 147 {
 148   xbt_dict_free(&keys);
 149   xbt_dict_free(&process_category);
 150 }
 151
 152 void TRACE_smpi_init(int rank)
 153 {
 154   if (!TRACE_smpi_is_enabled()) return;
 155
 156   char str[INSTR_DEFAULT_STR_SIZE];
 157   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 158
 159   container_t father;
 160   if (TRACE_smpi_is_grouped()){
 161     father = PJ_container_get (SIMIX_host_self_get_name());
 162   }else{
 163     father = PJ_container_get_root ();
 164   }
 165   xbt_assert(father!=NULL,
 166       "Could not find a parent for mpi rank %s at function %s", str, __FUNCTION__);
 167   PJ_container_new(str, INSTR_SMPI, father);
 168 }
 169
 170 void TRACE_smpi_finalize(int rank)
 171 {
 172   if (!TRACE_smpi_is_enabled()) return;
 173
 174   char str[INSTR_DEFAULT_STR_SIZE];
 175   container_t container = PJ_container_get(smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE));
 176   PJ_container_remove_from_parent (container);
 177   PJ_container_free (container);
 178 }
 179
 180 void TRACE_smpi_collective_in(int rank, int root, const char *operation, int size)
 181 {
 182   if (!TRACE_smpi_is_enabled()) return;
 183
 184   char str[INSTR_DEFAULT_STR_SIZE];
 185   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 186   container_t container = PJ_container_get (str);
 187   type_t type = PJ_type_get ("MPI_STATE", container->type);
 188   const char *color = instr_find_color (operation);
 189   val_t value = PJ_value_get_or_new (operation, color, type);
 190   new_pajePushStateWithSize (SIMIX_get_clock(), container, type, value, size);
 191 }
 192
 193 void TRACE_smpi_collective_out(int rank, int root, const char *operation)
 194 {
 195   if (!TRACE_smpi_is_enabled()) return;
 196
 197   char str[INSTR_DEFAULT_STR_SIZE];
 198   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 199   container_t container = PJ_container_get (str);
 200   type_t type = PJ_type_get ("MPI_STATE", container->type);
 201
 202   new_pajePopState (SIMIX_get_clock(), container, type);
 203 }
 204
 205 void TRACE_smpi_computing_init(int rank)
 206 {
 207  //first use, initialize the color in the trace
 208  //TODO : check with lucas and Pierre how to generalize this approach
 209   //to avoid unnecessary access to the color array
 210   if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_computing()) return;
 211
 212   char str[INSTR_DEFAULT_STR_SIZE];
 213   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 214   container_t container = PJ_container_get (str);
 215   type_t mpi = PJ_type_get("MPI", PJ_container_get_root()->type);
 216   type_t type = PJ_type_state_new ("COMPUTATION", mpi);
 217   const char *color = instr_find_color ("computing");
 218   val_t value = PJ_value_get_or_new ("computing", color, type);
 219   new_pajePushState (SIMIX_get_clock(), container, type, value);
 220 }
 221
 222 void TRACE_smpi_computing_in(int rank)
 223 {
 224   //do not forget to set the color first, otherwise this will explode
 225   if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
 226
 227   char str[INSTR_DEFAULT_STR_SIZE];
 228   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 229   container_t container = PJ_container_get (str);
 230   type_t type = PJ_type_get ("COMPUTATION", container->type);
 231   val_t value = PJ_value_get_or_new ("computing", NULL, type);
 232   new_pajePushState (SIMIX_get_clock(), container, type, value);
 233 }
 234
 235 void TRACE_smpi_computing_out(int rank, double flops)
 236 {
 237   if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
 238   char str[INSTR_DEFAULT_STR_SIZE];
 239   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 240   container_t container = PJ_container_get (str);
 241   type_t type = PJ_type_get ("COMPUTATION", container->type);
 242   xbt_dynar_t extra= xbt_dynar_new(sizeof(char*), NULL);
 243   char* char_duration  = bprintf("%g", flops);
 244   xbt_dynar_push(extra, &char_duration);
 245   new_pajePopStateWithExtra (SIMIX_get_clock(), container, type, extra);
 246 }
 247
 248 void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, int size)
 249 {
 250   if (!TRACE_smpi_is_enabled()) return;
 251
 252
 253   char str[INSTR_DEFAULT_STR_SIZE];
 254   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 255   container_t container = PJ_container_get (str);
 256   type_t type = PJ_type_get ("MPI_STATE", container->type);
 257   const char *color = instr_find_color (operation);
 258   val_t value = PJ_value_get_or_new (operation, color, type);
 259   new_pajePushStateWithSize (SIMIX_get_clock(), container, type, value, size);
 260 }
 261
 262 void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
 263 {
 264   if (!TRACE_smpi_is_enabled()) return;
 265
 266   char str[INSTR_DEFAULT_STR_SIZE];
 267   smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
 268   container_t container = PJ_container_get (str);
 269   type_t type = PJ_type_get ("MPI_STATE", container->type);
 270
 271   new_pajePopState (SIMIX_get_clock(), container, type);
 272 }
 273
 274 void TRACE_smpi_send(int rank, int src, int dst, int size)
 275 {
 276   if (!TRACE_smpi_is_enabled()) return;
 277
 278   char key[INSTR_DEFAULT_STR_SIZE] = {0};
 279   TRACE_smpi_put_key(src, dst, key, INSTR_DEFAULT_STR_SIZE);
 280
 281   char str[INSTR_DEFAULT_STR_SIZE];
 282   smpi_container(src, str, INSTR_DEFAULT_STR_SIZE);
 283   container_t container = PJ_container_get (str);
 284   type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
 285
 286   new_pajeStartLinkWithSize (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key, size);
 287 }
 288
 289 void TRACE_smpi_recv(int rank, int src, int dst)
 290 {
 291   if (!TRACE_smpi_is_enabled()) return;
 292
 293   char key[INSTR_DEFAULT_STR_SIZE] = {0};
 294   TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE);
 295
 296   char str[INSTR_DEFAULT_STR_SIZE];
 297   smpi_container(dst, str, INSTR_DEFAULT_STR_SIZE);
 298   container_t container = PJ_container_get (str);
 299   type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
 300
 301   new_pajeEndLink (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key);
 302 }
 303 #endif /* HAVE_TRACING */