OLT_Rx Class Reference

#include <OLT_Rx.h>

Inheritance diagram for OLT_Rx:

cSimpleModule cModule cComponent cDefaultList cNoncopyableOwnedObject cOwnedObject noncopyable cNamedObject cObject

List of all members.

Public Member Functions

virtual void volcadoFicheros ()
virtual void finish ()

Public Attributes

Analysis retardo_inalambrico
Analysis retardo_optico
Analysis plr
double numpaquetes
double plr_total
MAC_OLTmac_olt
double_vector_t var_Mbps
double_vector_t cont_var
std::vector< Analysisdesviacion
std::vector< Analysisplr_sla
double_vector_t throughput_sla
int cont_aux
int contador
double_vector_t total_bits_sla
int volcado

Protected Member Functions

virtual void initialize ()
virtual void handleMessage (cMessage *msg)

Protected Attributes

long double throughput
long double total_bits
double total_bits_throughput
long double total_bits_report
long double throughput_report
double total_bits_throughput_report
long double throughput_cabecera
long double total_bits_cabecera
double total_bits_throughput_cabecera
long double B_guarda
long double B_guarda_total
long double total_bw_perdido_bits
long double total_time_perdido
double media

Private Attributes

std::vector< Analysisretardo_global_P
std::vector< Analysiscarga_onu
analysis_matrix_t carga_prioridades
std::vector< Analysisretardo_sla
std::vector< std::vector
< Analysis > > 
retardo_servicios_sla
std::vector< Analysismedia_bytes_total_onus
FILE * retardo_analisis_sla
FILE * retardo_analisis
FILE * media_total_onu
FILE * tamano_throughput
FILE * plr_file
FILE * varianza
FILE * tamano_throughput_sla
FILE * retardo_total
FILE * carga_onus
FILE * carga_prioridades_onus
int_vector_t num_sla
simtime_t_vector_t retardo_P
simtime_t_vector_t retardo
double numReceived
long WirelessRx
long OpticalRx
double_vector_t TotalBytes
double_matrix_t PriorityBytes
double OpticalBytes
double WirelessBytes
double carga_cola
double carga_prioridad
int onus
int prioridades
simtime_t delay
simtime_t delay_opt
simtime_t delay_wir
int_vector_t tam_packet_queue


Detailed Description

Definition at line 33 of file OLT_Rx.h.


Member Function Documentation

void OLT_Rx::finish (  )  [virtual]

Reimplemented from cComponent.

Definition at line 673 of file OLT_Rx.cc.

00674 {
00675         // VISUALIZAMOS POR PANTALLA LA RECOGIDA DE ESTADISTICAS MANUAL CUANDO LLAMAMOS A LA FUNCION FINISH()
00676         ev<<" OLT " << endl;
00677         ev<<" Paquetes Ethernet Totales Recibidos: " << numReceived << endl;
00678         volcadoFicheros();
00679 }

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

Reimplemented from cSimpleModule.

Definition at line 103 of file OLT_Rx.cc.

