BS_mac Class Reference

#include <BS_mac.h>

Inheritance diagram for BS_mac:

cSimpleModule cModule cComponent cDefaultList cNoncopyableOwnedObject cOwnedObject noncopyable cNamedObject cObject

List of all members.

Public Member Functions

virtual void get_num_used_queues ()
virtual void extract_packets ()
virtual void relleno_arrays_retardos ()
virtual void recalculo_ruta_delay_aware (int ind_usr)
virtual void routing ()

Public Attributes

FILE * retardo_wireless
Analysis retardo
int ind_primero
int max_fila
int filas
int columnas
int used_queues
int prioridades
int esPasarela
int enlaces_intermedios
int extraction_method
int nodos_actualizados
int actualizaciones
double t_frame
double t_slot
double txrate
double rxrate
double eff_cap
double C_i
double media_saltos
long sumcolas
simtime_t time_frame
BS_tableTabla
BS_queuecola
BS_queuequeue
int_vector_t opt_route
int_vector_t index_used_queues
string_vector_t nombres_bs
int_vector_t indices_pasarelas
cTopology top
cTopology::Nodetop_node
simtime_t timepacket
time_vector_t slot_tx_delay
double_vector_t auxiliar_array
double_matrix_t auxiliar_matrix

Protected Member Functions

virtual void initialize ()
virtual void handleMessage (cMessage *msg)
virtual void finish ()
virtual int get_index_first_empty_row ()
virtual int is_an_empty_row (int row)
virtual int get_index_last_element (int row)
virtual int ya_aparece (char *nombre_nodo, int fila, int indice)
virtual int es_pasarela (cModule *node)
virtual int conseguir_siguiente_puerta (int init_ind, int puertas, cModule *node)
virtual int puerta_entrada_libre (cModule *node, int puertas)
virtual int puerta_salida_libre (cModule *node, int puertas)
virtual void calculo_ruta_shortest_path (int ind_usr)
virtual void calculo_ruta_minimum_hop (int ind_usr)
virtual void get_routes_for_each_user (int index)


Detailed Description

Definition at line 35 of file BS_mac.h.


Member Function Documentation

void BS_mac::calculo_ruta_minimum_hop ( int  ind_usr  )  [protected, virtual]

Definition at line 874 of file BS_mac.cc.

00875 {
00876         int indice_esta_bs = (int)this->getParentModule()->par("indice");
00877         //int indice_esta_bs = (int) this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00878         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red (25)
00879         int usuarios = (int) this->getParentModule()->par("numUser"); // Numero de usuarios
00880         int pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BS-pasarelas
00882         for(int j=0; j<pasarelas; j++)
00883         {
00884                 int min_index = Tabla->indices_rutas[ind_usr][0][j];
00885                 if(Tabla->num_rutas[ind_usr][j]>1)
00886                 {
00887                         for(int i=0; i<Tabla->num_rutas[ind_usr][j]; i++)
00888                         {
00890                                 //if(Tabla->saltos_total_rutas[Tabla->indices_rutas[ind_usr][i][j]] < Tabla->saltos_total_rutas[min_index])
00891                                 if(Tabla->peso_total_rutas[Tabla->indices_rutas[ind_usr][i][j]] < Tabla->peso_total_rutas[min_index])
00892                                 {
00893                                         min_index=Tabla->indices_rutas[ind_usr][i][j];
00894                                 }
00895                         }
00896                         opt_route[j]=min_index;
00898                 }
00899                 else if(Tabla->num_rutas[ind_usr][j]==1)
00900                 {
00902                         min_index = Tabla->indices_rutas[ind_usr][0][j];
00903                         opt_route[j]=min_index;
00905                 }
00906                 else if(Tabla->num_rutas[ind_usr][j]==0)
00907                 {
00908                         opt_route[j]= -1;
00909                 }
00910         }
00911 
00912         for(int q=0; q<pasarelas; q++)
00913         {
00914                 if(opt_route[q]!=-1)
00915                 {
00916                         Tabla->rutas_optimas_pasarelas[q][ind_usr] = Tabla->array_de_rutas[opt_route[q]];
00917                         auxiliar_matrix[q][ind_usr] = Tabla->peso_total_rutas[opt_route[q]];
00918                 }
00919         }
00920         if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1)
00921         {
00922                 for(int k=0; k<pasarelas; k++)
00923                 {
00924                         //ev << endl;
00925                         //ev << " **TABLA CON LA " << k << "-ESIMA RUTA OPTIMA (MENOR NUM. SALTOS) HASTA LA PASARELA " << nombres_bs[indices_pasarelas[k]]<< " PARA CADA USUARIO**" << endl;
00926                         for(int a=0; a<usuarios; a++)
00927                         {
00928                                 for(int b=0; b<columnas; b++)
00929                                 {
00930                                         //ev << " | " << Tabla->rutas_optimas_pasarelas[k][a][b];
00931                                 }
00932                                 //ev << " --> Peso: " << auxiliar_matrix[k][a] << endl;
00933                         }
00934                         //ev << endl;
00935                 }
00936         }
00937 
00938         int aux1=0, first_index=0, first_onu=0;
00939         for(int h=0; h<pasarelas; h++)
00940         {
00941                 if(opt_route[h]>0 && aux1==0)
00942                 {
00943                         aux1=1;
00944                         first_index=opt_route[h];
00945                         first_onu=indices_pasarelas[h];
00947                 }
00948                 else if(opt_route[h]>0 && aux1!=0)
00949                 {
00951                         //if(Tabla->saltos_total_rutas[opt_route[h]]<Tabla->saltos_total_rutas[first_index])
00952                         if(Tabla->peso_total_rutas[opt_route[h]]<Tabla->peso_total_rutas[first_index])
00953                         {
00954                                 first_index=opt_route[h];
00955                                 first_onu=indices_pasarelas[h];
00956                         }
00957                 }
00958         }
00960 
00961         Tabla->rutas_optimas[ind_usr] = Tabla->array_de_rutas[first_index];
00962         media_saltos = (double)(media_saltos + get_index_last_element(first_index) - 1);
00963         auxiliar_array[ind_usr] = Tabla->saltos_total_rutas[first_index];
00964         //auxiliar_array[ind_usr] = Tabla->peso_total_rutas[first_index];
00965 
00966         if(ind_usr == usuarios-1)
00967         //if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1)
00968         {
00969                 //ev << endl;
00970                 //ev << "               " << this->nombres_bs[indice_esta_bs] << endl;
00971                 //ev << " **TABLA CON LA RUTA OPTIMA HASTA UNA ONU (MENOR NUMERO DE SALTOS) PARA CADA USUARIO**" << endl;
00972                 for(int a=0; a<usuarios; a++)
00973                 {
00974                         for(int b=0; b<columnas; b++)
00975                         {
00976                                 //ev << " | " << Tabla->rutas_optimas[a][b];
00977                         }
00978                         //ev << "  --> Saltos: " << auxiliar_array[a] << endl;
00979                 }
00980                 //ev << endl;
00981         }
00982 }

void BS_mac::calculo_ruta_shortest_path ( int  ind_usr  )  [protected, virtual]

Definition at line 758 of file BS_mac.cc.

00759 {
00760         int indice_esta_bs = (int) this->getParentModule()->par("indice");
00761         //int indice_esta_bs = (int) this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00762         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red (25)
00763         int usuarios = (int) this->getParentModule()->par("numUser"); // Numero de usuarios
00764         int pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BS-pasarelas
00766         for(int j=0; j<pasarelas; j++)
00767         {
00768                 int min_index = Tabla->indices_rutas[ind_usr][0][j];
00769                 if(Tabla->num_rutas[ind_usr][j]>1)
00770                 {
00771                         for(int i=0; i<Tabla->num_rutas[ind_usr][j]; i++)
00772                         {
00774 
00775                                 //if(Tabla->longitud_total_rutas[Tabla->indices_rutas[ind_usr][i][j]] < Tabla->longitud_total_rutas[min_index])
00776                                 if(Tabla->peso_total_rutas[Tabla->indices_rutas[ind_usr][i][j]] < Tabla->peso_total_rutas[min_index])
00777                                 {
00778                                         min_index=Tabla->indices_rutas[ind_usr][i][j];
00779                                 }
00780                         }
00781                         opt_route[j]=min_index;
00783                 }
00784                 else if(Tabla->num_rutas[ind_usr][j]==1)
00785                 {
00787                         min_index = Tabla->indices_rutas[ind_usr][0][j];
00788                         opt_route[j]=min_index;
00790                 }
00791                 else if(Tabla->num_rutas[ind_usr][j]==0)
00792                 {
00793                         opt_route[j]= -1;
00794                 }
00795         }
00796 
00797         for(int q=0; q<pasarelas; q++)
00798         {
00799                 if(opt_route[q]!=-1)
00800                 {
00801                         Tabla->rutas_optimas_pasarelas[q][ind_usr] = Tabla->array_de_rutas[opt_route[q]];
00802                         auxiliar_matrix[q][ind_usr] = Tabla->peso_total_rutas[opt_route[q]];
00803                 }
00804         }
00805         if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1)
00806         {
00807                 for(int k=0; k<pasarelas; k++)
00808                 {
00809                         //ev << endl;
00810                         //ev << " **TABLA CON LA " << k << "-ESIMA RUTA OPTIMA (MENOR DISTANCIA) HASTA LA PASARELA " << nombres_bs[indices_pasarelas[k]]<< " PARA CADA USUARIO**" << endl;
00811                         for(int a=0; a<usuarios; a++)
00812                         {
00813                                 for(int b=0; b<columnas; b++)
00814                                 {
00815                                         //ev << " | " << Tabla->rutas_optimas_pasarelas[k][a][b];
00816                                 }
00817                                 //ev << " --> Peso: " << auxiliar_matrix[k][a] << endl;
00818                         }
00819                         //ev << endl;
00820                 }
00821         }
00822 
00823         int aux1=0, first_index=0, first_onu=0;
00824         for(int h=0; h<pasarelas; h++)
00825         {
00826                 if(opt_route[h]>0 && aux1==0)
00827                 {
00828                         aux1=1;
00829                         first_index=opt_route[h];
00830                         first_onu=indices_pasarelas[h];
00832                 }
00833                 else if(opt_route[h]>0 && aux1!=0)
00834                 {
00836 
00837                         if(Tabla->peso_total_rutas[opt_route[h]]<Tabla->peso_total_rutas[first_index])
00838                         //if(Tabla->longitud_total_rutas[opt_route[h]]<Tabla->longitud_total_rutas[first_index])
00839                         {
00840                                 first_index=opt_route[h];
00841                                 first_onu=indices_pasarelas[h];
00842                         }
00843                 }
00844         }
00846 
00847         Tabla->rutas_optimas[ind_usr] = Tabla->array_de_rutas[first_index];
00848         media_saltos = (double)(media_saltos + get_index_last_element(first_index)-1);
00849         auxiliar_array[ind_usr] = Tabla->longitud_total_rutas[first_index];
00850         //auxiliar_array[ind_usr] = Tabla->peso_total_rutas[first_index];
00851 
00852         if(ind_usr == usuarios-1)
00853         //if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1)
00854         {
00855                 //ev << endl;
00856                 //ev << "               " << this->nombres_bs[indice_esta_bs] << endl;
00857                 //ev << " **TABLA CON LA RUTA OPTIMA HASTA UNA ONU (MENOR DISTANCIA) PARA CADA USUARIO**" << endl;
00858                 for(int a=0; a<usuarios; a++)
00859                 {
00860                         for(int b=0; b<columnas; b++)
00861                         {
00862                                 //ev << " | " << Tabla->rutas_optimas[a][b];
00863                         }
00864                         //ev << "  --> Longitud: " << auxiliar_array[a] << " metros" << endl;
00865                 }
00866                 //ev << endl;
00867         }
00868 }

