src/simix/smx_network.c

   1 /* Copyright (c) 2009, 2010. 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 "private.h"
   8 #include "xbt/log.h"
   9 #include "mc/mc.h"
  10 #include "xbt/dict.h"
  11
  12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix,
  13                                 "Logging specific to SIMIX (network)");
  14
  15 static xbt_dict_t rdv_points = NULL;
  16
  17 static XBT_INLINE void SIMIX_comm_start(smx_action_t action);
  18 static void SIMIX_comm_finish(smx_action_t action);
  19 static void SIMIX_waitany_req_remove_from_actions(smx_req_t req);
  20 static void SIMIX_comm_copy_data(smx_action_t comm);
  21 static smx_action_t SIMIX_comm_new(e_smx_comm_type_t type);
  22 static XBT_INLINE void SIMIX_rdv_push(smx_rdv_t rdv, smx_action_t comm);
  23 static XBT_INLINE void SIMIX_rdv_remove(smx_rdv_t rdv, smx_action_t comm);
  24 static smx_action_t SIMIX_rdv_get_request(smx_rdv_t rdv, e_smx_comm_type_t type,
  25                                                                                   int (*match_fun)(void *, void *), void *);
  26 static void SIMIX_rdv_free(void *data);
  27
  28 void SIMIX_network_init(void)
  29 {
  30   rdv_points = xbt_dict_new();
  31 }
  32
  33 void SIMIX_network_exit(void)
  34 {
  35   xbt_dict_free(&rdv_points);
  36 }
  37
  38 /******************************************************************************/
  39 /*                           Rendez-Vous Points                               */
  40 /******************************************************************************/
  41
  42 smx_rdv_t SIMIX_rdv_create(const char *name)
  43 {
  44   /* two processes may have pushed the same rdv_create request at the same time */
  45   smx_rdv_t rdv = name ? xbt_dict_get_or_null(rdv_points, name) : NULL;
  46
  47   if (!rdv) {
  48     rdv = xbt_new0(s_smx_rvpoint_t, 1);
  49     rdv->name = name ? xbt_strdup(name) : NULL;
  50     rdv->comm_fifo = xbt_fifo_new();
  51
  52     if (rdv->name)
  53       xbt_dict_set(rdv_points, rdv->name, rdv, SIMIX_rdv_free);
  54   }
  55   return rdv;
  56 }
  57
  58 void SIMIX_rdv_destroy(smx_rdv_t rdv)
  59 {
  60   if (rdv->name)
  61     xbt_dict_remove(rdv_points, rdv->name);
  62 }
  63
  64 void SIMIX_rdv_free(void *data)
  65 {
  66   smx_rdv_t rdv = (smx_rdv_t) data;
  67   if (rdv->name)
  68     xbt_free(rdv->name);
  69   xbt_fifo_free(rdv->comm_fifo);
  70   xbt_free(rdv);
  71 }
  72
  73 smx_rdv_t SIMIX_rdv_get_by_name(const char *name)
  74 {
  75   return xbt_dict_get_or_null(rdv_points, name);
  76 }
  77
  78 int SIMIX_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
  79 {
  80   smx_action_t comm = NULL;
  81   xbt_fifo_item_t item = NULL;
  82   int count = 0;
  83
  84   xbt_fifo_foreach(rdv->comm_fifo, item, comm, smx_action_t) {
  85     if (comm->comm.src_proc->smx_host == host)
  86       count++;
  87   }
  88
  89   return count;
  90 }
  91
  92 smx_action_t SIMIX_rdv_get_head(smx_rdv_t rdv)
  93 {
  94   return xbt_fifo_get_item_content(xbt_fifo_get_first_item(rdv->comm_fifo));
  95 }
  96
  97 /**
  98  *  \brief Push a communication request into a rendez-vous point
  99  *  \param rdv The rendez-vous point
 100  *  \param comm The communication request
 101  */
 102 static XBT_INLINE void SIMIX_rdv_push(smx_rdv_t rdv, smx_action_t comm)
 103 {
 104   xbt_fifo_push(rdv->comm_fifo, comm);
 105   comm->comm.rdv = rdv;
 106 }
 107
 108 /**
 109  *  \brief Remove a communication request from a rendez-vous point
 110  *  \param rdv The rendez-vous point
 111  *  \param comm The communication request
 112  */
 113 static XBT_INLINE void SIMIX_rdv_remove(smx_rdv_t rdv, smx_action_t comm)
 114 {
 115   xbt_fifo_remove(rdv->comm_fifo, comm);
 116   comm->comm.rdv = NULL;
 117 }
 118
 119 /**
 120  *  \brief Checks if there is a communication action queued in a rendez-vous matching our needs
 121  *  \param type The type of communication we are looking for (comm_send, comm_recv)
 122  *  \return The communication action if found, NULL otherwise
 123  */
 124 smx_action_t SIMIX_rdv_get_request(smx_rdv_t rdv, e_smx_comm_type_t type,
 125                                    int (*match_fun)(void *, void *), void *data)
 126 {
 127   smx_action_t action;
 128   xbt_fifo_item_t item;
 129   void* req_data = NULL;
 130
 131   xbt_fifo_foreach(rdv->comm_fifo, item, action, smx_action_t){
 132     if (action->comm.type == SIMIX_COMM_SEND) {
 133       req_data = action->comm.src_data;
 134     } else if (action->comm.type == SIMIX_COMM_RECEIVE) {
 135       req_data = action->comm.dst_data;
 136     }
 137     if (action->comm.type == type && (!match_fun || match_fun(data, req_data))) {
 138       DEBUG1("Found a matching communication action %p", action);
 139       xbt_fifo_remove_item(rdv->comm_fifo, item);
 140       xbt_fifo_free_item(item);
 141       action->comm.refcount++;
 142       action->comm.rdv = NULL;
 143       return action;
 144     }
 145     DEBUG3("Sorry, communication action %p does not match our needs:"
 146            " its type is %d but we are looking for a comm of type %d",
 147            action, action->comm.type, type);
 148   }
 149   DEBUG0("No matching communication action found");
 150   return NULL;
 151 }
 152
 153 /******************************************************************************/
 154 /*                            Comunication Actions                            */
 155 /******************************************************************************/
 156
 157 /**
 158  *  \brief Creates a new comunicate action
 159  *  \param type The type of request (comm_send, comm_recv)
 160  *  \return The new comunicate action
 161  */
 162 smx_action_t SIMIX_comm_new(e_smx_comm_type_t type)
 163 {
 164   smx_action_t act;
 165
 166   /* alloc structures */
 167   act = xbt_new0(s_smx_action_t, 1);
 168   act->type = SIMIX_ACTION_COMMUNICATE;
 169   act->state = SIMIX_WAITING;
 170   act->request_list = xbt_fifo_new();
 171
 172   /* set communication */
 173   act->comm.type = type;
 174   act->comm.refcount = 1;
 175
 176 #ifdef HAVE_LATENCY_BOUND_TRACKING
 177   //initialize with unknown value
 178   act->latency_limited = -1;
 179 #endif
 180
 181 #ifdef HAVE_TRACING
 182   act->category = NULL;
 183 #endif
 184
 185   DEBUG1("Create communicate action %p", act);
 186
 187   return act;
 188 }
 189
 190 /**
 191  *  \brief Destroy a communicate action
 192  *  \param action The communicate action to be destroyed
 193  */
 194 void SIMIX_comm_destroy(smx_action_t action)
 195 {
 196   DEBUG2("Destroy action %p (refcount:%d)", action, action->comm.refcount);
 197
 198   if (action->comm.refcount <= 0)
 199     xbt_die(bprintf("the refcount of comm %p is already 0 before decreasing it. That's a bug!",action));
 200
 201   action->comm.refcount--;
 202   if (action->comm.refcount > 0)
 203     return;
 204   DEBUG2("Really free communication %p; refcount is now %d", action,
 205         action->comm.refcount);
 206
 207 #ifdef HAVE_LATENCY_BOUND_TRACKING
 208     action->latency_limited = SIMIX_comm_is_latency_bounded( action ) ;
 209 #endif
 210
 211 #ifdef HAVE_TRACING
 212   TRACE_smx_action_destroy(action);
 213 #endif
 214
 215   if (action->name)
 216     xbt_free(action->name);
 217
 218   xbt_fifo_free(action->request_list);
 219
 220   SIMIX_comm_destroy_internal_actions(action);
 221
 222   if (action->comm.detached && action->state != SIMIX_DONE) {
 223     /* the communication has failed and was detached:
 224      * we have to free the buffer */
 225     ((void_f_pvoid_t) action->comm.src_data)(action->comm.src_buff);
 226   }
 227
 228   xbt_free(action);
 229 }
 230
 231 void SIMIX_comm_destroy_internal_actions(smx_action_t action)
 232 {
 233   if (action->comm.surf_comm){
 234 #ifdef HAVE_LATENCY_BOUND_TRACKING
 235     action->latency_limited = SIMIX_comm_is_latency_bounded(action);
 236 #endif
 237     action->comm.surf_comm->model_type->action_unref(action->comm.surf_comm);
 238     action->comm.surf_comm = NULL;
 239   }
 240
 241   if (action->comm.src_timeout){
 242     action->comm.src_timeout->model_type->action_unref(action->comm.src_timeout);
 243     action->comm.src_timeout = NULL;
 244   }
 245
 246   if (action->comm.dst_timeout){
 247     action->comm.dst_timeout->model_type->action_unref(action->comm.dst_timeout);
 248     action->comm.dst_timeout = NULL;
 249   }
 250 }
 251
 252 smx_action_t SIMIX_comm_isend(smx_process_t src_proc, smx_rdv_t rdv,
 253                               double task_size, double rate,
 254                               void *src_buff, size_t src_buff_size,
 255                               int (*match_fun)(void *, void *), void *data,
 256                               int detached)
 257 {
 258   smx_action_t action;
 259
 260   /* Look for communication request matching our needs.
 261      If it is not found then create it and push it into the rendez-vous point */
 262   action = SIMIX_rdv_get_request(rdv, SIMIX_COMM_RECEIVE, match_fun, data);
 263
 264   if (!action) {
 265     action = SIMIX_comm_new(SIMIX_COMM_SEND);
 266     SIMIX_rdv_push(rdv, action);
 267   } else {
 268     action->state = SIMIX_READY;
 269     action->comm.type = SIMIX_COMM_READY;
 270   }
 271
 272   /* If the communication action is detached then decrease the refcount
 273    * by one, so it will be eliminated by the receivers destroy call */
 274   if(detached){
 275     action->comm.detached = 1;
 276     action->comm.refcount--;
 277   }
 278
 279   /* Setup the communication request */
 280   action->comm.src_proc = src_proc;
 281   action->comm.task_size = task_size;
 282   action->comm.rate = rate;
 283   action->comm.src_buff = src_buff;
 284   action->comm.src_buff_size = src_buff_size;
 285   action->comm.src_data = data;
 286
 287   if (MC_IS_ENABLED) {
 288     action->state = SIMIX_RUNNING;
 289     return action;
 290   }
 291
 292   SIMIX_comm_start(action);
 293   return action;
 294 }
 295
 296 smx_action_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
 297                       void *dst_buff, size_t *dst_buff_size,
 298                       int (*match_fun)(void *, void *), void *data)
 299 {
 300   smx_action_t action;
 301
 302   /* Look for communication request matching our needs.
 303    * If it is not found then create it and push it into the rendez-vous point
 304    */
 305   action = SIMIX_rdv_get_request(rdv, SIMIX_COMM_SEND, match_fun, data);
 306
 307   if (!action) {
 308     action = SIMIX_comm_new(SIMIX_COMM_RECEIVE);
 309     SIMIX_rdv_push(rdv, action);
 310   } else {
 311     action->state = SIMIX_READY;
 312     action->comm.type = SIMIX_COMM_READY;
 313   }
 314
 315   /* Setup communication request */
 316   action->comm.dst_proc = dst_proc;
 317   action->comm.dst_buff = dst_buff;
 318   action->comm.dst_buff_size = dst_buff_size;
 319   action->comm.dst_data = data;
 320
 321   if (MC_IS_ENABLED) {
 322     action->state = SIMIX_RUNNING;
 323     return action;
 324   }
 325
 326   SIMIX_comm_start(action);
 327   return action;
 328 }
 329
 330 void SIMIX_pre_comm_wait(smx_req_t req, int idx)
 331 {
 332   smx_action_t action = req->comm_wait.comm;
 333   double timeout = req->comm_wait.timeout;
 334   surf_action_t sleep;
 335
 336   /* Associate this request to the action */
 337   xbt_fifo_push(action->request_list, req);
 338   req->issuer->waiting_action = action;
 339
 340   if (MC_IS_ENABLED){
 341     if(idx == 0){
 342       action->state = SIMIX_DONE;
 343     }else{
 344       /* If we reached this point, the wait request must have a timeout */
 345       /* Otherwise it shouldn't be enabled and executed by the MC */
 346       if(timeout == -1)
 347         THROW_IMPOSSIBLE;
 348
 349       if(action->comm.src_proc == req->issuer)
 350         action->state = SIMIX_SRC_TIMEOUT;
 351       else
 352         action->state = SIMIX_DST_TIMEOUT;
 353     }
 354
 355     SIMIX_comm_finish(action);
 356     return;
 357   }
 358
 359   /* If the action has already finish perform the error handling, */
 360   /* otherwise set up a waiting timeout on the right side         */
 361   if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING) {
 362     SIMIX_comm_finish(action);
 363   } else { /* if (timeout >= 0) { we need a surf sleep action even when there is no timeout, otherwise surf won't tell us when the host fails */
 364     sleep = surf_workstation_model->extension.workstation.sleep(req->issuer->smx_host->host, timeout);
 365     surf_workstation_model->action_data_set(sleep, action);
 366
 367     if (req->issuer == action->comm.src_proc)
 368       action->comm.src_timeout = sleep;
 369     else
 370       action->comm.dst_timeout = sleep;
 371   }
 372 }
 373
 374 void SIMIX_pre_comm_test(smx_req_t req)
 375 {
 376   smx_action_t action = req->comm_test.comm;
 377
 378   if(MC_IS_ENABLED){
 379     req->comm_test.result = action->comm.src_proc && action->comm.dst_proc;
 380     if(req->comm_test.result){
 381       action->state = SIMIX_DONE;
 382       xbt_fifo_push(action->request_list, req);
 383       SIMIX_comm_finish(action);
 384     }else{
 385       SIMIX_request_answer(req);
 386     }
 387     return;
 388   }
 389
 390   req->comm_test.result = (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING);
 391   if (req->comm_test.result) {
 392     xbt_fifo_push(action->request_list, req);
 393     SIMIX_comm_finish(action);
 394   } else {
 395     SIMIX_request_answer(req);
 396   }
 397 }
 398
 399 void SIMIX_pre_comm_testany(smx_req_t req, int idx)
 400 {
 401   unsigned int cursor;
 402   smx_action_t action;
 403   xbt_dynar_t actions = req->comm_testany.comms;
 404   req->comm_testany.result = -1;
 405
 406   if (MC_IS_ENABLED){
 407     if(idx == -1){
 408       SIMIX_request_answer(req);
 409     }else{
 410       action = xbt_dynar_get_as(actions, idx, smx_action_t);
 411       req->comm_testany.result = idx;
 412       xbt_fifo_push(action->request_list, req);
 413       action->state = SIMIX_DONE;
 414       SIMIX_comm_finish(action);
 415     }
 416     return;
 417   }
 418
 419   xbt_dynar_foreach(req->comm_testany.comms,cursor,action) {
 420     if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING) {
 421       req->comm_testany.result = cursor;
 422       xbt_fifo_push(action->request_list, req);
 423       SIMIX_comm_finish(action);
 424       return;
 425     }
 426   }
 427   SIMIX_request_answer(req);
 428 }
 429
 430 void SIMIX_pre_comm_waitany(smx_req_t req, int idx)
 431 {
 432   smx_action_t action;
 433   unsigned int cursor = 0;
 434   xbt_dynar_t actions = req->comm_waitany.comms;
 435
 436   if (MC_IS_ENABLED){
 437     action = xbt_dynar_get_as(actions, idx, smx_action_t);
 438     xbt_fifo_push(action->request_list, req);
 439     req->comm_waitany.result = idx;
 440     action->state = SIMIX_DONE;
 441     SIMIX_comm_finish(action);
 442     return;
 443   }
 444
 445   xbt_dynar_foreach(actions, cursor, action){
 446     /* Associate this request to the action */
 447     xbt_fifo_push(action->request_list, req);
 448     if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING){
 449       SIMIX_comm_finish(action);
 450       break;
 451     }
 452   }
 453 }
 454
 455 void SIMIX_waitany_req_remove_from_actions(smx_req_t req)
 456 {
 457   smx_action_t action;
 458   unsigned int cursor = 0;
 459   xbt_dynar_t actions = req->comm_waitany.comms;
 460
 461   xbt_dynar_foreach(actions, cursor, action){
 462     xbt_fifo_remove(action->request_list, req);
 463   }
 464 }
 465
 466 /**
 467  *  \brief Start the simulation of a communication request
 468  *  \param action The communication action
 469  */
 470 static XBT_INLINE void SIMIX_comm_start(smx_action_t action)
 471 {
 472   /* If both the sender and the receiver are already there, start the communication */
 473   if (action->state == SIMIX_READY) {
 474     smx_host_t sender = action->comm.src_proc->smx_host;
 475     smx_host_t receiver = action->comm.dst_proc->smx_host;
 476
 477     DEBUG3("Starting communication %p from '%s' to '%s'", action,
 478            SIMIX_host_get_name(sender), SIMIX_host_get_name(receiver));
 479
 480     action->comm.surf_comm = surf_workstation_model->extension.workstation.
 481         communicate(sender->host, receiver->host, action->comm.task_size, action->comm.rate);
 482
 483     surf_workstation_model->action_data_set(action->comm.surf_comm, action);
 484
 485     action->state = SIMIX_RUNNING;
 486
 487 #ifdef HAVE_TRACING
 488     TRACE_smx_action_communicate(action, action->comm.src_proc);
 489 #endif
 490
 491     /* If a link is failed, detect it immediately */
 492     if (surf_workstation_model->action_state_get(action->comm.surf_comm) == SURF_ACTION_FAILED) {
 493       DEBUG2("Communication from '%s' to '%s' failed to start because of a link failure",
 494           SIMIX_host_get_name(sender), SIMIX_host_get_name(receiver));
 495       action->state = SIMIX_LINK_FAILURE;
 496       SIMIX_comm_destroy_internal_actions(action);
 497     }
 498
 499     /* If any of the process is suspend, create the action but stop its execution,
 500        it will be restarted when the sender process resume */
 501     if (SIMIX_process_is_suspended(action->comm.src_proc) ||
 502         SIMIX_process_is_suspended(action->comm.dst_proc)) {
 503       /* FIXME: check what should happen with the action state */
 504       surf_workstation_model->suspend(action->comm.surf_comm);
 505     }
 506   }
 507 }
 508
 509 void SIMIX_comm_finish(smx_action_t action)
 510 {
 511   smx_req_t req;
 512
 513   while ((req = xbt_fifo_shift(action->request_list))) {
 514
 515     /* If a waitany request is waiting for this action to finish, then remove
 516        it from the other actions in the waitany list. Afterwards, get the
 517        position of the actual action in the waitany request's actions dynar and
 518        return it as the result of the call */
 519     if (req->call == REQ_COMM_WAITANY) {
 520       SIMIX_waitany_req_remove_from_actions(req);
 521       if(!MC_IS_ENABLED)
 522         req->comm_waitany.result = xbt_dynar_search(req->comm_waitany.comms, &action);
 523     }
 524
 525     /* If the action is still in a rendez-vous point then remove from it */
 526     if (action->comm.rdv)
 527       SIMIX_rdv_remove(action->comm.rdv, action);
 528
 529     DEBUG1("SIMIX_comm_finish: action state = %d", action->state);
 530
 531     /* Check out for errors */
 532     switch (action->state) {
 533
 534       case SIMIX_DONE:
 535         DEBUG1("Communication %p complete!", action);
 536         SIMIX_comm_copy_data(action);
 537         break;
 538
 539       case SIMIX_SRC_TIMEOUT:
 540         TRY {
 541           THROW0(timeout_error, 0, "Communication timeouted because of sender");
 542         }
 543         CATCH(req->issuer->running_ctx->exception) {
 544           req->issuer->doexception = 1;
 545         }
 546         break;
 547
 548       case SIMIX_DST_TIMEOUT:
 549         TRY {
 550           THROW0(timeout_error, 0, "Communication timeouted because of receiver");
 551         }
 552         CATCH(req->issuer->running_ctx->exception) {
 553           req->issuer->doexception = 1;
 554         }
 555         break;
 556
 557       case SIMIX_SRC_HOST_FAILURE:
 558         TRY {
 559           if (req->issuer == action->comm.src_proc)
 560             THROW0(host_error, 0, "Host failed");
 561           else
 562             THROW0(network_error, 0, "Remote peer failed");
 563         }
 564         CATCH(req->issuer->running_ctx->exception) {
 565           req->issuer->doexception = 1;
 566         }
 567         break;
 568
 569       case SIMIX_DST_HOST_FAILURE:
 570         TRY {
 571           if (req->issuer == action->comm.dst_proc)
 572             THROW0(host_error, 0, "Host failed");
 573           else
 574             THROW0(network_error, 0, "Remote peer failed");
 575         }
 576         CATCH(req->issuer->running_ctx->exception) {
 577           req->issuer->doexception = 1;
 578         }
 579         break;
 580
 581       case SIMIX_LINK_FAILURE:
 582         TRY {
 583           DEBUG5("Link failure in action %p between '%s' and '%s': posting an exception to the issuer: %s (%p)",
 584               action, action->comm.src_proc->smx_host->name, action->comm.dst_proc->smx_host->name,
 585               req->issuer->name, req->issuer);
 586           THROW0(network_error, 0, "Link failure");
 587         }
 588         CATCH(req->issuer->running_ctx->exception) {
 589           req->issuer->doexception = 1;
 590         }
 591         break;
 592
 593       default:
 594         THROW_IMPOSSIBLE;
 595     }
 596
 597     /* if there is an exception during a waitany or a testany, indicate the position of the failed communication */
 598     if (req->issuer->doexception) {
 599       if (req->call == REQ_COMM_WAITANY) {
 600         req->issuer->running_ctx->exception.value = xbt_dynar_search(req->comm_waitany.comms, &action);
 601       }
 602       else if (req->call == REQ_COMM_TESTANY) {
 603         req->issuer->running_ctx->exception.value = xbt_dynar_search(req->comm_testany.comms, &action);
 604       }
 605     }
 606
 607     req->issuer->waiting_action = NULL;
 608     SIMIX_request_answer(req);
 609   }
 610 }
 611
 612 void SIMIX_post_comm(smx_action_t action)
 613 {
 614   /* Update action state */
 615   if (action->comm.src_timeout &&
 616      surf_workstation_model->action_state_get(action->comm.src_timeout) == SURF_ACTION_DONE)
 617      action->state = SIMIX_SRC_TIMEOUT;
 618   else if (action->comm.dst_timeout &&
 619           surf_workstation_model->action_state_get(action->comm.dst_timeout) == SURF_ACTION_DONE)
 620      action->state = SIMIX_DST_TIMEOUT;
 621   else if (action->comm.src_timeout &&
 622           surf_workstation_model->action_state_get(action->comm.src_timeout) == SURF_ACTION_FAILED)
 623      action->state = SIMIX_SRC_HOST_FAILURE;
 624   else if (action->comm.dst_timeout &&
 625           surf_workstation_model->action_state_get(action->comm.dst_timeout) == SURF_ACTION_FAILED)
 626      action->state = SIMIX_DST_HOST_FAILURE;
 627   else if (action->comm.surf_comm &&
 628           surf_workstation_model->action_state_get(action->comm.surf_comm) == SURF_ACTION_FAILED)
 629      action->state = SIMIX_LINK_FAILURE;
 630   else
 631     action->state = SIMIX_DONE;
 632
 633   DEBUG1("SIMIX_post_comm: action state = %d", action->state);
 634
 635   /* After this point the surf actions associated with the simix communicate
 636      action are no longer needed, thus we delete them. */
 637   SIMIX_comm_destroy_internal_actions(action);
 638
 639   /* If there are requests associated with the action, then answer them */
 640   if (xbt_fifo_size(action->request_list))
 641     SIMIX_comm_finish(action);
 642 }
 643
 644 void SIMIX_comm_cancel(smx_action_t action)
 645 {
 646   /* If the action is a waiting state means that it is still in a rdv */
 647   /* so remove from it and delete it */
 648   if (action->state == SIMIX_WAITING) {
 649     SIMIX_rdv_remove(action->comm.rdv, action);
 650     action->state = SIMIX_FAILED;
 651   } else {
 652     /* When running the MC there are no surf actions */
 653     if(!MC_IS_ENABLED)
 654       surf_workstation_model->action_cancel(action->comm.surf_comm);
 655   }
 656 }
 657
 658 void SIMIX_comm_suspend(smx_action_t action)
 659 {
 660   /*FIXME: shall we suspend also the timeout actions? */
 661   surf_workstation_model->suspend(action->comm.surf_comm);
 662 }
 663
 664 void SIMIX_comm_resume(smx_action_t action)
 665 {
 666   /*FIXME: check what happen with the timeouts */
 667   surf_workstation_model->resume(action->comm.surf_comm);
 668 }
 669
 670
 671 /************* Action Getters **************/
 672
 673 /**
 674  *  \brief get the amount remaining from the communication
 675  *  \param action The communication
 676  */
 677 double SIMIX_comm_get_remains(smx_action_t action)
 678 {
 679   double remains;
 680
 681   switch (action->state) {
 682
 683     case SIMIX_RUNNING:
 684       remains = surf_workstation_model->get_remains(action->comm.surf_comm);
 685       break;
 686
 687     case SIMIX_WAITING:
 688     case SIMIX_READY:
 689       remains = 0; /*FIXME: check what should be returned */
 690       break;
 691
 692     default:
 693       remains = 0; /*FIXME: is this correct? */
 694       break;
 695   }
 696   return remains;
 697 }
 698
 699 e_smx_state_t SIMIX_comm_get_state(smx_action_t action)
 700 {
 701   return action->state;
 702 }
 703
 704 /**
 705  *  \brief Return the user data associated to the sender of the communication
 706  *  \param action The communication
 707  *  \return the user data
 708  */
 709 void* SIMIX_comm_get_src_data(smx_action_t action)
 710 {
 711   return action->comm.src_data;
 712 }
 713
 714 /**
 715  *  \brief Return the user data associated to the receiver of the communication
 716  *  \param action The communication
 717  *  \return the user data
 718  */
 719 void* SIMIX_comm_get_dst_data(smx_action_t action)
 720 {
 721   return action->comm.dst_data;
 722 }
 723
 724 void* SIMIX_comm_get_src_buff(smx_action_t action)
 725 {
 726   return action->comm.src_buff;
 727 }
 728
 729 void* SIMIX_comm_get_dst_buff(smx_action_t action)
 730 {
 731   return action->comm.dst_buff;
 732 }
 733
 734 size_t SIMIX_comm_get_src_buff_size(smx_action_t action)
 735 {
 736   return action->comm.src_buff_size;
 737 }
 738
 739 size_t SIMIX_comm_get_dst_buff_size(smx_action_t action)
 740 {
 741   size_t buff_size;
 742
 743   if (action->comm.dst_buff_size)
 744     buff_size = *(action->comm.dst_buff_size);
 745   else
 746     buff_size = 0;
 747
 748   return buff_size;
 749 }
 750
 751 smx_process_t SIMIX_comm_get_src_proc(smx_action_t action)
 752 {
 753   return action->comm.src_proc;
 754 }
 755
 756 smx_process_t SIMIX_comm_get_dst_proc(smx_action_t action)
 757 {
 758   return action->comm.dst_proc;
 759 }
 760
 761 #ifdef HAVE_LATENCY_BOUND_TRACKING
 762 /**
 763  *  \brief verify if communication is latency bounded
 764  *  \param comm The communication
 765  */
 766 XBT_INLINE int SIMIX_comm_is_latency_bounded(smx_action_t action)
 767 {
 768   if (action->comm.surf_comm){
 769       DEBUG1("Getting latency limited for surf_action (%p)", action->comm.surf_comm);
 770       action->latency_limited = surf_workstation_model->get_latency_limited(action->comm.surf_comm);
 771       DEBUG1("Action limited is %d", action->latency_limited);
 772   }
 773   return action->latency_limited;
 774 }
 775 #endif
 776
 777 /******************************************************************************/
 778 /*                    SIMIX_comm_copy_data callbacks                       */
 779 /******************************************************************************/
 780 static void (*SIMIX_comm_copy_data_callback) (smx_action_t, size_t) =
 781     &SIMIX_comm_copy_pointer_callback;
 782
 783 void
 784 SIMIX_comm_set_copy_data_callback(void (*callback) (smx_action_t, size_t))
 785 {
 786   SIMIX_comm_copy_data_callback = callback;
 787 }
 788
 789 void SIMIX_comm_copy_pointer_callback(smx_action_t comm, size_t buff_size)
 790 {
 791   xbt_assert1((buff_size == sizeof(void *)),
 792               "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
 793   *(void **) (comm->comm.dst_buff) = comm->comm.src_buff;
 794 }
 795
 796 void SIMIX_comm_copy_buffer_callback(smx_action_t comm, size_t buff_size)
 797 {
 798   memcpy(comm->comm.dst_buff, comm->comm.src_buff, buff_size);
 799 }
 800
 801 /**
 802  *  \brief Copy the communication data from the sender's buffer to the receiver's one
 803  *  \param comm The communication
 804  */
 805 void SIMIX_comm_copy_data(smx_action_t comm)
 806 {
 807   size_t buff_size = comm->comm.src_buff_size;
 808   /* If there is no data to be copy then return */
 809   if (!comm->comm.src_buff || !comm->comm.dst_buff || comm->comm.copied == 1)
 810     return;
 811
 812   DEBUG6("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)",
 813          comm,
 814          comm->comm.src_proc->smx_host->name, comm->comm.src_buff,
 815          comm->comm.dst_proc->smx_host->name, comm->comm.dst_buff, buff_size);
 816
 817   /* Copy at most dst_buff_size bytes of the message to receiver's buffer */
 818   if (comm->comm.dst_buff_size)
 819     buff_size = MIN(buff_size, *(comm->comm.dst_buff_size));
 820
 821   /* Update the receiver's buffer size to the copied amount */
 822   if (comm->comm.dst_buff_size)
 823     *comm->comm.dst_buff_size = buff_size;
 824
 825   if (buff_size == 0)
 826     return;
 827
 828   (*SIMIX_comm_copy_data_callback) (comm, buff_size);
 829
 830   /* Set the copied flag so we copy data only once */
 831   /* (this function might be called from both communication ends) */
 832   comm->comm.copied = 1;
 833 }