Simulación de envíos y entrega de paquetes vector distancia Kurose prog3.c : Descargar .C

Simulación de envíos y entrega de paquetes vector distancia Kurose prog3.c : Descargar .C

Sergio De Luz

En esta entrada os presento un simulador de envíos y entrega de paquetes que usa el vector distancia para hallar la ruta más corta entre esos nodos. El programa determina la ruta más corto entre los nodos y actualiza su tabla de encaminamiento evitando los «infinitos».

Es la actividad número 3 que proporciona Kurose en su libro «Redes de Computadores», os adjunto la resolución de los distintos nodos y del programa principal.

Estos códigos los hemos hecho nosotros, ha sido probado en Ubuntu x64 y compila y funciona (aunque salen muchos warnings).

También os adjunto el Makefile para que os sea más fácil compilarlo.

El esquema de los nodos y de las distancias iniciales es el siguiente:

Podéis descargar todo el código fuente bajando este .ZIP: Vector distancias Kurose rog3.c DESCARGAR

A continuación os pongo el código fuente para que le echéis un vistazo.

red.c (Programa principal).

#include <stdio.h>
#include <stdlib.h>

#define LINKCHANGES 1
#define nodos 4
#define infinito 999
/* ******************************************************************
Programming assignment 3: implementing distributed, asynchronous,
distance vector routing.

THIS IS THE MAIN ROUTINE.  IT SHOULD NOT BE TOUCHED AT ALL BY STUDENTS!

**********************************************************************/

/* a rtpkt is the packet sent from one routing update process to
another via the call tolayer3() */
struct rtpkt {
int sourceid;       /* id of sending router sending this pkt */
int destid;         /* id of router to which pkt being sent
(must be an immediate neighbor) */
int contador;
int mincost[nodos];    /* min cost to node 0 … 3 */
};

int TRACE = 0;             /* for my debugging */
int YES = 1;
int NO = 0;
int connectcosts[nodos][nodos];

/*
creatertpkt( initrtpkt, srcid, destid, mincosts,cont)
struct rtpkt *initrtpkt;
int srcid;
int destid;
int mincosts[];
int cont;

{
int i;
initrtpkt->sourceid = srcid;
initrtpkt->destid = destid;
initrtpkt->contador=cont;
for (i=0; i<nodos; i++)
initrtpkt->mincost[i] = mincosts[i];
}
*/

/*****************************************************************
***************** NETWORK EMULATION CODE STARTS BELOW ***********
The code below emulates the layer 2 and below network environment:
– emulates the tranmission and delivery (with no loss and no
corruption) between two physically connected nodes
– calls the initializations routines rtinit0, etc., once before
beginning emulation

THERE IS NOT REASON THAT ANY STUDENT SHOULD HAVE TO READ OR UNDERSTAND
THE CODE BELOW.  YOU SHOLD NOT TOUCH, OR REFERENCE (in your code) ANY
OF THE DATA STRUCTURES BELOW.  If you’re interested in how I designed
the emulator, you’re welcome to look at the code – but again, you should have
to, and you defeinitely should not have to modify
******************************************************************/

struct event {
float evtime;           /* event time */
int evtype;             /* event type code */
int eventity;           /* entity where event occurs */
struct rtpkt *rtpktptr; /* ptr to packet (if any) assoc w/ this event */
struct event *prev;
struct event *next;
};
struct event *evlist = NULL;   /* the event list */

/* possible events: */
#define  FROM_LAYER2     2
#define  LINK_CHANGE     10

float clocktime = 0.000;

main()
{
struct event *eventptr;

init();

while (1) {

eventptr = evlist;            /* get next event to simulate */
if (eventptr==NULL)
goto terminate;
evlist = evlist->next;        /* remove this event from event list */
if (evlist!=NULL)
evlist->prev=NULL;
if (TRACE>1) {
printf(«MAIN: rcv event, t=%.3f, at %d»,
eventptr->evtime,eventptr->eventity);
if (eventptr->evtype == FROM_LAYER2 ) {
printf(» src:%2d,»,eventptr->rtpktptr->sourceid);
printf(» dest:%2d,»,eventptr->rtpktptr->destid);
printf(» contents: %3d %3d %3d %3dn»,
eventptr->rtpktptr->mincost[0], eventptr->rtpktptr->mincost[1],
eventptr->rtpktptr->mincost[2], eventptr->rtpktptr->mincost[3]);
}
}
clocktime = eventptr->evtime;    /* update time to next event time */
if (eventptr->evtype == FROM_LAYER2 ) {
if (eventptr->eventity == 0)
rtupdate0(eventptr->rtpktptr);
else if (eventptr->eventity == 1)
rtupdate1(eventptr->rtpktptr);
else if (eventptr->eventity == 2)
rtupdate2(eventptr->rtpktptr);
else if (eventptr->eventity == 3)
rtupdate3(eventptr->rtpktptr);
else { printf(«Panic: unknown event entityn»); exit((char)0); }
}
else if (eventptr->evtype == LINK_CHANGE ) {
if (clocktime<10001.0) {
linkhandler0(1,20);
linkhandler1(0,20);
}
else   {
linkhandler0(1,1);
linkhandler1(0,1);
}
}
else
{ printf(«Panic: unknown event typen»); exit(0); }
if (eventptr->evtype == FROM_LAYER2 )
free(eventptr->rtpktptr);        /* free memory for packet, if any */
free(eventptr);                    /* free memory for event struct   */
}

terminate:
printf(«nEl simulador ha terminado en el tiempo t=%f, no hay más paquetesn», clocktime);
}

