User_traffic Class Reference

#include <User_traffic.h>

Inheritance diagram for User_traffic:

cSimpleModule cModule cComponent cDefaultList cNoncopyableOwnedObject cOwnedObject noncopyable cNamedObject cObject

List of all members.

Public Member Functions

 User_traffic ()
virtual ~User_traffic ()
virtual int get_index_last_element (int row)
virtual int get_index_last_element_k (int index, int row)

Public Attributes

GeneratorpAG_user
int packetSize_user
double_vector_t load_dmb_user
BS_tableTabla
int cuenta_ruta
int k_paths
int opcion_caminos
BS_queuecola_bs
BS_rx_txrxtx_bs
long tamsumqueue_user
int_vector_t tamsumpop_user
double suma_tam_packets_user
simtime_t time_creation_user
double total_load_user
long suma_total_user
double channel_bit_rate
double txrate
double lambda
double inv_lambda
long packet_64_user
long packet_594_user
long packet_1500_user
long totalpacket_user

Protected Member Functions

virtual void initialize ()
virtual void handleMessage (cMessage *msg)
virtual void separatequeue (cMessage *msg)
virtual void priorityqueue (cMessage *msg)
virtual void volcadoFicheros ()
virtual void finish ()

Protected Attributes

int volcado
int contador

Private Attributes

Analysis carga_user
Analysis longitud_user
FILE * carga_paquetes_user
FILE * paquetes_user


Detailed Description

Definition at line 36 of file User_traffic.h.


Constructor & Destructor Documentation

User_traffic::User_traffic (  ) 

Definition at line 32 of file User_traffic.cc.

00033 {
00034         pAG_user = NULL;
00035 }

User_traffic::~User_traffic (  )  [virtual]

Definition at line 37 of file User_traffic.cc.

00038 {
00039         delete pAG_user;
00040 }


Member Function Documentation

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

Reimplemented from cComponent.

Definition at line 1089 of file User_traffic.cc.

01090 {
01091                 // VISUALIZAMOS POR PANTALLA LA RECOGIDA DE ESTADISTICAS DE LA CARGA CUANDO LLAMAMOS A LA FUNCION FINISH()
01092                 //ev << " Estadisticas tomadas en el Modulo " << this->getFullPath() << endl;
01093                 //ev << " Carga total de la fuente n." << this->getIndex() << " del " << this->getParentModule()->getFullName() << ": " << total_load_user << endl;
01094                 double media_aux = (double) carga_user.average();
01095                 ev << " MEDIA DE LA carga total de la fuente n." << this->getIndex() << " del " << this->getParentModule()->getFullName() << ": " << media_aux  << endl;
01096                 ev << " Media de la longitud de los paquetes generados: " << longitud_user.average() << endl;
01097                 volcadoFicheros();
01098 }

int User_traffic::get_index_last_element ( int  row  )  [virtual]

Definition at line 785 of file User_traffic.cc.

00786 {
00787         // El primer elemento es el usuario, luego podriamos empezar por i=1
00788         int i=1, encontrado = 0, ocupado, vacio, indice=1;
00789         while(encontrado == 0 && i<Tabla->columnas)
00790         {
00791                 ocupado = strcmp(" ", Tabla->rutas_optimas[row][i]);
00792                 vacio = strcmp(" ", Tabla->rutas_optimas[row][i + 1]);
00793                 if(ocupado !=0 && vacio ==0)
00794                 {
00795                         encontrado = 1;
00796                         indice = i;
00797                 }
00798                 i++;
00799         }
00800         return indice;
00801 }

int User_traffic::get_index_last_element_k ( int  index,
int  row 
) [virtual]

Definition at line 807 of file User_traffic.cc.

00808 {
00809         // El primer elemento es el usuario, luego podriamos empezar por i=1
00810         int i=1, encontrado = 0, ocupado, vacio, indice=1;
00811         while(encontrado == 0 && i<Tabla->columnas)
00812         {
00813                 ocupado = strcmp(" ", Tabla->rutas_optimas_pasarelas[index][row][i]);
00814                 vacio = strcmp(" ", Tabla->rutas_optimas_pasarelas[index][row][i + 1]);
00815                 if(ocupado !=0 && vacio ==0)
00816                 {
00817                         encontrado = 1;
00818                         indice = i;
00819                 }
00820                 i++;
00821         }
00822         return indice;
00823 }

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

Reimplemented from cSimpleModule.

Definition at line 234 of file User_traffic.cc.

