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