init()                         /* initialize the simulator */
{
int i;
float sum, avg;
float jimsrand();
struct event *evptr;

//   printf(«Enter TRACE:»);
//   scanf(«%d»,&TRACE);

srand(9999);              /* init random number generator */
sum = 0.0;                /* test random number generator for students */
for (i=0; i<1000; i++)
sum=sum+jimsrand();    /* jimsrand() should be uniform in [0,1] */
avg = sum/1000.0;
if (avg < 0.25 || avg > 0.75) {
printf(«It is likely that random number generation on your machinen» );
printf(«is different from what this emulator expects.  Please taken»);
printf(«a look at the routine jimsrand() in the emulator code. Sorry. n»);
exit((char)0);
}
/* initialize by hand since not all compilers allow array initilization */
connectcosts[0][0]=0;  connectcosts[0][1]=1; connectcosts[0][2]=3; connectcosts[0][3]=7;

connectcosts[1][0]=1;  connectcosts[1][1]=0;  connectcosts[1][2]=1; connectcosts[1][3]=infinito;

connectcosts[2][0]=3;  connectcosts[2][1]=1;  connectcosts[2][2]=0; connectcosts[2][3]=2;

connectcosts[3][0]=7;  connectcosts[3][1]=infinito;  connectcosts[3][2]=2; connectcosts[3][3]=0;
/* Se han añadido los valores propuestos en el enunciado */

clocktime=0.0;                /* initialize time to 0.0 */
rtinit0();
rtinit1();
rtinit2();
rtinit3();

/* initialize future link changes */
if (LINKCHANGES==1)   {
evptr = (struct event *)malloc(sizeof(struct event));
evptr->evtime =  10000.0;
evptr->evtype =  LINK_CHANGE;
evptr->eventity =  -1;
evptr->rtpktptr =  NULL;
insertevent(evptr);
evptr = (struct event *)malloc(sizeof(struct event));
evptr->evtype =  LINK_CHANGE;
evptr->evtime =  20000.0;
evptr->rtpktptr =  NULL;
insertevent(evptr);
}

}

/****************************************************************************/
/* jimsrand(): return a float in range [0,1].  The routine below is used to */
/* isolate all random number generation in one location.  We assume that the*/
/* system-supplied rand() function return an int in therange [0,mmm]        */
/****************************************************************************/
float jimsrand()
{
double mmm = 2147483647;   /* largest int  – MACHINE DEPENDENT!!!!!!!!   */
float x;                   /* individual students may need to change mmm */
x = rand()/mmm;            /* x should be uniform in [0,1] */
return(x);
}

/********************* EVENT HANDLINE ROUTINES *******/
/*  The next set of routines handle the event list   */
/*****************************************************/

insertevent(p)
struct event *p;
{
struct event *q,*qold;

if (TRACE>3) {
printf(»            INSERTEVENT: time is %lfn»,clocktime);
printf(»            INSERTEVENT: future time will be %lfn»,p->evtime);
}
q = evlist;     /* q points to header of list in which p struct inserted */
if (q==NULL) {   /* list is empty */
evlist=p;
p->next=NULL;
p->prev=NULL;
}
else {
for (qold = q; q !=NULL && p->evtime > q->evtime; q=q->next)
qold=q;
if (q==NULL) {   /* end of list */
qold->next = p;
p->prev = qold;
p->next = NULL;
}
else if (q==evlist) { /* front of list */
p->next=evlist;
p->prev=NULL;
p->next->prev=p;
evlist = p;
}
else {     /* middle of list */
p->next=q;
p->prev=q->prev;
q->prev->next=p;
q->prev=p;
}
}
}

printevlist()
{
struct event *q;
printf(«————–nEvent List Follows:n»);
for(q = evlist; q!=NULL; q=q->next) {
printf(«Event time: %f, type: %d entity: %dn»,q->evtime,q->evtype,q->eventity);
}
printf(«————–n»);
}

/************************** TOLAYER2 ***************/
tolayer2(packet)
struct rtpkt packet;