00235 {
00236         // VARIABLES
00237         int type = msg->getKind();
00238         // double buffer = (double) this->getParentModule()->par("buffer_size"); // Tamanyo del buffer (MB)
00239         //int priority = getIndex(); // Prioridad asignada por el identificador de la fuente que se crea
00240         int metodo = (int) this->par("user_insercionmethod_separatequeue0_priorityqueue1");
00241 
00242         // PARAMETROS IMPORTANTES PARA EL PAQUETE INALAMBRICO:
00243         int indice = (int) this->getParentModule()->getIndex(); // Este es el usuario user[indice]
00244         cModule *bsdestino; // El destinatario de este mensaje es la estacion base a la que se conecta el usuario
00245         bsdestino = this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule();
00246         char* name_dest; // Nombre del tipo de modulo (BS)
00247         char* dest; // Nombre del modulo (bsx)
00248         name_dest = (char*)bsdestino->getModuleType()->getName();
00249         dest = (char*) bsdestino->getFullName();
00250         int dir_dest = (int) bsdestino->par("indice");
00251         //int dir_dest = (int) bsdestino->getIndex(); /////// CAMBIO_RED ///////
00252         // Longitud del canal que coencta a este usuario con la BS correspondiente:
00253         double length = (double) this->getParentModule()->gate("physicalUser$o")->getChannel()->par(2);
00254 
00255         switch (type)
00256         {
00257                 case 0: // Si se ha recibido un automensaje (tipo = 0):
00258                         if (type==0)
00259                         {
00260                                 // Si existe una sola cola para los paquetes de los usuarios:
00261                                 if((int) this->getParentModule()->par("numcolas") == 1)
00262                                 {
00263                                         // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00264                                         /*
00265                                         Generator &AG = *pAG_user;
00266                                         AG.GetNextPacket();
00267                                         Trace trc = AG.PeekNextPacket();
00268                                         bytestamp_t tiempo = AG.GetTime();
00269                                         bytestamp_t ByteStamp = AG.GetByteStamp();
00270                                         bytestamp_t intervalo = ByteStamp - tiempo;
00271                                         simtime_t interarrivaltime = (simtime_t)(intervalo*8/channel_bit_rate);
00272                                         */
00273                                         // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00274 
00275                                         // Creacion del paquete inalambrico tipo DATA, para enviarlo a la BS mas cercana:
00276                                         DATA *datos = new DATA("Datos",12);
00277 
00278                                         // Obtencion de la ruta por la que encaminar los mensajes de este usuario:
00279                                         int tam_ruta, ruta_encontrada;
00280                                         switch(opcion_caminos)
00281                                         {
00282                                         case 0: // Un unico camino optimo, el de la tabla 'rutas_optimas'
00283                                                 tam_ruta = get_index_last_element(indice);
00284                                                 datos->setRutaArraySize(tam_ruta);
00285                                                 for(int y=0; y<tam_ruta; y++)
00286                                                 {
00287                                                         // NOTA: El usuario no se incluye en el campo 'ruta'
00288                                                         datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00289                                                 }
00290                                                 break;
00291                                         case 1: // Hasta k caminos, los de las k tablas 'rutas_optimas_pasarelas' (k=num_pasarelas)
00292                                                 ruta_encontrada = -1;
00293                                                 while(ruta_encontrada<0)
00294                                                 {
00295                                                         if(cuenta_ruta < k_paths)
00296                                                         {
00297                                                                 if(strcmp(Tabla->rutas_optimas_pasarelas[cuenta_ruta][indice][0]," ")!=0)
00298                                                                 {
00299                                                                         ruta_encontrada = cuenta_ruta;
00300                                                                 }
00301                                                                 cuenta_ruta++;
00302                                                         }
00303                                                         else
00304                                                         {
00305                                                                 cuenta_ruta=0;
00306                                                         }
00307                                                 }
00308 
00309                                                 tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00310                                                 datos->setRutaArraySize(tam_ruta);
00311                                                 for(int y=0; y<tam_ruta; y++)
00312                                                 {
00313                                                         // NOTA: El usuario no se incluye en el campo 'ruta'
00314                                                         datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00315                                                 }
00316                                                 break;
00317                                         case 2: // Opcion de fijar el camino mas largo (para pruebas entre bs0 y bs7)
00318                                                 tam_ruta = get_index_last_element(indice);
00319                                                 datos->setRutaArraySize(tam_ruta);
00320                                                 for(int y=0; y<tam_ruta; y++)
00321                                                 {
00322                                                         // NOTA: El usuario no se incluye en el campo 'ruta'
00323                                                         datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00324                                                 }
00325                                                 /*
00326                                                 // O tambien vale tomar la ruta para el user[0] de la tabla con las rutas optimas
00327                                                 // para la pasarela bs7: "rutas_optimas_pasarelas[0][0].size()".
00328                                                 ruta_encontrada = 0; //k_paths - 1;
00329                                                 tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00330                                                 datos->setRutaArraySize(tam_ruta);
00331                                                 for(int y=0; y<tam_ruta; y++)
00332                                                 {
00333                                                         // NOTA: El usuario no se incluye en el campo 'ruta'
00334                                                         datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00335                                                 }
00336                                                 */
00337                                                 break;
00338                                         default:
00339                                                 break;
00340                                         }
00341                                         double path_weight = (double)check_and_cast<BS_mac *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_mac"))->auxiliar_array[this->getParentModule()->getIndex()];
00342                                         datos->setPeso(path_weight);
00343                                         // Indice de la direccion del origen (el usuario) --> NO SE CAMBIA EN CADA SALTO:
00344                                         datos->setSrcAddress(indice);
00345                                         // Indice de la direccion de destino --> SI SE CAMBIA EN CADA SALTO:
00346                                         datos->setDestAddress(dir_dest);
00347                                         // Uso el campo 'Data' del paquete para almacenar la distancia recorrida (en metros):
00348                                         datos->setMetros(length);
00349                                         // Uso el campo 'Saltos' del paquete para almacenar el numero de saltos recorridos:
00350                                         datos->setSaltos(0); // NOTA: NO cuento user->bs como el primer salto
00351                                         // Grabacion del tiempo de creacion del paquete en el campo 'timestamp':
00352                                         time_creation_user = (simtime_t) simTime();
00353                                         datos->setTimestamp(time_creation_user);
00354                                         // Uso el campo 'UserOrigin' del paquete para almacenar el nombre del usuario origen (NO SE CAMBIA):
00355                                         datos->setUserOrigin(this->getParentModule()->getFullName());
00356                                         // Nombre completo del nodo anterior que (re)envia el mensaje (SI SE CAMBIA):
00357                                         datos->setOrigen(this->getParentModule()->getFullName());
00358                                         // Nombre completo del siguiente nodo receptor del mensaje (SI SE CAMBIA):
00359                                         datos->setDestino(dest);
00360                                         // Longitud del paquete (en bytes):
00361                                                 //datos->setByteLength(trc.PacketSize); // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00362                                         datos->setByteLength(poisson(packetSize_user));
00363 
00364                                         longitud_user.analyze((double)datos->getByteLength());
00365                                         // Prioridad e Id. de servicio (coincide con el indice de la fuente):
00366                                         datos->setPriority(getIndex());
00367 
00368                                         // Calculo de la suma total del tamanyo (en Bytes) de los paquetes generados por el usuario:
00369                                         suma_tam_packets_user = suma_tam_packets_user + (double) datos->getByteLength();
00370                                         totalpacket_user++; // SUMA TOTAL DE TODOS LOS PAQUETES CREADOS POR LA ONU
00371 
00372                                         /* Tiempo entre envios exponencial */
00373                                         // PROGRAMACION DE UN AUTOMENSAJE (ENVIO DEL MISMO 'msg'):
00374                                         // exp(1/lambda) -> 1/lambda [s] = segundos/paquetes -> depende de la tasa de transmisión
00375                                         simtime_t interarrivaltime = (simtime_t) exponential(inv_lambda);
00376                                         // El tiempo entre llegadas tiene una distribución exponencial con media E[t]=1/lambda.
00377                                         simtime_t next_time = simTime() + interarrivaltime;
00378                                         scheduleAt(next_time,msg);
00379 
00380                                         // IMPRESION POR PANTALLA DE ALGUNOS PARAMETROS DEL MENSAJE:
00381                                         //ev << " Generacion de un nuevo paquete de datos del usuario inalambrico 'User[" << this->getParentModule()->getIndex() << "]', de longitud " << datos->getByteLength() << " Bytes." << endl;
00385 
00386                                                 //ev << "       Ruta completa a seguir: " << this->getParentModule()->getFullName() << " | ";
00387                                                 //for(int y=0; y<tam_ruta; y++){ ev << datos->getRuta(y) << " | "; }
00388                                                 //ev << endl;
00389 
00390                                                 // Calculo de la carga del nodo del usuario y visualizacion cada vez que se genera un paquete 'DATA' nuevo:
00391                                         double tiempo_creacion_usuario = (double) SIMTIME_DBL(time_creation_user);
00392                                         total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*txrate)); // Formula para calcular la carga del nodo del usuario
00393                                         //total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*channel_bit_rate)); // Formula para calcular la carga del nodo del usuario
00394                                         //ev << "       Carga Total de la fuente n." << this->getIndex() << " del " << this->getParentModule()->getFullName() << ": " << total_load_user << "" << endl;
00395                                         //ev << " Tiempo de generacion del proximo paquete: " << SIMTIME_DBL(next_time) << endl;
00396 
00397                                         if(simTime()>0.5)
00398                                         {
00399                                                 //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00400                                                 carga_user.analyze((double)total_load_user);
00401                                         }
00402 
00403                                         if(datos->getByteLength()==64)
00404                                         {
00405                                                 // PAQUETES CREADOS DE 64 BYTES
00406                                                 packet_64_user++;
00407                                         }
00408                                         else if(datos->getByteLength()==594)
00409                                         {
00410                                                 // PAQUETES CREADOS DE 594 BYTES
00411                                                 packet_594_user++;
00412                                         }
00413                                         else if(datos->getByteLength()==1500)
00414                                         {
00415                                                 // PAQUETES CREADOS DE 1500 BYTES
00416                                                 packet_1500_user++;
00417                                         }
00418 
00419                                         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00420                                         switch(metodo)
00421                                         {
00422                                                 case 0:
00423                                                         // Llamada a la funcion0000015 del metodo de insercion paquetes de colas separadas:
00424                                                         separatequeue(datos);
00425                                                         break;
00426 
00427                                                 case 1:
00428                                                         // Llamada a la funcion del metodo de insercion de paquetes de prioridad de colas:
00429                                                         priorityqueue(datos);
00430                                                         break;
00431 
00432                                                 default:
00433                                                         ev<<" ERROR AL ELEGIR EL METODO DE INSERCION EN LAS COLAS, ELEGIR 0 o 1."<<endl;
00434                                                         delete datos;
00435                                                         //ev << " MENSAJE BORRADO" << endl;
00436                                                         break;
00437                                         }
00438                                 }
00439                                 else if((int) this->getParentModule()->par("numcolas") >= 2)
00440                                 {
00441                                         if(getIndex() == 0)
00442                                         {
00443                                                 // FUENTE CONSTANTE DE PAQUETES DE 70 BYTES QUE SE MANDAN CADA 125us
00444                                                 // Creacion del paquete tipo DATA, para enviarlo a la BS mas cercana:
00445                                                 //ETHERNETmsg *datos = new ETHERNETmsg("Datos",12);
00446                                                 DATA *datos = new DATA("Datos",12);
00447 
00448                                                 // Obtencion de la ruta por la que encaminar los mensajes de este usuario:
00449                                                 int tam_ruta, ruta_encontrada;
00450                                                 switch(opcion_caminos)
00451                                                 {
00452                                                 case 0: // Un unico camino optimo, el de la tabla 'rutas_optimas'
00453                                                         tam_ruta = get_index_last_element(indice);
00454                                                         datos->setRutaArraySize(tam_ruta);
00455                                                         for(int y=0; y<tam_ruta; y++)
00456                                                         {
00457                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00458                                                                 datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00459                                                         }
00460                                                         break;
00461                                                 case 1: // Hasta k caminos, los de las k tablas 'rutas_optimas_pasarelas' (k=num_pasarelas)
00462                                                         ruta_encontrada = -1;
00463                                                         while(ruta_encontrada<0)
00464                                                         {
00465                                                                 if(cuenta_ruta < k_paths)
00466                                                                 {
00467                                                                         if(strcmp(Tabla->rutas_optimas_pasarelas[cuenta_ruta][indice][0]," ")!=0)
00468                                                                         {
00469                                                                                 ruta_encontrada = cuenta_ruta;
00470                                                                         }
00471                                                                         cuenta_ruta++;
00472                                                                 }
00473                                                                 else
00474                                                                 {
00475                                                                         cuenta_ruta=0;
00476                                                                 }
00477                                                         }
00478                                                         tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00479                                                         datos->setRutaArraySize(tam_ruta);
00480                                                         for(int y=0; y<tam_ruta; y++)
00481                                                         {
00482                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00483                                                                 datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00484                                                         }
00485                                                         break;
00486                                                 case 2: // Opcion de fijar el camino mas largo (para pruebas entre bs0 y bs7)
00487                                                         tam_ruta = get_index_last_element(indice);
00488                                                         datos->setRutaArraySize(tam_ruta);
00489                                                         for(int y=0; y<tam_ruta; y++)
00490                                                         {
00491                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00492                                                                 datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00493                                                         }
00494                                                         /*
00495                                                         // O tambien vale tomar la ruta para el user[0] de la tabla con las rutas optimas
00496                                                         // para la pasarela bs7: "rutas_optimas_pasarelas[0][0].size()".
00497                                                         ruta_encontrada = 0; //k_paths - 1;
00498                                                         tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00499                                                         datos->setRutaArraySize(tam_ruta);
00500                                                         for(int y=0; y<tam_ruta; y++)
00501                                                         {
00502                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00503                                                                 datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00504                                                         }
00505                                                         */
00506                                                         break;
00507                                                 default:
00508                                                         break;
00509                                                 }
00510                                                 double path_weight = (double)check_and_cast<BS_mac *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_mac"))->auxiliar_array[this->getParentModule()->getIndex()];
00511                                                 datos->setPeso(path_weight);
00512                                                 // Indice de la direccion del origen (el usuario) --> NO SE CAMBIA EN CADA SALTO:
00513                                                 datos->setSrcAddress(indice);
00514                                                 // Indice de la direccion de destino --> SI SE CAMBIA EN CADA SALTO:
00515                                                 datos->setDestAddress(dir_dest);
00516                                                 // Uso el campo 'Metros' del paquete para almacenar la distancia recorrida (en metros):
00517                                                 datos->setMetros(length);
00518                                                 // Uso el campo 'Saltos' del paquete para almacenar el numero de saltos recorridos:
00519                                                 datos->setSaltos(0); // NOTA: NO cuento user->bs como el primer salto
00520                                                 // Grabacion del tiempo de creacion del paquete en el campo 'timestamp':
00521                                                 time_creation_user = (simtime_t) simTime();
00522                                                 datos->setTimestamp(time_creation_user);
00523                                                 // Uso el campo 'UserOrigin' del paquete para almacenar el nombre del usuario origen (NO SE CAMBIA):
00524                                                 datos->setUserOrigin(this->getParentModule()->getFullName());
00525                                                 // Nombre completo del nodo anterior que (re)envia el mensaje (SI SE CAMBIA):
00526                                                 datos->setOrigen(this->getParentModule()->getFullName());
00527                                                 // Nombre completo del siguiente nodo receptor del mensaje (SI SE CAMBIA):
00528                                                 datos->setDestino(dest);
00529                                                 // Longitud del mensaje:
00530                                                         //datos->setByteLength(70); // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00531                                                 datos->setByteLength(poisson(packetSize_user));
00532                                                 longitud_user.analyze((double)datos->getByteLength());
00533                                                 // Prioridad e Id. de servicio (coincide con el indice de la fuente):
00534                                                 datos->setPriority(getIndex());
00535 
00536                                                 // Calculo de la suma total del tamanyo (en Bytes) de los paquetes generados por el usuario:
00537                                                 suma_tam_packets_user = suma_tam_packets_user + (double) datos->getByteLength();
00538                                                 totalpacket_user++; // SUMA TOTAL DE TODOS LOS PAQUETES CREADOS POR LA ONU
00539 
00540                                                 /* Tiempo entre envios exponencial */
00541                                                 // PROGRAMACION DE UN AUTOMENSAJE (ENVIO DEL MISMO 'msg'):
00542                                                 // lambda*exp(1/lambda) -> 1/lambda [s] = segundos/paquetes -> depende de la tasa de transmisión
00543                                                 simtime_t interarrivaltime = (simtime_t) exponential(inv_lambda);
00544                                                 // El tiempo entre llegadas tiene una distribución exponencial con media E[t]=1/lambda.
00545                                                 simtime_t next_time = simTime() + interarrivaltime;
00546                                                 scheduleAt(next_time,msg);
00547 
00548                                                 // IMPRESION POR PANTALLA DE ALGUNOS PARAMETROS DEL MENSAJE:
00549                                                 //ev << " Generacion de un nuevo paquete de datos del usuario inalambrico 'User[" << this->getParentModule()->getIndex() << "]', de longitud " << datos->getByteLength() << " Bytes." << endl;
00553 
00554                                                         //ev << "       Ruta completa a seguir: " << this->getParentModule()->getFullName() << " | ";
00555                                                         //for(int y=0; y<tam_ruta; y++){ ev << datos->getRuta(y) << " | "; }
00556                                                         //ev << endl;
00557 
00558                                                 // Calculo de la carga del nodo del usuario y visualizacion cada vez que se genera un paquete 'DATA' nuevo:
00559                                                 double tiempo_creacion_usuario = (double) SIMTIME_DBL(time_creation_user);
00560                                                 total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*txrate)); // Formula para calcular la carga del nodo del usuario
00561                                                 //total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*channel_bit_rate)); // Formula para calcular la carga del nodo del usuario
00562                                                 //ev << "       Carga Total de la fuente n." << this->getIndex() << " del " << this->getParentModule()->getFullName() << ": " << total_load_user << "" << endl;
00563                                                 //ev << " Tiempo de generacion del proximo paquete: " << SIMTIME_DBL(next_time) << endl;
00564 
00565                                                 if(simTime()>0.5)
00566                                                 {
00567                                                         //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00568                                                         carga_user.analyze((double)total_load_user);
00569                                                 }
00570                                                 // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00571                                                 switch(metodo)
00572                                                 {
00573                                                         case 0:
00574                                                                 // Llamada a la funcion del metodo de insercion paquetes de colas separadas:
00575                                                                 separatequeue(datos);
00576                                                                 break;
00577 
00578                                                         case 1:
00579                                                                 // Llamada a la funcion del metodo de insercion de paquetes de prioridad de colas:
00580                                                                 priorityqueue(datos);
00581                                                                 break;
00582 
00583                                                         default:
00584                                                                 ev<<" ERROR AL ELEGIR EL METODO DE INSERCION EN LAS COLAS, ELEGIR 0 o 1."<<endl;
00585                                                                 delete datos;
00586                                                                 //ev << " MENSAJE BORRADO" << endl;
00587                                                                 break;
00588                                                 }
00589                                         }
00590                                         else if(getIndex() >= 1)
00591                                         {
00592                                                 // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00593                                                 /*
00594                                                 Generator &AG = *pAG_user;
00595                                                 AG.GetNextPacket();
00596                                                 Trace trc = AG.PeekNextPacket();
00597                                                 bytestamp_t tiempo = AG.GetTime();
00598                                                 bytestamp_t ByteStamp = AG.GetByteStamp();
00599                                                 bytestamp_t intervalo = ByteStamp - tiempo;
00600                                                 simtime_t interarrivaltime = (simtime_t)(intervalo*8/channel_bit_rate);
00601                                                 */
00602                                                 // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00603 
00604                                                 // Creacion del paquete tipo DATA, para enviarlo a la BS mas cercana:
00605                                                 //ETHERNETmsg *datos = new ETHERNETmsg("Datos",12);
00606                                                 DATA *datos = new DATA("Datos",12);
00607 
00608                                                 // Obtencion de la ruta por la que encaminar los mensajes de este usuario:
00609                                                 int tam_ruta, ruta_encontrada;
00610                                                 switch(opcion_caminos)
00611                                                 {
00612                                                 case 0: // Un unico camino optimo, el de la tabla 'rutas_optimas'
00613                                                         tam_ruta = get_index_last_element(indice);
00614                                                         datos->setRutaArraySize(tam_ruta);
00615                                                         for(int y=0; y<tam_ruta; y++)
00616                                                         {
00617                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00618                                                                 datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00619                                                         }
00620                                                         break;
00621                                                 case 1: // Hasta k caminos, los de las k tablas 'rutas_optimas_pasarelas' (k=num_pasarelas)
00622                                                         ruta_encontrada = -1;
00623                                                         while(ruta_encontrada<0)
00624                                                         {
00625                                                                 if(cuenta_ruta < k_paths)
00626                                                                 {
00627                                                                         if(strcmp(Tabla->rutas_optimas_pasarelas[cuenta_ruta][indice][0]," ")!=0)
00628                                                                         {
00629                                                                                 ruta_encontrada = cuenta_ruta;
00630                                                                         }
00631                                                                         cuenta_ruta++;
00632                                                                 }
00633                                                                 else
00634                                                                 {
00635                                                                         cuenta_ruta=0;
00636                                                                 }
00637                                                         }
00638                                                         tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00639                                                         datos->setRutaArraySize(tam_ruta);
00640                                                         for(int y=0; y<tam_ruta; y++)
00641                                                         {
00642                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00643                                                                 datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00644                                                         }
00645                                                         break;
00646                                                 case 2: // Opcion de fijar el camino mas largo (para pruebas entre bs0 y bs7)
00647                                                         tam_ruta = get_index_last_element(indice);
00648                                                         datos->setRutaArraySize(tam_ruta);
00649                                                         for(int y=0; y<tam_ruta; y++)
00650                                                         {
00651                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00652                                                                 datos->setRuta(y,Tabla->rutas_optimas[indice][y+1]);
00653                                                         }
00654                                                         /*
00655                                                         // O tambien vale tomar la ruta para el user[0] de la tabla con las rutas optimas
00656                                                         // para la pasarela bs7: "rutas_optimas_pasarelas[0][0].size()".
00657                                                         ruta_encontrada = 0; //k_paths - 1;
00658                                                         tam_ruta = get_index_last_element_k(ruta_encontrada, indice);
00659                                                         datos->setRutaArraySize(tam_ruta);
00660                                                         for(int y=0; y<tam_ruta; y++)
00661                                                         {
00662                                                                 // NOTA: El usuario no se incluye en el campo 'ruta'
00663                                                                 datos->setRuta(y,Tabla->rutas_optimas_pasarelas[ruta_encontrada][indice][y+1]);
00664                                                         }
00665                                                         */
00666                                                         break;
00667                                                 default:
00668                                                         break;
00669                                                 }
00670                                                 double path_weight = (double)check_and_cast<BS_mac *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_mac"))->auxiliar_array[this->getParentModule()->getIndex()];
00671                                                 datos->setPeso(path_weight);
00672 
00673                                                 // Indice de la direccion del origen (el usuario) --> NO SE CAMBIA EN CADA SALTO:
00674                                                 datos->setSrcAddress(indice);
00675                                                 // Indice de la direccion de destino --> SI SE CAMBIA EN CADA SALTO:
00676                                                 datos->setDestAddress(dir_dest);
00677                                                 // Uso el campo 'Metros' del paquete para almacenar la distancia recorrida (en metros):
00678                                                 datos->setMetros(length);
00679                                                 // Uso el campo 'Saltos' del paquete para almacenar el numero de saltos recorridos:
00680                                                 datos->setSaltos(0); // NOTA: NO cuento user->bs como el primer salto
00681                                                 // Grabacion del tiempo de creacion del paquete en el campo 'timestamp':
00682                                                 time_creation_user = (simtime_t) simTime();
00683                                                 datos->setTimestamp(time_creation_user);
00684                                                 // Uso el campo 'UserOrigin' del paquete para almacenar el nombre del usuario origen (NO SE CAMBIA):
00685                                                 datos->setUserOrigin(this->getParentModule()->getFullName());
00686                                                 // Nombre completo del nodo anterior que (re)envia el mensaje (SI SE CAMBIA):
00687                                                 datos->setOrigen(this->getParentModule()->getFullName());
00688                                                 // Nombre completo del siguiente nodo receptor del mensaje (SI SE CAMBIA):
00689                                                 datos->setDestino(dest);
00690                                                 // Longitud del paquete (en bytes):
00691                                                         //datos->setByteLength(trc.PacketSize); // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00692                                                 datos->setByteLength(poisson(packetSize_user));
00693                                                 longitud_user.analyze((double)datos->getByteLength());
00694                                                 // Prioridad e Id. de servicio (coincide con el indice de la fuente):
00695                                                 datos->setPriority(getIndex());
00696 
00697                                                 // Calculo de la suma total del tamanyo (en Bytes) de los paquetes generados por el usuario:
00698                                                 suma_tam_packets_user = suma_tam_packets_user + (double) datos->getByteLength();
00699                                                 totalpacket_user++; // SUMA TOTAL DE TODOS LOS PAQUETES CREADOS POR LA ONU
00700 
00701                                                 /* Tiempo entre envios exponencial */
00702                                                 // PROGRAMACION DE UN AUTOMENSAJE (ENVIO DEL MISMO 'msg'):
00703                                                 // exp(1/lambda) -> 1/lambda [s] = segundos/paquetes -> depende de la tasa de transmisión
00704                                                 simtime_t interarrivaltime = (simtime_t) exponential(inv_lambda);
00705                                                 // El tiempo entre llegadas tiene una distribución exponencial con media E[t]=1/lambda.
00706                                                 simtime_t next_time = simTime() + interarrivaltime;
00707                                                 scheduleAt(next_time,msg);
00708 
00709                                                 //ev << " Generacion de un nuevo paquete de datos del usuario inalambrico 'User[" << this->getParentModule()->getIndex() << "]', de longitud " << datos->getByteLength() << " Bytes." << endl;
00713 
00714                                                         //ev << "       Ruta completa a seguir: " << this->getParentModule()->getFullName() << " | ";
00715                                                         //for(int y=0; y<tam_ruta; y++){ ev << datos->getRuta(y) << " | "; }
00716                                                         //ev << endl;
00717 
00718                                                 // Calculo de la suma total del tamanyo (en Bytes) de los paquetes generados por el usuario:
00719                                                         //suma_tam_packets_user = suma_tam_packets_user + (double) trc.PacketSize;
00720 
00721                                                 // Calculo de la carga del nodo del usuario y visualizacion cada vez que se genera un paquete 'DATA' nuevo:
00722 
00723                                                 double tiempo_creacion_usuario = (double) SIMTIME_DBL(time_creation_user);
00724                                                 total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*txrate)); // Formula para calcular la carga del nodo del usuario
00725                                                 //total_load_user = (double) (suma_tam_packets_user * 8/(tiempo_creacion_usuario*channel_bit_rate)); // Formula para calcular la carga del nodo del usuario
00726                                                 //ev << "       Carga Total de la fuente n." << this->getIndex() << " del " << this->getParentModule()->getFullName() << ": " << total_load_user << "" << endl;
00727                                                 //ev << " Tiempo de generacion del proximo paquete: " << SIMTIME_DBL(next_time) << endl;
00728 
00729                                                 if(simTime()>0.5)
00730                                                 {
00731                                                         //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00732                                                         carga_user.analyze((double)total_load_user);
00733                                                 }
00734                                                 if(datos->getByteLength()==64)
00735                                                 {
00736                                                         // PAQUETES CREADOS DE 64 BYTES
00737                                                         packet_64_user++;
00738                                                 }
00739                                                 else if(datos->getByteLength()==594)
00740                                                 {
00741                                                         // PAQUETES CREADOS DE 594 BYTES
00742                                                         packet_594_user++;
00743                                                 }
00744                                                 else if(datos->getByteLength()==1500)
00745                                                 {
00746                                                         // PAQUETES CREADOS DE 1500 BYTES
00747                                                         packet_1500_user++;
00748                                                 }
00749 
00750                                                 // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00751                                                 switch(metodo)
00752                                                 {
00753                                                         case 0:
00754                                                                 // Llamada a la funcion del metodo de insercion paquetes de colas separadas:
00755                                                                 separatequeue(datos);
00756                                                                 break;
00757 
00758                                                         case 1:
00759                                                                 // Llamada a la funcion del metodo de insercion de paquetes de prioridad de colas:
00760                                                                 priorityqueue(datos);
00761                                                                 break;
00762 
00763                                                         default:
00764                                                                 ev<<" ERROR AL ELEGIR EL METODO DE INSERCION EN LAS COLAS, ELEGIR 0 o 1."<<endl;
00765                                                                 delete datos;
00766                                                                 //ev << " MENSAJE BORRADO" << endl;
00767                                                                 break;
00768                                                 }
00769                                         }
00770                                 }
00771                         }
00772                         break;
00773 
00774                 default: // En cualquier otro caso:
00775                                 delete msg;
00776                                 //ev << " MENSAJE BORRADO" << endl;
00777                                 break;
00778         }
00779 }

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

