extern XBT_PRIVATE xbt_dynar_t surf_path;
typedef enum {
- SURF_NETWORK_ELEMENT_NULL = 0, /* NULL */
- SURF_NETWORK_ELEMENT_HOST, /* host type */
- SURF_NETWORK_ELEMENT_ROUTER, /* router type */
- SURF_NETWORK_ELEMENT_AS /* AS type */
+ SURF_NETWORK_ELEMENT_NULL = 0, /* NULL */
+ SURF_NETWORK_ELEMENT_HOST, /* host type */
+ SURF_NETWORK_ELEMENT_ROUTER, /* router type */
+ SURF_NETWORK_ELEMENT_AS /* AS type */
} e_surf_network_element_type_t;
#ifdef __cplusplus
static void define_callbacks_ns3(void)
{
simgrid::s4u::Host::onCreation.connect(simgrid_ns3_add_host);
- simgrid::surf::routingEdgeCreatedCallbacks.connect(simgrid_ns3_add_router);
+ simgrid::surf::netcardCreatedCallbacks.connect(simgrid_ns3_add_router);
sg_platf_link_add_cb (&parse_ns3_add_link);
sg_platf_cluster_add_cb (&parse_ns3_add_cluster);
simgrid::surf::asCreatedCallbacks.connect(parse_ns3_add_AS);
info->setId(current_routing->parsePU(info));
xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info);
XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->getId());
- simgrid::surf::routingEdgeCreatedCallbacks(info);
+ simgrid::surf::netcardCreatedCallbacks(info);
if (router->coord && strcmp(router->coord, "")) {
unsigned int cursor;
namespace simgrid {
namespace surf {
-simgrid::xbt::signal<void(simgrid::surf::NetCard*)> routingEdgeCreatedCallbacks;
+simgrid::xbt::signal<void(simgrid::surf::NetCard*)> netcardCreatedCallbacks;
simgrid::xbt::signal<void(simgrid::surf::As*)> asCreatedCallbacks;
}
sg_host_t h = sg_host_by_name(name);
simgrid::surf::NetCard *net_elm = h==NULL?NULL: h->pimpl_netcard;
if (!net_elm)
- net_elm = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
+ net_elm = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
return net_elm;
}
sg_host_t h = sg_host_by_name_or_create(host->id);
h->pimpl_netcard = netcard;
XBT_DEBUG("Having set name '%s' id '%d'", host->id, netcard->getId());
- simgrid::surf::routingEdgeCreatedCallbacks(netcard);
+ simgrid::surf::netcardCreatedCallbacks(netcard);
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
/* set the new current component of the tree */
current_routing = new_as;
- current_routing->p_netElem = info;
+ current_routing->p_netcard = info;
- simgrid::surf::routingEdgeCreatedCallbacks(info);
+ simgrid::surf::netcardCreatedCallbacks(info);
simgrid::surf::asCreatedCallbacks(new_as);
}
route.link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL);
// Find the net_card corresponding to father
- simgrid::surf::NetCard *src_father_net_elm = src_father->p_netElem;
- simgrid::surf::NetCard *dst_father_net_elm = dst_father->p_netElem;
+ simgrid::surf::NetCard *src_father_netcard = src_father->p_netcard;
+ simgrid::surf::NetCard *dst_father_netcard = dst_father->p_netcard;
- common_father->getRouteAndLatency(src_father_net_elm, dst_father_net_elm,
+ common_father->getRouteAndLatency(src_father_netcard, dst_father_netcard,
&route, latency);
xbt_assert((route.gw_src != NULL) && (route.gw_dst != NULL),
if (dst_gateway_net_elm != dst)
_get_route_and_latency(dst_gateway_net_elm, dst, links, latency);
- // if vivaldi latency+=vivaldi(src_gateway,dst_gateway)
}
AS_t surf_platf_get_root(routing_platf_t platf){
* walk through the routing components tree and find a route between hosts
* by calling each "get_route" function in each routing component.
*/
-void RoutingPlatf::getRouteAndLatency(
- simgrid::surf::NetCard *src, simgrid::surf::NetCard *dst,
- xbt_dynar_t* route, double *latency)
+void RoutingPlatf::getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t* route, double *latency)
{
XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->getName(), dst->getName());
- if (!*route) {
+ if (NULL == *route) {
xbt_dynar_reset(routing_platf->p_lastRoute);
*route = routing_platf->p_lastRoute;
}
char *p_name = nullptr;
As *p_routingFather = nullptr;
xbt_dict_t p_routingSons = xbt_dict_new_homogeneous(NULL);
- NetCard *p_netElem;
+ NetCard *p_netcard;
xbt_dynar_t p_linkUpDownList = NULL;
/**
xbt_dynar_free(&p_indexNetworkElm);
xbt_dynar_free(&p_linkUpDownList);
xbt_free(p_name);
- if (p_netElem)
- delete p_netElem;
+ if (p_netcard)
+ delete p_netcard;
};
/**
* Callbacks *
*************/
-XBT_PUBLIC_DATA(simgrid::xbt::signal<void(NetCard*)>) routingEdgeCreatedCallbacks;
+XBT_PUBLIC_DATA(simgrid::xbt::signal<void(NetCard*)>) netcardCreatedCallbacks;
XBT_PUBLIC_DATA(simgrid::xbt::signal<void(As*)>) asCreatedCallbacks;
}
namespace simgrid {
namespace surf {
-/* Creation routing model functions */
-AsCluster::AsCluster() : AsNone()
-{
- p_backbone = 0;
- p_loopback = 0;
- p_router = 0;
- p_has_limiter = 0;
- p_has_loopback = 0;
- p_nb_links_per_node = 1;
-}
-
/* Business methods */
void AsCluster::getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat)
{
class AsCluster: public AsNone {
public:
- AsCluster();
-
- virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- //xbt_dynar_t getOneLinkRoutes();
- //void parseRoute(sg_platf_route_cbarg_t route);
- //void parseASroute(sg_platf_route_cbarg_t route);
-
- void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- //sg_platf_route_cbarg_t getBypassRoute(RoutingEdge *src, RoutingEdge *dst, double *lat);
-
- /* The parser calls the following functions to inform the routing models
- * that a new element is added to the AS currently built.
- *
- * Of course, only the routing model of this AS is informed, not every ones */
- int parsePU(NetCard *elm); /* A host or a router, whatever */
- int parseAS(NetCard *elm);
+ AsCluster() {}
+
+ 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;
+
+ int parsePU(NetCard *elm) override; /* A host or a router, whatever */
+ int parseAS(NetCard *elm) override;
virtual void create_links_for_node(sg_platf_cluster_cbarg_t cluster, int id, int rank, int position);
- Link* p_backbone;
- void *p_loopback;
- NetCard *p_router;
- int p_has_limiter;
- int p_has_loopback;
- int p_nb_links_per_node;
+
+ Link* p_backbone = nullptr;
+ void *p_loopback = nullptr;
+ NetCard *p_router = nullptr;
+ int p_has_limiter = 0;
+ int p_has_loopback = 0;
+ int p_nb_links_per_node = 1;
};
public:
FatTreeLink(sg_platf_cluster_cbarg_t cluster, FatTreeNode *source,
FatTreeNode *destination);
- /** Link going up in the tree
- */
+ /** Link going up in the tree */
Link *upLink;
- /** Link going down in the tree
- */
+ /** Link going down in the tree */
Link *downLink;
- /** Upper end of the link
- */
+ /** Upper end of the link */
FatTreeNode *upNode;
- /** Lower end of the link
- */
+ /** Lower end of the link */
FatTreeNode *downNode;
};
~AsClusterFatTree();
virtual void getRouteAndLatency(NetCard *src, NetCard *dst,
sg_platf_route_cbarg_t into,
- double *latency);
+ double *latency) override;
/** \brief Generate the fat tree
*
* It will also store the cluster for future use.
*/
void parse_specific_arguments(sg_platf_cluster_cbarg_t cluster);
- /** \brief Add a processing node.
- */
void addProcessingNode(int id);
void generateDotFile(const std::string& filename = "fatTree.dot") const;
}
}
-xbt_dynar_t AsDijkstra::getOnelinkRoutes()
+xbt_dynar_t AsDijkstra::getOneLinkRoutes()
{
xbt_dynar_t ret = xbt_dynar_new(sizeof(Onelink*), xbt_free_f);
sg_platf_route_cbarg_t route = xbt_new0(s_sg_platf_route_cbarg_t,1);
/* Creation routing model functions */
-AsDijkstra::AsDijkstra() : AsGeneric(), m_cached(0) {
- p_routeGraph = NULL;
- p_graphNodeMap = NULL;
- p_routeCache = NULL;
+AsDijkstra::AsDijkstra() : AsGeneric() {
}
-AsDijkstra::AsDijkstra(int cached) : AsGeneric(), m_cached(cached)
+AsDijkstra::AsDijkstra(bool cached) : AsGeneric(), m_cached(cached)
{
p_routeGraph = NULL;
p_graphNodeMap = NULL;
class AsDijkstra : public AsGeneric {
public:
AsDijkstra();
- AsDijkstra(int cached);
+ AsDijkstra(bool cached);
~AsDijkstra();
xbt_node_t routeGraphNewNode(int id, int graph_id);
graph_node_map_element_t nodeMapSearch(int id);
* will have a loopback attached to it.
*/
void addLoopback();
- void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat);
- xbt_dynar_t getOnelinkRoutes();
- void getRouteAndLatency(sg_platf_route_cbarg_t route, double *lat);
- void parseASroute(sg_platf_route_cbarg_t route);
- void parseRoute(sg_platf_route_cbarg_t route);
+ void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat) override;
+ xbt_dynar_t getOneLinkRoutes() override;
+ void getRouteAndLatency(sg_platf_route_cbarg_t route, double *lat); // FIXME: this function is dangerously not overriding because of diverging prototype
+ void parseASroute(sg_platf_route_cbarg_t route) override;
+ void parseRoute(sg_platf_route_cbarg_t route) override;
void end();
- xbt_graph_t p_routeGraph; /* xbt_graph */
- xbt_dict_t p_graphNodeMap; /* map */
- xbt_dict_t p_routeCache; /* use in cache mode */
- int m_cached;
+ xbt_graph_t p_routeGraph = nullptr; /* xbt_graph */
+ xbt_dict_t p_graphNodeMap = nullptr; /* map */
+ xbt_dict_t p_routeCache = nullptr; /* use in cache mode */
+ bool m_cached = false;
};
}
AsFloyd();
~AsFloyd();
- void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- xbt_dynar_t getOneLinkRoutes();
- void parseASroute(sg_platf_route_cbarg_t route);
- void parseRoute(sg_platf_route_cbarg_t route);
+ void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
+ 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 parseASroute(sg_platf_route_cbarg_t route);
- //void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- //sg_platf_route_cbarg_t getBypassRoute(RoutingEdge *src, RoutingEdge *dst, double *lat);
-
- /* The parser calls the following functions to inform the routing models
- * that a new element is added to the AS currently built.
- *
- * Of course, only the routing model of this AS is informed, not every ones */
- //int parsePU(RoutingEdge *elm); /* A host or a router, whatever */
- //int parseAS(RoutingEdge *elm);
-
- //virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
-
- /* vars for calculate the floyd algorith. */
+private:
+ /* vars to compute the Floyd algorithm. */
int *p_predecessorTable;
double *p_costTable;
sg_platf_route_cbarg_t *p_linkTable;
namespace simgrid {
namespace surf {
-AsFull::AsFull(){
- p_routingTable = 0;
-}
-
AsFull::~AsFull(){
if (p_routingTable) {
int table_size = (int)xbt_dynar_length(p_indexNetworkElm);
class AsFull: public AsGeneric {
public:
- sg_platf_route_cbarg_t *p_routingTable;
- AsFull();
+ AsFull() {}
~AsFull();
- void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- xbt_dynar_t getOneLinkRoutes();
- void parseRoute(sg_platf_route_cbarg_t route);
- void parseASroute(sg_platf_route_cbarg_t route);
+ void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
+ xbt_dynar_t getOneLinkRoutes() override;
+ void parseRoute(sg_platf_route_cbarg_t route) override;
+ void parseASroute(sg_platf_route_cbarg_t route) override;
- //void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- //sg_platf_route_cbarg_t getBypassRoute(RoutingEdge *src, RoutingEdge *dst, double *lat);
-
- /* The parser calls the following functions to inform the routing models
- * that a new element is added to the AS currently built.
- *
- * Of course, only the routing model of this AS is informed, not every ones */
- //virtual int parsePU(RoutingEdge *elm)=0; /* A host or a router, whatever */
- //virtual int parseAS( RoutingEdge *elm)=0;
-
- //virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
+ sg_platf_route_cbarg_t *p_routingTable = nullptr;
};
}
namespace simgrid {
namespace surf {
-xbt_dynar_t AsGeneric::getOneLinkRoutes() { // FIXME: kill that stub
- xbt_die("\"generic_get_onelink_routes\" not implemented yet");
- return NULL;
-}
-
void AsGeneric::getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)
{
int src, dst;
AsGeneric();
~AsGeneric();
- virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- virtual xbt_dynar_t getOneLinkRoutes();
- virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- virtual sg_platf_route_cbarg_t getBypassRoute(NetCard *src, NetCard *dst, double *lat);
+ virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
+ virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) override;
+ virtual sg_platf_route_cbarg_t getBypassRoute(NetCard *src, NetCard *dst, double *lat) override;
/* The parser calls the following functions to inform the routing models
* that a new element is added to the AS currently built.
*
* Of course, only the routing model of this AS is informed, not every ones */
- virtual int parsePU(NetCard *elm); /* A host or a router, whatever */
- virtual int parseAS(NetCard *elm);
- virtual void parseRoute(sg_platf_route_cbarg_t route);
- virtual void parseASroute(sg_platf_route_cbarg_t route);
- virtual void parseBypassroute(sg_platf_route_cbarg_t e_route);
+ virtual int parsePU(NetCard *elm) override; /* A host or a router, whatever */
+ virtual int parseAS(NetCard *elm) override;
+ virtual void parseRoute(sg_platf_route_cbarg_t route) override;
+ virtual void parseASroute(sg_platf_route_cbarg_t route) override;
+ virtual void parseBypassroute(sg_platf_route_cbarg_t e_route) override;
virtual sg_platf_route_cbarg_t newExtendedRoute(e_surf_routing_hierarchy_t hierarchy, sg_platf_route_cbarg_t routearg, int change_order);
virtual As *asExist(As *to_find);
}
void AsNone::parseRoute(sg_platf_route_cbarg_t /*route*/){
- THROW_IMPOSSIBLE;
+ THROW_IMPOSSIBLE; /* No. */
}
void AsNone::parseASroute(sg_platf_route_cbarg_t /*route*/){
THROW_IMPOSSIBLE;
}
-/* Creation routing model functions */
-AsNone::AsNone() {
-}
-
-AsNone::~AsNone() {
-}
-
}
}
class XBT_PRIVATE AsNone : public As {
public:
- AsNone();
- ~AsNone();
+ AsNone() {}
+ ~AsNone() {}
- void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- xbt_dynar_t getOneLinkRoutes();
- void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- sg_platf_route_cbarg_t getBypassRoute(NetCard *src, NetCard *dst, double *lat);
+ void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
+ xbt_dynar_t getOneLinkRoutes() override;
+ void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) override;
+ sg_platf_route_cbarg_t getBypassRoute(NetCard *src, NetCard *dst, double *lat) override;
/* The parser calls the following functions to inform the routing models
* that a new element is added to the AS currently built.
*
* Of course, only the routing model of this AS is informed, not every ones */
- int parsePU(NetCard *elm); /* A host or a router, whatever */
- int parseAS( NetCard *elm);
- void parseRoute(sg_platf_route_cbarg_t route);
- void parseASroute(sg_platf_route_cbarg_t route);
- void parseBypassroute(sg_platf_route_cbarg_t e_route);
+ int parsePU(NetCard *elm) override; /* A host or a router, whatever */
+ int parseAS( NetCard *elm) override;
+ void parseRoute(sg_platf_route_cbarg_t route) override;
+ void parseASroute(sg_platf_route_cbarg_t route) override;
+ void parseBypassroute(sg_platf_route_cbarg_t e_route) override;
};
}
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route_vivaldi, surf, "Routing part of surf");
+#define HOST_PEER(peername) bprintf("peer_%s", peername)
+#define ROUTER_PEER(peername) bprintf("router_%s", peername)
+#define LINK_PEER(peername) bprintf("link_%s", peername)
+
static XBT_INLINE double euclidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst) {
double src_coord, dst_coord;
/* ************************************************** */
/* ************** Vivaldi ROUTING **************** */
XBT_PRIVATE AS_t model_vivaldi_create(void); /* create structures for vivaldi routing model */
-#define HOST_PEER(peername) bprintf("peer_%s", peername)
-#define ROUTER_PEER(peername) bprintf("router_%s", peername)
-#define LINK_PEER(peername) bprintf("link_%s", peername)
namespace simgrid {
namespace surf {
class AsVivaldi: public AsGeneric {
public:
- sg_platf_route_cbarg_t *p_routingTable;
-
AsVivaldi() : AsGeneric() {};
~AsVivaldi() {};
- void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency);
- //void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges);
- //sg_platf_route_cbarg_t getBypassRoute(RoutingEdge *src, RoutingEdge *dst, double *lat);
-
- /* The parser calls the following functions to inform the routing models
- * that a new element is added to the AS currently built.
- *
- * Of course, only the routing model of this AS is informed, not every ones */
- int parsePU(NetCard *elm); /* A host or a router, whatever */
- //virtual int parseAS( RoutingEdge *elm)=0;
-
- //virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
+ void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;
+ int parsePU(NetCard *elm) override;
};
}