{
struct rtpkt *mypktptr;
struct event *evptr, *q;
float jimsrand(),lastime;
int i;

/* be nice: check if source and destination id’s are reasonable */
if (packet.sourceid<0 || packet.sourceid >nodos-1) {
printf(«WARNING: illegal source id in your packet, ignoring packet!n»);
return;
}
if (packet.destid<0 || packet.destid >nodos-1) {
printf(«WARNING: illegal dest id in your packet, ignoring packet!n»);
return;
}
if (packet.sourceid == packet.destid)  {
printf(«WARNING: source and destination id’s the same, ignoring packet!n»);
return;
}
if (connectcosts[packet.sourceid][packet.destid] == infinito)  {
printf(«WARNING: source and destination not connected, ignoring packet!n»);
return;
}

/* make a copy of the packet student just gave me since he/she may decide */
/* to do something with the packet after we return back to him/her */
mypktptr = (struct rtpkt *) malloc(sizeof(struct rtpkt));
mypktptr->sourceid = packet.sourceid;
mypktptr->destid = packet.destid;
mypktptr->contador=packet.contador;
for (i=0; i<nodos; i++)
mypktptr->mincost[i] = packet.mincost[i];
if (TRACE>2)  {
printf(»    TOLAYER2: source: %d, dest: %d, packet: %dn              costs:»,
mypktptr->sourceid, mypktptr->destid,mypktptr->contador);
for (i=0; i<nodos; i++)
printf(«%d  «,mypktptr->mincost[i]);
printf(«n»);
}

/* create future event for arrival of packet at the other side */
evptr = (struct event *)malloc(sizeof(struct event));
evptr->evtype =  FROM_LAYER2;   /* packet will pop out from layer3 */
evptr->eventity = packet.destid; /* event occurs at other entity */
evptr->rtpktptr = mypktptr;       /* save ptr to my copy of packet */

/* finally, compute the arrival time of packet at the other end.
medium can not reorder, so make sure packet arrives between 1 and 10
time units after the latest arrival time of packets
currently in the medium on their way to the destination */
lastime = clocktime;
for (q=evlist; q!=NULL ; q = q->next)
if ( (q->evtype==FROM_LAYER2  && q->eventity==evptr->eventity) )
lastime = q->evtime;
evptr->evtime =  lastime + 2.*jimsrand();

if (TRACE>2)
printf(»    TOLAYER2: scheduling arrival on other siden»);
insertevent(evptr);
}

Node0.c

#include <stdio.h>
#define nodos 4
#define infinito 999

extern int TRACE;
extern int YES;
extern int NO;
extern float clocktime;
extern int connectcosts[nodos][nodos];

extern struct rtpkt

{
int sourceid;       /* id of sending router sending this pkt */
int destid;         /* id of router to which pkt being sent
(must be an immediate neighbor) */
int contador;
int mincost[nodos];    /* min cost to node 0 … 3 */
} a;

struct distance_table
{
int costs[nodos][nodos];
} dt0;

int min_distancia0[nodos]={infinito,infinito,infinito,infinito};

/* students to write the following two routines, and maybe some others */

/*Función para calcular el mínimo coste*/
int calcula_min0()
{

int dest, via, cambio = 0;
/*Declaramos las variables que vamos a utilizar para los bucles de ordenación e         inicializamos cambio a 0 para usarlo*/

int mini[4];
/*Creamos un array de 4 unidades*/

/*Hallamos el camino más corto utilizando dos bucles for y comparando los resultados para iterar la próxima vez*/

for (dest=0; dest<4; dest++) {
mini[dest] = dt0.costs[dest][0];
for (via=1; via<4; via++) {
if (mini[dest] > dt0.costs[dest][via])
mini[dest] = dt0.costs[dest][via];
}
/*Actualizamos el array con la ruta nueva que es más corta*/
if (mini[dest] != min_distancia0[dest] ) {
min_distancia0[dest]= mini[dest];
cambio = 1;
}
}
return cambio;
}

/*Función para enviar a los nodos vecinos*/
void envia_vecinos0()
{
int dest;
struct rtpkt packet;

/*Creamos el paquete que vamos a enviar*/
packet.sourceid = 0;
for (dest=0; dest<4; dest++)
packet.mincost[dest] = min_distancia0[dest];

/*Enviamos el paquete a los destino*/
packet.destid=1;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 0 envia paquete al nodo 1 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);

packet.destid=2;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 0 envia paquete al nodo 2 cond %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);

packet.destid=3;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 0 envia paquete al nodo 3 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);

printf(«n»);
}

void rtinit0(void)
/*Se encarga de iniciar los valores de la matriz de encaminamiento que se encuentra
definida en la estructura dt.0*/

{
int dest,via;
printf(«En el tiempo t=%.3f, rtinit0() es llamado. n», clocktime);

/*Inicializamos la tabla distancias para escribir los nodos de destino. Dest significa el destino y via significa el nodo vecino próximo*/
for (dest=0; dest<4; dest++)
for (via=0; via<4; via++) {
if (dest==via)
dt0.costs[dest][via] = connectcosts[0][dest];
else
dt0.costs[dest][via] = infinito;
}
/*Calculamos el camino más corto*/
for (dest=0; dest<4; dest++)
min_distancia0[dest]=connectcosts[0][dest];
printdt0(&dt0);            /*Imprimimos la tabla de distancias*/
tolayer2();
envia_vecinos0();
/*Creamos el paquete y llamamos a envia_vecinos para mandar este paquete a los otros nodos*/
}

void rtupdate0(rcvdpkt)
/*Se llamará por parte de la entidad del nivel de enlace cada vez que llegue
al nodo 0 un paquete procedente de alguno de los nodos (adyacentes) de la red, que
será precisamente el que se reciba a través del parámetro de la función (rcvdpkt).

Estos datos deberían estar distribuidos en cada nodo, pero en esta simulación se defininen centralizados y de acceso global por comodidad en la implementación.*/
struct rtpkt *rcvdpkt;
{
int dest,via;
via=rcvdpkt->sourceid;

printf(«En el tiempo t=%.3f, rtupdate0() es llamado, y nodo 0 recibe paquete del nodo %dn»,
clocktime, via);

/* Actualizamos la tabla de distancias*/
for ( dest= 0; dest<4; dest++) {
dt0.costs[dest][via] = connectcosts[0][via] + rcvdpkt->mincost[dest];
if (dt0.costs[dest][via] > infinito)
dt0.costs[dest][via]=infinito;
}
printdt0(&dt0);                /*Mostramos la tabla de distancias actual*/
if (calcula_min0() == 1)    envia_vecinos0();    /*Actualizamos al camino más corto*/

}

