00001 00002 // PROYECTO FIN DE CARRERA // 00003 // TITULO: Disenyo de nuevas arquitecturas y algoritmos de gestión de recursos en // 00004 // redes de acceso FiWi // 00005 // AUTOR: Ana Emma Lopez Mato // 00006 // TUTOR: Noemi Merayo Alvarez // 00007 // INGENIERIA TECNICA DE TELECOMUNICACIONES, SISTEMAS DE TELECOMUNICACION // 00008 // UNIVERSIDAD DE VALLADOLID // 00010 00011 #include "ONU_GENTraffic.h" 00012 #include "GATE_m.h" 00013 #include "REPORT_m.h" 00014 #include "ETHERNET_m.h" 00015 #include <omnetpp.h> 00016 #include <vector> 00017 #include <time.h> 00018 #include "analysis.h" 00019 #include "ONU_Table.h" 00020 #include "OLT_Rx.h" 00021 /* 00022 * MODULO ONU_GENTraffic: 00023 */ 00024 // DEPENDIENDO DE LA VERSION DE LA FUENTE SELF SIMILAR CON LA QUE QUEREMOS TRABAJAR, DEBEMOS ELEGIR UNAS CABECERAS U OTRAS. 00025 // PARA ELEGIR LA VERSION DE LA FUENTE CON LA QUE QUERAMS TRABAJAR, TENEMOS QUE COMENTAR Y DESCOMENTAR LAS CABECERAS Y 00026 // LO QUE ESTA EN LAS FUNCIONES INITIALIZE() Y HANDLEMESSAGE() PARA CADA VERSION DE LA FUENTE 00027 00028 // FUENTE SELF SIMILAR VERSION 2 ///////////////////////////////// 00029 /* 00030 #include "_types.h" 00031 #include "_util.h" 00032 #include "_rand_MT.h" 00033 #include "_link.h" 00034 #include "trace.h" 00035 #include "aggreg.h" 00036 */ 00037 // FIN DE LA FUENTE VERSION 2////////////////////////////////////////////////////////////////////////////////////////////////////// 00039 00040 // FUENTE SELF SIMILAR VERSION 3 ////////////////////////////////// 00041 /* 00042 #include "trf_gen_v3.h" 00043 #include "avltree.h" 00044 #include "_types.h" 00045 */ 00046 // FIN DE LA FUENTE VERSION 3////////////////////////////////////////////////////////////////////////////////////////////////////// 00048 00049 00050 // GENERAMOS EL CODIGO Y LAS FUNCIONES DEL MODULO SIMPLE 00051 Define_Module(ONU_GENTraffic); 00052 00053 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 ///////////////////////////////////////////////////////////////// 00054 00056 //CONSTRUCTOR--> ESTABLECE LOS MIEMBROS DEL PUNTERO DEL GENERADOR EN NULL. // 00058 ONU_GENTraffic::ONU_GENTraffic() 00059 { 00060 pAG = NULL; // PUNTERO AL GENERADOR DE PAQUETES CON VALOR NULL O VACIO 00061 } 00062 00064 //DESTRUCTOR--> ELIMINA TODO LO QUE FUE ASIGNADO COMO NUEVO EN EL PUNTERO AL GENERADOR DE PAQUETES. // 00066 ONU_GENTraffic::~ONU_GENTraffic() 00067 { 00068 delete pAG; // BORRAMOS EL PUNTERO AL GENERADOR DE PAQUETES 00069 } 00070 00071 // FINAL DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 2 //////////////////////////////////////////////////////////////////// 00073 00074 00075 00076 // INICIO DE CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 //////////////////////////////////////////////////////////////////// 00077 /* 00079 // DEVUELVE LA LLAMADA DE LA FUNCION QUE CREA NUEVOS SUBS.STREAMS CON LA DISTRIBUCION DESEADA. // 00081 00082 Stream* CreateStream( load_t load, float mean_burst,int id ) 00083 { 00084 return new StreamPareto( load, mean_burst, SHAPE_PARETO ); // TIPO DE GENERADOR DE TRAFICO DE PARETO. 00085 //return new StreamExpon( load, mean_burst ) ; // TIPO DE GENERACION DE TRAFICO EXPONENCIAL 00086 00087 } 00088 00090 // DEVUELVE LA LLAMADA DE LA FUNCION QUE GENERA LOS TAMANYOS DE LOS PAQUETES CON LA DISTRIBUCION DESEADA. // 00092 pckt_size_t PacketSize( void ) // TAMANYO DEL PAQUETE A GENERAR 00093 { 00094 long int packetSize = (long int) 1500; // TAMANYO DEL PAQUETE FIJO = 1500 BYTES 00095 //int packetSize = intuniform(MIN_PACKET_SIZE,MAX_PACKET_SIZE); // TAMANYO DEL PAQUETE DEFINIDO EN EL ARCHIVO ONU_GENTRAFFIC.H 00096 00097 return (pckt_size_t)(packetSize); // DEVUELVE EL TAMANYO DEL PAQUETE SELECCIONADO 00098 } 00099 00101 //CONSTRUCTOR--> ESTABLECE LOS MIEMBROS DEL PUNTERO DEL GENERADOR EN NULL. // 00103 ONU_GENTraffic::ONU_GENTraffic() 00104 { 00105 pSRC=NULL; // PUNTERO AL GENERADOR DE PAQUETES CON VALOR NULL O VACIO 00106 } 00107 00109 //DESTRUCTOR--> ELIMINA TODO LO QUE FUE ASIGNADO COMO NUEVO EN EL PUNTERO AL GENERADOR DE PAQUETES. // 00111 ONU_GENTraffic::~ONU_GENTraffic() 00112 { 00113 delete pSRC; // BORRAMOS EL PUNTERO AL GENERADOR DE PAQUETES 00114 } 00115 */ 00116 // FINAL DEL CODIGO PARA LA FUENTE SELF SIMILAR VERSION 3 /////////////////////////////////////////////////////////////////////// 00118 00119 00120 00121 00123 //FUNCION INITIALIZE()--> ESTA FUNCION SE INVOCA DESPUES DE QUE OMNET++ HA PUESTO EN MARCHA LA RED, EN LA CUAL SE LEEN LOS // 00124 // PARAMETROS DEL MODULO Y SE INICIALIZAN TODAS DAS LAS VARIABLES DECLARADAS PARA ESTE MODULO SIMPLE, SE // 00125 // ASIGNAN ESTRUCTURAS DE DATOS DINAMICOS Y SE ASIGNAN E INICIALIZAN LOS AUTOMENSAJES SI SON NECESARIOS // 00126 // PARA EL FUNCIONAMIENTO DE ESTE MODULO. // 00128 void ONU_GENTraffic::initialize() 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 } 00298 00300 //FUNCION HANDLEMESSAGE(CMESSAGE *MSG)--> ESTA FUNCION SE INVOCA CON EL MENSAJE COMO PARAMETRO CADA VEZ QUE EL MODULO RECIBE UN // 00301 // UN MENSAJE O PAQUETE. SE RECORRE EL CODIGO IMPLEMENTADO PARA DEVOLVER UN VALOR O // 00302 // EJECUTAR UNA FUNCION DENTRO DEL MODULO SIMPLE. EL TIEMPO DE SIMULACION NO TRANSCURRE // 00303 // DENTRO DE LA LLAMADA DE LA FUNCION HANDLEMESSAGE(CMESSAGE *MSG) MIENTRAS RECORRE EL // 00304 // CODIGO IMPLEMENTADO. // // 00306 void ONU_GENTraffic::handleMessage(cMessage *msg) 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 } 00844 00846 //FUNCION SEPARATEQUEUE(cMessage *msg)--> FUNCION SE INVOCA CUANDO EL GENERADOR DE LA ONU CREA UN PAQUETE ETHERNET Y LO MANDA // 00847 // HACIA LAS COLAS DONDE SE INSERTAN MIENTRAS SE LE ASIGNA UN ANCHO DE BANDA PARA TRANSMITIR. // 00848 // ESTA FUNCION INSERTA LOS PAQUETES EN LA COLA CORRESPONDIENTE DESPUES DE COMPROBAR SI HAY ESPACIO EN DICHAS // 00849 // COLAS, SINO HAY ESPACIO LIBRE BORRA EL PAQUETE GENERADO ANTES DE SER ENVIADO A LA COLA. EL TAMANYO DE LAS // 00850 // COLAS SE DEFINE MEDIANTE UN TAMANYO TOTAL DE BUFFER QUE SE REPARTE ENTRE EL NUMERO DE COLAS QUE SE DEFINEN // 00851 // EN LA RED. EL BUFFER SE MIDE EN BYTES. // 00853 void ONU_GENTraffic::separatequeue(cMessage *msg) 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 } 00895 00897 //FUNCION PRIORITYQUEUE(cMessage *msg)--> FUNCION SE INVOCA CUANDO EL GENERADOR DE LA ONU CREA UN PAQUETE ETHERNET Y LO MANDA // 00898 // HACIA LAS COLAS DONDE SE INSERTAN MIENTRAS SE LE ASIGNA UN ANCHO DE BANDA PARA TRANSMITIR. // 00899 // ESTA FUNCION INSERTA LOS PAQUETES EN LA COLA CORRESPONDIENTE DESPUES DE COMPROBAR SI HAY ESPACIO EN EL // 00900 // BUFFER TOTAL. SINO HAY ESPACIO LIBRE EN EL BUFFER, SE BORRA UN PAQUETE DE LA COLA DE PRIORIDAD MAS BAJA Y SE// 00901 // INSERTA EL PAQUETE EN LA COLA CORRESPONDIENTE. SI AL BORRAR EL PAQUETE DE LA COLA DE PRIORIDAD MENOR NO SE // 00902 // PUEDE INSERTAR EL PAQUETE GENERADO, Y EN LA COLA DE MENOR PRIORIDAD NO HAY MAS PAQUETES PARA ELIMINAR, SE // 00903 // BORRA UN PAQUETE DE LA COLA DE PRIORIDAD INMEDIATAMENTE SUPERIOR A LA MAS BAJA Y DESPUES SE INSERTA EL // 00904 // PAQUETE SI YA HAY SITIO EN EL BUFFER. SI EL PAQUETE FUERA DE PRIORIDAD MENOR, SE BORRARIAN PAQUETES // 00905 // ANTERIORES DE DICHA COLA HASTA QUE SE PUEDA INSERTAR EL PAQUETE GENERADO.EL TAMANYO DEL BUFFER EN BYTES ES // 00906 // GLOBAL PARA TODAS LAS COLAS YA QUE SE COMPARA CON LAS SUMA DE TODOS LOS PAQUETES GENERADOS EN BYTES. // 00908 void ONU_GENTraffic::priorityqueue(cMessage *msg) 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 } 01063 01065 //FUNCION VOLCADOFICHEROS()--> ESCRIBE EN UNO O VARIOS FICHEROS DE TEXTO LOS DATOS DE MAYOR INTERES DE LA / 01066 // SIMULACION, PARA SU POSTERIOR ANALISIS. / 01068 void ONU_GENTraffic::volcadoFicheros() 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 } 01094 01096 //FUNCION FINISH()--> ESTA FUNCION SE INVOCA CUANDO LA SIMULACION HA TERMINADO CON EXITO SIN QUE SE PRODUZCA NINGUN ERROR. // 01097 // LO USAMOS PARA LA RECOGIDA DE ESTADISTICAS Y VISUALIZACION POR PANTALLA O MEDIANTE UN ARCHIVO. // 01099 void ONU_GENTraffic::finish() 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 }