Commit f43fe219 authored by Ricardo Martínez's avatar Ricardo Martínez
Browse files

PathComp component - Backend: 

- Added missing gitignore entries
- Added log messages
parent a4ddc9a4

src/pathcomp/.gitignore

+3 −0
Original line number Diff line number Diff line 
backend/wireshark

backend/*.o

backend/pathComp

backend/pathComp-dbg

src/pathcomp/backend/pathComp_sp.c

+1 −1
Original line number Diff line number Diff line
@@ -144,7 +144,7 @@ void computation_shortest_path(struct service_t* s, struct compRouteOutput_t* pa 
	DEBUG_PC("Computed Path Avail Bw: %f, Path Cost: %f, latency: %f", p->availCap, p->cost, p->delay);

	print_path(p);



	gboolean feasibleRoute = check_computed_path_feasability(s, p);

	gboolean feasibleRoute = check_computed_path_feasibility(s, p);

	if (feasibleRoute == TRUE) {

		DEBUG_PC("SP Feasible");

		print_path(p);

src/pathcomp/backend/pathComp_tools.c

+38 −32
Original line number Diff line number Diff line
@@ -1460,8 +1460,7 @@ void modify_targeted_graph (struct graph_t *g, struct path_set_t *A, struct comp 
 *	@date 2022

 */

/////////////////////////////////////////////////////////////////////////////////////////

gint find_nodeId (gconstpointer data, gconstpointer userdata)

