:NetworkModel()
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim");
- int select =
- xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update");
+ int select = xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
p_updateMechanism = UM_FULL;
}
if (!p_maxminSystem)
- p_maxminSystem = lmm_system_new(m_selectiveUpdate);
+ p_maxminSystem = lmm_system_new(m_selectiveUpdate);
routing_model_create(createLink("__loopback__",
498000000, NULL, 0.000015, NULL,
#include "xbt/RngStream.h"
#include <xbt/signal.hpp>
#include "simgrid/platf_interface.h"
-#include "surf/surf_routing.h"
#include "surf/surf.h"
#include "src/simix/smx_private.h"
#include "src/surf/platform.hpp"
-#include "cpu_interface.hpp"
-#include "host_interface.hpp"
+#include "src/surf/platform.hpp"
+#include "src/surf/cpu_interface.hpp"
+#include "src/surf/host_interface.hpp"
+#include "src/surf/network_interface.hpp"
+#include "surf/surf_routing.h" // FIXME: brain dead public header
+#include "src/surf/surf_routing_cluster.hpp"
+#include "src/surf/surf_routing_cluster_torus.hpp"
+#include "src/surf/surf_routing_cluster_fat_tree.hpp"
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_parse);
void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster)
{
- routing_new_cluster(cluster);
+ using simgrid::surf::AsCluster;
+ using simgrid::surf::AsClusterTorus;
+ using simgrid::surf::AsClusterFatTree;
+
+ char *host_id, *groups, *link_id = NULL;
+ xbt_dict_t patterns = NULL;
+ int rankId=0;
+
+ s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
+ s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
+
+ unsigned int iter;
+ int start, end, i;
+ xbt_dynar_t radical_elements;
+ xbt_dynar_t radical_ends;
+
+ if ((cluster->availability_trace && strcmp(cluster->availability_trace, ""))
+ || (cluster->state_trace && strcmp(cluster->state_trace, ""))) {
+ patterns = xbt_dict_new_homogeneous(xbt_free_f);
+ xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL);
+ xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL);
+ xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL);
+ }
+
+ /* Parse the topology attributes.
+ * Nothing to do in a vanilla cluster, but that's another story for torus and flat_trees */
+ s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER;
+ AS.id = cluster->id;
+
+ switch (cluster->topology) {
+ case SURF_CLUSTER_TORUS:
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Torus_Cluster\">", cluster->id);
+ AS.routing = A_surfxml_AS_routing_Cluster___torus;
+ break;
+ case SURF_CLUSTER_FAT_TREE:
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Fat_Tree_Cluster\">", cluster->id);
+ AS.routing = A_surfxml_AS_routing_Cluster___fat___tree;
+ break;
+ default:
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", cluster->id);
+ AS.routing = A_surfxml_AS_routing_Cluster;
+ break;
+ }
+
+ // What an inventive way of initializing the AS that I have as ancestor :-(
+ sg_platf_new_AS_begin(&AS);
+ simgrid::surf::As *current_routing = routing_get_current();
+ static_cast<AsCluster*>(current_routing)->parse_specific_arguments(cluster);
+
+ if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
+ ((AsCluster*)current_routing)->p_nb_links_per_node++;
+ ((AsCluster*)current_routing)->p_has_loopback=1;
+ }
+
+ if(cluster->limiter_link!=0){
+ ((AsCluster*)current_routing)->p_nb_links_per_node++;
+ ((AsCluster*)current_routing)->p_has_limiter=1;
+ }
+
+
+ current_routing->p_linkUpDownList
+ = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
+
+ //Make all hosts
+ radical_elements = xbt_str_split(cluster->radical, ",");
+ xbt_dynar_foreach(radical_elements, iter, groups) {
+
+ radical_ends = xbt_str_split(groups, "-");
+ start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
+
+ switch (xbt_dynar_length(radical_ends)) {
+ case 1:
+ end = start;
+ break;
+ case 2:
+ end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
+ break;
+ default:
+ surf_parse_error("Malformed radical");
+ break;
+ }
+ for (i = start; i <= end; i++) {
+ host_id =
+ bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
+ link_id = bprintf("%s_link_%d", cluster->id, i);
+
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->speed);
+
+ memset(&host, 0, sizeof(host));
+ host.id = host_id;
+ if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) {
+ xbt_dict_cursor_t cursor=NULL;
+ char *key,*data;
+ host.properties = xbt_dict_new();
+
+ xbt_dict_foreach(cluster->properties,cursor,key,data) {
+ xbt_dict_set(host.properties, key, xbt_strdup(data),free);
+ }
+ }
+ if (cluster->availability_trace && strcmp(cluster->availability_trace, "")) {
+ xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL);
+ char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
+ XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
+ host.speed_trace = tmgr_trace_new_from_file(avail_file);
+ xbt_free(avail_file);
+ } else {
+ XBT_DEBUG("\tavailability_file=\"\"");
+ }
+
+ if (cluster->state_trace && strcmp(cluster->state_trace, "")) {
+ char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns);
+ XBT_DEBUG("\tstate_file=\"%s\"", avail_file);
+ host.state_trace = tmgr_trace_new_from_file(avail_file);
+ xbt_free(avail_file);
+ } else {
+ XBT_DEBUG("\tstate_file=\"\"");
+ }
+
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push(host.speed_peak,&cluster->speed);
+ host.pstate = 0;
+
+ //host.power_peak = cluster->power;
+ host.speed_scale = 1.0;
+ host.core_amount = cluster->core_amount;
+ host.initiallyOn = 1;
+ host.coord = "";
+ sg_platf_new_host(&host);
+ xbt_dynar_free(&host.speed_peak);
+ XBT_DEBUG("</host>");
+
+ XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
+ cluster->bw, cluster->lat);
+
+
+ s_surf_parsing_link_up_down_t info_lim, info_loop;
+ // All links are saved in a matrix;
+ // every row describes a single node; every node
+ // may have multiple links.
+ // the first column may store a link from x to x if p_has_loopback is set
+ // the second column may store a limiter link if p_has_limiter is set
+ // other columns are to store one or more link for the node
+
+ //add a loopback link
+ if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
+ char *tmp_link = bprintf("%s_loopback", link_id);
+ XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
+ cluster->limiter_link);
+
+
+ memset(&link, 0, sizeof(link));
+ link.id = tmp_link;
+ link.bandwidth = cluster->loopback_bw;
+ link.latency = cluster->loopback_lat;
+ link.initiallyOn = 1;
+ link.policy = SURF_LINK_FATPIPE;
+ sg_platf_new_link(&link);
+ info_loop.link_up = Link::byName(tmp_link);
+ info_loop.link_down = info_loop.link_up;
+ free(tmp_link);
+ xbt_dynar_set(current_routing->p_linkUpDownList,
+ rankId*(static_cast<AsCluster*>(current_routing))->p_nb_links_per_node, &info_loop);
+ }
+
+ //add a limiter link (shared link to account for maximal bandwidth of the node)
+ if(cluster->limiter_link!=0){
+ char *tmp_link = bprintf("%s_limiter", link_id);
+ XBT_DEBUG("<limiter\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
+ cluster->limiter_link);
+
+
+ memset(&link, 0, sizeof(link));
+ link.id = tmp_link;
+ link.bandwidth = cluster->limiter_link;
+ link.latency = 0;
+ link.initiallyOn = 1;
+ link.policy = SURF_LINK_SHARED;
+ sg_platf_new_link(&link);
+ info_lim.link_up = Link::byName(tmp_link);
+ info_lim.link_down = info_lim.link_up;
+ free(tmp_link);
+ auto as_cluster = static_cast<AsCluster*>(current_routing);
+ xbt_dynar_set(current_routing->p_linkUpDownList,
+ rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback ,
+ &info_lim);
+
+ }
+
+
+ //call the cluster function that adds the others links
+ if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
+ ((AsClusterFatTree*) current_routing)->addProcessingNode(i);
+ }
+ else {
+ static_cast<AsCluster*>(current_routing)->create_links_for_node(cluster, i, rankId, rankId*
+ static_cast<AsCluster*>(current_routing)->p_nb_links_per_node
+ + static_cast<AsCluster*>(current_routing)->p_has_loopback
+ + static_cast<AsCluster*>(current_routing)->p_has_limiter );
+ }
+ xbt_free(link_id);
+ xbt_free(host_id);
+ rankId++;
+ }
+
+ xbt_dynar_free(&radical_ends);
+ }
+ xbt_dynar_free(&radical_elements);
+
+ // For fat trees, the links must be created once all nodes have been added
+ if(cluster->topology == SURF_CLUSTER_FAT_TREE) {
+ static_cast<simgrid::surf::AsClusterFatTree*>(current_routing)->create_links();
+ }
+ // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written,
+ // and it's very useful to connect clusters together
+ XBT_DEBUG(" ");
+ XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id);
+ char *newid = NULL;
+ s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
+ memset(&router, 0, sizeof(router));
+ router.id = cluster->router_id;
+ router.coord = "";
+ if (!router.id || !strcmp(router.id, ""))
+ router.id = newid =
+ bprintf("%s%s_router%s", cluster->prefix, cluster->id,
+ cluster->suffix);
+ sg_platf_new_router(&router);
+ ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
+ free(newid);
+
+ //Make the backbone
+ if ((cluster->bb_bw != 0) || (cluster->bb_lat != 0)) {
+ char *link_backbone = bprintf("%s_backbone", cluster->id);
+ XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link_backbone,
+ cluster->bb_bw, cluster->bb_lat);
+
+ memset(&link, 0, sizeof(link));
+ link.id = link_backbone;
+ link.bandwidth = cluster->bb_bw;
+ link.latency = cluster->bb_lat;
+ link.initiallyOn = 1;
+ link.policy = cluster->bb_sharing_policy;
+
+ sg_platf_new_link(&link);
+
+ routing_cluster_add_backbone(Link::byName(link_backbone));
+
+ free(link_backbone);
+ }
+
+ XBT_DEBUG("</AS>");
+ sg_platf_new_AS_end();
+ XBT_DEBUG(" ");
+ xbt_dict_free(&patterns); // no op if it were never set
+
simgrid::surf::on_cluster(cluster);
}
const char *name;
const char *desc;
AS_t (*create) ();
- void (*end) (AS_t as);
} s_routing_model_description_t, *routing_model_description_t;
/* This enum used in the routing structure helps knowing in which situation we are. */
XBT_PUBLIC(void) routing_exit(void);
XBT_PUBLIC(void) storage_register_callbacks(void);
-XBT_PRIVATE void routing_new_cluster(sg_platf_cluster_cbarg_t cluster);
-
XBT_PUBLIC(void) routing_register_callbacks(void);
-XBT_PUBLIC(void) generic_free_route(sg_platf_route_cbarg_t route); // FIXME rename to routing_route_free
- // FIXME: make previous function private to routing again?
+XBT_PUBLIC(void) routing_route_free(sg_platf_route_cbarg_t route); // FIXME: make previous function private to routing again?
XBT_PUBLIC(void) generic_get_graph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges, AS_t rc);
/**
#include "surf_routing.hpp"
#include "surf_routing_private.hpp"
#include "surf_routing_cluster.hpp"
-#include "surf_routing_cluster_torus.hpp"
-#include "surf_routing_cluster_fat_tree.hpp"
#include "simgrid/platf_interface.h" // platform creation API internal interface
#include "simgrid/sg_config.h"
int NS3_ASR_LEVEL; //host node for ns3
int ROUTING_PROP_ASR_LEVEL; //Where the properties are stored
-static xbt_dict_t random_value = NULL;
-
-
/** @brief Retrieve a netcard from its name
*
* Netcards are the thing that connect host or routers to the network
/* Global vars */
simgrid::surf::RoutingPlatf *routing_platf = NULL;
-/* global parse functions */
-extern xbt_dynar_t mount_list;
-
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
/** The current AS in the parsing */
return current_routing;
}
-static void routing_parse_postparse(void);
-
/* this lines are only for replace use like index in the model table */
typedef enum {
SURF_MODEL_FULL = 0,
struct s_model_type routing_models[] = {
{"Full",
"Full routing data (fast, large memory requirements, fully expressive)",
- model_full_create, model_full_end},
+ model_full_create},
{"Floyd",
"Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)",
- model_floyd_create, model_floyd_end},
+ model_floyd_create},
{"Dijkstra",
"Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)",
- model_dijkstra_create, model_dijkstra_both_end},
+ model_dijkstra_create},
{"DijkstraCache",
"Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)",
- model_dijkstracache_create, model_dijkstra_both_end},
+ model_dijkstracache_create},
{"none", "No routing (Unless you know what you are doing, avoid using this mode in combination with a non Constant network model).",
- model_none_create, NULL},
- {"Vivaldi", "Vivaldi routing",
- model_vivaldi_create, NULL},
- {"Cluster", "Cluster routing",
- model_cluster_create, NULL},
- {"Torus_Cluster", "Torus Cluster routing",
- model_torus_cluster_create, NULL},
- {"Fat_Tree_Cluster", "Fat Tree Cluster routing",
- model_fat_tree_cluster_create, NULL},
- {NULL, NULL, NULL, NULL}
+ model_none_create},
+ {"Vivaldi", "Vivaldi routing", model_vivaldi_create},
+ {"Cluster", "Cluster routing", model_cluster_create},
+ {"Torus_Cluster", "Torus Cluster routing", model_torus_cluster_create},
+ {"Fat_Tree_Cluster", "Fat Tree Cluster routing", model_fat_tree_cluster_create},
+ {NULL, NULL, NULL}
};
/**
if (current_routing == NULL) {
THROWF(arg_error, 0, "Close an AS, but none was under construction");
} else {
- if (current_routing->p_modelDesc->end)
- current_routing->p_modelDesc->end(current_routing);
+ current_routing->Seal();
current_routing = current_routing->p_routingFather;
}
}
/* Common ancestor is kind enough to declare a bypass route from src to dst -- use it and bail out */
if (e_route_bypass) {
xbt_dynar_merge(links, &e_route_bypass->link_list);
- generic_free_route(e_route_bypass);
+ routing_route_free(e_route_bypass);
return;
}
return SURF_NETWORK_ELEMENT_NULL;
}
-/**
- * \brief Generic method: create the global routing schema
- *
- * Make a global routing structure and set all the parsing functions.
- */
+/** @brief create the root AS */
void routing_model_create( void *loopback)
{
- /* config the uniq global routing */
- routing_platf = new simgrid::surf::RoutingPlatf();
- routing_platf->p_root = NULL;
- routing_platf->p_loopback = loopback;
- routing_platf->p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);
- /* no current routing at moment */
- current_routing = NULL;
+ routing_platf = new simgrid::surf::RoutingPlatf(loopback);
}
-
-/* ************************************************** */
-/* ********** PATERN FOR NEW ROUTING **************** */
-
-/* The minimal configuration of a new routing model need the next functions,
- * also you need to set at the start of the file, the new model in the model
- * 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;
-
-/*** Parse routing model functions ***/
-// 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) { xbt_free(rc);}
-
-/*** Creation routing model functions ***/
-// 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 ************************ */
xbt_dynar_free(&radical_elements);
}
-void routing_new_cluster(sg_platf_cluster_cbarg_t cluster)
-{
- using simgrid::surf::AsCluster;
- using simgrid::surf::AsClusterTorus;
- using simgrid::surf::AsClusterFatTree;
-
- char *host_id, *groups, *link_id = NULL;
- xbt_dict_t patterns = NULL;
- int rankId=0;
-
- s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
- s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
-
- unsigned int iter;
- int start, end, i;
- xbt_dynar_t radical_elements;
- xbt_dynar_t radical_ends;
-
- if ((cluster->availability_trace && strcmp(cluster->availability_trace, ""))
- || (cluster->state_trace && strcmp(cluster->state_trace, ""))) {
- patterns = xbt_dict_new_homogeneous(xbt_free_f);
- xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL);
- xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL);
- xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL);
- }
-
- /* Parse the topology attributes.
- * Nothing to do in a vanilla cluster, but that's another story for torus and flat_trees */
- s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER;
- AS.id = cluster->id;
-
- switch (cluster->topology) {
- case SURF_CLUSTER_TORUS:
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Torus_Cluster\">", cluster->id);
- AS.routing = A_surfxml_AS_routing_Cluster___torus;
- break;
- case SURF_CLUSTER_FAT_TREE:
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Fat_Tree_Cluster\">", cluster->id);
- AS.routing = A_surfxml_AS_routing_Cluster___fat___tree;
- break;
- default:
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", cluster->id);
- AS.routing = A_surfxml_AS_routing_Cluster;
- break;
- }
-
- sg_platf_new_AS_begin(&AS);
- static_cast<AsCluster*>(current_routing)->parse_specific_arguments(cluster);
-
- if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
- ((AsCluster*)current_routing)->p_nb_links_per_node++;
- ((AsCluster*)current_routing)->p_has_loopback=1;
- }
-
- if(cluster->limiter_link!=0){
- ((AsCluster*)current_routing)->p_nb_links_per_node++;
- ((AsCluster*)current_routing)->p_has_limiter=1;
- }
-
-
- current_routing->p_linkUpDownList
- = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
-
- //Make all hosts
- radical_elements = xbt_str_split(cluster->radical, ",");
- xbt_dynar_foreach(radical_elements, iter, groups) {
-
- radical_ends = xbt_str_split(groups, "-");
- start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
-
- switch (xbt_dynar_length(radical_ends)) {
- case 1:
- end = start;
- break;
- case 2:
- end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
- break;
- default:
- surf_parse_error("Malformed radical");
- break;
- }
- for (i = start; i <= end; i++) {
- host_id =
- bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
- link_id = bprintf("%s_link_%d", cluster->id, i);
-
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->speed);
-
- memset(&host, 0, sizeof(host));
- host.id = host_id;
- if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) {
- xbt_dict_cursor_t cursor=NULL;
- char *key,*data;
- host.properties = xbt_dict_new();
-
- xbt_dict_foreach(cluster->properties,cursor,key,data) {
- xbt_dict_set(host.properties, key, xbt_strdup(data),free);
- }
- }
- if (cluster->availability_trace && strcmp(cluster->availability_trace, "")) {
- xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL);
- char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
- XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
- host.speed_trace = tmgr_trace_new_from_file(avail_file);
- xbt_free(avail_file);
- } else {
- XBT_DEBUG("\tavailability_file=\"\"");
- }
-
- if (cluster->state_trace && strcmp(cluster->state_trace, "")) {
- char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns);
- XBT_DEBUG("\tstate_file=\"%s\"", avail_file);
- host.state_trace = tmgr_trace_new_from_file(avail_file);
- xbt_free(avail_file);
- } else {
- XBT_DEBUG("\tstate_file=\"\"");
- }
-
- host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push(host.speed_peak,&cluster->speed);
- host.pstate = 0;
-
- //host.power_peak = cluster->power;
- host.speed_scale = 1.0;
- host.core_amount = cluster->core_amount;
- host.initiallyOn = 1;
- host.coord = "";
- sg_platf_new_host(&host);
- xbt_dynar_free(&host.speed_peak);
- XBT_DEBUG("</host>");
-
- XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
- cluster->bw, cluster->lat);
-
-
- s_surf_parsing_link_up_down_t info_lim, info_loop;
- // All links are saved in a matrix;
- // every row describes a single node; every node
- // may have multiple links.
- // the first column may store a link from x to x if p_has_loopback is set
- // the second column may store a limiter link if p_has_limiter is set
- // other columns are to store one or more link for the node
-
- //add a loopback link
- if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
- char *tmp_link = bprintf("%s_loopback", link_id);
- XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
- cluster->limiter_link);
-
-
- memset(&link, 0, sizeof(link));
- link.id = tmp_link;
- link.bandwidth = cluster->loopback_bw;
- link.latency = cluster->loopback_lat;
- link.initiallyOn = 1;
- link.policy = SURF_LINK_FATPIPE;
- sg_platf_new_link(&link);
- info_loop.link_up = Link::byName(tmp_link);
- info_loop.link_down = info_loop.link_up;
- free(tmp_link);
- xbt_dynar_set(current_routing->p_linkUpDownList,
- rankId*(static_cast<AsCluster*>(current_routing))->p_nb_links_per_node, &info_loop);
- }
-
- //add a limiter link (shared link to account for maximal bandwidth of the node)
- if(cluster->limiter_link!=0){
- char *tmp_link = bprintf("%s_limiter", link_id);
- XBT_DEBUG("<limiter\tid=\"%s\"\tbw=\"%f\"/>", tmp_link,
- cluster->limiter_link);
-
-
- memset(&link, 0, sizeof(link));
- link.id = tmp_link;
- link.bandwidth = cluster->limiter_link;
- link.latency = 0;
- link.initiallyOn = 1;
- link.policy = SURF_LINK_SHARED;
- sg_platf_new_link(&link);
- info_lim.link_up = Link::byName(tmp_link);
- info_lim.link_down = info_lim.link_up;
- free(tmp_link);
- auto as_cluster = static_cast<AsCluster*>(current_routing);
- xbt_dynar_set(current_routing->p_linkUpDownList,
- rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback ,
- &info_lim);
-
- }
-
-
- //call the cluster function that adds the others links
- if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
- ((AsClusterFatTree*) current_routing)->addProcessingNode(i);
- }
- else {
- static_cast<AsCluster*>(current_routing)->create_links_for_node(cluster, i, rankId, rankId*
- static_cast<AsCluster*>(current_routing)->p_nb_links_per_node
- + static_cast<AsCluster*>(current_routing)->p_has_loopback
- + static_cast<AsCluster*>(current_routing)->p_has_limiter );
- }
- xbt_free(link_id);
- xbt_free(host_id);
- rankId++;
- }
-
- xbt_dynar_free(&radical_ends);
- }
- xbt_dynar_free(&radical_elements);
-
- // For fat trees, the links must be created once all nodes have been added
- if(cluster->topology == SURF_CLUSTER_FAT_TREE) {
- static_cast<simgrid::surf::AsClusterFatTree*>(current_routing)->create_links();
- }
- // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written,
- // and it's very useful to connect clusters together
- XBT_DEBUG(" ");
- XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id);
- char *newid = NULL;
- s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER;
- memset(&router, 0, sizeof(router));
- router.id = cluster->router_id;
- router.coord = "";
- if (!router.id || !strcmp(router.id, ""))
- router.id = newid =
- bprintf("%s%s_router%s", cluster->prefix, cluster->id,
- cluster->suffix);
- sg_platf_new_router(&router);
- ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL);
- free(newid);
-
- //Make the backbone
- if ((cluster->bb_bw != 0) || (cluster->bb_lat != 0)) {
- char *link_backbone = bprintf("%s_backbone", cluster->id);
- XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link_backbone,
- cluster->bb_bw, cluster->bb_lat);
-
- memset(&link, 0, sizeof(link));
- link.id = link_backbone;
- link.bandwidth = cluster->bb_bw;
- link.latency = cluster->bb_lat;
- link.initiallyOn = 1;
- link.policy = cluster->bb_sharing_policy;
-
- sg_platf_new_link(&link);
-
- routing_cluster_add_backbone(Link::byName(link_backbone));
-
- free(link_backbone);
- }
-
- XBT_DEBUG("</AS>");
- sg_platf_new_AS_end();
- XBT_DEBUG(" ");
- xbt_dict_free(&patterns); // no op if it were never set
-}
-
-static void routing_parse_postparse(void) {
- xbt_dict_free(&random_value);
-}
-
void sg_platf_new_peer(sg_platf_peer_cbarg_t peer)
{
using simgrid::surf::NetCard;
void routing_register_callbacks()
{
- simgrid::surf::on_postparse.connect(routing_parse_postparse);
simgrid::surf::on_postparse.connect(check_disk_attachment);
instr_routing_define_callbacks();
namespace simgrid {
namespace surf {
-RoutingPlatf::~RoutingPlatf()
-{
- xbt_dynar_free(&p_lastRoute);
- finalize_rec(p_root);
-}
+ RoutingPlatf::RoutingPlatf(void *loopback)
+ : p_loopback(loopback)
+ {
+ }
+ RoutingPlatf::~RoutingPlatf()
+ {
+ xbt_dynar_free(&p_lastRoute);
+ finalize_rec(p_root);
+ }
}
}
NetCard *p_netcard;
xbt_dynar_t p_linkUpDownList = NULL;
- /**
- * @brief The As constructor
- */
As(){};
+ /* Close that AS: no more content can be added to it */
+ virtual void Seal()=0;
- /**
- * @brief The As destructor
- */
virtual ~As(){
xbt_dict_free(&p_routingSons);
xbt_dynar_free(&p_indexNetworkElm);
*/
XBT_PUBLIC_CLASS RoutingPlatf {
public:
+ RoutingPlatf(void *loopback);
~RoutingPlatf();
- As *p_root;
+ As *p_root = nullptr;
void *p_loopback;
- xbt_dynar_t p_lastRoute;
+ xbt_dynar_t p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);
xbt_dynar_t getOneLinkRoutes(void);
xbt_dynar_t recursiveGetOneLinkRoutes(As *rc);
void getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t * links, double *latency);
class AsCluster: public AsNone {
public:
AsCluster() {}
+ void Seal() override {}; // nothing to do
virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) override;
virtual void create_links_for_node(sg_platf_cluster_cbarg_t cluster, int id, int rank, int position);
virtual void parse_specific_arguments(sg_platf_cluster_cbarg_t cluster) {}
+
Link* p_backbone = nullptr;
void *p_loopback = nullptr;
NetCard *p_router = nullptr;
return new simgrid::surf::AsDijkstra(1);
}
-void model_dijkstra_both_end(AS_t as)
-{
- simgrid::surf::AsDijkstra *THIS_AS
- = static_cast<simgrid::surf::AsDijkstra*>(as);
- xbt_node_t node = NULL;
- unsigned int cursor2;
- xbt_dynar_t nodes = NULL;
+/* Utility functions */
+namespace simgrid {
+namespace surf {
+void AsDijkstra::Seal()
+{
/* Create the topology graph */
- if(!THIS_AS->p_routeGraph)
- THIS_AS->p_routeGraph = xbt_graph_new_graph(1, NULL);
- if(!THIS_AS->p_graphNodeMap)
- THIS_AS->p_graphNodeMap = xbt_dict_new_homogeneous(&graph_node_map_elem_free);
+ if(!p_routeGraph)
+ p_routeGraph = xbt_graph_new_graph(1, NULL);
+ if(!p_graphNodeMap)
+ p_graphNodeMap = xbt_dict_new_homogeneous(&graph_node_map_elem_free);
- if (THIS_AS->m_cached && !THIS_AS->p_routeCache)
- THIS_AS->p_routeCache = xbt_dict_new_homogeneous(&route_cache_elem_free);
+ if (m_cached && !p_routeCache)
+ p_routeCache = xbt_dict_new_homogeneous(&route_cache_elem_free);
/* Add the loopback if needed */
- if (routing_platf->p_loopback && as->p_hierarchy == SURF_ROUTING_BASE)
- THIS_AS->addLoopback();
+ if (routing_platf->p_loopback && p_hierarchy == SURF_ROUTING_BASE)
+ addLoopback();
/* initialize graph indexes in nodes after graph has been built */
- nodes = xbt_graph_get_nodes(THIS_AS->p_routeGraph);
+ xbt_dynar_t nodes = xbt_graph_get_nodes(p_routeGraph);
+ xbt_node_t node = NULL;
+ unsigned int cursor2;
xbt_dynar_foreach(nodes, cursor2, node) {
graph_node_data_t data = (graph_node_data_t) xbt_graph_node_get_data(node);
data->graph_id = cursor2;
}
}
-/* Utility functions */
-
-namespace simgrid {
-namespace surf {
-
xbt_node_t AsDijkstra::routeGraphNewNode(int id, int graph_id)
{
xbt_node_t node = NULL;
class AsDijkstra : public AsGeneric {
public:
AsDijkstra();
+ void Seal() override;
+
AsDijkstra(bool cached);
~AsDijkstra();
xbt_node_t routeGraphNewNode(int id, int graph_id);
return new simgrid::surf::AsFloyd();
}
-void model_floyd_end(AS_t current_routing)
-{
- static_cast<simgrid::surf::AsFloyd*>(current_routing)->end();
-}
-
namespace simgrid {
namespace surf {
/* Delete link_table */
for (i = 0; i < table_size; i++)
for (j = 0; j < table_size; j++) {
- generic_free_route(TO_FLOYD_LINK(i, j));
+ routing_route_free(TO_FLOYD_LINK(i, j));
}
xbt_free(p_linkTable);
/* Delete bypass dict */
xbt_dynar_free(&route->link_list);
}
-void AsFloyd::end(){
+void AsFloyd::Seal(){
unsigned int i, j, a, b, c;
/* set the size of table routing */
xbt_dynar_t getOneLinkRoutes() override;
void parseASroute(sg_platf_route_cbarg_t route) override;
void parseRoute(sg_platf_route_cbarg_t route) override;
- void end();
+ void Seal() override;
private:
/* vars to compute the Floyd algorithm. */
return new simgrid::surf::AsFull();
}
-void model_full_end(AS_t _routing)
-{
+namespace simgrid {
+namespace surf {
+void AsFull::Seal() {
int i;
sg_platf_route_cbarg_t e_route;
/* set utils vars */
- simgrid::surf::AsFull *routing = static_cast<simgrid::surf::AsFull*>(_routing);
- int table_size = (int)xbt_dynar_length(routing->p_indexNetworkElm);
+ int table_size = (int)xbt_dynar_length(p_indexNetworkElm);
/* Create table if necessary */
- if (!routing->p_routingTable)
- routing->p_routingTable = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size);
+ if (!p_routingTable)
+ p_routingTable = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size);
/* Add the loopback if needed */
- if (routing_platf->p_loopback && routing->p_hierarchy == SURF_ROUTING_BASE) {
+ if (routing_platf->p_loopback && p_hierarchy == SURF_ROUTING_BASE) {
for (i = 0; i < table_size; i++) {
- e_route = routing->TO_ROUTE_FULL(i, i);
+ e_route = TO_ROUTE_FULL(i, i);
if (!e_route) {
e_route = xbt_new0(s_sg_platf_route_cbarg_t, 1);
e_route->gw_src = NULL;
e_route->gw_dst = NULL;
e_route->link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL);
xbt_dynar_push(e_route->link_list, &routing_platf->p_loopback);
- routing->TO_ROUTE_FULL(i, i) = e_route;
+ TO_ROUTE_FULL(i, i) = e_route;
}
}
}
}
-namespace simgrid {
-namespace surf {
-
AsFull::~AsFull(){
if (p_routingTable) {
int table_size = (int)xbt_dynar_length(p_indexNetworkElm);
public:
AsFull() {}
+ void Seal() override;
~AsFull();
void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
static int no_bypassroute_declared = 1;
-void generic_free_route(sg_platf_route_cbarg_t route)
+void routing_route_free(sg_platf_route_cbarg_t route)
{
if (route) {
xbt_dynar_free(&route->link_list);
}
AsGeneric::AsGeneric() {
- p_bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) generic_free_route);
+ p_bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) routing_route_free);
}
AsGeneric::~AsGeneric() {
class XBT_PRIVATE AsNone : public As {
public:
AsNone() {}
+ void Seal() override {}; // nothing to do
~AsNone() {}
void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
/* ************************************************************************** */
/* *************************** FLOYD ROUTING ******************************** */
XBT_PRIVATE AS_t model_floyd_create(void); /* create structures for floyd routing model */
-XBT_PRIVATE void model_floyd_end(AS_t as); /* finalize the creation of floyd routing model */
XBT_PRIVATE void model_floyd_parse_route(AS_t rc, sg_platf_route_cbarg_t route);
/* ************************************************** */
XBT_PRIVATE AS_t model_dijkstra_both_create(int cached); /* create by calling dijkstra or dijkstracache */
XBT_PRIVATE AS_t model_dijkstra_create(void); /* create structures for dijkstra routing model */
XBT_PRIVATE AS_t model_dijkstracache_create(void); /* create structures for dijkstracache routing model */
-XBT_PRIVATE void model_dijkstra_both_end(AS_t as); /* finalize the creation of dijkstra routing model */
XBT_PRIVATE void model_dijkstra_both_parse_route (AS_t rc, sg_platf_route_cbarg_t route);
/* ************************************************************************** */
/* *************************** FULL ROUTING ********************************* */
XBT_PRIVATE AS_t model_full_create(void); /* create structures for full routing model */
-XBT_PRIVATE void model_full_end(AS_t as); /* finalize the creation of full routing model */
XBT_PRIVATE void model_full_set_route( /* Set the route and ASroute between src and dst */
AS_t rc, sg_platf_route_cbarg_t route);
/* ************************************************************************** */
class AsVivaldi: public AsGeneric {
public:
AsVivaldi() : AsGeneric() {};
+ void Seal() override {}; // nothing to do
~AsVivaldi() {};
void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
