src/simix/libsmx.c

   1 /* libsmx.c - public interface to simix                                       */
   2 /* --------                                                                   */
   3 /* These functions are the only ones that are visible from the higher levels  */
   4 /* (most of them simply add some documentation to the generated simcall body) */
   5 /*                                                                            */
   6 /* This is somehow the "libc" of SimGrid                                      */
   7
   8 /* Copyright (c) 2010-2014. The SimGrid Team. All rights reserved.            */
   9
  10 /* This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the license (GNU LGPL) which comes with this package.   */
  12
  13 #include "mc/mc_replay.h"
  14 #include "smx_private.h"
  15 #include "mc/mc_forward.h"
  16 #include "xbt/ex.h"
  17 #include <math.h>         /* isfinite() */
  18 #include "mc/mc.h"
  19
  20 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
  21
  22 #include "popping_bodies.c"
  23
  24 /**
  25  * \ingroup simix_host_management
  26  * \brief Returns a host given its name.
  27  *
  28  * \param name The name of the host to get
  29  * \return The corresponding host
  30  */
  31 smx_host_t simcall_host_get_by_name(const char *name)
  32 {
  33   return simcall_BODY_host_get_by_name(name);
  34 }
  35
  36 /**
  37  * \ingroup simix_host_management
  38  * \brief Returns the name of a host.
  39  *
  40  * \param host A SIMIX host
  41  * \return The name of this host
  42  */
  43 const char* simcall_host_get_name(smx_host_t host)
  44 {
  45   return simcall_BODY_host_get_name(host);
  46 }
  47
  48 /**
  49  * \ingroup simix_host_management
  50  * \brief Start the host if it is off
  51  *
  52  * \param host A SIMIX host
  53  */
  54 void simcall_host_on(smx_host_t host)
  55 {
  56   simcall_BODY_host_on(host);
  57 }
  58
  59 /**
  60  * \ingroup simix_host_management
  61  * \brief Stop the host if it is on
  62  *
  63  * \param host A SIMIX host
  64  */
  65 void simcall_host_off(smx_host_t host)
  66 {
  67   simcall_BODY_host_off(host);
  68 }
  69
  70 /**
  71  * \ingroup simix_host_management
  72  * \brief Returns a dict of the properties assigned to a host.
  73  *
  74  * \param host A host
  75  * \return The properties of this host
  76  */
  77 xbt_dict_t simcall_host_get_properties(smx_host_t host)
  78 {
  79   return simcall_BODY_host_get_properties(host);
  80 }
  81
  82 /**
  83  * \ingroup simix_host_management
  84  * \brief Returns a dict of the properties assigned to a router or AS.
  85  *
  86  * \param name The name of the router or AS
  87  * \return The properties
  88  */
  89 xbt_dict_t simcall_asr_get_properties(const char *name)
  90 {
  91   return simcall_BODY_asr_get_properties(name);
  92 }
  93
  94
  95 /**
  96  * \ingroup simix_host_management
  97  * \brief Returns the speed of the processor.
  98  *
  99  * The speed returned does not take into account the current load on the machine.
 100  * \param host A SIMIX host
 101  * \return The speed of this host (in Mflop/s)
 102  */
 103 double simcall_host_get_speed(smx_host_t host)
 104 {
 105   return simcall_BODY_host_get_speed(host);
 106 }
 107
 108 /**
 109  * \ingroup simix_host_management
 110  * \brief Returns the number of core of the processor.
 111  *
 112  * \param host A SIMIX host
 113  * \return The number of core
 114  */
 115 int simcall_host_get_core(smx_host_t host)
 116 {
 117   return simcall_BODY_host_get_core(host);
 118 }
 119
 120 /**
 121  * \ingroup simix_host_management
 122  * \brief Returns the list of processes attached to the host.
 123  *
 124  * \param host A SIMIX host
 125  * \return the swag of attached processes
 126  */
 127 xbt_swag_t simcall_host_get_process_list(smx_host_t host)
 128 {
 129   return simcall_BODY_host_get_process_list(host);
 130 }
 131
 132
 133 /**
 134  * \ingroup simix_host_management
 135  * \brief Returns the available speed of the processor.
 136  *
 137  * \return Speed currently available (in Mflop/s)
 138  */
 139 double simcall_host_get_available_speed(smx_host_t host)
 140 {
 141   return simcall_BODY_host_get_available_speed(host);
 142 }
 143
 144 /**
 145  * \ingroup simix_host_management
 146  * \brief Returns the state of a host.
 147  *
 148  * Two states are possible: 1 if the host is active or 0 if it has crashed.
 149  * \param host A SIMIX host
 150  * \return 1 if the host is available, 0 otherwise
 151  */
 152 int simcall_host_get_state(smx_host_t host)
 153 {
 154   return simcall_BODY_host_get_state(host);
 155 }
 156
 157 /**
 158  * \ingroup simix_host_management
 159  * \brief Returns the power peak of a host.
 160  *
 161  * \param host A SIMIX host
 162  * \return the current power peak value (double)
 163  */
 164 double simcall_host_get_current_power_peak(smx_host_t host)
 165 {
 166   return simcall_BODY_host_get_current_power_peak(host);
 167 }
 168
 169 /**
 170  * \ingroup simix_host_management
 171  * \brief Returns one power peak (in flops/s) of a host at a given pstate
 172  *
 173  * \param host A SIMIX host
 174  * \param pstate_index pstate to test
 175  * \return the current power peak value (double) for pstate_index
 176  */
 177 double simcall_host_get_power_peak_at(smx_host_t host, int pstate_index)
 178 {
 179   return simcall_BODY_host_get_power_peak_at(host, pstate_index);
 180 }
 181
 182 /**
 183  * \ingroup simix_host_management
 184  * \brief Returns the number of power states for a host.
 185  *
 186  * \param host A SIMIX host
 187  * \return the number of power states
 188  */
 189 int simcall_host_get_nb_pstates(smx_host_t host)
 190 {
 191   return simcall_BODY_host_get_nb_pstates(host);
 192 }
 193
 194 /**
 195  * \ingroup simix_host_management
 196  * \brief Sets the pstate at which the host should run
 197  *
 198  * \param host A SIMIX host
 199  * \param pstate_index The pstate to which the CPU power will be set
 200  */
 201 void simcall_host_set_pstate(smx_host_t host, int pstate_index)
 202 {
 203         simcall_BODY_host_set_pstate(host, pstate_index);
 204 }
 205 /**
 206  * \ingroup simix_host_management
 207  * \brief Gets the pstate at which that host currently runs.
 208  *
 209  * \param host A SIMIX host
 210  */
 211 int simcall_host_get_pstate(smx_host_t host)
 212 {
 213         return simcall_BODY_host_get_pstate(host);
 214 }
 215
 216 /**
 217  * \ingroup simix_host_management
 218  * \brief Returns the total energy consumed by the host (in Joules)
 219  *
 220  * \param host A SIMIX host
 221  * \return the energy consumed by the host (double)
 222  */
 223 double simcall_host_get_consumed_energy(smx_host_t host)
 224 {
 225   return simcall_BODY_host_get_consumed_energy(host);
 226 }
 227
 228
 229 /**
 230  * \ingroup simix_host_management
 231  * \brief Creates a synchro that executes some computation of an host.
 232  *
 233  * This function creates a SURF action and allocates the data necessary
 234  * to create the SIMIX synchro. It can raise a host_error exception if the host crashed.
 235  *
 236  * \param name Name of the execution synchro to create
 237  * \param host SIMIX host where the synchro will be executed
 238  * \param flops_amount amount Computation amount (in flops)
 239  * \param priority computation priority
 240  * \param bound
 241  * \param affinity_mask
 242  * \return A new SIMIX execution synchronization
 243  */
 244 smx_synchro_t simcall_host_execute(const char *name, smx_host_t host,
 245                                     double flops_amount,
 246                                     double priority, double bound, unsigned long affinity_mask)
 247 {
 248   /* checking for infinite values */
 249   xbt_assert(isfinite(flops_amount), "flops_amount is not finite!");
 250   xbt_assert(isfinite(priority), "priority is not finite!");
 251
 252   return simcall_BODY_host_execute(name, host, flops_amount, priority, bound, affinity_mask);
 253 }
 254
 255 /**
 256  * \ingroup simix_host_management
 257  * \brief Creates a synchro that may involve parallel computation on
 258  * several hosts and communication between them.
 259  *
 260  * \param name Name of the execution synchro to create
 261  * \param host_nb Number of hosts where the synchro will be executed
 262  * \param host_list Array (of size host_nb) of hosts where the synchro will be executed
 263  * \param flops_amount Array (of size host_nb) of computation amount of hosts (in bytes)
 264  * \param bytes_amount Array (of size host_nb * host_nb) representing the communication
 265  * amount between each pair of hosts
 266  * \param amount the SURF action amount
 267  * \param rate the SURF action rate
 268  * \return A new SIMIX execution synchronization
 269  */
 270 smx_synchro_t simcall_host_parallel_execute(const char *name,
 271                                          int host_nb,
 272                                          smx_host_t *host_list,
 273                                          double *flops_amount,
 274                                          double *bytes_amount,
 275                                          double amount,
 276                                          double rate)
 277 {
 278   int i,j;
 279   /* checking for infinite values */
 280   for (i = 0 ; i < host_nb ; ++i) {
 281      xbt_assert(isfinite(flops_amount[i]), "flops_amount[%d] is not finite!", i);
 282      for (j = 0 ; j < host_nb ; ++j) {
 283         xbt_assert(isfinite(bytes_amount[i + host_nb * j]),
 284              "bytes_amount[%d+%d*%d] is not finite!", i, host_nb, j);
 285      }
 286   }
 287
 288   xbt_assert(isfinite(amount), "amount is not finite!");
 289   xbt_assert(isfinite(rate), "rate is not finite!");
 290
 291   return simcall_BODY_host_parallel_execute(name, host_nb, host_list,
 292                                             flops_amount,
 293                                             bytes_amount,
 294                                             amount, rate);
 295
 296 }
 297
 298 /**
 299  * \ingroup simix_host_management
 300  * \brief Destroys an execution synchro.
 301  *
 302  * Destroys a synchro, freeing its memory. This function cannot be called if there are a conditional waiting for it.
 303  * \param execution The execution synchro to destroy
 304  */
 305 void simcall_host_execution_destroy(smx_synchro_t execution)
 306 {
 307   simcall_BODY_host_execution_destroy(execution);
 308 }
 309
 310 /**
 311  * \ingroup simix_host_management
 312  * \brief Cancels an execution synchro.
 313  *
 314  * This functions stops the execution. It calls a surf function.
 315  * \param execution The execution synchro to cancel
 316  */
 317 void simcall_host_execution_cancel(smx_synchro_t execution)
 318 {
 319   simcall_BODY_host_execution_cancel(execution);
 320 }
 321
 322 /**
 323  * \ingroup simix_host_management
 324  * \brief Returns how much of an execution synchro remains to be done.
 325  *
 326  * \param execution The execution synchro
 327  * \return The remaining amount
 328  */
 329 double simcall_host_execution_get_remains(smx_synchro_t execution)
 330 {
 331   return simcall_BODY_host_execution_get_remains(execution);
 332 }
 333
 334 /**
 335  * \ingroup simix_host_management
 336  * \brief Returns the state of an execution synchro.
 337  *
 338  * \param execution The execution synchro
 339  * \return The state
 340  */
 341 e_smx_state_t simcall_host_execution_get_state(smx_synchro_t execution)
 342 {
 343   return simcall_BODY_host_execution_get_state(execution);
 344 }
 345
 346 /**
 347  * \ingroup simix_host_management
 348  * \brief Changes the priority of an execution synchro.
 349  *
 350  * This functions changes the priority only. It calls a surf function.
 351  * \param execution The execution synchro
 352  * \param priority The new priority
 353  */
 354 void simcall_host_execution_set_priority(smx_synchro_t execution, double priority)
 355 {
 356   /* checking for infinite values */
 357   xbt_assert(isfinite(priority), "priority is not finite!");
 358
 359   simcall_BODY_host_execution_set_priority(execution, priority);
 360 }
 361
 362 /**
 363  * \ingroup simix_host_management
 364  * \brief Changes the capping (the maximum CPU utilization) of an execution synchro.
 365  *
 366  * This functions changes the capping only. It calls a surf function.
 367  * \param execution The execution synchro
 368  * \param bound The new bound
 369  */
 370 void simcall_host_execution_set_bound(smx_synchro_t execution, double bound)
 371 {
 372   simcall_BODY_host_execution_set_bound(execution, bound);
 373 }
 374
 375 /**
 376  * \ingroup simix_host_management
 377  * \brief Changes the CPU affinity of an execution synchro.
 378  *
 379  * This functions changes the CPU affinity of an execution synchro. See taskset(1) on Linux.
 380  * \param execution The execution synchro
 381  * \param host Host
 382  * \param mask Affinity mask
 383  */
 384 void simcall_host_execution_set_affinity(smx_synchro_t execution, smx_host_t host, unsigned long mask)
 385 {
 386   simcall_BODY_host_execution_set_affinity(execution, host, mask);
 387 }
 388
 389 /**
 390  * \ingroup simix_host_management
 391  * \brief Waits for the completion of an execution synchro and destroy it.
 392  *
 393  * \param execution The execution synchro
 394  */
 395 e_smx_state_t simcall_host_execution_wait(smx_synchro_t execution)
 396 {
 397   return simcall_BODY_host_execution_wait(execution);
 398 }
 399
 400
 401 /**
 402  * \ingroup simix_vm_management
 403  * \brief Create a VM on the given physical host.
 404  *
 405  * \param name VM name
 406  * \param host Physical host
 407  *
 408  * \return The host object of the VM
 409  */
 410 void* simcall_vm_create(const char *name, smx_host_t phys_host){
 411   return simcall_BODY_vm_create(name, phys_host);
 412 }
 413
 414 /**
 415  * \ingroup simix_vm_management
 416  * \brief Start the given VM to the given physical host
 417  *
 418  * \param vm VM
 419  */
 420 void simcall_vm_start(smx_host_t vm)
 421 {
 422   simcall_BODY_vm_start(vm);
 423 }
 424
 425 /**
 426  * \ingroup simix_vm_management
 427  * \brief Get the state of the given VM
 428  *
 429  * \param vm VM
 430  * \return The state of the VM
 431  */
 432 int simcall_vm_get_state(smx_host_t vm)
 433 {
 434   return simcall_BODY_vm_get_state(vm);
 435 }
 436
 437 /**
 438  * \ingroup simix_vm_management
 439  * \brief Get the name of the physical host on which the given VM runs.
 440  *
 441  * \param vm VM
 442  * \return The name of the physical host
 443  */
 444 void *simcall_vm_get_pm(smx_host_t vm)
 445 {
 446   return simcall_BODY_vm_get_pm(vm);
 447 }
 448
 449 void simcall_vm_set_bound(smx_host_t vm, double bound)
 450 {
 451   simcall_BODY_vm_set_bound(vm, bound);
 452 }
 453
 454 void simcall_vm_set_affinity(smx_host_t vm, smx_host_t pm, unsigned long mask)
 455 {
 456   simcall_BODY_vm_set_affinity(vm, pm, mask);
 457 }
 458
 459 void simcall_host_get_params(smx_host_t vm, ws_params_t params)
 460 {
 461   simcall_BODY_host_get_params(vm, params);
 462 }
 463
 464 void simcall_host_set_params(smx_host_t vm, ws_params_t params)
 465 {
 466   simcall_BODY_host_set_params(vm, params);
 467 }
 468
 469 /**
 470  * \ingroup simix_vm_management
 471  * \brief Migrate the given VM to the given physical host
 472  *
 473  * \param vm VM
 474  * \param host Destination physical host
 475  */
 476 void simcall_vm_migrate(smx_host_t vm, smx_host_t host)
 477 {
 478   simcall_BODY_vm_migrate(vm, host);
 479 }
 480
 481 /**
 482  * \ingroup simix_vm_management
 483  * \brief Suspend the given VM
 484  *
 485  * \param vm VM
 486  */
 487 void simcall_vm_suspend(smx_host_t vm)
 488 {
 489   simcall_BODY_vm_suspend(vm);
 490 }
 491
 492 /**
 493  * \ingroup simix_vm_management
 494  * \brief Resume the given VM
 495  *
 496  * \param vm VM
 497  */
 498 void simcall_vm_resume(smx_host_t vm)
 499 {
 500   simcall_BODY_vm_resume(vm);
 501 }
 502
 503 /**
 504  * \ingroup simix_vm_management
 505  * \brief Save the given VM
 506  *
 507  * \param vm VM
 508  */
 509 void simcall_vm_save(smx_host_t vm)
 510 {
 511   simcall_BODY_vm_save(vm);
 512 }
 513
 514 /**
 515  * \ingroup simix_vm_management
 516  * \brief Restore the given VM
 517  *
 518  * \param vm VM
 519  */
 520 void simcall_vm_restore(smx_host_t vm)
 521 {
 522   simcall_BODY_vm_restore(vm);
 523 }
 524
 525 /**
 526  * \ingroup simix_vm_management
 527  * \brief Shutdown the given VM
 528  *
 529  * \param vm VM
 530  */
 531 void simcall_vm_shutdown(smx_host_t vm)
 532 {
 533   simcall_BODY_vm_shutdown(vm);
 534 }
 535
 536 /**
 537  * \ingroup simix_vm_management
 538  * \brief Destroy the given VM
 539  *
 540  * \param vm VM
 541  */
 542 void simcall_vm_destroy(smx_host_t vm)
 543 {
 544   simcall_BODY_vm_destroy(vm);
 545 }
 546
 547 /**
 548  * \ingroup simix_vm_management
 549  * \brief Encompassing simcall to prevent the removal of the src or the dst node at the end of a VM migration
 550  *  The simcall actually invokes the following calls:
 551  *     simcall_vm_set_affinity(vm, src_pm, 0);
 552  *     simcall_vm_migrate(vm, dst_pm);
 553  *     simcall_vm_resume(vm);
 554  *
 555  * It is called at the end of the migration_rx_fun function from msg/msg_vm.c
 556  *
 557  * \param vm VM to migrate
 558  * \param src_pm  Source physical host
 559  * \param dst_pmt Destination physical host
 560  */
 561 void simcall_vm_migratefrom_resumeto(smx_host_t vm, smx_host_t src_pm, smx_host_t dst_pm)
 562 {
 563   simcall_BODY_vm_migratefrom_resumeto(vm, src_pm, dst_pm);
 564 }
 565
 566 /**
 567  * \ingroup simix_process_management
 568  * \brief Creates and runs a new SIMIX process.
 569  *
 570  * The structure and the corresponding thread are created and put in the list of ready processes.
 571  *
 572  * \param process the process created will be stored in this pointer
 573  * \param name a name for the process. It is for user-level information and can be NULL.
 574  * \param code the main function of the process
 575  * \param data a pointer to any data one may want to attach to the new object. It is for user-level information and can be NULL.
 576  * It can be retrieved with the function \ref simcall_process_get_data.
 577  * \param hostname name of the host where the new agent is executed.
 578  * \param kill_time time when the process is killed
 579  * \param argc first argument passed to \a code
 580  * \param argv second argument passed to \a code
 581  * \param properties the properties of the process
 582  * \param auto_restart either it is autorestarting or not.
 583  */
 584 void simcall_process_create(smx_process_t *process, const char *name,
 585                               xbt_main_func_t code,
 586                               void *data,
 587                               const char *hostname,
 588                               double kill_time,
 589                               int argc, char **argv,
 590                               xbt_dict_t properties,
 591                               int auto_restart)
 592 {
 593   simcall_BODY_process_create(process, name, code, data, hostname,
 594                               kill_time, argc, argv, properties,
 595                               auto_restart);
 596 }
 597
 598 /**
 599  * \ingroup simix_process_management
 600  * \brief Kills a SIMIX process.
 601  *
 602  * This function simply kills a  process.
 603  *
 604  * \param process poor victim
 605  */
 606 void simcall_process_kill(smx_process_t process)
 607 {
 608   simcall_BODY_process_kill(process);
 609 }
 610
 611 /**
 612  * \ingroup simix_process_management
 613  * \brief Kills all SIMIX processes.
 614  */
 615 void simcall_process_killall(int reset_pid)
 616 {
 617   simcall_BODY_process_killall(reset_pid);
 618 }
 619
 620 /**
 621  * \ingroup simix_process_management
 622  * \brief Cleans up a SIMIX process.
 623  * \param process poor victim (must have already been killed)
 624  */
 625 void simcall_process_cleanup(smx_process_t process)
 626 {
 627   simcall_BODY_process_cleanup(process);
 628 }
 629
 630 /**
 631  * \ingroup simix_process_management
 632  * \brief Migrates an agent to another location.
 633  *
 634  * This function changes the value of the host on which \a process is running.
 635  *
 636  * \param process the process to migrate
 637  * \param dest name of the new host
 638  */
 639 void simcall_process_change_host(smx_process_t process, smx_host_t dest)
 640 {
 641   simcall_BODY_process_change_host(process, dest);
 642 }
 643
 644 void simcall_process_join(smx_process_t process, double timeout)
 645 {
 646   simcall_BODY_process_join(process, timeout);
 647 }
 648
 649 /**
 650  * \ingroup simix_process_management
 651  * \brief Suspends a process.
 652  *
 653  * This function suspends the process by suspending the synchro
 654  * it was waiting for completion.
 655  *
 656  * \param process a SIMIX process
 657  */
 658 void simcall_process_suspend(smx_process_t process)
 659 {
 660   xbt_assert(process, "Invalid parameters");
 661
 662   simcall_BODY_process_suspend(process);
 663 }
 664
 665 /**
 666  * \ingroup simix_process_management
 667  * \brief Resumes a suspended process.
 668  *
 669  * This function resumes a suspended process by resuming the synchro
 670  * it was waiting for completion.
 671  *
 672  * \param process a SIMIX process
 673  */
 674 void simcall_process_resume(smx_process_t process)
 675 {
 676   simcall_BODY_process_resume(process);
 677 }
 678
 679 /**
 680  * \ingroup simix_process_management
 681  * \brief Returns the amount of SIMIX processes in the system
 682  *
 683  * Maestro internal process is not counted, only user code processes are
 684  */
 685 int simcall_process_count(void)
 686 {
 687   return simcall_BODY_process_count();
 688 }
 689
 690 /**
 691  * \ingroup simix_process_management
 692  * \brief Return the PID of a #smx_process_t.
 693  * \param process a SIMIX process
 694  * \return the PID of this process
 695  */
 696 int simcall_process_get_PID(smx_process_t process)
 697 {
 698   if (process == SIMIX_process_self()) {
 699     /* avoid a simcall if this function is called by the process itself */
 700     return SIMIX_process_get_PID(process);
 701   }
 702
 703   return simcall_BODY_process_get_PID(process);
 704 }
 705
 706 /**
 707  * \ingroup simix_process_management
 708  * \brief Return the parent PID of a #smx_process_t.
 709  * \param process a SIMIX process
 710  * \return the PID of this process parenrt
 711  */
 712 int simcall_process_get_PPID(smx_process_t process)
 713 {
 714   if (process == SIMIX_process_self()) {
 715     /* avoid a simcall if this function is called by the process itself */
 716     return SIMIX_process_get_PPID(process);
 717   }
 718
 719   return simcall_BODY_process_get_PPID(process);
 720 }
 721
 722 /**
 723  * \ingroup simix_process_management
 724  * \brief Return the user data of a #smx_process_t.
 725  * \param process a SIMIX process
 726  * \return the user data of this process
 727  */
 728 void* simcall_process_get_data(smx_process_t process)
 729 {
 730   if (process == SIMIX_process_self()) {
 731     /* avoid a simcall if this function is called by the process itself */
 732     return SIMIX_process_get_data(process);
 733   }
 734
 735   return simcall_BODY_process_get_data(process);
 736 }
 737
 738 /**
 739  * \ingroup simix_process_management
 740  * \brief Set the user data of a #smx_process_t.
 741  *
 742  * This functions sets the user data associated to \a process.
 743  * \param process SIMIX process
 744  * \param data User data
 745  */
 746 void simcall_process_set_data(smx_process_t process, void *data)
 747 {
 748   if (process == SIMIX_process_self()) {
 749     /* avoid a simcall if this function is called by the process itself */
 750     SIMIX_process_self_set_data(process, data);
 751   }
 752   else {
 753     simcall_BODY_process_set_data(process, data);
 754   }
 755 }
 756
 757 /**
 758  * \ingroup simix_process_management
 759  * \brief Set the kill time of a process.
 760  * \param process a process
 761  * \param kill_time a double
 762  */
 763 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
 764 {
 765
 766   if (kill_time > SIMIX_get_clock()) {
 767     if (simix_global->kill_process_function) {
 768       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
 769           sg_host_name(process->smx_host));
 770       process->kill_timer = SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
 771     }
 772   }
 773 }
 774
 775 /**
 776  * \ingroup simix_process_management
 777  * \brief Return the location on which an agent is running.
 778  *
 779  * This functions returns the smx_host_t corresponding to the location on which
 780  * \a process is running.
 781  * \param process SIMIX process
 782  * \return SIMIX host
 783  */
 784 smx_host_t simcall_process_get_host(smx_process_t process)
 785 {
 786   return simcall_BODY_process_get_host(process);
 787 }
 788
 789 /**
 790  * \ingroup simix_process_management
 791  * \brief Return the name of an agent.
 792  *
 793  * This functions checks whether \a process is a valid pointer or not and return its name.
 794  * \param process SIMIX process
 795  * \return The process name
 796  */
 797 const char* simcall_process_get_name(smx_process_t process)
 798 {
 799   if (process == SIMIX_process_self()) {
 800     /* avoid a simcall if this function is called by the process itself */
 801     return process->name;
 802   }
 803   return simcall_BODY_process_get_name(process);
 804 }
 805
 806 /**
 807  * \ingroup simix_process_management
 808  * \brief Returns true if the process is suspended .
 809  *
 810  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
 811  * \param process SIMIX process
 812  * \return 1, if the process is suspended, else 0.
 813  */
 814 int simcall_process_is_suspended(smx_process_t process)
 815 {
 816   return  simcall_BODY_process_is_suspended(process);
 817 }
 818
 819 /**
 820  * \ingroup simix_process_management
 821  * \brief Return the properties
 822  *
 823  * This functions returns the properties associated with this process
 824  */
 825 xbt_dict_t simcall_process_get_properties(smx_process_t process)
 826 {
 827   return simcall_BODY_process_get_properties(process);
 828 }
 829 /**
 830  * \ingroup simix_process_management
 831  * \brief Add an on_exit function
 832  * Add an on_exit function which will be executed when the process exits/is killed.
 833  */
 834 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data)
 835 {
 836   simcall_BODY_process_on_exit(process, fun, data);
 837 }
 838 /**
 839  * \ingroup simix_process_management
 840  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
 841  * Will restart the process when the host comes back up if auto_restart is set to 1.
 842  */
 843
 844 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart)
 845 {
 846   simcall_BODY_process_auto_restart_set(process, auto_restart);
 847 }
 848
 849 /**
 850  * \ingroup simix_process_management
 851  * \brief Restarts the process, killing it and starting it again from scratch.
 852  */
 853 XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process)
 854 {
 855   return simcall_BODY_process_restart(process);
 856 }
 857 /**
 858  * \ingroup simix_process_management
 859  * \brief Creates a new sleep SIMIX synchro.
 860  *
 861  * This function creates a SURF action and allocates the data necessary
 862  * to create the SIMIX synchro. It can raise a host_error exception if the
 863  * host crashed. The default SIMIX name of the synchro is "sleep".
 864  *
 865  *   \param duration Time duration of the sleep.
 866  *   \return A result telling whether the sleep was successful
 867  */
 868 e_smx_state_t simcall_process_sleep(double duration)
 869 {
 870   /* checking for infinite values */
 871   xbt_assert(isfinite(duration), "duration is not finite!");
 872   return simcall_BODY_process_sleep(duration);
 873 }
 874
 875 /**
 876  *  \ingroup simix_rdv_management
 877  *  \brief Creates a new rendez-vous point
 878  *  \param name The name of the rendez-vous point
 879  *  \return The created rendez-vous point
 880  */
 881 smx_rdv_t simcall_rdv_create(const char *name)
 882 {
 883   return simcall_BODY_rdv_create(name);
 884 }
 885
 886
 887 /**
 888  *  \ingroup simix_rdv_management
 889  *  \brief Destroy a rendez-vous point
 890  *  \param rdv The rendez-vous point to destroy
 891  */
 892 void simcall_rdv_destroy(smx_rdv_t rdv)
 893 {
 894   simcall_BODY_rdv_destroy(rdv);
 895 }
 896 /**
 897  *  \ingroup simix_rdv_management
 898  *  \brief Returns a rendez-vous point knowing its name
 899  */
 900 smx_rdv_t simcall_rdv_get_by_name(const char *name)
 901 {
 902   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
 903
 904   /* FIXME: this is a horrible loss of performance, so we hack it out by
 905    * skipping the simcall (for now). It works in parallel, it won't work on
 906    * distributed but probably we will change MSG for that. */
 907
 908   return SIMIX_rdv_get_by_name(name);
 909 }
 910
 911 /**
 912  *  \ingroup simix_rdv_management
 913  *  \brief Counts the number of communication synchros of a given host pending
 914  *         on a rendez-vous point.
 915  *  \param rdv The rendez-vous point
 916  *  \param host The host to be counted
 917  *  \return The number of comm synchros pending in the rdv
 918  */
 919 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 920 {
 921   return simcall_BODY_rdv_comm_count_by_host(rdv, host);
 922 }
 923
 924 /**
 925  *  \ingroup simix_rdv_management
 926  *  \brief returns the communication at the head of the rendez-vous
 927  *  \param rdv The rendez-vous point
 928  *  \return The communication or NULL if empty
 929  */
 930 smx_synchro_t simcall_rdv_get_head(smx_rdv_t rdv)
 931 {
 932   return simcall_BODY_rdv_get_head(rdv);
 933 }
 934
 935 void simcall_rdv_set_receiver(smx_rdv_t rdv, smx_process_t process)
 936 {
 937   simcall_BODY_rdv_set_receiver(rdv, process);
 938 }
 939
 940 smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv)
 941 {
 942   return simcall_BODY_rdv_get_receiver(rdv);
 943 }
 944
 945 /**
 946  * \ingroup simix_comm_management
 947  */
 948 void simcall_comm_send(smx_process_t src, smx_rdv_t rdv, double task_size, double rate,
 949                          void *src_buff, size_t src_buff_size,
 950                          int (*match_fun)(void *, void *, smx_synchro_t),
 951                          void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data,
 952                          double timeout)
 953 {
 954   /* checking for infinite values */
 955   xbt_assert(isfinite(task_size), "task_size is not finite!");
 956   xbt_assert(isfinite(rate), "rate is not finite!");
 957   xbt_assert(isfinite(timeout), "timeout is not finite!");
 958
 959   xbt_assert(rdv, "No rendez-vous point defined for send");
 960
 961   if (MC_is_active() || MC_record_replay_is_active()) {
 962     /* the model-checker wants two separate simcalls */
 963     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
 964     comm = simcall_comm_isend(src, rdv, task_size, rate,
 965         src_buff, src_buff_size, match_fun, NULL, copy_data_fun, data, 0);
 966     simcall_comm_wait(comm, timeout);
 967     comm = NULL;
 968   }
 969   else {
 970     simcall_BODY_comm_send(src, rdv, task_size, rate, src_buff, src_buff_size,
 971                          match_fun, copy_data_fun, data, timeout);
 972   }
 973 }
 974
 975 /**
 976  * \ingroup simix_comm_management
 977  */
 978 smx_synchro_t simcall_comm_isend(smx_process_t src, smx_rdv_t rdv, double task_size, double rate,
 979                               void *src_buff, size_t src_buff_size,
 980                               int (*match_fun)(void *, void *, smx_synchro_t),
 981                               void (*clean_fun)(void *),
 982                               void (*copy_data_fun)(smx_synchro_t, void*, size_t),
 983                               void *data,
 984                               int detached)
 985 {
 986   /* checking for infinite values */
 987   xbt_assert(isfinite(task_size), "task_size is not finite!");
 988   xbt_assert(isfinite(rate), "rate is not finite!");
 989
 990   xbt_assert(rdv, "No rendez-vous point defined for isend");
 991
 992   return simcall_BODY_comm_isend(src, rdv, task_size, rate, src_buff,
 993                                  src_buff_size, match_fun,
 994                                  clean_fun, copy_data_fun, data, detached);
 995 }
 996
 997 /**
 998  * \ingroup simix_comm_management
 999  */
