src/simix/smx_user.c

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