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

Escrito por Sergio De Luz
Redes
3

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 Prog3.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!!


Continúa leyendo
  • Freddy

    No me compila :S

    • Tiene que funcionar porque antes de subirlo lo probé, qué error te da? A ver si podemos arreglarlo.

  • Oscar

    como debo hacerlo si quiero cambiar el esquema de nodos y en vez de usar 0,1,2,3. solo tener 0,1,2

    gracias!!