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