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