trace: when simix action gets its category, pass it to surf action

[simgrid.git] / src / simix / smx_network.c

diff --git a/src/simix/smx_network.c b/src/simix/smx_network.c
index 54efa74..7af536e 100644 (file)
--- a/src/simix/smx_network.c
+++ b/src/simix/smx_network.c
@@ -11,6 +11,9 @@
 
 /* Pimple to get an histogram of message sizes in the simulation */
 xbt_dict_t msg_sizes = NULL;
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+xbt_dict_t latency_limited_dict = NULL;
+#endif
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_network, simix,
                                 "Logging specific to SIMIX (network)");
@@ -160,6 +163,18 @@ smx_comm_t SIMIX_communication_new(smx_comm_type_t type)
 void SIMIX_communication_destroy(smx_comm_t comm)
 {
   VERB2("Destroy communication %p; refcount initially %d",comm,comm->refcount);
+
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+  //save is latency limited flag to use afterwards
+  if (latency_limited_dict == NULL) {
+         latency_limited_dict = xbt_dict_new();
+  }
+  if (comm->act){
+    DEBUG2("adding key %p with latency limited value %d to the dict", comm, SIMIX_action_is_latency_bounded(comm->act));
+    xbt_dicti_set(latency_limited_dict, (uintptr_t)comm, SIMIX_action_is_latency_bounded(comm->act));
+  }
+#endif
+
   comm->refcount--;
   if(comm->refcount > 0)
     return;
@@ -184,6 +199,8 @@ void SIMIX_communication_destroy(smx_comm_t comm)
       comm->dst_timeout = NULL;
     }
 
+
+
   xbt_free(comm);
 }
 
@@ -214,6 +231,7 @@ static XBT_INLINE void SIMIX_communication_start(smx_comm_t comm)
                                          comm->task_size, comm->rate);
 #ifdef HAVE_TRACING
     TRACE_smx_action_communicate (comm->act, comm->src_proc);
+    TRACE_surf_action (comm->act->surf_action, comm->act->category);
 #endif
 
     /* If any of the process is suspend, create the action but stop its execution,
@@ -248,7 +266,7 @@ static XBT_INLINE void SIMIX_communication_cleanup(smx_comm_t comm)
   if (!SIMIX_host_get_state(SIMIX_host_self())){
     if(comm->rdv)
       SIMIX_rdv_remove(comm->rdv, comm);
-    SIMIX_communication_destroy(comm);
+         SIMIX_communication_destroy(comm);
     THROW0(host_error, 0, "Host failed");
   } else if (SIMIX_action_get_state(comm->act) == SURF_ACTION_FAILED){
     SIMIX_communication_destroy(comm);
@@ -343,9 +361,34 @@ XBT_INLINE void SIMIX_communication_cancel(smx_comm_t comm)
  */
 XBT_INLINE double SIMIX_communication_get_remains(smx_comm_t comm)
 {
+  DEBUG1("calling SIMIX_action_get_remains(%p)", comm->act);
   return SIMIX_action_get_remains(comm->act);
 }  
 
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+/**
+ *  \brief verify if communication is latency bounded
+ *  \param comm The communication
+ */
+XBT_INLINE int SIMIX_communication_is_latency_bounded(smx_comm_t comm)
+{
+  //try to find comm on the list of finished flows
+  uintptr_t key = 0;
+  uintptr_t data = 0;
+  xbt_dict_cursor_t cursor;
+  xbt_dict_foreach(latency_limited_dict,cursor,key,data) {
+    DEBUG2("comparing key=%p with comm=%p", (void*)key, (void*)comm);
+       if((void*)comm == (void*)key){
+               DEBUG2("key %p found, return value latency limited value %d", (void*)key, (int)data);
+               return (int)data;
+       }
+  }
+
+  DEBUG1("calling SIMIX_action_is_latency_bounded(%p)", comm->act);
+  return SIMIX_action_is_latency_bounded(comm->act);
+}
+#endif
+
 /******************************************************************************/
 /*                    SIMIX_network_copy_data callbacks                       */
 /******************************************************************************/
@@ -448,9 +491,9 @@ XBT_PUBLIC(size_t) SIMIX_communication_get_src_buf_size(smx_comm_t comm)
 {
   return comm->src_buff_size;
 }
-XBT_PUBLIC(size_t *) SIMIX_communication_get_dst_buf_size(smx_comm_t comm)
+XBT_PUBLIC(size_t) SIMIX_communication_get_dst_buf_size(smx_comm_t comm)
 {
-  return comm->dst_buff_size;
+  return *(comm->dst_buff_size);
 }
 
 /******************************************************************************/
@@ -496,7 +539,7 @@ XBT_INLINE void SIMIX_network_send(smx_rdv_t rdv, double task_size, double rate,
 XBT_INLINE void SIMIX_network_recv(smx_rdv_t rdv, double timeout, void *dst_buff,
                         size_t *dst_buff_size, smx_comm_t *comm_ref)
 {
-  *comm_ref = SIMIX_network_irecv(rdv,dst_buff,dst_buff_size);
+  *comm_ref = (smx_comm_t) SIMIX_network_irecv(rdv,dst_buff,dst_buff_size);
   SIMIX_network_wait(*comm_ref,timeout);
 }