printdt0(dtptr)
struct distance_table *dtptr;

{
printf(»                via     n»);
printf(»   D0 |    1     2    3    n»);
printf(»  —-|—————————– n»);
printf(»     1|  %3d   %3d   %3dn»,dtptr->costs[1][1],
dtptr->costs[1][2],dtptr->costs[1][3]);
printf(«dest 2|  %3d   %3d   %3dn»,dtptr->costs[2][1],
dtptr->costs[2][2],dtptr->costs[2][3]);
printf(»     3|  %3d   %3d   %3dn»,dtptr->costs[3][1],
dtptr->costs[3][2],dtptr->costs[3][3]);

}

linkhandler0(linkid, newcost)
int linkid, newcost;

/* Son las funciones que se llaman por  parte del programa principal en  el instante
10.000 y 20.000 de la simulación para representar un cambio de valor en el coste
asociado al enlace entre el nodo 0 y el nodo 1. Por tanto, esta función sólo estará en node0.c y en node1.c*/

{
int oldcost=connectcosts[0][linkid],dest;

printf(«En el tiempo t=%.3f, linkhandler0() es llamado n», clocktime);
connectcosts[0][linkid] = newcost;

/*Actualización de la tabla de distancias*/
for (dest=0; dest<4; dest++) {
dt0.costs[dest][linkid] = dt0.costs[dest][linkid] – oldcost + newcost;
if (dt0.costs[dest][linkid] > infinito) dt0.costs[dest][linkid] = infinito;
}

printdt0(&dt0);            /*Mostramos la tabla de distancias*/
if (calcula_min0()==1) envia_vecinos0();    /*Actualizamos al camino más corto*/
}

Node1.c

#include <stdio.h>
#define nodos 4
#define infinito 999

extern int TRACE;
extern int YES;
extern int NO;
extern float clocktime;
extern int connectcosts[nodos][nodos];

extern struct rtpkt

{
int sourceid;       /* id of sending router sending this pkt */
int destid;         /* id of router to which pkt being sent
(must be an immediate neighbor) */
int contador;
int mincost[nodos];    /* min cost to node 0 … 3 */
} a;

struct distance_table
{
int costs[nodos][nodos];
} dt1;

/* students to write the following two routines, and maybe some others */
int min_distancia1[nodos]={infinito,infinito,infinito,infinito};

int calcula_min1()
{
int dest, via, cambio = 0;
int mini[4];

for (dest=0; dest<4; dest++) {
mini[dest] = dt1.costs[dest][0];
for (via=1; via<4; via++) {
if (mini[dest] > dt1.costs[dest][via])
mini[dest] = dt1.costs[dest][via];
}
if (mini[dest] != min_distancia1[dest]) {
min_distancia1[dest] = mini[dest];
cambio =1;
}
}
return cambio;
}

void envia_vecinos1()
{
int dest;
struct rtpkt packet;
packet.sourceid = 1;
for (dest=0; dest<4; dest++)
packet.mincost[dest] = min_distancia1[dest];
packet.destid=0;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 1 envia paquete al nodo 0 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
packet.destid=2;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 1 envia paquete al nodo 2 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
printf(«n»);

}

void rtinit1(void)
{
int dest,via;
printf(«En el tiempo t=%.3f, rtinit1() es llamado n», clocktime);

for (dest=0; dest<4; dest++)
for (via=0; via<4; via++) {
if (dest==via)     dt1.costs[dest][via] = connectcosts[1][dest];
else        dt1.costs[dest][via] = infinito;
}
for (dest=0; dest<4; dest++)
min_distancia1[dest]=connectcosts[1][dest];
printdt1(&dt1);
tolayer2();
envia_vecinos1();
}

void rtupdate1(rcvdpkt)
struct rtpkt *rcvdpkt;
{
int dest,via;
via=rcvdpkt->sourceid;

printf(«En el tiempo t=%.3f, rtupdate1() es llamado. Nodo 1 recibe paquete del nodo %dn»,clocktime, via);

for ( dest= 0; dest<4; dest++) {
dt1.costs[dest][via] = connectcosts[1][via] + rcvdpkt->mincost[dest];
if (dt1.costs[dest][via] > infinito)
dt1.costs[dest][via]= infinito;
}

printdt1(&dt1);
if (calcula_min1() == 1)    envia_vecinos1();

}

printdt1(dtptr)
struct distance_table *dtptr;