int BS_mac::conseguir_siguiente_puerta ( int  init_ind,
int  puertas,
cModule node 
) [protected, virtual]

Definition at line 342 of file BS_mac.cc.

00343 {
00344         cModule *nodo = check_and_cast<cModule*>(node);
00345         int i = init_ind, encontrado = 0;
00346         int indice = init_ind;
00347         while(i<puertas && encontrado ==0)
00348         {
00349                 if(nodo->gate("physicalBS$o",i)->isConnected())
00350                 {
00351                         if(strcmp("user",nodo->gate("physicalBS$o",i)->getNextGate()->getOwnerModule()->getName())!=0)
00352                         {
00353                                 encontrado = 1;
00354                                 indice = i;
00355                         }
00356                 }
00357                 i++;
00358         }
00359         return indice;
00360 }

int BS_mac::es_pasarela ( cModule node  )  [protected, virtual]

Definition at line 325 of file BS_mac.cc.

00326 {
00327         cModule *nodo_ = check_and_cast<cModule*>(node);
00328         cTopology::Node * nodo = top.getNodeFor(nodo_);
00329         char* nombre_enlace = (char*) nodo->getLinkOut(1)->getRemoteNode()->getModule()->getName();
00330         int encontrado = -1;
00331         if (strcmp(nombre_enlace,"onu")==0)
00332         {
00333                 encontrado = 1;
00334         }
00335         return encontrado;
00336 }

void BS_mac::extract_packets (  )  [virtual]

Definition at line 515 of file BS_mac.cc.

00516 {
00517         // Segun el metodo de extraccion de paquetes elegido en 'omnetpp.ini':
00518         switch(extraction_method)
00519         {
00520         case 0: // Metodo de extraccion con prioridad de colas estricta:
00521                 sumcolas = 0;
00522                 for(int w=0; w<used_queues; w++)
00523                 {
00524                         queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[w]));
00525                         queue->tamsumcola = 0; // Reseteo de la variable
00526                         for (int h=0; h<prioridades; h++)
00527                         {
00528                                 queue->tamsumcola = queue->tamsumcola + queue->tamqueue[h];
00529                                 //ev << " Bytes en la cola de prioridad P" << h << " con destino " << queue->getTarget() << ": " << queue->tamqueue[h] << "B" << endl;
00530                         }
00531 
00532                         // Si en este modulo BS_queue[], que a priori se considera "activo", no hay ningun paquete durante 2 ciclos,
00533                         // se cambia el calor de su variable "usado" para que en el proximo periodo se considere a este submodulo "inactivo":
00534                         if(queue->tamsumcola==0)
00535                         {
00536                                 queue->contador++;
00537                                 if(queue->contador>=1)
00538                                 {
00539                                         queue->usado=0;
00540                                         //ev << " El enlace " << this->getParentModule()->getFullName() << "-->" << queue->getTarget() << " esta INACTIVO. " << endl;
00541                                 }
00542                         }
00543 
00544                         //ev << " Total bytes con destino " << queue->getTarget() << ": " << queue->tamsumcola << "B" << endl;
00545                         sumcolas = sumcolas + queue->tamsumcola;
00546                 }
00547                 //ev << " Total bytes en las colas del nodo " << this->getParentModule()->getFullName() << ": " << sumcolas << "B" << endl;
00548 
00549                 // Para cada uno de los modulo BS_queue[] "activos", se invoca su metodo de extraccion de paquetes:
00550                 for(int j=0; j<used_queues; j++)
00551                 {
00552                         queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[j]));
00553                         queue->strictpriorityqueue();
00554                         // NOTA: Se envian todos los paquetes "de golpe" de los BS_queue[] al BS_rx_tx, pero este modulo no los pone en la red todos a la vez,
00555                         //                       sino que los envia al siguiente nodo con el retardo de transmision correspondiente (variable timepacket).
00556                 }
00557                 break;
00558         case 1: // Metodo de extraccion centralizado:
00559                 sumcolas = 0;
00560                 for(int w=0; w<used_queues; w++)
00561                 {
00562                         queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[w]));
00563                         queue->tamsumcola = 0; // Reseteo de la variable
00564                         for (int h=0; h<prioridades; h++)
00565                         {
00566                                 queue->tamsumcola = queue->tamsumcola + queue->tamqueue[h];
00567                                 //ev << " Bytes en la cola de prioridad P" << h << " con destino " << queue->getTarget() << ": " << queue->tamqueue[h] << "B" << endl;
00568                         }
00569 
00570                         // Si en este modulo BS_queue[], que a priori se considera "activo", no hay ningun paquete durante 2 ciclos,
00571                         // se cambia el calor de su variable "usado" para que en el proximo periodo se considere a este submodulo "inactivo":
00572                         if(queue->tamsumcola==0)
00573                         {
00574                                 queue->contador++;
00575                                 if(queue->contador>=1)
00576                                 {
00577                                         queue->usado=0;
00578                                         //ev << " El enlace " << this->getParentModule()->getFullName() << "-->" << queue->getTarget() << " esta INACTIVO. " << endl;
00579                                 }
00580                         }
00581 
00582                         //ev << " Total bytes con destino " << queue->getTarget() << ": " << queue->tamsumcola << "B" << endl;
00583                         sumcolas = sumcolas + queue->tamsumcola;
00584                 }
00585                 //ev << " Total bytes en las colas del nodo " << this->getParentModule()->getFullName() << ": " << sumcolas << "B" << endl;
00586 
00587                 for(int j=0; j<used_queues; j++)
00588                 {
00589                         queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[j]));
00590                         // Para cada uno de los modulo BS_queue[] "activos", se invoca su metodo de extraccion de paquetes:
00591                         queue->centralizedmethod();
00592                         // NOTA: Se envian todos los paquetes "de golpe" de los BS_queue[] al BS_rx_tx, pero este modulo no los pone en la red todos a la vez,
00593                         //                       sino que los envia al siguiente nodo con el retardo de transmision correspondiente (variable timepacket).
00594                 }
00595                 break;
00596         default:
00597                 break;
00598         }
00599 }

void BS_mac::finish (  )  [protected, virtual]

Reimplemented from cComponent.

Definition at line 404 of file BS_mac.cc.

00405 {
00406         if(strcmp(this->getParentModule()->getFullName(),"bs0")==0)
00407         //if(this->getParentModule()->getIndex()==0) /////// CAMBIO_RED ///////
00408         {
00409                 retardo_wireless = fopen("results/retardo_wireless.txt", "a+");
00410                 fprintf(retardo_wireless, "TIEMPO SIMULADO: T=%g\n", (double)SIMTIME_DBL(simTime()));
00411                 fprintf(retardo_wireless, "RETARDO MEDIO TOTAL: %g\n", (double)retardo.average());
00412                 fclose(retardo_wireless);
00413         }
00414         int criterio = this->getParentModule()->par("criterio"); // Criterio seguido para encaminar
00415         int este_indice = this->getParentModule()->par("indice");
00416         //int este_indice = this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00417         int estaciones = this->getParentModule()->par("numBS");
00418         /*
00419         if(criterio == 1 && este_indice==estaciones-1)
00420         {
00421                 ev << endl;
00422                 // Impresion de la tabla de encaminamiento optimo para cada usuario, segun el menor retardo:
00423                 ev << "         **TABLA CON LA RUTA OPTIMA HASTA UNA ONU (MENOR RETARDO) PARA CADA USUARIO**" << endl;
00424                 for(int a=0; a<(int)this->getParentModule()->par("numUser"); a++)
00425                 {
00426                         for(int b=0; b<columnas; b++)
00427                         {
00428                                 ev << " | " << Tabla->rutas_optimas[a][b];
00429                         }
00430                         ev << "  --> Peso (retardo): " << auxiliar_array[a] << " s."<< endl;
00431                 }
00432                 ev << endl;
00433                 //ev << endl;
00435                 //ev << "       TABLA CON EL PESO (RETARDO) DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
00436                 for(int a=0; a<max_fila; a++)
00437                 {
00438                         for(int b=0; b<columnas; b++)
00439                         {
00440                                 //ev << " | " << Tabla->array_de_pesos[a][b];
00441                         }
00442                         //ev << " --> Total: " << Tabla->peso_total_rutas[a] << endl;
00443                 }
00444         }
00445         */
00446 }