1000 void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
1001                        int (*match_fun)(void *, void *, smx_synchro_t),
1002                        void (*copy_data_fun)(smx_synchro_t, void*, size_t),
1003                        void *data, double timeout, double rate)
1004 {
1005   xbt_assert(isfinite(timeout), "timeout is not finite!");
1006   xbt_assert(rdv, "No rendez-vous point defined for recv");
1007
1008   if (MC_is_active() || MC_record_replay_is_active()) {
1009     /* the model-checker wants two separate simcalls */
1010     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
1011     comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size,
1012                               match_fun, copy_data_fun, data, rate);
1013     simcall_comm_wait(comm, timeout);
1014     comm = NULL;
1015   }
1016   else {
1017     simcall_BODY_comm_recv(rdv, dst_buff, dst_buff_size,
1018                            match_fun, copy_data_fun, data, timeout, rate);
1019   }
1020 }
1021 /**
1022  * \ingroup simix_comm_management
1023  */
1024 smx_synchro_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
1025                                 int (*match_fun)(void *, void *, smx_synchro_t),
1026                                 void (*copy_data_fun)(smx_synchro_t, void*, size_t),
1027                                 void *data, double rate)
1028 {
1029   xbt_assert(rdv, "No rendez-vous point defined for irecv");
1030
1031   return simcall_BODY_comm_irecv(rdv, dst_buff, dst_buff_size,
1032                                  match_fun, copy_data_fun, data, rate);
1033 }
1034
1035 /**
1036  * \ingroup simix_comm_management
1037  */
1038 smx_synchro_t simcall_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag,
1039                                 int (*match_fun)(void *, void *, smx_synchro_t), void *data)
1040 {
1041   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
1042
1043   return simcall_BODY_comm_iprobe(rdv, type, src, tag, match_fun, data);
1044 }
1045
1046 /**
1047  * \ingroup simix_comm_management
1048  */
1049 void simcall_comm_cancel(smx_synchro_t comm)
1050 {
1051   simcall_BODY_comm_cancel(comm);
1052 }
1053
1054 /**
1055  * \ingroup simix_comm_management
1056  */
1057 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
1058 {
1059   return simcall_BODY_comm_waitany(comms);
1060 }
1061
1062 /**
1063  * \ingroup simix_comm_management
1064  */
1065 int simcall_comm_testany(xbt_dynar_t comms)
1066 {
1067   if (xbt_dynar_is_empty(comms))
1068     return -1;
1069   return simcall_BODY_comm_testany(comms);
1070 }
1071
1072 /**
1073  * \ingroup simix_comm_management
1074  */
1075 void simcall_comm_wait(smx_synchro_t comm, double timeout)
1076 {
1077   xbt_assert(isfinite(timeout), "timeout is not finite!");
1078   simcall_BODY_comm_wait(comm, timeout);
1079 }
1080
1081 /**
1082  * \brief Set the category of an synchro.
1083  *
1084  * This functions changes the category only. It calls a surf function.
1085  * \param execution The execution synchro
1086  * \param category The tracing category
1087  */
1088 void simcall_set_category(smx_synchro_t synchro, const char *category)
1089 {
1090   if (category == NULL) {
1091     return;
1092   }
1093   simcall_BODY_set_category(synchro, category);
1094 }
1095
1096 /**
1097  * \ingroup simix_comm_management
1098  *
1099  */
1100 int simcall_comm_test(smx_synchro_t comm)
1101 {
1102   return simcall_BODY_comm_test(comm);
1103 }
1104
1105 /**
1106  * \ingroup simix_comm_management
1107  *
1108  */
1109 double simcall_comm_get_remains(smx_synchro_t comm)
1110 {
1111   return simcall_BODY_comm_get_remains(comm);
1112 }
1113
1114 /**
1115  * \ingroup simix_comm_management
1116  *
1117  */
1118 e_smx_state_t simcall_comm_get_state(smx_synchro_t comm)
1119 {
1120   return simcall_BODY_comm_get_state(comm);
1121 }
1122
1123 /**
1124  * \ingroup simix_comm_management
1125  *
1126  */
1127 void *simcall_comm_get_src_data(smx_synchro_t comm)
1128 {
1129   return simcall_BODY_comm_get_src_data(comm);
1130 }
1131
1132 /**
1133  * \ingroup simix_comm_management
1134  *
1135  */
1136 void *simcall_comm_get_dst_data(smx_synchro_t comm)
1137 {
1138   return simcall_BODY_comm_get_dst_data(comm);
1139 }
1140
1141 /**
1142  * \ingroup simix_comm_management
1143  *
1144  */
1145 smx_process_t simcall_comm_get_src_proc(smx_synchro_t comm)
1146 {
1147   return simcall_BODY_comm_get_src_proc(comm);
1148 }
1149
1150 /**
1151  * \ingroup simix_comm_management
1152  *
1153  */
1154 smx_process_t simcall_comm_get_dst_proc(smx_synchro_t comm)
1155 {
1156   return simcall_BODY_comm_get_dst_proc(comm);
1157 }
1158
1159 #ifdef HAVE_LATENCY_BOUND_TRACKING
1160 int simcall_comm_is_latency_bounded(smx_synchro_t comm)
1161 {
1162   return simcall_BODY_comm_is_latency_bounded(comm);
1163 }
1164 #endif
1165
1166 /**
1167  * \ingroup simix_synchro_management
1168  *
1169  */
1170 smx_mutex_t simcall_mutex_init(void)
1171 {
1172   if(!simix_global) {
1173     fprintf(stderr,"You must run MSG_init before using MSG\n"); // We can't use xbt_die since we may get there before the initialization
1174     xbt_abort();
1175   }
1176   return simcall_BODY_mutex_init();
1177 }
1178
1179 /**
1180  * \ingroup simix_synchro_management
1181  *
1182  */
1183 void simcall_mutex_destroy(smx_mutex_t mutex)
1184 {
1185   simcall_BODY_mutex_destroy(mutex);
1186 }
1187
1188 /**
1189  * \ingroup simix_synchro_management
1190  *
1191  */
1192 void simcall_mutex_lock(smx_mutex_t mutex)
1193 {
1194   simcall_BODY_mutex_lock(mutex);
1195 }
1196
1197 /**
1198  * \ingroup simix_synchro_management
1199  *
1200  */
1201 int simcall_mutex_trylock(smx_mutex_t mutex)
1202 {
1203   return simcall_BODY_mutex_trylock(mutex);
1204 }
1205
1206 /**
1207  * \ingroup simix_synchro_management
1208  *
1209  */
1210 void simcall_mutex_unlock(smx_mutex_t mutex)
1211 {
1212   simcall_BODY_mutex_unlock(mutex);
1213 }
1214
1215 /**
1216  * \ingroup simix_synchro_management
1217  *
1218  */
1219 smx_cond_t simcall_cond_init(void)
1220 {
1221   return simcall_BODY_cond_init();
1222 }
1223
1224 /**
1225  * \ingroup simix_synchro_management
1226  *
1227  */
1228 void simcall_cond_destroy(smx_cond_t cond)
1229 {
1230   simcall_BODY_cond_destroy(cond);
1231 }
1232
1233 /**
1234  * \ingroup simix_synchro_management
1235  *
1236  */
1237 void simcall_cond_signal(smx_cond_t cond)
1238 {
1239   simcall_BODY_cond_signal(cond);
1240 }
1241
1242 /**
1243  * \ingroup simix_synchro_management
1244  *
1245  */
1246 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
1247 {
1248   simcall_BODY_cond_wait(cond, mutex);
1249 }
1250
1251 /**
1252  * \ingroup simix_synchro_management
1253  *
1254  */
1255 void simcall_cond_wait_timeout(smx_cond_t cond,
1256                                  smx_mutex_t mutex,
1257                                  double timeout)
1258 {
1259   xbt_assert(isfinite(timeout), "timeout is not finite!");
1260   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
1261 }
1262
1263 /**
1264  * \ingroup simix_synchro_management
1265  *
1266  */
1267 void simcall_cond_broadcast(smx_cond_t cond)
1268 {
1269   simcall_BODY_cond_broadcast(cond);
1270 }
1271
1272 /**
1273  * \ingroup simix_synchro_management
1274  *
1275  */
1276 smx_sem_t simcall_sem_init(int capacity)
1277 {
1278   return simcall_BODY_sem_init(capacity);
1279 }
1280
1281 /**
1282  * \ingroup simix_synchro_management
1283  *
1284  */
1285 void simcall_sem_destroy(smx_sem_t sem)
1286 {
1287   simcall_BODY_sem_destroy(sem);
1288 }
1289
1290 /**
1291  * \ingroup simix_synchro_management
1292  *
1293  */
1294 void simcall_sem_release(smx_sem_t sem)
1295 {
1296   simcall_BODY_sem_release(sem);
1297 }
1298
1299 /**
1300  * \ingroup simix_synchro_management
1301  *
1302  */
1303 int simcall_sem_would_block(smx_sem_t sem)
1304 {
1305   return simcall_BODY_sem_would_block(sem);
1306 }
1307
1308 /**
1309  * \ingroup simix_synchro_management
1310  *
1311  */
1312 void simcall_sem_acquire(smx_sem_t sem)
1313 {
1314   simcall_BODY_sem_acquire(sem);
1315 }
1316
1317 /**
1318  * \ingroup simix_synchro_management
1319  *
1320  */
1321 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1322 {
1323   xbt_assert(isfinite(timeout), "timeout is not finite!");
1324   simcall_BODY_sem_acquire_timeout(sem, timeout);
1325 }
1326
1327 /**
1328  * \ingroup simix_synchro_management
1329  *
1330  */
1331 int simcall_sem_get_capacity(smx_sem_t sem)
1332 {
1333   return simcall_BODY_sem_get_capacity(sem);
1334 }
1335
1336 /**
1337  * \ingroup simix_file_management
1338  *
1339  */
1340 sg_size_t simcall_file_read(smx_file_t fd, sg_size_t size, smx_host_t host)
1341 {
1342   return simcall_BODY_file_read(fd, size, host);
1343 }
1344
1345 /**
1346  * \ingroup simix_file_management
1347  *
1348  */
1349 sg_size_t simcall_file_write(smx_file_t fd, sg_size_t size, smx_host_t host)
1350 {
1351   return simcall_BODY_file_write(fd, size, host);
1352 }
1353
1354 /**
1355  * \ingroup simix_file_management
1356  * \brief
1357  */
1358 smx_file_t simcall_file_open(const char* fullpath, smx_host_t host)
1359 {
1360   return simcall_BODY_file_open(fullpath, host);
1361 }
1362
1363 /**
1364  * \ingroup simix_file_management
1365  *
1366  */
1367 int simcall_file_close(smx_file_t fd, smx_host_t host)
1368 {
1369   return simcall_BODY_file_close(fd, host);
1370 }
1371
1372 /**
1373  * \ingroup simix_file_management
1374  *
1375  */
1376 int simcall_file_unlink(smx_file_t fd, smx_host_t host)
1377 {
1378   return simcall_BODY_file_unlink(fd, host);
1379 }
1380
1381 /**
1382  * \ingroup simix_file_management
1383  *
1384  */
1385 sg_size_t simcall_file_get_size(smx_file_t fd){
1386   return simcall_BODY_file_get_size(fd);
1387 }
1388
1389 /**
1390  * \ingroup simix_file_management
1391  *
1392  */
1393 sg_size_t simcall_file_tell(smx_file_t fd){
1394   return simcall_BODY_file_tell(fd);
1395 }
1396
1397 /**
1398  * \ingroup simix_file_management
1399  *
1400  */
1401 xbt_dynar_t simcall_file_get_info(smx_file_t fd)
1402 {
1403   return simcall_BODY_file_get_info(fd);
1404 }
1405
1406 /**
1407  * \ingroup simix_file_management
1408  *
1409  */
1410 int simcall_file_seek(smx_file_t fd, sg_offset_t offset, int origin){
1411   return simcall_BODY_file_seek(fd, offset, origin);
1412 }
1413
1414 /**
1415  * \ingroup simix_file_management
1416  * \brief Move a file to another location on the *same mount point*.
1417  *
1418  */
1419 int simcall_file_move(smx_file_t fd, const char* fullpath)
1420 {
1421   return simcall_BODY_file_move(fd, fullpath);
1422 }
1423
1424 /**
1425  * \ingroup simix_storage_management
1426  * \brief Returns the free space size on a given storage element.
1427  * \param storage a storage
1428  * \return Return the free space size on a given storage element (as sg_size_t)
1429  */
1430 sg_size_t simcall_storage_get_free_size (smx_storage_t storage){
1431   return simcall_BODY_storage_get_free_size(storage);
1432 }
1433
1434 /**
1435  * \ingroup simix_storage_management
1436  * \brief Returns the used space size on a given storage element.
1437  * \param storage a storage
1438  * \return Return the used space size on a given storage element (as sg_size_t)
1439  */
1440 sg_size_t simcall_storage_get_used_size (smx_storage_t storage){
1441   return simcall_BODY_storage_get_used_size(storage);
1442 }
1443
1444 /**
1445  * \ingroup simix_storage_management
1446  * \brief Returns the list of storages mounted on an host.
1447  * \param host A SIMIX host
1448  * \return a dict containing all storages mounted on the host
1449  */
1450 xbt_dict_t simcall_host_get_mounted_storage_list(smx_host_t host)
1451 {
1452   return simcall_BODY_host_get_mounted_storage_list(host);
1453 }
1454
1455 /**
1456  * \ingroup simix_storage_management
1457  * \brief Returns the list of storages attached to an host.
1458  * \param host A SIMIX host
1459  * \return a dict containing all storages attached to the host
1460  */
1461 xbt_dynar_t simcall_host_get_attached_storage_list(smx_host_t host)
1462 {
1463   return simcall_BODY_host_get_attached_storage_list(host);
1464 }
1465
1466 /**
1467  * \ingroup simix_storage_management
1468  * \brief Returns a dict of the properties assigned to a storage element.
1469  *
1470  * \param storage A storage element
1471  * \return The properties of this storage element
1472  */
1473 xbt_dict_t simcall_storage_get_properties(smx_storage_t storage)
1474 {
1475   return simcall_BODY_storage_get_properties(storage);
1476 }
1477
1478 /**
1479  * \ingroup simix_storage_management
1480  * \brief Returns a dict containing the content of a storage element.
1481  *
1482  * \param storage A storage element
1483  * \return The content of this storage element as a dict (full path file => size)
1484  */
1485 xbt_dict_t simcall_storage_get_content(smx_storage_t storage)
1486 {
1487   return simcall_BODY_storage_get_content(storage);
1488 }
1489
1490
1491
1492 #ifdef HAVE_MC
1493
1494 void *simcall_mc_snapshot(void) {
1495   return simcall_BODY_mc_snapshot();
1496 }
1497
1498 int simcall_mc_compare_snapshots(void *s1, void *s2) {
1499   return simcall_BODY_mc_compare_snapshots(s1, s2);
1500 }
1501
1502 #endif /* HAVE_MC */
1503
1504 int simcall_mc_random(int min, int max) {
1505   return simcall_BODY_mc_random(min, max);
1506 }
1507
1508 /* ************************************************************************** */
1509
1510 /** @brief returns a printable string representing a simcall */
1511 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1512   return simcall_names[kind];
1513 }