Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[NS3, trace] instrumentation code to register resource utilization from NS3
[simgrid.git] / src / surf / network_ns3.c
index 50cf119..16df513 100644 (file)
@@ -17,7 +17,24 @@ 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;
+
+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 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);
+static int action_is_suspended(surf_action_t action);
+static int action_unref(surf_action_t action);
+
+xbt_dynar_t IPV4addr;
 
 static void replace_str(char *str, const char *orig, const char *rep)
 {
@@ -39,7 +56,7 @@ static void replace_bdw_ns3(char * bdw)
 {
        char *temp = xbt_strdup(bdw);
        xbt_free(bdw);
-       bdw = bprintf("%fbps",atof(temp));
+       bdw = bprintf("%fBps",atof(temp));
        xbt_free(temp);
 
 }
@@ -61,10 +78,19 @@ void parse_ns3_add_host(void)
                                ns3_add_host(A_surfxml_host_id)
                                );
 }
+
+static void ns3_free_dynar(void * elmts){
+       if(elmts)
+               free(elmts);
+       return;
+}
+
 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);
+
        tmgr_trace_t bw_trace;
        tmgr_trace_t state_trace;
        tmgr_trace_t lat_trace;
@@ -171,8 +197,6 @@ void parse_ns3_add_cluster(void)
                }
        }
 
-
-
        //Create links
        unsigned int cpt;
        int elmts;