int BS_mac::get_index_first_empty_row (  )  [protected, virtual]

Definition at line 266 of file BS_mac.cc.

00267 {
00268         int i=0, indice=0;
00269         int coincide = 1;
00270         while(i<filas && coincide !=0)
00271         {
00272                 coincide = strcmp(" ", Tabla->array_de_rutas[i][0]);
00273                 indice = i;
00274                 i++;
00275         }
00276         return indice;
00277 }

int BS_mac::get_index_last_element ( int  row  )  [protected, virtual]

Definition at line 283 of file BS_mac.cc.

00284 {
00285         // El primer elemento es el usuario, luego podriamos empezar por i=1
00286         int i=1, encontrado = 0, ocupado, vacio, indice=1;
00287         while(encontrado == 0 && i<columnas)
00288         {
00289                 ocupado = strcmp(" ", Tabla->array_de_rutas[row][i]);
00290                 vacio = strcmp(" ", Tabla->array_de_rutas[row][i + 1]);
00291                 if(ocupado !=0 && vacio ==0)
00292                 {
00293                         encontrado = 1;
00294                         indice = i;
00295                 }
00296                 i++;
00297         }
00298         return indice;
00299 }

void BS_mac::get_num_used_queues (  )  [virtual]

Definition at line 452 of file BS_mac.cc.

00453 {
00454         used_queues = 0; // Reseteo de la variable
00455         int num_conexiones = (int) this->getParentModule()->par("conexiones");
00456         int queues = num_conexiones - 1;
00457         int auxiliar = 0, contador = 0;
00458         // Se recorren todos los modulos BS_queue[] de este modulo compuesto BS para comprobar el valor de sus parametros
00459         // "usado" y "uso". Recordar que cada modulo BS_queue[] corresponde a un enlace entre esta BS y una vecina.
00460         for(int q=0; q<queues; q++)
00461         {
00462                 queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",q));
00463                 if(queue->uso==1 && queue->usado==1)
00464                 {
00465                         used_queues++;
00466                         index_used_queues[contador]=q; // Almacenamiento del indice de cada BS_queue[] 'activa' en este vector.
00467                         contador++;
00468                         if(auxiliar==0)
00469                         {
00470                                 ind_primero = q; // Almacenamiento del indice de la primera BS_queue[] del array que esta activa.
00471                                 auxiliar = 1;
00472                         }
00473                 }
00474         }
00475         // Los posiciones del array que no se han rellenado (porque no hay mas BS_queue[] activos) se rellenan con el valor "-1".
00476         for(int h=used_queues; h<(int)index_used_queues.size(); h++)
00477         {
00478                 index_used_queues[h] = -1;
00479         }
00480         // Tiempo de slot = Tiempo de trama entre numero de modulos BS_queue[] activos:
00481         t_slot = t_frame/used_queues;
00482         // Capacidad efectiva = Capacidad del canal entre numero de modulos BS_queue[] activos:
00483         eff_cap = (double) txrate/used_queues;
00484         // Ancho de banda que se puede transmitir en el tiempo de slot que toca a cada BS_queue[]:
00485         double bw = (double) (txrate*t_slot)/8;
00486         // Se actualizan los sigquientes parametros en los modulos BS_queue[] activos:
00487         for(int h=0; h<used_queues; h++)
00488         {
00489                 // Posicion que ocupa este submodulo BS_queue[] en el vector de colas usadas del BS_mac:
00490                 check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[h]))->used_index = h;
00491                 // Ancho de banda disponible por el enlace que representa este BS_queue[] para el siguiente periodo de transmision:
00492                 check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[h]))->bandwidth = bw;
00493                 // Tiempo de slot de este BS_queue[]:
00494                 check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[h]))->t_slot = t_slot;
00495                 // Numero de modulos BS_queue[] activos en este modulo compuesto BS:
00496                 check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[h]))->used_bs_queues = used_queues;
00497         }
00498 
00499         //ev << " Numero de enlaces activos: " << used_queues << endl;
00500         //ev << " T_slot = " << t_slot << "s." << endl;
00501         /*
00502         ev << " Indice del primer enlace activo: " << ind_primero << endl;
00503         ev << " Indices de todos los enlaces activos: " << endl;
00504         for(int h=0; h<(int)index_used_queues.size(); h++)
00505         {
00506                 ev << " " << index_used_queues[h];
00507         }
00508         ev << endl;
00509         */
00510 }

void BS_mac::get_routes_for_each_user ( int  index  )  [protected, virtual]

Definition at line 694 of file BS_mac.cc.

00695 {
00696         /* Busqueda de todas las rutas posibles desde este usuario y una ONU pasarela */
00697         cModule *user;//, *bs;
00698         user = (cModule*) this->getParentModule()->getParentModule()->getSubmodule("user",index);
00699         int pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BSs pasarela
00700         int indice_esta_bs = (int)this->getParentModule()->par("indice");
00701         //int indice_esta_bs = (int)this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00702         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red (25)
00703         int connections = (int) this->getParentModule()->par("conexiones");
00704         int rutas_user = estaciones*pasarelas*connections*pasarelas;
00705         Tabla->indices_rutas[index].resize(rutas_user);
00706 
00707         for (int w=0; w<rutas_user; w++)
00708         {
00709                 Tabla->indices_rutas[index][w].resize(pasarelas,-1);
00710         }
00712         char* nombre_user = (char*) user->getFullName(); // Nombre del usuario al que pertenece este modulo
00713         char* nombre_pasarela; // Nombre de la BS pasarela
00714         int auxiliar, ultimo;
00715         for(int i=0; i<pasarelas; i++)
00716         {
00717                 auxiliar=0; // Entero auxiliar para rellenar cada fila de la matriz con los indices de las rutas de este usuario a cada pasarela.
00718                                 //bs = (cModule*) this->getParentModule()->getParentModule()->getSubmodule(nombres_bs[indices_pasarelas[i]]);
00719                 nombre_pasarela = (char*) nombres_bs[indices_pasarelas[i]];
00720                 //bs = (cModule*) this->getParentModule()->getParentModule()->getSubmodule("bs",indices_pasarelas[i]); /////// CAMBIO_RED ///////
00721                 //nombre_pasarela = (char*) bs->getFullName(); /////// CAMBIO_RED ///////
00722 
00723                 for(int a=0; a<max_fila; a++)
00724                 {
00725                         ultimo = get_index_last_element(a);
00726                         if(strcmp(nombre_user, Tabla->array_de_rutas[a][0])==0 && strcmp(nombre_pasarela, Tabla->array_de_rutas[a][ultimo-1])==0)
00727                         {
00728                                 Tabla->indices_rutas[index][auxiliar][i] = a;
00729                                 auxiliar++;
00730                         }
00731                 }
00732         }
00733         // SUMA DE LOS ELEMENTOS DEL
00734         int contador;
00735         for(int t=0; t<pasarelas; t++)
00736         {
00737                 contador=0;
00738                 // ... se recorren todos los indices almacenados:
00739                 for(int y=0; y<rutas_user; y++)
00740                 {
00741                         if(Tabla->indices_rutas[index][y][t]!=-1)
00742                         {
00743                                 contador++;
00744                         }
00745                 }
00746                 Tabla->num_rutas[index][t] = contador;
00747                 if(indice_esta_bs == estaciones-1)
00748                 {
00749                         //ev << " Numero de rutas desde el usuario " << nombre_user << " y la pasarela " << nombres_bs[indices_pasarelas[t]] << ": " << Tabla->num_rutas[index][t] << endl;
00750                 }
00751         }
00752 }

void BS_mac::handleMessage ( cMessage msg  )  [protected, virtual]

Reimplemented from cSimpleModule.

Definition at line 224 of file BS_mac.cc.

00225 {
00226         int type = msg->getKind();
00227         switch(type)
00228         {
00229                 case 1:
00230                         //ev << "New TDMA frame" << endl;
00231                         scheduleAt(simTime()+time_frame, msg);
00232                         get_num_used_queues(); // Re-obtencion de los indices de los modulos BS_queue[] activos
00233                         timepacket = 0; // Reseteo de variables
00234                         //slot_tx_delay.clear();
00235                         for(int q=0; q<used_queues; q++)
00236                         {
00237                                 queue = check_and_cast<BS_queue *>(this->getParentModule()->getSubmodule("bs_queue",index_used_queues[q]));
00238                                 queue->sumcheckedpacket = 0;
00239                                 queue->sumextractedpacket = 0;
00240                         }
00241                         extract_packets();
00242                 break;
00243                 default:
00244                         delete msg;
00245                         break;
00246         }
00247 }

void BS_mac::initialize (  )  [protected, virtual]

Reimplemented from cComponent.

Definition at line 36 of file BS_mac.cc.

