src/mc/mc_request.c

   1 /* Copyright (c) 2008-2014. 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 "mc_request.h"
   8 #include "mc_safety.h"
   9 #include "mc_private.h"
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_request, mc,
  12                                 "Logging specific to MC (request)");
  13
  14 static char *pointer_to_string(void *pointer);
  15 static char *buff_size_to_string(size_t size);
  16
  17 int MC_request_depend(smx_simcall_t r1, smx_simcall_t r2)
  18 {
  19   if (mc_reduce_kind == e_mc_reduce_none)
  20     return TRUE;
  21
  22   if (r1->issuer == r2->issuer)
  23     return FALSE;
  24
  25   /* Wait with timeout transitions are not considered by the independance theorem, thus we consider them as dependant with all other transitions */
  26   if ((r1->call == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(r1) > 0)
  27       || (r2->call == SIMCALL_COMM_WAIT
  28           && simcall_comm_wait__get__timeout(r2) > 0))
  29     return TRUE;
  30
  31   if (r1->call == SIMCALL_COMM_ISEND && r2->call == SIMCALL_COMM_IRECV)
  32     return FALSE;
  33
  34   if (r1->call == SIMCALL_COMM_IRECV && r2->call == SIMCALL_COMM_ISEND)
  35     return FALSE;
  36
  37   if ((r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV)
  38       && r2->call == SIMCALL_COMM_WAIT) {
  39
  40     smx_rdv_t rdv =
  41         r1->call ==
  42         SIMCALL_COMM_ISEND ? simcall_comm_isend__get__rdv(r1) :
  43         simcall_comm_irecv__get__rdv(r1);
  44
  45     if (rdv != simcall_comm_wait__get__comm(r2)->comm.rdv_cpy
  46         && simcall_comm_wait__get__timeout(r2) <= 0)
  47       return FALSE;
  48
  49     if ((r1->issuer != simcall_comm_wait__get__comm(r2)->comm.src_proc)
  50         && (r1->issuer != simcall_comm_wait__get__comm(r2)->comm.dst_proc)
  51         && simcall_comm_wait__get__timeout(r2) <= 0)
  52       return FALSE;
  53
  54     if ((r1->call == SIMCALL_COMM_ISEND)
  55         && (simcall_comm_wait__get__comm(r2)->comm.type == SIMIX_COMM_SEND)
  56         && (simcall_comm_wait__get__comm(r2)->comm.src_buff !=
  57             simcall_comm_isend__get__src_buff(r1))
  58         && simcall_comm_wait__get__timeout(r2) <= 0)
  59       return FALSE;
  60
  61     if ((r1->call == SIMCALL_COMM_IRECV)
  62         && (simcall_comm_wait__get__comm(r2)->comm.type == SIMIX_COMM_RECEIVE)
  63         && (simcall_comm_wait__get__comm(r2)->comm.dst_buff !=
  64             simcall_comm_irecv__get__dst_buff(r1))
  65         && simcall_comm_wait__get__timeout(r2) <= 0)
  66       return FALSE;
  67   }
  68
  69   if ((r2->call == SIMCALL_COMM_ISEND || r2->call == SIMCALL_COMM_IRECV)
  70       && r1->call == SIMCALL_COMM_WAIT) {
  71
  72     smx_rdv_t rdv =
  73         r2->call ==
  74         SIMCALL_COMM_ISEND ? simcall_comm_isend__get__rdv(r2) :
  75         simcall_comm_irecv__get__rdv(r2);
  76
  77     if (rdv != simcall_comm_wait__get__comm(r1)->comm.rdv_cpy
  78         && simcall_comm_wait__get__timeout(r1) <= 0)
  79       return FALSE;
  80
  81     if ((r2->issuer != simcall_comm_wait__get__comm(r1)->comm.src_proc)
  82         && (r2->issuer != simcall_comm_wait__get__comm(r1)->comm.dst_proc)
  83         && simcall_comm_wait__get__timeout(r1) <= 0)
  84       return FALSE;
  85
  86     if ((r2->call == SIMCALL_COMM_ISEND)
  87         && (simcall_comm_wait__get__comm(r1)->comm.type == SIMIX_COMM_SEND)
  88         && (simcall_comm_wait__get__comm(r1)->comm.src_buff !=
  89             simcall_comm_isend__get__src_buff(r2))
  90         && simcall_comm_wait__get__timeout(r1) <= 0)
  91       return FALSE;
  92
  93     if ((r2->call == SIMCALL_COMM_IRECV)
  94         && (simcall_comm_wait__get__comm(r1)->comm.type == SIMIX_COMM_RECEIVE)
  95         && (simcall_comm_wait__get__comm(r1)->comm.dst_buff !=
  96             simcall_comm_irecv__get__dst_buff(r2))
  97         && simcall_comm_wait__get__timeout(r1) <= 0)
  98       return FALSE;
  99   }
 100
 101   /* FIXME: the following rule assumes that the result of the
 102    * isend/irecv call is not stored in a buffer used in the
 103    * test call. */
 104   /*if(   (r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV)
 105      &&  r2->call == SIMCALL_COMM_TEST)
 106      return FALSE; */
 107
 108   /* FIXME: the following rule assumes that the result of the
 109    * isend/irecv call is not stored in a buffer used in the
 110    * test call.*/
 111   /*if(   (r2->call == SIMCALL_COMM_ISEND || r2->call == SIMCALL_COMM_IRECV)
 112      && r1->call == SIMCALL_COMM_TEST)
 113      return FALSE; */
 114
 115   if (r1->call == SIMCALL_COMM_ISEND && r2->call == SIMCALL_COMM_ISEND
 116       && simcall_comm_isend__get__rdv(r1) != simcall_comm_isend__get__rdv(r2))
 117     return FALSE;
 118
 119   if (r1->call == SIMCALL_COMM_IRECV && r2->call == SIMCALL_COMM_IRECV
 120       && simcall_comm_irecv__get__rdv(r1) != simcall_comm_irecv__get__rdv(r2))
 121     return FALSE;
 122
 123   if (r1->call == SIMCALL_COMM_WAIT
 124       && (r2->call == SIMCALL_COMM_WAIT || r2->call == SIMCALL_COMM_TEST)
 125       && (simcall_comm_wait__get__comm(r1)->comm.src_proc == NULL
 126           || simcall_comm_wait__get__comm(r1)->comm.dst_proc == NULL))
 127     return FALSE;
 128
 129   if (r2->call == SIMCALL_COMM_WAIT
 130       && (r1->call == SIMCALL_COMM_WAIT || r1->call == SIMCALL_COMM_TEST)
 131       && (simcall_comm_wait__get__comm(r2)->comm.src_proc == NULL
 132           || simcall_comm_wait__get__comm(r2)->comm.dst_proc == NULL))
 133     return FALSE;
 134
 135   if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_WAIT
 136       && simcall_comm_wait__get__comm(r1)->comm.src_buff ==
 137       simcall_comm_wait__get__comm(r2)->comm.src_buff
 138       && simcall_comm_wait__get__comm(r1)->comm.dst_buff ==
 139       simcall_comm_wait__get__comm(r2)->comm.dst_buff)
 140     return FALSE;
 141
 142   if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_WAIT
 143       && simcall_comm_wait__get__comm(r1)->comm.src_buff != NULL
 144       && simcall_comm_wait__get__comm(r1)->comm.dst_buff != NULL
 145       && simcall_comm_wait__get__comm(r2)->comm.src_buff != NULL
 146       && simcall_comm_wait__get__comm(r2)->comm.dst_buff != NULL
 147       && simcall_comm_wait__get__comm(r1)->comm.dst_buff !=
 148       simcall_comm_wait__get__comm(r2)->comm.src_buff
 149       && simcall_comm_wait__get__comm(r1)->comm.dst_buff !=
 150       simcall_comm_wait__get__comm(r2)->comm.dst_buff
 151       && simcall_comm_wait__get__comm(r2)->comm.dst_buff !=
 152       simcall_comm_wait__get__comm(r1)->comm.src_buff)
 153     return FALSE;
 154
 155   if (r1->call == SIMCALL_COMM_TEST &&
 156       (simcall_comm_test__get__comm(r1) == NULL
 157        || simcall_comm_test__get__comm(r1)->comm.src_buff == NULL
 158        || simcall_comm_test__get__comm(r1)->comm.dst_buff == NULL))
 159     return FALSE;
 160
 161   if (r2->call == SIMCALL_COMM_TEST &&
 162       (simcall_comm_test__get__comm(r2) == NULL
 163        || simcall_comm_test__get__comm(r2)->comm.src_buff == NULL
 164        || simcall_comm_test__get__comm(r2)->comm.dst_buff == NULL))
 165     return FALSE;
 166
 167   if (r1->call == SIMCALL_COMM_TEST && r2->call == SIMCALL_COMM_WAIT
 168       && simcall_comm_test__get__comm(r1)->comm.src_buff ==
 169       simcall_comm_wait__get__comm(r2)->comm.src_buff
 170       && simcall_comm_test__get__comm(r1)->comm.dst_buff ==
 171       simcall_comm_wait__get__comm(r2)->comm.dst_buff)
 172     return FALSE;
 173
 174   if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_TEST
 175       && simcall_comm_wait__get__comm(r1)->comm.src_buff ==
 176       simcall_comm_test__get__comm(r2)->comm.src_buff
 177       && simcall_comm_wait__get__comm(r1)->comm.dst_buff ==
 178       simcall_comm_test__get__comm(r2)->comm.dst_buff)
 179     return FALSE;
 180
 181   if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_TEST
 182       && simcall_comm_wait__get__comm(r1)->comm.src_buff != NULL
 183       && simcall_comm_wait__get__comm(r1)->comm.dst_buff != NULL
 184       && simcall_comm_test__get__comm(r2)->comm.src_buff != NULL
 185       && simcall_comm_test__get__comm(r2)->comm.dst_buff != NULL
 186       && simcall_comm_wait__get__comm(r1)->comm.dst_buff !=
 187       simcall_comm_test__get__comm(r2)->comm.src_buff
 188       && simcall_comm_wait__get__comm(r1)->comm.dst_buff !=
 189       simcall_comm_test__get__comm(r2)->comm.dst_buff
 190       && simcall_comm_test__get__comm(r2)->comm.dst_buff !=
 191       simcall_comm_wait__get__comm(r1)->comm.src_buff)
 192     return FALSE;
 193
 194   if (r1->call == SIMCALL_COMM_TEST && r2->call == SIMCALL_COMM_WAIT
 195       && simcall_comm_test__get__comm(r1)->comm.src_buff != NULL
 196       && simcall_comm_test__get__comm(r1)->comm.dst_buff != NULL
 197       && simcall_comm_wait__get__comm(r2)->comm.src_buff != NULL
 198       && simcall_comm_wait__get__comm(r2)->comm.dst_buff != NULL
 199       && simcall_comm_test__get__comm(r1)->comm.dst_buff !=
 200       simcall_comm_wait__get__comm(r2)->comm.src_buff
 201       && simcall_comm_test__get__comm(r1)->comm.dst_buff !=
 202       simcall_comm_wait__get__comm(r2)->comm.dst_buff
 203       && simcall_comm_wait__get__comm(r2)->comm.dst_buff !=
 204       simcall_comm_test__get__comm(r1)->comm.src_buff)
 205     return FALSE;
 206
 207
 208   return TRUE;
 209 }
 210
 211 static char *pointer_to_string(void *pointer)
 212 {
 213
 214   if (XBT_LOG_ISENABLED(mc_request, xbt_log_priority_verbose))
 215     return bprintf("%p", pointer);
 216
 217   return xbt_strdup("(verbose only)");
 218 }
 219
 220 static char *buff_size_to_string(size_t buff_size)
 221 {
 222
 223   if (XBT_LOG_ISENABLED(mc_request, xbt_log_priority_verbose))
 224     return bprintf("%zu", buff_size);
 225
 226   return xbt_strdup("(verbose only)");
 227 }
 228
 229
 230 char *MC_request_to_string(smx_simcall_t req, int value)
 231 {
 232   char *type = NULL, *args = NULL, *str = NULL, *p = NULL, *bs = NULL;
 233   smx_synchro_t act = NULL;
 234   smx_mutex_t mutex = NULL;
 235   size_t size = 0;
 236
 237   switch (req->call) {
 238   case SIMCALL_COMM_ISEND:
 239     type = xbt_strdup("iSend");
 240     p = pointer_to_string(simcall_comm_isend__get__src_buff(req));
 241     bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req));
 242     if (req->issuer->smx_host)
 243       args =
 244           bprintf("src=(%lu)%s (%s), buff=%s, size=%s", req->issuer->pid,
 245                   MSG_host_get_name(req->issuer->smx_host), req->issuer->name,
 246                   p, bs);
 247     else
 248       args =
 249           bprintf("src=(%lu)%s, buff=%s, size=%s", req->issuer->pid,
 250                   req->issuer->name, p, bs);
 251     break;
 252   case SIMCALL_COMM_IRECV:
 253     size =
 254         simcall_comm_irecv__get__dst_buff_size(req) ?
 255         *simcall_comm_irecv__get__dst_buff_size(req) : 0;
 256     type = xbt_strdup("iRecv");
 257     p = pointer_to_string(simcall_comm_irecv__get__dst_buff(req));
 258     bs = buff_size_to_string(size);
 259     if (req->issuer->smx_host)
 260       args =
 261           bprintf("dst=(%lu)%s (%s), buff=%s, size=%s", req->issuer->pid,
 262                   MSG_host_get_name(req->issuer->smx_host), req->issuer->name,
 263                   p, bs);
 264     else
 265       args =
 266           bprintf("dst=(%lu)%s, buff=%s, size=%s", req->issuer->pid,
 267                   req->issuer->name, p, bs);
 268     break;
 269   case SIMCALL_COMM_WAIT:
 270     act = simcall_comm_wait__get__comm(req);
 271     if (value == -1) {
 272       type = xbt_strdup("WaitTimeout");
 273       p = pointer_to_string(act);
 274       args = bprintf("comm=%s", p);
 275     } else {
 276       type = xbt_strdup("Wait");
 277       p = pointer_to_string(act);
 278       args = bprintf("comm=%s [(%lu)%s (%s)-> (%lu)%s (%s)]", p,
 279                      act->comm.src_proc ? act->comm.src_proc->pid : 0,
 280                      act->comm.src_proc ? MSG_host_get_name(act->comm.src_proc->
 281                                                             smx_host) : "",
 282                      act->comm.src_proc ? act->comm.src_proc->name : "",
 283                      act->comm.dst_proc ? act->comm.dst_proc->pid : 0,
 284                      act->comm.dst_proc ? MSG_host_get_name(act->comm.dst_proc->
 285                                                             smx_host) : "",
 286                      act->comm.dst_proc ? act->comm.dst_proc->name : "");
 287     }
 288     break;
 289   case SIMCALL_COMM_TEST:
 290     act = simcall_comm_test__get__comm(req);
 291     if (act->comm.src_proc == NULL || act->comm.dst_proc == NULL) {
 292       type = xbt_strdup("Test FALSE");
 293       p = pointer_to_string(act);
 294       args = bprintf("comm=%s", p);
 295     } else {
 296       type = xbt_strdup("Test TRUE");
 297       p = pointer_to_string(act);
 298       args = bprintf("comm=%s [(%lu)%s (%s) -> (%lu)%s (%s)]", p,
 299                      act->comm.src_proc->pid, act->comm.src_proc->name,
 300                      MSG_host_get_name(act->comm.src_proc->smx_host),
 301                      act->comm.dst_proc->pid, act->comm.dst_proc->name,
 302                      MSG_host_get_name(act->comm.dst_proc->smx_host));
 303     }
 304     break;
 305
 306   case SIMCALL_COMM_WAITANY:
 307     type = xbt_strdup("WaitAny");
 308     if (!xbt_dynar_is_empty(simcall_comm_waitany__get__comms(req))) {
 309       p = pointer_to_string(xbt_dynar_get_as
 310                             (simcall_comm_waitany__get__comms(req), value,
 311                              smx_synchro_t));
 312       args =
 313           bprintf("comm=%s (%d of %lu)", p, value + 1,
 314                   xbt_dynar_length(simcall_comm_waitany__get__comms(req)));
 315     } else {
 316       args = bprintf("comm at idx %d", value);
 317     }
 318     break;
 319
 320   case SIMCALL_COMM_TESTANY:
 321     if (value == -1) {
 322       type = xbt_strdup("TestAny FALSE");
 323       args = xbt_strdup("-");
 324     } else {
 325       type = xbt_strdup("TestAny");
 326       args =
 327           bprintf("(%d of %lu)", value + 1,
 328                   xbt_dynar_length(simcall_comm_testany__get__comms(req)));
 329     }
 330     break;
 331
 332   case SIMCALL_MUTEX_LOCK:
 333     mutex = simcall_mutex_lock__get__mutex(req);
 334     type = xbt_strdup("Mutex LOCK");
 335     args = bprintf("locked = %d, owner = %d, sleeping = %d", mutex->locked, mutex->owner != NULL ? (int)mutex->owner->pid : -1, xbt_swag_size(mutex->sleeping));
 336     break;
 337
 338   case SIMCALL_MC_SNAPSHOT:
 339     type = xbt_strdup("MC_SNAPSHOT");
 340     args = NULL;
 341     break;
 342
 343   case SIMCALL_MC_COMPARE_SNAPSHOTS:
 344     type = xbt_strdup("MC_COMPARE_SNAPSHOTS");
 345     args = NULL;
 346     break;
 347
 348   case SIMCALL_MC_RANDOM:
 349     type = xbt_strdup("MC_RANDOM");
 350     args = bprintf("%d", value);
 351     break;
 352
 353   default:
 354     THROW_UNIMPLEMENTED;
 355   }
 356
 357   if (args != NULL) {
 358     str =
 359         bprintf("[(%lu)%s (%s)] %s(%s)", req->issuer->pid,
 360                 MSG_host_get_name(req->issuer->smx_host), req->issuer->name,
 361                 type, args);
 362   } else {
 363     str =
 364         bprintf("[(%lu)%s (%s)] %s ", req->issuer->pid,
 365                 MSG_host_get_name(req->issuer->smx_host), req->issuer->name,
 366                 type);
 367   }
 368
 369   xbt_free(args);
 370   xbt_free(type);
 371   xbt_free(p);
 372   xbt_free(bs);
 373   return str;
 374 }
 375
 376 unsigned int MC_request_testany_fail(smx_simcall_t req)
 377 {
 378   unsigned int cursor;
 379   smx_synchro_t action;
 380
 381   xbt_dynar_foreach(simcall_comm_testany__get__comms(req), cursor, action) {
 382     if (action->comm.src_proc && action->comm.dst_proc)
 383       return FALSE;
 384   }
 385
 386   return TRUE;
 387 }
 388
 389 int MC_request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
 390 {
 391   smx_synchro_t act;
 392
 393   switch (req->call) {
 394
 395   case SIMCALL_COMM_WAIT:
 396     /* FIXME: check also that src and dst processes are not suspended */
 397     act = simcall_comm_wait__get__comm(req);
 398     return (act->comm.src_proc && act->comm.dst_proc);
 399     break;
 400
 401   case SIMCALL_COMM_WAITANY:
 402     act =
 403         xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), idx,
 404                          smx_synchro_t);
 405     return (act->comm.src_proc && act->comm.dst_proc);
 406     break;
 407
 408   case SIMCALL_COMM_TESTANY:
 409     act =
 410         xbt_dynar_get_as(simcall_comm_testany__get__comms(req), idx,
 411                          smx_synchro_t);
 412     return (act->comm.src_proc && act->comm.dst_proc);
 413     break;
 414
 415   default:
 416     return TRUE;
 417   }
 418 }
 419
 420 int MC_process_is_enabled(smx_process_t process)
 421 {
 422   return MC_request_is_enabled(&process->simcall);
 423 }
 424
 425 char *MC_request_get_dot_output(smx_simcall_t req, int value)
 426 {
 427
 428   char *str = NULL, *label = NULL;
 429   smx_synchro_t act = NULL;
 430
 431   switch (req->call) {
 432   case SIMCALL_COMM_ISEND:
 433     if (req->issuer->smx_host)
 434       label =
 435           bprintf("[(%lu)%s] iSend", req->issuer->pid,
 436                   MSG_host_get_name(req->issuer->smx_host));
 437     else
 438       label = bprintf("[(%lu)] iSend", req->issuer->pid);
 439     break;
 440
 441   case SIMCALL_COMM_IRECV:
 442     if (req->issuer->smx_host)
 443       label =
 444           bprintf("[(%lu)%s] iRecv", req->issuer->pid,
 445                   MSG_host_get_name(req->issuer->smx_host));
 446     else
 447       label = bprintf("[(%lu)] iRecv", req->issuer->pid);
 448     break;
 449
 450   case SIMCALL_COMM_WAIT:
 451     act = simcall_comm_wait__get__comm(req);
 452     if (value == -1) {
 453       if (req->issuer->smx_host)
 454         label =
 455             bprintf("[(%lu)%s] WaitTimeout", req->issuer->pid,
 456                     MSG_host_get_name(req->issuer->smx_host));
 457       else
 458         label = bprintf("[(%lu)] WaitTimeout", req->issuer->pid);
 459     } else {
 460       if (req->issuer->smx_host)
 461         label =
 462             bprintf("[(%lu)%s] Wait [(%lu)->(%lu)]", req->issuer->pid,
 463                     MSG_host_get_name(req->issuer->smx_host),
 464                     act->comm.src_proc ? act->comm.src_proc->pid : 0,
 465                     act->comm.dst_proc ? act->comm.dst_proc->pid : 0);
 466       else
 467         label =
 468             bprintf("[(%lu)] Wait [(%lu)->(%lu)]", req->issuer->pid,
 469                     act->comm.src_proc ? act->comm.src_proc->pid : 0,
 470                     act->comm.dst_proc ? act->comm.dst_proc->pid : 0);
 471     }
 472     break;
 473
 474   case SIMCALL_COMM_TEST:
 475     act = simcall_comm_test__get__comm(req);
 476     if (act->comm.src_proc == NULL || act->comm.dst_proc == NULL) {
 477       if (req->issuer->smx_host)
 478         label =
 479             bprintf("[(%lu)%s] Test FALSE", req->issuer->pid,
 480                     MSG_host_get_name(req->issuer->smx_host));
 481       else
 482         label = bprintf("[(%lu)] Test FALSE", req->issuer->pid);
 483     } else {
 484       if (req->issuer->smx_host)
 485         label =
 486             bprintf("[(%lu)%s] Test TRUE", req->issuer->pid,
 487                     MSG_host_get_name(req->issuer->smx_host));
 488       else
 489         label = bprintf("[(%lu)] Test TRUE", req->issuer->pid);
 490     }
 491     break;
 492
 493   case SIMCALL_COMM_WAITANY:
 494     if (req->issuer->smx_host)
 495       label =
 496           bprintf("[(%lu)%s] WaitAny [%d of %lu]", req->issuer->pid,
 497                   MSG_host_get_name(req->issuer->smx_host), value + 1,
 498                   xbt_dynar_length(simcall_comm_waitany__get__comms(req)));
 499     else
 500       label =
 501           bprintf("[(%lu)] WaitAny [%d of %lu]", req->issuer->pid, value + 1,
 502                   xbt_dynar_length(simcall_comm_waitany__get__comms(req)));
 503     break;
 504
 505   case SIMCALL_COMM_TESTANY:
 506     if (value == -1) {
 507       if (req->issuer->smx_host)
 508         label =
 509             bprintf("[(%lu)%s] TestAny FALSE", req->issuer->pid,
 510                     MSG_host_get_name(req->issuer->smx_host));
 511       else
 512         label = bprintf("[(%lu)] TestAny FALSE", req->issuer->pid);
 513     } else {
 514       if (req->issuer->smx_host)
 515         label =
 516             bprintf("[(%lu)%s] TestAny TRUE [%d of %lu]", req->issuer->pid,
 517                     MSG_host_get_name(req->issuer->smx_host), value + 1,
 518                     xbt_dynar_length(simcall_comm_testany__get__comms(req)));
 519       else
 520         label =
 521             bprintf("[(%lu)] TestAny TRUE [%d of %lu]", req->issuer->pid,
 522                     value + 1,
 523                     xbt_dynar_length(simcall_comm_testany__get__comms(req)));
 524     }
 525     break;
 526
 527   case SIMCALL_MUTEX_LOCK:
 528     label = bprintf("[(%lu)] Mutex LOCK", req->issuer->pid);
 529     break;
 530
 531   case SIMCALL_MC_RANDOM:
 532     if (req->issuer->smx_host)
 533       label =
 534           bprintf("[(%lu)%s] MC_RANDOM (%d)", req->issuer->pid,
 535                   MSG_host_get_name(req->issuer->smx_host), value);
 536     else
 537       label = bprintf("[(%lu)] MC_RANDOM (%d)", req->issuer->pid, value);
 538     break;
 539
 540   case SIMCALL_MC_SNAPSHOT:
 541     if (req->issuer->smx_host)
 542       label =
 543           bprintf("[(%lu)%s] MC_SNAPSHOT", req->issuer->pid,
 544                   MSG_host_get_name(req->issuer->smx_host));
 545     else
 546       label = bprintf("[(%lu)] MC_SNAPSHOT", req->issuer->pid);
 547     break;
 548
 549   case SIMCALL_MC_COMPARE_SNAPSHOTS:
 550     if (req->issuer->smx_host)
 551       label =
 552           bprintf("[(%lu)%s] MC_COMPARE_SNAPSHOTS", req->issuer->pid,
 553                   MSG_host_get_name(req->issuer->smx_host));
 554     else
 555       label = bprintf("[(%lu)] MC_COMPARE_SNAPSHOTS", req->issuer->pid);
 556     break;
 557
 558   default:
 559     THROW_UNIMPLEMENTED;
 560   }
 561
 562   str =
 563       bprintf("label = \"%s\", color = %s, fontcolor = %s", label,
 564               colors[req->issuer->pid - 1], colors[req->issuer->pid - 1]);
 565   xbt_free(label);
 566   return str;
 567
 568 }