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