src/simix/libsmx.cpp

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