src/simix/smx_user.c

   1 /* smx_user.c - public interface to simix                                   */
   2
   3 /* Copyright (c) 2010, 2011. Da SimGrid team. All rights reserved.          */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7 #ifndef _SVID_SOURCE
   8 #  define _SVID_SOURCE    /* strdup() */
   9 #endif
  10 #ifndef _ISOC99_SOURCE
  11 #  define _ISOC99_SOURCE  /* isfinite() */
  12 #endif
  13 #ifndef _ISO_C99_SOURCE
  14 #  define _ISO_C99_SOURCE /* isfinite() */
  15 #endif
  16 #include <math.h>         /* isfinite() */
  17
  18 #include "smx_private.h"
  19 #include "mc/mc.h"
  20 #include "xbt/ex.h"
  21
  22 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
  23
  24 static const char* simcall_names[] = {
  25 #undef SIMCALL_ENUM_ELEMENT
  26 #define SIMCALL_ENUM_ELEMENT(x) #x /* generate strings from the enumeration values */
  27 SIMCALL_LIST
  28 #undef SIMCALL_ENUM_ELEMENT
  29 };
  30
  31 /**
  32  * \ingroup simix_host_management
  33  * \brief Returns a host given its name.
  34  *
  35  * \param name The name of the host to get
  36  * \return The corresponding host
  37  */
  38 smx_host_t simcall_host_get_by_name(const char *name)
  39 {
  40   smx_simcall_t simcall = SIMIX_simcall_mine();
  41
  42   simcall->call = SIMCALL_HOST_GET_BY_NAME;
  43   simcall->host_get_by_name.name = name;
  44   SIMIX_simcall_push(simcall->issuer);
  45   return simcall->host_get_by_name.result;
  46 }
  47
  48 /**
  49  * \ingroup simix_host_management
  50  * \brief Returns the name of a host.
  51  *
  52  * \param host A SIMIX host
  53  * \return The name of this host
  54  */
  55 const char* simcall_host_get_name(smx_host_t host)
  56 {
  57   smx_simcall_t simcall = SIMIX_simcall_mine();
  58
  59   simcall->call = SIMCALL_HOST_GET_NAME;
  60   simcall->host_get_name.host = host;
  61   SIMIX_simcall_push(simcall->issuer);
  62   return simcall->host_get_name.result;
  63 }
  64
  65 /**
  66  * \ingroup simix_host_management
  67  * \brief Returns a dict of the properties assigned to a host.
  68  *
  69  * \param host A host
  70  * \return The properties of this host
  71  */
  72 xbt_dict_t simcall_host_get_properties(smx_host_t host)
  73 {
  74   smx_simcall_t simcall = SIMIX_simcall_mine();
  75
  76   simcall->call = SIMCALL_HOST_GET_PROPERTIES;
  77   simcall->host_get_properties.host = host;
  78   SIMIX_simcall_push(simcall->issuer);
  79   return simcall->host_get_properties.result;
  80 }
  81
  82 /**
  83  * \ingroup simix_host_management
  84  * \brief Returns the speed of the processor.
  85  *
  86  * The speed returned does not take into account the current load on the machine.
  87  * \param host A SIMIX host
  88  * \return The speed of this host (in Mflop/s)
  89  */
  90 double simcall_host_get_speed(smx_host_t host)
  91 {
  92   smx_simcall_t simcall = SIMIX_simcall_mine();
  93
  94   simcall->call = SIMCALL_HOST_GET_SPEED;
  95   simcall->host_get_speed.host = host;
  96   SIMIX_simcall_push(simcall->issuer);
  97   return simcall->host_get_speed.result;
  98 }
  99
 100 /**
 101  * \ingroup simix_host_management
 102  * \brief Returns the available speed of the processor.
 103  *
 104  * \return Speed currently available (in Mflop/s)
 105  */
 106 double simcall_host_get_available_speed(smx_host_t host)
 107 {
 108   smx_simcall_t simcall = SIMIX_simcall_mine();
 109
 110   simcall->call = SIMCALL_HOST_GET_AVAILABLE_SPEED;
 111   simcall->host_get_available_speed.host = host;
 112   SIMIX_simcall_push(simcall->issuer);
 113   return simcall->host_get_available_speed.result;
 114 }
 115
 116 /**
 117  * \ingroup simix_host_management
 118  * \brief Returns the state of a host.
 119  *
 120  * Two states are possible: 1 if the host is active or 0 if it has crashed.
 121  * \param host A SIMIX host
 122  * \return 1 if the host is available, 0 otherwise
 123  */
 124 int simcall_host_get_state(smx_host_t host)
 125 {
 126   smx_simcall_t simcall = SIMIX_simcall_mine();
 127
 128   simcall->call = SIMCALL_HOST_GET_STATE;
 129   simcall->host_get_state.host = host;
 130   SIMIX_simcall_push(simcall->issuer);
 131   return simcall->host_get_state.result;
 132 }
 133
 134 /**
 135  * \ingroup simix_host_management
 136  * \brief Returns the user data associated to a host.
 137  *
 138  * \param host SIMIX host
 139  * \return the user data of this host
 140  */
 141 void* simcall_host_get_data(smx_host_t host)
 142 {
 143   smx_simcall_t simcall = SIMIX_simcall_mine();
 144
 145   simcall->call = SIMCALL_HOST_GET_DATA;
 146   simcall->host_get_data.host = host;
 147   SIMIX_simcall_push(simcall->issuer);
 148   return simcall->host_get_data.result;
 149 }
 150
 151 /**
 152  * \ingroup simix_host_management
 153  * \brief Sets the user data associated to a host.
 154  *
 155  * The host must not have previous user data associated to it.
 156  * \param host A SIMIX host
 157  * \param data The user data to set
 158  */
 159 void simcall_host_set_data(smx_host_t host, void *data)
 160 {
 161   smx_simcall_t simcall = SIMIX_simcall_mine();
 162
 163   simcall->call = SIMCALL_HOST_SET_DATA;
 164   simcall->host_set_data.host = host;
 165   simcall->host_set_data.data = data;
 166   SIMIX_simcall_push(simcall->issuer);
 167 }
 168
 169 /**
 170  * \ingroup simix_host_management
 171  * \brief Creates an action that executes some computation of an host.
 172  *
 173  * This function creates a SURF action and allocates the data necessary
 174  * to create the SIMIX action. It can raise a host_error exception if the host crashed.
 175  *
 176  * \param name Name of the execution action to create
 177  * \param host SIMIX host where the action will be executed
 178  * \param computation_amount amount Computation amount (in bytes)
 179  * \param priority computation priority
 180  * \return A new SIMIX execution action
 181  */
 182 smx_action_t simcall_host_execute(const char *name, smx_host_t host,
 183                                     double computation_amount,
 184                                     double priority)
 185 {
 186   /* checking for infinite values */
 187   xbt_assert(isfinite(computation_amount), "computation_amount is not finite!");
 188   xbt_assert(isfinite(priority), "priority is not finite!");
 189
 190   smx_simcall_t simcall = SIMIX_simcall_mine();
 191
 192   simcall->call = SIMCALL_HOST_EXECUTE;
 193   simcall->host_execute.name = name;
 194   simcall->host_execute.host = host;
 195   simcall->host_execute.computation_amount = computation_amount;
 196   simcall->host_execute.priority = priority;
 197   SIMIX_simcall_push(simcall->issuer);
 198   return simcall->host_execute.result;
 199 }
 200
 201 /**
 202  * \ingroup simix_host_management
 203  * \brief Creates an action that may involve parallel computation on
 204  * several hosts and communication between them.
 205  *
 206  * \param name Name of the execution action to create
 207  * \param host_nb Number of hosts where the action will be executed
 208  * \param host_list Array (of size host_nb) of hosts where the action will be executed
 209  * \param computation_amount Array (of size host_nb) of computation amount of hosts (in bytes)
 210  * \param communication_amount Array (of size host_nb * host_nb) representing the communication
 211  * amount between each pair of hosts
 212  * \param amount the SURF action amount
 213  * \param rate the SURF action rate
 214  * \return A new SIMIX execution action
 215  */
 216 smx_action_t simcall_host_parallel_execute(const char *name,
 217                                          int host_nb,
 218                                          smx_host_t *host_list,
 219                                          double *computation_amount,
 220                                          double *communication_amount,
 221                                          double amount,
 222                                          double rate)
 223 {
 224   int i,j;
 225   /* checking for infinite values */
 226   for (i = 0 ; i < host_nb ; ++i) {
 227      xbt_assert(isfinite(computation_amount[i]), "computation_amount[%d] is not finite!", i);
 228      for (j = 0 ; j < host_nb ; ++j) {
 229         xbt_assert(isfinite(communication_amount[i + host_nb * j]),
 230              "communication_amount[%d+%d*%d] is not finite!", i, host_nb, j);
 231      }
 232   }
 233
 234   xbt_assert(isfinite(amount), "amount is not finite!");
 235   xbt_assert(isfinite(rate), "rate is not finite!");
 236
 237   smx_simcall_t simcall = SIMIX_simcall_mine();
 238
 239   simcall->call = SIMCALL_HOST_PARALLEL_EXECUTE;
 240   simcall->host_parallel_execute.name = name;
 241   simcall->host_parallel_execute.host_nb = host_nb;
 242   simcall->host_parallel_execute.host_list = host_list;
 243   simcall->host_parallel_execute.computation_amount = computation_amount;
 244   simcall->host_parallel_execute.communication_amount = communication_amount;
 245   simcall->host_parallel_execute.amount = amount;
 246   simcall->host_parallel_execute.rate = rate;
 247   SIMIX_simcall_push(simcall->issuer);
 248   return simcall->host_parallel_execute.result;
 249 }
 250
 251 /**
 252  * \ingroup simix_host_management
 253  * \brief Destroys an execution action.
 254  *
 255  * Destroys an action, freing its memory. This function cannot be called if there are a conditional waiting for it.
 256  * \param execution The execution action to destroy
 257  */
 258 void simcall_host_execution_destroy(smx_action_t execution)
 259 {
 260   smx_simcall_t simcall = SIMIX_simcall_mine();
 261
 262   simcall->call = SIMCALL_HOST_EXECUTION_DESTROY;
 263   simcall->host_execution_destroy.execution = execution;
 264   SIMIX_simcall_push(simcall->issuer);
 265 }
 266
 267 /**
 268  * \ingroup simix_host_management
 269  * \brief Cancels an execution action.
 270  *
 271  * This functions stops the execution. It calls a surf function.
 272  * \param execution The execution action to cancel
 273  */
 274 void simcall_host_execution_cancel(smx_action_t execution)
 275 {
 276   smx_simcall_t simcall = SIMIX_simcall_mine();
 277
 278   simcall->call = SIMCALL_HOST_EXECUTION_CANCEL;
 279   simcall->host_execution_cancel.execution = execution;
 280   SIMIX_simcall_push(simcall->issuer);
 281 }
 282
 283 /**
 284  * \ingroup simix_host_management
 285  * \brief Returns how much of an execution action remains to be done.
 286  *
 287  * \param execution The execution action
 288  * \return The remaining amount
 289  */
 290 double simcall_host_execution_get_remains(smx_action_t execution)
 291 {
 292   smx_simcall_t simcall = SIMIX_simcall_mine();
 293
 294   simcall->call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
 295   simcall->host_execution_get_remains.execution = execution;
 296   SIMIX_simcall_push(simcall->issuer);
 297   return simcall->host_execution_get_remains.result;
 298 }
 299
 300 /**
 301  * \ingroup simix_host_management
 302  * \brief Returns the state of an execution action.
 303  *
 304  * \param execution The execution action
 305  * \return The state
 306  */
 307 e_smx_state_t simcall_host_execution_get_state(smx_action_t execution)
 308 {
 309   smx_simcall_t simcall = SIMIX_simcall_mine();
 310
 311   simcall->call = SIMCALL_HOST_EXECUTION_GET_STATE;
 312   simcall->host_execution_get_state.execution = execution;
 313   SIMIX_simcall_push(simcall->issuer);
 314   return simcall->host_execution_get_state.result;
 315 }
 316
 317 /**
 318  * \ingroup simix_host_management
 319  * \brief Changes the priority of an execution action.
 320  *
 321  * This functions changes the priority only. It calls a surf function.
 322  * \param execution The execution action
 323  * \param priority The new priority
 324  */
 325 void simcall_host_execution_set_priority(smx_action_t execution, double priority)
 326 {
 327   /* checking for infinite values */
 328   xbt_assert(isfinite(priority), "priority is not finite!");
 329
 330   smx_simcall_t simcall = SIMIX_simcall_mine();
 331
 332   simcall->call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
 333   simcall->host_execution_set_priority.execution = execution;
 334   simcall->host_execution_set_priority.priority = priority;
 335   SIMIX_simcall_push(simcall->issuer);
 336 }
 337
 338 /**
 339  * \ingroup simix_host_management
 340  * \brief Waits for the completion of an execution action and destroy it.
 341  *
 342  * \param execution The execution action
 343  */
 344 e_smx_state_t simcall_host_execution_wait(smx_action_t execution)
 345 {
 346   smx_simcall_t simcall = SIMIX_simcall_mine();
 347
 348   simcall->call = SIMCALL_HOST_EXECUTION_WAIT;
 349   simcall->host_execution_wait.execution = execution;
 350   SIMIX_simcall_push(simcall->issuer);
 351   return simcall->host_execution_wait.result;
 352 }
 353
 354 /**
 355  * \ingroup simix_process_management
 356  * \brief Creates and runs a new SIMIX process.
 357  *
 358  * The structure and the corresponding thread are created and put in the list of ready processes.
 359  *
 360  * \param process the process created will be stored in this pointer
 361  * \param name a name for the process. It is for user-level information and can be NULL.
 362  * \param code the main function of the process
 363  * \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.
 364  * It can be retrieved with the function \ref simcall_process_get_data.
 365  * \param hostname name of the host where the new agent is executed.
 366  * \param kill_time time when the process is killed
 367  * \param argc first argument passed to \a code
 368  * \param argv second argument passed to \a code
 369  * \param properties the properties of the process
 370  * \param auto_restart either it is autorestarting or not.
 371  */
 372 void simcall_process_create(smx_process_t *process, const char *name,
 373                               xbt_main_func_t code,
 374                               void *data,
 375                               const char *hostname,
 376                               double kill_time,
 377                               int argc, char **argv,
 378                               xbt_dict_t properties,
 379                               int auto_restart)
 380 {
 381   smx_simcall_t simcall = SIMIX_simcall_mine();
 382
 383   simcall->call = SIMCALL_PROCESS_CREATE;
 384   simcall->process_create.process = process;
 385   simcall->process_create.name = name;
 386   simcall->process_create.code = code;
 387   simcall->process_create.data = data;
 388   simcall->process_create.hostname = hostname;
 389   simcall->process_create.kill_time = kill_time;
 390   simcall->process_create.argc = argc;
 391   simcall->process_create.argv = argv;
 392   simcall->process_create.properties = properties;
 393   simcall->process_create.auto_restart = auto_restart;
 394   SIMIX_simcall_push(simcall->issuer);
 395 }
 396
 397 /**
 398  * \ingroup simix_process_management
 399  * \brief Kills a SIMIX process.
 400  *
 401  * This function simply kills a  process.
 402  *
 403  * \param process poor victim
 404  */
 405 void simcall_process_kill(smx_process_t process)
 406 {
 407   smx_simcall_t simcall = SIMIX_simcall_mine();
 408
 409   simcall->call = SIMCALL_PROCESS_KILL;
 410   simcall->process_kill.process = process;
 411   SIMIX_simcall_push(simcall->issuer);
 412 }
 413
 414 /**
 415  * \ingroup simix_process_management
 416  * \brief Kills all SIMIX processes.
 417  */
 418 void simcall_process_killall(void)
 419 {
 420   smx_simcall_t simcall = SIMIX_simcall_mine();
 421
 422   simcall->call = SIMCALL_PROCESS_KILLALL;
 423   SIMIX_simcall_push(simcall->issuer);
 424 }
 425
 426 /**
 427  * \ingroup simix_process_management
 428  * \brief Cleans up a SIMIX process.
 429  * \param process poor victim (must have already been killed)
 430  */
 431 void simcall_process_cleanup(smx_process_t process)
 432 {
 433   smx_simcall_t simcall = SIMIX_simcall_mine();
 434
 435   simcall->call = SIMCALL_PROCESS_CLEANUP;
 436   simcall->process_cleanup.process = process;
 437   SIMIX_simcall_push(simcall->issuer);
 438 }
 439
 440 /**
 441  * \ingroup simix_process_management
 442  * \brief Migrates an agent to another location.
 443  *
 444  * This function changes the value of the host on which \a process is running.
 445  *
 446  * \param process the process to migrate
 447  * \param dest name of the new host
 448  */
 449 void simcall_process_change_host(smx_process_t process, smx_host_t dest)
 450 {
 451   smx_simcall_t simcall = SIMIX_simcall_mine();
 452
 453   simcall->call = SIMCALL_PROCESS_CHANGE_HOST;
 454   simcall->process_change_host.process = process;
 455   simcall->process_change_host.dest = dest;
 456   SIMIX_simcall_push(simcall->issuer);
 457 }
 458
 459 /**
 460  * \ingroup simix_process_management
 461  * \brief Suspends a process.
 462  *
 463  * This function suspends the process by suspending the action
 464  * it was waiting for completion.
 465  *
 466  * \param process a SIMIX process
 467  */
 468 void simcall_process_suspend(smx_process_t process)
 469 {
 470   xbt_assert(process, "Invalid parameters");
 471
 472   smx_simcall_t simcall = SIMIX_simcall_mine();
 473
 474   simcall->call = SIMCALL_PROCESS_SUSPEND;
 475   simcall->process_suspend.process = process;
 476   SIMIX_simcall_push(simcall->issuer);
 477 }
 478
 479 /**
 480  * \ingroup simix_process_management
 481  * \brief Resumes a suspended process.
 482  *
 483  * This function resumes a suspended process by resuming the action
 484  * it was waiting for completion.
 485  *
 486  * \param process a SIMIX process
 487  */
 488 void simcall_process_resume(smx_process_t process)
 489 {
 490   smx_simcall_t simcall = SIMIX_simcall_mine();
 491
 492   simcall->call = SIMCALL_PROCESS_RESUME;
 493   simcall->process_resume.process = process;
 494   SIMIX_simcall_push(simcall->issuer);
 495 }
 496
 497 /**
 498  * \ingroup simix_process_management
 499  * \brief Returns the amount of SIMIX processes in the system
 500  *
 501  * Maestro internal process is not counted, only user code processes are
 502  */
 503 int simcall_process_count(void)
 504 {
 505   smx_simcall_t simcall = SIMIX_simcall_mine();
 506
 507   simcall->call = SIMCALL_PROCESS_COUNT;
 508   SIMIX_simcall_push(simcall->issuer);
 509   return simcall->process_count.result;
 510 }
 511
 512 /**
 513  * \ingroup simix_process_management
 514  * \brief Return the user data of a #smx_process_t.
 515  * \param process a SIMIX process
 516  * \return the user data of this process
 517  */
 518 void* simcall_process_get_data(smx_process_t process)
 519 {
 520   if (process == SIMIX_process_self()) {
 521     /* avoid a simcall if this function is called by the process itself */
 522     return SIMIX_process_get_data(process);
 523   }
 524
 525   smx_simcall_t simcall = SIMIX_simcall_mine();
 526
 527   simcall->call = SIMCALL_PROCESS_GET_DATA;
 528   simcall->process_get_data.process = process;
 529   SIMIX_simcall_push(simcall->issuer);
 530   return simcall->process_get_data.result;
 531 }
 532
 533 /**
 534  * \ingroup simix_process_management
 535  * \brief Set the user data of a #smx_process_t.
 536  *
 537  * This functions checks whether \a process is a valid pointer or not and set the user data associated to \a process if it is possible.
 538  * \param process SIMIX process
 539  * \param data User data
 540  */
 541 void simcall_process_set_data(smx_process_t process, void *data)
 542 {
 543   if (process == SIMIX_process_self()) {
 544     /* avoid a simcall if this function is called by the process itself */
 545     SIMIX_process_self_set_data(process, data);
 546   }
 547   else {
 548
 549     smx_simcall_t simcall = SIMIX_simcall_mine();
 550
 551     simcall->call = SIMCALL_PROCESS_SET_DATA;
 552     simcall->process_set_data.process = process;
 553     simcall->process_set_data.data = data;
 554     SIMIX_simcall_push(simcall->issuer);
 555   }
 556 }
 557
 558 /**
 559  * \ingroup simix_process_management
 560  * \brief Set the kill time of a process.
 561  * \param process a process
 562  * \param kill_time a double
 563  */
 564 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
 565 {
 566
 567   if (kill_time > SIMIX_get_clock()) {
 568     if (simix_global->kill_process_function) {
 569       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
 570           process->smx_host->name);
 571       SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
 572     }
 573   }
 574 }
 575
 576 /**
 577  * \ingroup simix_process_management
 578  * \brief Return the location on which an agent is running.
 579  *
 580  * This functions checks whether \a process is a valid pointer or not and return the m_host_t corresponding to the location on which \a process is running.
 581  * \param process SIMIX process
 582  * \return SIMIX host
 583  */
 584 smx_host_t simcall_process_get_host(smx_process_t process)
 585 {
 586   smx_simcall_t simcall = SIMIX_simcall_mine();
 587
 588   simcall->call = SIMCALL_PROCESS_GET_HOST;
 589   simcall->process_get_host.process = process;
 590   SIMIX_simcall_push(simcall->issuer);
 591   return simcall->process_get_host.result;
 592 }
 593
 594 /**
 595  * \ingroup simix_process_management
 596  * \brief Return the name of an agent.
 597  *
 598  * This functions checks whether \a process is a valid pointer or not and return its name.
 599  * \param process SIMIX process
 600  * \return The process name
 601  */
 602 const char* simcall_process_get_name(smx_process_t process)
 603 {
 604   if (process == SIMIX_process_self()) {
 605     /* avoid a simcall if this function is called by the process itself */
 606     return process->name;
 607   }
 608
 609   smx_simcall_t simcall = SIMIX_simcall_mine();
 610
 611   simcall->call = SIMCALL_PROCESS_GET_NAME;
 612   simcall->process_get_name.process = process;
 613   SIMIX_simcall_push(simcall->issuer);
 614   return simcall->process_get_name.result;
 615 }
 616
 617 /**
 618  * \ingroup simix_process_management
 619  * \brief Returns true if the process is suspended .
 620  *
 621  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
 622  * \param process SIMIX process
 623  * \return 1, if the process is suspended, else 0.
 624  */
 625 int simcall_process_is_suspended(smx_process_t process)
 626 {
 627   smx_simcall_t simcall = SIMIX_simcall_mine();
 628
 629   simcall->call = SIMCALL_PROCESS_IS_SUSPENDED;
 630   simcall->process_is_suspended.process = process;
 631   SIMIX_simcall_push(simcall->issuer);
 632   return simcall->process_is_suspended.result;
 633 }
 634
 635 /**
 636  * \ingroup simix_process_management
 637  * \brief Return the properties
 638  *
 639  * This functions returns the properties associated with this process
 640  */
 641 xbt_dict_t simcall_process_get_properties(smx_process_t process)
 642 {
 643   smx_simcall_t simcall = SIMIX_simcall_mine();
 644
 645   simcall->call = SIMCALL_PROCESS_GET_PROPERTIES;
 646   simcall->process_get_properties.process = process;
 647   SIMIX_simcall_push(simcall->issuer);
 648   return simcall->process_get_properties.result;
 649 }
 650 /**
 651  * \ingroup simix_process_management
 652  * \brief Add an on_exit function
 653  * Add an on_exit function which will be executed when the process exits/is killed.
 654  */
 655 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_t fun, void *data) {
 656   smx_simcall_t simcall = SIMIX_simcall_mine();
 657
 658   simcall->call = SIMCALL_PROCESS_ON_EXIT;
 659   simcall->process_on_exit.process = process;
 660   simcall->process_on_exit.fun = fun;
 661   simcall->process_on_exit.data = data;
 662
 663   SIMIX_simcall_push(simcall->issuer);
 664 }
 665 /**
 666  * \ingroup simix_process_management
 667  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
 668  * Will restart the process when the host comes back up if auto_restart is set to 1.
 669  */
 670
 671 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart) {
 672   smx_simcall_t simcall = SIMIX_simcall_mine();
 673
 674   simcall->call = SIMCALL_PROCESS_AUTO_RESTART_SET;
 675   simcall->process_auto_restart.process = process;
 676   simcall->process_auto_restart.auto_restart = auto_restart;
 677
 678   SIMIX_simcall_push(simcall->issuer);
 679 }
 680 /**
 681  * \ingroup simix_process_management
 682  * \brief Creates a new sleep SIMIX action.
 683  *
 684  * This function creates a SURF action and allocates the data necessary
 685  * to create the SIMIX action. It can raise a host_error exception if the
 686  * host crashed. The default SIMIX name of the action is "sleep".
 687  *
 688  *   \param duration Time duration of the sleep.
 689  *   \return A result telling whether the sleep was successful
 690  */
 691 e_smx_state_t simcall_process_sleep(double duration)
 692 {
 693   /* checking for infinite values */
 694   xbt_assert(isfinite(duration), "duration is not finite!");
 695
 696   smx_simcall_t simcall = SIMIX_simcall_mine();
 697
 698   simcall->call = SIMCALL_PROCESS_SLEEP;
 699   simcall->process_sleep.duration = duration;
 700   SIMIX_simcall_push(simcall->issuer);
 701   return simcall->process_sleep.result;
 702 }
 703
 704 /**
 705  *  \ingroup simix_rdv_management
 706  *  \brief Creates a new rendez-vous point
 707  *  \param name The name of the rendez-vous point
 708  *  \return The created rendez-vous point
 709  */
 710 smx_rdv_t simcall_rdv_create(const char *name)
 711 {
 712   smx_simcall_t simcall = SIMIX_simcall_mine();
 713
 714   simcall->call = SIMCALL_RDV_CREATE;
 715   simcall->rdv_create.name = name;
 716
 717   SIMIX_simcall_push(simcall->issuer);
 718   return simcall->rdv_create.result;
 719 }
 720
 721
 722 /**
 723  *  \ingroup simix_rdv_management
 724  *  \brief Destroy a rendez-vous point
 725  *  \param rdv The rendez-vous point to destroy
 726  */
 727 void simcall_rdv_destroy(smx_rdv_t rdv)
 728 {
 729   smx_simcall_t simcall = SIMIX_simcall_mine();
 730
 731   simcall->call = SIMCALL_RDV_DESTROY;
 732   simcall->rdv_destroy.rdv = rdv;
 733
 734   SIMIX_simcall_push(simcall->issuer);
 735 }
 736 /**
 737  *  \ingroup simix_rdv_management
 738  *  \brief Returns a rendez-vous point knowing its name
 739  */
 740 smx_rdv_t simcall_rdv_get_by_name(const char *name)
 741 {
 742   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
 743
 744   /* FIXME: this is a horrible lost of performance, so we hack it out by
 745    * skipping the simcall (for now). It works in parallel, it won't work on
 746    * distributed but probably we will change MSG for that. */
 747
 748   /*
 749   smx_simcall_t simcall = simcall_mine();
 750   simcall->call = SIMCALL_RDV_GEY_BY_NAME;
 751   simcall->rdv_get_by_name.name = name;
 752   SIMIX_simcall_push(simcall->issuer);
 753   return simcall->rdv_get_by_name.result;*/
 754
 755   return SIMIX_rdv_get_by_name(name);
 756 }
 757
 758 /**
 759  *  \ingroup simix_rdv_management
 760  *  \brief Counts the number of communication actions of a given host pending
 761  *         on a rendez-vous point.
 762  *  \param rdv The rendez-vous point
 763  *  \param host The host to be counted
 764  *  \return The number of comm actions pending in the rdv
 765  */
 766 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
 767 {
 768   smx_simcall_t simcall = SIMIX_simcall_mine();
 769
 770   simcall->call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
 771   simcall->rdv_comm_count_by_host.rdv = rdv;
 772   simcall->rdv_comm_count_by_host.host = host;
 773
 774   SIMIX_simcall_push(simcall->issuer);
 775   return simcall->rdv_comm_count_by_host.result;
 776 }
 777
 778 /**
 779  *  \ingroup simix_rdv_management
 780  *  \brief returns the communication at the head of the rendez-vous
 781  *  \param rdv The rendez-vous point
 782  *  \return The communication or NULL if empty
 783  */
 784 smx_action_t simcall_rdv_get_head(smx_rdv_t rdv)
 785 {
 786   smx_simcall_t simcall = SIMIX_simcall_mine();
 787
 788   simcall->call = SIMCALL_RDV_GET_HEAD;
 789   simcall->rdv_get_head.rdv = rdv;
 790
 791   SIMIX_simcall_push(simcall->issuer);
 792   return simcall->rdv_get_head.result;
 793 }
 794 /**
 795  * \ingroup simix_comm_management
 796  */
 797 void simcall_comm_send(smx_rdv_t rdv, double task_size, double rate,
 798                          void *src_buff, size_t src_buff_size,
 799                          int (*match_fun)(void *, void *, smx_action_t), void *data,
 800                          double timeout)
 801 {
 802   /* checking for infinite values */
 803   xbt_assert(isfinite(task_size), "task_size is not finite!");
 804   xbt_assert(isfinite(rate), "rate is not finite!");
 805   xbt_assert(isfinite(timeout), "timeout is not finite!");
 806
 807   xbt_assert(rdv, "No rendez-vous point defined for send");
 808
 809   if (MC_IS_ENABLED) {
 810     /* the model-checker wants two separate simcalls */
 811     smx_action_t comm = simcall_comm_isend(rdv, task_size, rate,
 812         src_buff, src_buff_size, match_fun, NULL, data, 0);
 813     simcall_comm_wait(comm, timeout);
 814   }
 815   else {
 816     smx_simcall_t simcall = SIMIX_simcall_mine();
 817
 818     simcall->call = SIMCALL_COMM_SEND;
 819     simcall->comm_send.rdv = rdv;
 820     simcall->comm_send.task_size = task_size;
 821     simcall->comm_send.rate = rate;
 822     simcall->comm_send.src_buff = src_buff;
 823     simcall->comm_send.src_buff_size = src_buff_size;
 824     simcall->comm_send.match_fun = match_fun;
 825     simcall->comm_send.data = data;
 826     simcall->comm_send.timeout = timeout;
 827
 828     SIMIX_simcall_push(simcall->issuer);
 829   }
 830 }
 831 /**
 832  * \ingroup simix_comm_management
 833  */
 834 smx_action_t simcall_comm_isend(smx_rdv_t rdv, double task_size, double rate,
 835                               void *src_buff, size_t src_buff_size,
 836                               int (*match_fun)(void *, void *, smx_action_t),
 837                               void (*clean_fun)(void *),
 838                               void *data,
 839                               int detached)
 840 {
 841   /* checking for infinite values */
 842   xbt_assert(isfinite(task_size), "task_size is not finite!");
 843   xbt_assert(isfinite(rate), "rate is not finite!");
 844
 845   xbt_assert(rdv, "No rendez-vous point defined for isend");
 846
 847   smx_simcall_t simcall = SIMIX_simcall_mine();
 848
 849   simcall->call = SIMCALL_COMM_ISEND;
 850   simcall->comm_isend.rdv = rdv;
 851   simcall->comm_isend.task_size = task_size;
 852   simcall->comm_isend.rate = rate;
 853   simcall->comm_isend.src_buff = src_buff;
 854   simcall->comm_isend.src_buff_size = src_buff_size;
 855   simcall->comm_isend.match_fun = match_fun;
 856   simcall->comm_isend.clean_fun = clean_fun;
 857   simcall->comm_isend.data = data;
 858   simcall->comm_isend.detached = detached;
 859
 860   SIMIX_simcall_push(simcall->issuer);
 861   return simcall->comm_isend.result;
 862 }
 863 /**
 864  * \ingroup simix_comm_management
 865  */
 866 void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
 867                          int (*match_fun)(void *, void *, smx_action_t), void *data, double timeout)
 868 {
 869   xbt_assert(isfinite(timeout), "timeout is not finite!");
 870   xbt_assert(rdv, "No rendez-vous point defined for recv");
 871
 872   if (MC_IS_ENABLED) {
 873     /* the model-checker wants two separate simcalls */
 874     smx_action_t comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size,
 875         match_fun, data);
 876     simcall_comm_wait(comm, timeout);
 877   }
 878   else {
 879     smx_simcall_t simcall = SIMIX_simcall_mine();
 880
 881     simcall->call = SIMCALL_COMM_RECV;
 882     simcall->comm_recv.rdv = rdv;
 883     simcall->comm_recv.dst_buff = dst_buff;
 884     simcall->comm_recv.dst_buff_size = dst_buff_size;
 885     simcall->comm_recv.match_fun = match_fun;
 886     simcall->comm_recv.data = data;
 887     simcall->comm_recv.timeout = timeout;
 888
 889     SIMIX_simcall_push(simcall->issuer);
 890   }
 891 }
 892 /**
 893  * \ingroup simix_comm_management
 894  */
 895 smx_action_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
 896                                   int (*match_fun)(void *, void *, smx_action_t), void *data)
 897 {
 898   xbt_assert(rdv, "No rendez-vous point defined for irecv");
 899
 900   smx_simcall_t simcall = SIMIX_simcall_mine();
 901
 902   simcall->call = SIMCALL_COMM_IRECV;
 903   simcall->comm_irecv.rdv = rdv;
 904   simcall->comm_irecv.dst_buff = dst_buff;
 905   simcall->comm_irecv.dst_buff_size = dst_buff_size;
 906   simcall->comm_irecv.match_fun = match_fun;
 907   simcall->comm_irecv.data = data;
 908
 909   SIMIX_simcall_push(simcall->issuer);
 910   return simcall->comm_irecv.result;
 911 }
 912 void simcall_comm_destroy(smx_action_t comm)
 913 {
 914   xbt_assert(comm, "Invalid parameter");
 915
 916   /* FIXME remove this simcall type: comms are auto-destroyed now */
 917
 918   /*
 919   smx_simcall_t simcall = simcall_mine();
 920
 921   simcall->call = SIMCALL_COMM_DESTROY;
 922   simcall->comm_destroy.comm = comm;
 923
 924   SIMIX_simcall_push(simcall->issuer);
 925   */
 926 }
 927 /**
 928  * \ingroup simix_comm_management
 929  */
 930 void simcall_comm_cancel(smx_action_t comm)
 931 {
 932   smx_simcall_t simcall = SIMIX_simcall_mine();
 933
 934   simcall->call = SIMCALL_COMM_CANCEL;
 935   simcall->comm_cancel.comm = comm;
 936
 937   SIMIX_simcall_push(simcall->issuer);
 938 }
 939 /**
 940  * \ingroup simix_comm_management
 941  */
 942 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
 943 {
 944   smx_simcall_t simcall = SIMIX_simcall_mine();
 945
 946   simcall->call = SIMCALL_COMM_WAITANY;
 947   simcall->comm_waitany.comms = comms;
 948
 949   SIMIX_simcall_push(simcall->issuer);
 950   return simcall->comm_waitany.result;
 951 }
 952 /**
 953  * \ingroup simix_comm_management
 954  */
 955 int simcall_comm_testany(xbt_dynar_t comms)
 956 {
 957   smx_simcall_t simcall = SIMIX_simcall_mine();
 958   if (xbt_dynar_is_empty(comms))
 959     return -1;
 960
 961   simcall->call = SIMCALL_COMM_TESTANY;
 962   simcall->comm_testany.comms = comms;
 963
 964   SIMIX_simcall_push(simcall->issuer);
 965   return simcall->comm_testany.result;
 966 }
 967 /**
 968  * \ingroup simix_comm_management
 969  */
 970 void simcall_comm_wait(smx_action_t comm, double timeout)
 971 {
 972   xbt_assert(isfinite(timeout), "timeout is not finite!");
 973
 974   smx_simcall_t simcall = SIMIX_simcall_mine();
 975
 976   simcall->call = SIMCALL_COMM_WAIT;
 977   simcall->comm_wait.comm = comm;
 978   simcall->comm_wait.timeout = timeout;
 979
 980   SIMIX_simcall_push(simcall->issuer);
 981 }
 982
 983 #ifdef HAVE_TRACING
 984 /**
 985  * \brief Set the category of an action.
 986  *
 987  * This functions changes the category only. It calls a surf function.
 988  * \param execution The execution action
 989  * \param category The tracing category
 990  */
 991 void simcall_set_category(smx_action_t action, const char *category)
 992 {
 993   if (category == NULL) {
 994     return;
 995   }
 996
 997   smx_simcall_t simcall = SIMIX_simcall_mine();
 998
 999   simcall->call = SIMCALL_SET_CATEGORY;
1000   simcall->set_category.action = action;
1001   simcall->set_category.category = category;
1002
1003   SIMIX_simcall_push(simcall->issuer);
1004 }
1005 #endif
1006 /**
1007  * \ingroup simix_comm_management
1008  *
1009  */
1010 int simcall_comm_test(smx_action_t comm)
1011 {
1012   smx_simcall_t simcall = SIMIX_simcall_mine();
1013
1014   simcall->call = SIMCALL_COMM_TEST;
1015   simcall->comm_test.comm = comm;
1016
1017   SIMIX_simcall_push(simcall->issuer);
1018   return simcall->comm_test.result;
1019 }
1020 /**
1021  * \ingroup simix_comm_management
1022  *
1023  */
1024 double simcall_comm_get_remains(smx_action_t comm)
1025 {
1026   smx_simcall_t simcall = SIMIX_simcall_mine();
1027
1028   simcall->call = SIMCALL_COMM_GET_REMAINS;
1029   simcall->comm_get_remains.comm = comm;
1030
1031   SIMIX_simcall_push(simcall->issuer);
1032   return simcall->comm_get_remains.result;
1033 }
1034 /**
1035  * \ingroup simix_comm_management
1036  *
1037  */
1038 e_smx_state_t simcall_comm_get_state(smx_action_t comm)
1039 {
1040   smx_simcall_t simcall = SIMIX_simcall_mine();
1041
1042   simcall->call = SIMCALL_COMM_GET_STATE;
1043   simcall->comm_get_state.comm = comm;
1044
1045   SIMIX_simcall_push(simcall->issuer);
1046   return simcall->comm_get_state.result;
1047 }
1048 /**
1049  * \ingroup simix_comm_management
1050  *
1051  */
1052 void *simcall_comm_get_src_data(smx_action_t comm)
1053 {
1054   smx_simcall_t simcall = SIMIX_simcall_mine();
1055
1056   simcall->call = SIMCALL_COMM_GET_SRC_DATA;
1057   simcall->comm_get_src_data.comm = comm;
1058
1059   SIMIX_simcall_push(simcall->issuer);
1060   return simcall->comm_get_src_data.result;
1061 }
1062 /**
1063  * \ingroup simix_comm_management
1064  *
1065  */
1066 void *simcall_comm_get_dst_data(smx_action_t comm)
1067 {
1068   smx_simcall_t simcall = SIMIX_simcall_mine();
1069
1070   simcall->call = SIMCALL_COMM_GET_DST_DATA;
1071   simcall->comm_get_dst_data.comm = comm;
1072
1073   SIMIX_simcall_push(simcall->issuer);
1074   return simcall->comm_get_dst_data.result;
1075 }
1076 /**
1077  * \ingroup simix_comm_management
1078  *
1079  */
1080 smx_process_t simcall_comm_get_src_proc(smx_action_t comm)
1081 {
1082   smx_simcall_t simcall = SIMIX_simcall_mine();
1083
1084   simcall->call = SIMCALL_COMM_GET_SRC_PROC;
1085   simcall->comm_get_src_proc.comm = comm;
1086
1087   SIMIX_simcall_push(simcall->issuer);
1088   return simcall->comm_get_src_proc.result;
1089 }
1090 /**
1091  * \ingroup simix_comm_management
1092  *
1093  */
1094 smx_process_t simcall_comm_get_dst_proc(smx_action_t comm)
1095 {
1096   smx_simcall_t simcall = SIMIX_simcall_mine();
1097
1098   simcall->call = SIMCALL_COMM_GET_DST_PROC;
1099   simcall->comm_get_dst_proc.comm = comm;
1100
1101   SIMIX_simcall_push(simcall->issuer);
1102   return simcall->comm_get_dst_proc.result;
1103 }
1104
1105 #ifdef HAVE_LATENCY_BOUND_TRACKING
1106 int simcall_comm_is_latency_bounded(smx_action_t comm)
1107 {
1108   smx_simcall_t simcall = SIMIX_simcall_mine();
1109
1110   simcall->call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
1111   simcall->comm_is_latency_bounded.comm = comm;
1112
1113   SIMIX_simcall_push(simcall->issuer);
1114   return simcall->comm_is_latency_bounded.result;
1115 }
1116 #endif
1117 /**
1118  * \ingroup simix_synchro_management
1119  *
1120  */
1121 smx_mutex_t simcall_mutex_init(void)
1122 {
1123   if(!simix_global) {
1124     fprintf(stderr,"You must run MSG_init or gras_init before using MSG or GRAS\n"); // I would have loved using xbt_die but I can't since it is not initialized yet... :)
1125     abort();
1126   }
1127   smx_simcall_t simcall = SIMIX_simcall_mine();
1128
1129   simcall->call = SIMCALL_MUTEX_INIT;
1130
1131   SIMIX_simcall_push(simcall->issuer);
1132   return simcall->mutex_init.result;
1133 }
1134 /**
1135  * \ingroup simix_synchro_management
1136  *
1137  */
1138 void simcall_mutex_destroy(smx_mutex_t mutex)
1139 {
1140   smx_simcall_t simcall = SIMIX_simcall_mine();
1141
1142   simcall->call = SIMCALL_MUTEX_DESTROY;
1143   simcall->mutex_destroy.mutex = mutex;
1144
1145   SIMIX_simcall_push(simcall->issuer);
1146 }
1147 /**
1148  * \ingroup simix_synchro_management
1149  *
1150  */
1151 void simcall_mutex_lock(smx_mutex_t mutex)
1152 {
1153   smx_simcall_t simcall = SIMIX_simcall_mine();
1154
1155   simcall->call = SIMCALL_MUTEX_LOCK;
1156   simcall->mutex_lock.mutex = mutex;
1157
1158   SIMIX_simcall_push(simcall->issuer);
1159 }
1160 /**
1161  * \ingroup simix_synchro_management
1162  *
1163  */
1164 int simcall_mutex_trylock(smx_mutex_t mutex)
1165 {
1166   smx_simcall_t simcall = SIMIX_simcall_mine();
1167
1168   simcall->call = SIMCALL_MUTEX_TRYLOCK;
1169   simcall->mutex_trylock.mutex = mutex;
1170
1171   SIMIX_simcall_push(simcall->issuer);
1172   return simcall->mutex_trylock.result;
1173 }
1174 /**
1175  * \ingroup simix_synchro_management
1176  *
1177  */
1178 void simcall_mutex_unlock(smx_mutex_t mutex)
1179 {
1180   smx_simcall_t simcall = SIMIX_simcall_mine();
1181
1182   simcall->call = SIMCALL_MUTEX_UNLOCK;
1183   simcall->mutex_unlock.mutex = mutex;
1184
1185   SIMIX_simcall_push(simcall->issuer);
1186 }
1187 /**
1188  * \ingroup simix_synchro_management
1189  *
1190  */
1191 smx_cond_t simcall_cond_init(void)
1192 {
1193   smx_simcall_t simcall = SIMIX_simcall_mine();
1194
1195   simcall->call = SIMCALL_COND_INIT;
1196
1197   SIMIX_simcall_push(simcall->issuer);
1198   return simcall->cond_init.result;
1199 }
1200 /**
1201  * \ingroup simix_synchro_management
1202  *
1203  */
1204 void simcall_cond_destroy(smx_cond_t cond)
1205 {
1206   smx_simcall_t simcall = SIMIX_simcall_mine();
1207
1208   simcall->call = SIMCALL_COND_DESTROY;
1209   simcall->cond_destroy.cond = cond;
1210
1211   SIMIX_simcall_push(simcall->issuer);
1212 }
1213 /**
1214  * \ingroup simix_synchro_management
1215  *
1216  */
1217 void simcall_cond_signal(smx_cond_t cond)
1218 {
1219   smx_simcall_t simcall = SIMIX_simcall_mine();
1220
1221   simcall->call = SIMCALL_COND_SIGNAL;
1222   simcall->cond_signal.cond = cond;
1223
1224   SIMIX_simcall_push(simcall->issuer);
1225 }
1226 /**
1227  * \ingroup simix_synchro_management
1228  *
1229  */
1230 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
1231 {
1232   smx_simcall_t simcall = SIMIX_simcall_mine();
1233
1234   simcall->call = SIMCALL_COND_WAIT;
1235   simcall->cond_wait.cond = cond;
1236   simcall->cond_wait.mutex = mutex;
1237
1238   SIMIX_simcall_push(simcall->issuer);
1239 }
1240 /**
1241  * \ingroup simix_synchro_management
1242  *
1243  */
1244 void simcall_cond_wait_timeout(smx_cond_t cond,
1245                                  smx_mutex_t mutex,
1246                                  double timeout)
1247 {
1248   xbt_assert(isfinite(timeout), "timeout is not finite!");
1249
1250   smx_simcall_t simcall = SIMIX_simcall_mine();
1251
1252   simcall->call = SIMCALL_COND_WAIT_TIMEOUT;
1253   simcall->cond_wait_timeout.cond = cond;
1254   simcall->cond_wait_timeout.mutex = mutex;
1255   simcall->cond_wait_timeout.timeout = timeout;
1256
1257   SIMIX_simcall_push(simcall->issuer);
1258 }
1259 /**
1260  * \ingroup simix_synchro_management
1261  *
1262  */
1263 void simcall_cond_broadcast(smx_cond_t cond)
1264 {
1265   smx_simcall_t simcall = SIMIX_simcall_mine();
1266
1267   simcall->call = SIMCALL_COND_BROADCAST;
1268   simcall->cond_broadcast.cond = cond;
1269
1270   SIMIX_simcall_push(simcall->issuer);
1271 }
1272 /**
1273  * \ingroup simix_synchro_management
1274  *
1275  */
1276 smx_sem_t simcall_sem_init(int capacity)
1277 {
1278   smx_simcall_t simcall = SIMIX_simcall_mine();
1279
1280   simcall->call = SIMCALL_SEM_INIT;
1281   simcall->sem_init.capacity = capacity;
1282
1283   SIMIX_simcall_push(simcall->issuer);
1284   return simcall->sem_init.result;
1285 }
1286 /**
1287  * \ingroup simix_synchro_management
1288  *
1289  */
1290 void simcall_sem_destroy(smx_sem_t sem)
1291 {
1292   smx_simcall_t simcall = SIMIX_simcall_mine();
1293
1294   simcall->call = SIMCALL_SEM_DESTROY;
1295   simcall->sem_destroy.sem = sem;
1296
1297   SIMIX_simcall_push(simcall->issuer);
1298 }
1299 /**
1300  * \ingroup simix_synchro_management
1301  *
1302  */
1303 void simcall_sem_release(smx_sem_t sem)
1304 {
1305   smx_simcall_t simcall = SIMIX_simcall_mine();
1306
1307   simcall->call = SIMCALL_SEM_RELEASE;
1308   simcall->sem_release.sem = sem;
1309
1310   SIMIX_simcall_push(simcall->issuer);
1311 }
1312 /**
1313  * \ingroup simix_synchro_management
1314  *
1315  */
1316 int simcall_sem_would_block(smx_sem_t sem)
1317 {
1318   smx_simcall_t simcall = SIMIX_simcall_mine();
1319
1320   simcall->call = SIMCALL_SEM_WOULD_BLOCK;
1321   simcall->sem_would_block.sem = sem;
1322
1323   SIMIX_simcall_push(simcall->issuer);
1324   return simcall->sem_would_block.result;
1325 }
1326 /**
1327  * \ingroup simix_synchro_management
1328  *
1329  */
1330 void simcall_sem_acquire(smx_sem_t sem)
1331 {
1332   smx_simcall_t simcall = SIMIX_simcall_mine();
1333
1334   simcall->call = SIMCALL_SEM_ACQUIRE;
1335   simcall->sem_acquire.sem = sem;
1336
1337   SIMIX_simcall_push(simcall->issuer);
1338 }
1339 /**
1340  * \ingroup simix_synchro_management
1341  *
1342  */
1343 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1344 {
1345   xbt_assert(isfinite(timeout), "timeout is not finite!");
1346
1347   smx_simcall_t simcall = SIMIX_simcall_mine();
1348
1349   simcall->call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1350   simcall->sem_acquire_timeout.sem = sem;
1351   simcall->sem_acquire_timeout.timeout = timeout;
1352
1353   SIMIX_simcall_push(simcall->issuer);
1354 }
1355 /**
1356  * \ingroup simix_synchro_management
1357  *
1358  */
1359 int simcall_sem_get_capacity(smx_sem_t sem)
1360 {
1361   smx_simcall_t simcall = SIMIX_simcall_mine();
1362
1363   simcall->call = SIMCALL_SEM_GET_CAPACITY;
1364   simcall->sem_get_capacity.sem = sem;
1365
1366   SIMIX_simcall_push(simcall->issuer);
1367   return simcall->sem_get_capacity.result;
1368 }
1369 /**
1370  * \ingroup simix_file_management
1371  *
1372  */
1373 double simcall_file_read(void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1374 {
1375   smx_simcall_t simcall = SIMIX_simcall_mine();
1376
1377   simcall->call = SIMCALL_FILE_READ;
1378   simcall->file_read.ptr = ptr;
1379   simcall->file_read.size = size;
1380   simcall->file_read.nmemb = nmemb;
1381   simcall->file_read.stream = stream;
1382   SIMIX_simcall_push(simcall->issuer);
1383
1384   return simcall->file_read.result;
1385 }
1386 /**
1387  * \ingroup simix_file_management
1388  *
1389  */
1390 size_t simcall_file_write(const void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1391 {
1392   smx_simcall_t simcall = SIMIX_simcall_mine();
1393
1394   simcall->call = SIMCALL_FILE_WRITE;
1395   simcall->file_write.ptr = ptr;
1396   simcall->file_write.size = size;
1397   simcall->file_write.nmemb = nmemb;
1398   simcall->file_write.stream = stream;
1399   SIMIX_simcall_push(simcall->issuer);
1400
1401   return simcall->file_write.result;
1402 }
1403 /**
1404  * \ingroup simix_file_management
1405  * \brief
1406  */
1407 smx_file_t simcall_file_open(const char* mount, const char* path, const char* mode)
1408 {
1409   smx_simcall_t simcall = SIMIX_simcall_mine();
1410
1411   simcall->call = SIMCALL_FILE_OPEN;
1412   simcall->file_open.mount = mount;
1413   simcall->file_open.path = path;
1414   simcall->file_open.mode = mode;
1415   SIMIX_simcall_push(simcall->issuer);
1416
1417   return simcall->file_open.result;
1418 }
1419 /**
1420  * \ingroup simix_file_management
1421  *
1422  */
1423 int simcall_file_close(smx_file_t fp)
1424 {
1425   smx_simcall_t simcall = SIMIX_simcall_mine();
1426
1427   simcall->call = SIMCALL_FILE_CLOSE;
1428   simcall->file_close.fp = fp;
1429   SIMIX_simcall_push(simcall->issuer);
1430
1431   return simcall->file_close.result;
1432 }
1433 /**
1434  * \ingroup simix_file_management
1435  *
1436  */
1437 int simcall_file_stat(smx_file_t fd, s_file_stat_t *buf)
1438 {
1439   smx_simcall_t simcall = SIMIX_simcall_mine();
1440   simcall->call = SIMCALL_FILE_STAT;
1441   simcall->file_stat.fd = fd;
1442
1443   SIMIX_simcall_push(simcall->issuer);
1444
1445   *buf = simcall->file_stat.buf;
1446
1447   return simcall->file_stat.result;
1448 }
1449
1450 /* ************************************************************************** */
1451
1452 /** @brief returns a printable string representing a simcall */
1453 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1454   return simcall_names[kind];
1455 }