00037 {
00038         // Se incluyen en la topologia los nodos que contienen el parametro 'aux' (Users, BSs y ONUs):
00039         top.extractByParameter("aux");
00040         // NOTA: La clase cTopology es muy util para el manejo sencillo de los modulos compuestos (BS, ONU, User)
00041         //                       Cuando se crea un objeto de esta clase, se esta definiendo una representacion abstracta de la red
00042         //                       muy util para funciones de encaminamiento.
00043         //                       Los objetos cTopoloogy son grafos formados por nodos y enlaces. Los nodos se incluyen con la linea
00044         //                       'extractByParameter("")' y los enlaces son las conexiones entre ellos, que estan definidas en l .ned
00045         //                       como canales.
00046         //                       En este caso, para que el grafo incluya a todas las BSs, las ONUs y los Users, se ha definido en sus
00047         //                       respectivos ficheros de configuracion *.ned un parametro entero auxiliar llamado "aux", y se ha dicho
00048         //                       al grafo que incluya todos los nodos que tienen ese parametro.
00049         // Se extrae el nodo correspondiente al modulo compuesto que contiene este submodulo:
00050         top_node = top.getNodeFor((cModule*)this->getParentModule());
00051         // Si el enlace num.1 conecta con una ONU, es una pasarela:
00052         // NOTA: Tal como se han definido las conexiones en los ficheros *.ned de configuracion de red,
00053         //                       el enlace num.0 siempre es el que conecta BS con User (canal 'wifi'); y en el caso de
00054         //                 que una BS sea pasarela, los enlaces num.1 a num.<numcolas> corresponden a conexiones
00055         //                       con la ONU pasarela (canal 'pasarela'). Los demás enlaces conectan las BSs entre si (canal 'hops').
00056         if(strcmp(top_node->getLinkOut(1)->getRemoteNode()->getModule()->getName(),"onu")==0){  esPasarela=1;   }
00057         else{   esPasarela=0;   }
00058 
00059         // INICIALIZACION DE PARAMETROS //
00060         int indice_esta_bs = (int)this->getParentModule()->par("indice");       // Indice de este modulo BS
00061         //int indice_esta_bs = (int)this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00062 
00063         prioridades = (int)this->getParentModule()->par("numcolas"); // Numero de clases de servicio de la parte inalambrica de la red
00064         ind_primero = 0; // Indice del primer submodulo BS_queue que esta activo (uso = usado = 1).
00065         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red
00066         int num_pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BSs pasarela
00067         int usuarios = (int) this->getParentModule()->par("numUser"); // Corresponde a las filas de la tabla rutas_optimas[][]
00068         int criterio = (int) this->getParentModule()->par("criterio"); // Criterio seguido para encaminar (algoritmos SPRA, DARA o MHRA)
00069 
00070         extraction_method = (int) this->getParentModule()->par("user_extractionmethod_StrictPQ0_Centralized1"); // Metodo de extraccion de paquetes de las colas BS_queue[]
00071         media_saltos = 0; // Numero medio de saltos de las rutas elegidas por el algoritmo de encaminamiento implementado
00072         nodos_actualizados = 0; // Numero de BSs que han actualizado los pesos de sus enlaces, tras haber recibido todos los LSAs que esperaban, en cada periodo entre envios de LSAs en el algoritmo DARA (esta variable se actualiza desde el modulo BS_rx_tx).
00073         actualizaciones = 0;
00074         txrate = (double) this->getParentModule()->par("tasabinaria"); // Tasa de transmision wireless (bps)
00075         rxrate = (double) this->getParentModule()->par("tasabinaria"); // Tasa de recepcion wireless (bps)
00076         // NOTA: La definicion de dos parametros con el mismo valor (txrate=rxrate="tasabinaria") tiene su explicacion en que las BSs pasarela tienen diferente txrate,
00077         //                       pues solo transmiten trafico en sentido ascendente, hacia las ONUs pasarela, mediante un enlace optico, luego su tasa de transmision a las ONUs es la de la red EPON y no la del estandar WiFi.
00078         //                       Ahora bien, los paquetes que reciben las BSs pasarela de las otras BSs es a la tasa de transmision definida para el estandar wireless, luego por eso en este caso se distinguen dos variables distintas.
00079         enlaces_intermedios = (int) top_node->getNumOutLinks() - 1; // Numero de conexiones entre esta BS y otras BSs de la parte inalambrica de la red.
00080         if(esPasarela == 1) // Si es una BS pasarela...
00081         {
00082                 double opt_txrate = (double) this->getParentModule()->par("txrate");
00083                 txrate = opt_txrate/10; // ...la tasa de transmision es la misma que la de las ONUs...
00084                 enlaces_intermedios = enlaces_intermedios - prioridades; // ...y al numero de conexiones entre BSs hay que descontarle las conexiones con la ONU pasarela ("numqueue").
00085         }
00086 
00087         C_i = (double) rxrate/enlaces_intermedios; // Capacidad de enlace = Capacidad del canal entre numero de enlaces con otras BSs.
00088 
00089         // CALCULO DEL PESO INICIAL DE CADA ENLACE INALAMBRICO:
00090         double init_weight = 0.0;
00091         int long_pckt = (int) this->getParentModule()->par("longitud_media_paquete");
00092         int bits_pckt = 8*long_pckt; // Promedio de bits en cada paquete de las fuentes inalambricas
00093                                                                                                                          // (parametro inverso a mhu, la tasa de servicio).
00094         int primer_indice; // Para cada BS de la topologia, indice del primer enlace cuyo peso se actualiza.
00095         BS_mac *aux_control; // Variable para acceder remotamente a la capa MAC de cada BS y sus parametros.
00096         if(indice_esta_bs == estaciones-1)
00097         {
00098                 // Se actualiza el peso de cada enlace con su valor inicial (en el ".ned" se pone '0.0' por defecto):
00099                 for(int i=0; i<(int)top.getNumNodes(); i++)
00100                 { // Para cada nodo de la topologia...
00101                         if(strpbrk(top.getNode(i)->getModule()->getFullName(),"b")!=NULL) // Si es una BS...
00102                         {
00103                                 primer_indice = 1; // El primer enlace es siempre con un modulo User, no interesa aqui.
00104                                 if(strcmp(top.getNode(i)->getLinkOut(1)->getRemoteNode()->getModule()->getName(),"onu")==0)
00105                                 { // Si es una BS-pasarela, los 'prioridades' enlaces posteriores al primero tampoco interesan en esta
00106                                         // parte, porque conectan con la correspondiente ONU pasarela.
00107                                         primer_indice = primer_indice + prioridades;
00108                                 }
00109                                 for(int a=primer_indice; a<(int)top.getNode(i)->getNumOutLinks(); a++)
00110                                 {
00111                                         aux_control = check_and_cast<BS_mac *>(top.getNode(i)->getModule()->getSubmodule("bs_mac"));
00112                                         switch(criterio) // Segun el criterio de encaminamiento elegido en 'omnetpp.ini'...
00113                                         {
00114                                         case 0: // SPRA: Shortest Path Routing Algorithm
00115                                                 init_weight = (double) 1/aux_control->C_i; // peso = 1/Ci
00116                                                 // Ci = Capacidad efectiva de cada enlace = Capacidad de radio/Numero de enlaces de salida de cada nodo.
00117                                                 break;
00118                                         case 1: // DARA: Delay Aware Routing Algorithm
00119                                                 //aux_control = check_and_cast<BS_mac *>(top.getNode(i)->getLinkOut(a)->getRemoteNode()->getModule()->getSubmodule("bs_mac"));
00120                                                 init_weight = (double) (3*bits_pckt)/(2*aux_control->C_i); // peso = (3/2)*(1/uCi)
00121                                                 break;
00122                                         case 2: // MHRA: Minimum Hop Routing Algorithm
00123                                                 init_weight = (double) 1; // peso = 1
00124                                                 break;
00125                                         }
00126                                         (check_and_cast<cDelayChannel*>(top.getNode(i)->getLinkOut(a)->getLocalGate()->getChannel()))->par(3)
00127                                                         = (double)init_weight;
00128                                 }
00129                         }
00130                 }
00131         }
00132         // DEFINIMOS EL PROCESO PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO 'BS_table':
00133         Tabla = check_and_cast<BS_table *>(getParentModule()->getSubmodule("bs_table")); // ENTRAMOS Y CHEQUEAMOS EL MODULO BS_TABLE
00134 
00135         filas = Tabla->filas; // Filas de las tablas del modulo BS_Table
00136         columnas = Tabla->columnas; // Columnas de las tablas del modulo BS_Table
00137 
00138         // Vector con los nombres de todas las BS (para acceder mas facilmente a ellas dentro de bucles):
00139         nombres_bs.resize(estaciones);
00140         nombres_bs[0] = "bs0";
00141         nombres_bs[1] = "bs1";
00142         nombres_bs[2] = "bs2";
00143         nombres_bs[3] = "bs3";
00144         nombres_bs[4] = "bs4";
00145         nombres_bs[5] = "bs5";
00146         nombres_bs[6] = "bs6";
00147         nombres_bs[7] = "bs7";
00148         nombres_bs[8] = "bs8";
00149         nombres_bs[9] = "bs9";
00150         nombres_bs[10] = "bs10";
00151         nombres_bs[11] = "bs11";
00152         nombres_bs[12] = "bs12";
00153         nombres_bs[13] = "bs13";
00154         nombres_bs[14] = "bs14";
00155         nombres_bs[15] = "bs15";
00156         nombres_bs[16] = "bs16";
00157         nombres_bs[17] = "bs17";
00158         nombres_bs[18] = "bs18";
00159         nombres_bs[19] = "bs19";
00160         nombres_bs[20] = "bs20";
00161         nombres_bs[21] = "bs21";
00162         nombres_bs[22] = "bs22";
00163         nombres_bs[23] = "bs23";
00164         nombres_bs[24] = "bs24";
00165 
00166         // Vector con los indices de las "numGW" BSs pasarela:
00167         indices_pasarelas.resize(num_pasarelas);
00168         indices_pasarelas[0] = 7;
00169         indices_pasarelas[1] = 9;
00170         indices_pasarelas[2] = 13;
00171         indices_pasarelas[3] = 19;
00172         indices_pasarelas[4] = 24;
00173         /*
00174         indices_pasarelas[0] = 5;
00175         indices_pasarelas[1] = 7;
00176         indices_pasarelas[2] = 9;
00177         */
00178         for(int i=0; i<num_pasarelas; i++)
00179         {
00180                 Tabla->rutas_optimas_pasarelas[i].resize(usuarios);
00181                 for(int n=0;n<usuarios;n++)
00182                 {
00183                         Tabla->rutas_optimas_pasarelas[i][n].resize(columnas," ");
00184                 }
00186         }
00187 
00188         // Invocacion del metodo 'routing()' para cada BS, una vez que todas han sido inicializadas (desde la ultima BS de la subred):
00189         if(indice_esta_bs == estaciones-1)
00190         {
00191                 BS_mac *route;
00192                 for(int i=0; i<estaciones; i++)
00193                 {
00194                         route = check_and_cast<BS_mac *>(this->getParentModule()->getParentModule()->getSubmodule(nombres_bs[i])->getSubmodule("bs_mac"));
00195                         //route = check_and_cast<BS_mac *>(this->getParentModule()->getParentModule()->getSubmodule("bs",i)->getSubmodule("bs_mac")); /////// CAMBIO_RED ///////
00196                         route->routing();
00197                 }
00198         }
00199 
00201         sumcolas = 0; // Total bytes en las colas de esta BS.
00202         int conex = (int) this->getParentModule()->par("conexiones"); // Longitud del array de modulos BS_queue[] (numero de potenciales conexiones con otras BSs).
00203         int colas = conex-1;
00204         index_used_queues.resize(colas,-1);
00205         //slot_tx_delay.resize(colas, (simtime_t)0);
00206         t_frame = (double) this->getParentModule()->par("delta_time"); // Duracion del periodo de trama TDM en los canales inalambricos
00207         get_num_used_queues(); // Invocacion a la funcion que calcula el numero de modulos BS_queue[] que realmente estan conectados a enlaces que conectan con otras BSs intermedias.
00208         //ev << "Enlaces activos en esta BS: " << used_queues << endl;
00209         time_frame = (simtime_t) t_frame;
00210         //ev << "Tiempo de trama TDMA: " << t_frame << "s" << endl;
00211         //ev << "Tiempo de slot TDMA: " << t_slot << "s" << endl;
00212         timepacket = 0;
00213         cMessage *msg = new cMessage ("TDMA",1); 
00214         scheduleAt((simtime_t)0, msg); 
00215 }