{
printf(»                via     n»);
printf(»   D1 |    0     2     3 n»);
printf(»  —-|—————————– n»);
printf(»     0|  %3d   %3d   %3d n»,dtptr->costs[0][0],
dtptr->costs[0][2],dtptr->costs[0][3]);
printf(«dest 2|  %3d   %3d   %3d n»,dtptr->costs[2][0],
dtptr->costs[2][2],dtptr->costs[2][3]);
printf(»     3|  %3d   %3d   %3d n»,dtptr->costs[3][0],
dtptr->costs[3][2],dtptr->costs[3][3]);

}

linkhandler1(linkid, newcost)
int linkid, newcost;

{
int oldcost=connectcosts[1][linkid],dest;
printf(«En el tiempo t=%.3f, linkhandler0() es llamado n», clocktime);
connectcosts[1][linkid] = newcost;

for (dest=0; dest<4; dest++) {
dt1.costs[dest][linkid] = dt1.costs[dest][linkid] – oldcost + newcost;
if (dt1.costs[dest][linkid] > infinito)
dt1.costs[dest][linkid] = infinito;
}

printdt1(&dt1);
if (calcula_min1()==1)
envia_vecinos1();

}

Node2.c

#include <stdio.h>
#define nodos 4
#define infinito 999

extern int TRACE;
extern int YES;
extern int NO;
extern float clocktime;
extern int connectcosts[nodos][nodos];

extern struct rtpkt {
int sourceid;       /* id of sending router sending this pkt */
int destid;         /* id of router to which pkt being sent
(must be an immediate neighbor) */
int contador;
int mincost[nodos];    /* min cost to node 0 … 3 */
}a;

struct distance_table
{
int costs[nodos][nodos];
} dt2;

/* students to write the following two routines, and maybe some others */
int min_distancia2[nodos]={infinito,infinito,infinito,infinito};

int calcula_min2()
{
int dest, via, cambio = 0;
int mini[4];

for (dest=0; dest<4; dest++) {
mini[dest] = dt2.costs[dest][0];

for (via=1; via<4; via++) {
if (mini[dest] > dt2.costs[dest][via])
mini[dest] = dt2.costs[dest][via];
}
if (mini[dest] != connectcosts[2][dest] ) {
connectcosts[2][dest] = mini[dest];
cambio = 1;
}
}
return cambio;
}

void envia_vecinos2()
{
int dest;
struct rtpkt packet;
packet.sourceid = 2;
for (dest=0; dest<4; dest++)
packet.mincost[dest] = connectcosts[2][dest];

packet.destid=0;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 2 envia paquete al nodo 0 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
packet.destid=1;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 2 envia paquete al nodo 1 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
packet.destid=3;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 0 envia paquete al nodo 3 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
printf(«n»);

}

void rtinit2(void)
{
int dest,via;
printf(«En el tiempo t=%.3f, rtinit2() es llamado n», clocktime);

for (dest=0; dest<4; dest++)
for (via=0; via<4; via++) {
if (dest==via)
dt2.costs[dest][via] = connectcosts[2][dest];
else
dt2.costs[dest][via] = infinito;
}

for (dest=0; dest<4; dest++)
min_distancia2[dest]=connectcosts[2][dest];
printdt2(&dt2);
tolayer2();
envia_vecinos2();

}

void rtupdate2(rcvdpkt)
struct rtpkt *rcvdpkt;
{
int dest,via;
via=rcvdpkt->sourceid;
printf(«En el tiempo t=%.3f, rtupdate2() es llamado. Nodo 2 recibe paquete del nodo %dn»,
clocktime, via);

for ( dest= 0; dest<4; dest++) {
dt2.costs[dest][via] = connectcosts[2][via] + rcvdpkt->mincost[dest];
if (dt2.costs[dest][via] > infinito)
dt2.costs[dest][via]= infinito;
}

printdt2(&dt2);

if (calcula_min2() == 1)
envia_vecinos2();

}

printdt2(dtptr)
struct distance_table *dtptr;

{
printf(»                via     n»);
printf(»   D2 |    0     1     3 n»);
printf(»  —-|—————————– n»);
printf(»     0|  %3d   %3d   %3dn»,dtptr->costs[0][0],
dtptr->costs[0][1],dtptr->costs[0][3]);
printf(«dest 1|  %3d   %3d   %3dn»,dtptr->costs[1][0],
dtptr->costs[1][1],dtptr->costs[1][3]);
printf(»     3|  %3d   %3d   %3dn»,dtptr->costs[3][0],
dtptr->costs[3][1],dtptr->costs[3][3]);
}

Node3.c

#include <stdio.h>
#define nodos 4
#define infinito 999

extern int TRACE;
extern int YES;
extern int NO;
extern float clocktime;
extern int connectcosts[nodos][nodos];

extern struct rtpkt {
int sourceid;       /* id of sending router sending this pkt */
int destid;         /* id of router to which pkt being sent
(must be an immediate neighbor) */
int contador;
int mincost[nodos];    /* min cost to node 0 … 3 */
}a;

struct distance_table
{
int costs[nodos][nodos];
} dt3;

/* students to write the following two routines, and maybe some others */
int min_distancia3[nodos]={infinito,infinito,infinito,infinito};

int calcula_min3()
{
int dest, via, cambio = 0;
int mini[4];

for (dest=0; dest<4; dest++) {
mini[dest] = dt3.costs[dest][0];
for (via=1; via<4; via++) {
if (mini[dest] > dt3.costs[dest][via])
mini[dest] = dt3.costs[dest][via];
}
if (mini[dest] != connectcosts[3][dest] ) {
connectcosts[3][dest] = mini[dest];
cambio =1;
}
}
return cambio;
}

