ONU_GENTraffic Class Reference

#include <ONU_GENTraffic.h>

Inheritance diagram for ONU_GENTraffic:

cSimpleModule cModule cComponent cDefaultList cNoncopyableOwnedObject cOwnedObject noncopyable cNamedObject cObject

List of all members.

Public Member Functions

 ONU_GENTraffic ()
virtual ~ONU_GENTraffic ()

Public Attributes

GeneratorpAG
int packetSize
double_vector_t load_dmb
OLT_Rxolt_plr
int onu
int sla
int isGateway
double wavelength_bit_rate
ONU_SISTqueueonu_queue
long tamsumqueue
int_vector_t tamsumpop
double suma_tam_packets
simtime_t time_creation
double total_load
int_vector_t suma_total
long packet_64
long packet_594
long packet_1500
long totalpacket

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 load_carga
FILE * carga_paquetes
FILE * paquetes


Detailed Description

Definition at line 67 of file ONU_GENTraffic.h.


Constructor & Destructor Documentation

ONU_GENTraffic::ONU_GENTraffic (  ) 

Definition at line 58 of file ONU_GENTraffic.cc.

00059 {
00060     pAG = NULL; // PUNTERO AL GENERADOR DE PAQUETES CON VALOR NULL O VACIO
00061 }

ONU_GENTraffic::~ONU_GENTraffic (  )  [virtual]

Definition at line 66 of file ONU_GENTraffic.cc.

00067 {
00068     delete pAG; // BORRAMOS EL PUNTERO AL GENERADOR DE PAQUETES
00069 }


Member Function Documentation

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

Reimplemented from cComponent.

Definition at line 1099 of file ONU_GENTraffic.cc.

01100 {
01101         // VISUALIZAMOS POR PANTALLA LA RECOGIDA DE ESTADISTICAS DE LA CARGA CUANDO LLAMAMOS A LA FUNCION FINISH()
01102         //ev<<" Estadisticas tomadas en el Modulo ONU_GENTraffic"<<endl;
01103         ev<<" Carga del nodo de la ONU: "<<total_load<<endl;
01104         volcadoFicheros();
01105 }

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

Reimplemented from cSimpleModule.

Definition at line 306 of file ONU_GENTraffic.cc.