int BS_mac::is_an_empty_row ( int  row  )  [protected, virtual]

Definition at line 253 of file BS_mac.cc.

00254 {
00255         int ocupado = 0;
00256         if (strcmp(" ",Tabla->array_de_rutas[row][0])!=0)
00257         {
00258                 ocupado = 1;
00259         }
00260         return ocupado;
00261 }

int BS_mac::puerta_entrada_libre ( cModule node,
int  puertas 
) [protected, virtual]

Definition at line 366 of file BS_mac.cc.

00367 {
00368         cModule *nodo = check_and_cast<cModule*>(node);
00369         int i=0, encontrado = -1;
00370         while (i<puertas && encontrado ==-1)
00371         {
00372                 if(!nodo->gate("physicalBS$i",i)->isConnected())
00373                 {
00374                         encontrado = i;
00375                 }
00376                 i++;
00377         }
00378         return encontrado;
00379 }

int BS_mac::puerta_salida_libre ( cModule node,
int  puertas 
) [protected, virtual]

Definition at line 385 of file BS_mac.cc.

00386 {
00387         cModule *nodo = check_and_cast<cModule*>(node);
00388         int i=0, encontrado = -1;
00389         while (i<puertas && encontrado ==-1)
00390         {
00391                 if(!nodo->gate("physicalBS$o",i)->isConnected())
00392                 {
00393                         encontrado = i;
00394                 }
00395                 i++;
00396         }
00397         return encontrado;
00398 }

void BS_mac::recalculo_ruta_delay_aware ( int  ind_usr  )  [virtual]

Definition at line 988 of file BS_mac.cc.

00989 {
00990         int indice_esta_bs = (int)this->getParentModule()->par("indice");
00991         //int indice_esta_bs = (int) this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
00992         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red (25)
00993         int usuarios = (int) this->getParentModule()->par("numUser"); // Numero de usuarios
00994         int pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BS-pasarelas
00995 
00997         for(int j=0; j<pasarelas; j++)
00998         {
00999                 int min_index = Tabla->indices_rutas[ind_usr][0][j];
01000                 if(Tabla->num_rutas[ind_usr][j]>1)
01001                 {
01002                         for(int i=0; i<Tabla->num_rutas[ind_usr][j]; i++)
01003                         {
01005                                 if(Tabla->peso_total_rutas[Tabla->indices_rutas[ind_usr][i][j]] < Tabla->peso_total_rutas[min_index])
01006                                 {
01007                                         min_index=Tabla->indices_rutas[ind_usr][i][j];
01008                                 }
01009                         }
01010                         opt_route[j]=min_index;
01012                 }
01013                 else if(Tabla->num_rutas[ind_usr][j]==1)
01014                 {
01016                         min_index = Tabla->indices_rutas[ind_usr][0][j];
01017                         opt_route[j]=min_index;
01019                 }
01020                 else if(Tabla->num_rutas[ind_usr][j]==0)
01021                 {
01022                         opt_route[j]= -1;
01023                 }
01024         }
01025 
01026         for(int q=0; q<pasarelas; q++)
01027         {
01028                 if(opt_route[q]!=-1)
01029                 {
01030                         Tabla->rutas_optimas_pasarelas[q][ind_usr] = Tabla->array_de_rutas[opt_route[q]];
01031                         auxiliar_matrix[q][ind_usr] = Tabla->peso_total_rutas[opt_route[q]];
01032                 }
01033         }
01034         /*
01035         if(ind_usr == usuarios-1 && indice_esta_bs == estaciones-1 && actualizaciones == 0)
01036         {
01037                 for(int k=0; k<pasarelas; k++)
01038                 {
01039                         //ev << endl;
01040                         //ev << " **TABLA CON LA " << k << "-ESIMA RUTA OPTIMA (MENOR PESO) HASTA LA PASARELA " << nombres_bs[indices_pasarelas[k]]<< " PARA CADA USUARIO**" << endl;
01041                         for(int a=0; a<usuarios; a++)
01042                         {
01043                                 for(int b=0; b<columnas; b++)
01044                                 {
01045                                         //ev << " | " << Tabla->rutas_optimas_pasarelas[k][a][b];
01046                                 }
01047                                 //ev << " --> Peso: " << auxiliar_matrix[k][a] << endl;
01048                         }
01049                         //ev << endl;
01050                 }
01051 
01053                         //ev << " TABLA CON EL PESO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01054                         for(int a=0; a<max_fila; a++)
01055                         {
01056                                 for(int b=0; b<columnas; b++)
01057                                 {
01058                                         //ev << " | " << Tabla->array_de_pesos[a][b];
01059                                 }
01060                                 //ev << " --> Total: " << Tabla->peso_total_rutas[a] << endl;
01061                         }
01062                         //ev << endl;
01063         }
01064         */
01065         int aux1=0, first_index=0, first_onu=0;
01066         for(int h=0; h<pasarelas; h++)
01067         {
01068                 if(opt_route[h]>0 && aux1==0)
01069                 {
01070                         aux1=1;
01071                         first_index=opt_route[h];
01072                         first_onu=indices_pasarelas[h];
01074                 }
01075                 else if(opt_route[h]>0 && aux1!=0)
01076                 {
01078                         if(Tabla->peso_total_rutas[opt_route[h]]<Tabla->peso_total_rutas[first_index])
01079                         {
01080                                 first_index=opt_route[h];
01081                                 first_onu=indices_pasarelas[h];
01082                         }
01083                 }
01084         }
01086 
01087         Tabla->rutas_optimas[ind_usr] = Tabla->array_de_rutas[first_index];
01088         media_saltos = (double)(media_saltos + get_index_last_element(first_index)-1);
01089         auxiliar_array[ind_usr] = Tabla->peso_total_rutas[first_index];
01090         /*
01091         if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1 && actualizaciones==0)
01092         //if(ind_usr == usuarios-1 && indice_esta_bs==estaciones-1)
01093         {
01094                 //ev << endl;
01095                 //ev << "               " << this->nombres_bs[indice_esta_bs] << endl;
01096                 ev << " **TABLA CON LA RUTA OPTIMA HASTA UNA ONU (MENOR RETARDO) PARA CADA USUARIO**" << endl;
01097                 for(int a=0; a<usuarios; a++)
01098                 {
01099                         for(int b=0; b<columnas; b++)
01100                         {
01101                                 ev << " | " << Tabla->rutas_optimas[a][b];
01102                         }
01103                         ev << "  --> Peso (retardo): " << auxiliar_array[a] << " s."<< endl;
01104                 }
01105                 ev << endl;
01106                 //actualizaciones++;
01107                 ev << endl;
01109                 ev << " TABLA CON EL PESO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01110                 for(int g=0; g<usuarios; g++)
01111                 {
01112                         for(int h=0; h<pasarelas; h++)
01113                         {
01114                                 for(int i=0; i<Tabla->num_rutas[g][h]; i++)
01115                                 {
01116                                         for(int j=0; j<columnas; j++)
01117                                         {
01118                                                 ev << " | " << Tabla->array_de_pesos[Tabla->indices_rutas[g][i][h]][j];
01119                                         }
01120                                         ev << " --> Total: " << Tabla->peso_total_rutas[Tabla->indices_rutas[g][i][h]] << endl;
01121                                 }
01122                         }
01123                 }
01124                 ev << endl;
01125         }
01126         */
01127 }

void BS_mac::relleno_arrays_retardos (  )  [virtual]

Definition at line 605 of file BS_mac.cc.