00104 {
00105         // VARIABLES
00106         int type = msg->getKind(); // VARIABLE TYPE PARA IDENTIFICAR LOS MENSAJES DE LA RED
00107         long size;
00108         long size_throughput;
00109         long size_cabecera;
00110         double T_guarda = 0.000001; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS (CAMBIAR DE MANERA MANUAL)
00111         double T_guarda_bits;
00112 
00113         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA LOS MENSAJES QUE LLEGUEN A ESTE MODULO
00114         switch(type)
00115         {
00116                 case 1:
00117                         // LLEGA UN PAQUETE ETHERNET CON IDENTIFICADOR = 1
00118                         if(msg->getKind()==1)
00119                         {
00120                                 ETHERNETmsg *ethernetmsg=check_and_cast<ETHERNETmsg*>(msg); // CHEQUEAMOS EL PAQUETE ETHERNET
00121                                 // VARIABLES
00122                                 int id_servicio = ethernetmsg->getId_servicio(); // PARAMETRO QUE INDICA EL IDENTIFICADOR DEL SERVICIO DE LA ONU
00123                                 int numero_sla = num_sla[ethernetmsg->getSrcAddress()]; // PARAMETRO QUE INDICA EL IDENTIFICADOR DEL SLA ASOCIADO A LA ONU
00124                                 double tx_rate = 0.0, bit_rate = 0.0, time_creation = 0.0;
00125                                 // Si el mensaje Ethernet recibido es de prioridad P0 o P1, controlamos su retardo:
00126                                 if(ethernetmsg->getPriority()<2)
00127                                 {
00128                                         double aux_delay = SIMTIME_DBL(simTime() - ethernetmsg->getTimestamp());
00129                                         mac_olt=check_and_cast<MAC_OLT *>(getParentModule()->getSubmodule("olt_mac"));
00130                                         mac_olt->delay_onu[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] += aux_delay;
00131                                         mac_olt->paq_onu[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()]++;
00132                                         //ev<<" Paquetes recibidos de esa ONU y esa prioridad en este ciclo de transmision: " << mac_olt->paq_onu[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] << endl;
00133                                         //ev<<" Retardo total de estos paquetes: " << mac_olt->delay_onu[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] << endl;
00134                                 }
00135                                 // Para el algoritmo DaSPID, se cambia la disposicion de las ONUs en los SLAs:
00136                                 // Tambien para el IPACT normal, porque vamos a hacer pruebas para compararlos:
00137                                 if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==4 || (int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==1)
00138                                 {
00139                                         if(ethernetmsg->getSrcAddress()<2)
00140                                         {
00141                                                 throughput_sla[0]=throughput_sla[0]+ethernetmsg->getByteLength();
00142                                         }
00143                                         else if(ethernetmsg->getSrcAddress()>=2 && ethernetmsg->getSrcAddress()<8)
00144                                         {
00145                                                 throughput_sla[1]=throughput_sla[1]+ethernetmsg->getByteLength();
00146                                         }
00147                                         else if(ethernetmsg->getSrcAddress()>=8 && ethernetmsg->getSrcAddress()<16)
00148                                         {
00149                                                 throughput_sla[2]=throughput_sla[2]+ethernetmsg->getByteLength();
00150                                         }
00151                                 }
00152                                 else
00153                                 {
00154                                         if(ethernetmsg->getSrcAddress()==0)
00155                                         {
00156                                                 throughput_sla[0]=throughput_sla[0]+ethernetmsg->getByteLength();
00157                                         }
00158                                         else if(ethernetmsg->getSrcAddress()>=1 && ethernetmsg->getSrcAddress()<=5)
00159                                         {
00160                                                 throughput_sla[1]=throughput_sla[1]+ethernetmsg->getByteLength();
00161                                         }
00162                                         else if(ethernetmsg->getSrcAddress()>=6 && ethernetmsg->getSrcAddress()<=15)
00163                                         {
00164                                                 throughput_sla[2]=throughput_sla[2]+ethernetmsg->getByteLength();
00165                                         }
00166                                 }
00167                                 if(simTime()>=50*cont_aux)
00168                                 //if(simTime()>=1000*cont_aux)
00169                                 {
00170                                         cont_aux++;
00171                                         total_bits_sla[0]=throughput_sla[0]*8/simTime();
00172                                         total_bits_sla[1]=throughput_sla[1]*8/simTime();
00173                                         total_bits_sla[2]=throughput_sla[2]*8/simTime();
00174 
00175                                         //FICHERO PARA LA RECOGIDA DE LOS DATOS ESTADASTICOS DE LA MODULACION WDM
00176                                         //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00177                                         tamano_throughput_sla=fopen("results/tamano_throughput_slas.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00178                                         fprintf(tamano_throughput_sla,"%g\t" , (double)total_bits_sla[0]);
00179                                         fprintf(tamano_throughput_sla,"\t");
00180                                         fprintf(tamano_throughput_sla,"%g\t" , (double)total_bits_sla[1]);
00181                                         fprintf(tamano_throughput_sla,"\t");
00182                                         fprintf(tamano_throughput_sla,"%g\t" , (double)total_bits_sla[2]);
00183                                         fprintf(tamano_throughput_sla,"\n");
00184 
00185                                         fclose(tamano_throughput_sla); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00186                                 }
00187                                 size = ethernetmsg->getByteLength(); //RECOGEMOS EL TAMANYO DE LOS PAQUETES ETHERNET RECIBIDOS
00188                                 throughput = throughput+size; //ACTUALIZAMOS LA SUMA DE TODOS LOS PAQUETES ETHERNET
00189 
00190                                 size_cabecera=size-38; //AL PAQUETE ETHERNET QUE RECIBIMOS LE QUITAMOS LOS 38 BYTES DE CABECERA
00191                                 throughput_cabecera = throughput_cabecera+size_cabecera; //ACTUALIZAMOS LA SUMA DE LOS PAQUETES ETHERNET SIN CABECERA
00192 
00195 
00196                                 //COMPARAMOS EL TIEMPO DE SIMULACION CON EL VALOR 1 (SE EMPIEZAN A CREAR LOS PAQUETES ETHERNET) PARA EMPEZAR A COGER ESTADASTICAS MANUALMENTE Y CON LA CLASE ANALISIS
00197                                 if(simTime()>=1)
00198                                 {
00199                                         // RECOGIDA DE ESTADISTICAS DEL RETARDO GLOBAL CON LA CLASE ANALISIS PARA TODAS LAS CLASES DE SERVICIOS
00200                                           retardo_P[id_servicio] = simTime() - ethernetmsg->getTime_enter_queue(); // PARAMETRO PARA CALCULAR EL RETARDO CON LA CLASE ANALISIS
00201                                           retardo_global_P[id_servicio].analyze(SIMTIME_DBL(retardo_P[id_servicio])); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00202 
00203                                         // RECOGEMOS LAS ESTADISTICAS DEL RETARDO POR SLA CON LA CLASE ANALISIS
00204                                         // COMPARAMOS SI ES DE POLLING O CENTRALIZADO YA QUE SOLO SE TRABAJA CON LOS SLAs EN EL ALGORITMO CENTRALIZADO DMB
00205                                         if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==0)
00206                                         //if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==0)
00207                                         {
00208                                                 // RECOGEMOS LAS ESTADASTICAS DEL RETARDO POR SLA CON LA CLASE ANALISIS
00209                                                 retardo[numero_sla] =  simTime() - ethernetmsg->getTime_enter_queue(); // PARAMETRO PARA CALCULAR EL RETARDO CON LA CLASE ANALISIS
00210                                                 retardo_sla[numero_sla].analyze(SIMTIME_DBL(retardo[numero_sla])); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00211                                                 retardo_servicios_sla[numero_sla][id_servicio].analyze(SIMTIME_DBL(retardo_P[id_servicio])); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00212                                         }
00213                                         else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==2)
00214                                         //else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==2)
00215                                         {
00216                                                 // RECOGEMOS LAS ESTADASTICAS DEL RETARDO POR SLA CON LA CLASE ANALISIS
00217                                                 retardo[numero_sla] =  simTime() - ethernetmsg->getTime_enter_queue(); // PARAMETRO PARA CALCULAR EL RETARDO CON LA CLASE ANALISIS
00218                                                 retardo_sla[numero_sla].analyze(SIMTIME_DBL(retardo[numero_sla])); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00219                                                 retardo_servicios_sla[numero_sla][id_servicio].analyze(SIMTIME_DBL(retardo_P[id_servicio])); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00220                                         }
00221                                 }
00222 
00223                                 TotalBytes[ethernetmsg->getSrcAddress()] = TotalBytes[ethernetmsg->getSrcAddress()] + (double) ethernetmsg->getByteLength();
00224                                 PriorityBytes[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] = PriorityBytes[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] + (double) ethernetmsg->getByteLength();
00225                                 tx_rate = (double) this->getParentModule()->par("txrate");
00226                                 bit_rate = tx_rate/10;
00227                                 time_creation = (double) SIMTIME_DBL(simTime());
00228                                 carga_cola = (double) (TotalBytes[ethernetmsg->getSrcAddress()] * 8 / (time_creation * bit_rate));
00229                                 carga_prioridad = (double) (PriorityBytes[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()] * 8 / (time_creation * bit_rate));
00230                                 carga_onu[ethernetmsg->getSrcAddress()].analyze(carga_cola);
00231                                 carga_prioridades[ethernetmsg->getSrcAddress()][ethernetmsg->getPriority()].analyze(carga_prioridad);
00232                                 numReceived++; // INCREMENTAMOS EN UNO EL CONTADOR DE NUMERO DE PAQUETES ETHERNET RECIBIDOS
00233                                 if(ethernetmsg->getIsWireless() == 1)
00234                                 {
00235                                         WirelessRx++;
00236                                         WirelessBytes = WirelessBytes + (double) ethernetmsg->getByteLength();
00237                                         // Retardo extremo a extremo
00238                                         delay_wir = simTime() - ethernetmsg->getTimestamp();
00239                                         retardo_inalambrico.analyze(SIMTIME_DBL(delay_wir));
00240                                 }
00241                                 else if(ethernetmsg->getIsWireless() == 0)
00242                                 {
00243                                         OpticalRx++;
00244                                         OpticalBytes = OpticalBytes + (double) ethernetmsg->getByteLength();
00245                                         delay_opt = simTime() - ethernetmsg->getTimestamp();
00246                                         retardo_optico.analyze(SIMTIME_DBL(delay_opt));
00247                                 }
00248                                 if(ethernetmsg->getIsWireless()==1)
00249                                 {
00250                                         ev<<" Paquete Ethernet de origen inalambrico Recibido y Borrado."<<endl;
00251                                         //ev<<" Tiempo transcurrido desde el origen al destino: " << delay_wir << "s." << endl;
00252                                 }
00253                                 else
00254                                 {
00255                                         //ev<<" Paquete Ethernet de la ONU[" << ethernetmsg->getSrcAddress() << "] (Id. " << ethernetmsg->getId() << ") de prioridad P" << ethernetmsg->getPriority() << " recibido y borrado." << endl;
00256                                         //ev<<" Tiempo transcurrido desde el origen al destino: " << delay_opt << "s." << endl;
00257                                 }
00258                                 delete ethernetmsg; // BORRAMOS LOS PAQUETES ETHERNET
00260                                 //ev<<" Paquete Ethernet Recibido y Borrado."<<endl;
00261 
00262                                 // COMPARAMOS SI EL NUMERO DE ITERACCIONES ES MAYOR O IGUAL UN CIERTO NUMERO, O QUE LA FUNCION ANALISIS CONVERJA
00263                                 if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==0)
00264                                 //if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==0)
00265                                 {
00266                                         // METODO CENTRALIZADO O DMB
00267                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00268                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00269                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00270                                         // retardo_global_P[] -> RETARDO GLOBAL DE CADA SERVICIO
00271                                         // retardo_sla[] -> RETARDO GLOBAL DE CADA SLA
00272                                         // retardo_servicios_sla[][] -> RETARDO DE CADA SERVICIO ASOCIADO A CADA SLA
00273 
00274                                         if( retardo_global_P[0].number_iterations() >= 30 && retardo_sla[0].number_iterations() >= 30)// TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged() && retardo_sla[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00275                                         {
00276                                                 total_bits=throughput*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET LA PASAMOS A BITS
00277                                                 total_bits_throughput=total_bits/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00278 
00279                                                 total_bits_cabecera=throughput_cabecera*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET SIN LA CABECERA LA PASAMOS A BITS
00280                                                 total_bits_throughput_cabecera=total_bits_cabecera/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00281 
00282                                                 total_bits_report=throughput_report*8; //LA SUMA EN BYTES DE LOS PAQUETES REPORT SIN LA CABECERA LA PASAMOS A BITS
00283                                                 total_bits_throughput_report=total_bits_report/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00284 
00285                                                 B_guarda_total=B_guarda/simTime();
00286 
00287                                                 total_time_perdido=total_bw_perdido_bits/simTime();
00288 
00289                                                 media=plr_total/numpaquetes; //VALOR MEDIO DE PLR, ENTRE 0 Y 1
00290 
00291                                                 endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00292                                                 callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00293                                         }
00294                                 }
00295                                 else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==1)
00296                                 //else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==1)
00297                                 {
00298                                         // METODO DE POLLING O IPACT
00299                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00300                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00301                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00302                                         // retardo_global_P[] -> RETARDO GLOBAL DE CADA SERVICIO
00303                                         if( retardo_global_P[0].number_iterations() >= 30 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00304                                         {
00305                                                 total_bits=throughput*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET LA PASAMOS A BITS
00306                                             total_bits_throughput=total_bits/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00307 
00308                                                 total_bits_cabecera=throughput_cabecera*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET SIN LA CABECERA LA PASAMOS A BITS
00309                                                 total_bits_throughput_cabecera=total_bits_cabecera/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00310 
00311                                                 total_bits_report=throughput_report*8; //LA SUMA EN BYTES DE LOS PAQUETES REPORT SIN LA CABECERA LA PASAMOS A BITS
00312                                                 total_bits_throughput_report=total_bits_report/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00313 
00314                                                 B_guarda_total=B_guarda/simTime();
00315 
00316                                                 total_time_perdido=total_bw_perdido_bits/simTime();
00317 
00318                                                 media=plr_total/numpaquetes; //VALOR MEDIO DE PLR, ENTRE 0 Y 1
00319 
00320                                                 endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00321                                                 callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00322                                         }
00323                                         if(simTime() >= 5000)
00324                                         {
00325                                                 endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00326                                                 callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00327                                         }
00328                                 }
00329                                 else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==2)
00330                                 //else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==2)
00331                                 {
00332                                         // METODO DE WDM
00333                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00334                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00335                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00336                                         // retardo_global_P[] -> RETARDO GLOBAL DE CADA SERVICIO
00337                                         //if( retardo_global_P[0].number_iterations() >= 15 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00338                                         //if( retardo_global_P[0].number_iterations() >= 20 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00339                                         if( retardo_sla[0].number_iterations() >= 20 &&  retardo_sla[1].number_iterations() >= 20 && retardo_sla[2].number_iterations() >= 20)
00340                                         {
00341                                                     total_bits=throughput*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET LA PASAMOS A BITS
00342                                                     total_bits_throughput=total_bits/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00343 
00344                                                         total_bits_cabecera=throughput_cabecera*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET SIN LA CABECERA LA PASAMOS A BITS
00345                                                         total_bits_throughput_cabecera=total_bits_cabecera/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00346 
00347                                                         total_bits_report=throughput_report*8; //LA SUMA EN BYTES DE LOS PAQUETES REPORT SIN LA CABECERA LA PASAMOS A BITS
00348                                                         total_bits_throughput_report=total_bits_report/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00349 
00350                                                         B_guarda_total=B_guarda/simTime();
00351 
00352                                                         total_time_perdido=total_bw_perdido_bits/simTime();
00353 
00354                                                         media=plr_total/numpaquetes; //VALOR MEDIO DE PLR, ENTRE 0 Y 1
00355 
00356                                                     endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00357                                                         callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00358                                         }
00359                                 }
00360                                 else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==3)
00361                                 //else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==3)
00362                                 {
00363                                         // METODO DE POLLING CON PID
00364                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00365                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00366                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00367                                         // retardo_global_P[] -> RETARDO GLOBAL DE CADA SERVICIO
00368                                         //if( retardo_global_P[0].number_iterations() >= 15 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00369                                         //if( retardo_global_P[0].number_iterations() >= 20 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00370                                         //if( retardo_sla[0].number_iterations() >= 20 &&  retardo_sla[1].number_iterations() >= 20 && retardo_sla[2].number_iterations() >= 20)
00371                                         
00372                                         if(simTime()>=2000)
00373                                         {
00374                                                          total_bits=throughput*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET LA PASAMOS A BITS
00375                                                          total_bits_throughput=total_bits/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00376 
00377                                                          total_bits_cabecera=throughput_cabecera*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET SIN LA CABECERA LA PASAMOS A BITS
00378                                                          total_bits_throughput_cabecera=total_bits_cabecera/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00379 
00380                                                          total_bits_report=throughput_report*8; //LA SUMA EN BYTES DE LOS PAQUETES REPORT SIN LA CABECERA LA PASAMOS A BITS
00381                                                          total_bits_throughput_report=total_bits_report/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00382 
00383                                                          B_guarda_total=B_guarda/simTime();
00384 
00385                                                          total_time_perdido=total_bw_perdido_bits/simTime();
00386 
00387                                                          media=plr_total/numpaquetes; //VALOR MEDIO DE PLR, ENTRE 0 Y 1
00388 
00389                                                          for(int i=0; i<(int)par("numSLA"); i++)
00390                                                          {
00391                                                                  //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO MAC_OLT Y PODER PASARLE LA INFORMACION A LAS VARIABLES
00392                                                                  mac_olt=check_and_cast<MAC_OLT *>(getParentModule()->getSubmodule("olt_mac"));
00393                                                                  var_Mbps[i]=mac_olt->var_Mbps[i];
00394                                                                  cont_var[i]=mac_olt->cont_var[i];
00395                                                                  desviacion[i]=mac_olt->desviacion[i];
00396                                                         }
00397                                                          endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00398                                                          callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00399                                         }
00400                                 }
00402                                 else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==4)
00403                                 {
00404                                         // METODO DE POLLING CON DaSPID (Delay-aware SLA PID)
00405                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00406                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00407                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00408                                         // retardo_global_P[] -> RETARDO GLOBAL DE CADA SERVICIO
00409                                         //if( retardo_global_P[0].number_iterations() >= 15 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00410                                         //if( retardo_global_P[0].number_iterations() >= 20 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//retardo_global_P[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00411                                         //if( retardo_sla[0].number_iterations() >= 20 &&  retardo_sla[1].number_iterations() >= 20 && retardo_sla[2].number_iterations() >= 20)
00412 
00413                                         if(simTime()>=2000)
00414                                         {
00415                                                          total_bits=throughput*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET LA PASAMOS A BITS
00416                                                          total_bits_throughput=total_bits/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00417 
00418                                                          total_bits_cabecera=throughput_cabecera*8; //LA SUMA EN BYTES DE LOS PAQUETES ETHERNET SIN LA CABECERA LA PASAMOS A BITS
00419                                                          total_bits_throughput_cabecera=total_bits_cabecera/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00420 
00421                                                          total_bits_report=throughput_report*8; //LA SUMA EN BYTES DE LOS PAQUETES REPORT SIN LA CABECERA LA PASAMOS A BITS
00422                                                          total_bits_throughput_report=total_bits_report/simTime(); //CALCULAMOS LOS GIGABIT POR SEGUNDO
00423 
00424                                                          B_guarda_total=B_guarda/simTime();
00425 
00426                                                          total_time_perdido=total_bw_perdido_bits/simTime();
00427 
00428                                                          media=plr_total/numpaquetes; //VALOR MEDIO DE PLR, ENTRE 0 Y 1
00429 
00430                                                          for(int i=0; i<(int)par("numSLA"); i++)
00431                                                          {
00432                                                                  //VARIABLES PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO MAC_OLT Y PODER PASARLE LA INFORMACION A LAS VARIABLES
00433                                                                  mac_olt=check_and_cast<MAC_OLT *>(getParentModule()->getSubmodule("olt_mac"));
00434                                                                  var_Mbps[i]=mac_olt->var_Mbps[i];
00435                                                                  cont_var[i]=mac_olt->cont_var[i];
00436                                                                  desviacion[i]=mac_olt->desviacion[i];
00437                                                         }
00438                                                          endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00439                                                          callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00440                                         }
00441                                 }
00442 
00443                                 /*
00444                                 if(simTime()>=10*contador && volcado == 0)
00445                                 {
00446                                         contador++;
00447                                         //volcadoFicheros();
00448                                         carga_onus = fopen("results/carga_onus.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00449                                                 for(int i=0; i<onus; i++)
00450                                                 {
00451                                                         fprintf(carga_onus, "Carga ONU %i: %g\n", i, (double)carga_onu[i].average());
00452                                                 }
00453                                                 fprintf(carga_onus,"\n");
00454                                                 fclose(carga_onus); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00455 
00456                                         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00457                                         carga_prioridades_onus = fopen("results/carga_prioridades_onus.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00458                                                 for(int i=0; i<onus; i++)
00459                                                 {
00460                                                         fprintf(carga_prioridades_onus, "ONU[%i]:\n",i);
00461                                                         for(int j=0; j<prioridades; j++)
00462                                                         {
00463                                                                 fprintf(carga_prioridades_onus, "\tCarga cola P%i: %g\n", j, (double)carga_prioridades[i][j].average());
00464                                                         }
00465                                                 }
00466                                                 fprintf(carga_prioridades_onus,"\n");
00467                                                 fclose(carga_prioridades_onus); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00468                                 }
00469                                 */
00470                         }
00471                         break;
00472 
00473                 case 2:
00474                         // LLEGA UN PAQUETE REPORT CON IDENTIFICADOR = 2
00475                         if(msg->getKind()==2)
00476                         {
00477                                 REPORTmsg *reportmsg=check_and_cast<REPORTmsg*>(msg);
00478 
00479                                 num_sla[reportmsg->getSrcAddress()] = reportmsg->getNumsla(); // GUARDAMOS EN EL VECTOR num_sla[] EL IDENTIFICADOR DEL SLA Y LO VISUALIZAMOS POR PANTALLA
00480                                 //ev<<" Numero del SLA asociado a la ONU"<<reportmsg->getSrcAddress()<<": SLA"<<num_sla[reportmsg->getSrcAddress()]<<endl;
00481 
00482                                 size_throughput = reportmsg->getByteLength(); //RECOGEMOS EL TAMANYO DE LOS PAQUETES REPORT RECIBIDOS
00483                                 throughput_report = throughput_report+size_throughput; //ACTUALIZAMOS LA SUMA DE TODOS LOS PAQUETES ETHERNET
00484 
00485                                 T_guarda_bits=T_guarda*1000000000;
00486                                 B_guarda=B_guarda+T_guarda_bits;
00487 
00488                                 total_bw_perdido_bits=total_bw_perdido_bits+reportmsg->getBand();
00489 
00490                                 // COGEMOS LAS ESTADASTICAS DE LA MEDIA DE TODAS LAS ONUS CUANDO EL TIEMPO DE SIMULACION SEA MAYOR O IGUAL A 1
00491                                 if(simTime()>=1)
00492                                 {
00493                                         // RECORREMOS EL BUCLE FOR PARA GUARDAR EN EL VECTOR tam_packet_queue[] LOS BYTES QUE QUEDAN EN CADA COLA DESPUES DE CADA CICLO
00494                                         for(int i=0; i<prioridades; i++)
00495                                         {
00496                                                 tam_packet_queue[i] = reportmsg->getQueue_estado(i); // GUARDAMOS LOS BYTES QUE QUEDAN EN CADA COLA DESPUES DE CADA CICLO
00497                                                 media_bytes_total_onus[i].analyze(tam_packet_queue[i]); // RECOGEMOS EL RESULTADO CON LA CLASE ANALISIS
00498                                         }
00499 
00500                                         // PONEMOS EL SIGUIENTE CODIGO PARA QUE SE PARE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00501                                         // TENEMOS QUE MODIFICAR MANUALMENTE LAS VARIABLES QUE QUEREMOS QUE LLEGUEN A UN CIERTO NUMERO DE ITERACIONES
00502                                         // PARA QUE FINALICE LA SIMULACION Y SE INVOQUE LA FUNCION FINISH()
00503                                         // media_bytes_total_onus[] -> MEDIA POR SERVICIOS DE TODAS LAS ONU
00504                                         //if( media_bytes_total_onus[0].number_iterations() >= 25 ) // TENEMOS QUE ANYADIR LAS VARIABLES // numReceived >= 5000000)//media_bytes_total_onus[0].converged()) // NUMERO DE PAQUETES QUE LLEGAN O SI LA FUNCION ANALSIS CONVERGE
00505                                         //{
00506 
00507                                                 //endSimulation(); // LLAMAMOS A LA FUNCION TERMINAR SIMULACION
00508                                                 //callFinish(); // LLAMAMOS A LA FUNCION FINALIZAR
00509                                         //}
00510                                 }
00511                                 send(reportmsg, "oltrxOut"); // ENVIA EL PAQUETE REPORT HACIA LA CAPA MAC DEL OLT
00512                         }
00513                         break;
00514 
00515                 default:
00516                         delete msg;
00517                         break;
00518         }
00519 }

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

