X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1ee06836f97375c683e9e31d24ff77fb258b453b..fb1aa5988cbcd8d27c1c7a8ee359d51d153167e8:/src/surf/network_ns3.c

diff --git a/src/surf/network_ns3.c b/src/surf/network_ns3.c
index 8777c009f7..7b4a54f718 100644
--- a/src/surf/network_ns3.c
+++ b/src/surf/network_ns3.c
@@ -5,6 +5,7 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "surf_private.h"
+#include "surf/maxmin.h"
 #include "surf/ns3/ns3_interface.h"
 #include "xbt/lib.h"
 #include "surf/network_ns3_private.h"
@@ -17,8 +18,6 @@ extern xbt_lib_t as_router_lib;
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network_ns3, surf,
                                 "Logging specific to the SURF network NS3 module");
 
-#define MAX_LENGHT_IPV4 16 //255.255.255.255\0
-
 extern routing_global_t global_routing;
 extern xbt_dict_t dict_socket;
 
@@ -27,7 +26,7 @@ static double time_to_next_flow_completion = -1;
 static double ns3_share_resources(double min);
 static void ns3_update_actions_state(double now, double delta);
 static void finalize(void);
-static surf_action_t communicate(const char *src_name,
+static surf_action_t ns3_communicate(const char *src_name,
                                  const char *dst_name, double size, double rate);
 static void action_suspend(surf_action_t action);
 static void action_resume(surf_action_t action);
@@ -52,20 +51,20 @@ static void replace_str(char *str, const char *orig, const char *rep)
   str = xbt_strdup(buffer);
 }
 
-static void replace_bdw_ns3(char * bdw)
+static void replace_bdw_ns3(char ** bdw)
 {
-	char *temp = xbt_strdup(bdw);
-	xbt_free(bdw);
-	bdw = bprintf("%fBps",atof(temp));
+	char *temp = xbt_strdup(*bdw);
+	xbt_free(*bdw);
+	*bdw = bprintf("%fBps",atof(temp));
 	xbt_free(temp);
 
 }
 
-static void replace_lat_ns3(char * lat)
+static void replace_lat_ns3(char ** lat)
 {
-	char *temp = xbt_strdup(lat);
-	xbt_free(lat);
-	lat = bprintf("%fs",atof(temp));
+	char *temp = xbt_strdup(*lat);
+	xbt_free(*lat);
+	*lat = bprintf("%fs",atof(temp));
 	xbt_free(temp);
 }
 
@@ -80,8 +79,7 @@ void parse_ns3_add_host(void)
 }
 
 static void ns3_free_dynar(void * elmts){
-	if(elmts)
-		free(elmts);
+	free(elmts);
 	return;
 }
 