void envia_vecinos3()
{
int dest;
struct rtpkt packet;

packet.sourceid = 3;
for (dest=0; dest<4; dest++)
packet.mincost[dest] = connectcosts[3][dest];

packet.destid=0;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 3 envia paquete al nodo 0 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
packet.destid=2;
tolayer2(packet);
printf(«En el tiempo t=%.3f, nodo 3 envia paquete al nodo 2 con: %d %d %d %dn»,
clocktime, packet.mincost[0], packet.mincost[1], packet.mincost[2],packet.mincost[3]);
printf(«n»);

}

void rtinit3(void)
{
int dest,via;
printf(«En el tiempo t=%.3f, rtinit3() es llamado. n», clocktime);
for (dest=0; dest<4; dest++)
for (via=0; via<4; via++) {
if (dest==via)
dt3.costs[dest][via] = connectcosts[3][dest];
else
dt3.costs[dest][via] = infinito;
}

for (dest=0; dest<4; dest++)
min_distancia3[dest]=connectcosts[3][dest];
printdt3(&dt3);
tolayer2();
envia_vecinos3();

}

void rtupdate3(rcvdpkt)
struct rtpkt *rcvdpkt;
{
int dest,via;
via=rcvdpkt->sourceid;
printf(«En el tiempo t=%.3f, rtupdate3() es llamado. Nodo3 recibe paquete del nodo %dn»,
clocktime, via);

for ( dest= 0; dest<4; dest++) {
dt3.costs[dest][via] = connectcosts[3][via] + rcvdpkt->mincost[dest];
if (dt3.costs[dest][via] > infinito)
dt3.costs[dest][via]= infinito;
}
printdt3(&dt3);
if (calcula_min3() == 1)
envia_vecinos3();
}

printdt3(dtptr)
struct distance_table *dtptr;

{
printf(»                via     n»);
printf(»   D3 |    0     1     2 n»);
printf(»  —-|—————————– n»);
printf(»     0|  %3d   %3d   %3dn»,dtptr->costs[0][0],
dtptr->costs[0][1],dtptr->costs[0][2]);
printf(«dest 1|  %3d   %3d   %3dn»,dtptr->costs[1][0],
dtptr->costs[1][1],dtptr->costs[1][2]);
printf(»     2|  %3d   %3d   %3dn»,dtptr->costs[2][0],
dtptr->costs[2][1],dtptr->costs[2][2]);

}

MakeFile:

# AUTORES:
#
# Sanobis
# Bron

# Compilamos el programa

all:

gcc red.c node0.c node1.c node2.c node3.c -Wall -o programa

# Borramos el ejecutable

clean:

rm programa

Hasta aquí llegamos, espero que os sirva de ayuda para realizar vuestras prácticas y para que aprendáis el vector distancias!!

3 Comentarios
Logo redeszone.net
Navega gratis con publicidad…

Navegar por testdevelocidad.es con publicidad personalizada, seguimiento y cookies de forma gratuita. i

Para ello, nosotros y nuestros socios i necesitamos tu consentimiento i para el tratamiento de datos personales i para los siguientes fines:

Las cookies, los identificadores de dispositivos o los identificadores online de similares características (p. ej., los identificadores basados en inicio de sesión, los identificadores asignados aleatoriamente, los identificadores basados en la red), junto con otra información (p. ej., la información y el tipo del navegador, el idioma, el tamaño de la pantalla, las tecnologías compatibles, etc.), pueden almacenarse o leerse en tu dispositivo a fin de reconocerlo siempre que se conecte a una aplicación o a una página web para una o varias de los finalidades que se recogen en el presente texto.

La mayoría de las finalidades que se explican en este texto dependen del almacenamiento o del acceso a la información de tu dispositivo cuando utilizas una aplicación o visitas una página web. Por ejemplo, es posible que un proveedor o un editor/medio de comunicación necesiten almacenar una cookie en tu dispositivo la primera vez que visite una página web a fin de poder reconocer tu dispositivo las próximas veces que vuelva a visitarla (accediendo a esta cookie cada vez que lo haga).

La publicidad y el contenido pueden personalizarse basándose en tu perfil. Tu actividad en este servicio puede utilizarse para crear o mejorar un perfil sobre tu persona para recibir publicidad o contenido personalizados. El rendimiento de la publicidad y del contenido puede medirse. Los informes pueden generarse en función de tu actividad y la de otros usuarios. Tu actividad en este servicio puede ayudar a desarrollar y mejorar productos y servicios.