Reimplemented from cComponent.

Definition at line 33 of file OLT_Rx.cc.

00034 {
00035         contador = 0;
00036         volcado = 0;
00037         num_sla.resize((int)par("numOnu"),0); // VECTOR PARA GUARDAR EL IDENTIFICADOR DEL SLA DE LA ONU ASOCIADA. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NUMERO DE ONUS DE NUESTRA RED
00038         numReceived = 0; // INICIALIZAMOS EL NUMERO DE PAQUETES ETHERNET RECIBIDOS A 0
00039         WirelessRx = 0;
00040         OpticalRx = 0;
00041         OpticalBytes = 0;
00042         WirelessBytes = 0;
00043         onus = (int) par("numOnu");
00044         prioridades = (int)par("numqueue");
00045         carga_onu.resize(onus);
00046         TotalBytes.resize(onus,0);
00047         PriorityBytes.resize(onus);
00048         for(int i=0;i<onus;i++)
00049         {
00050                 PriorityBytes[i].resize(prioridades);
00051         }
00052         carga_prioridades.resize(onus);
00053         for(int i=0;i<onus;i++)
00054         {
00055                 carga_prioridades[i].resize(prioridades);
00056         }
00057         carga_cola = 0.0;
00058         carga_prioridad = 0.0;
00059         throughput = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES ETHERNET QUE LLEGAN
00060         total_bits=0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES ETHERNET EN BITS
00061         total_bits_throughput = 0; //INICIALIZAMOS A 0 LA VARIABLE EN BITS POR SEGUNDO
00062         total_bits_report = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES REPORT EN BITS
00063         throughput_report = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES REPORT QUE LLEGAN
00064         total_bits_throughput_report = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES REPORT EN BITS
00065         throughput_cabecera = 0;  //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES ETHERNET QUE LLEGAN SIN LA CABECERA
00066         total_bits_cabecera = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES ETHERNET EN BITS SIN LA CABECERA
00067         total_bits_throughput_cabecera = 0; //INICIALIZAMOS A 0 LA SUMA DE LOS PAQUETES ETHERNET SIN LA CABECERA EN BITS
00068         B_guarda = 0;
00069         B_guarda_total = 0;
00070         total_bw_perdido_bits=0;
00071         total_time_perdido=0;
00072         media=0;
00073         numpaquetes=0;
00074         plr_total=0;
00075 
00076         retardo_global_P.resize(prioridades);
00077         retardo_sla.resize((int)par("numSLA"));
00078         retardo_servicios_sla.resize((int)par("numSLA"));
00079         for(int i=0; i<(int)retardo_servicios_sla.size(); i++)
00080         {
00081                 retardo_servicios_sla[i].resize(prioridades);
00082         }
00083         media_bytes_total_onus.resize(prioridades);
00084         retardo_P.resize(prioridades,0);
00085         retardo.resize((int)par("numSLA"),0);
00086         tam_packet_queue.resize(prioridades,0);
00087         var_Mbps.resize((int)par("numSLA"),0);
00088         cont_var.resize((int)par("numSLA"),0);
00089         desviacion.resize((int)par("numSLA"));
00090         plr_sla.resize((int)par("numSLA"));
00091         throughput_sla.resize((int)par("numSLA")+2,0);
00092         cont_aux=1;
00093         total_bits_sla.resize((int)par("numSLA")+2,0);
00094 }