00606 {
00607         // Se incluyen en la topologia los nodos que contienen el parametro 'aux' (Users, BSs y ONUs):
00608         top.extractByParameter("aux");
00610         for(int i=0; i<max_fila; i++)
00611         {
00612                 for(int j=0; j<columnas; j++)
00613                 {
00614                         if(strcmp(Tabla->array_de_rutas[i][j]," ")!=0 && strpbrk(Tabla->array_de_rutas[i][j],"on")==NULL)
00615                         {
00616                                 int ind_1=0,ind_2=0;
00617                                 for(int p=0; p<(int)top.getNumNodes(); p++)
00618                                 {
00619                                         if(strcmp(top.getNode(p)->getModule()->getFullName(),Tabla->array_de_rutas[i][j])==0)
00620                                         {
00621                                                 ind_1=p;
00622                                         }
00623                                         if(strcmp(top.getNode(p)->getModule()->getFullName(),Tabla->array_de_rutas[i][j+1])==0)
00624                                         {
00625                                                 ind_2=p;
00626                                         }
00627                                 }
00628                                 top_node = top.getNode(ind_1);
00630                                 int ind_aux=-1, k=0;
00631                                 while(ind_aux<0 && k<(int)top_node->getNumOutLinks())
00632                                 {
00635                                         if(strcmp(top_node->getLinkOut(k)->getRemoteGate()->getOwnerModule()->getFullName(),top.getNode(ind_2)->getModule()->getFullName())==0)
00636                                         {
00637                                                 ind_aux=k;
00638                                         }
00639                                         k++;
00640                                 }
00641                                 /*for (int k=0; k<(int)top_node->getNumOutLinks(); k++)
00642                                 {
00643                                         if(strcmp(top_node->getLinkOut(k)->getRemoteGate()->getOwnerModule()->getFullName(),top.getNode(ind_2)->getModule()->getFullName())==0)
00644                                         {
00645                                                 ind_aux=k;
00646                                         }
00647                                 }*/
00648                                 //AQUI//
00649                                 if(strcmp(top_node->getLinkOut(ind_aux)->getRemoteNode()->getModule()->getName(),"onu")!=0)
00650                                 {
00651                                         Tabla->array_de_pesos[i][j] = (check_and_cast<cDelayChannel*>(top_node->getLinkOut(ind_aux)->getLocalGate()->getChannel()))->par(3);
00652                                 }
00653                         }
00654                 }
00655         }
00657 
00659         for(int a=0; a<max_fila; a++)
00660         {
00661                 for(int b=0; b<columnas; b++)
00662                 {
00663                         Tabla->peso_total_rutas[a] = 0;
00664                 }
00665         }
00666         for(int a=0; a<max_fila; a++)
00667         {
00668                 for(int b=0; b<columnas; b++)
00669                 {
00670                         Tabla->peso_total_rutas[a] = Tabla->peso_total_rutas[a] + Tabla->array_de_pesos[a][b];
00671                 }
00672         }
00674         /*//--->
00675         ev << " **ACTUALIZACION TABLA DE PESOS DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU**" << endl;
00676         for(int x=0; x<max_fila; x++)
00677         {
00678                 ev << Tabla->peso_total_rutas[x] << "   ==      ";
00679                 int last = get_index_last_element(x);
00680                 for(int b=0; b<last; b++)
00681                 {
00682                         ev << Tabla->array_de_pesos[x][b] << "  +       ";
00683                 }
00684                 ev << endl;
00685         }
00686         //<---*/
00687 }

void BS_mac::routing (  )  [virtual]

Definition at line 1136 of file BS_mac.cc.