La publicidad que se presenta en este servicio puede basarse en datos limitados, tales como la página web o la aplicación que esté utilizando, tu ubicación no precisa, el tipo de dispositivo o el contenido con el que está interactuando (o con el que ha interactuado) (por ejemplo, para limitar el número de veces que se presenta un anuncio concreto).

  • Un fabricante de automóviles quiere promocionar sus vehículos eléctricos a los usuarios respetuosos con el medioambiente que viven en la ciudad fuera del horario laboral. La publicidad se presenta en una página con contenido relacionado (como un artículo sobre medidas contra el cambio climático) después de las 18:30 h a los usuarios cuya ubicación no precisa sugiera que se encuentran en una zona urbana.
  • Un importante fabricante de acuarelas quiere realizar una campaña publicitaria en Internet para dar a conocer su última gama de acuarelas con la finalidad de llegar tanto a artistas aficionados como a profesionales y, a su vez, se evite mostrar el anuncio junto a otro contenido no relacionado (por ejemplo, artículos sobre cómo pintar una casa). Se detectará y limitará el número de veces que se ha presentado el anuncio a fin de no mostrarlo demasiadas veces.

La información sobre tu actividad en este servicio (por ejemplo, los formularios que rellenes, el contenido que estás consumiendo) puede almacenarse y combinarse con otra información que se tenga sobre tu persona o sobre usuarios similares(por ejemplo, información sobre tu actividad previa en este servicio y en otras páginas web o aplicaciones). Posteriormente, esto se utilizará para crear o mejorar un perfil sobre tu persona (que podría incluir posibles intereses y aspectos personales). Tu perfil puede utilizarse (también en un momento posterior) para mostrarte publicidad que pueda parecerte más relevante en función de tus posibles intereses, ya sea por parte nuestra o de terceros.

  • En una plataforma de redes sociales has leído varios artículos sobre cómo construir una casa en un árbol Esta información podría añadirse a un perfil determinado para indicar tuinterés en el contenido relacionado con la naturaleza, así como en los tutoriales de bricolaje (con el objetivo de permitir la personalización del contenido, de modo que en el futuro, por ejemplo, se te muestren más publicaciones de blogs y artículos sobre casas en árboles y cabañas de madera).
  • Has visualizado tres vídeos sobre la exploración espacial en diferentes aplicaciones de televisión. Una plataforma de noticias sin relación con las anteriores y con la que no has tenido contacto en el pasado crea un perfil basado en esa conducta de visualización marcando la exploración del espacio como un tema de tu posible interés para para otros vídeos.

El contenido que se te presenta en este servicio puede basarse en un perfilde personalización de contenido que se haya realizado previamente sobre tu persona, lo que puede reflejar tu actividad en este u otros servicios (por ejemplo, los formularios con los que interactúas o el contenido que visualizas), tus posibles intereses y aspectos personales. Un ejemplo de lo anterior sería la adaptación del orden en el que se te presenta el contenido, para que así te resulte más sencillo encontrar el contenido (no publicitario) que coincida con tus intereses.

  • Has leído unos artículos sobre comida vegetariana en una plataforma de redes sociales. Posteriormente has usado una aplicación de cocina de una empresa sin relación con la anterior plataforma. El perfil que se ha creado sobre tu persona en la plataforma de redes sociales se utilizará para mostrarte recetas vegetarianas en la pantalla de bienvenida de la aplicación de cocina.
  • Has visualizado tres vídeos sobre remo en páginas web diferentes. Una plataforma de video, no relacionada con la página web en la que has visualizado los vídeos sobre remo, pero basandose en el perfil creado cuando visistaste dicha web, podrá recomendarte otros 5 vídeos sobre remo cuando utilices la plataforma de video a través de tu televisor .

La información sobre qué publicidad se te presenta y sobre la forma en que interactúas con ella puede utilizarse para determinar lo bien que ha funcionado un anuncio en tu caso o en el de otros usuarios y si se han alcanzado los objetivos publicitarios. Por ejemplo, si has visualizado un anuncio, si has hecho clic sobre el mismo, si eso te ha llevado posteriormente a comprar un producto o a visitar una página web, etc. Esto resulta muy útil para comprender la relevancia de las campañas publicitarias./p>

  • Has hecho clic en un anuncio en una página web/medio de comunicación sobre descuentos realizados por una tienda online con motivo del “Black Friday” online y posteriormente has comprado un producto. Ese clic que has hecho estará vinculado a esa compra. Tu interacción y la de otros usuarios se medirán para saber el número de clics en el anuncio que han terminado en compra.
  • Usted es una de las pocas personas que ha hecho clic en un anuncio que promociona un descuento por el “Día de la madre”de una tienda de regalos en Internet dentro de la aplicación de una web/medio de comunicación. El medio de comunicación quiere contar con informes para comprender con qué frecuencia usted y otros usuarios han visualizado o han hecho clic en un anuncio determinado dentro de la aplicación y, en particular, en el anuncio del “Día de la madre” para así ayudar al medio de comunicación y a sus socios (por ejemplo, las agencias de publicidad) a optimizar la ubicación de los anuncios.

