src/msg/msg_gos.cpp

   1 /* Copyright (c) 2004-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "msg_private.h"
   8 #include "msg_mailbox.h"
   9 #include "mc/mc.h"
  10 #include "xbt/log.h"
  11 #include "xbt/sysdep.h"
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg,
  14                                 "Logging specific to MSG (gos)");
  15
  16 /** \ingroup msg_task_usage
  17  * \brief Executes a task and waits for its termination.
  18  *
  19  * This function is used for describing the behavior of a process. It
  20  * takes only one parameter.
  21  * \param task a #msg_task_t to execute on the location on which the process is running.
  22  * \return #MSG_OK if the task was successfully completed, #MSG_TASK_CANCELED
  23  * or #MSG_HOST_FAILURE otherwise
  24  */
  25 msg_error_t MSG_task_execute(msg_task_t task)
  26 {
  27   /* TODO: add this to other locations */
  28   msg_host_t host = MSG_process_get_host(MSG_process_self());
  29   MSG_host_add_task(host, task);
  30
  31   msg_error_t ret = MSG_parallel_task_execute(task);
  32
  33   MSG_host_del_task(host, task);
  34
  35   return ret;
  36 }
  37
  38 /** \ingroup msg_task_usage
  39  * \brief Executes a parallel task and waits for its termination.
  40  *
  41  * \param task a #msg_task_t to execute on the location on which the process is running.
  42  *
  43  * \return #MSG_OK if the task was successfully completed, #MSG_TASK_CANCELED
  44  * or #MSG_HOST_FAILURE otherwise
  45  */
  46 msg_error_t MSG_parallel_task_execute(msg_task_t task)
  47 {
  48   xbt_ex_t e;
  49   simdata_task_t simdata = task->simdata;
  50   msg_process_t self = SIMIX_process_self();
  51   simdata_process_t p_simdata = (simdata_process_t) SIMIX_process_self_get_data(self);
  52   e_smx_state_t comp_state;
  53   msg_error_t status = MSG_OK;
  54
  55   TRACE_msg_task_execute_start(task);
  56
  57   xbt_assert((!simdata->compute) && (task->simdata->isused == 0),
  58              "This task is executed somewhere else. Go fix your code! %d",
  59              task->simdata->isused!=NULL);
  60
  61   XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
  62
  63   if (simdata->flops_amount == 0 && !simdata->host_nb) {
  64     TRACE_msg_task_execute_end(task);
  65     return MSG_OK;
  66   }
  67
  68
  69   TRY {
  70     if (msg_global->debug_multiple_use)
  71       MSG_BT(simdata->isused, "Using Backtrace");
  72     else
  73       simdata->isused = (void*)1;
  74
  75     if (simdata->host_nb > 0) {
  76       simdata->compute = simcall_execution_parallel_start(task->name,
  77                                                        simdata->host_nb,
  78                                                        simdata->host_list,
  79                                                        simdata->flops_parallel_amount,
  80                                                        simdata->bytes_parallel_amount,
  81                                                        1.0, -1.0);
  82       XBT_DEBUG("Parallel execution action created: %p", simdata->compute);
  83     } else {
  84       unsigned long affinity_mask = (unsigned long)(uintptr_t) xbt_dict_get_or_null_ext(simdata->affinity_mask_db, (char *) p_simdata->m_host, sizeof(msg_host_t));
  85       XBT_DEBUG("execute %s@%s with affinity(0x%04lx)", MSG_task_get_name(task), MSG_host_get_name(p_simdata->m_host), affinity_mask);
  86
  87       simdata->compute = simcall_execution_start(task->name,
  88                                               simdata->flops_amount,
  89                                               simdata->priority,
  90                                               simdata->bound,
  91                                               affinity_mask
  92                                               );
  93
  94     }
  95     simcall_set_category(simdata->compute, task->category);
  96     p_simdata->waiting_action = simdata->compute;
  97     comp_state = simcall_execution_wait(simdata->compute);
  98
  99     p_simdata->waiting_action = NULL;
 100
 101     if (msg_global->debug_multiple_use && simdata->isused!=0)
 102       xbt_ex_free(*(xbt_ex_t*)simdata->isused);
 103     simdata->isused = 0;
 104
 105     XBT_DEBUG("Execution task '%s' finished in state %d",
 106               task->name, (int)comp_state);
 107   }
 108   CATCH(e) {
 109     switch (e.category) {
 110     case cancel_error:
 111       status = MSG_TASK_CANCELED;
 112       break;
 113     case host_error:
 114       status = MSG_HOST_FAILURE;
 115       break;
 116     default:
 117       RETHROW;
 118     }
 119     xbt_ex_free(e);
 120   }
 121   /* action ended, set comm and compute = NULL, the actions is already destroyed
 122    * in the main function */
 123   simdata->flops_amount = 0.0;
 124   simdata->comm = NULL;
 125   simdata->compute = NULL;
 126   TRACE_msg_task_execute_end(task);
 127
 128   MSG_RETURN(status);
 129 }
 130
 131
 132 /** \ingroup msg_task_usage
 133  * \brief Sleep for the specified number of seconds
 134  *
 135  * Makes the current process sleep until \a time seconds have elapsed.
 136  *
 137  * \param nb_sec a number of second
 138  */
 139 msg_error_t MSG_process_sleep(double nb_sec)
 140 {
 141   xbt_ex_t e;
 142   msg_error_t status = MSG_OK;
 143   /*msg_process_t proc = MSG_process_self();*/
 144
 145   TRACE_msg_process_sleep_in(MSG_process_self());
 146
 147   TRY {
 148     simcall_process_sleep(nb_sec);
 149   }
 150   CATCH(e) {
 151     switch (e.category) {
 152     case cancel_error:
 153       XBT_DEBUG("According to the JAVA API, a sleep call should only deal with HostFailureException, WTF here ?");
 154       // adsein: MSG_TASK_CANCELED is assigned when someone kills the process that made the sleep, this is not
 155       // correct. For instance, when the node is turned off, the error should be MSG_HOST_FAILURE, which is by the way
 156       // and according to the JAVA document, the only exception that can be triggered by MSG_Process_sleep call.
 157       // To avoid possible impacts in the code, I just raised a host_failure exception for the moment in the JAVA code
 158       // and did not change anythings at the C level.
 159       // See comment in the jmsg_process.c file, function JNIEXPORT void JNICALL Java_org_simgrid_msg_Process_sleep(JNIEnv *env, jclass cls, jlong jmillis, jint jnanos)
 160       status = MSG_TASK_CANCELED;
 161       break;
 162     default:
 163       RETHROW;
 164     }
 165     xbt_ex_free(e);
 166   }
 167
 168   TRACE_msg_process_sleep_out(MSG_process_self());
 169   MSG_RETURN(status);
 170 }
 171
 172 /** \ingroup msg_task_usage
 173  * \brief Receives a task from a mailbox.
 174  *
 175  * This is a blocking function, the execution flow will be blocked
 176  * until the task is received. See #MSG_task_irecv
 177  * for receiving tasks asynchronously.
 178  *
 179  * \param task a memory location for storing a #msg_task_t.
 180  * \param alias name of the mailbox to receive the task from
 181  *
 182  * \return Returns
 183  * #MSG_OK if the task was successfully received,
 184  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
 185  */
 186 msg_error_t MSG_task_receive(msg_task_t * task, const char *alias)
 187 {
 188   return MSG_task_receive_with_timeout(task, alias, -1);
 189 }
 190
 191 /** \ingroup msg_task_usage
 192  * \brief Receives a task from a mailbox at a given rate.
 193  *
 194  * \param task a memory location for storing a #msg_task_t.
 195  * \param alias name of the mailbox to receive the task from
 196  *  \param rate limit the reception to rate bandwidth
 197  *
 198  * \return Returns
 199  * #MSG_OK if the task was successfully received,
 200  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
 201  */
 202 msg_error_t MSG_task_receive_bounded(msg_task_t * task, const char *alias,
 203                                      double rate)
 204 {
 205   return MSG_task_receive_with_timeout_bounded(task, alias, -1, rate);
 206 }
 207
 208 /** \ingroup msg_task_usage
 209  * \brief Receives a task from a mailbox with a given timeout.
 210  *
 211  * This is a blocking function with a timeout, the execution flow will be blocked
 212  * until the task is received or the timeout is achieved. See #MSG_task_irecv
 213  * for receiving tasks asynchronously.  You can provide a -1 timeout
 214  * to obtain an infinite timeout.
 215  *
 216  * \param task a memory location for storing a #msg_task_t.
 217  * \param alias name of the mailbox to receive the task from
 218  * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_receive)
 219  *
 220  * \return Returns
 221  * #MSG_OK if the task was successfully received,
 222  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 223  */
 224 msg_error_t
 225 MSG_task_receive_with_timeout(msg_task_t * task, const char *alias,
 226                               double timeout)
 227 {
 228   return MSG_task_receive_ext(task, alias, timeout, NULL);
 229 }
 230
 231 /** \ingroup msg_task_usage
 232  * \brief Receives a task from a mailbox with a given timeout and at a given rate.
 233  *
 234  * \param task a memory location for storing a #msg_task_t.
 235  * \param alias name of the mailbox to receive the task from
 236  * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_receive)
 237  *  \param rate limit the reception to rate bandwidth
 238  *
 239  * \return Returns
 240  * #MSG_OK if the task was successfully received,
 241  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 242  */
 243 msg_error_t
 244 MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char *alias,
 245                                       double timeout,double rate)
 246 {
 247   return MSG_task_receive_ext_bounded(task, alias, timeout, NULL, rate);
 248 }
 249
 250 /** \ingroup msg_task_usage
 251  * \brief Receives a task from a mailbox from a specific host with a given timeout.
 252  *
 253  * This is a blocking function with a timeout, the execution flow will be blocked
 254  * until the task is received or the timeout is achieved. See #MSG_task_irecv
 255  * for receiving tasks asynchronously. You can provide a -1 timeout
 256  * to obtain an infinite timeout.
 257  *
 258  * \param task a memory location for storing a #msg_task_t.
 259  * \param alias name of the mailbox to receive the task from
 260  * \param timeout is the maximum wait time for completion (provide -1 for no timeout)
 261  * \param host a #msg_host_t host from where the task was sent
 262  *
 263  * \return Returns
 264  * #MSG_OK if the task was successfully received,
 265 * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 266  */
 267 msg_error_t
 268 MSG_task_receive_ext(msg_task_t * task, const char *alias, double timeout,
 269                      msg_host_t host)
 270 {
 271   xbt_ex_t e;
 272   msg_error_t ret = MSG_OK;
 273   XBT_DEBUG
 274       ("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'",
 275        alias);
 276   TRY {
 277     ret = MSG_mailbox_get_task_ext(MSG_mailbox_get_by_alias(alias), task,
 278                                    host, timeout);
 279   }
 280   CATCH(e) {
 281     switch (e.category) {
 282     case cancel_error:          /* may be thrown by MSG_mailbox_get_by_alias */
 283       ret = MSG_HOST_FAILURE;
 284       break;
 285     default:
 286       RETHROW;
 287     }
 288     xbt_ex_free(e);
 289   }
 290   return ret;
 291 }
 292
 293 /** \ingroup msg_task_usage
 294  * \brief Receives a task from a mailbox from a specific host with a given timeout
 295  *  and at a given rate.
 296  *
 297  * \param task a memory location for storing a #msg_task_t.
 298  * \param alias name of the mailbox to receive the task from
 299  * \param timeout is the maximum wait time for completion (provide -1 for no timeout)
 300  * \param host a #msg_host_t host from where the task was sent
 301  * \param rate limit the reception to rate bandwidth
 302  *
 303  * \return Returns
 304  * #MSG_OK if the task was successfully received,
 305 * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 306  */
 307 msg_error_t
 308 MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, double timeout,
 309                              msg_host_t host, double rate)
 310 {
 311   XBT_DEBUG
 312       ("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'",
 313        alias);
 314   return MSG_mailbox_get_task_ext_bounded(MSG_mailbox_get_by_alias(alias), task,
 315                                           host, timeout, rate);
 316 }
 317
 318 /* Internal function used to factorize code between
 319  * MSG_task_isend_with_matching() and MSG_task_dsend().
 320  */
 321 static XBT_INLINE
 322 msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *alias,
 323                                    int (*match_fun)(void*,void*, smx_synchro_t),
 324                                    void *match_data, void_f_pvoid_t cleanup,
 325                                    int detached)
 326 {
 327   simdata_task_t t_simdata = NULL;
 328   msg_process_t process = MSG_process_self();
 329   msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
 330   int call_end = TRACE_msg_task_put_start(task);
 331
 332   /* Prepare the task to send */
 333   t_simdata = task->simdata;
 334   t_simdata->sender = process;
 335   t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;
 336
 337   if (t_simdata->isused != 0) {
 338     if (msg_global->debug_multiple_use){
 339       XBT_ERROR("This task is already used in there:");
 340       xbt_backtrace_display((xbt_ex_t*) t_simdata->isused);
 341       XBT_ERROR("And you try to reuse it from here:");
 342       xbt_backtrace_display_current();
 343     } else {
 344       xbt_assert(t_simdata->isused == 0,
 345                  "This task is still being used somewhere else. You cannot send it now. Go fix your code! (use --cfg=msg/debug_multiple_use:on to get the backtrace of the other process)");
 346     }
 347   }
 348
 349   if (msg_global->debug_multiple_use)
 350     MSG_BT(t_simdata->isused, "Using Backtrace");
 351   else
 352     t_simdata->isused = (void*)1;
 353   t_simdata->comm = NULL;
 354   msg_global->sent_msg++;
 355
 356   /* Send it by calling SIMIX network layer */
 357   smx_synchro_t act = simcall_comm_isend(SIMIX_process_self(), mailbox, t_simdata->bytes_amount,
 358                                         t_simdata->rate, task, sizeof(void *),
 359                                         match_fun, cleanup, NULL, match_data,detached);
 360   t_simdata->comm = act; /* FIXME: is the field t_simdata->comm still useful? */
 361
 362   msg_comm_t comm;
 363   if (detached) {
 364     comm = NULL;
 365   } else {
 366     comm = xbt_new0(s_msg_comm_t, 1);
 367     comm->task_sent = task;
 368     comm->task_received = NULL;
 369     comm->status = MSG_OK;
 370     comm->s_comm = act;
 371   }
 372
 373   if (TRACE_is_enabled())
 374     simcall_set_category(act, task->category);
 375   if (call_end)
 376     TRACE_msg_task_put_end();
 377
 378   return comm;
 379 }
 380
 381
 382 /** \ingroup msg_task_usage
 383  * \brief Sends a task on a mailbox.
 384  *
 385  * This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
 386  * to end the communication.
 387  *
 388  * \param task a #msg_task_t to send on another location.
 389  * \param alias name of the mailbox to sent the task to
 390  * \return the msg_comm_t communication created
 391  */
 392 msg_comm_t MSG_task_isend(msg_task_t task, const char *alias)
 393 {
 394   return MSG_task_isend_internal(task, alias, NULL, NULL, NULL, 0);
 395 }
 396
 397 /** \ingroup msg_task_usage
 398  * \brief Sends a task on a mailbox with a maximum rate
 399  *
 400  * This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
 401  * to end the communication. The maxrate parameter allows the application
 402  * to limit the bandwidth utilization of network links when sending the task.
 403  *
 404  * \param task a #msg_task_t to send on another location.
 405  * \param alias name of the mailbox to sent the task to
 406  * \param maxrate the maximum communication rate for sending this task .
 407  * \return the msg_comm_t communication created
 408  */
 409 msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias,
 410                                   double maxrate)
 411 {
 412   task->simdata->rate = maxrate;
 413   return MSG_task_isend_internal(task, alias, NULL, NULL, NULL, 0);
 414 }
 415
 416
 417 /** \ingroup msg_task_usage
 418  * \brief Sends a task on a mailbox, with support for matching requests
 419  *
 420  * This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
 421  * to end the communication.
 422  *
 423  * \param task a #msg_task_t to send on another location.
 424  * \param alias name of the mailbox to sent the task to
 425  * \param match_fun boolean function which parameters are:
 426  *        - match_data_provided_here
 427  *        - match_data_provided_by_other_side_if_any
 428  *        - the_smx_synchro_describing_the_other_side
 429  * \param match_data user provided data passed to match_fun
 430  * \return the msg_comm_t communication created
 431  */
 432 msg_comm_t MSG_task_isend_with_matching(msg_task_t task, const char *alias,
 433                                         int (*match_fun)(void*, void*,
 434                                                          smx_synchro_t),
 435                                         void *match_data)
 436 {
 437   return MSG_task_isend_internal(task, alias, match_fun, match_data, NULL, 0);
 438 }
 439
 440 /** \ingroup msg_task_usage
 441  * \brief Sends a task on a mailbox.
 442  *
 443  * This is a non blocking detached send function.
 444  * Think of it as a best effort send. Keep in mind that the third parameter
 445  * is only called if the communication fails. If the communication does work,
 446  * it is responsibility of the receiver code to free anything related to
 447  * the task, as usual. More details on this can be obtained on
 448  * <a href="http://lists.gforge.inria.fr/pipermail/simgrid-user/2011-November/002649.html">this thread</a>
 449  * in the SimGrid-user mailing list archive.
 450  *
 451  * \param task a #msg_task_t to send on another location.
 452  * \param alias name of the mailbox to sent the task to
 453  * \param cleanup a function to destroy the task if the
 454  * communication fails, e.g. MSG_task_destroy
 455  * (if NULL, no function will be called)
 456  */
 457 void MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup)
 458 {
 459   MSG_task_isend_internal(task, alias, NULL, NULL, cleanup, 1);
 460 }
 461
 462 /** \ingroup msg_task_usage
 463  * \brief Sends a task on a mailbox with a maximal rate.
 464  *
 465  * This is a non blocking detached send function.
 466  * Think of it as a best effort send. Keep in mind that the third parameter
 467  * is only called if the communication fails. If the communication does work,
 468  * it is responsibility of the receiver code to free anything related to
 469  * the task, as usual. More details on this can be obtained on
 470  * <a href="http://lists.gforge.inria.fr/pipermail/simgrid-user/2011-November/002649.html">this thread</a>
 471  * in the SimGrid-user mailing list archive.
 472  *
 473  * \param task a #msg_task_t to send on another location.
 474  * \param alias name of the mailbox to sent the task to
 475  * \param cleanup a function to destroy the task if the
 476  * communication fails, e.g. MSG_task_destroy
 477  * (if NULL, no function will be called)
 478  * \param maxrate the maximum communication rate for sending this task
 479  *
 480  */
 481 void MSG_task_dsend_bounded(msg_task_t task, const char *alias,
 482                             void_f_pvoid_t cleanup, double maxrate)
 483 {
 484   task->simdata->rate = maxrate;
 485   MSG_task_dsend(task, alias, cleanup);
 486 }
 487
 488 /** \ingroup msg_task_usage
 489  * \brief Starts listening for receiving a task from an asynchronous communication.
 490  *
 491  * This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
 492  * to end the communication.
 493  *
 494  * \param task a memory location for storing a #msg_task_t. has to be valid until the end of the communication.
 495  * \param name of the mailbox to receive the task on
 496  * \return the msg_comm_t communication created
 497  */
 498 msg_comm_t MSG_task_irecv(msg_task_t *task, const char *name)
 499 {
 500   return MSG_task_irecv_bounded(task, name, -1.0);
 501 }
 502
 503 /** \ingroup msg_task_usage
 504  * \brief Starts listening for receiving a task from an asynchronous communication
 505  * at a given rate.
 506  *
 507  * \param task a memory location for storing a #msg_task_t. has to be valid until the end of the communication.
 508  * \param name of the mailbox to receive the task on
 509  * \param rate limit the bandwidth to the given rate
 510  * \return the msg_comm_t communication created
 511  */
 512 msg_comm_t MSG_task_irecv_bounded(msg_task_t *task, const char *name,
 513                                   double rate)
 514 {
 515   smx_rdv_t rdv = MSG_mailbox_get_by_alias(name);
 516
 517   /* FIXME: these functions are not traceable */
 518
 519   /* Sanity check */
 520   xbt_assert(task, "Null pointer for the task storage");
 521
 522   if (*task)
 523     XBT_CRITICAL
 524         ("MSG_task_irecv() was asked to write in a non empty task struct.");
 525
 526   /* Try to receive it by calling SIMIX network layer */
 527   msg_comm_t comm = xbt_new0(s_msg_comm_t, 1);
 528   comm->task_sent = NULL;
 529   comm->task_received = task;
 530   comm->status = MSG_OK;
 531   comm->s_comm = simcall_comm_irecv(MSG_process_self(), rdv, task, NULL, NULL, NULL, NULL, rate);
 532
 533   return comm;
 534 }
 535
 536 /** \ingroup msg_task_usage
 537  * \brief Checks whether a communication is done, and if yes, finalizes it.
 538  * \param comm the communication to test
 539  * \return TRUE if the communication is finished
 540  * (but it may have failed, use MSG_comm_get_status() to know its status)
 541  * or FALSE if the communication is not finished yet
 542  * If the status is FALSE, don't forget to use MSG_process_sleep() after the test.
 543  */
 544 int MSG_comm_test(msg_comm_t comm)
 545 {
 546   xbt_ex_t e;
 547   int finished = 0;
 548
 549   TRY {
 550     finished = simcall_comm_test(comm->s_comm);
 551
 552     if (finished && comm->task_received != NULL) {
 553       /* I am the receiver */
 554       if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0)
 555         xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused);
 556       (*comm->task_received)->simdata->isused = 0;
 557     }
 558   }
 559   CATCH(e) {
 560     switch (e.category) {
 561       case network_error:
 562         comm->status = MSG_TRANSFER_FAILURE;
 563         finished = 1;
 564         break;
 565
 566       case timeout_error:
 567         comm->status = MSG_TIMEOUT;
 568         finished = 1;
 569         break;
 570
 571       default:
 572         RETHROW;
 573     }
 574     xbt_ex_free(e);
 575   }
 576
 577   return finished;
 578 }
 579
 580 /** \ingroup msg_task_usage
 581  * \brief This function checks if a communication is finished.
 582  * \param comms a vector of communications
 583  * \return the position of the finished communication if any
 584  * (but it may have failed, use MSG_comm_get_status() to know its status),
 585  * or -1 if none is finished
 586  */
 587 int MSG_comm_testany(xbt_dynar_t comms)
 588 {
 589   xbt_ex_t e;
 590   int finished_index = -1;
 591
 592   /* create the equivalent dynar with SIMIX objects */
 593   xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), NULL);
 594   msg_comm_t comm;
 595   unsigned int cursor;
 596   xbt_dynar_foreach(comms, cursor, comm) {
 597     xbt_dynar_push(s_comms, &comm->s_comm);
 598   }
 599
 600   msg_error_t status = MSG_OK;
 601   TRY {
 602     finished_index = simcall_comm_testany(s_comms);
 603   }
 604   CATCH(e) {
 605     switch (e.category) {
 606       case network_error:
 607         finished_index = e.value;
 608         status = MSG_TRANSFER_FAILURE;
 609         break;
 610
 611       case timeout_error:
 612         finished_index = e.value;
 613         status = MSG_TIMEOUT;
 614         break;
 615
 616       default:
 617         RETHROW;
 618     }
 619     xbt_ex_free(e);
 620   }
 621   xbt_dynar_free(&s_comms);
 622
 623   if (finished_index != -1) {
 624     comm = xbt_dynar_get_as(comms, finished_index, msg_comm_t);
 625     /* the communication is finished */
 626     comm->status = status;
 627
 628     if (status == MSG_OK && comm->task_received != NULL) {
 629       /* I am the receiver */
 630       if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0)
 631         xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused);
 632       (*comm->task_received)->simdata->isused = 0;
 633     }
 634   }
 635
 636   return finished_index;
 637 }
 638
 639 /** \ingroup msg_task_usage
 640  * \brief Destroys a communication.
 641  * \param comm the communication to destroy.
 642  */
 643 void MSG_comm_destroy(msg_comm_t comm)
 644 {
 645   xbt_free(comm);
 646 }
 647
 648 /** \ingroup msg_task_usage
 649  * \brief Wait for the completion of a communication.
 650  *
 651  * It takes two parameters.
 652  * \param comm the communication to wait.
 653  * \param timeout Wait until the communication terminates or the timeout
 654  * occurs. You can provide a -1 timeout to obtain an infinite timeout.
 655  * \return msg_error_t
 656  */
 657 msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
 658 {
 659   xbt_ex_t e;
 660   TRY {
 661     simcall_comm_wait(comm->s_comm, timeout);
 662
 663     if (comm->task_received != NULL) {
 664       /* I am the receiver */
 665       if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0)
 666         xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused);
 667       (*comm->task_received)->simdata->isused = 0;
 668     }
 669
 670     /* FIXME: these functions are not traceable */
 671   }
 672   CATCH(e) {
 673     switch (e.category) {
 674     case network_error:
 675       comm->status = MSG_TRANSFER_FAILURE;
 676       break;
 677     case timeout_error:
 678       comm->status = MSG_TIMEOUT;
 679       break;
 680     default:
 681       RETHROW;
 682     }
 683     xbt_ex_free(e);
 684   }
 685
 686   return comm->status;
 687 }
 688
 689 /** \ingroup msg_task_usage
 690 * \brief This function is called by a sender and permit to wait for each communication
 691 *
 692 * \param comm a vector of communication
 693 * \param nb_elem is the size of the comm vector
 694 * \param timeout for each call of MSG_comm_wait
 695 */
 696 void MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout)
 697 {
 698   int i = 0;
 699   for (i = 0; i < nb_elem; i++) {
 700     MSG_comm_wait(comm[i], timeout);
 701   }
 702 }
 703
 704 /** \ingroup msg_task_usage
 705  * \brief This function waits for the first communication finished in a list.
 706  * \param comms a vector of communications
 707  * \return the position of the first finished communication
 708  * (but it may have failed, use MSG_comm_get_status() to know its status)
 709  */
 710 int MSG_comm_waitany(xbt_dynar_t comms)
 711 {
 712   xbt_ex_t e;
 713   int finished_index = -1;
 714
 715   /* create the equivalent dynar with SIMIX objects */
 716   xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), NULL);
 717   msg_comm_t comm;
 718   unsigned int cursor;
 719   xbt_dynar_foreach(comms, cursor, comm) {
 720     xbt_dynar_push(s_comms, &comm->s_comm);
 721   }
 722
 723   msg_error_t status = MSG_OK;
 724   TRY {
 725     finished_index = simcall_comm_waitany(s_comms);
 726   }
 727   CATCH(e) {
 728     switch (e.category) {
 729       case network_error:
 730         finished_index = e.value;
 731         status = MSG_TRANSFER_FAILURE;
 732         break;
 733
 734       case timeout_error:
 735         finished_index = e.value;
 736         status = MSG_TIMEOUT;
 737         break;
 738
 739       default:
 740         RETHROW;
 741     }
 742     xbt_ex_free(e);
 743   }
 744
 745   xbt_assert(finished_index != -1, "WaitAny returned -1");
 746   xbt_dynar_free(&s_comms);
 747
 748   comm = xbt_dynar_get_as(comms, finished_index, msg_comm_t);
 749   /* the communication is finished */
 750   comm->status = status;
 751
 752   if (comm->task_received != NULL) {
 753     /* I am the receiver */
 754     if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0)
 755       xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused);
 756     (*comm->task_received)->simdata->isused = 0;
 757   }
 758
 759   return finished_index;
 760 }
 761
 762 /**
 763  * \ingroup msg_task_usage
 764  * \brief Returns the error (if any) that occured during a finished communication.
 765  * \param comm a finished communication
 766  * \return the status of the communication, or #MSG_OK if no error occured
 767  * during the communication
 768  */
 769 msg_error_t MSG_comm_get_status(msg_comm_t comm) {
 770
 771   return comm->status;
 772 }
 773
 774 /** \ingroup msg_task_usage
 775  * \brief Get a task (#msg_task_t) from a communication
 776  *
 777  * \param comm the communication where to get the task
 778  * \return the task from the communication
 779  */
 780 msg_task_t MSG_comm_get_task(msg_comm_t comm)
 781 {
 782   xbt_assert(comm, "Invalid parameter");
 783
 784   return comm->task_received ? *comm->task_received : comm->task_sent;
 785 }
 786
 787 /**
 788  * \brief This function is called by SIMIX in kernel mode to copy the data of a comm.
 789  * \param comm the comm
 790  * \param buff the data copied
 791  * \param buff_size size of the buffer
 792  */
 793 void MSG_comm_copy_data_from_SIMIX(smx_synchro_t comm, void* buff, size_t buff_size) {
 794
 795   // copy the task
 796   SIMIX_comm_copy_pointer_callback(comm, buff, buff_size);
 797
 798   // notify the user callback if any
 799   if (msg_global->task_copy_callback) {
 800     msg_task_t task = (msg_task_t) buff;
 801     msg_global->task_copy_callback(task,
 802         simcall_comm_get_src_proc(comm), simcall_comm_get_dst_proc(comm));
 803   }
 804 }
 805
 806 /** \ingroup msg_task_usage
 807  * \brief Sends a task to a mailbox
 808  *
 809  * This is a blocking function, the execution flow will be blocked
 810  * until the task is sent (and received in the other side if #MSG_task_receive is used).
 811  * See #MSG_task_isend for sending tasks asynchronously.
 812  *
 813  * \param task the task to be sent
 814  * \param alias the mailbox name to where the task is sent
 815  *
 816  * \return Returns #MSG_OK if the task was successfully sent,
 817  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
 818  */
 819 msg_error_t MSG_task_send(msg_task_t task, const char *alias)
 820 {
 821   XBT_DEBUG("MSG_task_send: Trying to send a message on mailbox '%s'", alias);
 822   return MSG_task_send_with_timeout(task, alias, -1);
 823 }
 824
 825 /** \ingroup msg_task_usage
 826  * \brief Sends a task to a mailbox with a maximum rate
 827  *
 828  * This is a blocking function, the execution flow will be blocked
 829  * until the task is sent. The maxrate parameter allows the application
 830  * to limit the bandwidth utilization of network links when sending the task.
 831  *
 832  * \param task the task to be sent
 833  * \param alias the mailbox name to where the task is sent
 834  * \param maxrate the maximum communication rate for sending this task
 835  *
 836  * \return Returns #MSG_OK if the task was successfully sent,
 837  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
 838  */
 839 msg_error_t
 840 MSG_task_send_bounded(msg_task_t task, const char *alias, double maxrate)
 841 {
 842   task->simdata->rate = maxrate;
 843   return MSG_task_send(task, alias);
 844 }
 845
 846 /** \ingroup msg_task_usage
 847  * \brief Sends a task to a mailbox with a timeout
 848  *
 849  * This is a blocking function, the execution flow will be blocked
 850  * until the task is sent or the timeout is achieved.
 851  *
 852  * \param task the task to be sent
 853  * \param alias the mailbox name to where the task is sent
 854  * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send)
 855  *
 856  * \return Returns #MSG_OK if the task was successfully sent,
 857  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 858  */
 859 msg_error_t
 860 MSG_task_send_with_timeout(msg_task_t task, const char *alias,
 861                            double timeout)
 862 {
 863   return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
 864                                       task, timeout);
 865 }
 866
 867 /** \ingroup msg_task_usage
 868  * \brief Sends a task to a mailbox with a timeout and with a maximum rate
 869  *
 870  * This is a blocking function, the execution flow will be blocked
 871  * until the task is sent or the timeout is achieved.
 872  *
 873  * \param task the task to be sent
 874  * \param alias the mailbox name to where the task is sent
 875  * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send)
 876  * \param maxrate the maximum communication rate for sending this task
 877  *
 878  * \return Returns #MSG_OK if the task was successfully sent,
 879  * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
 880  */
 881 msg_error_t
 882 MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias,
 883                            double timeout, double maxrate)
 884 {
 885   task->simdata->rate = maxrate;
 886   return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
 887                                       task, timeout);
 888 }
 889
 890 /** \ingroup msg_task_usage
 891  * \brief Check if there is a communication going on in a mailbox.
 892  *
 893  * \param alias the name of the mailbox to be considered
 894  *
 895  * \return Returns 1 if there is a communication, 0 otherwise
 896  */
 897 int MSG_task_listen(const char *alias)
 898 {
 899   return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
 900 }
 901
 902 /** \ingroup msg_task_usage
 903  * \brief Check the number of communication actions of a given host pending in a mailbox.
 904  *
 905  * \param alias the name of the mailbox to be considered
 906  * \param host the host to check for communication
 907  *
 908  * \return Returns the number of pending communication actions of the host in the
 909  * given mailbox, 0 if there is no pending communication actions.
 910  *
 911  */
 912 int MSG_task_listen_from_host(const char *alias, msg_host_t host)
 913 {
 914   return
 915       MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias
 916                                                (alias), host);
 917 }
 918
 919 /** \ingroup msg_task_usage
 920  * \brief Look if there is a communication on a mailbox and return the
 921  * PID of the sender process.
 922  *
 923  * \param alias the name of the mailbox to be considered
 924  *
 925  * \return Returns the PID of sender process,
 926  * -1 if there is no communication in the mailbox.
 927  */
 928 int MSG_task_listen_from(const char *alias)
 929 {
 930   msg_task_t task;
 931
 932   if (NULL ==
 933       (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
 934     return -1;
 935
 936   return MSG_process_get_PID(task->simdata->sender);
 937 }
 938
 939 /** \ingroup msg_task_usage
 940  * \brief Sets the tracing category of a task.
 941  *
 942  * This function should be called after the creation of
 943  * a MSG task, to define the category of that task. The
 944  * first parameter task must contain a task that was
 945  * created with the function #MSG_task_create. The second
 946  * parameter category must contain a category that was
 947  * previously declared with the function #TRACE_category
 948  * (or with #TRACE_category_with_color).
 949  *
 950  * See \ref tracing for details on how to trace
 951  * the (categorized) resource utilization.
 952  *
 953  * \param task the task that is going to be categorized
 954  * \param category the name of the category to be associated to the task
 955  *
 956  * \see MSG_task_get_category, TRACE_category, TRACE_category_with_color
 957  */
 958 void MSG_task_set_category (msg_task_t task, const char *category)
 959 {
 960   TRACE_msg_set_task_category (task, category);
 961 }
 962
 963 /** \ingroup msg_task_usage
 964  *
 965  * \brief Gets the current tracing category of a task.
 966  *
 967  * \param task the task to be considered
 968  *
 969  * \see MSG_task_set_category
 970  *
 971  * \return Returns the name of the tracing category of the given task, NULL otherwise
 972  */
 973 const char *MSG_task_get_category (msg_task_t task)
 974 {
 975   return task->category;
 976 }
 977
 978 /**
 979  * \brief Returns the value of a given AS or router property
 980  *
 981  * \param asr the name of a router or AS
 982  * \param name a property name
 983  * \return value of a property (or NULL if property not set)
 984  */
 985 const char *MSG_as_router_get_property_value(const char* asr, const char *name)
 986 {
 987   return (char*) xbt_dict_get_or_null(
 988     MSG_as_router_get_properties(asr), name);
 989 }
 990
 991 /**
 992  * \brief Returns a xbt_dict_t consisting of the list of properties assigned to
 993  * a the AS or router
 994  *
 995  * \param asr the name of a router or AS
 996  * \return a dict containing the properties
 997  */
 998 xbt_dict_t MSG_as_router_get_properties(const char* asr)
 999 {
1000   return (simcall_asr_get_properties(asr));
1001 }
1002
1003 /**
1004  * \brief Change the value of a given AS or router
1005  *
1006  * \param asr the name of a router or AS
1007  * \param name a property name
1008  * \param value what to change the property to
1009  * \param free_ctn the freeing function to use to kill the value on need
1010  */
1011 void MSG_as_router_set_property_value(const char* asr, const char *name, char *value,void_f_pvoid_t free_ctn) {
1012   xbt_dict_set(MSG_as_router_get_properties(asr), name, value,free_ctn);
1013 }