{

gint find_nodeId (gconstpointer data, gconstpointer userdata) {

     /** check values */

     g_assert(data != NULL);

     g_assert(userdata != NULL);
@@ -1471,8 +1470,7 @@ gint find_nodeId (gconstpointer data, gconstpointer userdata) 
     

     //DEBUG_PC ("SNodeId (%s) nodeId (%s)", SNodeId->node.nodeId, nodeId);   

        

     if (!memcmp(SNodeId->node.nodeId, nodeId, strlen (SNodeId->node.nodeId)))

     {

     if (!memcmp(SNodeId->node.nodeId, nodeId, strlen (SNodeId->node.nodeId))) {

		return (0);

     }

    return -1;
@@ -1501,13 +1499,13 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
	g_assert(g); g_assert(s); g_assert(mapNodes);



	struct targetNodes_t *v = &(g->vertices[indexGraphU].targetedVertices[indexGraphV]);	

    DEBUG_PC("Explored Link %s => %s)", u->node.nodeId, v->tVertice.nodeId);

    DEBUG_PC("=======================CHECK Edge %s => %s =================================", u->node.nodeId, v->tVertice.nodeId);

	//DEBUG_PC("\t %s => %s", u->node.nodeId, v->tVertice.nodeId);	

    

    // v already explored in S? then, discard it

    GList *found = g_list_find_custom (*S, v->tVertice.nodeId, find_nodeId);

    if (found != NULL) {

        DEBUG_PC ("v (%s) in S, Discard", v->tVertice.nodeId);        

        DEBUG_PC ("%s in S, DISCARD", v->tVertice.nodeId);        

        return 0;

    }
@@ -1524,10 +1522,11 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
		DEBUG_PC("EDGE %s[%s] => %s[%s]", u->node.nodeId, e->aEndPointId, v->tVertice.nodeId, e->zEndPointId);

        //DEBUG_PC ("\t %s[%s] =>", u->node.nodeId, e->aEndPointId);

		//DEBUG_PC("\t => %s[%s]", v->tVertice.nodeId, e->zEndPointId);

		DEBUG_PC("\t AvailBw: %f, TotalBw: %f", edgeAvailBw, edgeTotalBw);

		DEBUG_PC("\t Edge Att: AvailBw: %f, TotalBw: %f", edgeAvailBw, edgeTotalBw);

        // Check Service Bw constraint

		if ((path_constraints->bw == TRUE) && (edgeAvailBw < path_constraints->bwConstraint))

		if ((path_constraints->bw == TRUE) && (edgeAvailBw < path_constraints->bwConstraint)) {

			continue;

		}

		else {

			foundAvailBw = 1;

			break;
@@ -1535,7 +1534,7 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
    }

	// BW constraint NOT MET, then DISCARD edge

    if ((path_constraints->bw == TRUE) && (foundAvailBw == 0)) {

        DEBUG_PC ("AvailBw: %f < path_constraint: %f -- Discard Edge", edgeAvailBw, path_constraints->bwConstraint);

       	DEBUG_PC ("Edge AvailBw: %f < path_constraint: %f -- DISCARD Edge", edgeAvailBw, path_constraints->bwConstraint);

		g_free(path_constraints);

        return 0;    

    }
@@ -1581,13 +1580,14 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
	if (arg & ENERGY_EFFICIENT_ARGUMENT) {

		if (distance_through_u == v_map->distance) {

			if (power_through_u > v_map->power) {

				DEBUG_PC("Energy (src -> u + u -> v: %f (Watts) >Energy (src, v): %f (Watts)--> DISCARD LINK", power_through_u, v_map->power);

				DEBUG_PC("Energy (src -> u + u -> v: %f (Watts) > Energy (src, v): %f (Watts) --> DISCARD EDGE", power_through_u, v_map->power);

				return 0;

			}

			// same energy consumption, consider latency

			if ((power_through_u == v_map->power) && (latency_through_u > v_map->latency)) {

				return 0;

			}

			// same energy, same latency, criteria: choose the one having the largest available bw

			if ((power_through_u == v_map->power) && (latency_through_u == v_map->latency) && (availBw_through_u < v_map->avaiBandwidth)) {

				return 0;

			}
@@ -1604,8 +1604,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
			return 0;

		}

	}

    DEBUG_PC ("%s --> %s Relaxed", u->node.nodeId, v->tVertice.nodeId);

    DEBUG_PC ("\t AvailBw: %f Mb/s, Cost: %f, Latency: %f ms, Energy: %f Watts", availBw_through_u, distance_through_u, latency_through_u, power_through_u);

   	DEBUG_PC ("Edge %s --> %s [RELAXED]", u->node.nodeId, v->tVertice.nodeId);

    DEBUG_PC ("\t path till %s: AvailBw: %f Mb/s | Cost: %f | Latency: %f ms | Energy: %f Watts", v->tVertice.nodeId, availBw_through_u, distance_through_u,

																latency_through_u, power_through_u);

    

    // Update Q list -- 

    struct nodeItem_t *nodeItem = g_malloc0 (sizeof (struct nodeItem_t));
@@ -1622,8 +1623,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
	if (arg & ENERGY_EFFICIENT_ARGUMENT) {

		*Q = g_list_insert_sorted(*Q, nodeItem, sort_by_energy);

	}

	else

	else {

		*Q = g_list_insert_sorted (*Q, nodeItem, sort_by_distance);

	}

    

	// Update the mapNodes for the specific reached tv   

    v_map->distance = distance_through_u;
@@ -1635,9 +1637,9 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
	struct edges_t *e1 = &(v_map->predecessor);

	struct edges_t *e2 = &(v->edges[indexEdge]);

	duplicate_edge(e1, e2);	

	DEBUG_PC ("u->v Edge: %s(%s) --> %s(%s)", e2->aNodeId.nodeId, e2->aEndPointId, e2->zNodeId.nodeId, e2->zEndPointId);

	//DEBUG_PC ("u->v Edge: %s(%s) --> %s(%s)", e2->aNodeId.nodeId, e2->aEndPointId, e2->zNodeId.nodeId, e2->zEndPointId);

	//DEBUG_PC("v-pred aTopology: %s", e2->aTopologyId);

	DEBUG_PC("v-pred zTopology: %s", e2->zTopologyId);

	//DEBUG_PC("v-pred zTopology: %s", e2->zTopologyId);



    // Check whether v is dstPEId

	//DEBUG_PC ("Targeted dstId: %s", s->service_endpoints_id[1].device_uuid);
@@ -1659,7 +1661,7 @@ gint check_link (struct nodeItem_t *u, gint indexGraphU, gint indexGraphV, struc 
 *	@date 2022

 */

/////////////////////////////////////////////////////////////////////////////////////////

gboolean check_computed_path_feasability (struct service_t *s, struct compRouteOutputItem_t* p) {	

gboolean check_computed_path_feasibility (struct service_t *s, struct compRouteOutputItem_t* p) {	

	float epsilon = 0.0000001;

	struct path_constraints_t* pathCons = get_path_constraints(s);

	gboolean ret = TRUE;
@@ -2346,7 +2348,7 @@ void build_contextSet_linklList(GList** set, gint activeFlag) { 
	// for each link in linkList:

	// 1st- Retrieve endpoints A --> B feauture (context Id, device Id, endpoint Id)

	// 2st - In the graph associated to the contextId, check wheter A (deviceId) is in the vertices list

	// o No, this is weird ... exist

	// o No, this is weird ... exit

	// o Yes, get the other link endpoint (i.e., B) and check whether it exists. If NOT add it, considering

	// all the attributes; Otherwise, check whether the link is different from existing edges between A and B

	gdouble epsilon = 0.1;
@@ -3065,7 +3067,7 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv 


			// if ingress of the root link (aNodeId) is the spurNode, then stops

			if (compare_node_id(&re->aNodeId, SN) == 0) {

				DEBUG_PC("root Link: aNodeId: %s and spurNode: %s -- stop exploring the rootPath (RP)", re->aNodeId.nodeId, SN->nodeId);

				DEBUG_PC("Ingress Node rootLink %s = spurNode %s; STOP exploring rootPath (RP)", re->aNodeId.nodeId, SN->nodeId);

				break;

			}

			// Extract from Q
@@ -3073,7 +3075,6 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv 
			struct nodeItem_t* node = (struct nodeItem_t*)(listnode->data);

			Q = g_list_remove(Q, node);



			//DEBUG_RL_RA ("Exploring node %s", node->node.nodeId);

			indexVertice = graph_vertice_lookup(node->node.nodeId, g);

			g_assert(indexVertice >= 0);
@@ -3087,22 +3088,21 @@ void dijkstra(gint srcMapIndex, gint dstMapIndex, struct graph_t* g, struct serv 
		}

		// Check that the first node in Q set is SpurNode, otherwise something went wrong ...

		if (compare_node_id(&re->aNodeId, SN) != 0) {

			//DEBUG_PC ("root Link: aNodeId: %s is NOT the spurNode: %s -- something wrong", re->aNodeId.nodeId, SN->nodeId);

			DEBUG_PC ("root Link: aNodeId: %s is NOT the spurNode: %s -- something wrong", re->aNodeId.nodeId, SN->nodeId);

			g_list_free_full(g_steal_pointer(&S), g_free);

			g_list_free_full(g_steal_pointer(&Q), g_free);

			return;

		}

	}



	while (g_list_length(Q) > 0) {

		//Extract from Q set

		GList* listnode = g_list_first(Q);

		struct nodeItem_t* node = (struct nodeItem_t*)(listnode->data);

		Q = g_list_remove(Q, node);

		DEBUG_PC("Q length: %d", g_list_length(Q));

		DEBUG_PC("DeviceId: %s", node->node.nodeId);

		DEBUG_PC("Explored DeviceId: %s", node->node.nodeId);



		// visit all the links from u within the graph

		// scan all the links from u within the graph

		indexVertice = graph_vertice_lookup(node->node.nodeId, g);

		g_assert(indexVertice >= 0);
@@ -3140,18 +3140,19 @@ gint ksp_comp(struct pred_t* pred, struct graph_t* g, struct service_t* s, 
	struct map_nodes_t* mapNodes, guint arg) {

	g_assert(pred); g_assert(g); g_assert(s);



	DEBUG_PC("Source: %s -- Destination: %s", s->service_endpoints_id[0].device_uuid, s->service_endpoints_id[1].device_uuid);

	DEBUG_PC("SOURCE: %s --> DESTINATION: %s", s->service_endpoints_id[0].device_uuid, 

								s->service_endpoints_id[1].device_uuid);



	// Check the both ingress src and dst endpoints are in the graph

	gint srcMapIndex = get_map_index_by_nodeId(s->service_endpoints_id[0].device_uuid, mapNodes);

	if (srcMapIndex == -1) {

		DEBUG_PC("ingress DeviceId: %s NOT in the graph", s->service_endpoints_id[0].device_uuid);

		DEBUG_PC("ingress DeviceId: %s NOT in G", s->service_endpoints_id[0].device_uuid);

		return -1;

	}

	

	gint dstMapIndex = get_map_index_by_nodeId(s->service_endpoints_id[1].device_uuid, mapNodes);

	if (dstMapIndex == -1) {

		DEBUG_PC("egress DeviceId: %s NOT in the graph", s->service_endpoints_id[1].device_uuid);

		DEBUG_PC("egress DeviceId: %s NOT in G", s->service_endpoints_id[1].device_uuid);

		return -1;

	}
@@ -3165,17 +3166,17 @@ gint ksp_comp(struct pred_t* pred, struct graph_t* g, struct service_t* s, 
	gint map_dstIndex = get_map_index_by_nodeId(s->service_endpoints_id[1].device_uuid, mapNodes);

	struct map_t* dest_map = &mapNodes->map[map_dstIndex];

	if (!(dest_map->distance < INFINITY_COST)) {

		DEBUG_PC("destination: %s NOT reachable", s->service_endpoints_id[1].device_uuid);

		DEBUG_PC("DESTINATION: %s NOT reachable", s->service_endpoints_id[1].device_uuid);

		return -1;

	}



	DEBUG_PC("AvailBw @ %s is %f", dest_map->verticeId.nodeId, dest_map->avaiBandwidth);

	// Check that the computed available bandwidth is larger than 0.0

	if (dest_map->avaiBandwidth <= (gfloat)0.0) {

		DEBUG_PC("dst: %s NOT REACHABLE", s->service_endpoints_id[1].device_uuid);

		DEBUG_PC("DESTINATION %s NOT REACHABLE", s->service_endpoints_id[1].device_uuid);

		return -1;

	}

	DEBUG_PC("dst: %s REACHABLE", s->service_endpoints_id[1].device_uuid);

	DEBUG_PC("DESTINATION %s REACHABLE", s->service_endpoints_id[1].device_uuid);

	// Handle predecessors

	build_predecessors(pred, s, mapNodes);

	return 1;
@@ -3229,6 +3230,9 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_ 
	struct service_endpoints_id_t* iEp = &(s->service_endpoints_id[0]);

	struct service_endpoints_id_t* eEp = &(s->service_endpoints_id[1]);



	DEBUG_PC("=======================================================================================");

	DEBUG_PC("STARTING PATH COMP FOR %s[%s] --> %s[%s]", iEp->device_uuid, iEp->endpoint_uuid, eEp->device_uuid, eEp->endpoint_uuid);



	// Compute the 1st KSP path

	gint done = ksp_comp(predecessors, g, s, NULL, NULL, mapNodes, arg);

	if (done == -1) {
@@ -3360,9 +3364,10 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_ 
	// copy the service endpoints, in general, there will be 2 (point-to-point network connectivity services)

	for (gint m = 0; m < s->num_service_endpoints_id; m++) {

		struct service_endpoints_id_t* iEp = &(s->service_endpoints_id[m]);

		struct service_endpoints_id_t* oEp = &(s->service_endpoints_id[m]);

		struct service_endpoints_id_t* oEp = &(path->service_endpoints_id[m]);

		copy_service_endpoint_id(oEp, iEp);

	}

	path->num_service_endpoints_id = s->num_service_endpoints_id;



	// Print all the paths i A

	for (gint h = 0; h < A->numPaths; h++) {
@@ -3376,9 +3381,10 @@ void alg_comp(struct service_t* s, struct compRouteOutput_t* path, struct graph_ 
			DEBUG_PC("Number Requested paths (%d) REACHED - STOP", ksp);

			break;

		}

		gdouble feasibleRoute = check_computed_path_feasability(s, &A->paths[ksp]);

		gdouble feasibleRoute = check_computed_path_feasibility(s, &A->paths[ksp]);

		if (feasibleRoute == TRUE) {

			DEBUG_PC("A[%d] available: %f, pathCost: %f; latency: %f, Power: %f", ksp, A->paths[ksp].availCap, A->paths[ksp].cost, A->paths[ksp].delay, A->paths[ksp].power);

			DEBUG_PC("A[%d] available: %f, pathCost: %f; latency: %f, Power: %f", ksp, A->paths[ksp].availCap, 

											A->paths[ksp].cost, A->paths[ksp].delay, A->paths[ksp].power);

			struct compRouteOutputItem_t* pathaux = &A->paths[ksp];

			path->numPaths++;

			struct path_t* targetedPath = &path->paths[path->numPaths - 1];

src/pathcomp/backend/pathComp_tools.h

+2 −2
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ extern GList* activeServList; 
#define INFINITY_COST                   0xFFFFFFFF

#define MAX_NUM_PRED					100



#define MAX_KSP_VALUE					3

#define MAX_KSP_VALUE					5



// HTTP RETURN CODES

#define HTTP_CODE_OK					200
@@ -576,7 +576,7 @@ gboolean matching_path_rootPath (struct compRouteOutputItem_t *, struct compRout 
void modify_targeted_graph (struct graph_t *, struct path_set_t *, struct compRouteOutputItem_t *, struct nodes_t *);

gint find_nodeId (gconstpointer, gconstpointer);

gint check_link (struct nodeItem_t *, gint, gint, struct graph_t *, struct service_t *, GList **, GList **, struct map_nodes_t *, guint arg);

gboolean check_computed_path_feasability (struct service_t *, struct compRouteOutputItem_t * );

gboolean check_computed_path_feasibility (struct service_t *, struct compRouteOutputItem_t * );



gint sort_by_distance (gconstpointer, gconstpointer);

gint sort_by_energy(gconstpointer, gconstpointer);