La información sobre qué contenido se te presenta y sobre la forma en que interactúas con él puede utilizarse para determinar, por ejemplo, si el contenido (no publicitario) ha llegado a su público previsto y ha coincidido con sus intereses. Por ejemplo, si hasleído un artículo, si has visualizado un vídeo, si has escuchado un “pódcast” o si has consultado la descripción de un producto, cuánto tiempo has pasado en esos servicios y en las páginas web que has visitado, etc. Esto resulta muy útil para comprender la relevancia del contenido (no publicitario) que se te muestra.

  • Has leído una publicación en un blog sobre senderismo desde la aplicación móvil de un editor/medio de comunicación y has seguido un enlace a una publicación recomendada y relacionada con esa publicación. Tus interacciones se registrarán para indicar que la publicación inicial sobre senderismo te ha resultado útil y que la misma ha tenido éxito a la hora de ganarse tu interés en la publicación relacionada. Esto se medirá para saber si deben publicarse más contenidos sobre senderismo en el futuro y para saber dónde emplazarlos en la pantalla de inicio de la aplicación móvil.
  • Se te ha presentado un vídeo sobre tendencias de moda, pero tu y otros usuarios habéis dejado de visualizarlo transcurridos unos 30 segundos. Esta información se utilizará para valorar la duración óptima de los futuros vídeos sobre tendencias de moda.

Se pueden generar informes basados en la combinación de conjuntos de datos (como perfiles de usuario, estadísticas, estudios de mercado, datos analíticos) respecto a tus interacciones y las de otros usuarios con el contenido publicitario (o no publicitario) para identificar las características comunes (por ejemplo, para determinar qué público objetivo es más receptivo a una campaña publicitaria o a ciertos contenidos).

  • El propietario de una librería que opera en Internet quiere contar con informes comerciales que muestren la proporción de visitantes que han visitado su página y se han ido sin comprar nada o que han consultado y comprado la última autobiografía publicada, así como la edad media y la distribución de género para cada uno de los dos grupos de visitantes. Posteriormente, los datos relacionados con la navegación que realizas en su página y sobre tus características personales se utilizan y combinan con otros datos para crear estas estadísticas.
  • Un anunciante quiere tener una mayor comprensión del tipo de público que interactúa con sus anuncios. Por ello, acude a un instituto de investigación con el fin de comparar las características de los usuarios que han interactuado con el anuncio con los atributos típicos de usuarios de plataformas similares en diferentes dispositivos. Esta comparación revela al anunciante que su público publicitario está accediendo principalmente a los anuncios a través de dispositivos móviles y que es probable que su rango de edad se encuentre entre los 45 y los 60 años.

La información sobre tu actividad en este servicio, como tu interacción con los anuncios o con el contenido, puede resultar muy útil para mejorar productos y servicios, así como para crear otros nuevos en base a las interacciones de los usuarios, el tipo de audiencia, etc. Esta finalidad específica no incluye el desarrollo ni la mejora de los perfiles de usuario y de identificadores.

  • Una plataforma tecnológica que opera con un proveedor de redes sociales observa un crecimiento en los usuarios de aplicaciones móviles y se da cuenta de que, en funciónde sus perfiles, muchos de ellos se conectan a través de conexiones móviles. La plataforma utiliza una tecnología nueva para mostrar anuncios con un formato óptimo para los dispositivos móviles y con un ancho de banda bajo a fin de mejorar su rendimiento.
  • Un anunciante está buscando una forma de mostrar anuncios en un nuevo tipo de dispositivo. El anunciante recopila información sobre la forma en que los usuarios interactúan con este nuevo tipo de dispositivo con el fin de determinar si puede crear un nuevo mecanismo para mostrar la publicidad en ese tipo de dispositivo.

El contenido que se presenta en este servicio puede basarse en datos limitados, como por ejemplo la página web o la aplicación que esté utilizando, tu ubicación no precisa, el tipo de dispositivo o el contenido con el que estás interactuando (o con el que has interactuado) (por ejemplo, para limitar el número de veces que se te presenta un vídeo o un artículo en concreto).

  • Una revista de viajes, para mejorar las experiencias de viaje en el extranjero, ha publicado en su página web un artículo sobre nuevos cursos que ofrece una escuela de idiomas por Internet. Las publicaciones del blog de la escuela se insertan directamente en la parte inferior de la página y se seleccionan en función de la ubicación no precisa del usuario (por ejemplo, publicaciones del blog que explican el plan de estudios del curso para idiomas diferentes al del país en el que este te encuentras).
  • Una aplicación móvil de noticias deportivas ha iniciado una nueva sección de artículos sobre los últimos partidos de fútbol. Cada artículo incluye vídeos alojados por una plataforma de streaming independiente que muestra los aspectos destacados de cada partido. Si adelantas un vídeo, esta información puede utilizarse para determinar que el siguiente vídeo a reproducir sea de menor duración.

Se puede utilizar la localización geográfica precisa y la información sobre las características del dispositivo

Al contar con tu aprobación, tu ubicación exacta (dentro de un radio inferior a 500 metros) podrá utilizarse para apoyar las finalidades que se explican en este documento.

Con tu aceptación, se pueden solicitar y utilizar ciertas características específicas de tu dispositivo para distinguirlo de otros (por ejemplo, las fuentes o complementos instalados y la resolución de su pantalla) en apoyo de las finalidades que se explican en este documento.

O sin publicidad desde 1,67€ al mes

Por solo 1,67€ al mes, disfruta de una navegación sin interrupciones por toda la red del Grupo ADSLZone: adslzone.net, movilzona.es, testdevelocidad.es, lamanzanamordida.net, hardzone.es, softzone.es, redeszone.net, topesdegama.com y más. Al unirte a nuestra comunidad, no solo estarás apoyando nuestro trabajo, sino que también te beneficiarás de una experiencia online sin publicidad ni cookies de seguimiento.