X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/75e8415d3b5fbec784b77b485da05ccbd0256d93..74214a6669ee21beba3e799a78b95f4e56c3b692:/src/surf/surf_routing.c diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c index 83e08a1def..a0b74ee2ae 100644 --- a/src/surf/surf_routing.c +++ b/src/surf/surf_routing.c @@ -1,10 +1,17 @@ -/* Copyright (c) 2009, 2010. The SimGrid Team. +/* Copyright (c) 2009, 2010. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ + + #include +#include "gras_config.h" + +#ifdef HAVE_PCRE_LIB + #include /* regular expresion library */ +#endif #include "surf_private.h" #include "xbt/dynar.h" #include "xbt/str.h" @@ -37,17 +44,25 @@ static void model_dijkstra_both_load(void); /* load parse functions for dijks static void model_dijkstra_both_unload(void); /* unload parse functions for dijkstra routing model */ static void model_dijkstra_both_end(void); /* finalize the creation of dijkstra routing model */ +static void* model_rulebased_create(void); /* create structures for rulebased routing model */ +static void model_rulebased_load(void); /* load parse functions for rulebased routing model */ +static void model_rulebased_unload(void); /* unload parse functions for rulebased routing model */ +static void model_rulebased_end(void); /* finalize the creation of rulebased routing model */ + static void* model_none_create(void); /* none routing model */ static void model_none_load(void); /* none routing model */ static void model_none_unload(void); /* none routing model */ static void model_none_end(void); /* none routing model */ +static void routing_full_parse_Scluster(void);/*cluster bypass*/ + /* this lines are olny for replace use like index in the model table */ #define SURF_MODEL_FULL 0 #define SURF_MODEL_FLOYD 1 #define SURF_MODEL_DIJKSTRA 2 #define SURF_MODEL_DIJKSTRACACHE 3 -#define SURF_MODEL_NONE 4 +#define SURF_MODEL_RULEBASED 4 +#define SURF_MODEL_NONE 5 /* must be finish with null and carefull if change de order */ struct s_model_type routing_models[] = @@ -59,6 +74,8 @@ struct s_model_type routing_models[] = model_dijkstra_create ,model_dijkstra_both_load, model_dijkstra_both_unload, model_dijkstra_both_end }, {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", model_dijkstracache_create, model_dijkstra_both_load, model_dijkstra_both_unload, model_dijkstra_both_end }, + {"RuleBased", "Rule-Based routing data (...)", + model_rulebased_create, model_rulebased_load, model_rulebased_unload, model_rulebased_end }, {"none", "No routing (usable with Constant network only)", model_none_create, model_none_load, model_none_unload, model_none_end }, {NULL,NULL,NULL,NULL,NULL,NULL}}; @@ -66,7 +83,7 @@ struct s_model_type routing_models[] = /* ************************************************************************** */ /* ***************** GENERIC PARSE FUNCTIONS (declarations) ***************** */ -static void generic_set_processing_units(routing_component_t rc, const char* name); +static void generic_set_processing_unit(routing_component_t rc, const char* name); static void generic_set_autonomous_system(routing_component_t rc, const char* name); static void generic_set_route(routing_component_t rc, const char* src, const char* dst, route_t route); static void generic_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route); @@ -75,12 +92,15 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con /* ************************************************************************** */ /* *************** GENERIC BUSINESS METHODS (declarations) ****************** */ +static xbt_dynar_t generic_get_onelink_routes (routing_component_t rc); +static int generic_is_router (const char *name); static route_extended_t generic_get_bypassroute(routing_component_t rc, const char* src, const char* dst); /* ************************************************************************** */ /* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */ static route_extended_t generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy, void* data, int order); +static void generic_free_route(route_t route); static void generic_free_extended_route(route_extended_t e_route); static routing_component_t generic_autonomous_system_exist(routing_component_t rc, char* element); static routing_component_t generic_processing_units_exist(routing_component_t rc, char* element); @@ -99,16 +119,35 @@ static xbt_dynar_t link_list = NULL; /* temporary store of current list link of /** * \brief Add a "host" to the network element list */ -static void parse_S_host(void) { +static void parse_S_host(char* host_id) { if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_BASE; - xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,A_surfxml_host_id), - "Reading a host, processing unit \"%s\" already exist",A_surfxml_host_id); - xbt_assert1(current_routing->set_processing_units, - "no defined method \"set_processing_units\" in \"%s\"",current_routing->name); - (*(current_routing->set_processing_units))(current_routing,A_surfxml_host_id); - xbt_dict_set(global_routing->where_network_elements,A_surfxml_host_id,(void*)current_routing,NULL); + xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,host_id), + "Reading a host, processing unit \"%s\" already exist",host_id); + xbt_assert1(current_routing->set_processing_unit, + "no defined method \"set_processing_unit\" in \"%s\"",current_routing->name); + (*(current_routing->set_processing_unit))(current_routing,host_id); + xbt_dict_set(global_routing->where_network_elements,host_id,(void*)current_routing,NULL); +} + +/* + * \brief Add a host to the network element list from XML + */ +static void parse_S_host_XML(void) +{ + parse_S_host(A_surfxml_host_id); } +/* + * \brief Add a host to the network element list from lua script + */ +static void parse_S_host_lua(char *host_id) +{ + parse_S_host(host_id); +} +/* + * + */ + /** * \brief Add a "router" to the network element list */ @@ -116,25 +155,44 @@ static void parse_S_router(void) { if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_BASE; xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,A_surfxml_router_id), "Reading a router, processing unit \"%s\" already exist",A_surfxml_router_id); - xbt_assert1(current_routing->set_processing_units, - "no defined method \"set_processing_units\" in \"%s\"",current_routing->name); - (*(current_routing->set_processing_units))(current_routing,A_surfxml_router_id); + xbt_assert1(current_routing->set_processing_unit, + "no defined method \"set_processing_unit\" in \"%s\"",current_routing->name); + (*(current_routing->set_processing_unit))(current_routing,A_surfxml_router_id); xbt_dict_set(global_routing->where_network_elements,A_surfxml_router_id,(void*)current_routing,NULL); + #ifdef HAVE_TRACING + TRACE_surf_host_declaration (A_surfxml_router_id, 0); + #endif } /** * \brief Set the endponints for a route */ -static void parse_S_route_new_and_endpoints(void) { +static void parse_S_route_new_and_endpoints(char *src_id,char *dst_id) { if( src != NULL && dst != NULL && link_list != NULL ) - THROW2(arg_error,0,"Route between %s to %s can not be defined",A_surfxml_route_src,A_surfxml_route_dst); - src = A_surfxml_route_src; - dst = A_surfxml_route_dst; + THROW2(arg_error,0,"Route between %s to %s can not be defined",src_id,dst_id); + src = src_id; + dst = dst_id; xbt_assert2(strlen(src)>0||strlen(dst)>0, "Some limits are null in the route between \"%s\" and \"%s\"",src,dst); link_list = xbt_dynar_new(sizeof(char*), &xbt_free_ref); } +/** + * \breif Set the endpoints for a route from XML + */ +static void parse_S_route_new_and_endpoints_XML(void) +{ + parse_S_route_new_and_endpoints(A_surfxml_route_src,A_surfxml_route_dst); +} + +/** + * \breif Set the endpoints for a route from lua + */ +static void parse_S_route_new_and_endpoints_lua(char *id_src,char *id_dst) +{ + parse_S_route_new_and_endpoints(id_src,id_dst); +} + /** * \brief Set the endponints and gateways for a ASroute */ @@ -168,21 +226,38 @@ static void parse_S_bypassRoute_new_and_endpoints(void) { /** * \brief Set a new link on the actual list of link for a route or ASroute */ -static void parse_E_link_c_ctn_new_elem(void) { +static void parse_E_link_ctn_new_elem(char *link_id) { char *val; - val = xbt_strdup(A_surfxml_link_c_ctn_id); + val = xbt_strdup(link_id); xbt_dynar_push(link_list, &val); } +/** + * \brief Set a new link on the actual list of link for a route or ASroute from XML + */ + +static void parse_E_link_ctn_new_elem_XML(void) +{ + parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id); +} + +/** + * \brief Set a new link on the actual list of link for a route or ASroute from lua + */ +static void parse_E_link_c_ctn_new_elem_lua(char *link_id) { + + parse_E_link_ctn_new_elem(link_id); +} + /** * \brief Store the route by calling the set_route function of the current routing component */ static void parse_E_route_store_route(void) { route_t route = xbt_new0(s_route_t,1); route->link_list = link_list; - xbt_assert1(generic_processing_units_exist(current_routing,src),"the \"%s\" processing units gateway does not exist",src); - xbt_assert1(generic_processing_units_exist(current_routing,dst),"the \"%s\" processing units gateway does not exist",dst); - xbt_assert1(current_routing->set_route,"no defined method \"set_route\" in \"%s\"",current_routing->name); +// xbt_assert1(generic_processing_units_exist(current_routing,src),"the \"%s\" processing units gateway does not exist",src); +// xbt_assert1(generic_processing_units_exist(current_routing,dst),"the \"%s\" processing units gateway does not exist",dst); + xbt_assert1(current_routing->set_route,"no defined method \"set_route\" in \"%s\"",current_routing->name); (*(current_routing->set_route))(current_routing,src,dst,route); link_list = NULL; src = NULL; @@ -196,11 +271,11 @@ static void parse_E_ASroute_store_route(void) { route_extended_t e_route = xbt_new0(s_route_extended_t,1); e_route->generic_route.link_list = link_list; e_route->src_gateway = xbt_strdup(gw_src); - e_route->dst_gateway = xbt_strdup(gw_dst); - xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src); - xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst); - xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src); - xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst); + e_route->dst_gateway = xbt_strdup(gw_dst); +// xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src); +// xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst); +// xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src); +// xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst); xbt_assert1(current_routing->set_ASroute,"no defined method \"set_ASroute\" in \"%s\"",current_routing->name); (*(current_routing->set_ASroute))(current_routing,src,dst,e_route); link_list = NULL; @@ -218,10 +293,10 @@ static void parse_E_bypassRoute_store_route(void) { e_route->generic_route.link_list = link_list; e_route->src_gateway = xbt_strdup(gw_src); e_route->dst_gateway = xbt_strdup(gw_dst); - xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src); - xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst); - xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src); - xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst); +// xbt_assert1(generic_autonomous_system_exist(current_routing,src),"the \"%s\" autonomous system does not exist",src); +// xbt_assert1(generic_autonomous_system_exist(current_routing,dst),"the \"%s\" autonomous system does not exist",dst); +// xbt_assert1(generic_processing_units_exist(current_routing,gw_src),"the \"%s\" processing units gateway does not exist",gw_src); +// xbt_assert1(generic_processing_units_exist(current_routing,gw_dst),"the \"%s\" processing units gateway does not exist",gw_dst); xbt_assert1(current_routing->set_bypassroute,"no defined method \"set_bypassroute\" in \"%s\"",current_routing->name); (*(current_routing->set_bypassroute))(current_routing,src,dst,e_route); link_list = NULL; @@ -234,13 +309,13 @@ static void parse_E_bypassRoute_store_route(void) { /** * \brief Make a new routing component * - * Detect the routing model type of the routing component, make the new structure and + * make the new structure and * set the parsing functions to allows parsing the part of the routing tree */ -static void parse_S_AS(void) { +static void parse_S_AS(char* AS_id,char* AS_routing) { routing_component_t new_routing; model_type_t model = NULL; - char* wanted = A_surfxml_AS_routing; + char* wanted = AS_routing; int cpt; /* seach the routing model */ for (cpt=0;routing_models[cpt].name;cpt++) @@ -259,9 +334,9 @@ static void parse_S_AS(void) { new_routing = (routing_component_t)(*(model->create))(); new_routing->routing = model; new_routing->hierarchy = SURF_ROUTING_NULL; - new_routing->name = xbt_strdup(A_surfxml_AS_id); + new_routing->name = xbt_strdup(AS_id); new_routing->routing_sons = xbt_dict_new(); - INFO2("Routing %s for AS %s",A_surfxml_AS_routing,A_surfxml_AS_id); + //INFO2("Routing %s for AS %s",A_surfxml_AS_routing,A_surfxml_AS_id); if( current_routing == NULL && global_routing->root == NULL ){ @@ -271,16 +346,16 @@ static void parse_S_AS(void) { } else if( current_routing != NULL && global_routing->root != NULL ) { - xbt_assert1(!xbt_dict_get_or_null(current_routing->routing_sons,A_surfxml_AS_id), - "The AS \"%s\" already exist",A_surfxml_AS_id); + xbt_assert1(!xbt_dict_get_or_null(current_routing->routing_sons,AS_id), + "The AS \"%s\" already exist",AS_id); /* it is a part of the tree */ new_routing->routing_father = current_routing; /* set the father behavior */ if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_RECURSIVE; /* add to the sons dictionary */ - xbt_dict_set(current_routing->routing_sons,A_surfxml_AS_id,(void*)new_routing,NULL); + xbt_dict_set(current_routing->routing_sons,AS_id,(void*)new_routing,NULL); /* add to the father element list */ - (*(current_routing->set_autonomous_system))(current_routing,A_surfxml_AS_id); + (*(current_routing->set_autonomous_system))(current_routing,AS_id); /* unload the prev parse rules */ (*(current_routing->routing->unload))(); @@ -293,16 +368,33 @@ static void parse_S_AS(void) { current_routing = new_routing; } +/* + * Detect the routing model type of the routing component from XML platforms + */ +static void parse_S_AS_XML(void) +{ + parse_S_AS(A_surfxml_AS_id,A_surfxml_AS_routing); +} + +/* + * define the routing model type of routing component from lua script + */ +static void parse_S_AS_lua(char* id,char* mode) +{ + parse_S_AS(id,mode); +} + + /** * \brief Finish the creation of a new routing component * * When you finish to read the routing component, other structures must be created. * the "end" method allow to do that for any routing model type */ -static void parse_E_AS(void) { +static void parse_E_AS(char *AS_id) { if( current_routing == NULL ) { - THROW1(arg_error,0,"Close AS(%s), that never open",A_surfxml_AS_id); + THROW1(arg_error,0,"Close AS(%s), that never open",AS_id); } else { xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,current_routing->name), "The AS \"%s\" already exist",current_routing->name); @@ -315,6 +407,22 @@ static void parse_E_AS(void) { } } +/* + * \brief Finish the creation of a new routing component from XML + */ +static void parse_E_AS_XML(void) +{ + parse_E_AS(A_surfxml_AS_id); +} + +/* + * \brief Finish the creation of a new routing component from lua + */ +static void parse_E_AS_lua(char *id) +{ + parse_E_AS(id); +} + /* Aux Business methods */ /** @@ -416,7 +524,7 @@ static route_extended_t _get_route(const char* src,const char* dst) { xbt_assert0(src&&dst,"bad parameters for \"_get_route\" method"); - route_extended_t e_route, e_route_cnt, e_route_src, e_route_dst; + route_extended_t e_route, e_route_cnt, e_route_src=NULL, e_route_dst=NULL; xbt_dynar_t elem_father_list = elements_father(src,dst); @@ -437,13 +545,15 @@ static route_extended_t _get_route(const char* src,const char* dst) { xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) { xbt_dynar_push(e_route->generic_route.link_list,&link); } - xbt_dynar_free( &(e_route_cnt->generic_route.link_list) ); - xbt_free(e_route_cnt); + generic_free_extended_route(e_route_cnt); } } else { /* SURF_ROUTING_RECURSIVE */ - route_extended_t e_route_bypass = (*(common_father->get_bypass_route))(common_father,src,dst); + route_extended_t e_route_bypass = NULL; + + if(common_father->get_bypass_route) + e_route_bypass = (*(common_father->get_bypass_route))(common_father,src,dst); if(e_route_bypass) e_route_cnt = e_route_bypass; @@ -475,15 +585,12 @@ static route_extended_t _get_route(const char* src,const char* dst) { } } - e_route->src_gateway = e_route_cnt->src_gateway; - e_route->dst_gateway = e_route_cnt->dst_gateway; - - xbt_dynar_free( &(e_route_src->generic_route.link_list) ); - xbt_free(e_route_src); - xbt_dynar_free( &(e_route_cnt->generic_route.link_list) ); - xbt_free(e_route_cnt); - xbt_dynar_free( &(e_route_dst->generic_route.link_list) ); - xbt_free(e_route_dst); + e_route->src_gateway = xbt_strdup(e_route_cnt->src_gateway); + e_route->dst_gateway = xbt_strdup(e_route_cnt->dst_gateway); + + generic_free_extended_route(e_route_src); + generic_free_extended_route(e_route_cnt); + generic_free_extended_route(e_route_dst); } xbt_dynar_free(&elem_father_list); @@ -502,8 +609,6 @@ static route_extended_t _get_route(const char* src,const char* dst) { */ static xbt_dynar_t get_route(const char* src,const char* dst) { - if(global_routing->last_route) xbt_dynar_free( &(global_routing->last_route) ); - route_extended_t e_route; xbt_dynar_t elem_father_list = elements_father(src,dst); routing_component_t common_father = xbt_dynar_get_as(elem_father_list, 0, routing_component_t); @@ -514,8 +619,13 @@ static xbt_dynar_t get_route(const char* src,const char* dst) { e_route = (*(common_father->get_route))(common_father,src,dst); xbt_assert2(e_route,"no route between \"%s\" and \"%s\"",src,dst); + + if(global_routing->last_route) xbt_dynar_free( &(global_routing->last_route) ); global_routing->last_route = e_route->generic_route.link_list; + if(e_route->src_gateway) xbt_free(e_route->src_gateway); + if(e_route->dst_gateway) xbt_free(e_route->dst_gateway); + xbt_free(e_route); xbt_dynar_free(&elem_father_list); @@ -567,6 +677,45 @@ static void finalize(void) { xbt_free(global_routing); } +static xbt_dynar_t recursive_get_onelink_routes (routing_component_t rc) +{ + xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free); + + //adding my one link routes + unsigned int cpt; + void *link; + xbt_dynar_t onelink_mine = rc->get_onelink_routes (rc); + if (onelink_mine){ + xbt_dynar_foreach(onelink_mine, cpt, link) { + xbt_dynar_push(ret,&link); + } + } + + //recursing + char *key; + xbt_dict_cursor_t cursor=NULL; + routing_component_t rc_child; + xbt_dict_foreach(rc->routing_sons, cursor, key, rc_child) { + xbt_dynar_t onelink_child = recursive_get_onelink_routes (rc_child);//->get_onelink_routes (rc_child); + if (onelink_child){ + xbt_dynar_foreach(onelink_child, cpt, link) { + xbt_dynar_push(ret,&link); + } + } + } + return ret; +} + +static xbt_dynar_t get_onelink_routes(void) +{ + return recursive_get_onelink_routes (global_routing->root); +} + +static int is_router(const char *name) +{ + xbt_die("global \"is_router\" function not implemented yet"); +} + /** * \brief Generic method: create the global routing schema * @@ -579,6 +728,8 @@ void routing_model_create(size_t size_of_links, void* loopback) { global_routing->where_network_elements = xbt_dict_new(); global_routing->root = NULL; global_routing->get_route = get_route; + global_routing->get_onelink_routes = get_onelink_routes; + global_routing->is_router = is_router; global_routing->finalize = finalize; global_routing->loopback = loopback; global_routing->size_of_link = size_of_links; @@ -588,21 +739,24 @@ void routing_model_create(size_t size_of_links, void* loopback) { current_routing = NULL; /* parse generic elements */ - surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host); + surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML); surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router); - surfxml_add_callback(STag_surfxml_route_cb_list, &parse_S_route_new_and_endpoints); + surfxml_add_callback(STag_surfxml_route_cb_list, &parse_S_route_new_and_endpoints_XML); surfxml_add_callback(STag_surfxml_ASroute_cb_list, &parse_S_ASroute_new_and_endpoints); surfxml_add_callback(STag_surfxml_bypassRoute_cb_list, &parse_S_bypassRoute_new_and_endpoints); - surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_E_link_c_ctn_new_elem); + surfxml_add_callback(ETag_surfxml_link_ctn_cb_list, &parse_E_link_ctn_new_elem_XML); surfxml_add_callback(ETag_surfxml_route_cb_list, &parse_E_route_store_route); surfxml_add_callback(ETag_surfxml_ASroute_cb_list, &parse_E_ASroute_store_route); surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list, &parse_E_bypassRoute_store_route); - surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS); - surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS); + surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS_XML); + surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML); + + surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_full_parse_Scluster); + } /* ************************************************************************** */ @@ -621,6 +775,40 @@ typedef struct { } s_routing_component_full_t,*routing_component_full_t; /* Business methods */ +static xbt_dynar_t full_get_onelink_routes(routing_component_t rc) +{ + xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free); + + routing_component_full_t routing = (routing_component_full_t)rc; + int table_size = xbt_dict_length(routing->to_index); + xbt_dict_cursor_t c1 = NULL, c2 = NULL; + char *k1, *d1, *k2, *d2; + xbt_dict_foreach(routing->to_index, c1, k1, d1) { + xbt_dict_foreach (routing->to_index, c2, k2, d2) { + int *src_id = xbt_dict_get_or_null(routing->to_index, k1); + int *dst_id = xbt_dict_get_or_null(routing->to_index, k2); + xbt_assert2(src_id && dst_id, "Ask for route \"from\"(%s) or \"to\"(%s) no found in the local table",src,dst); + route_extended_t route = TO_ROUTE_FULL(*src_id,*dst_id); + if (route){ + if (xbt_dynar_length(route->generic_route.link_list) == 1){ + void *link = *(void**)xbt_dynar_get_ptr(route->generic_route.link_list,0); + + onelink_t onelink = xbt_new0 (s_onelink_t, 1); + onelink->src = xbt_strdup (k1); + onelink->dst = xbt_strdup (k2); + onelink->link_ptr = link; + xbt_dynar_push (ret, &onelink); + } + } + } + } + return ret; +} + +static int full_is_router(const char *name) +{ + xbt_die("\"full_is_router\" function not implemented yet"); +} static route_extended_t full_get_route(routing_component_t rc, const char* src,const char* dst) { xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name); @@ -643,8 +831,8 @@ static route_extended_t full_get_route(routing_component_t rc, const char* src,c if(e_route) { new_e_route = xbt_new0(s_route_extended_t,1); - new_e_route->src_gateway = e_route->src_gateway; - new_e_route->dst_gateway = e_route->dst_gateway; + new_e_route->src_gateway = xbt_strdup(e_route->src_gateway); + new_e_route->dst_gateway = xbt_strdup(e_route->dst_gateway); new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL); xbt_dynar_foreach(e_route->generic_route.link_list, cpt, link) { xbt_dynar_push(new_e_route->generic_route.link_list,&link); @@ -676,12 +864,14 @@ static void full_finalize(routing_component_t rc) { static void* model_full_create(void) { routing_component_full_t new_component = xbt_new0(s_routing_component_full_t,1); - new_component->generic_routing.set_processing_units = generic_set_processing_units; + new_component->generic_routing.set_processing_unit = generic_set_processing_unit; new_component->generic_routing.set_autonomous_system = generic_set_autonomous_system; new_component->generic_routing.set_route = generic_set_route; new_component->generic_routing.set_ASroute = generic_set_ASroute; new_component->generic_routing.set_bypassroute = generic_set_bypassroute; new_component->generic_routing.get_route = full_get_route; + new_component->generic_routing.get_onelink_routes = full_get_onelink_routes; + new_component->generic_routing.is_router = full_is_router; new_component->generic_routing.get_bypass_route = generic_get_bypassroute; new_component->generic_routing.finalize = full_finalize; new_component->to_index = xbt_dict_new(); @@ -780,6 +970,15 @@ typedef struct { } s_routing_component_floyd_t,*routing_component_floyd_t; /* Business methods */ +static xbt_dynar_t floyd_get_onelink_routes(routing_component_t rc) +{ + xbt_die("\"floyd_get_onelink_routes\" function not implemented yet"); +} + +static int floyd_is_router(const char *name) +{ + xbt_die("\"floyd_is_router\" function not implemented yet"); +} static route_extended_t floyd_get_route(routing_component_t rc, const char* src,const char* dst) { xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name); @@ -802,7 +1001,7 @@ static route_extended_t floyd_get_route(routing_component_t rc, const char* src, int first = 1; int pred = *dst_id; int prev_pred = 0; - char *gw_src,*gw_dst, *prev_gw_src,*prev_gw_dst, *first_gw; + char *gw_src=NULL,*gw_dst=NULL, *prev_gw_src,*prev_gw_dst, *first_gw=NULL; unsigned int cpt; void* link; xbt_dynar_t links; @@ -844,8 +1043,8 @@ static route_extended_t floyd_get_route(routing_component_t rc, const char* src, xbt_assert4(pred != -1, "no route from host %d to %d (\"%s\" to \"%s\")", *src_id, *dst_id,src,dst); if(rc->hierarchy == SURF_ROUTING_RECURSIVE) { - new_e_route->src_gateway = gw_src; - new_e_route->dst_gateway = first_gw; + new_e_route->src_gateway = xbt_strdup(gw_src); + new_e_route->dst_gateway = xbt_strdup(first_gw); } return new_e_route; @@ -874,12 +1073,14 @@ static void floyd_finalize(routing_component_t rc) { static void* model_floyd_create(void) { routing_component_floyd_t new_component = xbt_new0(s_routing_component_floyd_t,1); - new_component->generic_routing.set_processing_units = generic_set_processing_units; + new_component->generic_routing.set_processing_unit = generic_set_processing_unit; new_component->generic_routing.set_autonomous_system = generic_set_autonomous_system; new_component->generic_routing.set_route = generic_set_route; new_component->generic_routing.set_ASroute = generic_set_ASroute; new_component->generic_routing.set_bypassroute = generic_set_bypassroute; new_component->generic_routing.get_route = floyd_get_route; + new_component->generic_routing.get_onelink_routes = floyd_get_onelink_routes; + new_component->generic_routing.is_router = floyd_is_router; new_component->generic_routing.get_bypass_route = generic_get_bypassroute; new_component->generic_routing.finalize = floyd_finalize; new_component->to_index = xbt_dict_new(); @@ -1128,6 +1329,15 @@ static void add_loopback_dijkstra(routing_component_dijkstra_t rc) { } /* Business methods */ +static xbt_dynar_t dijkstra_get_onelink_routes(routing_component_t rc) +{ + xbt_die("\"dijkstra_get_onelink_routes\" function not implemented yet"); +} + +static int dijkstra_is_router(const char *name) +{ + xbt_die("\"dijkstra_is_router\" function not implemented yet"); +} static route_extended_t dijkstra_get_route(routing_component_t rc, const char* src,const char* dst) { xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name); @@ -1252,7 +1462,7 @@ static route_extended_t dijkstra_get_route(routing_component_t rc, const char* s } /* compose route path with links */ - char *gw_src,*gw_dst, *prev_gw_src,*prev_gw_dst, *first_gw; + char *gw_src=NULL,*gw_dst=NULL, *prev_gw_src,*prev_gw_dst, *first_gw=NULL; for(v = dst_node_id; v != src_node_id; v = pred_arr[v]) { xbt_node_t node_pred_v = xbt_dynar_get_as(nodes, pred_arr[v], xbt_node_t); @@ -1289,8 +1499,8 @@ static route_extended_t dijkstra_get_route(routing_component_t rc, const char* s } if(rc->hierarchy == SURF_ROUTING_RECURSIVE) { - new_e_route->src_gateway = gw_src; - new_e_route->dst_gateway = first_gw; + new_e_route->src_gateway = xbt_strdup(gw_src); + new_e_route->dst_gateway = xbt_strdup(first_gw); } if(routing->cached && elm == NULL) { @@ -1328,12 +1538,14 @@ static void dijkstra_finalize(routing_component_t rc) { static void* model_dijkstra_both_create(int cached) { routing_component_dijkstra_t new_component = xbt_new0(s_routing_component_dijkstra_t,1); - new_component->generic_routing.set_processing_units = generic_set_processing_units; + new_component->generic_routing.set_processing_unit = generic_set_processing_unit; new_component->generic_routing.set_autonomous_system = generic_set_autonomous_system; new_component->generic_routing.set_route = generic_set_route; new_component->generic_routing.set_ASroute = generic_set_ASroute; new_component->generic_routing.set_bypassroute = generic_set_bypassroute; new_component->generic_routing.get_route = dijkstra_get_route; + new_component->generic_routing.get_onelink_routes = dijkstra_get_onelink_routes; + new_component->generic_routing.is_router = dijkstra_is_router; new_component->generic_routing.get_bypass_route = generic_get_bypassroute; new_component->generic_routing.finalize = dijkstra_finalize; new_component->cached = cached; @@ -1412,6 +1624,306 @@ static void model_dijkstra_both_end(void) { } +/* ************************************************** */ +/* ************** RULE-BASED ROUTING **************** */ + +/* Routing model structure */ + +typedef struct { + s_routing_component_t generic_routing; + xbt_dict_t dict_processing_units; + xbt_dict_t dict_autonomous_systems; + xbt_dynar_t list_route; + xbt_dynar_t list_ASroute; +} s_routing_component_rulebased_t,*routing_component_rulebased_t; + +typedef struct s_rule_route s_rule_route_t, *rule_route_t; +typedef struct s_rule_route_extended s_rule_route_extended_t, *rule_route_extended_t; + +struct s_rule_route { + xbt_dynar_t re_str_link; // dynar of char* + pcre* re_src; + pcre* re_dst; +}; + +struct s_rule_route_extended { + s_rule_route_t generic_rule_route; + char* re_src_gateway; + char* re_dst_gateway; +}; + +static void rule_route_free(void *e) { + rule_route_t* elem = (rule_route_t*)(e); + if (*elem) { + xbt_dynar_free(&(*elem)->re_str_link); + pcre_free((*elem)->re_src); + pcre_free((*elem)->re_dst); + xbt_free((*elem)); + } + (*elem) = NULL; +} + +static void rule_route_extended_free(void *e) { + rule_route_extended_t* elem = (rule_route_extended_t*)e; + if (*elem) { + xbt_dynar_free(&(*elem)->generic_rule_route.re_str_link); + pcre_free((*elem)->generic_rule_route.re_src); + pcre_free((*elem)->generic_rule_route.re_dst); + xbt_free((*elem)->re_src_gateway); + xbt_free((*elem)->re_dst_gateway); + xbt_free((*elem)); + } +} + +/* Parse routing model functions */ + +static void model_rulebased_set_processing_unit(routing_component_t rc, const char* name) { + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + xbt_dict_set(routing->dict_processing_units, name, (void*)(-1), NULL); +} + +static void model_rulebased_set_autonomous_system(routing_component_t rc, const char* name) { + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + xbt_dict_set(routing->dict_autonomous_systems, name, (void*)(-1), NULL); +} + +static void model_rulebased_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) { + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + rule_route_t ruleroute = xbt_new0(s_rule_route_t,1); + const char *error; + int erroffset; + ruleroute->re_src = pcre_compile(src,0,&error,&erroffset,NULL); + xbt_assert3(ruleroute->re_src,"PCRE compilation failed at offset %d (\"%s\"): %s\n", erroffset, src, error); + ruleroute->re_dst = pcre_compile(dst,0,&error,&erroffset,NULL); + xbt_assert3(ruleroute->re_src,"PCRE compilation failed at offset %d (\"%s\"): %s\n", erroffset, dst, error); + ruleroute->re_str_link = route->link_list; + xbt_dynar_push(routing->list_route,&ruleroute); + xbt_free(route); +} + +static void model_rulebased_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) { + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + rule_route_extended_t ruleroute_e = xbt_new0(s_rule_route_extended_t,1); + const char *error; + int erroffset; + ruleroute_e->generic_rule_route.re_src = pcre_compile(src,0,&error,&erroffset,NULL); + xbt_assert3(ruleroute_e->generic_rule_route.re_src,"PCRE compilation failed at offset %d (\"%s\"): %s\n", erroffset, src, error); + ruleroute_e->generic_rule_route.re_dst = pcre_compile(dst,0,&error,&erroffset,NULL); + xbt_assert3(ruleroute_e->generic_rule_route.re_src,"PCRE compilation failed at offset %d (\"%s\"): %s\n", erroffset, dst, error); + ruleroute_e->generic_rule_route.re_str_link = route->generic_route.link_list; + ruleroute_e->re_src_gateway = route->src_gateway; + ruleroute_e->re_dst_gateway = route->dst_gateway; + xbt_dynar_push(routing->list_ASroute,&ruleroute_e); + xbt_free(route->src_gateway); + xbt_free(route->dst_gateway); + xbt_free(route); +} + +static void model_rulebased_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) { + xbt_die("bypass routing not supported for Route-Based model"); +} + +#define BUFFER_SIZE 4096 /* result buffer size */ +#define OVECCOUNT 30 /* should be a multiple of 3 */ + +static char* remplace(char* value, const char** src_list, int src_size, const char** dst_list, int dst_size ) { + + char result_result[BUFFER_SIZE]; + int i_result_buffer; + int value_length = (int)strlen(value); + int number=0; + + int i=0; + i_result_buffer = 0; + do { + if( value[i] == '$' ) { + i++; // skip $ + + // find the number + int number_length = 0; + while( '0' <= value[i+number_length] && value[i+number_length] <= '9' ) { + number_length++; + } + xbt_assert2( number_length!=0, "bad string parameter, no number indication, at offset: %d (\"%s\")",i,value); + + // solve number + number = atoi(value+i); + i=i+number_length; + xbt_assert2(i+2= number, "bad string parameter, not enough length param_size, at offset: %d (\"%s\") %d %d",i,value,param_size,number); + + const char* param = param_list[number]; + int size = strlen(param); + int cp; + for(cp = 0; cp < size; cp++ ) { + result_result[i_result_buffer] = param[cp]; + i_result_buffer++; + if( i_result_buffer >= BUFFER_SIZE ) break; + } + } else { + result_result[i_result_buffer] = value[i]; + i_result_buffer++; + i++; // next char + } + + } while(iname); + + /* set utils vars */ + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + + int are_processing_units; + xbt_dynar_t rule_list; + if( xbt_dict_get_or_null(routing->dict_processing_units,src) && xbt_dict_get_or_null(routing->dict_processing_units,dst) ) { + are_processing_units = 1; + rule_list = routing->list_route; + } else if( xbt_dict_get_or_null(routing->dict_autonomous_systems,src) && xbt_dict_get_or_null(routing->dict_autonomous_systems,dst) ) { + are_processing_units = 0; + rule_list = routing->list_ASroute; + } else + xbt_assert2(NULL, "Ask for route \"from\"(%s) or \"to\"(%s) no found in the local table",src,dst); + + int rc_src = -1; + int rc_dst = -1; + int src_length = (int)strlen(src); + int dst_length = (int)strlen(dst); + + xbt_dynar_t links_list = xbt_dynar_new(global_routing->size_of_link,NULL); + + rule_route_t ruleroute; + unsigned int cpt; + int ovector_src[OVECCOUNT]; + int ovector_dst[OVECCOUNT]; + const char** list_src = NULL; + const char** list_dst = NULL; + xbt_dynar_foreach(rule_list, cpt, ruleroute) { + rc_src = pcre_exec(ruleroute->re_src,NULL,src,src_length,0,0,ovector_src,OVECCOUNT); + if( rc_src >= 0 ) { + rc_dst = pcre_exec(ruleroute->re_dst,NULL,dst,dst_length,0,0,ovector_dst,OVECCOUNT); + if( rc_dst >= 0 ) { + xbt_assert1(!pcre_get_substring_list(src,ovector_src,rc_src,&list_src),"error solving substring list for src \"%s\"",src); + xbt_assert1(!pcre_get_substring_list(dst,ovector_dst,rc_dst,&list_dst),"error solving substring list for src \"%s\"",dst); + char* link_name; + xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) { + char* new_link_name = remplace(link_name,list_src,rc_src,list_dst,rc_dst); + void* link = xbt_dict_get_or_null(surf_network_model->resource_set, new_link_name); + if (link) + xbt_dynar_push(links_list,&link); + else + THROW1(mismatch_error,0,"Link %s not found", new_link_name); + xbt_free(new_link_name); + } + } + } + if( rc_src >= 0 && rc_dst >= 0 ) break; + } + + route_extended_t new_e_route = NULL; + if(rc_src >= 0 && rc_dst >= 0) { + new_e_route = xbt_new0(s_route_extended_t,1); + new_e_route->generic_route.link_list = links_list; + } else if( !strcmp(src,dst) && are_processing_units ) { + new_e_route = xbt_new0(s_route_extended_t,1); + xbt_dynar_push(links_list,&(global_routing->loopback)); + new_e_route->generic_route.link_list = links_list; + } else { + xbt_dynar_free(&link_list); + } + + if(!are_processing_units && new_e_route) + { + rule_route_extended_t ruleroute_extended = (rule_route_extended_t)ruleroute; + new_e_route->src_gateway = remplace(ruleroute_extended->re_src_gateway,list_src,rc_src,list_dst,rc_dst); + new_e_route->dst_gateway = remplace(ruleroute_extended->re_dst_gateway,list_src,rc_src,list_dst,rc_dst); + } + + if(list_src) pcre_free_substring_list(list_src); + if(list_dst) pcre_free_substring_list(list_dst); + + return new_e_route; +} + +static route_extended_t rulebased_get_bypass_route(routing_component_t rc, const char* src,const char* dst) { + return NULL; +} + +static void rulebased_finalize(routing_component_t rc) { + routing_component_rulebased_t routing = (routing_component_rulebased_t) rc; + if (routing) { + xbt_dict_free(&routing->dict_processing_units); + xbt_dict_free(&routing->dict_autonomous_systems); + xbt_dynar_free(&routing->list_route); + xbt_dynar_free(&routing->list_ASroute); + /* Delete structure */ + xbt_free(routing); + } +} + +/* Creation routing model functions */ +static void* model_rulebased_create(void) { + routing_component_rulebased_t new_component = xbt_new0(s_routing_component_rulebased_t,1); + new_component->generic_routing.set_processing_unit = model_rulebased_set_processing_unit; + new_component->generic_routing.set_autonomous_system = model_rulebased_set_autonomous_system; + new_component->generic_routing.set_route = model_rulebased_set_route; + new_component->generic_routing.set_ASroute = model_rulebased_set_ASroute; + new_component->generic_routing.set_bypassroute = model_rulebased_set_bypassroute; + new_component->generic_routing.get_onelink_routes = rulebased_get_onelink_routes; + new_component->generic_routing.is_router = rulebased_is_router; + new_component->generic_routing.get_route = rulebased_get_route; + new_component->generic_routing.get_bypass_route = NULL; //rulebased_get_bypass_route; + new_component->generic_routing.finalize = rulebased_finalize; + /* initialization of internal structures */ + new_component->dict_processing_units = xbt_dict_new(); + new_component->dict_autonomous_systems = xbt_dict_new(); + new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free); + new_component->list_ASroute = xbt_dynar_new(sizeof(rule_route_extended_t), &rule_route_extended_free); + return new_component; +} + +static void model_rulebased_load(void) { + /* use "surfxml_add_callback" to add a parse function call */ +} + +static void model_rulebased_unload(void) { + /* use "surfxml_del_callback" to remove a parse function call */ +} + +static void model_rulebased_end(void) { +} + /* ************************************************************************** */ /* ******************************* NO ROUTING ******************************* */ @@ -1421,6 +1933,12 @@ typedef struct { } s_routing_component_none_t,*routing_component_none_t; /* Business methods */ +static xbt_dynar_t none_get_onelink_routes(routing_component_t rc){ + return NULL; +} +static int none_is_router(const char *name){ + return -1; +} static route_extended_t none_get_route(routing_component_t rc, const char* src,const char* dst){ return NULL; } @@ -1431,18 +1949,20 @@ static void none_finalize(routing_component_t rc) { xbt_free(rc); } -static void none_set_processing_units(routing_component_t rc, const char* name) {} +static void none_set_processing_unit(routing_component_t rc, const char* name) {} static void none_set_autonomous_system(routing_component_t rc, const char* name) {} /* Creation routing model functions */ static void* model_none_create(void) { routing_component_none_t new_component = xbt_new0(s_routing_component_none_t,1); - new_component->generic_routing.set_processing_units = none_set_processing_units; + new_component->generic_routing.set_processing_unit = none_set_processing_unit; new_component->generic_routing.set_autonomous_system = none_set_autonomous_system; new_component->generic_routing.set_route = NULL; new_component->generic_routing.set_ASroute = NULL; new_component->generic_routing.set_bypassroute = NULL; new_component->generic_routing.get_route = none_get_route; + new_component->generic_routing.get_onelink_routes = none_get_onelink_routes; + new_component->generic_routing.is_router = none_is_router; new_component->generic_routing.get_bypass_route = none_get_bypass_route; new_component->generic_routing.finalize = none_finalize; return new_component; @@ -1460,45 +1980,45 @@ static void model_none_end(void) {} * list. Remember keep the null ending of the list. */ /*** Routing model structure ***/ -typedef struct { - s_routing_component_t generic_routing; - /* things that your routing model need */ -} s_routing_component_NEW_t,*routing_component_NEW_t; +// typedef struct { +// s_routing_component_t generic_routing; +// /* things that your routing model need */ +// } s_routing_component_NEW_t,*routing_component_NEW_t; /*** Parse routing model functions ***/ -static void model_NEW_set_processing_units(routing_component_t rc, const char* name) {} -static void model_NEW_set_autonomous_system(routing_component_t rc, const char* name) {} -static void model_NEW_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {} -static void model_NEW_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) {} -static void model_NEW_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {} +// static void model_NEW_set_processing_unit(routing_component_t rc, const char* name) {} +// static void model_NEW_set_autonomous_system(routing_component_t rc, const char* name) {} +// static void model_NEW_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {} +// static void model_NEW_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) {} +// static void model_NEW_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {} /*** Business methods ***/ -static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} -static route_extended_t NEW_get_bypass_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} -static void NEW_finalize(routing_component_t rc) {} +// static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} +// static route_extended_t NEW_get_bypass_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} +// static void NEW_finalize(routing_component_t rc) { xbt_free(rc);} /*** Creation routing model functions ***/ -static void* model_NEW_create(void) { - routing_component_full_t new_component = xbt_new0(s_routing_component_full_t,1); - new_component->generic_routing.set_processing_units = model_NEW_set_processing_units; - new_component->generic_routing.set_autonomous_system = model_NEW_set_autonomous_system; - new_component->generic_routing.set_route = model_NEW_set_route; - new_component->generic_routing.set_ASroute = model_NEW_set_ASroute; - new_component->generic_routing.set_bypassroute = model_NEW_set_bypassroute; - new_component->generic_routing.get_route = NEW_get_route; - new_component->generic_routing.get_bypass_route = NEW_get_bypass_route; - new_component->generic_routing.finalize = NEW_finalize; - /* initialization of internal structures */ - return new_component; -} /* mandatory */ -static void model_NEW_load(void) {} /* mandatory */ -static void model_NEW_unload(void) {} /* mandatory */ -static void model_NEW_end(void) {} /* mandatory */ +// static void* model_NEW_create(void) { +// routing_component_NEW_t new_component = xbt_new0(s_routing_component_NEW_t,1); +// new_component->generic_routing.set_processing_unit = model_NEW_set_processing_unit; +// new_component->generic_routing.set_autonomous_system = model_NEW_set_autonomous_system; +// new_component->generic_routing.set_route = model_NEW_set_route; +// new_component->generic_routing.set_ASroute = model_NEW_set_ASroute; +// new_component->generic_routing.set_bypassroute = model_NEW_set_bypassroute; +// new_component->generic_routing.get_route = NEW_get_route; +// new_component->generic_routing.get_bypass_route = NEW_get_bypass_route; +// new_component->generic_routing.finalize = NEW_finalize; +// /* initialization of internal structures */ +// return new_component; +// } /* mandatory */ +// static void model_NEW_load(void) {} /* mandatory */ +// static void model_NEW_unload(void) {} /* mandatory */ +// static void model_NEW_end(void) {} /* mandatory */ /* ************************************************************************** */ /* ************************* GENERIC PARSE FUNCTIONS ************************ */ -static void generic_set_processing_units(routing_component_t rc, const char* name) { +static void generic_set_processing_unit(routing_component_t rc, const char* name) { DEBUG1("Load process unit \"%s\"",name); model_type_t modeltype = rc->routing; int *id = xbt_new0(int,1); @@ -1513,7 +2033,7 @@ static void generic_set_processing_units(routing_component_t rc, const char* nam modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) _to_index = ((routing_component_dijkstra_t)rc)->to_index; - else xbt_die("\"generic_set_processing_units\" not support"); + else xbt_die("\"generic_set_processing_unit\" not supported"); *id = xbt_dict_length(_to_index); xbt_dict_set(_to_index,name,id,xbt_free); } @@ -1533,7 +2053,7 @@ static void generic_set_autonomous_system(routing_component_t rc, const char* na modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) _to_index = ((routing_component_dijkstra_t)rc)->to_index; - else xbt_die("\"generic_set_autonomous_system\" not support"); + else xbt_die("\"generic_set_autonomous_system\" not supported"); *id = xbt_dict_length(_to_index); xbt_dict_set(_to_index,name,id,xbt_free); } @@ -1559,7 +2079,7 @@ static void generic_set_route(routing_component_t rc, const char* src, const cha _parse_routes = ((routing_component_dijkstra_t)rc)->parse_routes; _to_index = ((routing_component_dijkstra_t)rc)->to_index; - } else xbt_die("\"generic_set_route\" not support"); + } else xbt_die("\"generic_set_route\" not supported"); src_id = xbt_dict_get_or_null(_to_index, src); dst_id = xbt_dict_get_or_null(_to_index, dst); @@ -1596,7 +2116,7 @@ static void generic_set_ASroute(routing_component_t rc, const char* src, const c _parse_routes = ((routing_component_dijkstra_t)rc)->parse_routes; _to_index = ((routing_component_dijkstra_t)rc)->to_index; - } else xbt_die("\"generic_set_route\" not support"); + } else xbt_die("\"generic_set_route\" not supported"); src_id = xbt_dict_get_or_null(_to_index, src); dst_id = xbt_dict_get_or_null(_to_index, dst); @@ -1624,7 +2144,7 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con } else if(modeltype==&routing_models[SURF_MODEL_DIJKSTRA]|| modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) { dict_bypassRoutes = ((routing_component_dijkstra_t)rc)->bypassRoutes; - } else xbt_die("\"generic_set_bypassroute\" not support"); + } else xbt_die("\"generic_set_bypassroute\" not supported"); route_name = bprintf("%s#%s",src,dst); xbt_assert2(xbt_dynar_length(e_route->generic_route.link_list)>0, "Invalid count of links, must be greater than zero (%s,%s)",src,dst); xbt_assert4(!xbt_dict_get_or_null(dict_bypassRoutes,route_name), @@ -1641,6 +2161,16 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con /* ************************************************************************** */ /* *********************** GENERIC BUSINESS METHODS ************************* */ +static xbt_dynar_t generic_get_onelink_routes (routing_component_t rc) +{ + xbt_die("\"generic_get_onelink_routes\" not implemented yet"); +} + +static int generic_is_router (const char *name) +{ + xbt_die("\"generic_is_router\" not implemented yet"); +} + static route_extended_t generic_get_bypassroute(routing_component_t rc, const char* src, const char* dst) { model_type_t modeltype = rc->routing; xbt_dict_t dict_bypassRoutes; @@ -1652,7 +2182,7 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc, const ch } else if(modeltype==&routing_models[SURF_MODEL_DIJKSTRA]|| modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) { dict_bypassRoutes = ((routing_component_dijkstra_t)rc)->bypassRoutes; - } else xbt_die("\"generic_set_bypassroute\" not support"); + } else xbt_die("\"generic_get_bypassroute\" not supported"); routing_component_t src_as, dst_as; @@ -1710,19 +2240,19 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc, const ch for(i=0;iname, - (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,max)))->name); - e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); - xbt_free(route_name); + char* route_name = bprintf("%s#%s", + (*(routing_component_t*)(xbt_dynar_get_ptr(path_src,i)))->name, + (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,max)))->name); + e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); + xbt_free(route_name); } if( e_route_bypass ) break; if( max <= max_index_src && i <= max_index_dst ) { - char* route_name = bprintf("%s#%s", - (*(routing_component_t*)(xbt_dynar_get_ptr(path_src,max)))->name, - (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,i)))->name); - e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); - xbt_free(route_name); + char* route_name = bprintf("%s#%s", + (*(routing_component_t*)(xbt_dynar_get_ptr(path_src,max)))->name, + (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,i)))->name); + e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); + xbt_free(route_name); } if( e_route_bypass ) break; } @@ -1730,12 +2260,12 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc, const ch if( e_route_bypass ) break; if( max <= max_index_src && max <= max_index_dst ) { - char* route_name = bprintf("%s#%s", - (*(routing_component_t*)(xbt_dynar_get_ptr(path_src,max)))->name, - (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,max)))->name); - e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); - xbt_free(route_name); - } + char* route_name = bprintf("%s#%s", + (*(routing_component_t*)(xbt_dynar_get_ptr(path_src,max)))->name, + (*(routing_component_t*)(xbt_dynar_get_ptr(path_dst,max)))->name); + e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes,route_name); + xbt_free(route_name); + } if( e_route_bypass ) break; } @@ -1748,8 +2278,8 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc, const ch void* link; unsigned int cpt=0; new_e_route = xbt_new0(s_route_extended_t,1); - new_e_route->src_gateway = e_route_bypass->src_gateway; - new_e_route->dst_gateway = e_route_bypass->dst_gateway; + new_e_route->src_gateway = xbt_strdup(e_route_bypass->src_gateway); + new_e_route->dst_gateway = xbt_strdup(e_route_bypass->dst_gateway); new_e_route->generic_route.link_list = xbt_dynar_new(global_routing->size_of_link,NULL); xbt_dynar_foreach(e_route_bypass->generic_route.link_list, cpt, link) { xbt_dynar_push(new_e_route->generic_route.link_list,&link); @@ -1813,6 +2343,13 @@ static route_extended_t generic_new_extended_route(e_surf_routing_hierarchy_t hi return new_e_route; } +static void generic_free_route(route_t route) { + if(route) { + xbt_dynar_free(&(route->link_list)); + xbt_free(route); + } +} + static void generic_free_extended_route(route_extended_t e_route) { if(e_route) { xbt_dynar_free(&(e_route->generic_route.link_list)); @@ -1823,6 +2360,7 @@ static void generic_free_extended_route(route_extended_t e_route) { } static routing_component_t generic_as_exist(routing_component_t find_from, routing_component_t to_find) { + //return to_find; // FIXME: BYPASSERROR OF FOREACH WITH BREAK xbt_dict_cursor_t cursor = NULL; char *key; int found=0; @@ -1838,6 +2376,7 @@ static routing_component_t generic_as_exist(routing_component_t find_from, routi } static routing_component_t generic_autonomous_system_exist(routing_component_t rc, char* element) { + //return rc; // FIXME: BYPASSERROR OF FOREACH WITH BREAK routing_component_t element_as, result, elem; xbt_dict_cursor_t cursor = NULL; char *key; @@ -1846,11 +2385,14 @@ static routing_component_t generic_autonomous_system_exist(routing_component_t r if(element_as!=rc) result = generic_as_exist(rc,element_as); + int found=0; if(result) { xbt_dict_foreach(element_as->routing_sons, cursor, key, elem) { - if( !strcmp(elem->name,element) ) return element_as; + found = !strcmp(elem->name,element); + if( found ) break; } + if( found ) return element_as; } return NULL; } @@ -1874,3 +2416,305 @@ static void generic_src_dst_check(routing_component_t rc, const char* src, const xbt_assert2(rc == dst_as, "The routing component of src and dst is not the same as the network elements belong (%s==%s)",rc->name,dst_as->name); } + +static void routing_full_parse_Scluster(void) +{ + static int AX_ptr = 0; + + char *cluster_id = A_surfxml_cluster_id; + char *cluster_prefix = A_surfxml_cluster_prefix; + char *cluster_suffix = A_surfxml_cluster_suffix; + char *cluster_radical = A_surfxml_cluster_radical; + char *cluster_power = A_surfxml_cluster_power; + char *cluster_bw = A_surfxml_cluster_bw; + char *cluster_lat = A_surfxml_cluster_lat; + char *cluster_bb_bw = A_surfxml_cluster_bb_bw; + char *cluster_bb_lat = A_surfxml_cluster_bb_lat; + char *host_id, *groups, *link_id; + char *router_id, *link_router, *link_backbone, *route_src_dst; + unsigned int iter; + int start, end, i; + xbt_dynar_t radical_elements; + xbt_dynar_t radical_ends; + #ifndef HAVE_PCRE_LIB + xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL); + char *route_src,*route_dst; + int j; + #endif + + static unsigned int surfxml_buffer_stack_stack_ptr = 1; + static unsigned int surfxml_buffer_stack_stack[1024]; + + surfxml_buffer_stack_stack[0]= 0; + + surfxml_bufferstack_push(1); + + SURFXML_BUFFER_SET(AS_id, cluster_id); +#ifdef HAVE_PCRE_LIB + SURFXML_BUFFER_SET(AS_routing, "RuleBased"); + DEBUG1("",cluster_id); +#else + SURFXML_BUFFER_SET(AS_routing, "Full"); + DEBUG1("",cluster_id); +#endif + SURFXML_START_TAG(AS); + + radical_elements = xbt_str_split(cluster_radical, ","); + xbt_dynar_foreach(radical_elements, iter, groups) + { + radical_ends = xbt_str_split(groups, "-"); + switch (xbt_dynar_length(radical_ends)) + { + case 1: + surf_parse_get_int(&start, xbt_dynar_get_as(radical_ends, 0, char *)); + host_id = bprintf("%s%d%s", cluster_prefix, start, cluster_suffix); + #ifndef HAVE_PCRE_LIB + xbt_dynar_push_as(tab_elements_num, int, start); + #endif + link_id = bprintf("%s_link_%d", cluster_id, start); + + DEBUG2("",host_id,cluster_power); + SURFXML_BUFFER_SET(host_id, host_id); + SURFXML_BUFFER_SET(host_power, cluster_power); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_availability_file, ""); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_state_file, ""); + SURFXML_BUFFER_SET(host_interference_send, "1.0"); + SURFXML_BUFFER_SET(host_interference_recv, "1.0"); + SURFXML_BUFFER_SET(host_interference_send_recv, "1.0"); + SURFXML_BUFFER_SET(host_max_outgoing_rate, "-1.0"); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); + + DEBUG3("",link_id,cluster_bw,cluster_lat); + SURFXML_BUFFER_SET(link_id, link_id); + SURFXML_BUFFER_SET(link_bandwidth, cluster_bw); + SURFXML_BUFFER_SET(link_latency, cluster_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + A_surfxml_link_state = A_surfxml_link_state_ON; + SURFXML_BUFFER_SET(link_state_file, ""); + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + + break; + + case 2: + + surf_parse_get_int(&start, xbt_dynar_get_as(radical_ends, 0, char *)); + surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *)); + DEBUG2("Create hosts and links from %d to %d",start,end); + for (i = start; i <= end; i++) + { + host_id = bprintf("%s%d%s", cluster_prefix, i, cluster_suffix); + #ifndef HAVE_PCRE_LIB + xbt_dynar_push_as(tab_elements_num, int, i); + #endif + link_id = bprintf("%s_link_%d", cluster_id, i); + + DEBUG2("",host_id,cluster_power); + SURFXML_BUFFER_SET(host_id, host_id); + SURFXML_BUFFER_SET(host_power, cluster_power); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_availability_file, ""); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_state_file, ""); + SURFXML_BUFFER_SET(host_interference_send, "1.0"); + SURFXML_BUFFER_SET(host_interference_recv, "1.0"); + SURFXML_BUFFER_SET(host_interference_send_recv, "1.0"); + SURFXML_BUFFER_SET(host_max_outgoing_rate, "-1.0"); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); + + DEBUG3("",link_id,cluster_bw,cluster_lat); + SURFXML_BUFFER_SET(link_id, link_id); + SURFXML_BUFFER_SET(link_bandwidth, cluster_bw); + SURFXML_BUFFER_SET(link_latency, cluster_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + A_surfxml_link_state = A_surfxml_link_state_ON; + SURFXML_BUFFER_SET(link_state_file, ""); + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + } + break; + + default: + DEBUG0("Malformed radical"); + } + + xbt_dynar_free(&radical_ends); + } + + DEBUG0(" "); + router_id = bprintf("%srouter%s",cluster_prefix,cluster_suffix); + link_router = bprintf("%s_link_router",cluster_id); + link_backbone = bprintf("%s_backbone",cluster_id); + + DEBUG1("",router_id); + SURFXML_BUFFER_SET(router_id, router_id);; + SURFXML_START_TAG(router); + SURFXML_END_TAG(router); + + DEBUG3("",link_router,cluster_bw,cluster_lat); + SURFXML_BUFFER_SET(link_id, link_router); + SURFXML_BUFFER_SET(link_bandwidth, cluster_bw); + SURFXML_BUFFER_SET(link_latency, cluster_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + A_surfxml_link_state = A_surfxml_link_state_ON; + SURFXML_BUFFER_SET(link_state_file, ""); + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + + DEBUG3("",link_backbone,cluster_bb_bw,cluster_bb_lat); + SURFXML_BUFFER_SET(link_id, link_backbone); + SURFXML_BUFFER_SET(link_bandwidth, cluster_bb_bw); + SURFXML_BUFFER_SET(link_latency, cluster_bb_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + A_surfxml_link_state = A_surfxml_link_state_ON; + SURFXML_BUFFER_SET(link_state_file, ""); + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + + char *new_suffix = bprintf("%s",""); + + radical_elements = xbt_str_split(cluster_suffix, "."); + xbt_dynar_foreach(radical_elements, iter, groups) + { + if(strcmp(groups,"")) + { + new_suffix = bprintf("%s\\.%s",new_suffix,groups); + } + } + route_src_dst = bprintf("%s(.*)%s",cluster_prefix,new_suffix); + + DEBUG0(" "); + +#ifdef HAVE_PCRE_LIB + + DEBUG2("",route_src_dst,route_src_dst); + SURFXML_BUFFER_SET(route_src, route_src_dst); + SURFXML_BUFFER_SET(route_dst, route_src_dst); + SURFXML_START_TAG(route); + + DEBUG1("",cluster_id); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1src",cluster_id)); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG1("",cluster_id); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone",cluster_id)); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG1("",cluster_id); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1dst",cluster_id)); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG0(""); + SURFXML_END_TAG(route); +#else + for(i=0 ; i<=tab_elements_num->elmsize ; i++) + { + for(j=0 ; j<=tab_elements_num->elmsize ; j++) + { + route_src = bprintf("%s%d%s",cluster_prefix,xbt_dynar_get_as(tab_elements_num,i,int),cluster_suffix); + route_dst = bprintf("%s%d%s",cluster_prefix,xbt_dynar_get_as(tab_elements_num,j,int),cluster_suffix); + + DEBUG2("",route_src,route_dst); + SURFXML_BUFFER_SET(route_src, route_src); + SURFXML_BUFFER_SET(route_dst, route_dst); + SURFXML_START_TAG(route); + + route_src = bprintf("%s_link_%d",cluster_id,xbt_dynar_get_as(tab_elements_num,i,int)); + route_dst = bprintf("%s_link_%d",cluster_id,xbt_dynar_get_as(tab_elements_num,j,int)); + + DEBUG2("",cluster_id,xbt_dynar_get_as(tab_elements_num,i,int)); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_%d",cluster_id,xbt_dynar_get_as(tab_elements_num,i,int))); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG1("",cluster_id); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone",cluster_id)); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG2("",cluster_id,xbt_dynar_get_as(tab_elements_num,j,int)); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_%d",cluster_id,xbt_dynar_get_as(tab_elements_num,j,int))); + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + DEBUG0(""); + SURFXML_END_TAG(route); + } + } + xbt_dynar_free(&tab_elements_num); +#endif + + DEBUG0(""); + SURFXML_END_TAG(AS); + DEBUG0(" "); + + surfxml_bufferstack_pop(1); +} + +/* + * New methods to init the routing model component from the lua script + */ + +/* + * calling parse_S_AS_lua with lua values + */ +void routing_AS_init(const char* AS_id,const char* AS_routing) +{ + parse_S_AS_lua((char*)AS_id,(char*)AS_routing); +} + +/* + * calling parse_E_AS_lua to fisnish the creation of routing component + */ +void routing_AS_end(const char *AS_id) +{ + parse_E_AS_lua((char*)AS_id); +} + +/* + * add a host to the network element list + */ + +void routing_add_host(const char* host_id) +{ + parse_S_host_lua((char*)host_id); +} + +/* + * Set a new link on the actual list of link for a route or ASroute + */ +void routing_add_link(const char* link_id) +{ + parse_E_link_c_ctn_new_elem_lua((char*)link_id); +} + +/* + *Set the endpoints for a route + */ +void routing_set_route(const char* src_id,const char *dst_id) +{ + parse_S_route_new_and_endpoints_lua((char*)src_id,(char*)dst_id); +} + +/* + * Store the route by calling parse_E_route_store_route + */ +void routing_store_route(void) +{ + parse_E_route_store_route(); +}