* 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"
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 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);
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);
}
}
static void ns3_free_dynar(void * elmts){
- if(elmts)
- free(elmts);
+ free(elmts);
return;
}
{
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;
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)
{
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);
//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);
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);
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);
}
}
-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
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;
}
#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;
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);
{
ns3_finalize();
xbt_dynar_free_container(&IPV4addr);
+ xbt_dict_free(&dict_socket);
}
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;
}
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;
}
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;
}