Reimplemented from cComponent.

Definition at line 49 of file User_traffic.cc.

00050 {
00052         Tabla = check_and_cast<BS_table *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_table")); // ENTRAMOS Y CHEQUEAMOS EL MODULO BS_TABLE
00053 
00054         // INICIALIZACION PARAMETROS:
00056         packetSize_user = (int) this->getParentModule()->par("longitud_media_paquete");  // TAMANYO DEL PAQUETE (BYTES) FIJO PARA LA FUENTE EXPONENCIAL Y LA SELF-SIMILAR
00057         txrate = (double) this->getParentModule()->par("tasabinaria"); // Tasa de Tx (en bps)
00058         double carga = (double) this->getParentModule()->getParentModule()->par("carga_nodo");
00059         //ev << " Longitud media de los paquetes inalambricos: "<< packetSize_user << "B" << endl;
00060         tamsumpop_user.resize((int)par("numcolas"),0); // Suma de los Bytes de los paquetes extraidos de las colas
00061         suma_tam_packets_user = 0; // Suma total del tamanyo (en Bytes) de los paquetes generados por el usuario
00062         total_load_user = 0.0; // Carga total del nodo del usuario
00063         time_creation_user = (simtime_t) 0; // Tiempo de creacion
00064         // Suma total de los Bytes de los paquetes insertados en las colas
00065         suma_total_user = 0;
00066         tamsumqueue_user = 0;
00067 
00068         packet_64_user = 0;
00069         packet_594_user = 0;
00070         packet_1500_user = 0;
00071         totalpacket_user = 0;
00072         //ev << " Carga de la fuente n." << getIndex() << " del usuario[" << this->getParentModule()->getIndex() << "]: " << carga << endl;
00073         channel_bit_rate = carga*txrate;
00074         lambda = channel_bit_rate/(packetSize_user*8);
00075         //lambda = channel_bit_rate/(suma_tam_packets_user*8);
00076         //lambda = inf;
00077         //ev << " Valor inicial de lambda: " << lambda << endl;
00078         inv_lambda = (packetSize_user*8)/channel_bit_rate;
00079         //inv_lambda = (suma_tam_packets_user*8)/channel_bit_rate;
00080         //inv_lambda = 0;
00081         //ev << " Valor inicial de la media exponencial: " << inv_lambda << endl;
00082         //lambda = txrate/(packetSize_user*8);
00083         //inv_lambda = (packetSize_user*8)/txrate;
00084         volcado = 0; // Variable auxiliar para entrar en la funcion VolcadoFicheros() una vez
00085         contador = 0; // Variable auxiliar para entrar en la funcion VolcadoFicheros() periodicamente
00086         cuenta_ruta = 0;
00087         k_paths = (int) this->getParentModule()->par("numGW");
00088         opcion_caminos = (int) this->getParentModule()->par("caminos");
00089  // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00090         /*
00091         load_dmb_user.resize((int)this->getParentModule()->par("numcolas"),0);
00092 
00093         double carga = (double) this->getParentModule()->getParentModule()->par("carga_nodo"); // Carga de las Fuentes de Pareto.
00094 
00095 
00096         if((int)this->getParentModule()->par("numcolas")==1)
00097         {
00098                 // El usuario tiene un solo servicio:
00099                 load_dmb_user[getIndex()] = carga;
00100                 //ev << " CARGA DE LAS FUENTES DEL USUARIO: " << load_dmb_user[getIndex()] << endl;
00101         }
00102         else if((int)this->getParentModule()->par("numcolas")>=2)
00103         {
00104                 // El usuario tiene mas de un servicio:
00105                 if(getIndex()==0)
00106                 {
00107                         // SERVICIO P0
00108                         //ev << " CARGA DE LAS FUENTES DEL USUARIO: 0.0448" << endl;
00109                 }
00110                 else if(getIndex()>=1)
00111                 {
00112                         load_dmb_user[getIndex()] = carga; // VARIABLE CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA
00113                         ev<<" CARGA DE LAS FUENTES DEL USUARIO: "<<load_dmb_user[getIndex()]<<endl;
00114                 }
00115         }
00116 
00117         int flujos = (int)this->getParentModule()->par("user_numstreamV2_32_128_256"); // NUMERO DE FUENTES O SUB-STREAMS
00118         int metodo_generador = (int)this->getParentModule()->par("user_longpacketfixed0_trimodal1"); // PARAMETRO PARA DEFINIR LA LONGITUD O TAMANYO DE LOS PAQUETES DE LA RED ( LONGITUD O TAMANYO DE LOS PAQUETES DE LA RED FIJA O LONGITUD O TAMANYO DE LOS PAQUETES DE LA RED TRIMODAL )
00119 
00120         pAG_user = new Generator; // PUNTERO PARA EL GENERADOR
00121         // COMPARAMOS CON EL SWITCH EL METODO CON EL QUE TRABAJA EL GENERADOR ( MONOMODAL O TRIMODAL )
00122         switch(metodo_generador)
00123         {
00124                 case 0:
00125                         // MONOMODAL-> 1 SERVICIO
00126                         //ev << " " << flujos << " flujos self-similar" << endl;
00127                         // pAG_user = new Generator; // PUNTERO PARA EL GENERADOR
00128                         for(int src=0; src<flujos; src++)
00129                         {
00130                                 pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00131                         }
00132                         break;
00133 
00134                 case 1:
00135                         // TRIMODAL-> 3 SERVICIOS
00136                         switch(flujos)
00137                         {
00138                                 case 32:
00139                                 //      //ev << " Numero de flujos self-similar: 32" << endl;
00140                                         //pAG_user = new Generator; // PUNTERO PARA EL GENERADOR
00141                                         // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00142                                         for(int src=0; src<flujos; src++)
00143                                         {
00144                                                 if(src<3)
00145                                                 {
00146                                                         packetSize_user = 64;
00147                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00148                                                 }
00149                                                 else if(src>=3 && src<8)
00150                                                 {
00151                                                         packetSize_user = 594;
00152                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00153                                                 }
00154                                                 else if(src>=8)
00155                                                 {
00156                                                         packetSize_user = 1500;
00157                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00158                                                 }
00159                                         }
00160                                         break;
00161 
00162                                 case 128:
00163                                 //      //ev << " Numero de flujos self-similar: 128" << endl;
00164                                         // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00165                                         for(int src=0; src<flujos; src++)
00166                                         {
00167                                                 if(src<12)
00168                                                 {
00169                                                         packetSize_user = 64;
00170                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00171                                                 }
00172                                                 else if(src>=12 && src<32)
00173                                                 {
00174                                                         packetSize_user = 594;
00175                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00176                                                 }
00177                                                 else if(src>=32)
00178                                                 {
00179                                                         packetSize_user = 1500;
00180                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00181                                                 }
00182                                         }
00183                                         break;
00184 
00185                                 case 256:
00186                                 //      //ev << " Numero de flujos self-similar: 256" << endl;
00187                                         //pAG_user = new Generator; // PUNTERO PARA EL GENERADOR
00188                                         // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00189                                         for(int src=0; src<flujos; src++)
00190                                         {
00191                                                 if(src<24)
00192                                                 {
00193                                                         packetSize_user = 64;
00194                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00195                                                 }
00196                                                 else if(src>=24 && src<64)
00197                                                 {
00198                                                         packetSize_user = 594;
00199                                                         pAG_user->AddSource(new SourcePareto( src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00200                                                 }
00201                                                 else if(src>=64)
00202                                                 {
00203                                                         packetSize_user = 1500;
00204                                                         pAG_user->AddSource(new SourcePareto(src, 0, packetSize_user, 0, carga/flujos, 1.4, 1.2));
00205                                                 }
00206                                         }
00207                                         break;
00208                         }
00209         }
00210         */
00211         // DESCOMENTAR ESTE CODIGO SI SE QUIERE GENERAR TRAFICO SELF-SIMILAR EN LA PARTE INALAMBRICA //
00212 
00213         int gateway = check_and_cast<BS_rx_tx *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_rx_tx"))->esPasarela;
00215         if(opcion_caminos!=2 && gateway==0)
00216         {
00217                 cMessage *msg = new cMessage("Auto",0);
00218                 scheduleAt((simtime_t)0,msg);
00219         }
00220         else if(opcion_caminos==2 && this->getParentModule()->getIndex()==0)
00221         {
00222                 cMessage *msg = new cMessage("Auto",0);
00223                 scheduleAt((simtime_t)0,msg);
00224         }
00225 }

void User_traffic::priorityqueue ( cMessage msg  )  [protected, virtual]

Definition at line 896 of file User_traffic.cc.

00897 {
00899         double buffer = (double) par("buffer_size"); // Longitud total del buffer (Bytes)
00900         double bloqueo;
00901 
00902         //ETHERNETmsg *msjdatos = check_and_cast<ETHERNETmsg*>(msg);
00903         DATA *msjdatos = check_and_cast<DATA*>(msg);
00904 
00905         // Acceso a los submodulos 'bs_rx_tx' y 'bs_queue[<loquetoque>]':
00906         rxtx_bs = check_and_cast<BS_rx_tx *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_rx_tx"));
00907         // Numero de submodulos 'bs_queue'
00908         int long_puerta = (int) rxtx_bs->gateSize("queueRxTx");
00909         // Obtencion del nodo siguiente a la BS que recibe los paquetes de este usuario (segundo elemento del array 'Ruta'):
00910         char* nodo_siguiente = (char*) msjdatos->getRuta(1);
00911         // Obtencion del indice del modulo 'bs_queue' que nos interesa (aquel que almacena los paquetes dirigidos
00912         // al 'nodo_siguiente'):
00913         int j=0, found = -1;
00914         while(j<long_puerta && found<0)
00915         {
00916                 cola_bs = check_and_cast<BS_queue *>(rxtx_bs->gate("queueRxTx$o",j)->getNextGate()->getOwnerModule());
00917                 if(strcmp(nodo_siguiente,cola_bs->getTarget())==0)
00918                 {
00919                         found = j;
00920                 }
00921                 j++;
00922         }
00923 
00924         //ev << "       Intento de insercion de este paquete en la cola de prioridad P" << this->getIndex()
00925                         //<< " del modulo " << (char*) msjdatos->getRuta(0) << "." << cola_bs->getFullName()
00926                         //<< " con destino " << cola_bs->getTarget() << ":" << endl;
00927 
00928         // Suma de todas las subcolas del modulo BS_QUEUE correspondiente:
00929         for(int i=0; i<(int)par("numcolas"); i++)
00930         {
00931                 // Los bytes en todas las cQueue (tantas como prioridades) se almacenan en 'suma_total_user':
00932                 suma_total_user = suma_total_user + cola_bs->tamqueue[i];
00933 
00934         }
00935         // La variable 'tamsumqueue_user' almacena la suma total de los bytes de todos los paquetes de la bs_queue
00936         // y la longitud del paquete a enviar:
00937         tamsumqueue_user = suma_total_user + msjdatos->getByteLength();
00938         /*
00939         //ev << "       Suma de los Bytes de los paquetes insertados en todas las colas del submodulo "
00940                         << cola_bs->getFullName() << " (mas el nuevo paquete): " << tamsumqueue_user << " Bytes" << endl;
00941         */
00942         // Comprobacion de si hay espacio suficiente en el buffer total (todas las colas):
00943         // Si los bytes de todas las colas no superan la longitud del buffer total:
00944         if(buffer >= tamsumqueue_user)
00945         {
00947                 bloqueo=0.0; //ENVIO PAQUETE
00948                 // Envio del paquete "msjdatos" a la interfaz del usuario:
00949                 send(msjdatos, "traffic");
00950                 //ev << " MENSAJE ENVIADO." << endl;
00951         }
00952         // Si la suma de los bytes de todas las colas supera la longitud del buffer total:
00953         else if(buffer < tamsumqueue_user)
00954         {
00956                 // Recorremos todas las colas, de menor a mayor prioridad, para borrar alguno de sus paquetes previos
00957                 // y dejar sitio asi al nuevo paquete:
00958                 int i = (int)par("numcolas")-1, fuera = -1; 
00959                 while(i>=0 && fuera < 0) 
00960                 //for(int i=(int)par("numcolas")-1; i>=0; i--) /////
00961                 {
00962                         // Si el nuevo paquete es de la misma prioridad que la de la cola que se esta checkeando
00963                         // (en principio, la mas baja), se borra directamente:
00964                         if(msjdatos->getPriority() == i)
00965                         {
00966                                 //ev << " MENSAJE 'DATA' (Id." << msjdatos->getId() << ") BORRADO" << endl;
00969                                 // Resta de los bytes del paquete borrado a la suma total de todas las colas:
00970                                 tamsumqueue_user = tamsumqueue_user - msjdatos->getByteLength();
00972                                         //              << cola_bs->getFullName() << ": " << tamsumqueue_user << " Bytes" << endl;
00973 
00974                                 bloqueo = 1.0; //BORRADO PAQUETE
00975                                 delete msjdatos; // BORRADO DEL PAQUETE 'msjdatos'
00976                                 // INCREMENTO DE LA VARIABLE PARA CONTROLAR EL BORRADO DE PAQUETES EN LA PARTE INALAMBRICA:
00977                                 check_and_cast<BS_table *>(rxtx_bs->getParentModule()->getSubmodule("bs_table"))->paquetes_borrados++;
00978 
00980                                 // Salida del bucle que recorre las colas
00981                                 fuera = 1; 
00982                         }
00983                         // Si el nuevo paquete es de mayor prioridad que la de la cola que se esta checkeando
00984                         // Y esta cola NO esta vacia, se borran paquetes suyos hasta poder meter el nuevo:
00985                         else if(msjdatos->getPriority() < i && cola_bs->queue[i].getLength()>0)
00986                         {
00987                                 int salir = -1; 
00988                                 // Recorremos todos los paquetes de esta cola, desde el mas antiguo:
00989                                 while (cola_bs->queue[i].getLength()>0 && salir < 0) 
00990                                 //for(int j=0; j<=cola_bs->queue[i].getLength(); j++) /////
00991                                 {
00992                                         // Llamada a la funcion del modulo 'bs_queue' para borrar el primer paquete de la cola:
00993                                         cola_bs->deleteElement(msjdatos,i);
00994                                         // INCREMENTO DE LA VARIABLE PARA CONTROLAR EL BORRADO DE PAQUETES EN LA PARTE INALAMBRICA:
00995                                         check_and_cast<BS_table *>(rxtx_bs->getParentModule()->getSubmodule("bs_table"))->paquetes_borrados++;
00996                                         // VISUALIZAMOS POR PANTALLA LA LONGITUD DEL PAQUETE QUE VAMOS A ELIMINAR
01000                                         // Resta de los bytes del paquete extraido a la variable 'tamsumqueue_user':
01001                                         tamsumqueue_user = tamsumqueue_user - cola_bs->user_tamqueuepop[i];
01003                                         // Suma de los bytes de los paquetes que salen de las colas,
01004                                         // para restarlo a la longitud de cada una:
01005                                         tamsumpop_user[i] = tamsumpop_user[i] + cola_bs->user_tamqueuepop[i];
01006 
01007                                         // COMPROBACION DE SI LA LONGITUD TOTAL DEL BUFFER SUPERA EL NUMERO DE BYTES QUE LLEGAN
01008                                         // A LAS COLAS TRAS HABER BORRADO UN PAQUETE:
01009                                         // Si hay espacio suficiente en cola para insertar el nuevo paquete...
01010                                         if(buffer >= tamsumqueue_user)
01011                                         {
01013                                                 //              << " bytes) --> ENVIO PAQUETE A LA COLA P" << msjdatos->getPriority() << endl;
01014                                                 bloqueo=0.0; //ENVIO PAQUETE
01015                                                 // Envio del paquete "msjdatos" a la interfaz del usuario:
01016                                                 send(msjdatos, "traffic");
01017                                                 //ev << " MENSAJE ENVIADO" << endl;
01018                                                 // Salida del bucle que recorre los paquetes de esta cola
01019                                                 salir = 1; 
01020                                                 fuera = 1; 
01021                                                 //break; /////
01022                                         }
01023                                         // Si NO hay espacio suficiente en cola para insertar el nuevo paquete...
01024                                         else if(buffer < tamsumqueue_user)
01025                                         {
01027                                                 //              << " bytes) --> LIBERACION DE MAS ESPACIO EN LAS COLAS" << endl;
01028                                         }
01029                                         // Pasamos a la siguiente iteracion
01030                                 }
01031                                 if(buffer > tamsumqueue_user)
01032                                 {
01033                                         // Salida del bucle que recorre todas las colas
01034                                         //break; /////
01035                                         fuera = 1; 
01036                                 }
01037                         }
01038                         else if(msjdatos->getPriority() < i && cola_bs->queue[i].getLength()==0)
01039                         {
01041                         }
01042                         i--; 
01043                 }
01044         }
01045         // DAMOS EL VALOR CERO A LAS DOS VARIABLES PARA PODER HACER LO CALCULOS NECESARIOS EN SIGUIENTES SITUACIONES CORRECTAMENTE
01046         suma_total_user = 0;
01047         tamsumqueue_user = 0;
01048         /*
01049         if(simTime()>=10*contador && volcado == 0)
01050         {
01051                 volcadoFicheros();
01052                 contador++;
01053         }
01054         */
01055 }

void User_traffic::separatequeue ( cMessage msg  )  [protected, virtual]

Definition at line 828 of file User_traffic.cc.

00829 {
00831         double buffer = (double) par("buffer_size"); // Longitud total del buffer (Bytes)
00832         double bloqueo;
00833 
00834         //ETHERNETmsg *msjdatos = check_and_cast<ETHERNETmsg*>(msg);
00835         DATA *msjdatos = check_and_cast<DATA*>(msg);
00836 
00837         // Acceso a los submodulos 'bs_rx_tx' y 'bs_queue[<loquetoque>]':
00838         rxtx_bs = check_and_cast<BS_rx_tx *>(this->getParentModule()->gate("physicalUser$o")->getNextGate()->getOwnerModule()->getSubmodule("bs_rx_tx"));
00839         // Numero de submodulos 'bs_queue'
00840         int long_puerta = (int) rxtx_bs->gateSize("queueRxTx");
00841         // Obtencion del nodo siguiente a la BS que recibe los paquetes de este usuario:
00842         char* nodo_siguiente = (char*) msjdatos->getRuta(1);
00843         // Obtencion del indice del modulo 'bs_queue' que nos interesa (aquel que almacena
00844         // los paquetes dirigidos al 'nodo_siguiente'):
00845         int j=0, found = -1;
00846         while(j<long_puerta && found<0)
00847         {
00848                 cola_bs = check_and_cast<BS_queue *>(rxtx_bs->gate("queueRxTx$o",j)->getNextGate()->getOwnerModule());
00849                 if(strcmp(nodo_siguiente,cola_bs->getTarget())==0)
00850                 {
00851                         found = j;
00852                 }
00853                 j++;
00854         }
00855 
00856         //buffer = buffer/cola_bs->colas_salida;///////
00857 
00858         /*
00859         //ev << " Intento de insercion de este paquete en la cola P" << this->getIndex() << " del modulo "
00860                         << (char*) msjdatos->getRuta(0) << "." << cola_bs->getFullName() << " con destino "
00861                         << cola_bs->getTarget() << endl;
00862 
00863         // Visualizacion por pantalla del numero de bytes presentes en la cola donde se quiere insertar el nuevo paquete:
00864         //ev << "       Longitud de la cola P" << msjdatos->getPriority() << ", donde insertamos el paquete " << ": " << cola_bs->tamqueue[msjdatos->getPriority()] << " Bytes" << endl;
00865         */
00866 
00867         // Comprobacion de si hay espacio suficiente o no en el buffer de esta cola:
00868         // Si hay espacio:
00869         if(buffer/(int)par("numcolas") >= (cola_bs->tamqueue[msjdatos->getPriority()] + msjdatos->getByteLength()))
00870         {
00872                 bloqueo=0.0; //ENVIO PAQUETE
00873 
00874                 // Envio del paquete "msjdatos" a la interfaz del usuario:
00875                 //cola_bs->tamqueue[msjdatos->getPriority()] = cola_bs->tamqueue[msjdatos->getPriority()] + msjdatos->getByteLength();
00876                 //msjdatos->setTime_enter_queue(simTime());
00877                 //cola_bs->queue[getIndex()].insert(msjdatos);
00878                 send(msjdatos, "traffic");
00879         }
00880         // Si no hay espacio:
00881         else if(buffer/(int)par("numcolas") < (cola_bs->tamqueue[msjdatos->getPriority()] + msjdatos->getByteLength()))
00882         {
00884                 bloqueo=1.0; //BORRADO PAQUETE
00885                 // Borrado del mensaje "msjdatos" al no poderlo insertar en su cola por estar llena:
00886                 delete msjdatos;
00887                 //ev << " MENSAJE BORRADO" << endl;
00888                 // INCREMENTO DE LA VARIABLE PARA CONTROLAR EL BORRADO DE PAQUETES EN LA PARTE INALAMBRICA:
00889                 check_and_cast<BS_table *>(rxtx_bs->getParentModule()->getSubmodule("bs_table"))->paquetes_borrados++;
00890         }
00891 }

void User_traffic::volcadoFicheros (  )  [protected, virtual]

Definition at line 1061 of file User_traffic.cc.

01062 {
01063         //volcado = 1;
01064         // 'CARGA_PAQUETES_USER': FICHERO CON LA CARGA DE CADA FUENTE DE TRAFICO INALAMBRICO EN CADA MODULO USER.
01065         carga_paquetes_user = fopen("results/carga_paquetes_user.txt", "a+");
01066         //fprintf(carga_paquetes_user,"Carga total de la fuente %i del User %i: %g\n", getIndex(), this->getParentModule()->getIndex(), total_load_user);
01067         fprintf(carga_paquetes_user,"Carga total de la fuente %i del User %i: %g\n", getIndex(), this->getParentModule()->getIndex(), (double)carga_user.average());
01068         fclose(carga_paquetes_user);
01069 
01070         //'PAQUETES_USER': FICHERO CON EL NUMERO TOTAL DE PAQUETES GENERADOS POR CADA FUENTE DE TRAFICO INALAMBRICO EN CADA MODULO USER.
01071         paquetes_user = fopen("results/paquetes_user.txt", "a+");
01072         fprintf(paquetes_user,"User [%i]: Fuente P%i \n", this->getParentModule()->getIndex(), getIndex());
01073         fprintf(paquetes_user,"Total paquetes de longitud media %g Bytes\t",(double)longitud_user.average());
01074         //fprintf(paquetes_user,"64 Bytes\t");
01075         //fprintf(paquetes_user,"594 Bytes\t");
01076         //fprintf(paquetes_user,"1500 Bytes\n");
01077         fprintf(paquetes_user,"%li \t", totalpacket_user); // SUMA TOTAL DE PAQUETES GENERADOS
01078         //fprintf(paquetes_user," %li \t", packet_64_user); // PAQUETES GENERADOS DE 64 BYTES
01079         //fprintf(paquetes_user," %li \t", packet_594_user); // PAQUETES GENERADOS DE 594 BYTES
01080         //fprintf(paquetes_user," %li\t", packet_1500_user); // PAQUETES GENERADOS DE 1500 BYTES
01081         fprintf(paquetes_user,"\n");
01082         fclose(paquetes_user);
01083 }


Member Data Documentation

Definition at line 42 of file User_traffic.h.

Definition at line 40 of file User_traffic.h.

Definition at line 65 of file User_traffic.h.

Definition at line 57 of file User_traffic.h.

int User_traffic::contador [protected]

Definition at line 85 of file User_traffic.h.

Definition at line 54 of file User_traffic.h.

Definition at line 68 of file User_traffic.h.

Definition at line 55 of file User_traffic.h.

Definition at line 67 of file User_traffic.h.

Definition at line 50 of file User_traffic.h.

Definition at line 41 of file User_traffic.h.

Definition at line 56 of file User_traffic.h.

Definition at line 72 of file User_traffic.h.

Definition at line 71 of file User_traffic.h.

Definition at line 70 of file User_traffic.h.

Definition at line 49 of file User_traffic.h.

Definition at line 48 of file User_traffic.h.

FILE* User_traffic::paquetes_user [private]

Definition at line 43 of file User_traffic.h.

Definition at line 58 of file User_traffic.h.

Definition at line 61 of file User_traffic.h.

Definition at line 64 of file User_traffic.h.

Definition at line 51 of file User_traffic.h.

Definition at line 60 of file User_traffic.h.

Definition at line 59 of file User_traffic.h.

Definition at line 62 of file User_traffic.h.

Definition at line 63 of file User_traffic.h.

Definition at line 73 of file User_traffic.h.

Definition at line 66 of file User_traffic.h.

int User_traffic::volcado [protected]

Definition at line 84 of file User_traffic.h.


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

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