@@ -234,44 +258,20 @@ static xbt_dynar_t ns3_get_route(const char *src, const char *dst)
 void parse_ns3_end_platform(void)
 {
        ns3_end_platform();
-
-         xbt_lib_cursor_t cursor = NULL;
-         char *name = NULL;
-         void **data = NULL;
-         XBT_DEBUG("link_lib");
-         xbt_lib_foreach(link_lib, cursor, name, data) {
-                       XBT_DEBUG("\tSee link '%s'\t--> NS3_LEVEL %p",
-                                       name,
-                                       data[NS3_LINK_LEVEL]);
-         }
-         XBT_DEBUG(" ");
-         XBT_DEBUG("host_lib");
-         xbt_lib_foreach(host_lib, cursor, name, data) {
-                       XBT_DEBUG("\tSee host '%s'\t--> NS3_LEVEL %p",
-                                       name,
-                                       data[NS3_HOST_LEVEL]);
-         }
-         XBT_DEBUG(" ");
-         XBT_DEBUG("as_router_lib");
-         xbt_lib_foreach(as_router_lib, cursor, name, data) {
-                       XBT_DEBUG("\tSee ASR '%s'\t--> NS3_LEVEL %p",
-                                       name,
-                                       data[NS3_ASR_LEVEL]);
-         }
-
-         XBT_DEBUG(" ");
 }
 
 /* Create the ns3 topology based on routing strategy */
 void create_ns3_topology()
 {
-   XBT_INFO("Starting topology generation");
+   XBT_DEBUG("Starting topology generation");
+
+   xbt_dynar_shrink(IPV4addr,0);
 
    //get the onelinks from the parsed platform
    xbt_dynar_t onelink_routes = global_routing->get_onelink_routes();
    if (!onelink_routes)
      xbt_die("There is no routes!");
-   XBT_INFO("Have get_onelink_routes, found %ld routes",onelink_routes->used);
+   XBT_DEBUG("Have get_onelink_routes, found %ld routes",onelink_routes->used);
    //save them in trace file
    onelink_t onelink;
    unsigned int iter;
@@ -281,17 +281,17 @@ void create_ns3_topology()
      void *link = onelink->link_ptr;
 
      if( strcmp(src,dst) && ((surf_ns3_link_t)link)->created){
-     XBT_INFO("Route from '%s' to '%s' with link '%s'",src,dst,((surf_ns3_link_t)link)->data->id);
-     char * link_bdw = xbt_strdup(((surf_ns3_link_t)link)->data->bdw);
-        char * link_lat = xbt_strdup(((surf_ns3_link_t)link)->data->lat);
+     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);
         ((surf_ns3_link_t)link)->created = 0;
 
-        replace_bdw_ns3(link_bdw);
-        replace_lat_ns3(link_lat);
-//      XBT_INFO("src (%s), dst (%s), src_id = %d, dst_id = %d",src,dst, src_id, dst_id);
-     XBT_INFO("\tLink (%s) bdw:%s->%s lat:%s->%s",((surf_ns3_link_t)link)->data->id,
-                ((surf_ns3_link_t)link)->data->bdw,link_bdw,
-                ((surf_ns3_link_t)link)->data->lat,link_lat
+        //      XBT_DEBUG("src (%s), dst (%s), src_id = %d, dst_id = %d",src,dst, src_id, dst_id);
+     XBT_DEBUG("\tLink (%s) bdw:%s lat:%s",((surf_ns3_link_t)link)->data->id,
+                link_bdw,
+                link_lat
                 );
 
      //create link ns3
@@ -342,13 +342,39 @@ static void free_ns3_host(void * elmts)
        free(host);
 }
 
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+static int ns3_get_link_latency_limited(surf_action_t action)
+{
+  return 0;
+}
+#endif
+
 void surf_network_model_init_NS3(const char *filename)
 {
+       if (surf_network_model)
+               return;
+
        surf_network_model = surf_model_init();
        surf_network_model->name = "network NS3";
        surf_network_model->extension.network.get_link_latency = ns3_get_link_latency;
        surf_network_model->extension.network.get_link_bandwidth = ns3_get_link_bandwidth;
        surf_network_model->extension.network.get_route = ns3_get_route;
+
+       surf_network_model->model_private->share_resources = ns3_share_resources;
+       surf_network_model->model_private->update_actions_state = ns3_update_actions_state;
+       surf_network_model->model_private->finalize = finalize;
+
+       surf_network_model->suspend = action_suspend;
+       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 = ns3_communicate;
+
+       /* Added the initialization for NS3 interface */
+       if (ns3_initialize()) {
+       xbt_die("Impossible to initialize NS3 interface");
+       }
+
        routing_model_create(sizeof(s_surf_ns3_link_t), NULL, NULL);
        define_callbacks_ns3(filename);
 
@@ -356,6 +382,146 @@ void surf_network_model_init_NS3(const char *filename)
        NS3_ASR_LEVEL  = xbt_lib_add_level(as_router_lib,(void_f_pvoid_t)free_ns3_host);
        NS3_LINK_LEVEL = xbt_lib_add_level(link_lib,(void_f_pvoid_t)free_ns3_link);
 
+       xbt_dynar_push(model_list, &surf_network_model);
        update_model_description(surf_network_model_description,
                    "NS3", surf_network_model);
+
+#ifdef HAVE_LATENCY_BOUND_TRACKING
+       surf_network_model->get_latency_limited = ns3_get_link_latency_limited;
+#endif
+}
+
+static void finalize(void)
+{
+       ns3_finalize();
+       xbt_dynar_free_container(&IPV4addr);
+}
+
+static double ns3_share_resources(double min)
+{
+       XBT_DEBUG("ns3_share_resources");
+
+       xbt_swag_t running_actions =
+         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());
+
+       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;
+}
+
+static void ns3_update_actions_state(double now, double delta)
+{
+         xbt_dict_cursor_t cursor = NULL;
+         char *key;
+         void *data;
+
+         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;
+
+         xbt_dict_foreach(dict_socket,cursor,key,data){
+           action = (surf_action_network_ns3_t)ns3_get_socket_action(data);
+           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),
+                   now-delta,
+                   delta);
+             }
+             action->last_sent = data_sent;
+           }
+#endif
+
+           if(ns3_get_socket_is_finished(data) == 1){
+             action->generic_action.finish = now;
+             surf_action_state_set(&(action->generic_action), SURF_ACTION_DONE);
+           }
+         }
+         return;
+}
+
+/* Max durations are not supported */
+static surf_action_t ns3_communicate(const char *src_name,
+                                 const char *dst_name, double size, double rate)
+{
+  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_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;
+}
+
+/* Suspend a flow() */
+static void action_suspend(surf_action_t action)
+{
+  THROW_UNIMPLEMENTED;
+}
+
+/* Resume a flow() */
+static void action_resume(surf_action_t action)
+{
+  THROW_UNIMPLEMENTED;
+}
+
+/* Test whether a flow is suspended */
+static int action_is_suspended(surf_action_t action)
+{
+  return 0;
+}
+
+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);
+    if (action->category)
+      xbt_free(action->category);
+#endif
+
+    surf_action_free(&action);
+    return 1;
+  }
+  return 0;
 }