00307 {
00308         //VARIABLES
00309         int type = msg->getKind(); // VARIABLE TYPE PARA IDENTIFICAR LOS MENSAJES DE LA RED
00310         int method = (int)par("insercionmethod_separatequeue0_priorityqueue1"); // PARAMETRO PARA ELEGIR EL METODO DE COLAS ( METODO DE COLAS SEPARADAS O METODO DE PRIORIDAD DE COLAS )
00311                 //double buffer = (double)par("tambuffer"); // TAMANYO TOTAL DEL BUFFER Y VISUALIZACION POR PANTALLA
00312         //ev<<" Tamanyo del Buffer: "<<buffer<<endl;
00313         // TASA DE BITS POR LONGITUD DE ONDA UTILIZADA
00314         double txrate = (double)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
00315         wavelength_bit_rate = txrate/10;// DIVIDIMOS LA TASAS DE TRANSMISION ENTRE 10 PARA QUE TENGAMOS EL PARAMETRO = 10e8 PARA TENER UN TAMANYO DE BUFFER DE 10 MBytes
00316         int destAddress = 9; // DIRECCION DE DESTINO DEL PAQUETE ETHERNET
00317         int srcAddress = getParentModule()->getParentModule()->getIndex(); // DIRECCION FUENTE O DE ORIGEN DEL PAQUETE ETHERNET
00318         int priority = getIndex(); // PARAMETRO DE LA PRIORIDAD QUE SE ASIGNA POR EL IDENTIFICADOR DE LA FUENTE QUE SE CREA
00319 
00320         onu=srcAddress;
00321         if(onu<2) //if(onu==0)
00322         {
00323                 sla=0;
00324         }
00325         else if(onu>=2 && onu<8)//else if(onu>=1 && onu<=5)
00326         {
00327                 sla=1;
00328         }
00329         else if(onu>=8)//else if(onu>=6)
00330         {
00331                 sla=2;
00332         }
00333         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA LOS MENSAJES QUE LLEGUEN A ESTE MODULO
00334         switch(type)
00335         {
00336                 case 5:
00337                         // LLEGA UN AUTOMENSAJE CON IDENTIFICADOR = 5 PARA GENERAR EL PAQUETE ETHERNET
00338                         if(msg->getKind()==5)
00339                         {
00340                                 if((int)par("numqueue") == 1)
00341                                 {
00342                                 //      ev<<" TRABAJAMOS CON UN FUENTE SELF SIMILAR AL SOLO TENER UNA PRIORIDAD"<<endl;
00343 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 ////////////////////////////////////////////////////////////////////
00344                                         Generator &AG=*pAG;
00345                                         AG.GetNextPacket();
00346                                         Trace trc= AG.PeekNextPacket();
00347                                         bytestamp_t tiempo=AG.GetTime();
00348                                         bytestamp_t ByteStamp= AG.GetByteStamp();
00349                                         bytestamp_t intervalo=ByteStamp-tiempo;
00350 
00351                                         // CALCULAMOS LA VARIABLE interarrivaltime A PARTIR DEL INTERVALO DETERMINADO EN BYTES
00352                                         simtime_t interarrivaltime = (simtime_t)(intervalo*8/wavelength_bit_rate);
00353 
00354                                         //CREAMOS PAQUETE ETHERNET PARA ENVIAR AL OLT
00355                                         ETHERNETmsg *packet = new ETHERNETmsg("Ethernet");
00356                                         packet->setIsWireless(0); // MENSAJE DE FUENTE OPTICA (isWireless = 0):
00357                                         packet->setSrcAddress(srcAddress); // DIRECCION FUENTE O DE ORIGEN
00358                                         packet->setDestAddress(destAddress); // DIRECCION DE DESTINO
00359                                         packet->setByteLength(trc.PacketSize); // TAMANYO DEL PAQUETE ETHERNET
00360                                         packet->setPriority(priority); // PRIORIDAD DEL PAQUETE ETHERNET
00361                                         packet->setLambdaethernet(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE ETHERNET
00362                                         packet->setKind(1); // IDENTIFICADOR DEL PAQUETE ETHERNET
00363                                         packet->setId_servicio(getIndex());
00364                                         /*
00365                                         //VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE ETHERNET
00366                                         ev<<" Paquete Ethernet "<<endl;
00367                                         ev<<" Origen ONU "<<packet->getSrcAddress()<<endl;
00368                                         ev<<" Destino OLT con ID "<<packet->getDestAddress()<<endl;
00369                                         ev<<" Prioridad: "<<packet->getPriority()<<endl;
00370                                         ev<<" Longitud de onda de envio, Lambda "<<packet->getLambdaethernet()<<endl;
00371                                         ev<<" Tamanyo Paquete Ethernet: "<<packet->getByteLength()<<endl;
00372                                         ev<<" Tipo "<<packet->getKind()<<endl;
00373                                         ev<<" Identificador servicio P"<<packet->getId_servicio()<<endl;
00374                                         */
00375                                         simtime_t time_sch = (simtime_t) (simTime()+interarrivaltime);
00376                                         scheduleAt(time_sch,msg); //PROGRAMAMOS UN AUTOMENSAJE PARA EL INSTANTE SimTime()+interarrivalTime
00377 
00378                                         //ev<<" Generacion de un nuevo paquete de datos 'ETHERNET' de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "] " << endl;
00380 
00381                                         // CALCULAMOS LA SUMA TOTAL DEL TAMANYO DE LOS PAQUETES GENERADOS POR LA ONU EN BYTES Y LO VISUALIZAMOS POR PANTALLA
00382                                         suma_tam_packets = suma_tam_packets + (double) trc.PacketSize;
00384 
00385                                         time_creation = (simtime_t) simTime(); // TIEMPO DE CREACCION DEL PAQUETE ETHERNET
00386                                         packet->setTimestamp(time_creation);
00387                                         // CALCULAMOS LA CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA CADA VEZ QUE SE GENERA UN PAQUETE ETHERNET
00388                                         double tiempo_creacion = (double) SIMTIME_DBL(time_creation);
00389                                         total_load = (double) (suma_tam_packets*8/(tiempo_creacion*wavelength_bit_rate)); // FORMULA PARA CALCULAR LA CARGA DEL NODO DE LA ONU
00392                                         //ev<<"         Carga Total del Nodo de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "]: " << total_load << endl;
00393 
00394                                         //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00395                                         load_carga.analyze(total_load);
00396 
00397                                         totalpacket++; // SUMA TOTAL DE TODOS LOS PAQUETES CREADOS POR LA ONU
00398 
00399                                         if(packet->getByteLength()==64)
00400                                         {
00401                                                 // PAQUETES CREADOS DE 64 BYTES
00402                                                 packet_64++;
00403                                         }
00404                                         else if(packet->getByteLength()==594)
00405                                         {
00406                                                 // PAQUETES CREADOS DE 594 BYTES
00407                                                 packet_594++;
00408                                         }
00409                                         else if(packet->getByteLength()==1500)
00410                                         {
00411                                                 // PAQUETES CREADOS DE 1500 BYTES
00412                                                 packet_1500++;
00413                                         }
00414 
00415                                         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00416                                         switch(method)
00417                                         {
00418                                                 case 0:
00419                                                         //ev<<" Metodo de Colas Separadas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00420                                                         //ev<<" Tamanyo Colas Totales."<<endl;
00421 
00422                                                         // VISUALIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00423                                                         for(int i=0; i<(int)par("numqueue"); i++)
00424                                                         {
00425                                                                 cModule *c_onu_queue;
00426                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00427                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00428                                                                 //ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00429                                                         }
00430                                                         //delete packet;
00431                                                         separatequeue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE COLAS SEPARADAS
00432                                                         break;
00433 
00434                                                 case 1:
00435                                                         //ev<<" Metodo de Prioridad de Colas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00436 
00437                                                         // VISUALIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00438                                                         for(int i=0; i<(int)par("numqueue"); i++)
00439                                                         {
00440                                                                 cModule *c_onu_queue;
00441                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00442                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00443                                                                 //ev<<" Tamanyo cola P"<<i<<" -> "<<onu_queue->tamqueue[i]<<" Bytes"<<endl;
00444                                                         }
00445                                                         //delete packet;
00446                                                         priorityqueue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE PRIORIDAD DE COLAS
00447                                                         break;
00448 
00449                                                 default:
00450                                                         ev<<" ERROR AL ELEGIR EL METODO DE COLAS, ELEGIR 0 o 1."<<endl;
00451                                                         delete packet;
00452                                                         break;
00453                                         }
00454 
00455 // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2////////////////////////////////////////////////////////////////////////////
00457 
00458 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 ///////////////////////////////////////////////////////////////////////////
00459 /*
00460                                         PacketGenerator &SRC=*pSRC;
00461                                         Packet pckt; // DEFINIMOS EL PAQUETE
00462                                         pckt = SRC.GetNextPacket(); // SIGUIENTE PAQUETE
00463 
00464                                         // CALCULAMOS LA VARIABLE interarrivaltime A PARTIR DEL INTERVALO DETERMINADO EN BYTES
00465                                         interarrivalTime = (simtime_t)(((double)pckt.Interval*8)/wavelength_bit_rate);
00466 
00467                                         //CREAMOS PAQUETE ETHERNET PARA ENVIAR AL OLT
00468                                         ETHERNETmsg *packet = new ETHERNETmsg("Ethernet");
00469                                         packet->setSrcAddress(srcAddress); // DIRECCION FUENTE O DE ORIGEN
00470                                         packet->setDestAddress(destAddress); // DIRECCION DE DESTINO
00471                                         packet->setByteLength(pckt.PcktSize); // TAMANYO DEL PAQUETE ETHERNET
00472                                         packet->setPriority(priority); // PRIORIDAD DEL PAQUETE ETHERNET
00473                                         packet->setLambdaethernet(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE ETHERNET
00474                                         packet->setKind(1); // IDENTIFICADOR DEL PAQUETE ETHERNET
00475                                         packet->setId_servicio(getIndex());
00476 
00477                                         //VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE ETHERNET
00478                                         ev<<" Paquete Ethernet "<<endl;
00479                                         ev<<" Origen ONU "<<packet->getSrcAddress()<<endl;
00480                                         ev<<" Destino OLT con ID "<<packet->getDestAddress()<<endl;
00481                                         ev<<" Prioridad: "<<packet->getPriority()<<endl;
00482                                         ev<<" Longitud de onda de envio, Lambda "<<packet->getLambdaethernet()<<endl;
00483                                         ev<<" Tamanyo Paquete Ethernet: "<<packet->getByteLength()<<endl;
00484                                         ev<<" Tipo "<<packet->getKind()<<endl;
00485                                         ev<<" Identificador servicio P"<<packet->getId_servicio()<<endl;
00486 
00487                                         scheduleAt(simTime()+interarrivalTime,msg); //PROGRAMAMOS UN AUTOMENSAJE PARA EL INSTANTE SimTime()+interarrivalTime
00488 
00489                                         // CALCULAMOS LA SUMA TOTAL DEL TAMANYO DE LOS PAQUETES GENERADOS POR LA ONU EN BYTES Y LO VISUALIZAMOS POR PANTALLA
00490                                         suma_tam_packets = suma_tam_packets + pckt.PcktSize;
00491                                         ev<<" suma tamanyo paquetes ONU "<<getParentModule()->getParentModule()->getIndex()<<": "<<suma_tam_packets<<"Bytes"<<endl;
00492 
00493                                         time_creation = simTime(); // TIEMPO DE CREACCION DEL PAQUETE ETHERNET
00494 
00495                                         // CALCULAMOS LA CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA CADA VEZ QUE SE GENERA UN PAQUETE ETHERNET
00496                                         total_load = suma_tam_packets*8/(SIMTIME_DBL(time_creation)*); // FORMULA PARA CALCULAR LA CARGA DEL NODO DE LA ONU
00497                                         ev<<" Carga Total del Nodo de la ONU: "<<total_load<<endl;
00498 
00499                                         //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00500                                         load_carga.analyze(total_load);
00501 
00502                                         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00503                                         switch(method)
00504                                         {
00505                                                 case 0:
00506                                                         ev<<" Metodo de Colas Separadas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00507                                                         ev<<" Tamanyo Colas Totales."<<endl;
00508 
00509                                                         // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00510                                                         for(int i=0; i<(int)par("numqueue"); i++)
00511                                                         {
00512                                                                 cModule *c_onu_queue;
00513                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00514                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00515                                                                 ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00516                                                         }
00517                                                         separatequeue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE COLAS SEPARADAS
00518                                                         break;
00519 
00520                                                 case 1:
00521                                                         ev<<" Metodo de Prioridad de Colas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00522 
00523                                                         // VISUALIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00524                                                         for(int i=0; i<(int)par("numqueue"); i++)
00525                                                         {
00526                                                                 cModule *c_onu_queue;
00527                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00528                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00529                                                                 ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00530                                                         }
00531                                                         priorityqueue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE PRIORIDAD DE COLAS
00532                                                         break;
00533 
00534                                                 default:
00535                                                         ev<<" ERROR AL ELEGIR EL METODO DE COLAS, ELEGIR 0 o 1."<<endl;
00536                                                         delete packet;
00537                                                         break;
00538                                         }
00539 */
00540 // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 ////////////////////////////////////////////////////////////////////////////
00542                                 }
00543                                 else if((int)par("numqueue") >= 2)
00544                                 {
00545                                         if(getIndex() == 0)
00546                                         {
00547                                                 //ev<<" TRABAJAMOS CON UN FUENTE DE TASA CONSTANTE YA QUE TENEMOS UNA PRIORIDAD "<<getIndex()<<endl;
00548                                                 // FUENTE CONSTANTE DE PAQUETES DE 70 BYTES QUE SE MANDAN DURANTE 125 MICROSEGUNDOS
00549                                                 //CREAMOS PAQUETE ETHERNET PARA ENVIAR AL OLT
00550                                                 ETHERNETmsg *packet = new ETHERNETmsg("Ethernet");
00551                                                 packet->setIsWireless(0); // MENSAJE DE FUENTE OPTICA (isWireless = 0):
00552                                                 packet->setSrcAddress(srcAddress); // DIRECCION FUENTE O DE ORIGEN
00553                                                 packet->setDestAddress(destAddress); // DIRECCION DE DESTINO
00554                                                 packet->setByteLength(70); // TAMANYO DEL PAQUETE ETHERNET
00555                                                 packet->setPriority(priority); // PRIORIDAD DEL PAQUETE ETHERNET
00556                                                 packet->setLambdaethernet(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE ETHERNET
00557                                                 packet->setKind(1); // IDENTIFICADOR DEL PAQUETE ETHERNET
00558                                                 packet->setId_servicio(getIndex());
00559                                                 /*
00560                                                 //VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE ETHERNET
00561                                                 ev<<" Paquete Ethernet "<<endl;
00562                                                 ev<<" Origen ONU "<<packet->getSrcAddress()<<endl;
00563                                                 ev<<" Destino OLT con ID "<<packet->getDestAddress()<<endl;
00564                                                 ev<<" Prioridad: "<<packet->getPriority()<<endl;
00565                                                 ev<<" Longitud de onda de envio, Lambda "<<packet->getLambdaethernet()<<endl;
00566                                                 ev<<" Tamanyo Paquete Ethernet: "<<packet->getByteLength()<<endl;
00567                                                 ev<<" Tipo "<<packet->getKind()<<endl;
00568                                                 ev<<" Identificador servicio P"<<packet->getId_servicio()<<endl;
00569                                                 */
00570                                                 scheduleAt(simTime()+0.000125,msg); //PROGRAMAMOS UN AUTOMENSAJE PARA EL INSTANTE SimTime()+interarrivalTime
00571 
00572                                                 //ev<<" Generacion de un nuevo paquete de datos 'ETHERNET' de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "] " << endl;
00574 
00575                                                 // CALCULAMOS LA SUMA TOTAL DEL TAMANYO DE LOS PAQUETES GENERADOS POR LA ONU EN BYTES Y LO VISUALIZAMOS POR PANTALLA
00576                                                 suma_tam_packets = suma_tam_packets + (double) packet->getByteLength();
00577                                                 //ev<<"         Suma bytes paquetes ONU "<<getParentModule()->getParentModule()->getIndex()<<": "<<suma_tam_packets<<"Bytes"<<endl;
00578 
00579                                                 time_creation = simTime(); // TIEMPO DE CREACCION DEL PAQUETE ETHERNET
00580                                                 packet->setTimestamp(time_creation);
00581                                                 // CALCULAMOS LA CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA CADA VEZ QUE SE GENERA UN PAQUETE ETHERNET
00582                                                 double tiempo_creacion = (double) SIMTIME_DBL(time_creation);
00583                                                 total_load = (double) (suma_tam_packets*8/(tiempo_creacion*wavelength_bit_rate)); // FORMULA PARA CALCULAR LA CARGA DEL NODO DE LA ONU
00584                                                 //ev<<"         Carga Total del Nodo de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "]: " << total_load << endl;
00585 
00586                                                 //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00587                                                 load_carga.analyze(total_load);
00588                                                 totalpacket++;
00589 
00590                                                 // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00591                                                 switch(method)
00592                                                         {
00593                                                                 case 0:
00594                                                                                 //ev<<" Metodo de Colas Separadas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00595                                                                         //ev<<" Tamanyo Colas Totales."<<endl;
00596 
00597                                                                         // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00598                                                                         for(int i=0; i<(int)par("numqueue"); i++)
00599                                                                         {
00600                                                                                 cModule *c_onu_queue;
00601                                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00602                                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00603                                                                                 //ev<<" Longitud cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00604                                                                         }
00605                                                                         //delete packet;
00606                                                                                 separatequeue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE COLAS SEPARADAS
00607                                                                                 break;
00608 
00609                                                                 case 1:
00610                                                                                 //ev<<" Metodo de Prioridad de Colas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00611 
00612                                                                         // VISUALIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00613                                                                         for(int i=0; i<(int)par("numqueue"); i++)
00614                                                                         {
00615                                                                                 cModule *c_onu_queue;
00616                                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00617                                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00618                                                                                 //ev<<" Longitud cola P"<<i<<" -> "<<onu_queue->tamqueue[i]<<" Bytes"<<endl;
00619                                                                         }
00620                                                                         //delete packet;
00621                                                                         priorityqueue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE PRIORIDAD DE COLAS
00622                                                                         break;
00623 
00624                                                                 default:
00625                                                                         ev<<" ERROR AL ELEGIR EL METODO DE COLAS, ELEGIR 0 o 1."<<endl;
00626                                                                         delete packet;
00627                                                                         break;
00628                                                         }
00629 
00630                                         }
00631                                         else if(getIndex() >=1)
00632                                         {
00633                                         //      ev<<" TRABAJAMOS CON UN FUENTE SELF SIMILAR AL TENER LA PRIORIDAD "<<getIndex()<<" > QUE PRIORIDAD 0"<<endl;
00634 
00635 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 //////////////////////////////////////////////////////////////////////////
00636 
00637                                                 Generator &AG=*pAG;
00638                                                 AG.GetNextPacket();
00639                                                 Trace trc= AG.PeekNextPacket();
00640 
00641                                                 bytestamp_t tiempo=AG.GetTime();
00642                                                 bytestamp_t ByteStamp= AG.GetByteStamp();
00643                                                 bytestamp_t intervalo=ByteStamp-tiempo;
00644 
00645                                                 // CALCULAMOS LA VARIABLE interarrivaltime A PARTIR DEL INTERVALO DETERMINADO EN BYTES
00646                                                 simtime_t interarrivaltime = (simtime_t)(intervalo*8/wavelength_bit_rate);
00647 
00648                                                 //CREAMOS PAQUETE ETHERNET PARA ENVIAR AL OLT
00649                                                 ETHERNETmsg *packet = new ETHERNETmsg("Ethernet");
00650                                                 packet->setIsWireless(0); // MENSAJE DE FUENTE OPTICA (isWireless = 0):
00651                                                 packet->setSrcAddress(srcAddress); // DIRECCION FUENTE O DE ORIGEN
00652                                                 packet->setDestAddress(destAddress); // DIRECCION DE DESTINO
00653                                                 packet->setByteLength(trc.PacketSize); // TAMANYO DEL PAQUETE ETHERNET
00654                                                 packet->setPriority(priority); // PRIORIDAD DEL PAQUETE ETHERNET
00655                                                 packet->setLambdaethernet(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE ETHERNET
00656                                                 packet->setKind(1); // IDENTIFICADOR DEL PAQUETE ETHERNET
00657                                                 packet->setId_servicio(getIndex());
00658                                                 //ev<<" Generacion de un nuevo paquete de datos 'ETHERNET' de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "] " << endl;
00659 
00660                                                 /*
00661                                                 //VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE ETHERNET
00662                                                 ev<<" Paquete Ethernet "<<endl;
00663                                                 ev<<" Origen ONU "<<packet->getSrcAddress()<<endl;
00664                                                 ev<<" Destino OLT con ID "<<packet->getDestAddress()<<endl;
00665                                                 ev<<" Prioridad: "<<packet->getPriority()<<endl;
00666                                                 ev<<" Longitud de onda de envio, Lambda "<<packet->getLambdaethernet()<<endl;
00667                                                 ev<<" Tamanyo Paquete Ethernet: "<<packet->getByteLength()<<endl;
00668                                                 ev<<" Tipo "<<packet->getKind()<<endl;
00669                                                 ev<<" Identificador servicio P"<<packet->getId_servicio()<<endl;
00670                                                 */
00671 
00672                                                 scheduleAt(simTime()+interarrivaltime,msg); //PROGRAMAMOS UN AUTOMENSAJE PARA EL INSTANTE SimTime()+interarrivalTime
00673 
00674                                                 // CALCULAMOS LA SUMA TOTAL DE LA LONGITUD DE LOS PAQUETES GENERADOS POR LA ONU EN BYTES Y LO VISUALIZAMOS POR PANTALLA
00675                                                 suma_tam_packets = suma_tam_packets + (double) trc.PacketSize;
00676                                                 //ev<<" Suma del Tamanyo de los Paquetes de la Onu ONU "<<getParentModule()->getParentModule()->getIndex()<<": "<<suma_tam_packets<<"Bytes"<<endl;
00677 
00678                                                 time_creation = simTime(); // TIEMPO DE CREACCION DEL PAQUETE ETHERNET
00679                                                 packet->setTimestamp(time_creation);
00680                                                 // CALCULAMOS LA CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA CADA VEZ QUE SE GENERA UN PAQUETE ETHERNET
00681                                                 double tiempo_creacion = (double) SIMTIME_DBL(time_creation);
00682                                                 total_load = (double) (suma_tam_packets*8/(tiempo_creacion*wavelength_bit_rate)); // FORMULA PARA CALCULAR LA CARGA DEL NODO DE LA ONU
00683                                                 //ev<<"         Carga Total del Nodo de la ONU[" << this->getParentModule()->getParentModule()->getIndex() << "]: " << total_load << endl;
00684 
00685                                                 //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00686                                                 load_carga.analyze(total_load);
00687 
00688                                                 totalpacket++; // SUMA TOTAL DE TODOS LOS PAQUETES CREADOS POR LA ONU
00689 
00690                                                 if(packet->getByteLength()==64)
00691                                                 {
00692                                                         // PAQUETES CREADOS DE 64 BYTES
00693                                                         packet_64++;
00694                                                 }
00695                                                 else if(packet->getByteLength()==594)
00696                                                 {
00697                                                         // PAQUETES CREADOS DE 594 BYTES
00698                                                         packet_594++;
00699                                                 }
00700                                                 else if(packet->getByteLength()==1500)
00701                                                 {
00702                                                         // PAQUETES CREADOS DE 1500 BYTES
00703                                                         packet_1500++;
00704                                                 }
00705 
00706                                                 // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00707                                                 switch(method)
00708                                                 {
00709                                                         case 0:
00710                                                                 //ev<<" Metodo de Colas Separadas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00711                                                                 //ev<<" Tamanyo Colas Totales."<<endl;
00712 
00713                                                                 // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00714                                                                 for(int i=0; i<(int)par("numqueue"); i++)
00715                                                                 {
00716                                                                         cModule *c_onu_queue;
00717                                                                         c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00718                                                                         onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00719                                                                 //      ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00720                                                                 }
00721                                                                 //delete packet;
00722                                                                 separatequeue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE COLAS SEPARADAS
00723                                                                 break;
00724 
00725                                                                 case 1:
00726                                                                 //      ev<<" Metodo de Prioridad de Colas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00727 
00728                                                                         // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00729                                                                         for(int i=0; i<(int)par("numqueue"); i++)
00730                                                                         {
00731                                                                                 cModule *c_onu_queue;
00732                                                                                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00733                                                                                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00734                                                                                 //ev<<" Tamanyo cola P"<<i<<" -> "<<onu_queue->tamqueue[i]<<" Bytes"<<endl;
00735                                                                         }
00736                                                                         //delete packet;
00737                                                                         priorityqueue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE PRIORIDAD DE COLAS
00738                                                                         break;
00739 
00740                                                                 default:
00741                                                                         ev<<" ERROR AL ELEGIR EL METODO DE COLAS, ELEGIR 0 o 1."<<endl;
00742                                                                         delete packet;
00743                                                                         break;
00744                                                 }
00745 
00746 // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 /////////////////////////////////////////////////////////////////////////
00748 
00749 
00750 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 ////////////////////////////////////////////////////////////////////////
00751 /*
00752                                                 PacketGenerator &SRC=*pSRC;
00753                                                 Packet pckt; // DEFINIMOS EL PAQUETE
00754                                                 pckt = SRC.GetNextPacket(); // SIGUIENTE PAQUETE
00755 
00756                                                 // CALCULAMOS LA VARIABLE interarrivaltime A PARTIR DEL INTERVALO DETERMINADO EN BYTES
00757                                                 interarrivalTime = (simtime_t)(((double)pckt.Interval*8)/wavelength_bit_rate);
00758 
00759                                                 //CREAMOS PAQUETE ETHERNET PARA ENVIAR AL OLT
00760                                                 ETHERNETmsg *packet = new ETHERNETmsg("Ethernet");
00761                                                 packet->setSrcAddress(srcAddress); // DIRECCION FUENTE O DE ORIGEN
00762                                                 packet->setDestAddress(destAddress); // DIRECCION DE DESTINO
00763                                                 packet->setByteLength(pckt.PcktSize); // TAMANYO DEL PAQUETE ETHERNET
00764                                                 packet->setPriority(priority); // PRIORIDAD DEL PAQUETE ETHERNET
00765                                                 packet->setLambdaethernet(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE ETHERNET
00766                                                 packet->setKind(1); // IDENTIFICADOR DEL PAQUETE ETHERNET
00767                                                 packet->setId_servicio(getIndex());
00768 
00769                                                 //VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE ETHERNET
00770                                                 ev<<" Paquete Ethernet "<<endl;
00771                                                 ev<<" Origen ONU "<<packet->getSrcAddress()<<endl;
00772                                                 ev<<" Destino OLT con ID "<<packet->getDestAddress()<<endl;
00773                                                 ev<<" Prioridad: "<<packet->getPriority()<<endl;
00774                                                 ev<<" Longitud de onda de envio, Lambda "<<packet->getLambdaethernet()<<endl;
00775                                                 ev<<" Tamanyo Paquete Ethernet: "<<packet->getByteLength()<<endl;
00776                                                 ev<<" Tipo "<<packet->getKind()<<endl;
00777                                                 ev<<" Identificador servicio P"<<packet->getId_servicio()<<endl;
00778 
00779                                                 scheduleAt(simTime()+interarrivalTime,msg); //PROGRAMAMOS UN AUTOMENSAJE PARA EL INSTANTE SimTime()+interarrivalTime
00780 
00781                                                 // CALCULAMOS LA SUMA TOTAL DEL TAMANYO DE LOS PAQUETES GENERADOS POR LA ONU EN BYTES Y LO VISUALIZAMOS POR PANTALLA
00782                                                 suma_tam_packets = suma_tam_packets + pckt.PcktSize;
00783                                                 ev<<" suma tamanyo paquetes ONU "<<getParentModule()->getParentModule()->getIndex()<<": "<<suma_tam_packets<<"Bytes"<<endl;
00784 
00785                                                 time_creation = simTime(); // TIEMPO DE CREACCION DEL PAQUETE ETHERNET
00786 
00787                                                 // CALCULAMOS LA CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA CADA VEZ QUE SE GENERA UN PAQUETE ETHERNET
00788                                                 total_load = suma_tam_packets*8/(SIMTIME_DBL(time_creation)*wavelength_bit_rate); // FORMULA PARA CALCULAR LA CARGA DEL NODO DE LA ONU
00789                                                 ev<<" Carga Total del Nodo de la ONU: "<<total_load<<endl;
00790 
00791                                                 //RECOGIDA DE ESTADISTICAS DE LA CARGA TOTAL
00792                                                 load_carga.analyze(total_load);
00793 
00794                                                 // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA EL METODO DE INSERCION DE PAQUETES DE LAS COLAS
00795                                                 switch(method)
00796                                                 {
00797                                                         case 0:
00798                                                                 ev<<" Metodo de Colas Separadas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00799                                                                 ev<<" Tamanyo Colas Totales."<<endl;
00800 
00801                                                                 // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00802                                                                 for(int i=0; i<(int)par("numqueue"); i++)
00803                                                                 {
00804                                                                         cModule *c_onu_queue;
00805                                                                         c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00806                                                                         onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00807                                                                         ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00808                                                                 }
00809                                                                 separatequeue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE COLAS SEPARADAS
00810                                                                 break;
00811 
00812                                                         case 1:
00813                                                                 ev<<" Metodo de Prioridad de Colas."<<" Tamanyo Buffer Total: "<< buffer<<"Bytes"<<endl;
00814 
00815                                                                 // VISULAIZAMOS POR PANTALLA EL TAMANYO DE LAS COLAS ENTRANDO DESDE ESTE MODULO AL MODULO ONU_SISTQUEUE Y COMPROBANDO SU TAMANYO
00816                                                                 for(int i=0; i<(int)par("numqueue"); i++)
00817                                                                 {
00818                                                                         cModule *c_onu_queue;
00819                                                                         c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00820                                                                         onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00821                                                                         ev<<" Tamanyo cola "<<i<<"-> "<<onu_queue->tamqueue[i]<<"Bytes"<<endl;
00822                                                                 }
00823                                                                 priorityqueue(packet); // LLAMADA A LA FUNCION DEL METODO DE INSERCION DE PAQUETES DE PRIORIDAD DE COLAS
00824                                                                 break;
00825 
00826                                                         default:
00827                                                                 ev<<" ERROR AL ELEGIR EL METODO DE COLAS, ELEGIR 0 o 1."<<endl;
00828                                                                 delete packet;
00829                                                                 break;
00830                                                 }
00831 */
00832 // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 ////////////////////////////////////////////////////////////////////
00834                                         }
00835                                 }
00836                         }
00837                         break;
00838 
00839                 default:
00840                                 delete msg;
00841                                 break;
00842         }
00843 }

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

Reimplemented from cComponent.

Definition at line 128 of file ONU_GENTraffic.cc.

00129 {
00130         volcado = 0;
00131         contador = 0;
00132         isGateway = 0;
00133         // Inicializacion de las variables (aunque no se vayan a usar):
00134         load_dmb.resize((int)par("numqueue"),0);
00135         onu=0;
00136         sla=0;
00137         tamsumpop.resize((int)par("numqueue"),0);
00138         suma_tam_packets = 0;
00139         total_load = 0.0;
00140         time_creation = 0;
00141         suma_total.resize((int)par("numqueue"),0);
00142         packet_64 = 0;
00143         packet_594 = 0;
00144         packet_1500 = 0;
00145         totalpacket = 0;
00146         //int indiceOnu = this->getParentModule()->getParentModule()->getIndex();
00147         //int pasarelas = this->getParentModule()->getParentModule()->getParentModule()->par("numGW");
00148         if(this->getParentModule()->getParentModule()->gate("gatewirelessInOut$o",0)->isConnected())
00149         {
00150                 isGateway = 1;
00151         }
00152         //ACTIVAR//
00153         if(isGateway == 0) // Si no es pasarela, inicializa fuentes Onu:
00154         {
00155         // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 ///////////////////////////////////////////////////////////////////////
00156                 // COMPARAMOS EL NUMERO DE COLAS O SERVICIOS DE LA ONU
00157                 if((int)par("numqueue")==1)
00158                 {
00159                         // LA ONU SOLO TIENE UN SERVICIO
00160                         load_dmb[getIndex()] = (double)par("node_load"); // VARIABLE CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA
00161                         //ev<<" Carga de los nodos de las ONU: " << load_dmb[getIndex()] << endl;
00162                 }
00163                 else if((int)par("numqueue")>=2)
00164                 {
00165                         // LA ONU TIENE 2 O MAS SERVICIOS
00166                         if(getIndex()==0)
00167                         {
00168                                 // SERVICIO P0
00169                                 //ev<<" Carga de los nodos de las ONU: 0.0448" << endl;
00170                         }
00171                         else if(getIndex()>=1)
00172                         {
00173                                 load_dmb[getIndex()] = (double)par("node_load"); // VARIABLE CARGA DEL NODO DE LA ONU Y LA VISUALIZAMOS POR PANTALLA
00174                                 ev<<" Carga de los nodos de las ONU: "<<load_dmb[getIndex()]<<endl;
00175                         }
00176                 }
00177 
00178                 packetSize = 1500;  // TAMANYO DEL PAQUETE FIJO PARA LA FUENTE SELF SIMILAR VERSION 2
00179                 //packetSize = intuniform(MIN_PACKET_SIZE,MAX_PACKET_SIZE); // TAMANYO DEL PAQUETE VARIABLE ENTRE DOS VALORES PARA LA FUENTE SELF SIMILAR VERSION 2
00180                 int streams = (int)par("numstreamV2_32_128_256"); // NUMERO DE FUENTES O SUB-STREAMS
00181                 int method_generator = (int)par("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 )
00182 
00183                 // COMPARAMOS CON EL SWITCH EL METODO CON EL QUE TRABAJA EL GENERADOR ( MONOMODAL O TRIMODAL )
00184                 switch(method_generator)
00185                 {
00186                         case 0:
00187                                 // MONOMODAL-> 1 SERVICIO
00188                                 pAG =new Generator; // PUNTERO PARA EL GENERADOR
00189                                 for( int src = 0; src < streams; src++ )
00190                                 {
00191                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00192                                 }
00193                                 break;
00194 
00195                         case 1:
00196                                 // TRIMODAL-> 3 SERVICIOS
00197 
00198                                 switch((int)par("numstreamV2_32_128_256"))
00199                                 {
00200                                         case 32:
00201                                                 pAG =new Generator; // PUNTERO PARA EL GENERADOR
00202                                                 // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00203                                                 for( int src = 0; src < streams; src++ )
00204                                                 {
00205                                                         if(src<3)
00206                                                         {
00207                                                                 packetSize = 64;
00208                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00209                                                         }
00210                                                         else if(src>=3 && src<8)
00211                                                         {
00212                                                                 packetSize = 594;
00213                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00214                                                         }
00215                                                         else if(src>=8)
00216                                                         {
00217                                                                 packetSize = 1500;
00218                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00219                                                         }
00220                                                 }
00221                                                 break;
00222 
00223                                         case 128:
00224                                                 pAG =new Generator; // PUNTERO PARA EL GENERADOR
00225                                                 // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00226                                                 for( int src = 0; src < streams; src++ )
00227                                                 {
00228                                                         if(src<12)
00229                                                         {
00230                                                                 packetSize = 64;
00231                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00232                                                         }
00233                                                         else if(src>=12 && src<32)
00234                                                         {
00235                                                                 packetSize = 594;
00236                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00237                                                         }
00238                                                         else if(src>=32)
00239                                                         {
00240                                                                 packetSize = 1500;
00241                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00242                                                         }
00243                                                 }
00244                                                 break;
00245 
00246                                         case 256:
00247                                                 pAG =new Generator; // PUNTERO PARA EL GENERADOR
00248                                                 // MEDIANTE EL BUCLE FOR REPARTIMOS LAS FUENTES O STREAMS PARA GENERAR PAQUETES DE VARIOS TAMANYOS O LONGITUDES
00249                                                 for( int src = 0; src < streams; src++ )
00250                                                 {
00251                                                         if(src<24)
00252                                                         {
00253                                                                 packetSize = 64;
00254                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00255                                                         }
00256                                                         else if(src>=24 && src<64)
00257                                                         {
00258                                                                 packetSize = 594;
00259                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00260                                                         }
00261                                                         else if(src>=64)
00262                                                         {
00263                                                                 packetSize = 1500;
00264                                                                 pAG->AddSource( new SourcePareto( src, 0, packetSize, 0, load_dmb[getIndex()]/streams, 1.4, 1.2 ));
00265                                                         }
00266                                                 }
00267                                                 break;
00268                                 }
00269 
00270                 }
00271 
00272                 //CREAMOS UN AUTOMENSAJE PARA CREAR LOS PAQUETES ETHERNET QUE MANDA LA ONU HACIA EL OLT
00273                 cMessage *msg = new cMessage ("Mensaje inicial"); //ACTIVAR//
00274                 msg->setKind(5); // IDENTIFICADOR DEL AUTOMENSAJE //ACTIVAR//
00275                 scheduleAt(1, msg); //ACTIVAR//
00276         // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 ////////////////////////////////////////////////////////////////////////
00277 
00278         // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 ////////////////////////////////////////////////////////////////////////
00279         /*
00280                 // INICIALIZACION DE LAS VARIABLES DEFINIDAS EN EL ARCHIVO ONU_GENTRAFFIC.H
00281                 load = (int)par("node_load");
00282                 pSRC=new PacketGenerator ( 0, MIN_IFG, MEAN_BURST_SIZE, CreateStream, PacketSize, SUB_STREAMS, load);
00283 
00284                 // CREAMOS UN AUTOMENSAJE PARA CREAR LOS PAQUETES ETHERNET QUE MANDA LA ONU HACIA EL OLT
00285                 cMessage *msg = new cMessage ("mensaje inicial");
00286                 msg->setKind(5); // IDENTIFICADOR DEL AUTOMENSAJE
00287                 scheduleAt(1, msg);
00288         */
00289         // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 //////////////////////////////////////////////////////////////////////////
00290 
00291         //ACTIVAR//
00292         }
00293         else
00294         {
00295                 //ev<<" Esta ONU actua de pasarela con la parte inalambrica" << endl;
00296         }
00297 }

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

Definition at line 908 of file ONU_GENTraffic.cc.

00909 {
00910         // EJECUTAMOS EL METODO DE INSERCION DE PRIORIDAD DE COLAS
00911 
00912         // VARIABLES
00913         double buffer = (double)par("tambuffer"); // TAMANYO TOTAL DEL BUFFER EN BYTES
00914         double bloqueo;
00915 
00916         ETHERNETmsg *ethernetmsg=check_and_cast<ETHERNETmsg*>(msg); // CHEQUEAMOS EL PAQUETE ETHERNET
00917 
00919 
00920         // VARIABLES PARA PODER ENTRAR DESTE ESTE MODULO AL MODULO ONU_SISTQUEUE Y PODER OBTENER INFORMACION SOBRE LAS COLAS
00921         for(int i=0; i<(int)par("numqueue"); i++)
00922         {
00923                 cModule *c_onu_queue;
00924                 c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00925                 onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00926                 suma_total[getIndex()] = suma_total[getIndex()] + onu_queue->tamqueue[i];
00927         }
00928         //ev<<" Suma de los Bytes de los Paquetes que estan insertados en todas las colas de la Red PON: "<<suma_total[getIndex()]<<endl;
00929 
00930         // DAMOS A LA VARIABLE tamsumqueue EL VALOR DE LA SUMA TOTAL DE LOS BYTES QUE HAY EN TODAS LAS COLAS MAS EL TAMANYO DEL MENSAJE QUE GENERA LA FUENTE
00931         tamsumqueue = suma_total[getIndex()] + ethernetmsg->getByteLength();
00932 
00935 
00936         // COMPARAMOS SI EL TAMANYO TOTAL DEL BUFFER ES MAYOR O MENOR QUE LA SUMA DEL TAMANYO DE TODOS LOS PAQUETES QUE LLEGAN A LAS COLAS
00937         if(buffer >= tamsumqueue)
00938         {
00940                 bloqueo = 0.0; //ENVIO PAQUETE
00941                 //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_Rx Y PODER PASARLE LA INFORMACION A LA VARIABLE PLR
00942                 cModule *c_plr;
00943                 c_plr=getParentModule()->getParentModule()->getParentModule()->getSubmodule("olt")->getSubmodule("olt_rx");
00944                 olt_plr=check_and_cast<OLT_Rx *>(c_plr);
00945                 olt_plr->plr.analyze(bloqueo);
00946                 olt_plr->plr_sla[sla].analyze(bloqueo);
00947                 //ev<<" Envio mensaje Ethernet (Id. " << ethernetmsg->getId() << ") al modulo 'ONU_mac'." << endl;
00948                 send(ethernetmsg, "onugenOut", ethernetmsg->getPriority()); // EN ESTE CASO, SE ENVIA EL PAQUETE ETHERNET HACIA LAS COLAS
00949         }
00950         else if(buffer < tamsumqueue)
00951         {
00952                 // EN ESTE CASO, EL PAQUETE NO ENTRA EN LAS COLAS Y TENEMOS QUE ELIMINAR UNO DE MENOR PRIORIDAD PARA INSERTAR EL PAQUETE NUEVO
00953                 // VISUALIZAMOS POR PANTALLA QUE EL TAMANYO DE LA SUMA DE LAS COLAS ES MAYOR QUE EL TAMANYO TOTAL DEL BUFFER
00955 
00956                 // COMPROBAMOS LAS COLAS MENOR A MAYOR PRIORIDAD PARA ELIMINAR UN PAQUETE ANTERIOR PARA INSERTAR EL NUEVO
00957                 //int i = (int)par("numqueue")-1, fuera = -1; ///////
00958                 //while(i>=0 && fuera < 0) ///////
00959                 for(int i=(int)par("numqueue")-1; i>=0; i--)
00960                 {
00961                         // VARIABLES PARA PODER ENTRAR DESTE ESTE MODULO AL MODULO ONU_SISTQUEUE Y PODER OBTENER INFORMACION SOBRE LAS COLAS
00962                         cModule *c_onu_queue;
00963                         c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",i);
00964                         onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00965 
00966                         // COMPARAMOS SI LA PRIORIDAD DEL PAQUETE QUE LLEGA ES LA MAS BAJA O ES DE MAYOR PRIORIDAD
00967                         if(ethernetmsg->getPriority() == i)
00968                         {
00969                                 // SI EL PAQUETE QUE LLEGA ES DE LA MENOR PRIORIDAD, DIRECTAMENTE SE BORRA
00971                                 // RESTAMOS EL TAMANYO DEL PAQUETE QUE SE BORRA A LA SUMA DEL TAMANYO DE LOS PAQUETES QUE LLEGAN A LAS COLAS DE LA ONU Y LO VISUALIZAMOS POR PANTALLA
00973                                 tamsumqueue = tamsumqueue - ethernetmsg->getByteLength();
00975 
00976                                 bloqueo=1.0; //BORRADO PAQUETE
00977 
00978                                 //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_Rx Y PODER PASARLE LA INFORMACION A LA VARIABLE PLR
00979                                 cModule *c_plr;
00980                                 c_plr=getParentModule()->getParentModule()->getParentModule()->getSubmodule("olt")->getSubmodule("olt_rx");
00981                                 olt_plr=check_and_cast<OLT_Rx *>(c_plr);
00982                                 olt_plr->plr.analyze(bloqueo);
00983                                 olt_plr->plr_sla[sla].analyze(bloqueo);
00984                                 //ev<<" BORRADO mensaje Ethernet (Id. " << ethernetmsg->getId() << "). " << endl;
00985                                 delete ethernetmsg; // BORRAMOS EL PAQUETE ETHERNET
00986                                 //fuera = 1; ///////
00987                                 break; // SALIMOS DEL BUCLE FOR
00988                         }
00989                         else if(ethernetmsg->getPriority() < i && onu_queue->queue.getLength()>0)
00990                         {
00991                                 // SI EL PAQUETE QUE LLEGA ES PRIORIDAD MAYOR QUE LA COLA EN LA QUE NOS ENCONTRAMOS.
00992                                 // SI ADEMAS EN NUMERO DE PAQUETES DE ESTA COLA ES MAYOR QUE 0,
00993                                 // BORRAMOS PAQUETES HASTA QUE PODAMOS INSERTAR EL NUEVO PAQUETE
00994 
00995                                 // RECORREMOS TODOS LOS PAQUETES DE LA COLA DESDE EL MAS ANTIGUO PARA ELIMINARLOS Y PODER INSERTAR EL PAQUETE NUEVO
00996                                 //int salir = -1; ///////
00997                                 //while (onu_queue->queue.getLength()>0 && salir < 0) ///////
00998                                 for(int j=0; j<=onu_queue->queue.getLength(); j++)
00999                                 {
01000                                         // LLAMAMOS DE FORMA REMOTA A LA FUNCION ELIMINAR ELEMENTOS IMPLIMENTADA EN EL MODULO ONU_SISTQUEUE
01001                                         onu_queue->deleteelement(ethernetmsg);
01002 
01003                                         // VISUALIZAMOS POR PANTALLA EL TAMANYO DEL PAQUETE QUE VAMOS A ELIMINAR
01004                                         //ev<<" Sacamos el mensaje con longitud "<<onu_queue->tamqueuepop<<"Bytes de la cola "<<i<<" y borramos. Comprobamos si entra el mensaje que llego."<<endl;
01005 
01006                                         // RESTAMOS EL TAMANYO DEL PAQUETE QUE SACAMOS A LA SUMA DEL TAMANYO DE LOS PAQUETES QUE LLEGAN A LAS COLAS
01007                                         tamsumqueue = tamsumqueue - onu_queue->tamqueuepop;
01008                                         //ev<<" Tamanyo Total de la Suma de las Colas-> "<<tamsumqueue<<"Bytes"<<endl;
01009 
01010                                         // SUMA DEL TAMANYO DE LOS PAQUETES QUE SALEN DE LAS COLAS PARA RESTARSELO AL TAMANYO DE CADA COLA Y LO VISULAIZAMOS POR PANTALLA
01011                                         tamsumpop[i] = tamsumpop[i] + onu_queue->tamqueuepop;
01012 
01013                                         // COMPARAMOS SI EL TAMANYO TOTAL DEL BUFFER ES MAYOR QUE LA SUMA DEL TAMANYO DE LOS PAQUETES QUE LLEGAN A LAS COLAS DESPUES DE RESTAR EL PAQUETE ELIMINADO
01014                                         if(buffer > tamsumqueue)
01015                                         {
01016                                                 // SI HAY UN TAMANYO SUFICIENTE EN LA COLA PARA INSERTAR EL NUEVO PAQUETE, LO ENVIAMOS HACIA LAS COLAS
01017                                                 //ev<<" Como Tamanyo Total Buffer "<<buffer<<" > "<<"Tamanyo Total Colas "<<tamsumqueue<<"Bytes"<<". Enviamos el paquete a la cola "<<ethernetmsg->getPriority()<<endl;
01018 
01019                                                 bloqueo=0.0; //ENVIO PAQUETE
01020 
01021                                                 //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_Rx Y PODER PASARLE LA INFORMACION A LA VARIABLE PLR
01022                                                 cModule *c_plr;
01023                                                 c_plr=getParentModule()->getParentModule()->getParentModule()->getSubmodule("olt")->getSubmodule("olt_rx");
01024                                                 olt_plr=check_and_cast<OLT_Rx *>(c_plr);
01025                                                 olt_plr->plr.analyze(bloqueo);
01026                                                 olt_plr->plr_sla[sla].analyze(bloqueo);
01027                                                 //ev<<" Envio mensaje Ethernet (Id. " << ethernetmsg->getId() << ") al modulo 'ONU_mac'." << endl;
01028                                                 send(ethernetmsg, "onugenOut", ethernetmsg->getPriority()); // ENVIAMOS EL PAQUETE ETHERNET HACIA LA COLA CORRESPONDIENTE
01029                                                 //salir = 1; ///////
01030                                                 //fuera = 1; ///////
01031                                                 break;// SALIMOS DEL BUCLE FOR QUE RECORRE LA COLA EN LA QUE ESTAMOS
01032                                         }
01033                                 }
01034                                 // COMPARAMOS SI EL TAMANYO TOTAL DEL BUFFER ES MAYOR QUE LA SUMA DEL TAMANYO DE LOS PAQUETES QUE LLEGAN A LAS COLAS DESPUES DE RESTAR EL PAQUETE ELIMINADO
01035                                 if(buffer > tamsumqueue)
01036                                 {
01037                                         //fuera = 1; ///////
01038                                         break; // SALIMOS DEL BUCLE FOR QUE RECORRE TODAS LAS COLAS
01039                                 }
01040                         }
01041                         //i--; ///////
01042                 }
01043         }
01044 
01045         // DAMOS EL VALOR CERO A LAS DOS VARIABLES PARA PODER HACER LO CALCULOS NECESARIOS EN SIGUIENTES SITUACIONES CORRECTAMENTE
01046         for(int i=0; i<(int)par("numqueue"); i++)
01047         {
01048                 suma_total[i] = 0;
01049         }
01050 
01051         olt_plr->plr_total=olt_plr->plr_total+bloqueo; //SUMATORIO DE LA VARIABLE BLOQUEO
01052         olt_plr->numpaquetes++; //ACTUALIZAMOS EL NUMERO DE PAQUETES ETHERNET
01053 
01054         tamsumqueue = 0;
01055 
01056         if(simTime()>=10*contador) // && volcado == 0)
01057         {
01058                 volcadoFicheros();
01059                 contador++;
01060         }
01061 
01062 }

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

Definition at line 853 of file ONU_GENTraffic.cc.

00854 {
00855         // EJECUTAMOS EL METODO DE INSERCION DE COLAS SEPARADAS
00856         // VARIABLES
00857         double buffer = (double)par("tambuffer"); // TAMANYO TOTAL DEL BUFFER EN BYTES
00858         double bloqueo;
00859         ETHERNETmsg *ethernetmsg=check_and_cast<ETHERNETmsg*>(msg); // CHEQUEAMOS EL PAQUETE ETHERNET
00860         // VARIABLES PARA PODER ENTRAR DESTE ESTE MODULO AL MODULO ONU_SISTQUEUE Y PODER OBTENER INFORMACION SOBRE LAS COLAS
00861         cModule *c_onu_queue;
00862         c_onu_queue = getParentModule()->getParentModule()->getSubmodule("onu_squeue")->getSubmodule("onu_sistqueue",ethernetmsg->getPriority());
00863         onu_queue = check_and_cast<ONU_SISTqueue *>(c_onu_queue);
00864         // VISUALIZAMOS POR PANTALLA EL TAMANYO DE LA COLA DONDE INSERTAREMOS EL MENSAJE CREADO POR LA FUENTE
00865         //ev<<" Longitud de la Cola "<<ethernetmsg->getPriority()<<" donde insertamos paquete"<<"-> "<<onu_queue->tamqueue[ethernetmsg->getPriority()]<<"Bytes"<<endl;
00866         // COMPARAMOS SI EL TAMANYO DEL BUFFER PARA CADA COLA ES MAYOR O MENOR QUE EL TAMANYO DE LA COLA MAS EL TAMANYO DEL MENSAJE ETHERNET
00867         if(buffer/(int)par("numqueue") >= onu_queue->tamqueue[ethernetmsg->getPriority()] + ethernetmsg->getByteLength() )
00868         {
00869                 //ev<<" Como Longitud total Cola "<<buffer/(int)par("numqueue")<<" >= "<<onu_queue->tamqueue[ethernetmsg->getPriority()] + ethernetmsg->getByteLength()<<". Enviamos Paquete."<<endl;
00870                 bloqueo=0.0; //ENVIO PAQUETE
00871                 //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_Rx Y PODER PASARLE LA INFORMACION A LA VARIABLE PLR
00872                 cModule *c_plr;
00873                 c_plr=getParentModule()->getParentModule()->getParentModule()->getSubmodule("olt")->getSubmodule("olt_rx");
00874                 olt_plr=check_and_cast<OLT_Rx *>(c_plr);
00875                 olt_plr->plr.analyze(bloqueo);
00876                 //ev<<" Envio mensaje Ethernet (Id. " << ethernetmsg->getId() << ") al modulo 'ONU_mac'." << endl;
00877                 send(ethernetmsg, "onugenOut", ethernetmsg->getPriority()); // EN ESTE CASO, ENVIAMOS EL PAQUETE ETHERNET HACIA LA COLA CORRESPONDIENTE
00878         }
00879         else if(buffer/(int)par("numqueue") < onu_queue->tamqueue[ethernetmsg->getPriority()] + ethernetmsg->getByteLength() )
00880         {
00881                 //ev<<" Como Longitud total Cola "<<buffer/(int)par("numqueue")<<" < "<<onu_queue->tamqueue[ethernetmsg->getPriority()] + ethernetmsg->getByteLength()<<". Borramos Paquete. Cola LLena"<<endl;
00882                 bloqueo=1.0; //BORRO PAQUETE
00883 
00884                 //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_Rx Y PODER PASARLE LA INFORMACION A LA VARIABLE PLR
00885                 cModule *c_plr;
00886                 c_plr=getParentModule()->getParentModule()->getParentModule()->getSubmodule("olt")->getSubmodule("olt_rx");
00887                 olt_plr=check_and_cast<OLT_Rx *>(c_plr);
00888                 olt_plr->plr.analyze(bloqueo);
00889                 //ev<<" BORRADO mensaje Ethernet (Id. " << ethernetmsg->getId() << ")." << endl;
00890                 delete ethernetmsg; // EN ESTE CASO, BORRAMOS EL MENSAJE ETHERNET YA QUE NO SE PUEDE INSERTAR EN LA COLA AL ESTAR LLENA
00891         }
00892         olt_plr->plr_total=olt_plr->plr_total+bloqueo; //SUMATORIO DE LA VARIABLE BLOQUEO
00893         olt_plr->numpaquetes++; //ACTUALIZAMOS EL NUMERO DE PAQUETES ETHERNET
00894 }

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

Definition at line 1068 of file ONU_GENTraffic.cc.

01069 {
01070         volcado = 1;
01071         // RECOGIDA DE ESTADISTICAS Y LO GUARDAMOS LOS DATOS EN EL ARCHIVO CARGA_PAQUETES
01072         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
01073         carga_paquetes=fopen("results/carga_paquetes.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
01074 
01075                 fprintf(carga_paquetes,"Carga total de la fuente %i de la ONU %i: %g\t", getIndex(), this->getParentModule()->getParentModule()->getIndex(), (double)load_carga.average()); // CARGA DEL NODO DE LA ONU
01076                 fprintf(carga_paquetes,"\n");
01077                 fclose(carga_paquetes); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
01078 
01079         // RECOGIDA DE ESTADISTICAS DE LOS PAQUETES GENERADOS Y LO GUARDAMOS LOS DATOS EN EL ARCHIVO PAQUETES
01080         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
01081         paquetes=fopen("results/paquetes.txt", "a+");
01082                 fprintf(paquetes,"ONU [%i]: Fuente P%i \n", this->getParentModule()->getParentModule()->getIndex(), getIndex());
01083                 fprintf(paquetes,"Total\t");
01084                 fprintf(paquetes,"64 Bytes\t");
01085                 fprintf(paquetes,"594 Bytes\t");
01086                 fprintf(paquetes,"1500 Bytes\n");
01087                 fprintf(paquetes,"%li \t", totalpacket); // SUMA TOTAL DE PAQUETES GENERADOS
01088                 fprintf(paquetes," %li \t", packet_64); // PAQUETES GENERADOS DE 64 BYTES
01089                 fprintf(paquetes," %li \t", packet_594); // PAQUETES GENERADOS DE 594 BYTES
01090                 fprintf(paquetes," %li\t", packet_1500); // PAQUETES GENERADOS DE 1500 BYTES
01091                 fprintf(paquetes,"\n");
01092                 fclose(paquetes); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
01093 }


Member Data Documentation

Definition at line 72 of file ONU_GENTraffic.h.

int ONU_GENTraffic::contador [protected]

Definition at line 131 of file ONU_GENTraffic.h.

Definition at line 87 of file ONU_GENTraffic.h.

Definition at line 71 of file ONU_GENTraffic.h.

Definition at line 83 of file ONU_GENTraffic.h.

Definition at line 84 of file ONU_GENTraffic.h.

Definition at line 85 of file ONU_GENTraffic.h.

Definition at line 108 of file ONU_GENTraffic.h.

Definition at line 119 of file ONU_GENTraffic.h.

Definition at line 118 of file ONU_GENTraffic.h.

Definition at line 117 of file ONU_GENTraffic.h.

Definition at line 82 of file ONU_GENTraffic.h.

Definition at line 81 of file ONU_GENTraffic.h.

FILE* ONU_GENTraffic::paquetes [private]

Definition at line 73 of file ONU_GENTraffic.h.

Definition at line 86 of file ONU_GENTraffic.h.

Definition at line 111 of file ONU_GENTraffic.h.

Definition at line 114 of file ONU_GENTraffic.h.

Definition at line 110 of file ONU_GENTraffic.h.

Definition at line 109 of file ONU_GENTraffic.h.

Definition at line 112 of file ONU_GENTraffic.h.

Definition at line 113 of file ONU_GENTraffic.h.

Definition at line 120 of file ONU_GENTraffic.h.

int ONU_GENTraffic::volcado [protected]

Definition at line 130 of file ONU_GENTraffic.h.

Definition at line 106 of file ONU_GENTraffic.h.


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

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