src/simix/libsmx.c

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