01137 {
01138         // VARIABLES AUXILIARES //
01139         int indice_esta_bs = (int)this->getParentModule()->par("indice"); // Indice de esta BS
01140         //int indice_esta_bs = (int) this->getParentModule()->getIndex(); /////// CAMBIO_RED ///////
01141         int estaciones = (int) this->getParentModule()->par("numBS"); // Numero de estaciones base de la red
01142         int num_pasarelas = (int) this->getParentModule()->par("numGW"); // Numero de BSs pasarela
01143         int usuarios = (int) this->getParentModule()->par("numUser"); // Corresponde a las filas de la tabla rutas_optimas[][]
01144         int criterio = (int) this->getParentModule()->par("criterio"); // Criterio seguido para encaminar (SPRA, DARA, MHRA)
01145         cModule *red = (cModule*) this->getParentModule()->getParentModule(); // Referencia al modulo tipo cNetwork que corresponde a la red simulada
01146         cModule *nodo, *sig_nodo;
01147         cTopology::Node *topo_nodo;
01148         int enlaces;
01149         char* nombre_usuario;
01150         char* nombre_nodo;
01151         char* nombre_sig_nodo;
01152         double dist_user_bs = 0, distancia = 0, del_user_bs = 0.0, retardo = 0.0, wei_user_bs = 0.0, peso = 0.0;
01153 
01155         // Para cada usuario, se meten tantas filas como posibles caminos hay hasta una onu pasarela.
01156         for(int a=0; a<usuarios; a++)
01157         {
01158                 // La primera celda de todas las filas contiene el nombre del modulo del usuario inalambrico:
01159                 nombre_usuario = (char*) red->getSubmodule("user",a)->getFullName();
01160                 // Acceso remoto al modulo BS que atiende a cada usuario:
01161                 nodo = red->getSubmodule("user",a)->gate("physicalUser$o")->getNextGate()->getOwnerModule();
01162                 nombre_nodo = (char*) nodo->getFullName(); // Nombre de la BS con la esta conectado el User
01163                 dist_user_bs = (double) red->getSubmodule("user",a)->gate("physicalUser$o")->getChannel()->par(2); // Obtencion de la distancia entre el User y la BS
01164                 del_user_bs = (double) red->getSubmodule("user",a)->gate("physicalUser$o")->getChannel()->par(4); // Obtencion del retardo de propagacion del canal entre User y BS
01165                 //wei_user_bs = (double) top.getNodeFor(red->getSubmodule(nombres_bs[a]))->getLinkOut(0)->getLocalGate()->getChannel()->par(3); // Obtencion del peso del canal entre User y BS
01166                 topo_nodo = top.getNodeFor((cModule*)nodo); // Acceso al nodo del grafo (cTopology) top correspondiente al modulo BS con el que conecta el User
01167                 enlaces = topo_nodo->getNumOutLinks(); // Numero de enlaces salientes del nodo BS con el que conecta el User
01168                 int primero = get_index_first_empty_row(); // Obtencion del indice de la primera fila vacia de las tablas array_de_rutas[][], array_de_longitudes [][], array_de_pesos[][], array_de_retardos[][]
01169                 // Si la BS con la que conecta el User es una pasarela, se graba en las tablas la ruta User->BS->ONU y se pasa al siguiente User
01170                 // (los User que estan conectados a las BS pasarela encaminan su trafico directamente por ellas, aunque se ha decidido que estos User concretos no generen trafico)
01171                 if(strcmp(topo_nodo->getLinkOut(1)->getRemoteNode()->getModule()->getName(),"onu")==0)
01172                 {
01173                         sig_nodo = topo_nodo->getLinkOut(1)->getRemoteNode()->getModule();
01174                         nombre_sig_nodo = (char*)sig_nodo->getFullName();
01175                         distancia = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(1)->getLocalGate()->getChannel()))->par(2);
01176                         retardo = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(1)->getLocalGate()->getChannel()))->par(4);
01177                         //peso = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(1)->getLocalGate()->getChannel()))->par(3);
01178                         peso = 0.0; // Se pone a 0 el peso entre BS y ONU pasarelas (los pesos, que sirven para elegir una ruta optima, solo proceden en los enlaces entre BSs, asi que los enlaces ente User y BS y entre ONu y BS tienen peso nulo).
01179                         // RELLENO DE UNA NUEVA FILA EN LAS TABLAS //
01180                         Tabla->array_de_rutas[primero][0] = nombre_usuario;
01181                         Tabla->array_de_rutas[primero][1] = nombre_nodo;
01182                         Tabla->array_de_rutas[primero][2] = nombre_sig_nodo;
01183                         Tabla->array_de_longitudes[primero][0] = dist_user_bs;
01184                         Tabla->array_de_longitudes[primero][1] = distancia;
01185                         Tabla->array_de_retardos[primero][0] = del_user_bs;
01186                         Tabla->array_de_retardos[primero][1] = retardo;
01187                         Tabla->array_de_pesos[primero][0] = wei_user_bs;
01188                         Tabla->array_de_pesos[primero][1] = peso;
01189                 }
01190                 else
01191                 {
01192                         // Si la BS con la que conecta el User no es una pasarela, se recorren todos los enlaces salientes de este nodo BS para ir incluyendo nuevas rutas para este User en las tablas
01193                         for(int b=1; b<(int)topo_nodo->getNumOutLinks(); b++)
01194                         {
01195                                 sig_nodo = topo_nodo->getLinkOut(b)->getRemoteNode()->getModule(); // Acceso remoto al modulo BS con el que conecta la BS asociada al User por el enlace saliente 'b'
01196                                 nombre_sig_nodo = (char*)sig_nodo->getFullName(); // Nombre de esta BS, siguiente nodo en la posible nueva ruta
01197                                 distancia = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(b)->getLocalGate()->getChannel()))->par(2); // Distancia entre las 2 BSs
01198                                 retardo = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(b)->getLocalGate()->getChannel()))->par(4); // Retardo de propagacion en el canal entre las 2 BSs
01199                                 peso = (double) (check_and_cast<cDelayChannel*>(topo_nodo->getLinkOut(b)->getLocalGate()->getChannel()))->par(3); // Peso del enlace entre las 2 BSs
01200                                 // RELLENO DE UNA NUEVA FILA EN LAS TABLAS //
01201                                 Tabla->array_de_rutas[primero+b-1][0] = nombre_usuario;
01202                                 Tabla->array_de_rutas[primero+b-1][1] = nombre_nodo;
01203                                 Tabla->array_de_rutas[primero+b-1][2] = nombre_sig_nodo;
01204                                 Tabla->array_de_longitudes[primero+b-1][0] = dist_user_bs;
01205                                 Tabla->array_de_longitudes[primero+b-1][1] = distancia;
01206                                 Tabla->array_de_retardos[primero+b-1][0] = del_user_bs;
01207                                 Tabla->array_de_retardos[primero+b-1][1] = retardo;
01208                                 Tabla->array_de_pesos[primero+b-1][0] = wei_user_bs;
01209                                 Tabla->array_de_pesos[primero+b-1][1] = peso;
01210                         }
01211                 }
01212         }
01213         // Una vez se han rellenado una serie de filas de las tablas con rutas entre un User, la BS asociada y el siguiente nodo con el que conecta dicha BS,
01214         // es muy probable que la mayoria de las rutas esten a medias (es decir, que aun no acaben en una ONU pasarela). Por eso, ahora se recorren todas las
01215         // filas ya rellenadas para intentar completar estas rutas (e incluso incluir nuevas, si procede). Pero este recorrido no se puede hacer una vez,
01216         // porque en cada iteracion del bucle se incluye un unico nodo mas a cada ruta, luego se necesitan unas cuantas iteraciones para garantizar que todas las
01217         // rutas se han completado.
01218         int bucle = 0;
01219         while(bucle<=15) //Para SFNet: bucle<=15 //Para SFNet_small: bucle<=10 //Para SFNet_small2: bucle<=7
01220         {
01221                 // Variables auxiliares //
01222                 int c=0, ultimo_nodo=0;
01223                 char *elemento;
01224                 char* nom_onu;
01225                 double dist_onu=0.0, ret_onu=0.0, pes_onu=0.0;
01226                 cModule *bs_intermedia;
01227                 cTopology::Node *top_inter_bs;
01228                 // Se recorren todas las filas de la tabla array_de_rutas[][]:
01229                 while(c<filas)
01230                 {
01231                         // Si esta no es una fila vacia, se comprueba si termina o no en una ONU
01232                         if(strcmp(Tabla->array_de_rutas[c][0]," ")!=0)
01233                         {
01234                                 ultimo_nodo = get_index_last_element(c); // Ultimo nodo de la ruta, hasta el momento
01235                                 // Si la ruta no termina en una ONU, se accede al modulo BS cuyo nombre aparece en el ultimo nodo (hasta el momento) de la ruta
01236                                 // y se intenta completar esta ruta buscando los nodos con los que esta BS intermedia conecta (ONU u otra BS):
01237                                 if(strpbrk(Tabla->array_de_rutas[c][ultimo_nodo],"on") == NULL)
01238                                 {
01239                                         elemento = (char*) Tabla->array_de_rutas[c][ultimo_nodo]; // Nombre del ultimo elemento que aparece en la fila (se sabe que es una BS)
01240                                         bs_intermedia = (cModule*) red->getSubmodule(elemento); // Obtencion del modulo al que corresponde el nombre que aparece en la ultima posicion ocupada de la fila 'c'
01241                                         /*
01243                                         int number = -1, cont_aux=0;
01244                                         while(cont_aux<estaciones && number<0)
01245                                         {
01246                                                 if(strcmp(elemento,(char*)red->getSubmodule("bs",cont_aux)->getFullName())==0)
01247                                                 {
01248                                                         number = cont_aux;
01249                                                 }
01250                                                 cont_aux++;
01251                                         }
01252                                         bs_intermedia = (cModule*) red->getSubmodule("bs",number);
01254                                         */
01255                                         top_inter_bs = top.getNodeFor(bs_intermedia); // Acceso al nodo del grafo que corresponde al modulo de la BS intermedia
01256                                         // Si la "BS intermedia" es una pasarela, se incluye en la fila la info del enlace BS<-->ONU y se pasa a la siguiente fila:
01257                                         if(strcmp(top_inter_bs->getLinkOut(1)->getRemoteNode()->getModule()->getName(),"onu")==0)
01258                                         {
01259                                                 nom_onu = (char*) top_inter_bs->getLinkOut(1)->getRemoteNode()->getModule()->getFullName();
01260                                                 dist_onu = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(1)->getLocalGate()->getChannel()))->par(2);
01261                                                 ret_onu = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(1)->getLocalGate()->getChannel()))->par(4);
01262                                                 //pes_onu = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(1)->getLocalGate()->getChannel()))->par(3);
01263                                                 pes_onu = 0.0;
01264                                                 Tabla->array_de_rutas[c][ultimo_nodo+1] = nom_onu;
01265                                                 Tabla->array_de_longitudes[c][ultimo_nodo] = dist_onu;
01266                                                 Tabla->array_de_retardos[c][ultimo_nodo] = ret_onu;
01267                                                 Tabla->array_de_pesos[c][ultimo_nodo] = pes_onu;
01268                                         }
01269                                         // Si la "BS intermedia" no es una pasarela, se recorren los enlaces salientes de este nodo y se intentan incluir nuevas rutas en la tabla
01270                                         else if(strcmp(top_inter_bs->getLinkOut(1)->getRemoteNode()->getModule()->getName(),"onu")!=0)
01271                                         {
01272                                                 int primera_vez = 0, indice_auxiliar = 0;
01273                                                 for(int d=1;d<(int)top_inter_bs->getNumOutLinks();d++)
01274                                                 {
01275                                                         cModule *aux_mod = top_inter_bs->getLinkOut(d)->getRemoteNode()->getModule();
01276                                                         char *aux_nom  = (char*)aux_mod->getFullName();
01277                                                         if(ya_aparece(aux_nom,c,ultimo_nodo)==0) // Si no aparece ya este elemento en la ruta, se mete
01278                                                         {
01279                                                                 double dist_aux = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(d)->getLocalGate()->getChannel()))->par(2);
01280                                                                 double ret_aux = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(d)->getLocalGate()->getChannel()))->par(4);
01281                                                                 double pes_aux = (double) (check_and_cast<cDelayChannel*>(top_inter_bs->getLinkOut(d)->getLocalGate()->getChannel()))->par(3);
01282                                                                 if(primera_vez == 1)//Si no es la primera nueva ruta que se mete para este nodo:
01283                                                                 {
01284                                                                         indice_auxiliar = get_index_first_empty_row();//Se mete en la primera fila disponible
01285                                                                         Tabla->array_de_rutas[indice_auxiliar] = Tabla->array_de_rutas[c];
01286                                                                         Tabla->array_de_longitudes[indice_auxiliar] = Tabla->array_de_longitudes[c];
01287                                                                         Tabla->array_de_retardos[indice_auxiliar] = Tabla->array_de_retardos[c];
01288                                                                         Tabla->array_de_pesos[indice_auxiliar] = Tabla->array_de_pesos[c];
01289                                                                 }
01290                                                                 else if(primera_vez == 0)//Si es la primera nueva ruta que se mete para este nodo:
01291                                                                 {
01292                                                                         indice_auxiliar = c;//Se completa la ruta en la presente fila
01293                                                                         primera_vez = 1;
01294                                                                 }
01295                                                                 Tabla->array_de_rutas[indice_auxiliar][ultimo_nodo+1] = aux_nom;
01296                                                                 Tabla->array_de_longitudes[indice_auxiliar][ultimo_nodo] = dist_aux;
01297                                                                 Tabla->array_de_retardos[indice_auxiliar][ultimo_nodo] = ret_aux;
01298                                                                 Tabla->array_de_pesos[indice_auxiliar][ultimo_nodo] = pes_aux;
01299                                                         }
01300                                                 }
01301                                                 if(primera_vez==0)
01302                                                 {// Si no se ha aņadido nada a esta ruta incompleta, se elimina de la tabla
01303                                                         for(int i=c; i<filas-1; i++)
01304                                                         {
01305                                                                 Tabla->array_de_rutas[i] = Tabla->array_de_rutas[i+1];
01306                                                                 Tabla->array_de_longitudes[i] = Tabla->array_de_longitudes[i+1];
01307                                                                 Tabla->array_de_retardos[i] = Tabla->array_de_retardos[i+1];
01308                                                                 Tabla->array_de_pesos[i] = Tabla->array_de_pesos[i+1];
01309                                                         }
01310                                                         c--; // Si se ha borrado una fila, se evita que se incremente el valor de c en la siguiente iteracion
01311                                                 }
01312                                         }
01313                                 }
01314                         }
01315                         c++;
01316                 }
01317                 bucle++;
01318         }
01320         max_fila = get_index_first_empty_row(); // Obtencion del indice de la ultima fila ocupada en las tablas recien rellenadas
01321 
01323         for(int a=0; a<max_fila; a++)
01324         {
01325                 for(int b=0; b<columnas; b++)
01326                 {
01327                         Tabla->longitud_total_rutas[a] = Tabla->longitud_total_rutas[a] + Tabla->array_de_longitudes[a][b];
01328                 }
01329         }
01330         for(int a=0; a<max_fila; a++)
01331         {
01332                 for(int b=0; b<columnas; b++)
01333                 {
01334                         Tabla->retardo_total_rutas[a] = Tabla->retardo_total_rutas[a] + Tabla->array_de_retardos[a][b];
01335                 }
01336         }
01337         for(int a=0; a<max_fila; a++)
01338         {
01339                 for(int b=0; b<columnas; b++)
01340                 {
01341                         Tabla->peso_total_rutas[a] = Tabla->peso_total_rutas[a] + Tabla->array_de_pesos[a][b];
01342                 }
01343         }
01344         for(int a=0; a<max_fila; a++)
01345         {
01346                 Tabla->saltos_total_rutas[a] = get_index_last_element(a) - 1;
01347         }
01349 
01350         /*
01351         if(indice_esta_bs == estaciones-1)
01352         {
01353                 ev << endl << " CRITERIO SEGUIDO PARA REALIZAR EL ENCAMINAMIENTO DE LOS MENSAJES DE LOS USUARIOS: " << endl;
01354                 switch(criterio)
01355                 {
01356                 case 0:
01357                         ev << "         SHORTEST-PATH: Minimizar la distancia recorrida de origen a destino" << endl;
01358                         break;
01359                 case 1:
01360                         ev << "         MINIMUM-DELAY: Minimizar el retardo de propagacion de origen a destino" << endl;
01361                         break;
01362                 case 2:
01363                         ev << "         MINIMUM-HOP: Minimizar el numero de saltos total" << endl;
01364                         break;
01365                 }
01366         }
01367         */
01368 
01369         // CALCULO DE LA RUTA MAS CORTA PARA CADA USUARIO, SEGUN EL CRITERIO ELEGIDO:
01370         auxiliar_array.resize(usuarios); // Redimensionamiento de un array y una matriz auxiliares para la siguiente operacion
01371         auxiliar_matrix.resize(num_pasarelas);
01372         for(int n=0;n<num_pasarelas;n++)
01373         {
01374                 auxiliar_matrix[n].resize(usuarios,0.0);
01375         }
01376         opt_route.resize(num_pasarelas,-1);
01377         for(int r=0; r<usuarios; r++)
01378         {
01379                 get_routes_for_each_user(r);
01380                 switch(criterio)
01381                 {
01382                 case 0:
01383                         calculo_ruta_shortest_path(r);
01384                         break;
01385                 case 1:
01386                         recalculo_ruta_delay_aware(r);
01387                         break;
01388                 case 2:
01389                         calculo_ruta_minimum_hop(r);
01390                         break;
01391                 }
01392         }
01393 
01394         //auxiliar_array.resize(0);
01395         for(int n=0;n<num_pasarelas;n++)
01396         {
01397                 auxiliar_matrix[n].resize(0);
01398         }
01399         opt_route.resize(0);
01400 
01401         media_saltos = (double)(media_saltos/usuarios);
01403 
01404         // REDIMENSIONAMOS LOS ARRAYS QUITANDO LAS FILAS QUE NO HACEN FALTA (ASI SE LIBERA ALGO DE ESPACIO EN MEMORIA):
01405         Tabla->saltos_total_rutas.resize(max_fila);
01406         Tabla->longitud_total_rutas.resize(max_fila);
01407         Tabla->retardo_total_rutas.resize(max_fila);
01408         Tabla->peso_total_rutas.resize(max_fila);
01409         Tabla->array_de_rutas.resize(max_fila);
01410         Tabla->array_de_longitudes.resize(max_fila);
01411         Tabla->array_de_retardos.resize(max_fila);
01412         Tabla->array_de_pesos.resize(max_fila);
01413 
01414         // IMPRESION DE LAS TABLAS (SOLO EN LA INICIALIZACION DE LA ULTIMA BS):
01415         if(indice_esta_bs == estaciones-1)
01416         {
01418                 /*
01419                 //ev << endl;
01420                 //ev << " **RUTAS COMPLETAS ORDENADAS SEGUN EL USUARIO ORIGEN Y LA BS-PASARELA DESTINO**" << endl;
01421                 for(int g=0; g<usuarios; g++)
01422                 {
01423                         for(int h=0; h<num_pasarelas; h++)
01424                         {
01425                                 for(int i=0; i<Tabla->num_rutas[g][h]; i++)
01426                                 {
01427                                         for(int j=0; j<columnas; j++)
01428                                         {
01429                                                 //ev << " | " << Tabla->array_de_rutas[Tabla->indices_rutas[g][i][h]][j];
01430                                         }
01431                                         //ev << " --> PESO: " << Tabla->peso_total_rutas[Tabla->indices_rutas[g][i][h]] << endl;
01432                                 }
01433                         }
01434                 }
01435                 //ev << endl;
01436         //}
01437  //--->
01439                 //ev << " TABLA CON LA LONGITUD DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01440                 for(int g=0; g<usuarios; g++)
01441                 {
01442                         for(int h=0; h<num_pasarelas; h++)
01443                         {
01444                                 for(int i=0; i<Tabla->num_rutas[g][h]; i++)
01445                                 {
01446                                         for(int j=0; j<columnas; j++)
01447                                         {
01448                                                 //ev << " | " << Tabla->array_de_longitudes[Tabla->indices_rutas[g][i][h]][j];
01449                                         }
01450                                         //ev << " --> Total: " << Tabla->longitud_total_rutas[Tabla->indices_rutas[g][i][h]] << endl;
01451                                 }
01452                         }
01453                 }
01454                 //ev << endl;
01456                 //ev << " TABLA CON EL RETARDO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01457                 for(int g=0; g<usuarios; g++)
01458                 {
01459                         for(int h=0; h<num_pasarelas; h++)
01460                         {
01461                                 for(int i=0; i<Tabla->num_rutas[g][h]; i++)
01462                                 {
01463                                         for(int j=0; j<columnas; j++)
01464                                         {
01465                                                 //ev << " | " << Tabla->array_de_retardos[Tabla->indices_rutas[g][i][h]][j];
01466                                         }
01467                                         //ev << " --> Total: " << Tabla->retardo_total_rutas[Tabla->indices_rutas[g][i][h]] << endl;
01468                                 }
01469                         }
01470                 }
01471                 //ev << endl;
01473                 //ev << " TABLA CON EL PESO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01474                 for(int g=0; g<usuarios; g++)
01475                 {
01476                         for(int h=0; h<num_pasarelas; h++)
01477                         {
01478                                 for(int i=0; i<Tabla->num_rutas[g][h]; i++)
01479                                 {
01480                                         for(int j=0; j<columnas; j++)
01481                                         {
01482                                                 //ev << " | " << Tabla->array_de_pesos[Tabla->indices_rutas[g][i][h]][j];
01483                                         }
01484                                         //ev << " --> Total: " << Tabla->peso_total_rutas[Tabla->indices_rutas[g][i][h]] << endl;
01485                                 }
01486                         }
01487                 }
01488                 //ev << endl;
01489                  */
01491 
01493                 /*
01495                 //ev << endl;
01496                 //ev << " TABLA CON LOS NODOS INTERMEDIOS DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01497                 for(int a=0; a<max_fila; a++)
01498                 {
01499                         for(int b=0; b<columnas; b++)
01500                         {
01501                                 //ev << " | " << Tabla->array_de_rutas[a][b];
01502                         }
01503                         //ev << " Total saltos: " << Tabla->saltos_total_rutas[a] << endl;
01504                 }
01505                 //ev << endl;
01506 
01508                 //ev << " TABLA CON LA LONGITUD DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01509                 for(int a=0; a<max_fila; a++)
01510                 {
01511                         for(int b=0; b<columnas; b++)
01512                         {
01513                                 //ev << " | " << Tabla->array_de_longitudes[a][b];
01514                         }
01515                         //ev << " --> Total: " << Tabla->longitud_total_rutas[a] << endl;
01516                 }
01517                 //ev << endl;
01519                 //ev << " TABLA CON EL RETARDO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01520                 for(int a=0; a<max_fila; a++)
01521                 {
01522                         for(int b=0; b<columnas; b++)
01523                         {
01524                                 //ev << " | " << Tabla->array_de_retardos[a][b];
01525                         }
01526                         //ev << " --> Total: " << Tabla->retardo_total_rutas[a] << endl;
01527                 }
01528                 //ev << endl;
01530                 //ev << " TABLA CON EL PESO DE CADA ENLACE DE TODAS LAS RUTAS POSIBLES DESDE CADA USUARIO A UNA ONU" << endl;
01531                 for(int a=0; a<max_fila; a++)
01532                 {
01533                         for(int b=0; b<columnas; b++)
01534                         {
01535                                 //ev << " | " << Tabla->array_de_pesos[a][b];
01536                         }
01537                         //ev << " --> Total: " << Tabla->peso_total_rutas[a] << endl;
01538                 }
01539                 //ev << endl;
01541                 */
01543         }
01544 
01545         // VACIAMOS LOS ARRAYS CUYA INFORMACION NO VA A HACER MAS FALTA EN LA SIMULACION:
01546         //Tabla->saltos_total_rutas.clear();
01547         Tabla->longitud_total_rutas.clear();
01548         Tabla->retardo_total_rutas.clear();
01549         Tabla->array_de_longitudes.clear();
01550         Tabla->array_de_retardos.clear();
01551         //Tabla->array_de_pesos.clear();
01552         //Tabla->peso_total_rutas.clear();
01553 }