@@ -89,7 +87,7 @@ void parse_ns3_add_link(void)
 {
 	XBT_DEBUG("NS3_ADD_LINK '%s'",A_surfxml_link_id);
 
-	if(!IPV4addr) IPV4addr = xbt_dynar_new(MAX_LENGHT_IPV4*sizeof(char),ns3_free_dynar);
+	if(!IPV4addr) IPV4addr = xbt_dynar_new(sizeof(char*),ns3_free_dynar);
 
 	tmgr_trace_t bw_trace;
 	tmgr_trace_t state_trace;
@@ -202,8 +200,8 @@ void parse_ns3_add_cluster(void)
 	int elmts;
 	char * lat = xbt_strdup(cluster_lat);
 	char * bw =  xbt_strdup(cluster_bw);
-	replace_lat_ns3(lat);
-	replace_bdw_ns3(bw);
+	replace_lat_ns3(&lat);
+	replace_bdw_ns3(&bw);
 
 	xbt_dynar_foreach(tab_elements_num,cpt,elmts)
 	{
@@ -217,7 +215,9 @@ void parse_ns3_add_cluster(void)
 		if(host_src && host_dst){}
 		else xbt_die("\tns3_add_link from %d to %d",host_src->node_num,host_dst->node_num);
 
-		ns3_add_link(host_src->node_num,host_dst->node_num,bw,lat);
+		ns3_add_link(host_src->node_num,host_src->type,
+					 host_dst->node_num,host_dst->type,
+					 bw,lat);
 
 		free(router_id);
 		free(host_id);
@@ -228,8 +228,8 @@ void parse_ns3_add_cluster(void)
 	//Create link backbone
 	lat = xbt_strdup(cluster_bb_lat);
 	bw =  xbt_strdup(cluster_bb_bw);
-	replace_lat_ns3(lat);
-	replace_bdw_ns3(bw);
+	replace_lat_ns3(&lat);
+	replace_bdw_ns3(&bw);
 	ns3_add_cluster(bw,lat,A_surfxml_cluster_id);
 	xbt_free(lat);
 	xbt_free(bw);	
@@ -282,10 +282,10 @@ void create_ns3_topology()
 
      if( strcmp(src,dst) && ((surf_ns3_link_t)link)->created){
      XBT_DEBUG("Route from '%s' to '%s' with link '%s'",src,dst,((surf_ns3_link_t)link)->data->id);
-     char * link_bdw = bprintf("%s",((surf_ns3_link_t)link)->data->bdw);
-	 char * link_lat = bprintf("%s",(((surf_ns3_link_t)link)->data->lat));
- 	 replace_lat_ns3(link_lat);
- 	 replace_bdw_ns3(link_bdw);
+     char * link_bdw = xbt_strdup(((surf_ns3_link_t)link)->data->bdw);
+	 char * link_lat = xbt_strdup(((surf_ns3_link_t)link)->data->lat);
+ 	 replace_lat_ns3(&link_lat);
+ 	 replace_bdw_ns3(&link_bdw);
 	 ((surf_ns3_link_t)link)->created = 0;
 
 	 //	 XBT_DEBUG("src (%s), dst (%s), src_id = %d, dst_id = %d",src,dst, src_id, dst_id);
@@ -303,7 +303,7 @@ void create_ns3_topology()
      if(host_src && host_dst){}
      else xbt_die("\tns3_add_link from %d to %d",host_src->node_num,host_dst->node_num);
 
-     ns3_add_link(host_src->node_num,host_dst->node_num,link_bdw,link_lat);
+     ns3_add_link(host_src->node_num,host_src->type,host_dst->node_num,host_dst->type,link_bdw,link_lat);
 
      xbt_free(link_bdw);
      xbt_free(link_lat);
@@ -311,7 +311,7 @@ void create_ns3_topology()
    }
 }
 
-static void define_callbacks_ns3(const char *filename)
+static void define_callbacks_ns3(void)
 {
   surfxml_add_callback(STag_surfxml_host_cb_list, &parse_ns3_add_host);	      //HOST
   surfxml_add_callback(STag_surfxml_router_cb_list, &parse_ns3_add_router);	  //ROUTER
@@ -323,10 +323,6 @@ static void define_callbacks_ns3(const char *filename)
   surfxml_add_callback(ETag_surfxml_platform_cb_list, &parse_ns3_end_platform); //InitializeRoutes
 }
 
-static void free_ns3_elmts(void * elmts)
-{
-}
-
 static void free_ns3_link(void * elmts)
 {
 	ns3_link_t link = elmts;
@@ -349,7 +345,14 @@ static int ns3_get_link_latency_limited(surf_action_t action)
 }
 #endif
 
-void surf_network_model_init_NS3(const char *filename)
+#ifdef HAVE_TRACING
+static void ns3_action_set_category(surf_action_t action, const char *category)
+{
+  action->category = xbt_strdup (category);
+}
+#endif
+
+void surf_network_model_init_NS3()
 {
 	if (surf_network_model)
 		return;
@@ -368,15 +371,20 @@ void surf_network_model_init_NS3(const char *filename)
 	surf_network_model->resume = action_resume;
 	surf_network_model->is_suspended = action_is_suspended;
 	surf_network_model->action_unref = action_unref;
-	surf_network_model->extension.network.communicate = communicate;
+	surf_network_model->extension.network.communicate = ns3_communicate;
+
+#ifdef HAVE_TRACING
+  surf_network_model->set_category = ns3_action_set_category;
+#endif
 
 	/* Added the initialization for NS3 interface */
-	if (ns3_initialize()) {
+
+	if (ns3_initialize(xbt_cfg_get_string(_surf_cfg_set,"ns3/TcpModel"))) {
 	xbt_die("Impossible to initialize NS3 interface");
 	}
 
 	routing_model_create(sizeof(s_surf_ns3_link_t), NULL, NULL);
-	define_callbacks_ns3(filename);
+	define_callbacks_ns3();
 
 	NS3_HOST_LEVEL = xbt_lib_add_level(host_lib,(void_f_pvoid_t)free_ns3_host);
 	NS3_ASR_LEVEL  = xbt_lib_add_level(as_router_lib,(void_f_pvoid_t)free_ns3_host);
@@ -395,6 +403,7 @@ static void finalize(void)
 {
 	ns3_finalize();
 	xbt_dynar_free_container(&IPV4addr);
+	xbt_dict_free(&dict_socket);
 }
 
 static double ns3_share_resources(double min)
@@ -405,20 +414,19 @@ static double ns3_share_resources(double min)
 	  surf_network_model->states.running_action_set;
 
 	//get the first relevant value from the running_actions list
-	if (!xbt_swag_size(running_actions))
-	return -1.0;
-
-	ns3_simulator(min);
-	time_to_next_flow_completion = ns3_time() - surf_get_clock();
-
-//	XBT_INFO("min       : %f",min);
-//	XBT_INFO("ns3  time : %f",ns3_time());
-//	XBT_INFO("surf time : %f",surf_get_clock());
+	if (!xbt_swag_size(running_actions) || min == 0.0)
+	  return -1.0;
+	else
+	 do {
+	   ns3_simulator(min);
+	   time_to_next_flow_completion = ns3_time() - surf_get_clock();
+	 } while(double_equals(time_to_next_flow_completion,0));
+
+	XBT_DEBUG("min       : %f",min);
+	XBT_DEBUG("ns3  time : %f",ns3_time());
+	XBT_DEBUG("surf time : %f",surf_get_clock());
+	XBT_DEBUG("Next completion %f :",time_to_next_flow_completion);
 
-	xbt_assert(time_to_next_flow_completion,
-			  "Time to next flow completion not initialized!\n");
-
-	XBT_DEBUG("ns3_share_resources return %f",time_to_next_flow_completion);
 	return time_to_next_flow_completion;
 }
 
@@ -428,36 +436,83 @@ static void ns3_update_actions_state(double now, double delta)
 	  char *key;
 	  void *data;
 
-	  surf_action_t action = NULL;
+	  static xbt_dynar_t socket_to_destroy = NULL;
+    if(!socket_to_destroy) socket_to_destroy = xbt_dynar_new(sizeof(char*),NULL);
+
+	  surf_action_network_ns3_t action = NULL;
 	  xbt_swag_t running_actions =
 	      surf_network_model->states.running_action_set;
 
 	  /* If there are no running flows, just return */
-	  if (!xbt_swag_size(running_actions))
-	  	return;
+	  if (!xbt_swag_size(running_actions)) {
+	    while(double_positive(now-ns3_time())) {
+	      ns3_simulator(now-ns3_time());
+	    }
+	    return;
+	  }
 
 	  xbt_dict_foreach(dict_socket,cursor,key,data){
-		action = (surf_action_t)ns3_get_socket_action(data);
-		action->remains = ns3_get_socket_remains(data);
-		if(ns3_get_socket_is_finished(data) == 1){
-			action->finish = now;
-			surf_action_state_set(action, SURF_ACTION_DONE);
-		}
+	    action = (surf_action_network_ns3_t)ns3_get_socket_action(data);
+	    XBT_DEBUG("Processing socket %p (action %p)",data,action);
+	    action->generic_action.remains = action->generic_action.cost - ns3_get_socket_sent(data);
+
+#ifdef HAVE_TRACING
+	    if (TRACE_is_enabled() &&
+	        surf_action_state_get(&(action->generic_action)) == SURF_ACTION_RUNNING){
+	      double data_sent = ns3_get_socket_sent(data);
+	      double data_delta_sent = data_sent - action->last_sent;
+
+	      xbt_dynar_t route = global_routing->get_route(action->src_name, action->dst_name);
+	      unsigned int i;
+	      for (i = 0; i < xbt_dynar_length (route); i++){
+	        surf_ns3_link_t *link = ((surf_ns3_link_t*)xbt_dynar_get_ptr (route, i));
+	        TRACE_surf_link_set_utilization ((*link)->generic_resource.name,
+	            action->generic_action.data,
+	            (surf_action_t) action,
+	            (data_delta_sent)/delta,
+	            now-delta,
+	            delta);
+	      }
+	      action->last_sent = data_sent;
+	    }
+#endif
+
+	    if(ns3_get_socket_is_finished(data) == 1){
+	      xbt_dynar_push(socket_to_destroy,&key);
+	      XBT_DEBUG("Destroy socket %p of action %p", key, action);
+	      action->generic_action.finish = now;
+	      surf_action_state_set(&(action->generic_action), SURF_ACTION_DONE);
+	    }
+	  }
+
+	  while (!xbt_dynar_is_empty(socket_to_destroy)){
+	    xbt_dynar_pop(socket_to_destroy,&key);
+
+	    void *data = xbt_dict_get (dict_socket, key);
+	    surf_action_network_ns3_t action = (surf_action_network_ns3_t)ns3_get_socket_action(data);
+	    XBT_DEBUG ("Removing socket %p of action %p", key, action);
+	    xbt_dict_remove(dict_socket,key);
 	  }
 	  return;
 }
 
 /* Max durations are not supported */
-static surf_action_t communicate(const char *src_name,
+static surf_action_t ns3_communicate(const char *src_name,
                                  const char *dst_name, double size, double rate)
 {
-  surf_action_t action = NULL;
+  surf_action_network_ns3_t action = NULL;
 
   XBT_DEBUG("Communicate from %s to %s",src_name,dst_name);
-  action = surf_action_new(sizeof(s_surf_action_t), size, surf_network_model, 0);
+  action = surf_action_new(sizeof(s_surf_action_network_ns3_t), size, surf_network_model, 0);
 
   ns3_create_flow(src_name, dst_name, surf_get_clock(), size, action);
 
+#ifdef HAVE_TRACING
+  action->last_sent = 0;
+  action->src_name = xbt_strdup (src_name);
+  action->dst_name = xbt_strdup (dst_name);
+#endif
+
   return (surf_action_t) action;
 }
 
@@ -484,6 +539,13 @@ static int action_unref(surf_action_t action)
   action->refcount--;
   if (!action->refcount) {
     xbt_swag_remove(action, action->state_set);
+
+#ifdef HAVE_TRACING
+    xbt_free(((surf_action_network_ns3_t)action)->src_name);
+    xbt_free(((surf_action_network_ns3_t)action)->dst_name);
+    xbt_free(action->category);
+#endif
+    XBT_DEBUG ("Removing action %p", action);
     surf_action_free(&action);
     return 1;
   }