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)
 223     ((void_f_pvoid_t)action->comm.src_data)(action->comm.src_buff);
 224
 225   xbt_free(action);
 226 }
 227
 228 void SIMIX_comm_destroy_internal_actions(smx_action_t action)
 229 {
 230   if (action->comm.surf_comm){
 231 #ifdef HAVE_LATENCY_BOUND_TRACKING
 232     action->latency_limited = SIMIX_comm_is_latency_bounded(action);
 233 #endif
 234     action->comm.surf_comm->model_type->action_unref(action->comm.surf_comm);
 235     action->comm.surf_comm = NULL;
 236   }
 237
 238   if (action->comm.src_timeout){
 239     action->comm.src_timeout->model_type->action_unref(action->comm.src_timeout);
 240     action->comm.src_timeout = NULL;
 241   }
 242
 243   if (action->comm.dst_timeout){
 244     action->comm.dst_timeout->model_type->action_unref(action->comm.dst_timeout);
 245     action->comm.dst_timeout = NULL;
 246   }
 247 }
 248
 249 smx_action_t SIMIX_comm_isend(smx_process_t src_proc, smx_rdv_t rdv,
 250                               double task_size, double rate,
 251                               void *src_buff, size_t src_buff_size,
 252                               int (*match_fun)(void *, void *), void *data,
 253                               int detached)
 254 {
 255   smx_action_t action;
 256
 257   /* Look for communication request matching our needs.
 258      If it is not found then create it and push it into the rendez-vous point */
 259   action = SIMIX_rdv_get_request(rdv, SIMIX_COMM_RECEIVE, match_fun, data);
 260
 261   if (!action) {
 262     action = SIMIX_comm_new(SIMIX_COMM_SEND);
 263     SIMIX_rdv_push(rdv, action);
 264   } else {
 265     action->state = SIMIX_READY;
 266     action->comm.type = SIMIX_COMM_READY;
 267   }
 268
 269   /* If the communication action is detached then decrease the refcount
 270    * by one, so it will be eliminated by the receivers destroy call */
 271   if(detached){
 272     action->comm.detached = 1;
 273     action->comm.refcount--;
 274   }
 275
 276   /* Setup the communication request */
 277   action->comm.src_proc = src_proc;
 278   action->comm.task_size = task_size;
 279   action->comm.rate = rate;
 280   action->comm.src_buff = src_buff;
 281   action->comm.src_buff_size = src_buff_size;
 282   action->comm.src_data = data;
 283
 284   if (MC_IS_ENABLED) {
 285     action->state = SIMIX_RUNNING;
 286     return action;
 287   }
 288
 289   SIMIX_comm_start(action);
 290   return action;
 291 }
 292
 293 smx_action_t SIMIX_comm_irecv(smx_process_t dst_proc, smx_rdv_t rdv,
 294                       void *dst_buff, size_t *dst_buff_size,
 295                       int (*match_fun)(void *, void *), void *data)
 296 {
 297   smx_action_t action;
 298
 299   /* Look for communication request matching our needs.
 300    * If it is not found then create it and push it into the rendez-vous point
 301    */
 302   action = SIMIX_rdv_get_request(rdv, SIMIX_COMM_SEND, match_fun, data);
 303
 304   if (!action) {
 305     action = SIMIX_comm_new(SIMIX_COMM_RECEIVE);
 306     SIMIX_rdv_push(rdv, action);
 307   } else {
 308     action->state = SIMIX_READY;
 309     action->comm.type = SIMIX_COMM_READY;
 310   }
 311
 312   /* Setup communication request */
 313   action->comm.dst_proc = dst_proc;
 314   action->comm.dst_buff = dst_buff;
 315   action->comm.dst_buff_size = dst_buff_size;
 316   action->comm.dst_data = data;
 317
 318   if (MC_IS_ENABLED) {
 319     action->state = SIMIX_RUNNING;
 320     return action;
 321   }
 322
 323   SIMIX_comm_start(action);
 324   return action;
 325 }
 326
 327 void SIMIX_pre_comm_wait(smx_req_t req, int idx)
 328 {
 329   smx_action_t action = req->comm_wait.comm;
 330   double timeout = req->comm_wait.timeout;
 331   surf_action_t sleep;
 332
 333   /* Associate this request to the action */
 334   xbt_fifo_push(action->request_list, req);
 335   req->issuer->waiting_action = action;
 336
 337   if (MC_IS_ENABLED){
 338     if(idx == 0){
 339       action->state = SIMIX_DONE;
 340     }else{
 341       /* If we reached this point, the wait request must have a timeout */
 342       /* Otherwise it shouldn't be enabled and executed by the MC */
 343       if(timeout == -1)
 344         THROW_IMPOSSIBLE;
 345
 346       if(action->comm.src_proc == req->issuer)
 347         action->state = SIMIX_SRC_TIMEOUT;
 348       else
 349         action->state = SIMIX_DST_TIMEOUT;
 350     }
 351
 352     SIMIX_comm_finish(action);
 353     return;
 354   }
 355
 356   /* If the action has already finish perform the error handling, */
 357   /* otherwise set up a waiting timeout on the right side         */
 358   if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING) {
 359     SIMIX_comm_finish(action);
 360   } 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 */
 361     sleep = surf_workstation_model->extension.workstation.sleep(req->issuer->smx_host->host, timeout);
 362     surf_workstation_model->action_data_set(sleep, action);
 363
 364     if (req->issuer == action->comm.src_proc)
 365       action->comm.src_timeout = sleep;
 366     else
 367       action->comm.dst_timeout = sleep;
 368   }
 369 }
 370
 371 void SIMIX_pre_comm_test(smx_req_t req)
 372 {
 373   smx_action_t action = req->comm_test.comm;
 374
 375   if(MC_IS_ENABLED){
 376     req->comm_test.result = action->comm.src_proc && action->comm.dst_proc;
 377     if(req->comm_test.result){
 378       action->state = SIMIX_DONE;
 379       xbt_fifo_push(action->request_list, req);
 380       SIMIX_comm_finish(action);
 381     }else{
 382       SIMIX_request_answer(req);
 383     }
 384     return;
 385   }
 386
 387   req->comm_test.result = (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING);
 388   if (req->comm_test.result) {
 389     xbt_fifo_push(action->request_list, req);
 390     SIMIX_comm_finish(action);
 391   } else {
 392     SIMIX_request_answer(req);
 393   }
 394 }
 395
 396 void SIMIX_pre_comm_testany(smx_req_t req, int idx)
 397 {
 398   unsigned int cursor;
 399   smx_action_t action;
 400   xbt_dynar_t actions = req->comm_testany.comms;
 401   req->comm_testany.result = -1;
 402
 403   if (MC_IS_ENABLED){
 404     if(idx == -1){
 405       SIMIX_request_answer(req);
 406     }else{
 407       action = xbt_dynar_get_as(actions, idx, smx_action_t);
 408       req->comm_testany.result = idx;
 409       xbt_fifo_push(action->request_list, req);
 410       action->state = SIMIX_DONE;
 411       SIMIX_comm_finish(action);
 412     }
 413     return;
 414   }
 415
 416   xbt_dynar_foreach(req->comm_testany.comms,cursor,action) {
 417     if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING) {
 418       req->comm_testany.result = cursor;
 419       xbt_fifo_push(action->request_list, req);
 420       SIMIX_comm_finish(action);
 421       return;
 422     }
 423   }
 424   SIMIX_request_answer(req);
 425 }
 426
 427 void SIMIX_pre_comm_waitany(smx_req_t req, int idx)
 428 {
 429   smx_action_t action;
 430   unsigned int cursor = 0;
 431   xbt_dynar_t actions = req->comm_waitany.comms;
 432
 433   if (MC_IS_ENABLED){
 434     action = xbt_dynar_get_as(actions, idx, smx_action_t);
 435     xbt_fifo_push(action->request_list, req);
 436     req->comm_waitany.result = idx;
 437     action->state = SIMIX_DONE;
 438     SIMIX_comm_finish(action);
 439     return;
 440   }
 441
 442   xbt_dynar_foreach(actions, cursor, action){
 443     /* Associate this request to the action */
 444     xbt_fifo_push(action->request_list, req);
 445     if (action->state != SIMIX_WAITING && action->state != SIMIX_RUNNING){
 446       SIMIX_comm_finish(action);
 447       break;
 448     }
 449   }
 450 }
 451
 452 void SIMIX_waitany_req_remove_from_actions(smx_req_t req)
 453 {
 454   smx_action_t action;
 455   unsigned int cursor = 0;
 456   xbt_dynar_t actions = req->comm_waitany.comms;
 457
 458   xbt_dynar_foreach(actions, cursor, action){
 459     xbt_fifo_remove(action->request_list, req);
 460   }
 461 }
 462
 463 /**
 464  *  \brief Start the simulation of a communication request
 465  *  \param action The communication action
 466  */
 467 static XBT_INLINE void SIMIX_comm_start(smx_action_t action)
 468 {
 469   /* If both the sender and the receiver are already there, start the communication */
 470   if (action->state == SIMIX_READY) {
 471     smx_host_t sender = action->comm.src_proc->smx_host;
 472     smx_host_t receiver = action->comm.dst_proc->smx_host;
 473
 474     DEBUG3("Starting communication %p from '%s' to '%s'", action,
 475            SIMIX_host_get_name(sender), SIMIX_host_get_name(receiver));
 476
 477     action->comm.surf_comm = surf_workstation_model->extension.workstation.
 478         communicate(sender->host, receiver->host, action->comm.task_size, action->comm.rate);
 479
 480     surf_workstation_model->action_data_set(action->comm.surf_comm, action);
 481
 482     action->state = SIMIX_RUNNING;
 483
 484 #ifdef HAVE_TRACING
 485     TRACE_smx_action_communicate(action, action->comm.src_proc);
 486 #endif
 487
 488     /* If a link is failed, detect it immediately */
 489     if (surf_workstation_model->action_state_get(action->comm.surf_comm) == SURF_ACTION_FAILED) {
 490       DEBUG2("Communication from '%s' to '%s' failed to start because of a link failure",
 491           SIMIX_host_get_name(sender), SIMIX_host_get_name(receiver));
 492       action->state = SIMIX_LINK_FAILURE;
 493       SIMIX_comm_destroy_internal_actions(action);
 494     }
 495
 496     /* If any of the process is suspend, create the action but stop its execution,
 497        it will be restarted when the sender process resume */
 498     if (SIMIX_process_is_suspended(action->comm.src_proc) ||
 499         SIMIX_process_is_suspended(action->comm.dst_proc)) {
 500       /* FIXME: check what should happen with the action state */
 501       surf_workstation_model->suspend(action->comm.surf_comm);
 502     }
 503   }
 504 }
 505
 506 void SIMIX_comm_finish(smx_action_t action)
 507 {
 508   smx_req_t req;
 509
 510   while ((req = xbt_fifo_shift(action->request_list))) {
 511
 512     /* If a waitany request is waiting for this action to finish, then remove
 513        it from the other actions in the waitany list. Afterwards, get the
 514        position of the actual action in the waitany request's actions dynar and
 515        return it as the result of the call */
 516     if (req->call == REQ_COMM_WAITANY) {
 517       SIMIX_waitany_req_remove_from_actions(req);
 518       if(!MC_IS_ENABLED)
 519         req->comm_waitany.result = xbt_dynar_search(req->comm_waitany.comms, &action);
 520     }
 521
 522     /* If the action is still in a rendez-vous point then remove from it */
 523     if (action->comm.rdv)
 524       SIMIX_rdv_remove(action->comm.rdv, action);
 525
 526     DEBUG1("SIMIX_comm_finish: action state = %d", action->state);
 527
 528     /* Check out for errors */
 529     switch (action->state) {
 530
 531       case SIMIX_DONE:
 532         DEBUG1("Communication %p complete!", action);
 533         SIMIX_comm_copy_data(action);
 534         break;
 535
 536       case SIMIX_SRC_TIMEOUT:
 537         TRY {
 538           THROW0(timeout_error, 0, "Communication timeouted because of sender");
 539         }
 540         CATCH(req->issuer->running_ctx->exception) {
 541           req->issuer->doexception = 1;
 542         }
 543         break;
 544
 545       case SIMIX_DST_TIMEOUT:
 546         TRY {
 547           THROW0(timeout_error, 0, "Communication timeouted because of receiver");
 548         }
 549         CATCH(req->issuer->running_ctx->exception) {
 550           req->issuer->doexception = 1;
 551         }
 552         break;
 553
 554       case SIMIX_SRC_HOST_FAILURE:
 555         TRY {
 556           if (req->issuer == action->comm.src_proc)
 557             THROW0(host_error, 0, "Host failed");
 558           else
 559             THROW0(network_error, 0, "Remote peer failed");
 560         }
 561         CATCH(req->issuer->running_ctx->exception) {
 562           req->issuer->doexception = 1;
 563         }
 564         break;
 565
 566       case SIMIX_DST_HOST_FAILURE:
 567         TRY {
 568           if (req->issuer == action->comm.dst_proc)
 569             THROW0(host_error, 0, "Host failed");
 570           else
 571             THROW0(network_error, 0, "Remote peer failed");
 572         }
 573         CATCH(req->issuer->running_ctx->exception) {
 574           req->issuer->doexception = 1;
 575         }
 576         break;
 577
 578       case SIMIX_LINK_FAILURE:
 579         TRY {
 580           DEBUG5("Link failure in action %p between '%s' and '%s': posting an exception to the issuer: %s (%p)",
 581               action, action->comm.src_proc->smx_host->name, action->comm.dst_proc->smx_host->name,
 582               req->issuer->name, req->issuer);
 583           THROW0(network_error, 0, "Link failure");
 584         }
 585         CATCH(req->issuer->running_ctx->exception) {
 586           req->issuer->doexception = 1;
 587         }
 588         break;
 589
 590       default:
 591         THROW_IMPOSSIBLE;
 592     }
 593
 594     /* if there is an exception during a waitany or a testany, indicate the position of the failed communication */
 595     if (req->issuer->doexception) {
 596       if (req->call == REQ_COMM_WAITANY) {
 597         req->issuer->running_ctx->exception.value = xbt_dynar_search(req->comm_waitany.comms, &action);
 598       }
 599       else if (req->call == REQ_COMM_TESTANY) {
 600         req->issuer->running_ctx->exception.value = xbt_dynar_search(req->comm_testany.comms, &action);
 601       }
 602     }
 603
 604     req->issuer->waiting_action = NULL;
 605     SIMIX_request_answer(req);
 606   }
 607 }
 608
 609 void SIMIX_post_comm(smx_action_t action)
 610 {
 611   /* Update action state */
 612   if (action->comm.src_timeout &&
 613      surf_workstation_model->action_state_get(action->comm.src_timeout) == SURF_ACTION_DONE)
 614      action->state = SIMIX_SRC_TIMEOUT;
 615   else if (action->comm.dst_timeout &&
 616           surf_workstation_model->action_state_get(action->comm.dst_timeout) == SURF_ACTION_DONE)
 617      action->state = SIMIX_DST_TIMEOUT;
 618   else if (action->comm.src_timeout &&
 619           surf_workstation_model->action_state_get(action->comm.src_timeout) == SURF_ACTION_FAILED)
 620      action->state = SIMIX_SRC_HOST_FAILURE;
 621   else if (action->comm.dst_timeout &&
 622           surf_workstation_model->action_state_get(action->comm.dst_timeout) == SURF_ACTION_FAILED)
 623      action->state = SIMIX_DST_HOST_FAILURE;
 624   else if (action->comm.surf_comm &&
 625           surf_workstation_model->action_state_get(action->comm.surf_comm) == SURF_ACTION_FAILED)
 626      action->state = SIMIX_LINK_FAILURE;
 627   else
 628     action->state = SIMIX_DONE;
 629
 630   DEBUG1("SIMIX_post_comm: action state = %d", action->state);
 631
 632   /* After this point the surf actions associated with the simix communicate
 633      action are no longer needed, thus we delete them. */
 634   SIMIX_comm_destroy_internal_actions(action);
 635
 636   /* If there are requests associated with the action, then answer them */
 637   if (xbt_fifo_size(action->request_list))
 638     SIMIX_comm_finish(action);
 639 }
 640
 641 void SIMIX_comm_cancel(smx_action_t action)
 642 {
 643   /* If the action is a waiting state means that it is still in a rdv */
 644   /* so remove from it and delete it */
 645   if (action->state == SIMIX_WAITING) {
 646     SIMIX_rdv_remove(action->comm.rdv, action);
 647     action->state = SIMIX_FAILED;
 648   } else {
 649     /* When running the MC there are no surf actions */
 650     if(!MC_IS_ENABLED)
 651       surf_workstation_model->action_cancel(action->comm.surf_comm);
 652   }
 653 }
 654
 655 void SIMIX_comm_suspend(smx_action_t action)
 656 {
 657   /*FIXME: shall we suspend also the timeout actions? */
 658   surf_workstation_model->suspend(action->comm.surf_comm);
 659 }
 660
 661 void SIMIX_comm_resume(smx_action_t action)
 662 {
 663   /*FIXME: check what happen with the timeouts */
 664   surf_workstation_model->resume(action->comm.surf_comm);
 665 }
 666
 667
 668 /************* Action Getters **************/
 669
 670 /**
 671  *  \brief get the amount remaining from the communication
 672  *  \param action The communication
 673  */
 674 double SIMIX_comm_get_remains(smx_action_t action)
 675 {
 676   double remains;
 677
 678   switch (action->state) {
 679
 680     case SIMIX_RUNNING:
 681       remains = surf_workstation_model->get_remains(action->comm.surf_comm);
 682       break;
 683
 684     case SIMIX_WAITING:
 685     case SIMIX_READY:
 686       remains = 0; /*FIXME: check what should be returned */
 687       break;
 688
 689     default:
 690       remains = 0; /*FIXME: is this correct? */
 691       break;
 692   }
 693   return remains;
 694 }
 695
 696 e_smx_state_t SIMIX_comm_get_state(smx_action_t action)
 697 {
 698   return action->state;
 699 }
 700
 701 /**
 702  *  \brief Return the user data associated to the sender of the communication
 703  *  \param action The communication
 704  *  \return the user data
 705  */
 706 void* SIMIX_comm_get_src_data(smx_action_t action)
 707 {
 708   return action->comm.src_data;
 709 }
 710
 711 /**
 712  *  \brief Return the user data associated to the receiver of the communication
 713  *  \param action The communication
 714  *  \return the user data
 715  */
 716 void* SIMIX_comm_get_dst_data(smx_action_t action)
 717 {
 718   return action->comm.dst_data;
 719 }
 720
 721 void* SIMIX_comm_get_src_buff(smx_action_t action)
 722 {
 723   return action->comm.src_buff;
 724 }
 725
 726 void* SIMIX_comm_get_dst_buff(smx_action_t action)
 727 {
 728   return action->comm.dst_buff;
 729 }
 730
 731 size_t SIMIX_comm_get_src_buff_size(smx_action_t action)
 732 {
 733   return action->comm.src_buff_size;
 734 }
 735
 736 size_t SIMIX_comm_get_dst_buff_size(smx_action_t action)
 737 {
 738   size_t buff_size;
 739
 740   if (action->comm.dst_buff_size)
 741     buff_size = *(action->comm.dst_buff_size);
 742   else
 743     buff_size = 0;
 744
 745   return buff_size;
 746 }
 747
 748 smx_process_t SIMIX_comm_get_src_proc(smx_action_t action)
 749 {
 750   return action->comm.src_proc;
 751 }
 752
 753 smx_process_t SIMIX_comm_get_dst_proc(smx_action_t action)
 754 {
 755   return action->comm.dst_proc;
 756 }
 757
 758 #ifdef HAVE_LATENCY_BOUND_TRACKING
 759 /**
 760  *  \brief verify if communication is latency bounded
 761  *  \param comm The communication
 762  */
 763 XBT_INLINE int SIMIX_comm_is_latency_bounded(smx_action_t action)
 764 {
 765   if (action->comm.surf_comm){
 766       DEBUG1("Getting latency limited for surf_action (%p)", action->comm.surf_comm);
 767       action->latency_limited = surf_workstation_model->get_latency_limited(action->comm.surf_comm);
 768       DEBUG1("Action limited is %d", action->latency_limited);
 769   }
 770   return action->latency_limited;
 771 }
 772 #endif
 773
 774 /******************************************************************************/
 775 /*                    SIMIX_comm_copy_data callbacks                       */
 776 /******************************************************************************/
 777 static void (*SIMIX_comm_copy_data_callback) (smx_action_t, size_t) =
 778     &SIMIX_comm_copy_pointer_callback;
 779
 780 void
 781 SIMIX_comm_set_copy_data_callback(void (*callback) (smx_action_t, size_t))
 782 {
 783   SIMIX_comm_copy_data_callback = callback;
 784 }
 785
 786 void SIMIX_comm_copy_pointer_callback(smx_action_t comm, size_t buff_size)
 787 {
 788   xbt_assert1((buff_size == sizeof(void *)),
 789               "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
 790   *(void **) (comm->comm.dst_buff) = comm->comm.src_buff;
 791 }
 792
 793 void SIMIX_comm_copy_buffer_callback(smx_action_t comm, size_t buff_size)
 794 {
 795   memcpy(comm->comm.dst_buff, comm->comm.src_buff, buff_size);
 796 }
 797
 798 /**
 799  *  \brief Copy the communication data from the sender's buffer to the receiver's one
 800  *  \param comm The communication
 801  */
 802 void SIMIX_comm_copy_data(smx_action_t comm)
 803 {
 804   size_t buff_size = comm->comm.src_buff_size;
 805   /* If there is no data to be copy then return */
 806   if (!comm->comm.src_buff || !comm->comm.dst_buff || comm->comm.copied == 1)
 807     return;
 808
 809   DEBUG6("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)",
 810          comm,
 811          comm->comm.src_proc->smx_host->name, comm->comm.src_buff,
 812          comm->comm.dst_proc->smx_host->name, comm->comm.dst_buff, buff_size);
 813
 814   /* Copy at most dst_buff_size bytes of the message to receiver's buffer */
 815   if (comm->comm.dst_buff_size)
 816     buff_size = MIN(buff_size, *(comm->comm.dst_buff_size));
 817
 818   /* Update the receiver's buffer size to the copied amount */
 819   if (comm->comm.dst_buff_size)
 820     *comm->comm.dst_buff_size = buff_size;
 821
 822   if (buff_size == 0)
 823     return;
 824
 825   (*SIMIX_comm_copy_data_callback) (comm, buff_size);
 826
 827   /* Set the copied flag so we copy data only once */
 828   /* (this function might be called from both communication ends) */
 829   comm->comm.copied = 1;
 830 }