int BS_mac::ya_aparece ( char *  nombre_nodo,
int  fila,
int  indice 
) [protected, virtual]

Definition at line 305 of file BS_mac.cc.

00306 {
00307         int iguales=0, b=indice, aparece=0;
00308         while(b>=0 && aparece==0)
00309         {
00310                 iguales = strcmp(nombre_nodo,Tabla->array_de_rutas[fila][b]);
00311                 if(iguales==0)
00312                 {
00313                         aparece = 1;
00314                 }
00315                 b--;
00316         }
00317         return aparece;
00318 }


Member Data Documentation

Definition at line 66 of file BS_mac.h.

Definition at line 87 of file BS_mac.h.

Definition at line 88 of file BS_mac.h.

double BS_mac::C_i

Definition at line 72 of file BS_mac.h.

Definition at line 77 of file BS_mac.h.

Definition at line 59 of file BS_mac.h.

Definition at line 71 of file BS_mac.h.

Definition at line 63 of file BS_mac.h.

Definition at line 62 of file BS_mac.h.

Definition at line 64 of file BS_mac.h.

Definition at line 58 of file BS_mac.h.

Definition at line 56 of file BS_mac.h.

Definition at line 80 of file BS_mac.h.

Definition at line 82 of file BS_mac.h.

Definition at line 57 of file BS_mac.h.

Definition at line 73 of file BS_mac.h.

Definition at line 65 of file BS_mac.h.

Definition at line 81 of file BS_mac.h.

Definition at line 79 of file BS_mac.h.

Definition at line 61 of file BS_mac.h.

Definition at line 78 of file BS_mac.h.

Definition at line 55 of file BS_mac.h.

Definition at line 54 of file BS_mac.h.

Definition at line 70 of file BS_mac.h.

Definition at line 86 of file BS_mac.h.

Definition at line 74 of file BS_mac.h.

Definition at line 67 of file BS_mac.h.

Definition at line 68 of file BS_mac.h.

Definition at line 76 of file BS_mac.h.

simtime_t BS_mac::time_frame

Definition at line 75 of file BS_mac.h.

simtime_t BS_mac::timepacket

Definition at line 85 of file BS_mac.h.

Definition at line 83 of file BS_mac.h.

Definition at line 84 of file BS_mac.h.

Definition at line 69 of file BS_mac.h.

Definition at line 60 of file BS_mac.h.


The documentation for this class was generated from the following files:

Generated on Thu Nov 28 14:47:21 2013 for red_wireless by  doxygen 1.5.7.1