void OLT_Rx::volcadoFicheros (  )  [virtual]

Definition at line 525 of file OLT_Rx.cc.

00526 {
00527         //volcado = 1;
00528 
00529         //RECOGIDA DE ESTADISTICAS CON LA CLASE ANALISIS!! GUARDAMOS LOS DATOS EN UN ARCHIVO
00530         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00531         carga_onus = fopen("results/carga_onus.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00532                 for(int i=0; i<onus; i++)
00533                 {
00534                         fprintf(carga_onus, "Carga ONU %i: %g\n", i, (double)carga_onu[i].average());
00535                 }
00536                 fprintf(carga_onus,"\n");
00537                 fclose(carga_onus); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00538 
00539         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00540         carga_prioridades_onus = fopen("results/carga_prioridades_onus.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00541                 for(int i=0; i<onus; i++)
00542                 {
00543                         fprintf(carga_prioridades_onus, "ONU[%i]:\n",i);
00544                         for(int j=0; j<prioridades; j++)
00545                         {
00546                                 fprintf(carga_prioridades_onus, "\tCarga cola P%i: %g\n", j, (double)carga_prioridades[i][j].average());
00547                         }
00548                 }
00549                 fprintf(carga_prioridades_onus,"\n");
00550                 fclose(carga_prioridades_onus); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00551 
00552         //RECOGIDA DE ESTADISTICAS CON LA CLASE ANALISIS!! GUARDAMOS LOS DATOS EN UN ARCHIVO
00553         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00554         retardo_total=fopen("results/retardo_total.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00555                 fprintf(retardo_total, "Retardo medio paquetes wireless: %g\n", (double)retardo_inalambrico.average());
00556                 fprintf(retardo_total, "Retardo medio paquetes opticos: %g\n", (double)retardo_optico.average());
00557                 fprintf(retardo_total,"\n");
00558                 fclose(retardo_total); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00559 
00560         //RECOGIDA DE ESTADISTICAS CON LA CLASE ANALISIS!! GUARDAMOS LOS DATOS EN UN ARCHIVO
00561         // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00562         retardo_analisis=fopen("results/retardo_analisis.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00563                 // RECORREMOS ESTE BUCLE FOR PARA OBTENER LA MEDIA GLOBAL DE CADA SERVICIO
00564                 for(int i=0; i<prioridades; i++)
00565                 {
00566                         fprintf(retardo_analisis,"COLA P%i\n", i);
00567                         fprintf(retardo_analisis,"Media del retardo global: %g\n", (double)retardo_global_P[i].average()); // MEDIA DEL RETARDO
00568                         fprintf(retardo_analisis,"Intervalo de confianza: %g\n", (double)retardo_global_P[i].half_confidence_interval()); // DESVIACION DEL RETARDO
00569                 }
00570                 fprintf(retardo_analisis,"Total paquetes recibidos: %g\n", numReceived);
00571                 fclose(retardo_analisis); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00572 
00573                 // ARCHIVO PARA RECOGER LOS DATOS DEL RETARDO POR CADA SLA GLOBAL Y POR TIPO DE SERVICIOS
00574                 // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00575                 retardo_analisis_sla=fopen("results/retardo_analisis_sla.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00576                 for(int i=0; i<(int)par("numSLA"); i++)
00577                 {
00578                         fprintf(retardo_analisis_sla,"SLA %i\n", i);
00579                         fprintf(retardo_analisis_sla,"Media del retardo global: %g\n", (double)retardo_sla[i].average()); // MEDIA DEL RETARDO GLOBAL DE CADA SLA
00580                         // RECORREMOS ESTE BUCLE FOR PARA OBTENER LA MEDIA DE CADA SERVICIO ASOCIADA A CADA SLA
00581                         for(int j=0; j<prioridades; j++)
00582                         {
00583                                 fprintf(retardo_analisis_sla,"Retardo del servicio P%i: %g\n", j, (double)retardo_servicios_sla[i][j].average());
00584                         }
00585                         fprintf(retardo_analisis_sla,"Intervalo de confianza del retardo global: %g\n", (double)retardo_sla[i].half_confidence_interval()); // DESVIACION DEL RETARDO GLOBAL DE CADA SLA
00586                         // RECORREMOS ESTE BUCLE FOR PARA OBTENER EL INTERVALO DE CONFIANZA DE CADA SERVICIO ASOCIADO A CADA SLA
00587                         for(int j=0; j<prioridades; j++)
00588                         {
00589                                 fprintf(retardo_analisis_sla,"Intervalo de confianza del retardo del servicio %i: %g\n", j, (double)retardo_servicios_sla[i][j].half_confidence_interval()); // MEDIA DEL RETARDO GLOBAL DE CADA SLA
00590                         }
00591                         fprintf(retardo_analisis_sla,"---\n");
00592                 }
00593                 fclose(retardo_analisis_sla); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00594 
00595                 // RECOGIDA DE ESTADISTICAS DE LAS MEDIAS DE LOS BYTES QUE QUEDAN EN LAS COLAS DE TODAS LAS ONUs DESPUES DE CADA CICLO CON LA CLASE ANALISIS Y LO GUARDAMOS LOS DATOS EN UN ARCHIVO
00596                 // SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00597                 media_total_onu=fopen("results/media_total_onu.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00598                         for(int i=0; i<prioridades; i++)
00599                         {
00600                                         fprintf(media_total_onu,"Media de los bytes sobrantes en la cola %i tras cada ciclo: %g\n", i, (double)media_bytes_total_onus[i].average()); // MEDIA DE LOS BYTES QUE QUEDAN EN LAS COLAS DESPUES DE CADA CICLO
00601                         }
00602                         fclose(media_total_onu); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00603 
00604                 //FICHERO PARA LA RECOGIDA DE LOS DATOS ESTADASTICOS DE LA MODULACION WDM
00605                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00606                 tamano_throughput=fopen("results/tamano_throughput.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00607                 fprintf(tamano_throughput,"Throughput (bps) de los paquetes ETHERNET: %g\n" , (double)total_bits_throughput); //BITS POR SEGUNDO DE THROUGHPUT DE LOS PAQUETES ETHERNET
00608                 fprintf(tamano_throughput,"Throughput (bps) de los paquetes REPORT: %g\n" , (double)total_bits_throughput_report);//BITS POR SEGUNDO DE THROUGHPUT DE LOS PAQUETES REPORT
00609                 fprintf(tamano_throughput,"Throughput (bps) de los paquetes ETHERNET sin los bits de cabecera: %g\n" , (double)total_bits_throughput_cabecera); //BITS POR SEGUNDO DE THROUGPUT DE LOS PAQUETES ETHERNET SIN LOS BITS DE CABECERA
00610                 fprintf(tamano_throughput,"Ancho de banda de guarda total (bits): %Lg\n" ,(long double)B_guarda_total); //BITS DE ANCHO DE BANDA DE GUARDA
00611                 fprintf(tamano_throughput,"Tiempo perdido en total (segundos): %Lg\n" ,(long double)total_time_perdido); //TIEMPO DESALINEAMIENTO
00612                 fprintf(tamano_throughput,"Ancho de banda perdido en total (bits): %Lg\n" ,(long double)total_bw_perdido_bits); //NUMERO DE BITS DE DESALINEAMIENTO
00613                 fprintf(tamano_throughput,"Total bits de los paquetes REPORT: %Lg\n" ,(long double)total_bits_report); //NUMERO DE BITS QUE TIENEN LOS MENSAJES REPORT
00614                 fclose(tamano_throughput); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00615 
00616                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE LA PLR (Packet Loss Ratio)
00617                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00618                 plr_file=fopen("results/plr.txt", "a+"); //ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00619                 //fprintf(plr_file,"%g\t" , (double)plr.average()); //METODO ANALISIS PARA EL PLR
00620                 //fprintf(plr_file,"\t");
00621                 //fprintf(plr_file,"%g\t" , (double)media); //METODO DE RECOGIDA DE ESTADASTICAS MANUAL PARA EL PLR
00622                 //fprintf(plr_file,"\n");
00623                 fprintf(plr_file, "PACKET LOSS RATIO\n");
00624                 for(int i=0; i<(int)par("numSLA"); i++)
00625                 {
00626                         fprintf(plr_file, "Media PLR del SLA %i: %g\n" , i, (double)plr_sla[i].average());
00627                 }
00628 
00629                 fclose(plr_file); //CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00630 
00631                 //FICHERO PARA LA RECOGIDA DE LOS DATOS ESTADISTICOS DE LA MODULACION WDM
00632                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00633                 //tamano_throughput_sla=fopen("results/tamano_throughput_slas.doc", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
00634                 //fprintf(tamano_throughput_sla,"%g\t" , (double)throughput_sla[0]);
00635                 //fprintf(tamano_throughput_sla,"\t");
00636                 //fprintf(tamano_throughput_sla,"%g\t" , (double)throughput_sla[1]);
00637                 //fprintf(tamano_throughput_sla,"\t");
00638                 //fprintf(tamano_throughput_sla,"%g\t" , (double)throughput_sla[2]);
00639                 //fprintf(tamano_throughput_sla,"\n");
00640 
00641                 //fclose(tamano_throughput_sla); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00642 
00643                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE LA VARIANZA
00644                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
00645                 varianza=fopen("results/varianza.txt" , "a+");
00646                 for(int i=0; i<(int)par("numSLA"); i++)
00647                 {
00648 
00649                         fprintf(varianza, "Varianza SLA %i: %Lg\n", i, (long double) sqrt(var_Mbps[i]/cont_var[i]));
00650                         fprintf(varianza,"\t");
00651                 }
00652                 fprintf(varianza,"---\n");
00653 
00654                 for(int i=0; i<(int)par("numSLA"); i++)
00655                 {
00656                         fprintf(varianza, "Margen de error SLA %i: %Lg\n", i, (long double) 1.960*sqrt(var_Mbps[i]/(cont_var[i]-1))/sqrt(cont_var[i]));
00657                 }
00658                 fprintf(varianza,"---\n");
00659 
00660                 for(int i=0; i<(int)par("numSLA"); i++)
00661                 {
00662                         fprintf(varianza, "Desviacion SLA %i: %g\n", i, (double) desviacion[i].average());
00663                 }
00664                 fprintf(varianza,"---\n");
00665 
00666                 fclose(varianza); //CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
00667 }


Member Data Documentation

long double OLT_Rx::B_guarda [protected]

Definition at line 98 of file OLT_Rx.h.

long double OLT_Rx::B_guarda_total [protected]

Definition at line 99 of file OLT_Rx.h.

double OLT_Rx::carga_cola [private]

Definition at line 77 of file OLT_Rx.h.

std::vector<Analysis> OLT_Rx::carga_onu [private]

Definition at line 41 of file OLT_Rx.h.

FILE* OLT_Rx::carga_onus [private]

Definition at line 64 of file OLT_Rx.h.

double OLT_Rx::carga_prioridad [private]

Definition at line 78 of file OLT_Rx.h.

Definition at line 44 of file OLT_Rx.h.

Definition at line 65 of file OLT_Rx.h.

Definition at line 116 of file OLT_Rx.h.

Definition at line 112 of file OLT_Rx.h.

Definition at line 117 of file OLT_Rx.h.

simtime_t OLT_Rx::delay [private]

Definition at line 81 of file OLT_Rx.h.

simtime_t OLT_Rx::delay_opt [private]

Definition at line 82 of file OLT_Rx.h.

simtime_t OLT_Rx::delay_wir [private]

Definition at line 83 of file OLT_Rx.h.

Definition at line 113 of file OLT_Rx.h.

Definition at line 110 of file OLT_Rx.h.

double OLT_Rx::media [protected]

Definition at line 102 of file OLT_Rx.h.

std::vector<Analysis> OLT_Rx::media_bytes_total_onus [private]

Definition at line 53 of file OLT_Rx.h.

FILE* OLT_Rx::media_total_onu [private]

Definition at line 58 of file OLT_Rx.h.

Definition at line 67 of file OLT_Rx.h.

Definition at line 108 of file OLT_Rx.h.

double OLT_Rx::numReceived [private]

Definition at line 70 of file OLT_Rx.h.

int OLT_Rx::onus [private]

Definition at line 79 of file OLT_Rx.h.

double OLT_Rx::OpticalBytes [private]

Definition at line 75 of file OLT_Rx.h.

long OLT_Rx::OpticalRx [private]

Definition at line 72 of file OLT_Rx.h.

Definition at line 107 of file OLT_Rx.h.

FILE* OLT_Rx::plr_file [private]

Definition at line 60 of file OLT_Rx.h.

std::vector<Analysis> OLT_Rx::plr_sla

Definition at line 114 of file OLT_Rx.h.

Definition at line 109 of file OLT_Rx.h.

int OLT_Rx::prioridades [private]

Definition at line 80 of file OLT_Rx.h.

Definition at line 74 of file OLT_Rx.h.

Definition at line 69 of file OLT_Rx.h.

FILE* OLT_Rx::retardo_analisis [private]

Definition at line 57 of file OLT_Rx.h.

Definition at line 56 of file OLT_Rx.h.

std::vector<Analysis> OLT_Rx::retardo_global_P [private]

Definition at line 38 of file OLT_Rx.h.

Definition at line 105 of file OLT_Rx.h.

Definition at line 106 of file OLT_Rx.h.

Definition at line 68 of file OLT_Rx.h.

std::vector<std::vector < Analysis > > OLT_Rx::retardo_servicios_sla [private]

Definition at line 50 of file OLT_Rx.h.

std::vector<Analysis> OLT_Rx::retardo_sla [private]

Definition at line 47 of file OLT_Rx.h.

FILE* OLT_Rx::retardo_total [private]

Definition at line 63 of file OLT_Rx.h.

Definition at line 84 of file OLT_Rx.h.

FILE* OLT_Rx::tamano_throughput [private]

Definition at line 59 of file OLT_Rx.h.

Definition at line 62 of file OLT_Rx.h.

long double OLT_Rx::throughput [protected]

Definition at line 89 of file OLT_Rx.h.

long double OLT_Rx::throughput_cabecera [protected]

Definition at line 95 of file OLT_Rx.h.

long double OLT_Rx::throughput_report [protected]

Definition at line 93 of file OLT_Rx.h.

Definition at line 115 of file OLT_Rx.h.

long double OLT_Rx::total_bits [protected]

Definition at line 90 of file OLT_Rx.h.

long double OLT_Rx::total_bits_cabecera [protected]

Definition at line 96 of file OLT_Rx.h.

long double OLT_Rx::total_bits_report [protected]

Definition at line 92 of file OLT_Rx.h.

Definition at line 118 of file OLT_Rx.h.

double OLT_Rx::total_bits_throughput [protected]

Definition at line 91 of file OLT_Rx.h.

Definition at line 97 of file OLT_Rx.h.

Definition at line 94 of file OLT_Rx.h.

long double OLT_Rx::total_bw_perdido_bits [protected]

Definition at line 100 of file OLT_Rx.h.

long double OLT_Rx::total_time_perdido [protected]

Definition at line 101 of file OLT_Rx.h.

Definition at line 73 of file OLT_Rx.h.

Definition at line 111 of file OLT_Rx.h.

FILE* OLT_Rx::varianza [private]

Definition at line 61 of file OLT_Rx.h.

Definition at line 120 of file OLT_Rx.h.

double OLT_Rx::WirelessBytes [private]

Definition at line 76 of file OLT_Rx.h.

long OLT_Rx::WirelessRx [private]

Definition at line 71 of file OLT_Rx.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