ADD_TEST(msg-masterslave-virtual-machines-thread ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:thread --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/masterslave_virtual_machines.tesh)
+ ADD_TEST(msg-cloud-two-tasks-vm-thread ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:thread --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/cloud/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/ --cd ${CMAKE_BINARY_DIR}/examples/msg/cloud/ ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/two_tasks_vm.tesh)
+
if(CONTEXT_UCONTEXT)
ADD_TEST(msg-sendrecv-CLM03-ucontext ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:ucontext --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv/sendrecv_CLM03.tesh)
ADD_TEST(msg-sendrecv-Vegas-ucontext ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:ucontext --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv/sendrecv_Vegas.tesh)
ADD_TEST(msg-masterslave-vivaldi-ucontext ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:ucontext --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_vivaldi.tesh)
ADD_TEST(msg-masterslave-virtual-machines-ucontext ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:ucontext --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/masterslave_virtual_machines.tesh)
+
+ ADD_TEST(msg-cloud-two-tasks-vm-ucontext ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:ucontext --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/cloud/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/ --cd ${CMAKE_BINARY_DIR}/examples/msg/cloud/ ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/two_tasks_vm.tesh)
endif()
if(HAVE_RAWCTX)
ADD_TEST(msg-masterslave-vivaldi-raw ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:raw --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_vivaldi.tesh)
ADD_TEST(msg-masterslave-virtual-machines-raw ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:raw --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/masterslave_virtual_machines.tesh)
+
+ ADD_TEST(msg-cloud-two-tasks-vm-raw ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:raw --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/cloud/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/ --cd ${CMAKE_BINARY_DIR}/examples/msg/cloud/ ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/two_tasks_vm.tesh)
+
endif()
ADD_TEST(msg-energy-pstates-thread ${TESH_COMMAND} ${TESH_OPTION} --cfg contexts/factory:thread --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e1/pstate.tesh)
add_executable(bound "bound.c")
add_executable(scale "scale.c")
add_executable(multicore "multicore.c")
+add_executable(two_tasks_vm "two_tasks_vm.c")
### Add definitions for compile
target_link_libraries(masterslave_virtual_machines simgrid)
target_link_libraries(bound simgrid)
target_link_libraries(scale simgrid)
target_link_libraries(multicore simgrid)
+target_link_libraries(two_tasks_vm simgrid)
+
set(tesh_files
${tesh_files}
${CMAKE_CURRENT_SOURCE_DIR}/masterslave_virtual_machines.tesh
+ ${CMAKE_CURRENT_SOURCE_DIR}/two_tasks_vm.tesh
PARENT_SCOPE
)
set(xml_files
${CMAKE_CURRENT_SOURCE_DIR}/bound.c
${CMAKE_CURRENT_SOURCE_DIR}/scale.c
${CMAKE_CURRENT_SOURCE_DIR}/multicore.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/two_tasks_vm.c
PARENT_SCOPE
)
set(bin_files
}
CpuCas01::~CpuCas01(){
- xbt_dynar_free(&p_powerPeakList);
+ if (getModel() == surf_cpu_model_pm)
+ xbt_dynar_free(&p_powerPeakList);
}
bool CpuCas01::isUsed()
xbt_dynar_t route = xbt_dynar_new(sizeof(RoutingEdgePtr), NULL);
- XBT_IN("(%s,%s,%g,%g)", src->p_name, dst->p_name, size, rate);
+ XBT_IN("(%s,%s,%g,%g)", src->getName(), dst->getName(), size, rate);
routing_platf->getRouteAndLatency(src, dst, &route, &latency);
xbt_assert(!xbt_dynar_is_empty(route) || latency,
"You're trying to send data from %s to %s but there is no connection at all between these two hosts.",
- src->p_name, dst->p_name);
+ src->getName(), dst->getName());
xbt_dynar_foreach(route, i, _link) {
link = static_cast<NetworkCm02LinkPtr>(_link);
link = *static_cast<NetworkCm02LinkPtr *>(xbt_dynar_get_ptr(route, 0));
gapAppend(size, link, action);
XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
- action, src->p_name, dst->p_name, action->m_senderGap,
+ action, src->getName(), dst->getName(), action->m_senderGap,
action->m_latency);
}
ActionPtr NetworkConstantModel::communicate(RoutingEdgePtr src, RoutingEdgePtr dst,
double size, double rate)
{
- char *src_name = src->p_name;
- char *dst_name = dst->p_name;
+ char *src_name = src->getName();
+ char *dst_name = dst->getName();
XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
NetworkConstantActionPtr action = new NetworkConstantAction(this, size, sg_latency_factor);
}
char *surf_routing_edge_name(sg_routing_edge_t edge){
- return edge->p_name;
+ return edge->getName();
}
#ifdef CONTEXT_THREADS
sg_config_finalize();
+ xbt_dynar_free(&host_that_restart);
+ xbt_dynar_free(&surf_path);
+
+ xbt_lib_free(&host_lib);
+ xbt_lib_free(&link_lib);
+ xbt_lib_free(&as_router_lib);
+ xbt_lib_free(&storage_lib);
+ xbt_lib_free(&storage_type_lib);
+
+ xbt_dict_free(&watched_hosts_lib);
+
xbt_dynar_foreach(model_list, iter, model)
delete model;
xbt_dynar_free(&model_list);
xbt_free(surf_mins);
surf_mins = NULL;
- xbt_dynar_free(&host_that_restart);
- xbt_dynar_free(&surf_path);
-
- xbt_lib_free(&host_lib);
- xbt_lib_free(&link_lib);
- xbt_lib_free(&as_router_lib);
- xbt_lib_free(&storage_lib);
- xbt_lib_free(&storage_type_lib);
-
- xbt_dict_free(&watched_hosts_lib);
-
tmgr_finalize();
surf_parse_lex_destroy();
surf_parse_free_callbacks();
current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
// If dynar is is greater than edge id and if the host_link is already defined
- if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->m_id &&
- xbt_dynar_get_as(current_routing->p_linkUpDownList, info->m_id, void*))
+ if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->getId() &&
+ xbt_dynar_get_as(current_routing->p_linkUpDownList, info->getId(), void*))
xbt_die("Host_link for '%s' is already defined!",host->id);
- XBT_DEBUG("Push Host_link for host '%s' to position %d", info->p_name, info->m_id);
- xbt_dynar_set_as(current_routing->p_linkUpDownList, info->m_id, s_surf_parsing_link_up_down_t, link_up_down);
+ XBT_DEBUG("Push Host_link for host '%s' to position %d", info->getName(), info->getId());
+ xbt_dynar_set_as(current_routing->p_linkUpDownList, info->getId(), s_surf_parsing_link_up_down_t, link_up_down);
}
/**
xbt_assert(!xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL),
"Reading a host, processing unit \"%s\" already exists", host->id);
- RoutingEdgePtr info = new RoutingEdge();
- info->p_rcComponent = current_routing;
- info->p_rcType = SURF_NETWORK_ELEMENT_HOST;
- info->p_name = xbt_strdup(host->id);
- info->m_id = current_routing->parsePU(info);
+ RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(host->id),
+ -1,
+ SURF_NETWORK_ELEMENT_HOST,
+ current_routing);
+ info->setId(current_routing->parsePU(info));
xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
- XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->m_id);
+ XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
"Reading a router, processing unit \"%s\" already exists",
router->id);
- RoutingEdgePtr info = new RoutingEdge();
- info->p_rcComponent = current_routing;
- info->p_rcType = SURF_NETWORK_ELEMENT_ROUTER;
- info->p_name = xbt_strdup(router->id);
- info->m_id = current_routing->parsePU(info);
+ RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(router->id),
+ -1,
+ SURF_NETWORK_ELEMENT_ROUTER,
+ current_routing);
+ 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->m_id);
+ XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->getId());
if (router->coord && strcmp(router->coord, "")) {
unsigned int cursor;
new_as->p_hierarchy = SURF_ROUTING_NULL;
new_as->p_name = xbt_strdup(AS->id);
- RoutingEdgePtr info = new RoutingEdge();
-
+ RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(new_as->p_name),
+ -1,
+ SURF_NETWORK_ELEMENT_AS,
+ current_routing);
if (current_routing == NULL && routing_platf->p_root == NULL) {
/* it is the first one */
new_as->p_routingFather = NULL;
routing_platf->p_root = new_as;
- info->m_id = -1;
+ info->setId(-1);
} else if (current_routing != NULL && routing_platf->p_root != NULL) {
xbt_assert(!xbt_dict_get_or_null
xbt_dict_set(current_routing->p_routingSons, AS->id,
(void *) new_as, NULL);
/* add to the father element list */
- info->m_id = current_routing->parseAS(info);
+ info->setId(current_routing->parseAS(info));
} else {
THROWF(arg_error, 0, "All defined components must be belong to a AS");
}
- info->p_rcComponent = new_as->p_routingFather;
- info->p_rcType = SURF_NETWORK_ELEMENT_AS;
- info->p_name = xbt_strdup(new_as->p_name);
-
- xbt_lib_set(as_router_lib, info->p_name, ROUTING_ASR_LEVEL,
+ xbt_lib_set(as_router_lib, info->getName(), ROUTING_ASR_LEVEL,
(void *) info);
- XBT_DEBUG("Having set name '%s' id '%d'", new_as->p_name, info->m_id);
+ XBT_DEBUG("Having set name '%s' id '%d'", new_as->p_name, info->getId());
/* set the new current component of the tree */
current_routing = new_as;
/* (1) find the as where the src and dst are located */
sg_routing_edge_t src_data = src;
sg_routing_edge_t dst_data = dst;
- src_as = src_data->p_rcComponent;
- dst_as = dst_data->p_rcComponent;
+ src_as = src_data->getRcComponent();
+ dst_as = dst_data->getRcComponent();
#ifndef NDEBUG
- char* src_name = src_data->p_name;
- char* dst_name = dst_data->p_name;
+ char* src_name = src_data->getName();
+ char* dst_name = dst_data->getName();
#endif
xbt_assert(src_as && dst_as,
memset(&route,0,sizeof(route));
xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
- XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->p_name, dst->p_name);
+ XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->getName(), dst->getName());
/* Find how src and dst are interconnected */
AsPtr common_father, src_father, dst_father;
&route, latency);
xbt_assert((route.gw_src != NULL) && (route.gw_dst != NULL),
- "bad gateways for route from \"%s\" to \"%s\"", src->p_name, dst->p_name);
+ "bad gateways for route from \"%s\" to \"%s\"", src->getName(), dst->getName());
sg_routing_edge_t src_gateway_net_elm = route.gw_src;
sg_routing_edge_t dst_gateway_net_elm = route.gw_dst;
}
e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_routing_edge_t edge){
- return edge->p_rcType;
+ return edge->getRcType();
}
void RoutingPlatf::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst,
xbt_dynar_t* route, double *latency)
{
- XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->p_name, dst->p_name);
+ XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->getName(), dst->getName());
if (!*route) {
xbt_dynar_reset(routing_platf->p_lastRoute);
*route = routing_platf->p_lastRoute;
_get_route_and_latency(src, dst, route, latency);
xbt_assert(!latency || *latency >= 0.0,
- "negative latency on route between \"%s\" and \"%s\"", src->p_name, dst->p_name);
+ "negative latency on route between \"%s\" and \"%s\"", src->getName(), dst->getName());
}
xbt_dynar_t RoutingPlatf::getOneLinkRoutes(){
{
RoutingEdgePtr rc = sg_routing_edge_by_name_or_null(name);
if (rc)
- return rc->p_rcType;
+ return rc->getRcType();
return SURF_NETWORK_ELEMENT_NULL;
}
xbt_dynar_t res = xbt_dynar_new(sizeof(xbt_dictelm_t), NULL);
for (index = 0; index < count; index++) {
relm = xbt_dynar_get_as(elms, index, RoutingEdgePtr);
- delm = xbt_lib_get_elm_or_null(host_lib, relm->p_name);
+ delm = xbt_lib_get_elm_or_null(host_lib, relm->getName());
if (delm!=NULL) {
xbt_dynar_push(res, &delm);
}
*/
struct RoutingEdge {
public:
- ~RoutingEdge() { xbt_free(p_name);};
+ virtual ~RoutingEdge(){};
+ virtual int getId()=0;
+ virtual int *getIdPtr()=0;
+ virtual void setId(int id)=0;
+ virtual char *getName()=0;
+ virtual AsPtr getRcComponent()=0;
+ virtual e_surf_network_element_type_t getRcType()=0;
+};
+
+struct RoutingEdgeImpl : public RoutingEdge {
+public:
+ RoutingEdgeImpl(char *name, int id, e_surf_network_element_type_t rcType, AsPtr rcComponent)
+ : p_rcComponent(rcComponent), p_rcType(rcType), m_id(id), p_name(name) {}
+ ~RoutingEdgeImpl() { xbt_free(p_name);};
+
+ int getId() {return m_id;}
+ int *getIdPtr() {return &m_id;}
+ void setId(int id) {m_id = id;}
+ char *getName() {return p_name;}
+ AsPtr getRcComponent() {return p_rcComponent;}
+ e_surf_network_element_type_t getRcType() {return p_rcType;}
+private:
AsPtr p_rcComponent;
e_surf_network_element_type_t p_rcType;
int m_id;
char *p_name;
};
+struct RoutingEdgeWrapper : public RoutingEdge {
+public:
+ RoutingEdgeWrapper(RoutingEdge *re) : p_re(re){}
+ ~RoutingEdgeWrapper(){}
+ int getId() {return p_re->getId();}
+ int *getIdPtr() {return p_re->getIdPtr();}
+ void setId(int id) {p_re->setId(id);}
+ char *getName() {return p_re->getName();}
+ AsPtr getRcComponent() {return p_re->getRcComponent();}
+ e_surf_network_element_type_t getRcType() {return p_re->getRcType();}
+private:
+ RoutingEdge *p_re;
+};
/** @ingroup SURF_routing_interface
* @brief Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
{
s_surf_parsing_link_up_down_t info;
XBT_VERB("cluster_get_route_and_latency from '%s'[%d] to '%s'[%d]",
- src->p_name, src->m_id, dst->p_name, dst->m_id);
+ src->getName(), src->getId(), dst->getName(), dst->getId());
- if (src->p_rcType != SURF_NETWORK_ELEMENT_ROUTER) { // No specific link for router
+ if (src->getRcType() != SURF_NETWORK_ELEMENT_ROUTER) { // No specific link for router
- if((src->m_id == dst->m_id) && p_has_loopback ){
- info = xbt_dynar_get_as(p_linkUpDownList, src->m_id * p_nb_links_per_node, s_surf_parsing_link_up_down_t);
+ if((src->getId() == dst->getId()) && p_has_loopback ){
+ info = xbt_dynar_get_as(p_linkUpDownList, src->getId() * p_nb_links_per_node, s_surf_parsing_link_up_down_t);
xbt_dynar_push_as(route->link_list, void *, info.link_up);
if (lat)
*lat += static_cast<NetworkLinkPtr>(info.link_up)->getLatency();
if (p_has_limiter){ // limiter for sender
- info = xbt_dynar_get_as(p_linkUpDownList, src->m_id * p_nb_links_per_node + p_has_loopback, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, src->getId() * p_nb_links_per_node + p_has_loopback, s_surf_parsing_link_up_down_t);
xbt_dynar_push_as(route->link_list, void *, info.link_up);
}
- info = xbt_dynar_get_as(p_linkUpDownList, src->m_id * p_nb_links_per_node + p_has_loopback + p_has_limiter, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, src->getId() * p_nb_links_per_node + p_has_loopback + p_has_limiter, s_surf_parsing_link_up_down_t);
if (info.link_up) { // link up
xbt_dynar_push_as(route->link_list, void *, info.link_up);
if (lat)
*lat += p_backbone->getLatency();
}
- if (dst->p_rcType != SURF_NETWORK_ELEMENT_ROUTER) { // No specific link for router
- info = xbt_dynar_get_as(p_linkUpDownList, dst->m_id * p_nb_links_per_node + p_has_loopback + p_has_limiter, s_surf_parsing_link_up_down_t);
+ if (dst->getRcType() != SURF_NETWORK_ELEMENT_ROUTER) { // No specific link for router
+ info = xbt_dynar_get_as(p_linkUpDownList, dst->getId() * p_nb_links_per_node + p_has_loopback + p_has_limiter, s_surf_parsing_link_up_down_t);
if (info.link_down) { // link down
xbt_dynar_push_as(route->link_list, void *, info.link_down);
*lat += static_cast<NetworkLinkPtr>(info.link_down)->getLatency();
}
if (p_has_limiter){ // limiter for receiver
- info = xbt_dynar_get_as(p_linkUpDownList, dst->m_id * p_nb_links_per_node + p_has_loopback, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, dst->getId() * p_nb_links_per_node + p_has_loopback, s_surf_parsing_link_up_down_t);
xbt_dynar_push_as(route->link_list, void *, info.link_up);
}
}
xbt_assert(p_router,"Malformed cluster");
/* create the router */
- char *link_name = p_router->p_name;
+ char *link_name = p_router->getName();
routerNode = new_xbt_graph_node(graph, link_name, nodes);
if(p_backbone) {
for (isrc = 0; isrc < table_size; isrc++) {
src = xbt_dynar_get_as(p_indexNetworkElm, isrc, RoutingEdgePtr);
- if (src->p_rcType != SURF_NETWORK_ELEMENT_ROUTER) {
- previous = new_xbt_graph_node(graph, src->p_name, nodes);
+ if (src->getRcType() != SURF_NETWORK_ELEMENT_ROUTER) {
+ previous = new_xbt_graph_node(graph, src->getName(), nodes);
- info = xbt_dynar_get_as(p_linkUpDownList, src->m_id, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, src->getId(), s_surf_parsing_link_up_down_t);
if (info.link_up) { // link up
}
int AsCluster::parsePU(RoutingEdgePtr elm) {
- XBT_DEBUG("Load process unit \"%s\"", elm->p_name);
+ XBT_DEBUG("Load process unit \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
return xbt_dynar_length(p_indexNetworkElm)-1;
}
int AsCluster::parseAS(RoutingEdgePtr elm) {
- XBT_DEBUG("Load Autonomous system \"%s\"", elm->p_name);
+ XBT_DEBUG("Load Autonomous system \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
return xbt_dynar_length(p_indexNetworkElm)-1;
}
void AsClusterTorus::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t route, double *lat){
XBT_VERB("torus_get_route_and_latency from '%s'[%d] to '%s'[%d]",
- src->p_name,src->m_id,
- dst->p_name,dst->m_id);
+ src->getName(), src->getId(),
+ dst->getName(), dst->getId());
- if (dst->p_rcType == SURF_NETWORK_ELEMENT_ROUTER || src->p_rcType == SURF_NETWORK_ELEMENT_ROUTER) return;
+ if (dst->getRcType() == SURF_NETWORK_ELEMENT_ROUTER || src->getRcType() == SURF_NETWORK_ELEMENT_ROUTER) return;
- if((src->m_id == dst->m_id) && p_has_loopback ){
- s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(p_linkUpDownList, src->m_id * p_nb_links_per_node, s_surf_parsing_link_up_down_t);
+ if((src->getId() == dst->getId()) && p_has_loopback ){
+ s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(p_linkUpDownList, src->getId() * p_nb_links_per_node, s_surf_parsing_link_up_down_t);
xbt_dynar_push_as(route->link_list, void *, info.link_up);
if (lat)
* TODO Change to dynamic assignment
*/
unsigned int j, cur_dim, dim_product = 1;
- int current_node = src->m_id;
+ int current_node = src->getId();
int unsigned next_node = 0;
/**
* Arrays that hold the coordinates of the current node and
* into this dimension or not.
*/
unsigned int* myCoords, *targetCoords;
- myCoords = rankId_to_coords(src->m_id, p_dimensions);
- targetCoords = rankId_to_coords(dst->m_id, p_dimensions);
+ myCoords = rankId_to_coords(src->getId(), p_dimensions);
+ targetCoords = rankId_to_coords(dst->getId(), p_dimensions);
/**
* linkOffset describes the offset where the link
* we want to use is stored
* which can only be the case if src->m_id == dst->m_id -- see above
* for this special case)
*/
- int nodeOffset = (xbt_dynar_length(p_dimensions)+1)*src->m_id;
+ int nodeOffset = (xbt_dynar_length(p_dimensions)+1)*src->getId();
int linkOffset = nodeOffset;
bool use_lnk_up = false; // Is this link of the form "cur -> next" or "next -> cur"?
// false means: next -> cur
- while (current_node != dst->m_id) {
+ while (current_node != dst->getId()) {
dim_product = 1; // First, we will route in x-dimension
for (j = 0; j < xbt_dynar_length(p_dimensions); j++) {
cur_dim = xbt_dynar_get_as(p_dimensions, j, int);
// current_node/dim_product = position in current dimension
- if ((current_node/dim_product) % cur_dim != (dst->m_id/dim_product) % cur_dim) {
+ if ((current_node/dim_product) % cur_dim != (dst->getId()/dim_product) % cur_dim) {
if (( targetCoords[j] > myCoords[j] && targetCoords[j] <= myCoords[j]+cur_dim/2) // Is the target node on the right, without the wrap-around?
|| ( myCoords[j] > cur_dim/2 && (myCoords[j]+cur_dim/2)%cur_dim >= targetCoords[j] )) { // Or do we need to use the wrap around to reach it?
/* set utils vars */
srcDstCheck(src, dst);
- int *src_id = &(src->m_id);
- int *dst_id = &(dst->m_id);
+ int *src_id = src->getIdPtr();
+ int *dst_id = dst->getIdPtr();
if (!src_id || !dst_id)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src->p_name,dst->p_name);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src->getName(),dst->getName());
int *pred_arr = NULL;
int src_node_id = 0;
xbt_edge_t edge = xbt_graph_get_edge(p_routeGraph, node_s_v, node_e_v);
if (edge == NULL)
- THROWF(arg_error, 0, "No route from '%s' to '%s'", src->p_name, dst->p_name);
+ THROWF(arg_error, 0, "No route from '%s' to '%s'", src->getName(), dst->getName());
e_route = (sg_platf_route_cbarg_t) xbt_graph_edge_get_data(edge);
xbt_graph_get_edge(p_routeGraph, node_pred_v, node_v);
if (edge == NULL)
- THROWF(arg_error, 0, "No route from '%s' to '%s'", src->p_name, dst->p_name);
+ THROWF(arg_error, 0, "No route from '%s' to '%s'", src->getName(), dst->getName());
prev_gw_src = gw_src;
first_gw = gw_dst;
if (p_hierarchy == SURF_ROUTING_RECURSIVE && v != dst_node_id
- && strcmp(gw_dst->p_name, prev_gw_src->p_name)) {
+ && strcmp(gw_dst->getName(), prev_gw_src->getName())) {
xbt_dynar_t e_route_as_to_as=NULL;
routing_platf->getRouteAndLatency(gw_dst_net_elm, prev_gw_src_net_elm, &e_route_as_to_as, NULL);
if (edge == NULL)
- THROWF(arg_error,0,"No route from '%s' to '%s'", src->p_name, dst->p_name);
+ THROWF(arg_error,0,"No route from '%s' to '%s'", src->getName(), dst->getName());
links = e_route_as_to_as;
int pos = 0;
xbt_dynar_foreach(links, cpt, link) {
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
else{
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
- route->gw_src->p_name, dst, route->gw_dst->p_name);
+ route->gw_src->getName(), dst, route->gw_dst->getName());
as_route = 1;
- if(route->gw_dst->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The gw_dst '%s' does not exist!",route->gw_dst->p_name);
- if(route->gw_src->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The gw_src '%s' does not exist!",route->gw_src->p_name);
+ if(route->gw_dst->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The gw_dst '%s' does not exist!",route->gw_dst->getName());
+ if(route->gw_src->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The gw_src '%s' does not exist!",route->gw_src->getName());
}
RoutingEdgePtr src_net_elm, dst_net_elm;
p_routeCache = xbt_dict_new_homogeneous(&route_cache_elem_free);
sg_platf_route_cbarg_t e_route = newExtendedRoute(p_hierarchy, route, 1);
- newRoute(src_net_elm->m_id, dst_net_elm->m_id, e_route);
+ newRoute(src_net_elm->getId(), dst_net_elm->getId(), e_route);
// Symmetrical YES
if ( (route->symmetrical == TRUE && as_route == 0)
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
- route->gw_dst->p_name, src, route->gw_src->p_name);
+ route->gw_dst->getName(), src, route->gw_src->getName());
xbt_dynar_t nodes = xbt_graph_get_nodes(p_routeGraph);
- xbt_node_t node_s_v = xbt_dynar_get_as(nodes, src_net_elm->m_id, xbt_node_t);
- xbt_node_t node_e_v = xbt_dynar_get_as(nodes, dst_net_elm->m_id, xbt_node_t);
+ xbt_node_t node_s_v = xbt_dynar_get_as(nodes, src_net_elm->getId(), xbt_node_t);
+ xbt_node_t node_e_v = xbt_dynar_get_as(nodes, dst_net_elm->getId(), xbt_node_t);
xbt_edge_t edge =
xbt_graph_get_edge(p_routeGraph, node_e_v, node_s_v);
route->gw_dst = gw_tmp;
}
sg_platf_route_cbarg_t link_route_back = newExtendedRoute(p_hierarchy, route, 0);
- newRoute(dst_net_elm->m_id, src_net_elm->m_id, link_route_back);
+ newRoute(dst_net_elm->getId(), src_net_elm->getId(), link_route_back);
}
xbt_dynar_free(&route->link_list);
}
/* create a result route */
xbt_dynar_t route_stack = xbt_dynar_new(sizeof(sg_platf_route_cbarg_t), NULL);
int pred;
- int cur = dst->m_id;
+ int cur = dst->getId();
do {
- pred = TO_FLOYD_PRED(src->m_id, cur);
+ pred = TO_FLOYD_PRED(src->getId(), cur);
if (pred == -1)
- THROWF(arg_error, 0, "No route from '%s' to '%s'", src->p_name, dst->p_name);
+ THROWF(arg_error, 0, "No route from '%s' to '%s'", src->getName(), dst->getName());
xbt_dynar_push_as(route_stack, sg_platf_route_cbarg_t, TO_FLOYD_LINK(pred, cur));
cur = pred;
- } while (cur != src->m_id);
+ } while (cur != src->getId());
if (p_hierarchy == SURF_ROUTING_RECURSIVE) {
res->gw_src = xbt_dynar_getlast_as(route_stack, sg_platf_route_cbarg_t)->gw_src;
unsigned int cpt;
if (p_hierarchy == SURF_ROUTING_RECURSIVE && prev_dst_gw != NULL
- && strcmp(prev_dst_gw->p_name, e_route->gw_src->p_name)) {
+ && strcmp(prev_dst_gw->getName(), e_route->gw_src->getName())) {
routing_get_route_and_latency(prev_dst_gw, e_route->gw_src,
&res->link_list, lat);
}
else{
as_route = 1;
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
- route->gw_src->p_name, dst, route->gw_dst->p_name);
- if(route->gw_dst->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The dst_gateway '%s' does not exist!",route->gw_dst->p_name);
- if(route->gw_src->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The src_gateway '%s' does not exist!",route->gw_src->p_name);
+ route->gw_src->getName(), dst, route->gw_dst->getName());
+ if(route->gw_dst->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The dst_gateway '%s' does not exist!",route->gw_dst->getName());
+ if(route->gw_src->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The src_gateway '%s' does not exist!",route->gw_src->getName());
}
- if(TO_FLOYD_LINK(src_net_elm->m_id, dst_net_elm->m_id))
+ if(TO_FLOYD_LINK(src_net_elm->getId(), dst_net_elm->getId()))
{
char * link_name;
xbt_dynar_push(link_route_to_test,&link);
}
xbt_assert(!xbt_dynar_compare(
- TO_FLOYD_LINK(src_net_elm->m_id, dst_net_elm->m_id)->link_list,
+ TO_FLOYD_LINK(src_net_elm->getId(), dst_net_elm->getId())->link_list,
link_route_to_test,
(int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,dst);
}
else
{
- TO_FLOYD_LINK(src_net_elm->m_id, dst_net_elm->m_id) =
+ TO_FLOYD_LINK(src_net_elm->getId(), dst_net_elm->getId()) =
newExtendedRoute(p_hierarchy, route, 1);
- TO_FLOYD_PRED(src_net_elm->m_id, dst_net_elm->m_id) = src_net_elm->m_id;
- TO_FLOYD_COST(src_net_elm->m_id, dst_net_elm->m_id) =
- ((TO_FLOYD_LINK(src_net_elm->m_id, dst_net_elm->m_id))->link_list)->used; /* count of links, old model assume 1 */
+ TO_FLOYD_PRED(src_net_elm->getId(), dst_net_elm->getId()) = src_net_elm->getId();
+ TO_FLOYD_COST(src_net_elm->getId(), dst_net_elm->getId()) =
+ ((TO_FLOYD_LINK(src_net_elm->getId(), dst_net_elm->getId()))->link_list)->used; /* count of links, old model assume 1 */
}
if ( (route->symmetrical == TRUE && as_route == 0)
|| (route->symmetrical == TRUE && as_route == 1)
)
{
- if(TO_FLOYD_LINK(dst_net_elm->m_id, src_net_elm->m_id))
+ if(TO_FLOYD_LINK(dst_net_elm->getId(), src_net_elm->getId()))
{
if(!route->gw_dst && !route->gw_src)
XBT_DEBUG("See Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
- route->gw_src->p_name, src, route->gw_dst->p_name);
+ route->gw_src->getName(), src, route->gw_dst->getName());
char * link_name;
unsigned int i;
xbt_dynar_t link_route_to_test = xbt_dynar_new(sizeof(sg_routing_link_t), NULL);
xbt_dynar_push(link_route_to_test,&link);
}
xbt_assert(!xbt_dynar_compare(
- TO_FLOYD_LINK(dst_net_elm->m_id, src_net_elm->m_id)->link_list,
+ TO_FLOYD_LINK(dst_net_elm->getId(), src_net_elm->getId())->link_list,
link_route_to_test,
(int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,dst);
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
- route->gw_src->p_name, src, route->gw_dst->p_name);
+ route->gw_src->getName(), src, route->gw_dst->getName());
- TO_FLOYD_LINK(dst_net_elm->m_id, src_net_elm->m_id) =
+ TO_FLOYD_LINK(dst_net_elm->getId(), src_net_elm->getId()) =
newExtendedRoute(p_hierarchy, route, 0);
- TO_FLOYD_PRED(dst_net_elm->m_id, src_net_elm->m_id) = dst_net_elm->m_id;
- TO_FLOYD_COST(dst_net_elm->m_id, src_net_elm->m_id) =
- ((TO_FLOYD_LINK(dst_net_elm->m_id, src_net_elm->m_id))->link_list)->used; /* count of links, old model assume 1 */
+ TO_FLOYD_PRED(dst_net_elm->getId(), src_net_elm->getId()) = dst_net_elm->getId();
+ TO_FLOYD_COST(dst_net_elm->getId(), src_net_elm->getId()) =
+ ((TO_FLOYD_LINK(dst_net_elm->getId(), src_net_elm->getId()))->link_list)->used; /* count of links, old model assume 1 */
}
}
xbt_dynar_free(&route->link_list);
OnelinkPtr onelink;
if (p_hierarchy == SURF_ROUTING_BASE) {
RoutingEdgePtr tmp_src = xbt_dynar_get_as(p_indexNetworkElm, src, sg_routing_edge_t);
- tmp_src->m_id = src;
+ tmp_src->setId(src);
RoutingEdgePtr tmp_dst = xbt_dynar_get_as(p_indexNetworkElm, dst, sg_routing_edge_t);
- tmp_dst->m_id = dst;
+ tmp_dst->setId(dst);
onelink = new Onelink(link, tmp_src, tmp_dst);
} else if (p_hierarchy == SURF_ROUTING_RECURSIVE)
onelink = new Onelink(link, route->gw_src, route->gw_dst);
void AsFull::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t res, double *lat)
{
XBT_DEBUG("full_get_route_and_latency from %s[%d] to %s[%d]",
- src->p_name,
- src->m_id,
- dst->p_name,
- dst->m_id );
+ src->getName(),
+ src->getId(),
+ dst->getName(),
+ dst->getId());
/* set utils vars */
size_t table_size = xbt_dynar_length(p_indexNetworkElm);
void *link;
unsigned int cpt = 0;
- e_route = TO_ROUTE_FULL(src->m_id, dst->m_id);
+ e_route = TO_ROUTE_FULL(src->getId(), dst->getId());
if (e_route) {
res->gw_src = e_route->gw_src;
if (!p_routingTable)
p_routingTable = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size);
- if (TO_ROUTE_FULL(src_net_elm->m_id, dst_net_elm->m_id)) {
+ if (TO_ROUTE_FULL(src_net_elm->getId(), dst_net_elm->getId())) {
char *link_name;
unsigned int i;
xbt_dynar_t link_route_to_test =
xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
xbt_dynar_push(link_route_to_test, &link);
}
- if (xbt_dynar_compare(TO_ROUTE_FULL(src_net_elm->m_id, dst_net_elm->m_id)->link_list,
+ if (xbt_dynar_compare(TO_ROUTE_FULL(src_net_elm->getId(), dst_net_elm->getId())->link_list,
link_route_to_test, full_pointer_resource_cmp)) {
surf_parse_error("A route between \"%s\" and \"%s\" already exists "
"with a different content. "
// route->dst_gateway, subas->name);
as_route = 1;
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
- src, route->gw_src->p_name, dst, route->gw_dst->p_name);
- if (route->gw_dst->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The dst_gateway '%s' does not exist!", route->gw_dst->p_name);
- if (route->gw_src->p_rcType == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The src_gateway '%s' does not exist!", route->gw_src->p_name);
+ src, route->gw_src->getName(), dst, route->gw_dst->getName());
+ if (route->gw_dst->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The dst_gateway '%s' does not exist!", route->gw_dst->getName());
+ if (route->gw_src->getRcType() == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The src_gateway '%s' does not exist!", route->gw_src->getName());
}
- TO_ROUTE_FULL(src_net_elm->m_id, dst_net_elm->m_id) = newExtendedRoute(p_hierarchy, route, 1);
- xbt_dynar_shrink(TO_ROUTE_FULL(src_net_elm->m_id, dst_net_elm->m_id)->link_list, 0);
+ TO_ROUTE_FULL(src_net_elm->getId(), dst_net_elm->getId()) = newExtendedRoute(p_hierarchy, route, 1);
+ xbt_dynar_shrink(TO_ROUTE_FULL(src_net_elm->getId(), dst_net_elm->getId())->link_list, 0);
}
if ( (route->symmetrical == TRUE && as_route == 0)
route->gw_src = route->gw_dst;
route->gw_dst = gw_tmp;
}
- if (TO_ROUTE_FULL(dst_net_elm->m_id, src_net_elm->m_id)) {
+ if (TO_ROUTE_FULL(dst_net_elm->getId(), src_net_elm->getId())) {
char *link_name;
unsigned int i;
xbt_dynar_t link_route_to_test =
xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
xbt_dynar_push(link_route_to_test, &link);
}
- xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(dst_net_elm->m_id, src_net_elm->m_id)->link_list,
+ xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(dst_net_elm->getId(), src_net_elm->getId())->link_list,
link_route_to_test,
full_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
- dst, route->gw_src->p_name, src, route->gw_dst->p_name);
- TO_ROUTE_FULL(dst_net_elm->m_id, src_net_elm->m_id) = newExtendedRoute(p_hierarchy, route, 0);
- xbt_dynar_shrink(TO_ROUTE_FULL(dst_net_elm->m_id, src_net_elm->m_id)->link_list, 0);
+ dst, route->gw_src->getName(), src, route->gw_dst->getName());
+ TO_ROUTE_FULL(dst_net_elm->getId(), src_net_elm->getId()) = newExtendedRoute(p_hierarchy, route, 0);
+ xbt_dynar_shrink(TO_ROUTE_FULL(dst_net_elm->getId(), src_net_elm->getId())->link_list, 0);
}
}
xbt_dynar_free(&route->link_list);
int AsGeneric::parsePU(RoutingEdgePtr elm)
{
- XBT_DEBUG("Load process unit \"%s\"", elm->p_name);
+ XBT_DEBUG("Load process unit \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
return xbt_dynar_length(p_indexNetworkElm)-1;
}
int AsGeneric::parseAS(RoutingEdgePtr elm)
{
- XBT_DEBUG("Load Autonomous system \"%s\"", elm->p_name);
+ XBT_DEBUG("Load Autonomous system \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
return xbt_dynar_length(p_indexNetworkElm)-1;
}
src, dst);
xbt_assert(!xbt_dict_get_or_null(dict_bypassRoutes, route_name),
"The bypass route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exists",
- src, e_route->gw_src->p_name, dst, e_route->gw_dst->p_name);
+ src, e_route->gw_src->getName(), dst, e_route->gw_dst->getName());
sg_platf_route_cbarg_t new_e_route = NULL;
if(e_route->gw_dst)
getRouteAndLatency(my_src, my_dst, route, NULL);
- XBT_DEBUG ("get_route_and_latency %s -> %s", my_src->p_name, my_dst->p_name);
+ XBT_DEBUG ("get_route_and_latency %s -> %s", my_src->getName(), my_dst->getName());
unsigned int cpt;
void *link;
const char *previous_name, *current_name;
if (route->gw_src) {
- previous = new_xbt_graph_node(graph, route->gw_src->p_name, nodes);
- previous_name = route->gw_src->p_name;
+ previous = new_xbt_graph_node(graph, route->gw_src->getName(), nodes);
+ previous_name = route->gw_src->getName();
} else {
- previous = new_xbt_graph_node(graph, my_src->p_name, nodes);
- previous_name = my_src->p_name;
+ previous = new_xbt_graph_node(graph, my_src->getName(), nodes);
+ previous_name = my_src->getName();
}
xbt_dynar_foreach(route->link_list, cpt, link) {
}
if (route->gw_dst) {
- current = new_xbt_graph_node(graph, route->gw_dst->p_name, nodes);
- current_name = route->gw_dst->p_name;
+ current = new_xbt_graph_node(graph, route->gw_dst->getName(), nodes);
+ current_name = route->gw_dst->getName();
} else {
- current = new_xbt_graph_node(graph, my_dst->p_name, nodes);
- current_name = my_dst->p_name;
+ current = new_xbt_graph_node(graph, my_dst->getName(), nodes);
+ current_name = my_dst->getName();
}
new_xbt_graph_edge(graph, previous, current, edges);
XBT_DEBUG (" %s -> %s", previous_name, current_name);
double *lat)
{
// If never set a bypass route return NULL without any further computations
- XBT_DEBUG("generic_get_bypassroute from %s to %s", src->p_name, dst->p_name);
+ XBT_DEBUG("generic_get_bypassroute from %s to %s", src->getName(), dst->getName());
if (no_bypassroute_declared)
return NULL;
sg_platf_route_cbarg_t e_route_bypass = NULL;
xbt_dict_t dict_bypassRoutes = p_bypassRoutes;
- if(dst->p_rcComponent == this && src->p_rcComponent == this ){
- char *route_name = bprintf("%s#%s", src->p_name, dst->p_name);
+ if(dst->getRcComponent() == this && src->getRcComponent() == this ){
+ char *route_name = bprintf("%s#%s", src->getName(), dst->getName());
e_route_bypass = (sg_platf_route_cbarg_t) xbt_dict_get_or_null(dict_bypassRoutes, route_name);
if(e_route_bypass)
XBT_DEBUG("Find bypass route with %ld links",xbt_dynar_length(e_route_bypass->link_list));
if (src == NULL || dst == NULL)
xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
- src->p_name, dst->p_name, p_name);
+ src->getName(), dst->getName(), p_name);
- src_as = src->p_rcComponent;
- dst_as = dst->p_rcComponent;
+ src_as = src->getRcComponent();
+ dst_as = dst->getRcComponent();
/* (2) find the path to the root routing component */
path_src = xbt_dynar_new(sizeof(AsPtr), NULL);
char *key;
element_as = ((RoutingEdgePtr)
xbt_lib_get_or_null(as_router_lib, element,
- ROUTING_ASR_LEVEL))->p_rcComponent;
+ ROUTING_ASR_LEVEL))->getRcComponent();
result = ((AsPtr) - 1);
if (element_as != this)
result = asExist(element_as);
AsPtr element_as;
element_as = ((RoutingEdgePtr)
xbt_lib_get_or_null(host_lib,
- element, ROUTING_HOST_LEVEL))->p_rcComponent;
+ element, ROUTING_HOST_LEVEL))->getRcComponent();
if (element_as == this)
return element_as;
return asExist(element_as);
if (src_data == NULL || dst_data == NULL)
xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
- src->p_name,
- dst->p_name,
+ src->getName(),
+ dst->getName(),
p_name);
AsPtr src_as =
- (src_data)->p_rcComponent;
+ (src_data)->getRcComponent();
AsPtr dst_as =
- (dst_data)->p_rcComponent;
+ (dst_data)->getRcComponent();
if (src_as != dst_as)
xbt_die("The src(%s in %s) and dst(%s in %s) are in differents AS",
- src->p_name, src_as->p_name,
- dst->p_name, dst_as->p_name);
+ src->getName(), src_as->p_name,
+ dst->getName(), dst_as->p_name);
if (this != dst_as)
xbt_die
("The routing component of src'%s' and dst'%s' is not the same as the network elements belong (%s?=%s?=%s)",
- src->p_name,
- dst->p_name,
+ src->getName(),
+ dst->getName(),
src_as->p_name,
dst_as->p_name,
p_name);
}
int AsNone::parsePU(RoutingEdgePtr elm) {
- XBT_DEBUG("Load process unit \"%s\"", elm->p_name);
+ XBT_DEBUG("Load process unit \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
/* don't care about PUs */
return -1;
}
int AsNone::parseAS(RoutingEdgePtr elm) {
- XBT_DEBUG("Load Autonomous system \"%s\"", elm->p_name);
+ XBT_DEBUG("Load Autonomous system \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, RoutingEdgePtr, elm);
/* even don't care about sub-ASes -- I'm as nihilist as an old punk*/
return -1;
s_surf_parsing_link_up_down_t info;
XBT_DEBUG("vivaldi_get_route_and_latency from '%s'[%d] '%s'[%d]",
- src->p_name, src->m_id, dst->p_name, dst->m_id);
+ src->getName(), src->getId(), dst->getName(), dst->getId());
- if(src->p_rcType == SURF_NETWORK_ELEMENT_AS) {
- char *src_name = ROUTER_PEER(src->p_name);
- char *dst_name = ROUTER_PEER(dst->p_name);
+ if(src->getRcType() == SURF_NETWORK_ELEMENT_AS) {
+ char *src_name = ROUTER_PEER(src->getName());
+ char *dst_name = ROUTER_PEER(dst->getName());
route->gw_src = (sg_routing_edge_t) xbt_lib_get_or_null(as_router_lib, src_name, ROUTING_ASR_LEVEL);
route->gw_dst = (sg_routing_edge_t) xbt_lib_get_or_null(as_router_lib, dst_name, ROUTING_ASR_LEVEL);
xbt_free(src_name);
xbt_dynar_t src_ctn, dst_ctn;
char *tmp_src_name, *tmp_dst_name;
- if(src->p_rcType == SURF_NETWORK_ELEMENT_HOST){
- tmp_src_name = HOST_PEER(src->p_name);
+ if(src->getRcType() == SURF_NETWORK_ELEMENT_HOST){
+ tmp_src_name = HOST_PEER(src->getName());
if(p_linkUpDownList){
- info = xbt_dynar_get_as(p_linkUpDownList, src->m_id, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, src->getId(), s_surf_parsing_link_up_down_t);
if(info.link_up) { // link up
xbt_dynar_push_as(route->link_list, void*, info.link_up);
if (lat)
}
}
src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, tmp_src_name, COORD_HOST_LEVEL);
- if(!src_ctn ) src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, src->p_name, COORD_HOST_LEVEL);
+ if(!src_ctn ) src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, src->getName(), COORD_HOST_LEVEL);
}
- else if(src->p_rcType == SURF_NETWORK_ELEMENT_ROUTER || src->p_rcType == SURF_NETWORK_ELEMENT_AS){
- tmp_src_name = ROUTER_PEER(src->p_name);
+ else if(src->getRcType() == SURF_NETWORK_ELEMENT_ROUTER || src->getRcType() == SURF_NETWORK_ELEMENT_AS){
+ tmp_src_name = ROUTER_PEER(src->getName());
src_ctn = (xbt_dynar_t) xbt_lib_get_or_null(as_router_lib, tmp_src_name, COORD_ASR_LEVEL);
}
else{
THROW_IMPOSSIBLE;
}
- if(dst->p_rcType == SURF_NETWORK_ELEMENT_HOST){
- tmp_dst_name = HOST_PEER(dst->p_name);
+ if(dst->getRcType() == SURF_NETWORK_ELEMENT_HOST){
+ tmp_dst_name = HOST_PEER(dst->getName());
if(p_linkUpDownList){
- info = xbt_dynar_get_as(p_linkUpDownList, dst->m_id, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(p_linkUpDownList, dst->getId(), s_surf_parsing_link_up_down_t);
if(info.link_down) { // link down
xbt_dynar_push_as(route->link_list,void*,info.link_down);
if (lat)
}
}
dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, tmp_dst_name, COORD_HOST_LEVEL);
- if(!dst_ctn ) dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, dst->p_name, COORD_HOST_LEVEL);
+ if(!dst_ctn ) dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(host_lib, dst->getName(), COORD_HOST_LEVEL);
}
- else if(dst->p_rcType == SURF_NETWORK_ELEMENT_ROUTER || dst->p_rcType == SURF_NETWORK_ELEMENT_AS){
- tmp_dst_name = ROUTER_PEER(dst->p_name);
+ else if(dst->getRcType() == SURF_NETWORK_ELEMENT_ROUTER || dst->getRcType() == SURF_NETWORK_ELEMENT_AS){
+ tmp_dst_name = ROUTER_PEER(dst->getName());
dst_ctn = (xbt_dynar_t) xbt_lib_get_or_null(as_router_lib, tmp_dst_name, COORD_ASR_LEVEL);
}
else{
}
int AsVivaldi::parsePU(RoutingEdgePtr elm) {
- XBT_DEBUG("Load process unit \"%s\"", elm->p_name);
+ XBT_DEBUG("Load process unit \"%s\"", elm->getName());
xbt_dynar_push_as(p_indexNetworkElm, sg_routing_edge_t, elm);
return xbt_dynar_length(p_indexNetworkElm)-1;
}
* from the VM name, we have to make sure that the system does not call the
* free callback for the network resource object. The network resource object
* is still used by the physical machine. */
- p_netElm = static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, sub_ws->getName(), ROUTING_HOST_LEVEL));
+ p_netElm = new RoutingEdgeWrapper(static_cast<RoutingEdgePtr>(xbt_lib_get_or_null(host_lib, sub_ws->getName(), ROUTING_HOST_LEVEL)));
xbt_lib_set(host_lib, name, ROUTING_HOST_LEVEL, p_netElm);
p_subWs = sub_ws;
