108
* \brief Add a "host_link" to the network element list
110
static void parse_S_host_link(sg_platf_host_link_cbarg_t host)
112
sg_routing_edge_t info = NULL;
113
info = xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL);
114
xbt_assert(info, "Host '%s' not found!",host->id);
115
xbt_assert(current_routing->model_desc == &routing_models[SURF_MODEL_CLUSTER] ||
116
current_routing->model_desc == &routing_models[SURF_MODEL_VIVALDI],
117
"You have to be in model Cluster to use tag host_link!");
119
s_surf_parsing_link_up_down_t link_up_down;
120
link_up_down.link_up = xbt_lib_get_or_null(link_lib, host->link_up, SURF_LINK_LEVEL);
121
link_up_down.link_down = xbt_lib_get_or_null(link_lib, host->link_down, SURF_LINK_LEVEL);
123
xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);
124
xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);
126
if(!current_routing->link_up_down_list)
127
current_routing->link_up_down_list = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
129
// If dynar is is greater than edge id and if the host_link is already defined
130
if(xbt_dynar_length(current_routing->link_up_down_list) > info->id &&
131
xbt_dynar_get_as(current_routing->link_up_down_list,info->id,void*))
132
xbt_die("Host_link for '%s' is already defined!",host->id);
134
XBT_DEBUG("Push Host_link for host '%s' to position %d",info->name,info->id);
135
xbt_dynar_set_as(current_routing->link_up_down_list,info->id,s_surf_parsing_link_up_down_t,link_up_down);
113
139
* \brief Add a "host" to the network element list
115
141
static void parse_S_host(sg_platf_host_cbarg_t host)
198
* \brief Set the end points for a route
200
static void routing_parse_S_route(void)
202
src = A_surfxml_route_src;
203
dst = A_surfxml_route_dst;
204
xbt_assert(strlen(src) > 0 || strlen(dst) > 0,
205
"Missing end-points while defining route \"%s\"->\"%s\"",
207
parsed_link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
211
* \brief Set the end points and gateways for a ASroute
213
static void routing_parse_S_ASroute(void)
215
src = A_surfxml_ASroute_src;
216
dst = A_surfxml_ASroute_dst;
217
gw_src = A_surfxml_ASroute_gw_src;
218
gw_dst = A_surfxml_ASroute_gw_dst;
219
xbt_assert(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0 || strlen(gw_dst) > 0,
220
"Missing end-points while defining route \"%s\"->\"%s\" (with %s and %s as gateways)",
221
src, dst,gw_src,gw_dst);
222
parsed_link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
226
* \brief Set the end points for a bypassRoute
228
static void routing_parse_S_bypassRoute(void)
230
src = A_surfxml_bypassRoute_src;
231
dst = A_surfxml_bypassRoute_dst;
234
xbt_assert(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0 || strlen(gw_dst) > 0,
235
"Missing end-points while defining route \"%s\"->\"%s\" (with %s and %s as gateways)",
236
src, dst,gw_src,gw_dst);
237
parsed_link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
241
* \brief Set the end points for a bypassASroute
243
static void routing_parse_S_bypassASroute(void)
245
src = A_surfxml_bypassASroute_src;
246
dst = A_surfxml_bypassASroute_dst;
247
gw_src = A_surfxml_bypassASroute_gw_src;
248
gw_dst = A_surfxml_bypassASroute_gw_dst;
249
xbt_assert(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0 || strlen(gw_dst) > 0,
250
"Missing end-points while defining route \"%s\"->\"%s\" (with %s and %s as gateways)",
251
src, dst,gw_src,gw_dst);
252
parsed_link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
255
* \brief Set a new link on the actual list of link for a route or ASroute from XML
258
static void routing_parse_link_ctn(void)
261
switch (A_surfxml_link_ctn_direction) {
262
case AU_surfxml_link_ctn_direction:
263
case A_surfxml_link_ctn_direction_NONE:
264
link_id = xbt_strdup(A_surfxml_link_ctn_id);
266
case A_surfxml_link_ctn_direction_UP:
267
link_id = bprintf("%s_UP", A_surfxml_link_ctn_id);
269
case A_surfxml_link_ctn_direction_DOWN:
270
link_id = bprintf("%s_DOWN", A_surfxml_link_ctn_id);
273
xbt_dynar_push(parsed_link_list, &link_id);
277
223
* \brief Store the route by calling the set_route function of the current routing component
279
static void routing_parse_E_route(void)
225
static void parse_E_route(sg_platf_route_cbarg_t route)
281
route_t route = xbt_new0(s_route_t, 1);
282
route->link_list = parsed_link_list;
283
227
xbt_assert(current_routing->parse_route,
284
228
"no defined method \"set_route\" in \"%s\"",
285
229
current_routing->name);
286
current_routing->parse_route(current_routing, src, dst, route);
287
generic_free_route(route);
288
parsed_link_list = NULL;
231
current_routing->parse_route(current_routing, route);
294
235
* \brief Store the ASroute by calling the set_ASroute function of the current routing component
296
static void routing_parse_E_ASroute(void)
237
static void parse_E_ASroute(sg_platf_route_cbarg_t ASroute)
298
route_t e_route = xbt_new0(s_route_t, 1);
299
e_route->link_list = parsed_link_list;
301
if (!strcmp(current_routing->model_desc->name,"RuleBased")) {
302
// DIRTY PERL HACK AHEAD: with the rulebased routing, the {src,dst}_gateway fields
303
// store the provided name instead of the entity directly (model_rulebased_parse_ASroute knows)
305
// This is because the user will provide something like "^AS_(.*)$" instead of the proper name of a given entity
306
e_route->src_gateway = (sg_routing_edge_t) gw_src;
307
e_route->dst_gateway = (sg_routing_edge_t) gw_dst;
309
e_route->src_gateway = sg_routing_edge_by_name_or_null(gw_src);
310
e_route->dst_gateway = sg_routing_edge_by_name_or_null(gw_dst);
312
239
xbt_assert(current_routing->parse_ASroute,
313
240
"no defined method \"set_ASroute\" in \"%s\"",
314
241
current_routing->name);
315
current_routing->parse_ASroute(current_routing, src, dst, e_route);
316
generic_free_route(e_route);
317
parsed_link_list = NULL;
325
* \brief Store the bypass route by calling the set_bypassroute function of the current routing component
327
static void routing_parse_E_bypassRoute(void)
329
route_t e_route = xbt_new0(s_route_t, 1);
330
e_route->link_list = parsed_link_list;
332
xbt_assert(current_routing->parse_bypassroute,
333
"Bypassing mechanism not implemented by routing '%s'",
334
current_routing->name);
336
current_routing->parse_bypassroute(current_routing, src, dst, e_route);
337
parsed_link_list = NULL;
344
* \brief Store the bypass route by calling the set_bypassroute function of the current routing component
346
static void routing_parse_E_bypassASroute(void)
348
route_t e_route = xbt_new0(s_route_t, 1);
349
e_route->link_list = parsed_link_list;
350
e_route->src_gateway = sg_routing_edge_by_name_or_null(gw_src);
351
e_route->dst_gateway = sg_routing_edge_by_name_or_null(gw_dst);
352
xbt_assert(current_routing->parse_bypassroute,
353
"Bypassing mechanism not implemented by routing '%s'",
354
current_routing->name);
355
current_routing->parse_bypassroute(current_routing, src, dst, e_route);
356
parsed_link_list = NULL;
242
current_routing->parse_ASroute(current_routing, ASroute);
246
* \brief Store the bypass route by calling the set_bypassroute function of the current routing component
248
static void parse_E_bypassRoute(sg_platf_route_cbarg_t route)
250
xbt_assert(current_routing->parse_bypassroute,
251
"Bypassing mechanism not implemented by routing '%s'",
252
current_routing->name);
254
current_routing->parse_bypassroute(current_routing, route);
258
* \brief Store the bypass route by calling the set_bypassroute function of the current routing component
260
static void parse_E_bypassASroute(sg_platf_route_cbarg_t ASroute)
262
xbt_assert(current_routing->parse_bypassroute,
263
"Bypassing mechanism not implemented by routing '%s'",
264
current_routing->name);
265
current_routing->parse_bypassroute(current_routing, ASroute);
268
static void routing_parse_trace(sg_platf_trace_cbarg_t trace)
270
tmgr_trace_t tmgr_trace;
271
if (!trace->file || strcmp(trace->file, "") != 0) {
272
tmgr_trace = tmgr_trace_new_from_file(trace->file);
273
} else if (strcmp(trace->pc_data, "") == 0) {
277
tmgr_trace_new_from_string(trace->id, trace->pc_data,
280
xbt_dict_set(traces_set_list, trace->id, (void *) tmgr_trace, NULL);
283
static void routing_parse_trace_connect(sg_platf_trace_connect_cbarg_t trace_connect)
285
xbt_assert(xbt_dict_get_or_null
286
(traces_set_list, trace_connect->trace),
287
"Cannot connect trace %s to %s: trace unknown",
288
trace_connect->trace,
289
trace_connect->element);
291
switch (trace_connect->kind) {
292
case SURF_TRACE_CONNECT_KIND_HOST_AVAIL:
293
xbt_dict_set(trace_connect_list_host_avail,
294
trace_connect->trace,
295
xbt_strdup(trace_connect->element), NULL);
297
case SURF_TRACE_CONNECT_KIND_POWER:
298
xbt_dict_set(trace_connect_list_power, trace_connect->trace,
299
xbt_strdup(trace_connect->element), NULL);
301
case SURF_TRACE_CONNECT_KIND_LINK_AVAIL:
302
xbt_dict_set(trace_connect_list_link_avail,
303
trace_connect->trace,
304
xbt_strdup(trace_connect->element), NULL);
306
case SURF_TRACE_CONNECT_KIND_BANDWIDTH:
307
xbt_dict_set(trace_connect_list_bandwidth,
308
trace_connect->trace,
309
xbt_strdup(trace_connect->element), NULL);
311
case SURF_TRACE_CONNECT_KIND_LATENCY:
312
xbt_dict_set(trace_connect_list_latency, trace_connect->trace,
313
xbt_strdup(trace_connect->element), NULL);
316
xbt_die("Cannot connect trace %s to %s: kind of trace unknown",
317
trace_connect->trace, trace_connect->element);
322
extern int _sg_init_status; /* yay, this is an horrible hack */
364
325
* \brief Make a new routing component to the platform
373
334
* @param AS_id name of this autonomous system. Must be unique in the platform
374
335
* @param wanted_routing_type one of Full, Floyd, Dijkstra or similar. Full list in the variable routing_models, in src/surf/surf_routing.c
376
void routing_AS_begin(const char *AS_id, const char *wanted_routing_type)
337
void routing_AS_begin(sg_platf_AS_cbarg_t AS)
339
XBT_DEBUG("routing_AS_begin");
379
341
routing_model_description_t model = NULL;
382
343
xbt_assert(!xbt_lib_get_or_null
383
(as_router_lib, AS_id, ROUTING_ASR_LEVEL),
384
"The AS \"%s\" already exists", AS_id);
344
(as_router_lib, AS->id, ROUTING_ASR_LEVEL),
345
"The AS \"%s\" already exists", AS->id);
347
_sg_init_status = 2; /* horrible hack: direct access to the global controlling the level of configuration to prevent any further config */
386
349
/* search the routing model */
387
for (cpt = 0; routing_models[cpt].name; cpt++)
388
if (!strcmp(wanted_routing_type, routing_models[cpt].name))
389
model = &routing_models[cpt];
390
/* if its not exist, error */
392
fprintf(stderr, "Routing model %s not found. Existing models:\n",
393
wanted_routing_type);
394
for (cpt = 0; routing_models[cpt].name; cpt++)
395
fprintf(stderr, " %s: %s\n", routing_models[cpt].name,
396
routing_models[cpt].desc);
351
case A_surfxml_AS_routing_Cluster: model = &routing_models[SURF_MODEL_CLUSTER];break;
352
case A_surfxml_AS_routing_Dijkstra: model = &routing_models[SURF_MODEL_DIJKSTRA];break;
353
case A_surfxml_AS_routing_DijkstraCache: model = &routing_models[SURF_MODEL_DIJKSTRACACHE];break;
354
case A_surfxml_AS_routing_Floyd: model = &routing_models[SURF_MODEL_FLOYD];break;
355
case A_surfxml_AS_routing_Full: model = &routing_models[SURF_MODEL_FULL];break;
356
case A_surfxml_AS_routing_None: model = &routing_models[SURF_MODEL_NONE];break;
357
case A_surfxml_AS_routing_RuleBased: model = &routing_models[SURF_MODEL_RULEBASED];break;
358
case A_surfxml_AS_routing_Vivaldi: model = &routing_models[SURF_MODEL_VIVALDI];break;
359
default: xbt_die("Not a valid model!!!");
400
363
/* make a new routing component */
401
364
new_as = (AS_t) model->create();
402
365
new_as->model_desc = model;
403
366
new_as->hierarchy = SURF_ROUTING_NULL;
404
new_as->name = xbt_strdup(AS_id);
367
new_as->name = xbt_strdup(AS->id);
406
369
sg_routing_edge_t info = NULL;
407
info = xbt_new0(s_network_element_t, 1);
370
info = xbt_new0(s_routing_edge_t, 1);
409
372
if (current_routing == NULL && routing_platf->root == NULL) {
745
710
/* ************************************************************************** */
746
711
/* ************************* GENERIC PARSE FUNCTIONS ************************ */
713
void routing_cluster_add_backbone(void* bb) {
714
xbt_assert(current_routing->model_desc == &routing_models[SURF_MODEL_CLUSTER],
715
"You have to be in model Cluster to use tag backbone!");
716
xbt_assert(!((as_cluster_t)current_routing)->backbone,"The backbone link is already defined!");
717
((as_cluster_t)current_routing)->backbone = bb;
718
XBT_DEBUG("Add a backbone to AS '%s'",current_routing->name);
721
static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet)
724
char *groups , *host_id , *link_id = NULL;
726
xbt_dynar_t radical_elements;
727
xbt_dynar_t radical_ends;
730
radical_elements = xbt_str_split(cabinet->radical, ",");
731
xbt_dynar_foreach(radical_elements, iter, groups) {
733
radical_ends = xbt_str_split(groups, "-");
734
start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
736
switch (xbt_dynar_length(radical_ends)) {
741
end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
744
surf_parse_error("Malformed radical");
747
s_sg_platf_host_cbarg_t host;
748
memset(&host, 0, sizeof(host));
749
host.initial_state = SURF_RESOURCE_ON;
750
host.power_peak = cabinet->power;
751
host.power_scale = 1.0;
752
host.core_amount = 1;
754
s_sg_platf_link_cbarg_t link;
755
memset(&link, 0, sizeof(link));
756
link.state = SURF_RESOURCE_ON;
757
link.policy = SURF_LINK_FULLDUPLEX;
758
link.latency = cabinet->lat;
759
link.bandwidth = cabinet->bw;
761
s_sg_platf_host_link_cbarg_t host_link;
762
memset(&host_link, 0, sizeof(host_link));
764
for (i = start; i <= end; i++) {
765
host_id = bprintf("%s%d%s",cabinet->prefix,i,cabinet->suffix);
766
link_id = bprintf("link_%s%d%s",cabinet->prefix,i,cabinet->suffix);
769
sg_platf_new_host(&host);
770
sg_platf_new_link(&link);
772
char* link_up = bprintf("%s_UP",link_id);
773
char* link_down = bprintf("%s_DOWN",link_id);
774
host_link.id = host_id;
775
host_link.link_up = link_up;
776
host_link.link_down= link_down;
777
sg_platf_new_host_link(&host_link);
785
xbt_dynar_free(&radical_ends);
787
xbt_dynar_free(&radical_elements);
748
790
static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
750
792
char *host_id, *groups, *link_id = NULL;
945
974
host.coord = peer->coord;
946
975
sg_platf_new_host(&host);
949
XBT_DEBUG("<router id=\"%s\"\tcoordinates=\"%s\"/>", router_id, peer->coord);
950
s_sg_platf_router_cbarg_t router;
951
memset(&router, 0, sizeof(router));
952
router.id = router_id;
953
router.coord = peer->coord;
954
sg_platf_new_router(&router);
956
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id_up,
957
peer->bw_in, peer->lat);
958
977
s_sg_platf_link_cbarg_t link;
959
978
memset(&link, 0, sizeof(link));
960
979
link.state = SURF_RESOURCE_ON;
961
980
link.policy = SURF_LINK_SHARED;
962
link.id = link_id_up;
963
link.bandwidth = peer->bw_in;
964
981
link.latency = peer->lat;
965
sg_platf_new_link(&link);
967
// FIXME: dealing with full duplex is not the role of this piece of code, I'd say [Mt]
968
// Instead, it should be created fullduplex, and the models will do what's needed in this case
969
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id_down,
983
char* link_up = bprintf("%s_UP",link_id);
984
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_up,
970
985
peer->bw_out, peer->lat);
971
link.id = link_id_down;
972
sg_platf_new_link(&link);
977
XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", host_id, router_id);
978
XBT_DEBUG("symmetrical=\"NO\">");
979
SURFXML_BUFFER_SET(route_src, host_id);
980
SURFXML_BUFFER_SET(route_dst, router_id);
981
A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
982
SURFXML_START_TAG(route);
984
XBT_DEBUG("<link_ctn\tid=\"%s\"/>", link_id_up);
985
SURFXML_BUFFER_SET(link_ctn_id, link_id_up);
986
A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
987
SURFXML_START_TAG(link_ctn);
988
SURFXML_END_TAG(link_ctn);
990
XBT_DEBUG("</route>");
991
SURFXML_END_TAG(route);
994
XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", router_id, host_id);
995
XBT_DEBUG("symmetrical=\"NO\">");
996
SURFXML_BUFFER_SET(route_src, router_id);
997
SURFXML_BUFFER_SET(route_dst, host_id);
998
A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
999
SURFXML_START_TAG(route);
1001
XBT_DEBUG("<link_ctn\tid=\"%s\"/>", link_id_down);
1002
SURFXML_BUFFER_SET(link_ctn_id, link_id_down);
1003
A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
1004
SURFXML_START_TAG(link_ctn);
1005
SURFXML_END_TAG(link_ctn);
1007
XBT_DEBUG("</route>");
1008
SURFXML_END_TAG(route);
1011
sg_platf_new_AS_end();
987
link.bandwidth = peer->bw_out;
988
sg_platf_new_link(&link);
990
char* link_down = bprintf("%s_DOWN",link_id);
991
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_down,
992
peer->bw_in, peer->lat);
994
link.bandwidth = peer->bw_in;
995
sg_platf_new_link(&link);
997
XBT_DEBUG("<host_link\tid=\"%s\"\tup=\"%s\"\tdown=\"%s\" />", host_id,link_up,link_down);
998
s_sg_platf_host_link_cbarg_t host_link;
999
memset(&host_link, 0, sizeof(host_link));
1000
host_link.id = host_id;
1001
host_link.link_up = link_up;
1002
host_link.link_down= link_down;
1003
sg_platf_new_host_link(&host_link);
1012
1005
XBT_DEBUG(" ");
1014
1007
//xbt_dynar_free(&tab_elements_num);
1018
free(link_backbone);
1021
surfxml_bufferstack_pop(1);
1024
1014
static void routing_parse_Srandom(void)
1146
1136
sg_platf_host_add_cb(parse_S_host);
1147
1137
sg_platf_router_add_cb(parse_S_router);
1149
surfxml_add_callback(STag_surfxml_random_cb_list, &routing_parse_Srandom);
1151
surfxml_add_callback(STag_surfxml_route_cb_list, &routing_parse_S_route);
1152
surfxml_add_callback(STag_surfxml_ASroute_cb_list, &routing_parse_S_ASroute);
1153
surfxml_add_callback(STag_surfxml_bypassRoute_cb_list,
1154
&routing_parse_S_bypassRoute);
1155
surfxml_add_callback(STag_surfxml_bypassASroute_cb_list,
1156
&routing_parse_S_bypassASroute);
1158
surfxml_add_callback(ETag_surfxml_link_ctn_cb_list, &routing_parse_link_ctn);
1160
surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_parse_E_route);
1161
surfxml_add_callback(ETag_surfxml_ASroute_cb_list, &routing_parse_E_ASroute);
1162
surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list,
1163
&routing_parse_E_bypassRoute);
1164
surfxml_add_callback(ETag_surfxml_bypassASroute_cb_list,
1165
&routing_parse_E_bypassASroute);
1138
sg_platf_host_link_add_cb(parse_S_host_link);
1139
sg_platf_route_add_cb(parse_E_route);
1140
sg_platf_ASroute_add_cb(parse_E_ASroute);
1141
sg_platf_bypassRoute_add_cb(parse_E_bypassRoute);
1142
sg_platf_bypassASroute_add_cb(parse_E_bypassASroute);
1167
1144
sg_platf_cluster_add_cb(routing_parse_cluster);
1145
sg_platf_cabinet_add_cb(routing_parse_cabinet);
1169
1147
sg_platf_peer_add_cb(routing_parse_peer);
1170
1148
sg_platf_postparse_add_cb(routing_parse_postparse);