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 = NULL; /* MC needs the comm to be set to NULL during the simcall */
1023     comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size,
1024                               match_fun, data, rate);
1025     simcall_comm_wait(comm, timeout);
1026     comm = NULL;
1027   }
1028   else {
1029     simcall_BODY_comm_recv(rdv, dst_buff, dst_buff_size,
1030                            match_fun, data, timeout, rate);
1031   }
1032 }
1033 /**
1034  * \ingroup simix_comm_management
1035  */
1036 smx_action_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
1037                                 int (*match_fun)(void *, void *, smx_action_t),
1038                                 void *data, double rate)
1039 {
1040   xbt_assert(rdv, "No rendez-vous point defined for irecv");
1041
1042   return simcall_BODY_comm_irecv(rdv, dst_buff, dst_buff_size,
1043                                  match_fun, data, rate);
1044 }
1045
1046
1047 /**
1048  * \ingroup simix_comm_management
1049  */
1050 smx_action_t simcall_comm_iprobe(smx_rdv_t rdv, int src, int tag,
1051                                 int (*match_fun)(void *, void *, smx_action_t), void *data)
1052 {
1053   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
1054
1055   return simcall_BODY_comm_iprobe(rdv, src, tag, match_fun, data);
1056 }
1057
1058 void simcall_comm_destroy(smx_action_t comm)
1059 {
1060   xbt_assert(comm, "Invalid parameter");
1061
1062   /* FIXME remove this simcall type: comms are auto-destroyed now */
1063
1064   /*
1065   smx_simcall_t simcall = simcall_mine();
1066
1067   simcall->call = SIMCALL_COMM_DESTROY;
1068   simcall->comm_destroy.comm = comm;
1069
1070   SIMIX_simcall_push(simcall->issuer);
1071   */
1072 }
1073
1074 /**
1075  * \ingroup simix_comm_management
1076  */
1077 void simcall_comm_cancel(smx_action_t comm)
1078 {
1079   simcall_BODY_comm_cancel(comm);
1080 }
1081
1082 /**
1083  * \ingroup simix_comm_management
1084  */
1085 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
1086 {
1087   return simcall_BODY_comm_waitany(comms);
1088 }
1089
1090 /**
1091  * \ingroup simix_comm_management
1092  */
1093 int simcall_comm_testany(xbt_dynar_t comms)
1094 {
1095   if (xbt_dynar_is_empty(comms))
1096     return -1;
1097   return simcall_BODY_comm_testany(comms);
1098 }
1099
1100 /**
1101  * \ingroup simix_comm_management
1102  */
1103 void simcall_comm_wait(smx_action_t comm, double timeout)
1104 {
1105   xbt_assert(isfinite(timeout), "timeout is not finite!");
1106   simcall_BODY_comm_wait(comm, timeout);
1107 }
1108
1109 #ifdef HAVE_TRACING
1110 /**
1111  * \brief Set the category of an action.
1112  *
1113  * This functions changes the category only. It calls a surf function.
1114  * \param execution The execution action
1115  * \param category The tracing category
1116  */
1117 void simcall_set_category(smx_action_t action, const char *category)
1118 {
1119   if (category == NULL) {
1120     return;
1121   }
1122   simcall_BODY_set_category(action, category);
1123 }
1124 #endif
1125
1126 /**
1127  * \ingroup simix_comm_management
1128  *
1129  */
1130 int simcall_comm_test(smx_action_t comm)
1131 {
1132   return simcall_BODY_comm_test(comm);
1133 }
1134
1135 /**
1136  * \ingroup simix_comm_management
1137  *
1138  */
1139 double simcall_comm_get_remains(smx_action_t comm)
1140 {
1141   return simcall_BODY_comm_get_remains(comm);
1142 }
1143
1144 /**
1145  * \ingroup simix_comm_management
1146  *
1147  */
1148 e_smx_state_t simcall_comm_get_state(smx_action_t comm)
1149 {
1150   return simcall_BODY_comm_get_state(comm);
1151 }
1152
1153 /**
1154  * \ingroup simix_comm_management
1155  *
1156  */
1157 void *simcall_comm_get_src_data(smx_action_t comm)
1158 {
1159   return simcall_BODY_comm_get_src_data(comm);
1160 }
1161
1162 /**
1163  * \ingroup simix_comm_management
1164  *
1165  */
1166 void *simcall_comm_get_dst_data(smx_action_t comm)
1167 {
1168   return simcall_BODY_comm_get_dst_data(comm);
1169 }
1170
1171 /**
1172  * \ingroup simix_comm_management
1173  *
1174  */
1175 smx_process_t simcall_comm_get_src_proc(smx_action_t comm)
1176 {
1177   return simcall_BODY_comm_get_src_proc(comm);
1178 }
1179
1180 /**
1181  * \ingroup simix_comm_management
1182  *
1183  */
1184 smx_process_t simcall_comm_get_dst_proc(smx_action_t comm)
1185 {
1186   return simcall_BODY_comm_get_dst_proc(comm);
1187 }
1188
1189 #ifdef HAVE_LATENCY_BOUND_TRACKING
1190 int simcall_comm_is_latency_bounded(smx_action_t comm)
1191 {
1192   return simcall_BODY_comm_is_latency_bounded(comm);
1193 }
1194 #endif
1195
1196 /**
1197  * \ingroup simix_synchro_management
1198  *
1199  */
1200 smx_mutex_t simcall_mutex_init(void)
1201 {
1202   if(!simix_global) {
1203     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
1204     xbt_abort();
1205   }
1206   return simcall_BODY_mutex_init();
1207 }
1208
1209 /**
1210  * \ingroup simix_synchro_management
1211  *
1212  */
1213 void simcall_mutex_destroy(smx_mutex_t mutex)
1214 {
1215   simcall_BODY_mutex_destroy(mutex);
1216 }
1217
1218 /**
1219  * \ingroup simix_synchro_management
1220  *
1221  */
1222 void simcall_mutex_lock(smx_mutex_t mutex)
1223 {
1224   simcall_BODY_mutex_lock(mutex);
1225 }
1226
1227 /**
1228  * \ingroup simix_synchro_management
1229  *
1230  */
1231 int simcall_mutex_trylock(smx_mutex_t mutex)
1232 {
1233   return simcall_BODY_mutex_trylock(mutex);
1234 }
1235
1236 /**
1237  * \ingroup simix_synchro_management
1238  *
1239  */
1240 void simcall_mutex_unlock(smx_mutex_t mutex)
1241 {
1242   simcall_BODY_mutex_unlock(mutex);
1243 }
1244
1245 /**
1246  * \ingroup simix_synchro_management
1247  *
1248  */
1249 smx_cond_t simcall_cond_init(void)
1250 {
1251   return simcall_BODY_cond_init();
1252 }
1253
1254 /**
1255  * \ingroup simix_synchro_management
1256  *
1257  */
1258 void simcall_cond_destroy(smx_cond_t cond)
1259 {
1260   simcall_BODY_cond_destroy(cond);
1261 }
1262
1263 /**
1264  * \ingroup simix_synchro_management
1265  *
1266  */
1267 void simcall_cond_signal(smx_cond_t cond)
1268 {
1269   simcall_BODY_cond_signal(cond);
1270 }
1271
1272 /**
1273  * \ingroup simix_synchro_management
1274  *
1275  */
1276 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
1277 {
1278   simcall_BODY_cond_wait(cond, mutex);
1279 }
1280
1281 /**
1282  * \ingroup simix_synchro_management
1283  *
1284  */
1285 void simcall_cond_wait_timeout(smx_cond_t cond,
1286                                  smx_mutex_t mutex,
1287                                  double timeout)
1288 {
1289   xbt_assert(isfinite(timeout), "timeout is not finite!");
1290   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
1291 }
1292
1293 /**
1294  * \ingroup simix_synchro_management
1295  *
1296  */
1297 void simcall_cond_broadcast(smx_cond_t cond)
1298 {
1299   simcall_BODY_cond_broadcast(cond);
1300 }
1301
1302 /**
1303  * \ingroup simix_synchro_management
1304  *
1305  */
1306 smx_sem_t simcall_sem_init(int capacity)
1307 {
1308   return simcall_BODY_sem_init(capacity);
1309 }
1310
1311 /**
1312  * \ingroup simix_synchro_management
1313  *
1314  */
1315 void simcall_sem_destroy(smx_sem_t sem)
1316 {
1317   simcall_sem_destroy(sem);
1318 }
1319
1320 /**
1321  * \ingroup simix_synchro_management
1322  *
1323  */
1324 void simcall_sem_release(smx_sem_t sem)
1325 {
1326   simcall_BODY_sem_release(sem);
1327 }
1328
1329 /**
1330  * \ingroup simix_synchro_management
1331  *
1332  */
1333 int simcall_sem_would_block(smx_sem_t sem)
1334 {
1335   return simcall_BODY_sem_would_block(sem);
1336 }
1337
1338 /**
1339  * \ingroup simix_synchro_management
1340  *
1341  */
1342 void simcall_sem_acquire(smx_sem_t sem)
1343 {
1344   simcall_BODY_sem_acquire(sem);
1345 }
1346
1347 /**
1348  * \ingroup simix_synchro_management
1349  *
1350  */
1351 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1352 {
1353   xbt_assert(isfinite(timeout), "timeout is not finite!");
1354   simcall_BODY_sem_acquire_timeout(sem, timeout);
1355 }
1356
1357 /**
1358  * \ingroup simix_synchro_management
1359  *
1360  */
1361 int simcall_sem_get_capacity(smx_sem_t sem)
1362 {
1363   return simcall_BODY_sem_get_capacity(sem);
1364 }
1365
1366 /**
1367  * \ingroup simix_file_management
1368  * \brief Returns the user data associated to a file.
1369  *
1370  * \param fd A simix file
1371  * \return the user data of this file
1372  */
1373 void* simcall_file_get_data(smx_file_t fd)
1374 {
1375   return simcall_BODY_file_get_data(fd);
1376 }
1377
1378 /**
1379  * \ingroup simix_file_management
1380  * \brief Sets the user data associated to a file.
1381  *
1382  * \param fd A SIMIX file
1383  * \param data The user data to set
1384  */
1385 void simcall_file_set_data(smx_file_t fd, void *data)
1386 {
1387   simcall_file_set_data(fd, data);
1388 }
1389
1390 /**
1391  * \ingroup simix_file_management
1392  *
1393  */
1394 sg_size_t simcall_file_read(smx_file_t fd, sg_size_t size)
1395 {
1396   return simcall_BODY_file_read(fd, size);
1397 }
1398
1399 /**
1400  * \ingroup simix_file_management
1401  *
1402  */
1403 sg_size_t simcall_file_write(smx_file_t fd, sg_size_t size)
1404 {
1405   return simcall_BODY_file_write(fd, size);
1406 }
1407
1408 /**
1409  * \ingroup simix_file_management
1410  * \brief
1411  */
1412 smx_file_t simcall_file_open(const char* mount, const char* path)
1413 {
1414   return simcall_BODY_file_open(mount, path);
1415 }
1416
1417 /**
1418  * \ingroup simix_file_management
1419  *
1420  */
1421 int simcall_file_close(smx_file_t fd)
1422 {
1423   return simcall_BODY_file_close(fd);
1424 }
1425
1426 /**
1427  * \ingroup simix_file_management
1428  *
1429  */
1430 int simcall_file_unlink(smx_file_t fd)
1431 {
1432   return simcall_BODY_file_unlink(fd);
1433 }
1434
1435 /**
1436  * \ingroup simix_file_management
1437  *
1438  */
1439 xbt_dict_t simcall_file_ls(const char* mount, const char* path)
1440 {
1441   return simcall_BODY_file_ls(mount, path);
1442 }
1443 /**
1444  * \ingroup simix_file_management
1445  *
1446  */
1447 sg_size_t simcall_file_get_size(smx_file_t fd){
1448   return simcall_BODY_file_get_size(fd);
1449 }
1450
1451 /**
1452  * \ingroup simix_file_management
1453  *
1454  */
1455 sg_size_t simcall_file_tell(smx_file_t fd){
1456   return simcall_BODY_file_tell(fd);
1457 }
1458
1459 /**
1460  * \ingroup simix_file_management
1461  *
1462  */
1463 xbt_dynar_t simcall_file_get_info(smx_file_t fd)
1464 {
1465   return simcall_BODY_file_get_info(fd);
1466 }
1467
1468 /**
1469  * \ingroup simix_file_management
1470  *
1471  */
1472 int simcall_file_seek(smx_file_t fd, sg_size_t offset, int origin){
1473   return simcall_BODY_file_seek(fd, offset, origin);
1474 }
1475
1476 /**
1477  * \ingroup simix_file_management
1478  *
1479  */
1480 void simcall_storage_file_rename(smx_storage_t storage, const char* src,  const char* dest)
1481 {
1482   return simcall_BODY_storage_file_rename(storage, src, dest);
1483 }
1484
1485 /**
1486  * \ingroup simix_storage_management
1487  * \brief Returns the free space size on a given storage element.
1488  * \param storage name
1489  * \return Return the free space size on a given storage element (as sg_size_t)
1490  */
1491 sg_size_t simcall_storage_get_free_size (const char* name){
1492   return simcall_BODY_storage_get_free_size(name);
1493 }
1494
1495 /**
1496  * \ingroup simix_storage_management
1497  * \brief Returns the used space size on a given storage element.
1498  * \param storage name
1499  * \return Return the used space size on a given storage element (as sg_size_t)
1500  */
1501 sg_size_t simcall_storage_get_used_size (const char* name){
1502   return simcall_BODY_storage_get_used_size(name);
1503 }
1504
1505 /**
1506  * \ingroup simix_storage_management
1507  * \brief Returns the list of storages mounted on an host.
1508  * \param host A SIMIX host
1509  * \return a dict containing all storages mounted on the host
1510  */
1511 xbt_dict_t simcall_host_get_storage_list(smx_host_t host)
1512 {
1513   return simcall_BODY_host_get_storage_list(host);
1514 }
1515
1516 /**
1517  * \ingroup simix_storage_management
1518  * \brief Returns a dict of the properties assigned to a storage element.
1519  *
1520  * \param storage A storage element
1521  * \return The properties of this storage element
1522  */
1523 xbt_dict_t simcall_storage_get_properties(smx_storage_t storage)
1524 {
1525   return simcall_BODY_storage_get_properties(storage);
1526 }
1527
1528 /**
1529  * \ingroup simix_storage_management
1530  * \brief Returns a dict containing the content of a storage element.
1531  *
1532  * \param storage A storage element
1533  * \return The content of this storage element as a dict (full path file => size)
1534  */
1535 xbt_dict_t simcall_storage_get_content(smx_storage_t storage)
1536 {
1537   return simcall_BODY_storage_get_content(storage);
1538 }
1539
1540 #ifdef HAVE_MC
1541
1542 void *simcall_mc_snapshot(void)
1543 {
1544   return simcall_BODY_mc_snapshot();
1545 }
1546
1547 int simcall_mc_compare_snapshots(void *s1, void *s2){
1548   return simcall_BODY_mc_compare_snapshots(s1, s2);
1549 }
1550
1551 int simcall_mc_random(int min, int max)
1552 {
1553   return simcall_BODY_mc_random(min, max);
1554 }
1555
1556
1557 #endif /* HAVE_MC */
1558
1559 /* ****************************************************************************************** */
1560 /* TUTORIAL: New API                                                                          */
1561 /* All functions for simcall                                                                  */
1562 /* ****************************************************************************************** */
1563 int simcall_new_api_fct(const char* param1, double param2){
1564   smx_simcall_t simcall = SIMIX_simcall_mine();
1565   simcall->call = SIMCALL_NEW_API_INIT;
1566   simcall->new_api.param1 = param1;
1567   simcall->new_api.param2 = param2;
1568
1569   SIMIX_simcall_push(simcall->issuer);
1570   return simcall->new_api.result;
1571 }
1572
1573 /* ************************************************************************** */
1574
1575 /** @brief returns a printable string representing a simcall */
1576 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1577   return simcall_names[kind];
1578 }