MAC_OLT Class Reference

#include <MAC_OLT.h>

Inheritance diagram for MAC_OLT:

cSimpleModule cModule cComponent cDefaultList cNoncopyableOwnedObject cOwnedObject noncopyable cNamedObject cObject

List of all members.

Public Member Functions

int numInitStages () const

Public Attributes

ONU_SISTqueueonu_queue
OLT_Tabletable_module
long sumqueue
long sumbdemand
long B_sobra
long B_exceded
simtime_t tstarttime
double_vector_t B_alloc
double_vector_t B_demand
double_vector_t t_slot
double_vector_t t_slot_initialization
int_vector_t B_extra
simtime_t tiempo_tx_siguiente
simtime_t tiempo_sim_delay_datarate
double_vector_t T_alloc
double delay
simtime_t delay_pon1
simtime_t_vector_t delay_pon2
simtime_t_vector_t delay_total
double_vector_t B_ex_sla
double_vector_t B_max_dmb
int id_onu
double W_min
double long_max
double B_basico
double sumatorio
int_vector_t SLA_onu
int_vector_t numonu_sla
int_vector_t Wsla
int_vector_t numsla
simtime_t_vector_t tiempo_tx_sig
int aux
double_vector_t B_max_sla
double_vector_t B_max_sla_ant
int id
double tiempo_inic_PID
double tiempo_PID
int_vector_t numero_sla
int_vector_t pet
double_vector_t error
double_vector_t sum_error
double_vector_t BW_max_PID
double_vector_t BW_max_PID_ant
double_vector_t control
double_vector_t error_ant
double_vector_t B_guarantee
vector< vector< vector< double > > > cola_vector
double_vector_t bw_acum_ONU
double_vector_t bw_alg_ONU
double_vector_t bw_acum_Mbps
double_vector_t bw_alg_Mbps
int intento_pid
int intento
int_vector_t BW_sla
int_vector_t BW_SLA_onu
int prueba
double_vector_t B_Mbps
double_vector_t B_alloc_total
double_vector_t desviacionBwMaxGuar
double_vector_t cont_var_BwMax
double_vector_t var
double_vector_t var_Mbps
double_vector_t cont_var
double_vector_t error_abs
double_vector_t error_rel
double_vector_t var_Mbps_instantaneo
std::vector< Analysisdesviacion
double_vector_t PID_MEDIO
double_vector_t PID_MEDIO_TOTAL
int cont_aux0
int cont_aux2
int cont_aux10
int cont
double_vector_t B_Mbps_sla
double_matrix_t delay_onu
int_matrix_t paq_onu
vector< vector< vector< vector
< double > > > > 
vector_ventana
double_matrix_t retardo_alg_SLA
double_matrix_t retardo_acum_SLA
double_matrix_t retardo_alg_ONU
double_matrix_t retardo_max_ONU
double_vector_t sum_error_delay
double_vector_t error_ant_delay
int flagPrioridad
int flag_control_delay
int no_capacidad
int primera_vez
int aux_cont
int cont_auxiliar
int contador_aux
double_vector_t paquetes_borrados_P1
double_vector_t paquetes_recibidos_P1

Protected Member Functions

virtual void initialize (int stage)
virtual void handleMessage (cMessage *msg)
virtual void centralizedmethod_DMB (cMessage *msg)
virtual void pollingmethod_IPACT (cMessage *msg)
virtual void wdmmethod (cMessage *msg)
virtual void DBA_polling_PID (cMessage *msg)
virtual void DBA_polling_DaSPID (cMessage *msg)
virtual void PID_control_delay (cMessage *msg)
virtual void recoger_delay_por_sla (int sla, double retardo, int prioridad)
virtual void PID (cMessage *msg)
virtual void recoger_bw_por_onu (cMessage *msg)
virtual void calcularvarianza (cMessage *msg)

Private Attributes

FILE * B_alloc_medio
FILE * B_max_PID
FILE * BW_Mbps
FILE * BW_acum
FILE * B_total
FILE * pid_medio_file
FILE * controlfich
FILE * evaluacion_retardo_slas_P0
FILE * evaluacion_retardo_slas_P1
FILE * B_alloc_periodico
FILE * bloqueo_cad_daspid_P1
std::vector< AnalysisdesviacionBwMax


Detailed Description

Definition at line 33 of file MAC_OLT.h.


Member Function Documentation

void MAC_OLT::calcularvarianza ( cMessage msg  )  [protected, virtual]

Definition at line 3065 of file MAC_OLT.cc.

03066 {
03067         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
03068 
03069         //ev<<" "<<endl;
03070         //ev<<" ENTRO EN EL CODIGO PARA CALCULAR VARIANZA "<<endl;
03071         //ev<<" "<<endl;
03072 
03073         int onu=reportmsg->getSrcAddress(); //VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
03074         int acum=0;
03075         double T_cycle=0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
03076         double T_guarda = 0.000001; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
03077         double txrate = (int)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
03078         double tasa_tx_gate = 512/txrate;
03079         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
03080         int m;
03081         //if(pet[onu]==1) //SI DEMANDA MIS ANCHO DE BANDA QUE EL MAXIMO, CALCULAMOS LA VARIANZA
03082         //{
03083                 for (int j=0; j<(int)par("numSLA"); j++)
03084                 {
03085                         for(int k=acum; k<numonu_sla[j]+acum; k++)
03086                         {
03087                                 B_guarantee[k]=BW_SLA_onu[k]*1000000*(T_cycle-(int)par("numOnu")*T_guarda-(int)par("numOnu")*tasa_tx_report);
03088 
03089                                 if(k==onu)
03090                                 {
03091                                         //ev<<" SLA: "<<j<<" y ONU: "<<k<<endl;
03092 
03093                                         desviacionBwMax[j].analyze(B_max_sla[k]);
03094                                         desviacionBwMaxGuar[j]= desviacionBwMaxGuar[j]+((B_guarantee[k]-B_max_sla[k])*(B_guarantee[k]-B_max_sla[k]));
03095                                         cont_var_BwMax[j]++;
03096 
03097                                         //ev<<" pet "<<pet[k]<<endl;
03098 
03099                                         //if(pet[k]==1)
03100                                         //{
03101 
03102                                                 var[j]= var[j]+((B_guarantee[k]-bw_alg_ONU[k])*(B_guarantee[k]-bw_alg_ONU[k]));
03103                                                 var_Mbps[j]=var_Mbps[j]+ ((B_guarantee[k]/(T_cycle-16*T_guarda - 16*tasa_tx_gate))-bw_alg_Mbps[k])*((B_guarantee[k]/(T_cycle-16*T_guarda - 16*tasa_tx_gate))-bw_alg_Mbps[k]);  //EL CUADRADO DEL ERROR
03104                                                 cont_var[j]=cont_var[j]+1;
03105 
03106                                                 //ev<<" VARIANZA "<<1.960*sqrt(var[j]/cont_var[j])<<endl;
03107                                                 //ev<<" VARIANZA MBPS "<<1.960*sqrt(var_Mbps[j]/cont_var[j])<<endl;
03108                                                 desviacion[j].analyze(bw_alg_Mbps[k]);
03109                                         //}
03110                                 }
03111                         m=k;
03112                         }
03113                         acum=m+1;
03114                 }
03115         //}
03116 }

void MAC_OLT::centralizedmethod_DMB ( cMessage msg  )  [protected, virtual]

Definition at line 510 of file MAC_OLT.cc.

00511 {
00512         //ev<<" EJECUTAMOS EL METODO CENTRALIZADO DMB EN EL OLT."<<endl;
00513 
00514         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
00515 
00516         //VARIABLES
00517         double txrate = (double)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
00518         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DE UN MENSAJE GATE CON UN TAMANYO DE 64 BYTES
00519         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DE UN MENSAJE REPORT CON UN TAMANYO DE 64 BYTES
00520         double T_cycle = 0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
00521         double T_guarda = 0.000001; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
00522         double T_guarda_nonu = T_guarda*(int)par("numOnu"); // TIEMPO DE GUARDA TOTAL DE TODAS LAS ONUS MENOS LA ULTIMA
00523         double T_report_nonu = tasa_tx_report*((int)par("numOnu")); // TASA DE TRANSMISION TOTAL DE LOS PAQUETES REPORT DE TODAS LAS ONUS
00524         double T_cycle_total = T_cycle - T_guarda_nonu - T_report_nonu; // TIEMPO DE CICLO FINAL Y LO VISUALIZAMOS POR PANTALLA
00525         //ev<<" Tiempo de ciclo total: "<<T_cycle_total<<"s"<<endl;
00526         double B_cycle = txrate*T_cycle_total/8; // ANCHO DE BANDA MAXIMO DEL CICLO EN BYTES Y LO VISULAIZAMOS POR PANTALLA
00527         //ev<<" Ancho de banda del ciclo: "<<B_cycle<<"Bytes"<<endl;
00528         double B_report = txrate*tasa_tx_report/8; // TAMANYO DEL PAQUETE REPORT (BYTES)
00529         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO EL NÚMERO DE COLAS QUE SE DEFINEN
00530         int srcAddress = 9; // DEFINICION DEL IDENTIFICADOR DE LA DIRECCION DE ORIGEN O FUENTE
00531         simtime_t time_tx_onu0; // TIEMPO DE TRANSMISION DE LA PRIMERA ONU
00532         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
00533         double longitud_total_red; // DEFINIMOS LA VARIABLE QUE NOS INDICA LA LONGITUD TOTAL DE LA RED
00534 
00535         // ASIGANCION DE PESOS
00536         Wsla[0] = (int)par("w_sla0"); // PESO DEL SLA0 DEFINIDO EN NUESTRA RED
00537         Wsla[1] = (int)par("w_sla1"); // PESO DEL SLA1 DEFINIDO EN NUESTRA RED
00538         Wsla[2] = (int)par("w_sla2"); // PESO DEL SLA2 DEFINIDO EN NUESTRA RED
00539         Wsla[3] = (int)par("w_sla3"); // PESO DEL SLA3 DEFINIDO EN NUESTRA RED
00540         Wsla[4] = (int)par("w_sla4"); // PESO DEL SLA4 DEFINIDO EN NUESTRA RED
00541 
00542         // ASIGNACION DEL NÚMERO DE ONUS
00543         numonu_sla[0] = (int)par("numonu_sla0"); // NÚMERO DE ONUs ASOCIADO AL SLA0
00544         numonu_sla[1] = (int)par("numonu_sla1"); // NÚMERO DE ONUs ASOCIADO AL SLA1
00545         numonu_sla[2] = (int)par("numonu_sla2"); // NÚMERO DE ONUs ASOCIADO AL SLA2
00546         numonu_sla[3] = (int)par("numonu_sla3"); // NÚMERO DE ONUs ASOCIADO AL SLA3
00547         numonu_sla[4] = (int)par("numonu_sla4"); // NÚMERO DE ONUs ASOCIADO AL SLA4
00548 
00549         // CALCULAMOS EL DELAY DEPENDIENDO DE LA LONGITUD Y LE SUMAMOS LA TASA DE TRANSMISION DEL PAQUETE GATE PARA SUMARLE DESPUES AL TIEMPO DE INICIO DE TRANSMISION
00550         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
00551         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
00552         //ev<<" Retardo de la Red PON: "<<delay<<endl; // VISUALIZAMOS EL RETARDO DE LA RED
00553 
00554         //LEEMOS EL TIEMPO CUANDO SE ENVIO EL REPORT DE LA ONU 15 Y LO GUARDAMOS EN EL VECTOR DE LA TABLA
00555         table_module->table_olt_report_time[0] = reportmsg->getTimesendreport();
00556         //ev<<" Tiempo en el que se envio el paquete Report "<<table_module->table_olt_report_time[0]<<endl;
00557 
00558         //VAMOS A CALCULAR EL ANCHO DE BANDA DEMANDADO Y LO GUARDAMOS EN LA TABLA DEL OLT
00559         //ev<<" Calculamos el Bandwidth Demandado y lo guardamos en la tabla del OLT."<<endl;
00560         // SUMAMOS EL TAMANYO DEL ESTADO DE LAS COLAS DE LA ONU QUE A MANDADO EL REPORT QUE LLEGA AL OLT
00561         for(int i=0; i<(int)par("numqueue"); i++)
00562         {
00563                 sumqueue = sumqueue + reportmsg->getQueue_estado(i);
00564         }
00565         // SI LA SUMA TOTAL DEL TAMANYO DE LAS COLAS ES 0, DAMOS UN VALOR PREDETERMINADO DE 20 BYTES
00566         if(sumqueue == 0)
00567         {
00568                 sumqueue = 20;
00569         }
00570 
00571         // ASIGNAMOS LA SUMA TOTAL A LA VARIABLE DEL ANCHO DE BANDA DEMANDADO DE LA ONU
00572         B_demand[reportmsg->getSrcAddress()] = sumqueue;
00573 
00574         sumqueue = 0; // DAMOS EL VALOR 0 A LA SUMA DE LAS COLAS. DE ESTA MANERA LA INICIALIZAMOS DE NUEVO A 0
00575 
00576         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE EL ANCHO DE BANDA DEMANDADO POR LA ONU Y LO VISUALIZAMOS POR PANTALLA
00577         table_module->table_olt_report[reportmsg->getSrcAddress()][(int)par("numqueue")] = B_demand[reportmsg->getSrcAddress()];
00578         //ev<<"ONU "<< reportmsg->getSrcAddress()<<"->"<< "Bandwidth Demandado: "<< B_demand[reportmsg->getSrcAddress()]<<"Bytes"<<endl;
00579 
00580         // SUMAMO EL ANCHO DE BANDA DEMANDADO DE CADA ONU PARA DESPUES COMPARARLO CON EL ANCHO DE BANDA MAXIMO DEL CICLO
00581         sumbdemand = sumbdemand + B_demand[reportmsg->getSrcAddress()];
00582 
00583         // EJECUTAMOS EL METODO DMB DEL OLT CUANDO NOS LLEGUE EL PAQUETE REPORT DE LA ÚLTIMA ONU DE LA RED
00584         if(reportmsg->getSrcAddress()==((int)par("numOnu")-1))
00585         {
00586                 //ev<<" EJECUTAMOS EL METODO CENTRALIZADO DEL OLT, METODO DMB."<<endl;
00587                 //ev<<" Suma del Ancho de Banda Demandado por todas las ONUs: "<<sumbdemand<<"Bytes"<<endl;
00588 
00589                 // ASIGANCION DE LOS SLA A CADA ONU CON SU RESPECTIVO PESO
00590                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODOS LOS SLA DEFINIDOS EN LA RED
00591                 for(int j=0; j<(int)par("numSLA"); j++)
00592                 {
00593                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
00594                         for(int i=0; i<numonu_sla[j]; i++)
00595                         {
00596                                 SLA_onu[id_onu+i] = Wsla[j]; // ASIGANAMOS A LA VARIABLE SLA_onu[] EL VALOR DEL PESO DEL SLA AL QUE ESTA ASOCIADA ESA ONU
00597                                 //ev<<" ONU "<<id_onu+i<<": Peso="<<Wsla[j]<<endl; // VISUALIZAMOS EL PESO ASOCIADO A CADA ONU
00598                                 numsla[id_onu+i] = j; // INTRODUCIMOS EN LA VARIABLE numsla[] EL IDENTIFICADOR DEL SLA PARA CADA ONU YA QUE LO UTILIZAREMOS PARA RECOGER EL RETARDO DE CADA SLA
00599                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU QUE
00600                                 if(i==(numonu_sla[j]-1))
00601                                 {
00602                                         id_onu=id_onu+1+i;
00603                                 }
00604                         }
00605                 }
00606                 id_onu=0; // IGUALAMOS EL IDENTIFICADOR DE LA ONU AL VALOR 0
00607 
00608                 // DEFINIMOS EL ANCHO DE BANDA MAXIMO
00609                 W_min = 0.34; // PESO MINIMO CON VALOR FIJO DE 0.34
00610                 long_max = B_cycle/(int)par("numOnu"); // LONGITUD MAXIMA QUE TIENE UNA ONU PARA TRANSMITIR DEPENDIENDO DEL B_cycle Y DEL NÚMERO DE ONUs
00611                 B_basico = W_min*long_max; // ANCHO DE BANDA BASICO PARA TRANSMITIR QUE TIENE CADA ONU Y LO VISUALIZAMOS POR PANTALLA
00612                 //ev<<" Ancho de Banda Basico: "<<B_basico<<endl;
00613 
00614                 // RECORREMOS MEDIANTE ESTE BUCLE FOR LOS SLAs DEFINIDOS EN NUESTRA RED PARA REALIZAR EL SUMATORIO PARA CALCULAR EL ANCHO DE BANDA ASOCIADO A CADA SLA
00615                 for(int i=0; i<(int)par("numSLA"); i++)
00616                 {
00617                         sumatorio = sumatorio + (numonu_sla[i]*Wsla[i]); // CALCULAMOS EL SUMATORIO Y LO VISUALIZAMOS POR PANTALLA
00618                         //ev<<" Sumatorio: "<<sumatorio<<endl;
00619                 }
00620 
00621                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA DE CADA ONU ASIGNADO POR EL SLA QUE CORRESPONDE A CADA ONU
00622                 for(int j=0; j<(int)par("numOnu"); j++)
00623                 {
00624                         B_ex_sla[j] = (B_cycle - (B_basico*(int)par("numOnu")))*SLA_onu[j]/sumatorio; // CALCULAMOS EL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU
00625                         //ev<<" Ancho de Banda de SLA de la ONU"<<j<<": "<<B_ex_sla[j]<<endl; // VISUALIZAMOS EL ANCHO DE BANDA
00626                 }
00627                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA MAXIMO DE CADA ONU
00628                 for(int j=0; j<(int)par("numOnu"); j++)
00629                 {
00630                         B_max_dmb[j] = B_basico + B_ex_sla[j]; // CALCULAMOS EL ANCHO DE BANDA MAXIMO Y LO VISUALIZAMOS POR PANTALLA
00631                         //ev<<" Ancho de Banda Maximo de la ONU"<<j<<": "<<B_max_dmb[j]<<endl;
00632                 }
00633                 sumatorio = 0; // DAMOS EL VALOR 0 AL SUMATORIO PARA QUE NO SE INCREMENTE
00634 
00635                 // COMPARAMOS SI LA SUMA TOTAL DE ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO DEL CICLO
00636                 if(sumbdemand < B_cycle)
00637                 {
00638                         B_alloc[0] = B_demand[0] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
00639                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGANDO
00640                         //ev<<"Ancho de Banda Asignado ONU 0: "<<B_alloc[0]<<endl;
00641                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
00642                         table_module->table_olt_report[0][(int)par("numqueue")+1] = B_alloc[0];
00643                         //ev<<"ONU "<< 0<<"->"<< "Bandwidth Asignado: "<< B_alloc[0]<<"Bytes"<<endl;
00644 
00645                         t_slot[0] = B_alloc[0]*8/txrate; // ASIGNAMOS EL TIEMPO DE SLOT PARA LA ONU 0
00646 
00647                         time_tx_onu0 = simTime() + delay + tasa_tx_gate; // TIEMPO DE TRANSMISION PARA LA ONU 0 CON DISTANCIAS FIJAS
00648                         //ev<<" Tiempo de inicio de transmision de la ONU 0: "<<time_tx_onu0<<endl;
00649 
00650                         // CREAMOS EL PAQUETE GATE QUE MANDA EL OLT PARA LA ONU 0
00651                         GATEmsg *packet = new GATEmsg("gate");
00652                         packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00653                         packet->setDestAddress(0); // DIRECCION DE DESTINO
00654                         packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00655                         packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00656                         packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00657                         packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00658                         packet->setNumsla(numsla[0]); // IDENTIFICADOR DEL SLA DE LA ONU DE DESTINO
00659 
00660                         // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00661                         if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00662                         {
00663                                 B_slot[0]= B_alloc[0]; // DEFINIMOS ANCHO DE BANDA DE SLOT
00664                                 packet->setGrant_IntervalTx(0,B_slot[0]);
00665                         }
00666                         else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00667                         {
00668                                 //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00669                                 // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00670                                 for(int b=0; b<(int)par("numqueue"); b++)
00671                                 {
00672                                         B_slot[b] = B_alloc[b]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00673                                         packet->setGrant_IntervalTx(b,B_slot[b]);
00674                                         //ev<<"Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
00675                                 }
00676                         }
00677                         packet->setGrant_IniTime(time_tx_onu0); // TIEMPO DE INICIO DE TRANSMISION
00678                         packet->setTimereport(table_module->table_olt_report_time[0]); // PASAMOS A ESTE CAMPO DESDE LA TABLA DEL MODULO OLT_TABLE EL TIEMPO CUANDO SE ENVIA EL REPORT EN LA ONU
00679                         /*
00680                         // VISUALIZAMOS POR PANTALLA LOS CAMPOS DEL PAQUETE GATE
00681                         ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
00682                         ev<<" Paquete Gate."<<endl;
00683                         ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00684                         ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00685                         ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00686                         ev<<" Tipo "<<packet->getKind()<<endl;
00687                         ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
00688                         ev<<" SLA: "<<packet->getNumsla()<<endl;
00689                         ev<<"  "<<endl;
00690                         */
00691                         // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00692                         sendDelayed(packet, tasa_tx_gate, "mactxOut");
00693 
00694                         tstarttime = time_tx_onu0; // ASIGNAMOS A LA VARIABLE tstarttime EL TIEMPO DE INICIO DE TRANSMISION DE LA ONU 0
00695 
00696                         // CREAMOS CON EL BUCLE FOR LOS PAQUETES GATE PARA LAS DEMAS ONUS
00697                         for(int i=1; i<(int)par("numOnu"); i++)
00698                         {
00699                                 B_alloc[i] = B_demand[i] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
00700                                 // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
00701                                 //ev<<" Ancho de Banda Asigando ONU "<<i<<": "<<B_alloc[i]<<endl;
00702                                 // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
00703                                 table_module->table_olt_report[i][(int)par("numqueue")+1] = B_alloc[i];
00704                                 //ev<<"ONU "<< i<<"->"<< "Bandwidth Asignado: "<< B_alloc[i]<<"Bytes"<<endl;
00705 
00706                                 t_slot[i] = B_alloc[i]*8/txrate; //ASIGNAMOS EL TIEMPO DE SLOT PARA CADA ONU
00707 
00708                                 //ASIGNAMOS EL TIEMPO DE INICIO DE TRANSMISION DE LAS ONUS Y LO VISUALIZAMOS POR PANTALLA
00709                                 tstarttime = tstarttime + T_guarda + t_slot[i-1];
00710                                 //ev<<" Tiempo de tslot de la onu "<<i-1<<" "<<t_slot[i-1]<<endl;
00711 
00712                                 // CREAMOS EL PAQUETE GATE QUE MANDA EL OLT PARA LAS DEMIS ONUS
00713                                 GATEmsg *packet = new GATEmsg("gate");
00714                                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00715                                 packet->setDestAddress(i); // DIRECCION DE DESTINO
00716                                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00717                                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00718                                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00719                                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00720                                 packet->setNumsla(numsla[i]); // IDENTIFICADOR DEL SLA DE LA ONU DE DESTINO
00721 
00722                                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00723                                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00724                                 {
00725                                         B_slot[0]= B_alloc[i]; // DEFINIMOS ANCHO DE BANDA DE SLOT
00726                                         packet->setGrant_IntervalTx(0,B_slot[0]);
00727                                 }
00728                                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00729                                 {
00730                                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00731                                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00732                                         for(int b=0; b<(int)par("numqueue"); b++)
00733                                         {
00734                                                 B_slot[b] = B_alloc[i]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00735                                                 packet->setGrant_IntervalTx(b,B_slot[b]);
00736                                                 ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
00737                                         }
00738                                 }
00739                                 packet->setGrant_IniTime(tstarttime); // TIEMPO DE INICIO DE TRANSMISION
00740                                 /*
00741                                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
00742                                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
00743                                 ev<<" Paquete Gate."<<endl;
00744                                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00745                                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00746                                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00747                                 ev<<" Tipo "<<packet->getKind()<<endl;
00748                                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
00749                                 ev<<" SLA: "<<packet->getNumsla()<<endl;
00750                                 ev<<"  "<<endl;
00751                                 */
00752                                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00753                                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
00754 
00755                         }
00756 
00757                         sumbdemand = 0; // PONEMOS A 0 EL VALOR DE LA SUMA DEL ANCHO DE BANDA DEMANDADO DE TODAS LAS ONUS PARA EL PROXIMO CICLO
00758                 }
00759                 else if(sumbdemand > B_cycle)
00760                 {
00761                         //RECORREMOS LAS ONUS PARA VER SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
00762                         for(int i=0; i<(int)par("numOnu"); i++)
00763                         {
00764                                 //ev<<" ONU "<<i<<endl; // VISUALIZAMOS EN LA ONU EN LA QUE NOS ENCONTRAMOS
00765 
00766                                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
00767                                 if(B_demand[i] <= B_max_dmb[i])
00768                                 {
00769                                         B_alloc[i] = B_demand[i] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
00770                                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
00771                                         //ev<<" Ancho de Banda Asigando ONU "<<i<<": "<<B_alloc[i]<<endl;
00772                                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
00773                                         table_module->table_olt_report[i][(int)par("numqueue")+1] = B_alloc[i];
00774                                         //ev<<"ONU "<< i<<"->"<< "Bandwidth Asignado: "<< B_alloc[i]<<"Bytes"<<endl;
00775 
00776                                         // GUARDAMOS EL ANCHO DE BANDA QUE SOBRA EN LA VARIABLE B_SOBRA Y LO VISUALIZAMOS POR PANTALLA
00777                                         B_sobra = B_sobra + (B_max_dmb[i] - B_demand[i]); //vemos el ancho de banda que sobra
00778                                         //ev<<" Ancho de Banda que Sobra: "<<B_sobra<<endl;
00779                                 }
00780                                 else if(B_demand[i] > B_max_dmb[i])
00781                                 {
00782                                         B_alloc[i] = B_max_dmb[i] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
00783                                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
00784                                         //ev<<" Ancho de Banda Asigando ONU "<<i<<": "<<B_alloc[i]<<endl;
00785                                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
00786                                         table_module->table_olt_report[i][(int)par("numqueue")+1] = B_alloc[i];
00787                                         //ev<<"ONU "<< i<<"->"<< "Bandwidth Asignado: "<< B_alloc[i]<<"Bytes"<<endl;
00788 
00789                                         // GUARDAMOS EL ANCHO DE BANDA QUE SE DEMANDA EN EXCESO EN LA VARIABLE B_exceded Y LO VISUALIZAMOS POR PANTALLA
00790                                         B_exceded = B_exceded + (B_demand[i] - B_max_dmb[i]);
00791                                         //ev<<" Ancho de Banda en Exceso: "<<B_exceded<<endl;
00792                                 }
00793                         }
00794 
00795                         //AHORA RECORREMOS LAS ONUS QUE DEMANDAN MIS ANCHO DE BANDA QUE EL MAXIMO PARA ASIGNARLE UNA PARTE PROPORCIONAL DE LO QUE SOBRA
00796                         for(int i=0; i<(int)par("numOnu"); i++)
00797                         {
00798                                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR QUE EL ANCHO DE BANDA MAXIMO
00799                                 if(B_demand[i] > B_max_dmb[i])
00800                                 {
00801                                         // CALCULAMOS EL ANCHO DE BANDA PROPORCINAL QUE ASIGNAREMOS A LA ONU QUE PIDE UN ANCHO DE BANDA EN EXCESO
00802                                         B_extra[i] = B_sobra*(B_demand[i] - B_max_dmb[i])/B_exceded;
00803 
00804                                         // ASIGNAMOS EL ANCHO DE BANDA TOTAL A LA ONU Y LO CARGAMOS EN LA TABLA EN LA COLUMNA DE ANCHO DE BANDA ASIGNADO
00805                                         B_alloc[i] = B_alloc[i] + B_extra[i]; // ANCHO DE BANDA ASIGANDO TOTAL
00806                                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
00807                                         table_module->table_olt_report[i][(int)par("numqueue")+1] = B_alloc[i];
00808                                         //ev<<"ONU "<< i<<"->"<< "Bandwidth Asignado: "<< B_alloc[i]<<"Bytes"<<endl;
00809                                 }
00810                         }
00811 
00812                         t_slot[0] = B_alloc[0]*8/txrate; //ASIGNAMOS EL TIEMPO DE SLOT PARA LA ONU 0
00813 
00814                         //ASIGNAMOS EL TIEMPO DE INICIO DE TRANSMISION DE LA PRIMERA ONU Y LO VISUALIZAMOS POR PANTALLA
00815                         time_tx_onu0 = simTime() + delay + tasa_tx_gate; // TIEMPO DE TRANSMISION PARA LA ONU 0 CON DISTANCIAS FIJAS
00816                         //ev<<" Tiempo de inicio de transmision de la ONU 0: "<<time_tx_onu0<<endl;
00817 
00818                         //CREAMOS EL PAQUETE GATE PARA LA ONU 0
00819                         GATEmsg *packet = new GATEmsg("gate");
00820                         packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00821                         packet->setDestAddress(0); // DIRECCION DE DESTINO
00822                         packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00823                         packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00824                         packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00825                         packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00826                         packet->setNumsla(numsla[0]); // IDENTIFICADOR DEL SLA DE LA ONU DE DESTINO
00827 
00828                         // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00829                         if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00830                         {
00831                                 B_slot[0]= B_alloc[0]; // DEFINIMOS ANCHO DE BANDA DE SLOT
00832                                 packet->setGrant_IntervalTx(0,B_slot[0]);
00833                         }
00834                         else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00835                         {
00836                                 //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00837                                 // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00838                                 for(int b=0; b<(int)par("numqueue"); b++)
00839                                 {
00840                                         B_slot[b] = B_alloc[b]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00841                                         packet->setGrant_IntervalTx(b,B_slot[b]);
00842                                         //ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
00843                                 }
00844                         }
00845                         packet->setGrant_IniTime(time_tx_onu0); // TIEMPO DE INICIO DE TRANSMISION
00846                         packet->setTimereport(table_module->table_olt_report_time[0]); // PASAMOS A ESTE CAMPO DESDE LA TABLA DEL MODULO OLT_TABLE EL TIEMPO CUANDO SE ENVIA EL REPORT EN LA ONU
00847                         /*
00848                         // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
00849                         ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
00850                         ev<<" Paquete Gate."<<endl;
00851                         ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00852                         ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00853                         ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00854                         ev<<" Tipo "<<packet->getKind()<<endl;
00855                         ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
00856                         ev<<" SLA: "<<packet->getNumsla()<<endl;
00857                         ev<<"  "<<endl;
00858                         */
00859                         // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00860                         sendDelayed(packet, tasa_tx_gate, "mactxOut");
00861 
00862                         tstarttime = time_tx_onu0; // ASIGNAMOS A LA VARIABLE tstarttime EL TIEMPO DE INICIO DE TRANSMISION DE LA ONU 0
00863 
00864                         // CREAMOS EL PAQUETE GATE QUE MANDA EL OLT PARA LAS DEMIS ONUS
00865                         for(int i=1; i<(int)par("numOnu"); i++)
00866                         {
00867                                 t_slot[i] = B_alloc[i]*8/txrate;//ASIGNAMOS EL TIEMPO DE SLOT PARA CADA ONU
00868 
00869                                 //ASIGNAMOS EL TIEMPO DE INICIO DE TRANSMISION DE LAS ONUS Y LO VISUALIZAMOS POR PANTALLA
00870                                 tstarttime = tstarttime + T_guarda + t_slot[i-1];
00871                                 //ev<<" Tiempo de tslot de la onu "<<i-1<<" "<<t_slot[i-1]<<endl;
00872 
00873                                 // CREAMOS EL PAQUETE GATE QUE MANDA EL OLT PARA LAS DEMIS ONUS
00874                                 GATEmsg *packet = new GATEmsg("gate");
00875                                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00876                                 packet->setDestAddress(i); // DIRECCION DE DESTINO
00877                                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00878                                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00879                                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00880                                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00881                                 packet->setNumsla(numsla[i]); // IDENTIFICADOR DEL SLA DE LA ONU DE DESTINO
00882 
00883                                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00884                                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00885                                 {
00886                                         B_slot[0]= B_alloc[i]; // DEFINIMOS ANCHO DE BANDA DE SLOT
00887                                         packet->setGrant_IntervalTx(0,B_slot[0]);
00888                                 }
00889                                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00890                                 {
00891                                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00892                                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00893                                         for(int b=0; b<(int)par("numqueue"); b++)
00894                                         {
00895                                                 B_slot[b] = B_alloc[i]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00896                                                 packet->setGrant_IntervalTx(b,B_slot[b]);
00897                                                 //ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
00898                                         }
00899                                 }
00900                                 packet->setGrant_IniTime(tstarttime); // TIEMPO DE INICIO DE TRANSMISION
00901                                 /*
00902                                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
00903                                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
00904                                 ev<<" Paquete Gate."<<endl;
00905                                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00906                                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00907                                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00908                                 ev<<" Tipo "<<packet->getKind()<<endl;
00909                                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
00910                                 ev<<" SLA: "<<packet->getNumsla()<<endl;
00911                                 ev<<"  "<<endl;
00912                                 */
00913                                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00914                                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
00915 
00916                         }
00917 
00918                         sumbdemand = 0; // PONEMOS A 0 EL VALOR DE LA SUMA DEL ANCHO DE BANDA DEMANDADO DE TODAS LAS ONUS PARA EL PROXIMO CICLO
00919                         B_sobra = 0; // PONEMOS A 0 EL VALOR DEL ANCHO DE BANDA DE SOBRA PARA EL PROXIMO CICLO
00920                         B_exceded = 0; // PONEMOS A 0 EL VALOR DEL ANCHO DE BANDA EN EXCESO PARA EL PROXIMO CICLO
00921                 }
00922         }
00923 
00924         delete reportmsg; // BORRAMOS EL MENSAJE REPORT
00925 }

void MAC_OLT::DBA_polling_DaSPID ( cMessage msg  )  [protected, virtual]

Definition at line 1965 of file MAC_OLT.cc.

01966 {
01967         // NOTA:
01968         // BW_sla[], SW_SLA_onu[] --> Mbits
01969         // B_max_sla, sumqueue, B_demand[], BW_max_PID[], B_cycle, B_report,B_alloc[], B_alloc_total[], B_Mbps_sla[] --> bit
01970 
01971         //ev<<" EJECUTAMOS EL METODO IPACT DE POLLING CON EL ALGORITMO DaSPID." << endl;
01972         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg);
01973         //VARIABLES
01974         double txrate = (int)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
01975         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
01976         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
01977         double T_cycle = 0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
01978         double T_guarda = 0.000001; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
01979         double T_guarda_nonu = T_guarda*((int)par("numOnu")); // TIEMPO DE GUARDA TOTAL DE TODAS LAS ONUS
01980         double T_report_nonu = tasa_tx_report*((int)par("numOnu")); // TASA DE TRANSMISION TOTAL DE LOS PAQUETES REPORT DE TODAS LAS ONUS
01981         double T_cycle_total = T_cycle - T_guarda_nonu - T_report_nonu; // TIEMPO DE CICLO FINAL Y LO VISUALIZAMOS POR PANTALLA
01982         // T_cycle_total = 0.001975808s
01983         //ev<<" Tiempo de ciclo total: "<<T_cycle_total<<"s."<<endl;
01984         double T_tx_onu; // TIEMPO DE TRANSMISION DE UNA ONU
01985         long double B_cycle = txrate*T_cycle_total; // ANCHO DE BANDA MAXIMO DEL CICLO (BITS)
01986         // B_cycle = 1975808 bits = 246976 Bytes.
01987         //ev<<" Ancho de banda del ciclo: "<<B_cycle<<" Bits"<<endl;
01988         long double B_report = 512; // TAMANYO DEL PAQUETE REPORT (64 BYTES)
01989         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO EL NÚMERO DE COLAS QUE SE DEFINEN
01990         int srcAddress = 9; // DEFINICION DEL IDENTIFICADOR DE LA DIRECCION DE ORIGEN O FUENTE
01991         simtime_t time_tx_onu0; // TIEMPO DE TRANSIMISION DE LA PRIMERA ONU
01992         int onu = reportmsg->getSrcAddress(); // VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
01993         int lengthmethod = (int)par("methodlength_longvariable0_longfija1");
01994         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
01995         cTopology topo; // DEFINIMOS UN PARAMETRO DE LA TOPOLOGIA DE LA RED
01996         double longitud_total_red; // DEFINIMOS LA VARIABLE QUE NOS INDICA LA LONGITUD TOTAL DE LA RED
01997 
01998         // ASIGNACION DE PESOS
01999         Wsla[0] = (int)par("w_sla0"); // PESO DEL SLA0 DEFINIDO EN NUESTRA RED (1)
02000         Wsla[1] = (int)par("w_sla1"); // PESO DEL SLA1 DEFINIDO EN NUESTRA RED (2)
02001         Wsla[2] = (int)par("w_sla2"); // PESO DEL SLA2 DEFINIDO EN NUESTRA RED (3)
02002 
02003         // ASIGNACION DEL NUMERO DE ONUS
02004         numonu_sla[0] = (int)par("numonu_sla0"); // NUMERO DE ONUs ASOCIADO AL SLA0 (2)
02005         numonu_sla[1] = (int)par("numonu_sla1"); // NUMERO DE ONUs ASOCIADO AL SLA1 (6)
02006         numonu_sla[2] = (int)par("numonu_sla2"); // NUMERO DE ONUs ASOCIADO AL SLA2 (8)
02007 
02008         // ASIGNACION DE ANCHO DE BANDAS
02009         BW_sla[0] = (int)par("BW_garantizado0"); //ANCHO DE BANDA ASOCIADO AL SLA0 (100Mb)
02010         BW_sla[1] = (int)par("BW_garantizado1"); //ANCHO DE BANDA ASOCIADO AL SLA1 (75Mb)
02011         BW_sla[2] = (int)par("BW_garantizado2"); //ANCHO DE BANDA ASOCIADO AL SLA2 (50Mb)
02012 
02013         // ASIGNACION DE LOS LIMITES DE RETARDO MAXIMO (EN SEGUNDOS) POR CADA SLA Y PRIORIDAD:
02014         /* SLA 0: ONU[0] y ONU[1] */
02015         retardo_max_ONU[0][0] = 0.001*1.5;      // SLA0-P0: 1.5ms
02016         retardo_max_ONU[0][1] = 0.001*5;                // SLA0-P1: 5ms
02017         retardo_max_ONU[1][0] = 0.001*1.5;
02018         retardo_max_ONU[1][1] = 0.001*5;
02019         /* SLA 1: ONU[2], ONU[3], ONU[4], ONU[5], ONU[6] y ONU[7] */
02020         retardo_max_ONU[2][0] = 0.001*1.5;      // SLA1-P0: 1.5ms
02021         retardo_max_ONU[2][1] = 0.001*20;               // SLA1-P1: 20ms
02022         retardo_max_ONU[3][0] = 0.001*1.5;
02023         retardo_max_ONU[3][1] = 0.001*20;
02024         retardo_max_ONU[4][0] = 0.001*1.5;
02025         retardo_max_ONU[4][1] = 0.001*20;
02026         retardo_max_ONU[5][0] = 0.001*1.5;
02027         retardo_max_ONU[5][1] = 0.001*20;
02028         retardo_max_ONU[6][0] = 0.001*1.5;
02029         retardo_max_ONU[6][1] = 0.001*20;
02030         retardo_max_ONU[7][0] = 0.001*1.5;
02031         retardo_max_ONU[7][1] = 0.001*20;
02032         /* SLA 2: ONU[8], ONU[9], ONU[10], ONU[11], ONU[12], ONU[13], ONU[14] y ONU[15] */
02033         retardo_max_ONU[8][0] = 0.001*1.5;      // SLA2-P0: 1.5ms
02034         retardo_max_ONU[8][1] = 0.001*60;               // SLA2-P1: 60ms
02035         retardo_max_ONU[9][0] = 0.001*1.5;
02036         retardo_max_ONU[9][1] = 0.001*60;
02037         retardo_max_ONU[10][0] = 0.001*1.5;
02038         retardo_max_ONU[10][1] = 0.001*60;
02039         retardo_max_ONU[11][0] = 0.001*1.5;
02040         retardo_max_ONU[11][1] = 0.001*60;
02041         retardo_max_ONU[12][0] = 0.001*1.5;
02042         retardo_max_ONU[12][1] = 0.001*60;
02043         retardo_max_ONU[13][0] = 0.001*1.5;
02044         retardo_max_ONU[13][1] = 0.001*60;
02045         retardo_max_ONU[14][0] = 0.001*1.5;
02046         retardo_max_ONU[14][1] = 0.001*60;
02047         retardo_max_ONU[15][0] = 0.001*1.5;
02048         retardo_max_ONU[15][1] = 0.001*60;
02049 
02050         // CALCULAMOS EL DELAY O RETARDO DEPENDIENDO DE LA LONGITUD DE NUESTRA RED
02051         switch(lengthmethod)
02052         {
02053                 case 0:
02054                         // METODO DE LONGITUD VARIABLE
02055                         topo.extractByParameter( "numlong" ); // EXTRAEMOS LOS NODOS DE NUESTRA RED QUE UTILIZAN EL PARIMETRO numlong
02056                         delay_pon1 = ((int)par("longpon1")*3)/(velocidad*2); // CALCULAMOS EL RETARDO DEL SEGMENTO DE LA RED QUE UNE EL OLT Y EL SPLITTER
02057                         // RECORREMOS CON EL BUCLE FOR TODAS LAS ONUS PARA CALCULAR EL RETARDO DEL CANAL QUE UNE EL SPLITTER CON CADA ONU
02058                         for(int i=0; i<(int)par("numOnu"); i++)
02059                         {
02060                                 cModule *module = getParentModule()->getParentModule()->getSubmodule("onu", i); // DEFINIMOS EL PARIMETRO MODULE QUE NOS INDICA EL CAMINO HASTA EL NODO DEL QUE QUEREMOS OBTENER INFORMACION
02061                                 cTopology::Node *nodeonuOut = topo.getNodeFor(module); // NOMBRE DEL NODO QUE SACAMOS DEL GRAFO
02062                                 // RECORREMOS CON EL BUCLE FOR TODOS LOS ENLACES DE SALIDA QUE TIENE ESE NODO PARA OBTENER LA INFORMACION QUE SOLICITAMOS
02063                                 for(int j=0; j<nodeonuOut->getNumOutLinks(); j++)
02064                                 {
02065                                         delay_pon2[i] = (check_and_cast<cDelayChannel*>(nodeonuOut->getLinkOut(j)->getLocalGate()->getChannel()))->getDelay();
02066                                         //ev<<" Retardo Onu"<<i<<": "<<delay_pon2[i]<<endl; // VISUALIZAMOS EL VALOR DEL RETARDO
02067                                         delay_total[i] = delay_pon1 + delay_pon2[i]; // CALCULAMOS EL RETARDO TOTAL DE LA RED Y LO VISUALIZAMOS
02068                                         //ev<<" Retardo Total de la red PON: "<<delay_total[i]<<endl;
02069                                 }
02070                         }
02071                         break;
02072 
02073                 case 1:
02074                         // METODO DE LONGITUD FIJA
02075                         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARIMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
02076                         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
02077                         break;
02078 
02079                 default:
02080                         ev<<"Error al elegir el metodo de longitudes."<<endl;
02081                         break;
02082         }
02083         // OBTENEMOS Y VISUALIZAMOS POR PANTALLA EL TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE
02084         // COMPARAMOS SI SE TRATA DE LONGITUD DE LA RED VARIABLE O LONGITUD DE LA RED FIJA
02085         if((int)par("methodlength_longvariable0_longfija1")==0)
02086         {
02087                 // METODO DE LONGITUD VARIABLE
02088                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS ALEATORIAS
02089                 tiempo_sim_delay_datarate = simTime() + delay_total[onu] + tasa_tx_gate;
02090                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
02091         }
02092         else if((int)par("methodlength_longvariable0_longfija1")==1)
02093         {
02094                 // METODO DE LONGITUD FIJA
02095                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS FIJAS
02096                 tiempo_sim_delay_datarate = simTime() + delay + tasa_tx_gate;
02097                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
02098         }
02099 
02100         for(int j=0; j<(int)par("numSLA"); j++)
02101         {
02102                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
02103                 for(int i=0; i<numonu_sla[j]; i++)
02104                 {
02105                         SLA_onu[id_onu+i] = Wsla[j]; // ASIGANAMOS A LA VARIABLE SLA_onu[] EL VALOR DEL PESO DEL SLA AL QUE ESTA ASOCIADA ESA ONU
02106                         BW_SLA_onu[id_onu+i] = BW_sla[j]; //ASIGNAMOS A LA VARIABLE BW_SLA_onu[] EL VALOR DEL ANCHO DE BANDA GARANTIZADO POR SLA
02107                         //ev<<" ONU "<<id_onu+i<<": Peso="<<Wsla[j]<<endl; // VISUALIZAMOS EL PESO ASOCIADO A CADA ONU
02108                         numsla[id_onu+i] = j; // INTRODUCIMOS EN LA VARIABLE numsla[] EL IDENTIFICADOR DEL SLA PARA CADA ONU YA QUE LO UTILIZAREMOS PARA RECOGER EL RETARDO DE CADA SLA
02109                         numero_sla[id_onu+i]=j;
02110                         // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU
02111                         if(i==(numonu_sla[j]-1))
02112                         {
02113                                         id_onu=id_onu+1+i;
02114                         }
02115                 }
02116         }
02117         id_onu=0; // IGUALAMOS EL IDENTIFICADOR DE LA ONU AL VALOR 0
02118 
02119         // RECORREMOS MEDIANTE ESTE BUCLE FOR LOS SLAs DEFINIDOS EN NUESTRA RED PARA REALIZAR EL SUMATORIO PARA CALCULAR EL ANCHO DE BANDA ASOCIADO A CADA SLA
02120         for(int i=0; i<(int)par("numSLA"); i++)
02121         {
02122                         sumatorio = sumatorio + (numonu_sla[i]*Wsla[i]); // CALCULAMOS EL SUMATORIO Y LO VISUALIZAMOS POR PANTALLA
02124         }
02125         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA DE CADA ONU ASIGNADO POR EL SLA QUE CORRESPONDE A CADA ONU
02126         // (SOLO LA PRIMERA VEZ)
02127         if(prueba==0)
02128         {
02129                 for(int j=0; j<(int)par("numSLA"); j++)
02130                 {
02131                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
02132                         for(int i=0; i<numonu_sla[j]; i++)
02133                         {
02134                                 B_max_sla[id+i] = B_cycle*Wsla[j]/sumatorio; // CALCULAMOS EL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU
02136                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU:
02137                                 if(i==(numonu_sla[j]-1))
02138                                 {
02139                                         id=id+1+i;
02140                                 }
02141                         }
02142                 }
02143                 prueba=1;
02144         }
02145         id=0;
02146         sumatorio = 0; // DAMOS EL VALOR 0 AL SUMATORIO PARA QUE NO SE INCREMENTE
02147         //VAMOS A CALCULAR EL ANCHO DE BANDA DEMANDADO Y LO GUARDAMOS EN LA TABLA
02148         //ev<<" Calculamos el Bandwidth demandado y lo guardamos en la tabla del OLT."<<endl;
02149         // SUMAMOS EL TAMANYO DEL ESTADO DE LAS COLAS DE LA ONU QUE HA MANDADO EL REPORT QUE LLEGA AL OLT
02150         for(int i=0; i<(int)par("numqueue"); i++)
02151         {
02152                 //ev<<" Bytes en la cola P" << i << " de la ONU[" << onu << "]: " << reportmsg->getQueue_estado(i) << endl;
02153                 sumqueue = sumqueue + (reportmsg->getQueue_estado(i)*8);
02154         }
02155         //ev<<" Total bits presentes en las colas de la ONU[" << onu << "]: " << sumqueue << endl;
02156         // SI LA SUMA TOTAL DEL TAMANYO DE LAS COLAS ES 0, DAMOS UN VALOR PREDETERMINADO DE 20 BYTES
02157         if(sumqueue == 0)
02158         {
02159                 sumqueue = 20*8; //POR 8 PARA PASARLO A BITS
02160         }
02161         // ASIGNAMOS LA SUMA TOTAL A LA VARIABLE DEL ANCHO DE BANDA DEMANDADO DE LA ONU
02162         B_demand[onu] = sumqueue; //bits
02163         sumqueue = 0;// DAMOS EL VALOR 0 A LA SUMA DE LAS COLAS, PARA LA PROXIMA ASIGNACION DE BW
02164         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE EL ANCHO DE BANDA DEMANDADO POR LA ONU Y LO VISUALIZAMOS POR PANTALLA
02165         table_module->table_olt_report[onu][(int)par("numqueue")] = B_demand[onu];
02166         //ev<<" ONU[" << onu << "] --> " << "Bandwidth Demandado: " << B_demand[onu] << " Bits" << endl;
02167 
02168         // ASIGNACION A CADA ONU DEL ANCHO DE BANDA MAXIMO, SEGUN SU SLA:
02169         // (SOLO LA PRIMERA VEZ)
02170         if(intento==0)
02171         {
02172                 for(int j=0 ; j<(int)par("numOnu"); j++)
02173                 {
02174                         BW_max_PID[j]=B_max_sla[j]; //bits
02175 
02176                 }
02177                 intento=1;
02178         }
02179 
02180         // **EJECUTAMOS EL ALGORITMO IPACT YA QUE SE EJECUTA CADA VEZ QUE LLEGA UN MENSAJE REPORT DESDE LAS ONUS**
02181         // NOTA:
02182         // BW_sla[], SW_SLA_onu[] --> Mbits
02183         // B_max_sla, sumqueue, B_demand[], BW_max_PID[], B_cycle, B_report,B_alloc[], B_alloc_total[], B_Mbps_sla[] --> bit
02184         //ev<<" Ancho de banda maximo por PID para la ONU[" << onu << "]: " << BW_max_PID[onu] << " bits" << endl;
02185         //ev<<"  --> " << "Bandwidth maximo para su SLA (sin contar los 512 bits del Report): " << B_max_sla[onu] << " Bits" << endl;
02186 
02187         // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
02188         if(B_demand[onu] <= B_max_sla[onu])
02189         {
02190                 B_alloc[onu] = B_demand[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
02191                 pet[onu]=0;
02192         }
02193         else if(B_demand[onu] > B_max_sla[onu])
02194         {
02195                 B_alloc[onu] = B_max_sla[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
02196                 pet[onu]=1;
02197         }
02198         // En el caso de no haber bits en las colas de la ONU:
02199         // B_alloc[onu] = B_demand[onu](160b) + B_report(512b) = 672 bits.
02200         //ev<<"  --> " << "Bandwidth asignado para el proximo periodo: " << B_alloc[onu] << " Bits" << endl;
02201         /*
02202         //PET para Controlar DElay!!!!!!!!!!!!!!!
02203         //Se pone a principio de ciclo de 1 en vez de a 0 xq el PID tiene que estar activo siempre en todas las ONUs hasta que todas cumplan con los retardos
02204         if(onu==0)
02205         {
02206                 for(int i=0; i<(int)par("numOnu"); i++)
02207                 {
02208                         pet[i]=1;
02209 
02210                 }
02211         }
02212         */
02213         if(simTime()>2)
02214         {
02215                 recoger_bw_por_onu(msg);
02216         }
02217         /* PARA HACER LA VENTANA POR SLAs Y PRIORIDADES (P0 y P1) */
02218         // Si el Report recibido es de la ultima ONU del array, el ciclo para calcular el retardo ha acabado.
02219         // Por tanto, ahora se hacen las medias del retardo y se actualiza la ventana.
02220         if(onu==(int)par("numOnu")-1)
02221         {
02222                 int prioridades = 2; // Clases de servicio de las que se controla el retardo con el PID (P0 y P1)
02223                 double delay_sla[(int)par("numSLA")][prioridades]; // Suma del retardo de todos los paquetes recibidos en un ciclo de cada SLA y prioridad
02224                 int paquetes_sla[(int)par("numSLA")][prioridades]; // Numero total de paquetes recibidos en un ciclo de cada SLA y prioridad
02225 
02226                 // Se ponen a cero todas las variables auxiliares para este nuevo ciclo:
02227                 for(int i=0; i<(int)par("numSLA"); i++)
02228                 {
02229                         for(int j=0; j<prioridades; j++)
02230                         {
02231                                 delay_sla[i][j]=0.0;
02232                                 paquetes_sla[i][j]=0;
02233                         }
02234                 }
02235                 int acum=0, k=0;
02236                 for (int j=0; j<(int)par("numSLA"); j++)
02237                 {
02238                         for(k=acum; k<numonu_sla[j]+acum; k++)
02239                         {
02240                                 for(int p=0; p<prioridades; p++)
02241                                 {
02242                                         // Aunque se va imprimiendo con cada actualizacion de cada onu de cada sla, el valor correcto
02243                                         // del retardo total y numero de paquetes de cada sla es el ultimo que sale impreso en el Tkenv.
02244                                         delay_sla[j][p]=delay_sla[j][p]+delay_onu[k][p];
02245                                         //ev<<" Retardo de los paquetes del SLA " << j << " con prioridad P" << p << ": " << delay_sla[j][p] << " segundos." << endl;
02246                                         paquetes_sla[j][p]=paquetes_sla[j][p] + paq_onu[k][p];
02247                                         //ev<<" Paquetes recibidos en el SLA " << j << " con prioridad P" << p << ": " << paquetes_sla[j][p] << endl;
02248                                         delay_onu[k][p]=0.0; // Para el siguiente ciclo
02249                                         paq_onu[k][p]=0.0; // Para el siguiente ciclo
02250                                 }
02251                         }
02252                         acum=k;
02253                         for(int p=0; p<prioridades; p++)
02254                         {
02255                                 if(paquetes_sla[j][p]>0) //Si hay algún paquete, entonces puedo dividir para sacar el delay:
02256                                 {
02257                                         recoger_delay_por_sla(j, (double)(delay_sla[j][p]/paquetes_sla[j][p]), p);
02258                                 }
02259                         }
02260                 }
02261                 //Fin ventana SLAS
02262         }
02263         // Se ajusta el BW al finalizar el ciclo:
02264         if((simTime()>tiempo_PID) && (onu==(int)par("numOnu")-1))
02265         {
02266                 int cumplen=0;
02267                 // **PARA DAR PRIORIDAD AL SLA0 Y SLA1 SI NO CUMPLEN TODOS**
02268                 // Comprobamos que cumplen los SLAs prioritarios:
02269                 int acum=0;
02270                 int k=0;
02271                 for (int j=0; j<(int)par("numSLA"); j++)
02272                 {
02273                         for(k=acum; k<numonu_sla[j]+acum; k++)
02274                         {
02276                                 if((j==0)||(j==1))
02277                                 {
02278                                         if (retardo_alg_ONU[k][1]<retardo_max_ONU[k][1])
02279                                         {
02280                                                 cumplen++;
02281                                         }
02282                                 }
02283                         }
02284                         acum=k;
02285                 }
02286                 if(no_capacidad==1)
02287                 {
02288                         flag_control_delay=1; // Si no hay capacidad para todas las ONUs.
02289                 }
02290                 else
02291                 {
02292                         if(cumplen==(numonu_sla[0]+numonu_sla[1]))
02293                         {
02294                                 flag_control_delay=0; // Si cumplen todas las ONUs.
02295                         }
02296                         else
02297                         {
02298                                 flag_control_delay=1; // Si no cumplen todas las ONUs.
02299                         }
02300                 }
02301         }
02302         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
02303         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
02304         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<" Bits"<<endl;
02305         T_alloc[onu] = B_alloc[onu]/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
02306         T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
02307 
02308         //CREAMOS EL PAQUETE GATE PARA LA ONU
02309         GATEmsg *packet = new GATEmsg("gate");
02310         packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
02311         packet->setDestAddress(onu); // DIRECCION DE DESTINO
02312         packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
02313         packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
02314         packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
02315         packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
02316         packet->setNumsla(numero_sla[onu]);
02317         // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
02318         if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
02319         {
02320                 B_slot[0]= B_alloc[onu]/8; // DEFINIMOS ANCHO DE BANDA DE SLOT
02321                 packet->setGrant_IntervalTx(0,B_slot[0]);
02322         }
02323         else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
02324         {
02325                 //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
02326                 // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
02327                 for(int b=0; b<(int)par("numqueue"); b++)
02328                 {
02329                         B_slot[b] = B_alloc[onu]/8; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA (BYTES)
02330                         packet->setGrant_IntervalTx(b,B_slot[b]);
02331                 }
02332         }
02333         /*
02334         // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
02335         ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
02336         ev<<" Paquete Gate."<<endl;
02337         ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
02338         ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
02339         ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
02340         ev<<" Tipo "<<packet->getKind()<<endl;
02341         ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
02342         ev<<" SLA: "<<packet ->getNumsla()<<endl;
02343         ev<<"  "<<endl;
02344         */
02345         // NOTA: "tiempo_tx_siguiente" --> Tiempo de inicio del proximo ciclo de transmision de la ONU.
02346         //                       "tiempo_sim_delay_datarate" --> simTime() + Retardo propagacion + Tiempo de tx de un paquete Gate.
02347         // Si el inicio del proximo ciclo es menor que el tiempo en que ha de llegar a la ONU el Gate que ahora
02348         // va a enviarle el OLT...
02349         if(tiempo_tx_siguiente <= tiempo_sim_delay_datarate)
02350         {
02351                 //ev<<" **CASO A. Tiempo de Transmision siguiente menor que la suma del tiempo actual con el retardo de propagacion y el tiempo de transmision de un Gate.**"<<endl;
02352                 packet->setGrant_IniTime(tiempo_sim_delay_datarate); // TIEMPO DE INICIO DE TRANSMISION
02353                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
02354                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
02355                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU:
02356                 tiempo_tx_siguiente = tiempo_sim_delay_datarate + T_tx_onu;
02357         }
02358         // Si el inicio del proximo ciclo es mayor que el tiempo en que ha de llegar a la ONU el Gate que ahora
02359         // va a enviarle el OLT...
02360         else if(tiempo_tx_siguiente > tiempo_sim_delay_datarate)
02361         {
02362                 //ev<<" **CASO B. Tiempo de Transmision siguiente mayor que la suma del tiempo actual con el retardo de propagacion y el tiempo de transmision de un Gate.**"<<endl;
02363                 packet->setGrant_IniTime(tiempo_tx_siguiente); // TIEMPO DE INICIO DE TRANSMISION
02364                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
02365                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
02366                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU:
02367                 tiempo_tx_siguiente = tiempo_tx_siguiente + T_tx_onu;
02368         }
02369         //ev<<" Tiempo de Transmision Siguiente: T="<<tiempo_tx_siguiente<<endl;
02370 
02371         // ADICION DEL ANCHO DE BANDA ASIGNADO EN ESTE CICLO AL ANCHO DE BANDA ASIGNADO EN TOTAL:
02372         B_alloc_total[onu]=B_alloc_total[onu]+B_alloc[onu]; //B_ALLOC TOTAL EN Bits
02373         //ev<<" B_ALLOC_TOTAL "<<B_alloc_total[onu]<<" onu: "<<onu<<endl;
02374         //B_Mbps[onu]=B_alloc_total[onu]/(SIMTIME_DBL(simTime()));
02375 
02376         // ALMACENAMIENTO DEL ANCHO DE BANDA ACUMULADO PARA CALCULAR EL THROUGHPUT POR SLA AL HACER FINISH:
02377         if(onu<2)
02378         {
02379                 B_Mbps_sla[0]=B_Mbps_sla[0]+(B_alloc[onu]-B_report);
02380         }
02381         else if(onu>=2 && onu<8)
02382         {
02383                 B_Mbps_sla[1]=B_Mbps_sla[1]+(B_alloc[onu]-B_report);
02384         }
02385         else if(onu>=8 && onu<16 )
02386         {
02387                 B_Mbps_sla[2]=B_Mbps_sla[2]+(B_alloc[onu]-B_report);
02388         }
02389         delete reportmsg; // BORRAMOS EL MENSAJE REPORT
02390 
02391         if(simTime()> 10*cont_auxiliar)
02392         {
02393                 cont_auxiliar++;
02394                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL BW ASIGNADO A CADA SLA:
02395                 B_alloc_periodico=fopen("results/B_alloc.txt", "a+");
02396                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02397                 fprintf(B_alloc_periodico," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)B_alloc[0], (double)B_alloc[2], (double)B_alloc[8]);
02398                 fclose(B_alloc_periodico);
02399         }
02400 }

void MAC_OLT::DBA_polling_PID ( cMessage msg  )  [protected, virtual]

Definition at line 1563 of file MAC_OLT.cc.

01564 {
01565         // NOTA:
01566         // BW_sla[], SW_SLA_onu[] --> Mbits
01567         // B_max_sla, sumqueue, B_demand[], BW_max_PID[], B_cycle, B_report,B_alloc[], B_alloc_total[], B_Mbps_sla[] --> bit
01568 
01569         ev<<" EJECUTAMOS EL METODO IPACT DE POLLING CON EL ALGORITMO PID."<<endl;
01570         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
01571         //VARIABLES
01572         double txrate = (int)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
01573         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
01574         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
01575         double T_cycle = 0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
01576         double T_guarda = 0.000001; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
01577         double T_guarda_nonu = T_guarda*((int)par("numOnu")); // TIEMPO DE GUARDA TOTAL DE TODAS LAS ONUS
01578         double T_report_nonu = tasa_tx_report*((int)par("numOnu")); // TASA DE TRANSMISION TOTAL DE LOS PAQUETES REPORT DE TODAS LAS ONUS
01579         double T_cycle_total = T_cycle - T_guarda_nonu - T_report_nonu; // TIEMPO DE CICLO FINAL Y LO VISUALIZAMOS POR PANTALLA
01580         //ev<<" Tiempo de ciclo total: "<<T_cycle_total<<"s"<<endl;
01581         double T_tx_onu; // TIEMPO DE TRANSMISION DE UNA ONU
01582         long double B_cycle = txrate*T_cycle_total; // ANCHO DE BANDA MAXIMO DEL CICLO EN BITS
01583         //ev<<" Ancho de banda del ciclo: "<<B_cycle<<"Bytes"<<endl;
01584         long double B_report = txrate*tasa_tx_report/8; // TAMANYO DEL PAQUETE REPORT
01585         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO EL NÚMERO DE COLAS QUE SE DEFINEN
01586         int srcAddress = 9; // DEFINICION DEL IDENTIFICADOR DE LA DIRECCION DE ORIGEN O FUENTE
01587         simtime_t time_tx_onu0; // TIEMPO DE TRANSIMISION DE LA PRIMERA ONU
01588         int onu = reportmsg->getSrcAddress(); // VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
01589         int lengthmethod = (int)par("methodlength_longvariable0_longfija1");
01590         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
01591         cTopology topo; // DEFINIMOS UN PARAMETRO DE LA TOPOLOGIA DE LA RED
01592         double longitud_total_red; // DEFINIMOS LA VARIABLE QUE NOS INDICA LA LONGITUD TOTAL DE LA RED
01593 
01594         // ASIGANCION DE PESOS
01595         Wsla[0] = (int)par("w_sla0"); // PESO DEL SLA0 DEFINIDO EN NUESTRA RED
01596         Wsla[1] = (int)par("w_sla1"); // PESO DEL SLA1 DEFINIDO EN NUESTRA RED
01597         Wsla[2] = (int)par("w_sla2"); // PESO DEL SLA2 DEFINIDO EN NUESTRA RED
01598 
01599         // ASIGNACION DEL NÚMERO DE ONUS
01600         numonu_sla[0] = (int)par("numonu_sla0"); // NÚMERO DE ONUs ASOCIADO AL SLA0
01601         numonu_sla[1] = (int)par("numonu_sla1"); // NÚMERO DE ONUs ASOCIADO AL SLA1
01602         numonu_sla[2] = (int)par("numonu_sla2"); // NÚMERO DE ONUs ASOCIADO AL SLA2
01603 
01604         //ASIGNACION DE ANCHO DE BANDAS
01605         BW_sla[0] = (int)par("BW_garantizado0"); //ANCHO DE BANDA ASOCIADO AL SLA0
01606         BW_sla[1] = (int)par("BW_garantizado1"); //ANCHO DE BANDA ASOCIADO AL SLA1
01607         BW_sla[2] = (int)par("BW_garantizado2"); //ANCHO DE BANDA ASOCIADO AL SLA2
01608 
01609         // CALCULAMOS EL DELAY O RETARDO DEPENDIENDO DE LA LONGITUD DE NUESTRA RED
01610         switch(lengthmethod)
01611         {
01612                 case 0:
01613                         // METODO DE LONGITUD VARIABLE
01614                         topo.extractByParameter( "numlong" ); // EXTRAEMOS LOS NODOS DE NUESTRA RED QUE UTILIZAN EL PARAMETRO numlong
01615                         delay_pon1 = ((int)par("longpon1")*3)/(velocidad*2); // CALCULAMOS EL RETARDO DEL SEGMENTO DE LA RED QUE UNE EL OLT Y EL SPLITTER
01616                         // RECORREMOS CON EL BUCLE FOR TODAS LAS ONUS PARA CALCULAR EL RETARDO DEL CANAL QUE UNE EL SPLITTER CON CADA ONU
01617                         for(int i=0; i<(int)par("numOnu"); i++)
01618                         {
01619                                 cModule *module = getParentModule()->getParentModule()->getSubmodule("onu", i); // DEFINIMOS EL PARAMETRO MODULE QUE NOS INDICA EL CAMINO HASTA EL NODO DEL QUE QUEREMOS OBTENER INFORMACION
01620                                 cTopology::Node *nodeonuOut = topo.getNodeFor(module); // NOMBRE DEL NODO QUE SACAMOS DEL GRAFO
01621                                 // RECORREMOS CON EL BUCLE FOR TODOS LOS ENLACES DE SALIDA QUE TIENE ESE NODO PARA OBTENER LA INFORMACION QUE SOLICITAMOS
01622                                 for(int j=0; j<nodeonuOut->getNumOutLinks(); j++)
01623                                 {
01624                                         delay_pon2[i] = (check_and_cast<cDelayChannel*>(nodeonuOut->getLinkOut(j)->getLocalGate()->getChannel()))->getDelay();
01625                                         //ev<<" Retardo Onu"<<i<<": "<<delay_pon2[i]<<endl; // VISUALIZAMOS EL VALOR DEL RETARDO
01626                                         delay_total[i] = delay_pon1 + delay_pon2[i]; // CALCULAMOS EL RETARDO TOTAL DE LA RED Y LO VISUALIZAMOS
01627                                         //ev<<" Retardo Total de la red PON: "<<delay_total[i]<<endl;
01628                                 }
01629                         }
01630                         break;
01631 
01632                 case 1:
01633                         // METODO DE LONGITUD FIJA
01634                         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
01635                         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
01636                         break;
01637 
01638                 default:
01639                         ev<<"Error al elegir el metodo de longitudes."<<endl;
01640                         break;
01641 
01642         }
01643 
01644         // OBTENEMOS Y VISUALIZAMOS POR PANTALLA EL TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE
01645         // COMPARAMOS SI SE TRATA DE LONGITUD DE LA RED VARIABLE O LONGITUD DE LA RED FIJA
01646         if((int)par("methodlength_longvariable0_longfija1")==0)
01647         {
01648                 // METODO DE LONGITUD VARIABLE
01649                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS ALEATORIAS
01650                 tiempo_sim_delay_datarate = simTime() + delay_total[onu] + tasa_tx_gate;
01651                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
01652         }
01653         else if((int)par("methodlength_longvariable0_longfija1")==1)
01654         {
01655                 // METODO DE LONGITUD FIJA
01656                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS FIJAS
01657                 tiempo_sim_delay_datarate = simTime() + delay + tasa_tx_gate;
01658                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
01659         }
01660 
01661         for(int j=0; j<(int)par("numSLA"); j++)
01662         {
01663                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01664                 for(int i=0; i<numonu_sla[j]; i++)
01665                 {
01666                         SLA_onu[id_onu+i] = Wsla[j]; // ASIGANAMOS A LA VARIABLE SLA_onu[] EL VALOR DEL PESO DEL SLA AL QUE ESTA ASOCIADA ESA ONU
01667                         BW_SLA_onu[id_onu+i] = BW_sla[j]; //ASIGNAMOS A LA VARIABLE BW_SLA_onu[] EL VALOR DEL ANCHO DE BANDA GARANTIZADO POR SLA
01668                         //ev<<" ONU "<<id_onu+i<<": Peso="<<Wsla[j]<<endl; // VISUALIZAMOS EL PESO ASOCIADO A CADA ONU
01669                         numsla[id_onu+i] = j; // INTRODUCIMOS EN LA VARIABLE numsla[] EL IDENTIFICADOR DEL SLA PARA CADA ONU YA QUE LO UTILIZAREMOS PARA RECOGER EL RETARDO DE CADA SLA
01670                         numero_sla[id_onu+i]=j;
01671                         // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU
01672                         if(i==(numonu_sla[j]-1))
01673                         {
01674                                         id_onu=id_onu+1+i;
01675                         }
01676                 }
01677         }
01678         id_onu=0; // IGUALAMOS EL IDENTIFICADOR DE LA ONU AL VALOR 0
01679 
01680         // RECORREMOS MEDIANTE ESTE BUCLE FOR LOS SLAs DEFINIDOS EN NUESTRA RED PARA REALIZAR EL SUMATORIO PARA CALCULAR EL ANCHO DE BANDA ASOCIADO A CADA SLA
01681         for(int i=0; i<(int)par("numSLA"); i++)
01682         {
01683                         sumatorio = sumatorio + (numonu_sla[i]*Wsla[i]); // CALCULAMOS EL SUMATORIO Y LO VISUALIZAMOS POR PANTALLA
01684                         //ev<<" Sumatorio: "<<sumatorio<<endl;
01685         }
01686 
01687         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA DE CADA ONU ASIGNADO POR EL SLA QUE CORRESPONDE A CADA ONU
01688         // (SOLO LA PRIMERA VEZ)
01689         if(prueba==0)
01690         {
01691                 for(int j=0; j<(int)par("numSLA"); j++)
01692                 {
01693                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01694                         for(int i=0; i<numonu_sla[j]; i++)
01695                         {
01696                                 B_max_sla[id+i] = B_cycle*Wsla[j]/sumatorio; // CALCULAMOS EL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU
01697                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU QUE
01698                                 if(i==(numonu_sla[j]-1))
01699                                 {
01700                                                                         id=id+1+i;
01701                                 }
01702                         }
01703                 }
01704                 prueba=1;
01705         }
01706         id=0;
01707         sumatorio = 0; // DAMOS EL VALOR 0 AL SUMATORIO PARA QUE NO SE INCREMENTE
01708 
01709         //VAMOS A CALCULAR EL ANCHO DE BANDA DEMANDADO Y LO GUARDAMOS EN LA TABLA
01710         //ev<<" Calculamos el Bandwidth Demandado y lo guardamos en la tabla del OLT."<<endl;
01711         // SUMAMOS EL TAMANYO DEL ESTADO DE LAS COLAS DE LA ONU QUE A MANDADO EL REPORT QUE LLEGA AL OLT
01712         for(int i=0; i<(int)par("numqueue"); i++)
01713         {
01714                 sumqueue = sumqueue + (reportmsg->getQueue_estado(i)*8);
01715         }
01716         // SI LA SUMA TOTAL DEL TAMANYO DE LAS COLAS ES 0, DAMOS UN VALOR PREDETERMINADO DE 20 BYTES
01717         if(sumqueue == 0)
01718         {
01719                 sumqueue = 20*8; //POR 8 PARA PASARLO A BITS
01720         }
01721 
01722         // ASIGNAMOS LA SUMA TOTAL A LA VARIABLE DEL ANCHO DE BANDA DEMANDADO DE LA ONU
01723         //ev<<" sumqueue "<<sumqueue<<endl;
01724         B_demand[onu] = sumqueue;
01725 
01726         sumqueue = 0;// DAMOS EL VALOR 0 A LA SUMA DE LAS COLAS. DE ESTA MANERA LA INICIALIZAMOS DE NUEVO A 0
01727 
01728         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE EL ANCHO DE BANDA DEMANDADO POR LA ONU Y LO VISUALIZAMOS POR PANTALLA
01729         table_module->table_olt_report[onu][(int)par("numqueue")] = B_demand[onu];
01730         //ev<<"ONU "<< onu<<"->"<< "Bandwidth Demandado: "<< B_demand[onu]<<" Bits"<<endl; //cambiado
01731 
01732         //CALCULAMOS ANCHO DE BANDA MAXIMO DE CADA ONU DEPENDIENDO DEL SLA
01733         // (SOLO LA PRIMERA VEZ)
01734         if(intento==0)
01735         {
01736                 for(int j=0 ; j<(int)par("numOnu"); j++)
01737                 {
01738                         BW_max_PID[j]=B_max_sla[j];
01739                 }
01740                 intento=1;
01741         }
01742         /*
01743         for(int i=0; i<(int)par("numOnu"); i++)
01744         {
01745                 ev<<"ANCHO DE BANDA MAXIMO PARA ONU "<<i<<" : "<<B_max_sla[i]<<endl;
01746         }
01747         */
01748 
01749         // EJECUTAMOS EL ALGORITMO IPACT YA QUE SE EJECUTA CADA VEZ QUE LLEGA UN MENSAJE REPORT DESDE LAS ONUS
01750         if(tiempo_tx_siguiente <= tiempo_sim_delay_datarate)
01751         {
01752                 //ev<<" **CASO A. Tiempo de Transmision siguiente menor.**"<<endl;
01753 
01754                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
01755                 if(B_demand[onu] <= B_max_sla[onu])
01756                 {
01757                         //ev<<" ANCHO DE BANDA MAXIMO PARA ONU "<<onu<<" => "<<B_max_sla[onu]<<endl;
01758                         B_alloc[onu] = B_demand[onu] + B_report*8; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
01759 
01760                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01761                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01762                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<" Bits"<<endl;
01763 
01764                         T_alloc[onu] = B_alloc[onu]/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01765 
01766                         if(simTime()>=1)
01767                         {
01768                                 recoger_bw_por_onu(msg);
01769                                 calcularvarianza(msg);
01770                         }
01771                         pet[onu]=0;
01772                 }
01773                 else if(B_demand[onu] > B_max_sla[onu])
01774                 {
01775                         //ev<<" ANCHO DE BANDA MAXIMO PARA ONU "<<onu<<" => "<<B_max_sla[onu]<<endl;
01776                         B_alloc[onu] = B_max_sla[onu] + B_report*8; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
01777 
01778                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01779                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01780                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<" Bits"<<endl;
01781 
01782                         T_alloc[onu] = B_alloc[onu]/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01783 
01784                         if(simTime()>=1)
01785                         {
01786                                 recoger_bw_por_onu(msg);
01787                                 calcularvarianza(msg);
01788                         }
01789 
01790                         //ACTIVAMOS EL PID
01791                         pet[onu]=1;
01792                 }
01793 
01794                 T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
01795 
01796                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01797                 GATEmsg *packet = new GATEmsg("gate");
01798                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01799                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01800                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01801                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01802                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01803                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01804                 packet->setNumsla(numero_sla[onu]);
01805 
01806 
01807                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01808                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01809                 {
01810                         B_slot[0]= B_alloc[onu]/8; // DEFINIMOS ANCHO DE BANDA DE SLOT
01811                         packet->setGrant_IntervalTx(0,B_slot[0]);
01812                 }
01813                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01814                 {
01815                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
01816                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01817                         for(int b=0; b<(int)par("numqueue"); b++)
01818                         {
01819                                 B_slot[b] = B_alloc[onu]/8; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01820                                 packet->setGrant_IntervalTx(b,B_slot[b]);
01821                         }
01822                 }
01823                 packet->setGrant_IniTime(tiempo_sim_delay_datarate); // TIEMPO DE INICIO DE TRANSMISION
01824                 /*
01825                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01826                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01827                 ev<<" Paquete Gate."<<endl;
01828                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01829                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01830                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01831                 ev<<" Tipo "<<packet->getKind()<<endl;
01832                 ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
01833                 ev<<" SLA: "<<packet ->getNumsla()<<endl;
01834                 ev<<"  "<<endl;
01835                 */
01836                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01837                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01838                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU
01839                 tiempo_tx_siguiente = tiempo_sim_delay_datarate + T_tx_onu;
01840                 //ev<<" Tiempo de Transmision Siguiente: "<<tiempo_tx_siguiente<<endl;
01841         }
01842         else if(tiempo_tx_siguiente > tiempo_sim_delay_datarate)
01843         {
01844                 //ev<<" **CASO B. Tiempo de Transmision siguiente mayor.**"<<endl;
01845 
01846                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
01847                 if(B_demand[onu] <= B_max_sla[onu])
01848                 {
01849                         //ev<<" ANCHO DE BANDA MAXIMO PARA ONU "<<onu<<" => "<<B_max_sla[onu]<<endl;
01850                         B_alloc[onu] = B_demand[onu] + B_report*8; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
01851 
01852                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01853                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01854                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<" Bits"<<endl;
01855 
01856                         T_alloc[onu] = B_alloc[onu]/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01857 
01858                         if(simTime()>=1)
01859                         {
01860                                 recoger_bw_por_onu(msg);
01861                                 calcularvarianza(msg);
01862                         }
01863                         pet[onu]=0;
01864                 }
01865                 else if(B_demand[onu] > B_max_sla[onu])
01866                 {
01867                         //ev<<" ANCHO DE BANDA MAXIMO PARA ONU "<<onu<<" => "<<B_max_sla[onu]<<endl;
01868                         B_alloc[onu] = B_max_sla[onu] + B_report*8; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
01869 
01870                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01871                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01872                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<" Bits"<<endl;
01873 
01874                         T_alloc[onu] = B_alloc[onu]/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01875 
01876                         if(simTime()>=1)
01877                         {
01878                                 recoger_bw_por_onu(msg);
01879                                 calcularvarianza(msg);
01880                         }
01881                         //ACTIVAMOS EL PID
01882                         pet[onu]=1;
01883                 }
01884 
01885                 T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
01886 
01887                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01888                 GATEmsg *packet = new GATEmsg("gate");
01889                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01890                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01891                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01892                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01893                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01894                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01895                 packet->setNumsla(numero_sla[onu]);
01896 
01897 
01898                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01899                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01900                 {
01901                         B_slot[0]= B_alloc[onu]/8; // DEFINIMOS ANCHO DE BANDA DE SLOT
01902                         packet->setGrant_IntervalTx(0,B_slot[0]);
01903                 }
01904                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01905                 {
01906                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
01907                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01908                         for(int b=0; b<(int)par("numqueue"); b++)
01909                         {
01910                                 B_slot[b] = B_alloc[onu]/8; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01911                                 packet->setGrant_IntervalTx(b,B_slot[b]);
01912                         }
01913                 }
01914                 packet->setGrant_IniTime(tiempo_tx_siguiente); // TIEMPO DE INICIO DE TRANSMISION
01915                 /*
01916                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01917                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01918                 ev<<" Paquete Gate."<<endl;
01919                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01920                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01921                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01922                 ev<<" Tipo "<<packet->getKind()<<endl;
01923                 ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
01924                 ev<<" SLA: "<<packet ->getNumsla()<<endl;
01925                 ev<<"  "<<endl;
01926                 */
01927                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01928                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01929 
01930                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU
01931                 tiempo_tx_siguiente = tiempo_tx_siguiente + T_tx_onu;
01932                 //ev<<" Tiempo de Transmision Siguiente: "<<tiempo_tx_siguiente<<endl;
01933 
01934         }
01935 
01936         B_alloc_total[onu]=B_alloc_total[onu]+B_alloc[onu]; //B_ALLOC TOTAL EN Bits
01937 
01938         //ev<<" B_ALLOC_TOTAL "<<B_alloc_total[onu]<<" onu: "<<onu<<endl;
01939 
01940         //B_Mbps[onu]=B_alloc_total[onu]/(SIMTIME_DBL(simTime()));
01941 
01942         if(onu==0)
01943         {
01944 
01945                 B_Mbps_sla[0]=B_Mbps_sla[0]+(B_alloc[onu]-B_report*8);
01946         }
01947         else if(onu>=1 && onu<=5)
01948         {
01949 
01950                 B_Mbps_sla[1]=B_Mbps_sla[1]+(B_alloc[onu]-B_report*8);
01951 
01952         }
01953 
01954         else if(onu>=6 && onu<=15 )
01955         {
01956                 B_Mbps_sla[2]=B_Mbps_sla[2]+(B_alloc[onu]-B_report*8);
01957 
01958         }
01959                 delete reportmsg; // BORRAMOS EL MENSAJE REPORT
01960 }

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

Reimplemented from cSimpleModule.

Definition at line 206 of file MAC_OLT.cc.

00207 {
00208         //VARIABLES
00209         int type = msg->getKind(); // VARIABLE TYPE PARA IDENTIFICAR LOS MENSAJES DE LA RED
00210         double txrate = (int)par("txrate"); // VARIABLE TASA DE TRANSMISION
00211         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO IGUAL AL NÚMERO DE COLAS QUE DEFINAMOS
00212         int srcAddress = 9; // DEFINIMOS EL IDENTIFICADOR DE LA DIRECCION FUENTE DE LOS PAQUETES GATE
00213         int oltmethod = (int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4"); // VARIABLE QUE NOS INDICA EL METODO DEL OLT ELEGIDO AL PRINCIPIO DE LA SIMULACION
00214         //int oltmethod = (int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3"); // VARIABLE QUE NOS INDICA EL METODO DEL OLT ELEGIDO AL PRINCIPIO DE LA SIMULACION
00215         double tasa_tx_gate = 512/txrate; // VARIABLE QUE NOS INDICA LA TASA DE TRANSMISION DEL PAQUETE GATE CON UN TAMANYO DE 64 BYTES
00216         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
00217         double longitud_total_red; // PARIMETOR  QUE NOS INDICA LA LONGITUD TOTAL DE LA RED PARA CUANDO SIMULAMOS LA RED CON UNA LONGITU FIJA
00218         int lambda=0; //LONGITUD DE ONDA POR LA QUE SE VA A MANDAR EL PAQUETE
00219         int entero; //VARIABLE QUE RECOGE EL NÚMERO DE ONUs QUE VAN POR CADA LONGITUD DE ONDA
00220         int resto; //VARIABLE AUXILIAR EN CASO DE QUE POR UNA LONGITUD DE ONDA VAYAN MIS PAQUETES
00221         int entero_aux; //VARIABLE AUXILIAR PARA AUMENTAR EL NÚMERO DE ONUs POR LAMBDA
00222         int auxiliar=0; //VARIABLE AUXILIAR
00223         int contador=1; //VARIABLE AUXILIAR
00224 
00225         // ESTRUCTURA CONDICIONAL SWITCH QUE NOS DIFERENCIA LOS MENSAJES QUE LLEGUEN A ESTE MODULO
00226         switch(type)
00227         {
00228                 case 0:
00229                         if(msg->getKind()==0)
00230                         {
00231                                 simtime_t next_period = simTime() + (simtime_t) 10;
00232                                 scheduleAt(next_period,msg);
00233 
00234                                 /*
00235                                 ev << "         Paquetes P1 borrados SLA0: " << paquetes_borrados_P1[0] << endl;
00236                                 ev << "         Paquetes P1 recibidos SLA0: " << paquetes_recibidos_P1[0] << endl;
00237                                 ev << " P_bloqueo SLA0: " << (double)(paquetes_borrados_P1[0]/paquetes_recibidos_P1[0]) << endl;
00238                                 ev << "         Paquetes P1 borrados SLA1: " << paquetes_borrados_P1[1] << endl;
00239                                 ev << "         Paquetes P1 recibidos SLA1: " << paquetes_recibidos_P1[1] << endl;
00240                                 ev << " P_bloqueo SLA1: " << (double)(paquetes_borrados_P1[1]/paquetes_recibidos_P1[1]) << endl;
00241                                 ev << "         Paquetes P1 borrados SLA2: " << paquetes_borrados_P1[2] << endl;
00242                                 ev << "         Paquetes P1 recibidos SLA2: " << paquetes_recibidos_P1[2] << endl;
00243                                 ev << " P_bloqueo SLA2: " << (double)(paquetes_borrados_P1[2]/paquetes_recibidos_P1[2]) << endl;
00244                                 */
00245 
00246                                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE LA PROBABILIDAD DE BLOQUEO PARA LA CLASE P1, POR CADA SLA:
00247                                 bloqueo_cad_daspid_P1=fopen("results/bloqueo_CAD_DaSPID_P1.txt", "a+");
00248                                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
00249                                 fprintf(bloqueo_cad_daspid_P1," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)(paquetes_borrados_P1[0]/paquetes_recibidos_P1[0]), (double)(paquetes_borrados_P1[1]/paquetes_recibidos_P1[1]), (double)(paquetes_borrados_P1[2]/paquetes_recibidos_P1[2]));
00250                                 fclose(bloqueo_cad_daspid_P1);
00251 
00252                                 paquetes_borrados_P1.clear();
00253                                 paquetes_recibidos_P1.clear();
00254                         }
00255                 break;
00256                 case 2:
00257                         // LLEGA UN PAQUETE REPORT CON IDENTIFICADOR = 2
00258                         if(msg->getKind()==2)
00259                         {
00260                                 REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL MENSAJE REPORT
00261                                 //ev<<" Llega al final un paquete report de la ONU "<<reportmsg->getSrcAddress()<< " por la lambda: "<<reportmsg->getLambdareport()<<endl;
00262 
00263                                 // BULCE FOR PARA GUARDAR EN LA TABLA DEL MODULO OLT_TABLE EL ESTADO DE LAS COLAS
00264                                 for(int j=0; j<(int)par("numqueue"); j++)
00265                                 {
00266                                         table_module->table_olt_report[reportmsg->getSrcAddress()][j] = reportmsg->getQueue_estado(j);
00267                                 }
00268                                 /*
00269                                 // VISUALIZAMOS POR PANTALLA CON LOS BUCLES FOR LA TABLA COMPLETA DEL MODULO OLT_TABLE
00270                                 for(int i=0; i<(int)par("numOnu"); i++)
00271                                 {
00272                                         for(int j=0; j<(int)par("numqueue"); j++)
00273                                         {
00274                                                 ev<<"ONU "<< i<<"->"<< "Queue Estado "<< j <<": "<<table_module->table_olt_report[i][j]<<endl;
00275                                         }
00276                                         ev<<"ONU "<< i<<"->"<< "Bandwidth Demandado: "<<table_module->table_olt_report[i][(int)par("numqueue")]<<endl;
00277                                         ev<<"ONU "<< i<<"->"<< "Bandwidth Asignado: "<<table_module->table_olt_report[i][(int)par("numqueue")+1]<<endl;
00278                                 }
00279                                 */
00280                                 // ESTRUCTURA CONDICIONAL Sdwidth QUE NOS DIFERENCIA LOS METODOS DEL OLT
00281                                 switch(oltmethod)
00282                                 {
00283                                         case 0:
00284                                                 // METODO DMB O CENTRALIZADO DEL OLT
00285                                                 centralizedmethod_DMB(msg);
00286                                                 break;
00287 
00288                                         case 1:
00289                                                 // METODO IPACT O DE POLLING DEL OLT
00290                                                 pollingmethod_IPACT(msg);
00291                                                 break;
00292 
00293                                         case 2:
00294                                                 // METODO PARA MODULACION WDM
00295                                                 wdmmethod(msg);
00296                                                 break;
00297 
00298                                         case 3:
00299                                                 // METODO IPACT O DE POLLING CON ALGORITMO PID
00300                                                 DBA_polling_PID(msg);
00301                                                 break;
00302 
00303                                         case 4:
00304                                                 // METODO IPACT O DE POLLING CON ALGORITMO DaSPID
00305                                                 DBA_polling_DaSPID(msg);
00306                                                 break;
00307 
00308                                         default:
00309                                                 ev<<" ERROR AL ELEGIR EL METODO DEL OLT, ELEGIR 0 , 1, 2, 3 o 4."<<endl;
00310                                                 break;
00311                                 }
00312 
00313                         }
00314                         break;
00315 
00316                 case 5:
00317                         // LLEGA UN AUTOMENSAJE CON IDENTIFICADOR = 5 PARA GENERAR EL PAQUETE GATE
00318                         if(msg->getKind()==5)
00319                         {
00320                                 delete msg; // BORRAMOS EL AUTOMENSAJE YA QUE NO SE UTILIZA MAS ADELANTE
00321 
00322                                 //UNA LONGITUD DE ONDA
00323                                 if((int)par("numlong")==1)
00324                                 {
00325                                         // CALCULAMOS EL DELAY O RETARDO DEPENDIENDO DE LA LONGITUD DE NUESTRA RED
00326                                         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
00327                                         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
00328 
00329                                         // INICIALIZAMOS EL OLT MANDANDO UN MENSAJE GATE A CADA ONU INDICANDO EL ANCHO DE BANDA DE SLOT Y EL TIEMPO DE INICIO DE TRANSMISION
00330                                         // MEDIANTE EL BUCLE FOR CREAMOS LOS PAQUETES GATE PARA LAS ONUS DE NUESTRA RED
00331                                         for(int i=0; i<(int)par("numOnu"); i++)
00332                                         {
00333                                                 // CREAMOS EL PAQUETE GATE
00334                                                 GATEmsg *packet = new GATEmsg("Gate");
00335                                                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00336                                                 packet->setDestAddress(i); // DIRECCION DE DESTINO
00337                                                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00338                                                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00339                                                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00340                                                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00341 
00342                                                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00343                                                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00344                                                 {
00345                                                         B_slot[0]= 564;//1602;//txrate*1/8; // DEFINIMOS ANCHO DE BANDA DE SLOT
00346                                                         packet->setGrant_IntervalTx(0,B_slot[0]);
00347                                                         t_slot_initialization[0] = (B_slot[0]*8/txrate); // CALCULAMOS EL TIEMPO DE SLOT DE INICIALIZACION
00348 
00349                                                         packet->setGrant_IniTime(i*t_slot_initialization[0]+tasa_tx_gate+delay); // TIEMPO DE INICIO DE TRANSIMISION PARA CADA ONU
00350                                                 }
00351                                                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00352                                                 {
00353                                                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00354                                                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00355                                                         for(int b=0; b<(int)par("numqueue"); b++)
00356                                                         {
00357                                                                 B_slot[b] = 564;//1602;//txrate*1/8; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00358                                                                 packet->setGrant_IntervalTx(b,B_slot[b]);
00359                                                                 //ev<<" Ancho de Banda de slot "<<b<<" "<<B_slot[b]<<endl;
00360                                                                 t_slot_initialization[b] = (B_slot[b]*8/txrate); // CALCULAMOS EL TIEMPO DE SLOT DE INICIALIZACION
00361                                                                 packet->setGrant_IniTime(i*t_slot_initialization[b]+tasa_tx_gate+delay); // TIEMPO DE INICIO DE TRANSIMISION PARA CADA ONU
00362 
00363                                                         }
00364                                                 }
00365 
00366                                                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
00367                                                 ev<<" Creamos el paquete 'Gate' para la ONU["<<packet->getDestAddress()<<"]"<<endl;
00368                                                 ev<<" Paquete Gate."<<endl;
00369                                                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00370                                                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00371                                                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00372                                                 ev<<" Tipo "<<packet->getKind()<<endl;
00373                                                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
00374                                                 ev<<"  "<<endl;
00375 
00376                                                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00377                                                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
00378 
00379                                         }
00380 
00381                                         //CALCULAMOS EL TIEMPO DE TX SIGUIENTE QUE UTILIZAREMOS EN EL METODOD DE POLLING DE IPACT
00382                                         tiempo_tx_siguiente = ((int)par("numOnu")*t_slot_initialization[0])+tasa_tx_gate+delay;
00383                                         //ev<<" Tiempo Transmision Siguiente: "<<tiempo_tx_siguiente<<endl;
00384                                 }
00385 
00386                                 //MIS DE UNA LONGITUD DE ONDA
00387                                 else if((int)par("numlong")>1)
00388                                 {
00389                                         // CALCULAMOS EL DELAY O RETARDO DEPENDIENDO DE LA LONGITUD DE NUESTRA RED
00390                                         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
00391                                         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
00392 
00393                                         // INICIALIZAMOS EL OLT MANDANDO UN MENSAJE GATE A CADA ONU INDICANDO EL ANCHO DE BANDA DE SLOT Y EL TIEMPO DE INICIO DE TRANSMISION
00394                                         // MEDIANTE EL BUCLE FOR CREAMOS LOS PAQUETES GATE PARA LAS ONUS DE NUESTRA RED
00395                                         for(int i=0; i<(int)par("numOnu"); i++)
00396                                         {
00397                                                 // CREAMOS EL PAQUETE GATE
00398                                                 GATEmsg *packet = new GATEmsg("gate");
00399                                                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
00400                                                 packet->setDestAddress(i); // DIRECCION DE DESTINO
00401                                                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
00402                                                 packet->setLambdagate(lambda); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
00403                                                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
00404                                                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
00405 
00406                                                 lambda++; //ACTUALIZAMOS LA VARIABLE LAMBDA
00407 
00408                                                 if(lambda==(int)par("numlong"))
00409                                                 {
00410                                                         lambda=0;
00411                                                 }
00412 
00413                                                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
00414                                                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
00415                                                 {
00416                                                         B_slot[0]= 564;//1602;//txrate*1/8; // DEFINIMOS ANCHO DE BANDA DE SLOT
00417                                                         packet->setGrant_IntervalTx(0,B_slot[0]);
00418                                                         t_slot_initialization[0] = (B_slot[0]*8/txrate); // CALCULAMOS EL TIEMPO DE SLOT DE INICIALIZACION
00419                                                         packet->setGrant_IniTime(auxiliar*t_slot_initialization[0]+tasa_tx_gate+delay); // TIEMPO DE INICIO DE TRANSIMISION PARA CADA ONU
00420                                                         contador++;
00421                                                         if(contador>(int)par("numlong"))
00422                                                         {
00423                                                                 auxiliar++;
00424                                                                 contador=1;
00425                                                         }
00426                                                 }
00427 
00428                                                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
00429                                                 {
00430                                                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
00431                                                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
00432                                                         for(int b=0; b<(int)par("numqueue"); b++)
00433                                                         {
00434                                                                 B_slot[b] = 564;//1602;//txrate*1/8; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
00435                                                                 packet->setGrant_IntervalTx(b,B_slot[b]);
00436                                                                 ev<<" Ancho de Banda de slot "<<b<<" "<<B_slot[b]<<endl;
00437                                                                 t_slot_initialization[b] = (B_slot[b]*8/txrate); // CALCULAMOS EL TIEMPO DE SLOT DE INICIALIZACION
00438                                                                 packet->setGrant_IniTime(auxiliar*t_slot_initialization[b]+tasa_tx_gate+delay); // TIEMPO DE INICIO DE TRANSIMISION PARA CADA ONU
00439                                                                 contador++;
00440                                                                 if(contador>(int)par("numlong"))
00441                                                                 {
00442                                                                         auxiliar++;
00443                                                                         contador=1;
00444                                                                 }
00445                                                         }
00446                                                 }
00447                                                 /*
00448                                                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
00449                                                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
00450                                                 ev<<" Paquete Gate."<<endl;
00451                                                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
00452                                                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
00453                                                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
00454                                                 ev<<" Tipo "<<packet->getKind()<<endl;
00455                                                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
00456                                                 ev<<"  "<<endl;
00457                                                 */
00458                                                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
00459                                                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
00460 
00461                                         }
00462 
00463                                         entero=(int)(int)par("numOnu")/(int)par("numlong");
00464                                         resto=(int)par("numOnu")%(int)par("numlong");
00465 
00466                                         for(int k=0; k<(int)par("numlong");k++)
00467                                         {
00468                                                 tiempo_tx_sig[k]=(entero*t_slot_initialization[0])+tasa_tx_gate+delay;
00469                                         }
00470 
00471                                         for(int f=0; f<(int)par("numlong");f++)
00472                                         {
00473                                                 if(resto>0)
00474                                                 {
00475                                                         entero_aux=entero+1;
00476                                                         tiempo_tx_sig[f]=(entero_aux*t_slot_initialization[0])+tasa_tx_gate+delay;
00477 
00478                                                 }
00479                                         resto--;
00480                                         }
00481 
00482                                         for(int m=0; m<(int)par("numlong");m++)
00483                                         {
00484                                                         ev<<"Tiempo de Transmision Siguiente para lambda "<< m <<":"<<" "<< tiempo_tx_sig[m]<<endl;
00485                                         }
00486                                 }
00487                                 break;
00488                         }
00489                 case 6:
00490                         PID(msg);
00491                         break;
00492                 case 7:
00493                         PID_control_delay(msg);
00494                         break;
00495                 default:
00496                         delete msg;
00497                         break;
00498         }
00499 }

void MAC_OLT::initialize ( int  stage  )  [protected, virtual]

Reimplemented from cComponent.

Definition at line 38 of file MAC_OLT.cc.

00039 {
00041         // CREAMOS UN AUTOMENSAJE PARA CREAR EL PAQUETE GATE QUE MANDA EL OLT HACIA LAS ONUS PARA LA INICIALIZACION
00042         cMessage *msg = new cMessage ("mensaje inicial gate");
00043         msg->setKind(5); // IDENTIFICAMOS EL AUTOMENSAJE CON EL IDENTIFICADOR = 5
00044         scheduleAt(0, msg); // SI QUE QUITA NO SE INICIALIZAN LAS ONUS, NO SE MANDAN LOS GATES //ACTIVAR//
00045         // Para quitar la red PON, no enviar este mensaje.
00046 
00047         // INICIALIZAMOS VARIABLES AL VALOR 0
00048         sumqueue = 0; // VARIABLE DEL TAMANYO DE LA SUMA DE LOS PAQUETES DE LAS COLAS
00049         sumbdemand = 0; // VARIABLE DEL TAMANYO DE LA SUMA DEL ANCHO DE BANDA DEMANDADO
00050         B_sobra = 0; // VARIABLE DEL ANCHO DE BANDA DE SOBRA
00051         B_exceded = 0; // VARIABLE DEL ANCHO DE BANDA EN EXCESO
00052         tstarttime = 0; // VARIABLE DEL TIEMPO DE INICIO DE TRANSMISION
00053         B_alloc.resize((int)par("numOnu"),0); // VECTOR DEL ANCHO DE BANDA ASIGNADO. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS QUE DEFINAMOS
00054         B_demand.resize((int)par("numOnu"),0); // VECTOR DEL ANCHO DE BANDA DEMANDADO. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS QUE DEFINAMOS
00055         B_extra.resize((int)par("numOnu"),0); // VECTOR DEL ANCHO DE BANDA EXTRA QUE SE ASIGNA A MAYORES. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS QUE DEFINAMOS
00056         t_slot.resize((int)par("numOnu"),0); // VECTOR DE TIEMPO DE SLOT DE LA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS QUE DEFINAMOS
00057         t_slot_initialization.resize((int)par("numOnu"),0); // VECTOR DE TIEMPO DE SLOT DE LA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00058         T_alloc.resize((int)par("numOnu"),0); // VECTOR DE TIEMPO ASIGNADO PARA TRANSMITIR. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS QUE DEFINAMOS
00059         tiempo_tx_siguiente = 0; // VARIABLE DE TIEMPO DE TRANSMISION DE LA SIGUIENTE ONU
00060         tiempo_sim_delay_datarate = 0; // VARIABLE DE TIEMPO DE LA SUMA DEL TIEMPO DE SIMULACION, RETARDO Y TIEMPO DE TRANSMISION DEL PAQUETE GATE
00061         delay = 0; // RETARDO DE NUESTRA RED DEPENDIENDO DE LA LONGITUD TOTAL DE LA RED
00062         delay_pon1 = 0; // RETARDO DEL SEGMENTO DE LA RED QUE UNE EL OLT Y EL SPLITTER
00063         delay_pon2.resize((int)par("numOnu"),0); // VECTOR DEL RETARDO DEL SEGMENTO DE LA RED QUE UNE EL SPLITTER Y CADA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00064         delay_total.resize((int)par("numOnu"),0); // // VECTOR DE LA SUMA DE LOS RETARDOS DE CADA SEGMENTO DE LA RED (OLT-SPLITTER Y SPLITTER-ONU). SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00065         B_ex_sla.resize((int)par("numOnu"),0); // VECTOR DEL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00066         B_max_dmb.resize((int)par("numOnu"),0); // VECTOR DEL ANCHO DE BANDA MAXIMO PARA CADA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00067         SLA_onu.resize((int)par("numOnu"),0); // VECTOR EN EL QUE SE INTRODUCIRA LOS PESOS ASOCIADOS AL SLA QUE CORRESPONDE A CADA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00068         numsla.resize((int)par("numOnu"),0); // VECTOR QUE NOS GUARDA EL NÚMERO DE SLA ASOCIADO A CADA ONU. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE ONUS DE NUESTRA RED
00069         Wsla.resize((int)par("numSLA")+2,0); // VECTOR DE LOS PESOS DE CADA SLA. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE SLAs + 2 YA QUE SE UTILIZAN 3 SLA Y HEMOS DEFINIDO MANUALMENTE 4 PESOS PARA NUESTRA RED
00070         numonu_sla.resize((int)par("numSLA")+2,0); //  VECTOR DEL NÚMERO DE ONUs ASOCIADAS A CADA SLA. SE INICIALIZA A 0 CON UN TAMANYO IGUAL AL NÚMERO DE SLAs + 2 YA QUE SE UTILIZAN 3 SLA Y HEMOS DEFINIDO MANUALMENTE 4 PESOS PARA NUESTRA RED
00071         id_onu = 0; // IDENTIFICADOR DE LA ONU
00072         W_min = 0; // PESO MINIMO CON UN VALOR FIJO DE 0.34
00073         long_max = 0; // LONGITUD MAXIMA QUE TIENE UNA ONU PARA TRANSMITIR DEPENDIENDO DEL B_cycle Y DEL NÚMERO DE ONUs
00074         B_basico = 0; // ANCHO DE BANDA BASICO PARA TRANSMITIR QUE TIENE CADA ONU.
00075         sumatorio = 0; // VARIABLE QUE NOS INDICA EL SUMATORIO DE CADA PESO ASOCIADO A UN SLA POR SU NÚMERO DE ONUS ASOCIADOS A SLA
00076         tiempo_tx_sig.resize((int)par("numlong"),0);
00077         aux = 0; //VARIABLE AUXILIAR PARA GUARDAR LA LAMBDA POR LA QUE SE ENVIA EL PAQUETE
00078         id=0;
00079         tiempo_inic_PID = 10; //TIEMPO EN EL QUE SE INICIA EL PID // En el paper: Tsample=10s.
00080         tiempo_PID = 10; //INTERVALO DE TIEMPO EN EL QUE VA A SALTAR EL PID // En el paper: Tsample=10s.
00081         numero_sla.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA EL NUMERO DE SLA PARA MANDAR EL GATE
00082         pet.resize((int)par("numOnu"),1); //VECTOR QUE INDICA POR CADA ONU SI SE ACTIVA (1) O NO (0) EL PID
00083         error.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA EL ERROR POR ONU DEL PID
00084         sum_error.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA LA SUMA DEL ERROR POR ONU DEL PID
00085         B_max_sla.resize((int)par("numOnu"),0); //ANCHO DE BANDA MAXIMO POR SLA
00086         B_max_sla_ant.resize((int)par("numOnu"),0); //ANCHO DE BANDA MAXIMO POR SLA
00087         BW_max_PID.resize((int)par("numOnu"),0); //VECTOR DEL ANCHO DE BANDA MAXIMO POR ONU DEL PID
00088         BW_max_PID_ant.resize((int)par("numOnu"),0); //VECTOR DEL ANCHO DE BANDA MAXIMO ANTERIOR POR ONU DEL PID
00089         sum_error_delay.resize((int)par("numOnu"),0);
00090         error_ant_delay.resize((int)par("numOnu"),0);
00091         flagPrioridad = 0;
00092         flag_control_delay = 0;
00093         delay_onu.resize((int)par("numOnu")); // Retardo total de los paquetes recibidos en cada ciclo de cada ONU, clasificados por prioridad.
00094         for(int i=0; i<(int)par("numOnu"); i++)
00095         {
00096                 delay_onu[i].resize(2,0.0); // Solo se controla el retardo de las clases P0 y P1.
00097         }
00098         paq_onu.resize((int)par("numOnu")); // Total paquetes recibidos en cada ciclo de cada ONU, clasificados por prioridad.
00099         for(int i=0; i<(int)par("numOnu"); i++)
00100         {
00101                 paq_onu[i].resize(2,0); // Solo se controla el retardo de las clases P0 y P1.
00102         }
00103         retardo_alg_ONU.resize((int)par("numOnu"));
00104         for(int i=0; i<(int)par("numOnu"); i++)
00105         {
00106                 retardo_alg_ONU[i].resize(2,0.0); // Solo se controla el retardo de las clases P0 y P1.
00107         }
00108         retardo_max_ONU.resize((int)par("numOnu"));
00109         for(int i=0; i<(int)par("numOnu"); i++)
00110         {
00111                 retardo_max_ONU[i].resize(2,0.0); // Solo se controla el retardo de las clases P0 y P1.
00112         }
00113 
00114         control.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA LA VARIABLE CONTROL POR ONU PARA ESTABLECER EL PID
00115         error_ant.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA LOS ERRORES ANTERIORES POR ONU EN EL PID
00116         B_guarantee.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA EL ANCHO DE BANDA GARANTIZADO POR ONU PARA CALCULAR EL ERROR DEL PID
00117         cola_vector.resize((int)par("numOnu")); //VECTOR QUE USAREMOS PARA LA FUNCION recoger_bw_por_onu
00118         vector_ventana.resize((int)par("numSLA")); //ARRAY QUE SE USA PARA LA FUNCION recoger_delay_por_sla
00119         for(int i=0; i<(int)par("numSLA"); i++)
00120         {
00121                 vector_ventana[i].resize(2); // Solo se controla el retardo de las clases P0 y P1.
00122         }
00123         no_capacidad = 0; //¿?
00124         bw_acum_ONU.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA EL ANCHO DE BANDA ACUMULADO POR ONU
00125         retardo_alg_SLA.resize((int)par("numSLA")); // ARRAY QUE GUARDA LA MEDIA DEL RETARDO DE VENTANA POR SLA Y PRIORIDAD
00126         for(int i=0; i<(int)par("numSLA"); i++)
00127         {
00128                 retardo_alg_SLA[i].resize(2,0); // Solo se controla el retardo de las clases P0 y P1.
00129         }
00130         retardo_acum_SLA.resize((int)par("numSLA")); // ARRAY QUE GUARDA EL RETARDO ACUMULADO POR SLA Y PRIORIDAD
00131         for(int i=0; i<(int)par("numSLA"); i++)
00132         {
00133                 retardo_acum_SLA[i].resize(2,0); // Solo se controla el retardo de las clases P0 y P1.
00134         }
00135         aux_cont = 0; // VARIABLE AUXILIAR
00136         cont_auxiliar = 0; // VARIABLE AUXILIAR
00137         contador_aux = 0; // VARIABLE AUXILIAR
00138         bw_alg_ONU.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA LA MEDIA DEL ANCHO DE BANDA DE VENTANA
00139         bw_acum_Mbps.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA EL ANCHO DE BANDA ACUMULADO POR ONU EN MBPS
00140         bw_alg_Mbps.resize((int)par("numOnu"),0); //VECTOR QUE GUARDA LA MEDIA DEL ANCHO DE BANDA DE VENTANA EN MBPS
00141         intento_pid=0;
00142         intento=0;
00143         BW_sla.resize((int)par("numSLA")+2,0);
00144         BW_SLA_onu.resize((int)par("numOnu"),0);
00145         prueba=0;
00146         B_Mbps.resize((int)par("numOnu"),0);
00147         B_alloc_total.resize((int)par("numOnu"),0);
00148         desviacionBwMaxGuar.resize((int)par("numSLA")+2,0);
00149         cont_var_BwMax.resize((int)par("numSLA")+2,0);
00150         var.resize((int)par("numSLA")+2,0);
00151         var_Mbps.resize((int)par("numSLA")+2,0);
00152         cont_var.resize((int)par("numSLA")+2,0);
00153         error_abs.resize((int)par("numSLA")+2,0);
00154         error_rel.resize((int)par("numSLA")+2,0);
00155         var_Mbps_instantaneo.resize((int)par("numSLA")+2,0);
00156         desviacionBwMax.resize((int)par("numSLA"));
00157         desviacion.resize((int)par("numSLA"));
00158         PID_MEDIO.resize((int)par("numSLA"));
00159         PID_MEDIO_TOTAL.resize((int)par("numSLA"));
00160         cont_aux0=0;
00161         cont_aux2=0;
00162         cont_aux10=0;
00163         cont=1;
00164         B_Mbps_sla.resize((int)par("numSLA")+2,0);
00165 
00166         // DEFININOS EL PROCESO PARA PODER ENTRAR DESDE ESTE MODULO AL MODULO OLT_TABLE
00167         cModule *c_table_module;
00168         if(stage==0)
00169         {
00170                 c_table_module = getParentModule()->getSubmodule("olt_table"); // CAMINO PARA LLEGAR HASTA EL MODULO OLT_TABLE
00171                 table_module = check_and_cast<OLT_Table *>(c_table_module); // ENTRAMOS Y CHEQUEAMOS EL MODULO OLT_TABLE
00172         }
00173 
00175         //SOLO QUEREMOS QUE SALTE EL PID PARA EL METODO POLLING IPACT
00176         if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==3)
00177         //if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3")==3)
00178         {
00179                 cMessage *msg1 = new cMessage ("Mensaje inicial gate");
00180                 msg1->setKind(6); // IDENTIFICAMOS EL AUTOMENSAJE CON EL IDENTIFICADOR = 6
00181                 scheduleAt(tiempo_inic_PID, msg1); // SI QUE QUITA NO SE INICIALIZAN LAS ONUS, NO SE MANDAN LOS GATES
00182         }
00183         //NUEVO:
00184         else if((int)par("oltmethod_Centralized0_Polling1_wdm2_PollingPID3_DaSPID4")==4)
00185         {
00186                 cMessage *msg1 = new cMessage ("Mensaje inicial gate");
00187                 msg1->setKind(7); // IDENTIFICAMOS EL AUTOMENSAJE CON EL IDENTIFICADOR = 6
00188                 scheduleAt(tiempo_inic_PID, msg1); // SI QUE QUITA NO SE INICIALIZAN LAS ONUS, NO SE MANDAN LOS GATES
00189 
00190                 paquetes_borrados_P1.resize((int)par("numSLA"),0);
00191                 paquetes_recibidos_P1.resize((int)par("numSLA"),0);
00192                 simtime_t next_period = simTime() + (simtime_t) 10;
00193                 cMessage *msg0 = new cMessage ("Control_Bloqueo",0);
00194                 scheduleAt(next_period, msg0);
00195         }
00196 
00197 }

int MAC_OLT::numInitStages (  )  const [virtual]

Reimplemented from cComponent.

Definition at line 29 of file MAC_OLT.cc.

00029 {return 1;}

void MAC_OLT::PID ( cMessage msg  )  [protected, virtual]

Definition at line 2776 of file MAC_OLT.cc.

02777 {
02778         delete msg;
02779         // Ku=1.1 y Tu=22
02780         double Kp=0.66; //PARAMETRO DE NUESTRO PID Kp=0.6Ku
02781         double Ti=11; //PARAMETRO DE NUESTRO PID Ti=0.5Tu
02782         double Td=2.75; //PARAMETRO DE NUESTRO PID  Td=0.125Tu
02783         double time_slot; //VARIABLE PARA EL TIEMPO DE SLOT
02784         double T_cycle=0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
02785         int BW_total_ciclo; //ANCHO DE BANDA TOTAL DEL CICLO
02786         double T_guarda = 0.000001; //TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
02787         double txrate = (int)par("txrate"); // VARIABLE TASA DE TRANSMISION
02788         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
02789         double Total_PID=0.0;
02790         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
02791 
02792         ev<<" ENTRA EN EL PID EN EL TIEMPO: "<<simTime()<<endl;
02793         tiempo_inic_PID+=tiempo_PID;
02794 
02795         //GENERAMOS EL MENSAJE DE TIPO 6 PARA QUE DESDE EL handleMessage() SE LLAME CADA
02796         // 'tiempo_inic_PID' EL ALGORITMO PID QUE ACTUALIZA LOS ANCHOS DE BANDA MAXIMOS
02797         // EN FUNCION DE LOS ERRORES. ESTO ES PARALELO A LA ASIGNACION DE ANCHO DE BANDA,
02798         // CICLO TRAS CICLO, QUE SE REALIZA CON EL ALGORITMO ANTERIOR, 'DBA_polling_PID'.
02799         cMessage *msg2 = new cMessage ("Mensaje inicial");
02800         msg2->setKind(6); // IDENTIFICAMOS EL AUTOMENSAJE CON EL IDENTIFICADOR = 6
02801         scheduleAt(tiempo_inic_PID, msg2); // SI QUE QUITA NO SE INICIALIZAN LAS ONUS, NO SE MANDAN LOS GATES
02802         //ev<<"         Proximo PID en T=" << tiempo_inic_PID << "." << endl;
02803 
02804         //RECORREMOS TODAS LAS ONU's
02805         for(int i=0; i<(int)par("numOnu"); i++)
02806         {
02807                 //ev<<" Si es 1 se activa el PID si es 0 no: "<<pet[i]<<" para la onu: "<<i<<endl;
02808 
02809                 //NO SE ACTIVA EL PID
02810                 if(pet[i]==0)
02811                 {
02812                         //ENTRAR UNA VEZ QUE EL PID SALTE AL MENOS UNA VEZ
02813                         if(intento_pid==1)
02814                         {
02815                                 //ev<<" MAXIMO ANTERIOR "<<BW_max_PID_ant[i]<<endl;
02816                                 BW_max_PID[i]=BW_max_PID_ant[i];
02817                         }
02818                         B_guarantee[i]=BW_SLA_onu[i]*1000000*(T_cycle-(int)par("numOnu")*T_guarda-(int)par("numOnu")*tasa_tx_report); // Bits
02819                         error[i]=B_guarantee[i]-bw_alg_ONU[i];
02820                         //ev<<" Garantizado "<<B_guarantee[i]<<endl;
02821                 }
02822 
02823                 //SE ACTIVA EL PID:
02824                 else
02825                 {
02826                         intento_pid=1;
02827 
02828                         B_guarantee[i]=BW_SLA_onu[i]*1000000*(T_cycle-(int)par("numOnu")*T_guarda-(int)par("numOnu")*tasa_tx_report);
02829 
02830                         //ev<<" GARANTIZADO "<<B_guarantee[i]<<endl;
02831                         //ev<<" MEDIA "<<bw_alg_ONU[i]<<endl;
02832 
02833                         //CALCULAMOS EL ERROR
02834                         error[i]=B_guarantee[i]-bw_alg_ONU[i];
02835 
02836                         //ACTUALIZAMOS EL ERROR
02837                         sum_error[i]=sum_error[i]+error[i];
02838 
02839                         //CALCULAMOS LA VARIABLE DE CONTROL
02840                         control[i]=Kp*(error[i]+((tiempo_PID/Ti)*sum_error[i])+((Td/tiempo_PID)*(error[i]-error_ant[i])));
02841                         //ev<<" control "<<control[i]<<endl;
02842                         //ev<<" error "<<error[i]<<endl;
02843                         //ev<<" error ant "<<error_ant[i]<<endl;
02844                         //ev<<" sum_error "<<sum_error[i]<<endl;
02845 
02846                         //CALCULAMOS EL VALOR MAXIMO DEL PID
02847                         BW_max_PID[i]=B_max_sla[i]+control[i];
02848 
02849                         //SI EL VALOR MAXIMO DEL PID ES NEGATIVO
02850                         if(BW_max_PID[i]<0.0)
02851                         {
02852                                 BW_max_PID[i]=0.0;
02853                         }
02854 
02855                         BW_max_PID_ant[i]=BW_max_PID[i];
02856 
02857                         error_ant[i]=error[i];
02858                 }
02859         }
02860 
02861         //ESCALAMOS LA SALIDA PARA QUE EL ANCHO DE BANDA NO SUPERE EL CONTENIDO EN EL CICLO MAXIMO
02862         time_slot= T_cycle/((int)par("numOnu"));
02863 
02864         BW_total_ciclo = (int)((time_slot - T_guarda - tasa_tx_gate)*txrate*(int)par("numOnu"));
02865 
02866         //RECORREMOS TODAS LAS ONUs PARA COMPLETAR EL SUMATORIO DE Total_PID
02867         for(int i=0; i<(int)par("numOnu"); i++)
02868         {
02869                     Total_PID = Total_PID + BW_max_PID[i];
02870         }
02871 
02872         //ev<<" Total Pid "<<Total_PID<<endl;
02873     //ev<<" BW_total_ciclo "<<BW_total_ciclo<<endl;
02874 
02875         //SI EL PID TOTAL ES MAYOR QUE EL ANCHO DE BANDA TOTAL DEL CICLO
02876         if(Total_PID>BW_total_ciclo)
02877         {
02878                 //ev<<" Total Pid > BW_total_ciclo "<<endl;
02879                 for(int i=0; i<(int)par("numOnu"); i++)
02880                 {
02881                         B_max_sla[i]=(BW_total_ciclo*BW_max_PID[i])/Total_PID;
02882 
02883                 }
02884         }
02885         //SI EL PID TOTAL ES MENOR QUE EL ANCHO DE BANDA TOTAL DEL CICLO
02886         else
02887         {
02888                 //ev<<" Total Pid < BW_total_ciclo "<<endl;
02889                 for (int i=0; i<(int)par("numOnu"); i++)
02890                 {
02891                         B_max_sla[i]=BW_max_PID[i];
02892                 }
02893         }
02894 
02895         if(simTime()>=20*cont)
02896         {
02897                 cont++;
02898                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_ALLOC_MEDIO , VALOR MEDIO DE LA VENTANA
02899                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02900                 B_alloc_medio=fopen("results/B_alloc_medio.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
02901                 fprintf(B_alloc_medio,"%g\t" , (double)bw_alg_ONU[0]);
02902                 fprintf(B_alloc_medio,"\t");
02903                 fprintf(B_alloc_medio,"%g\t" , (double)bw_alg_ONU[1]);
02904                 fprintf(B_alloc_medio,"\t");
02905                 fprintf(B_alloc_medio,"%g\t" , (double)bw_alg_ONU[6]);
02906                 fprintf(B_alloc_medio,"\n");
02907                 fclose(B_alloc_medio); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02908 
02909                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_MAX_PID
02910                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02911                 B_max_PID=fopen("results/B_max_PID.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
02912                 fprintf(B_max_PID,"%g\t" , (double)B_max_sla[0]);
02913                 fprintf(B_max_PID,"\t");
02914                 fprintf(B_max_PID,"%g\t" , (double)B_max_sla[1]);
02915                 fprintf(B_max_PID,"\t");
02916                 fprintf(B_max_PID,"%g\t" , (double)B_max_sla[6]);
02917                 fprintf(B_max_PID,"\n");
02918                 fclose(B_max_PID); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02919 
02920 
02921                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_Mbps
02922                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02923                 BW_Mbps=fopen("results/BW_Mbps.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
02924                 fprintf(BW_Mbps,"%g\t" , (double)B_Mbps_sla[0]/SIMTIME_DBL(simTime()));
02925                 fprintf(BW_Mbps,"\t");
02926                 fprintf(BW_Mbps,"%g\t" , (double)B_Mbps_sla[1]/SIMTIME_DBL(simTime()));
02927                 fprintf(BW_Mbps,"\t");
02928                 fprintf(BW_Mbps,"%g\t" , (double)B_Mbps_sla[2]/SIMTIME_DBL(simTime()));
02929                 fprintf(BW_Mbps,"\n");
02930                 fclose(BW_Mbps); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02931 
02932                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL BW_acum en bytes
02933                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02934                 //BW_acum=fopen("results/BW_acum.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
02935                 //fprintf(BW_acum,"%g\t" , (double)bw_acum_total[0]);
02936                 //fprintf(BW_acum,"\t");
02937                 //fprintf(BW_acum,"%g\t" , (double)bw_acum_total[1]);
02938                 //fprintf(BW_acum,"\t");
02939                 //fprintf(BW_acum,"%g\t" , (double)bw_acum_total[6]);
02940                 //fprintf(BW_acum,"\n");
02941                 //fclose(BW_acum); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02942 
02943                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_TOTAL
02944                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02945                 B_total=fopen("results/B_total.txt", "a+"); // ABRIMOS EL ARCHIVO EN EL QUE GUARDAREMOS LOS RESULTADOS
02946                 fprintf(B_total,"%g\t" , (double)B_alloc_total[0]);
02947                 fprintf(B_total,"\t");
02948                 fprintf(B_total,"%g\t" , (double)B_alloc_total[1]);
02949                 fprintf(B_total,"\t");
02950                 fprintf(B_total,"%g\t" , (double)B_alloc_total[6]);
02951                 fprintf(B_total,"\n");
02952                 fclose(B_total); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02953 
02954                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL PID_MEDIO
02955                 //SE PONE LA RUTA DONDE SE VAN A CREAR LOS ARCHIVOS
02956                 pid_medio_file=fopen("results/pid_medio_file.txt", "a+");
02957                 fprintf(pid_medio_file,"%g\t" , (double)PID_MEDIO[0]);
02958                 fprintf(pid_medio_file,"\t");
02959                 fprintf(pid_medio_file,"%g\t" , (double)PID_MEDIO[1]);
02960                 fprintf(pid_medio_file,"\t");
02961                 fprintf(pid_medio_file,"%g\t" , (double)PID_MEDIO[2]);
02962                 fprintf(pid_medio_file,"\n");
02963                 fclose(pid_medio_file); // CERRAMOS EL ARCHIVO EN EL QUE GUARDAMOS LOS DATOS
02964         }
02965 }

void MAC_OLT::PID_control_delay ( cMessage msg  )  [protected, virtual]

Definition at line 2405 of file MAC_OLT.cc.

02406 {
02407         // FUNCION PARA CONTROLAR EL RETARDO EN EL PID:
02408         // Según el error que se comete entre el valor medio del retardo para las clases de servicio
02409         // P0-P1 y el valor estipulado, se modifican los anchos de banda de cada ONU.
02410         delete msg;
02411         double Kp = 0.3; //PARAMETRO DE NUESTRO DaSPID
02412         //double Ti = 11; //PARAMETRO DE NUESTRO DaSPID
02413         //double Td = 2.75; //PARAMETRO DE NUESTRO DaSPID
02414         double BW_total_ciclo; //ANCHO DE BANDA TOTAL DEL CICLO
02415         double Total_PID = 0.0;
02416         double time_slot; //VARIABLE PARA EL TIEMPO DE SLOT
02417         //double retardo; //VARIABLE PARA EL RETARDO
02418         double T_cycle=0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
02419         double T_guarda = 0.000001; //TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
02420         double txrate = (int)par("txrate"); // VARIABLE TASA DE TRANSMISION
02421         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
02422         //double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
02423 
02424         //ev<<" ENTRA EN EL PID EN EL TIEMPO: " << simTime() << endl;
02425         tiempo_inic_PID+=tiempo_PID;
02426 
02427         //GENERAMOS EL MENSAJE DE TIPO 7 PARA QUE DESDE EL handleMessage() SE LLAME CADA 'tiempo_inic_PID'
02428         // AL ALGORITMO PID QUE ACTUALIZA LOS ANCHOS DE BANDA MAXIMOS EN FUNCION DE LOS ERRORES DEL RETARDO.
02429         // ESTO ES PARALELO A LA ASIGNACION DE ANCHO DE BANDA, CICLO TRAS CICLO, QUE SE REALIZA CON EL ALGORITMO ANTERIOR, 'DBA_polling_DaSPID'.
02430         cMessage *msg2 = new cMessage ("mensaje inicial");
02431         msg2->setKind(7); // IDENTIFICAMOS EL AUTOMENSAJE CON EL IDENTIFICADOR = 6
02432         scheduleAt(tiempo_inic_PID, msg2); // SI QUE QUITA NO SE INICIALIZAN LAS ONUS, NO SE MANDAN LOS GATES
02433         //ev<<"         Proximo PID en T=" << tiempo_inic_PID << "." << endl;
02434 
02435         // SE CALCULA EL BW MAXIMO DEL PID UNA VEZ POR SLA, PARA LA ULTIMA ONU DE CADA UNO, Y LUEGO SE COPIA EL VALOR OBTENIDO
02436         // EN LA POSICION CORRESPONDIENTE AL RESTO DE ONUs DEL MISMO SLA:
02437         int acum_onus_sla = 0;
02438         for(int i=0; i<(int)par("numSLA"); i++)
02439         {
02440                 acum_onus_sla += numonu_sla[i];
02441                 // 'acum_onus_sla-1' = indice de la ultima onu asociada a cada sla
02442                 B_max_sla_ant[acum_onus_sla-1] = B_max_sla[acum_onus_sla-1];
02443                 if(pet[acum_onus_sla-1] == 0)
02444                 {
02445                         BW_max_PID[acum_onus_sla-1] = BW_max_PID_ant[acum_onus_sla-1];
02446                         //ev<<"El PID no esta activo. El ancho de banda que propone el PID es el de antes, que es " << BW_max_PID[acum_onus_sla-1] << " bits" << endl;
02447                         flagPrioridad = 1;
02448                 }
02449                 else
02450                 {
02451                         //ev<<" Retardo maximo para los paquetes P0 del SLA " << i << ": " << retardo_max_ONU[acum_onus_sla-1][0] << endl;
02452                         //ev<<" Retardo maximo para los paquetes P1 del SLA " << i << ": " << retardo_max_ONU[acum_onus_sla-1][1] << endl;
02453                         //retardo = (double) retardo_alg_ONU[i][1] - retardo_max_ONU[i][1];
02454                         error[acum_onus_sla-1] = (retardo_max_ONU[acum_onus_sla-1][1] - retardo_alg_ONU[acum_onus_sla-1][1]) + (retardo_max_ONU[acum_onus_sla-1][0] - retardo_alg_ONU[acum_onus_sla-1][0]);
02455                         //error[i] = (retardo_alg_ONU[i][1] - retardo_max_ONU[i][1]) + (retardo_alg_ONU[i][0] - retardo_max_ONU[i][0]);
02456                         //ev<<" Delay_limit: " << retardo_max_ONU[acum_onus_sla-1][1] << ". Delay de la ventana real: " << retardo_alg_ONU[acum_onus_sla-1][1] << endl;
02457                         sum_error_delay[acum_onus_sla-1] = sum_error_delay[acum_onus_sla-1] + error[acum_onus_sla-1];
02458                         //ev<<" SLA " << i << ": Error=" << error[acum_onus_sla-1] << "; sum_error=" << sum_error_delay[acum_onus_sla-1] << "; error_ant=" << error_ant_delay[acum_onus_sla-1] << endl;
02459                         // CALCULO DE LA VARIABLE DE CONTROL:
02460                         control[acum_onus_sla-1] = Kp*error[acum_onus_sla-1]; // TERMINO PROPORCIONAL (P)
02461                         //control[i] = Kp*(error[i]+((tiempo_PID/Ti)*sum_error_delay[i])+((Td/Tsample)*(error[i]-error_ant_delay[i])));  //---- PID
02462                         //control[i] = Kp*(error[i]+((Td/tiempo_PID)*(error[i]-error_ant_delay[i])));  // PD
02463                         //control[i] = Kp*(error[i]+((tiempo_PID/Ti)*sum_error_delay[i]));  // PI
02464                         //control[i] = Kp*(((tiempo_PID/Ti)*sum_error_delay[i]));  // I
02465                         //ev<<" Senyal de control (en tiempo): " << control[acum_onus_sla-1] << endl;
02466                         // CONVERSION DE LA SENYAL DE CONTROL A BITS:
02467                         control[acum_onus_sla-1] = control[acum_onus_sla-1]*100000; // Factor de conversion DaSPID = 100000
02468                         //control[i] = control[i]*bw_alg_ONU[i]/retardo_alg_ONU[i][1];
02469                         //ev<<" Senyal de control (en bits): " << control[acum_onus_sla-1] << endl;
02470                         //ev<<" ANTES -> Maximo BW para este SLA segun el PID: " << BW_max_PID[acum_onus_sla-1] << " bits. "<< endl;
02471                         // OBTENCION DE LOS NUEVOS ANCHOS DE BANDA MAXIMOS PARA CADA SLA:
02472                         BW_max_PID[acum_onus_sla-1] = B_max_sla[acum_onus_sla-1] - control[acum_onus_sla-1];
02473                         //BW_max_PID[i] = B_max_sla[i] + control[i];
02474 
02475                         // SI EL VALOR MAXIMO DEL PID ES NEGATIVO:
02476                         if(BW_max_PID[acum_onus_sla-1] <= 0.0)
02477                         {
02478                                 BW_max_PID[acum_onus_sla-1] = 80000; // bits
02479                         }
02480                         //ev<<" DESPUES -> Maximo BW para este PID: " << BW_max_PID[acum_onus_sla-1] << " bits. "<< endl;
02481                         BW_max_PID_ant[acum_onus_sla-1] = BW_max_PID[acum_onus_sla-1];
02482                         error_ant_delay[acum_onus_sla-1] = error[acum_onus_sla-1];
02483                 }
02484                 for(int j=acum_onus_sla-numonu_sla[i]; j<acum_onus_sla;j++)
02485                 {
02486                         BW_max_PID[j] = BW_max_PID[acum_onus_sla-1];
02487                         B_max_sla[j] = B_max_sla[acum_onus_sla-1];
02488                         //ev<<" BW max segun el PID para la ONU[" << j << "]: " << BW_max_PID[j] << " bits." << endl;
02489                         control[j] = control[acum_onus_sla-1];
02490                         error[j] = error[acum_onus_sla-1];
02491                         sum_error_delay[j] = sum_error_delay[acum_onus_sla-1];
02492                 }
02493         }
02495 
02496         // ESCALADO DE LA SALIDA PARA QUE EL ANCHO DE BANDA NO SUPERE EL CONTENIDO EN EL CICLO MAXIMO:
02497         time_slot = T_cycle/((int)par("numOnu"));
02498         BW_total_ciclo = (int)((time_slot - T_guarda - tasa_tx_gate)*txrate*((int)par("numOnu")));      //Ancho de banda maximo total contenido en el tiempo maximo de un ciclo.
02499 
02500         //ESTO ES PARA CARGAS ALTAS DONDE NO SE PUEDE GARANTIZAR EL DELAY:
02501         double Bw_min=80000; // BITS
02502         if(flag_control_delay==1)
02503         {
02504                 //Hay que dar prioridad al SLA0 y SLA1:
02505                 int acum=0;
02506                 int k=0;
02507                 double suma_BW_prioritarios=0.0;
02508 
02509                 for (int j=0; j<(int)par("numSLA"); j++)
02510                 {
02511                         for(k=acum; k<numonu_sla[j]+acum; k++)
02512                         {
02513                                 if((j==0)||(j==1))
02514                                 {
02515                                         suma_BW_prioritarios = suma_BW_prioritarios + BW_max_PID[k];
02516                                 }
02517                         }
02518                         acum=k;
02519                 }
02520                 // Si el ancho de banda supera el maximo para las ONUs de este SLA; hay que escalar:
02521                 if(suma_BW_prioritarios > BW_total_ciclo-(Bw_min*numonu_sla[2]))
02522                 {
02523                         //ev<<" La suma de BW prioritario es mayor que el BW disponible en el ciclo, garantizando un minimo al SLA2 --> Escalamos el BW de los prioritarios." << endl;
02524                         acum=0;
02525                         k=0;
02526                         for (int j=0; j<(int)par("numSLA"); j++)
02527                         {
02528                                 for(k=acum; k<numonu_sla[j]+acum; k++)
02529                                 {
02530                                         if(j==2)
02531                                         {
02532                                                 B_max_sla[k]=Bw_min;
02533                                         }
02534                                         else
02535                                         {
02536                                                 B_max_sla[k]=((BW_total_ciclo-Bw_min*numonu_sla[2])*BW_max_PID[k])/suma_BW_prioritarios;
02537                                         }
02538                                 }
02539                                 acum=k;
02540                         }
02541                 }
02542                 // Si el ancho de banda no supera el maximo para las ONUs prioritarias, se da lo que sobra al SLA2:
02543                 else
02544                 {
02545                         //ev<<" Lo que sugiere el PID para los prioritarios es menor que el disponible menos el minimo del SLA2; asi que se da lo que sugiere el PID y el resto se reparte entre las ONUs del SLA2." << endl;
02546                         acum=0;
02547                         k=0;
02548                         for (int j=0; j<(int)par("numSLA"); j++)
02549                         {
02550                                 for(k=acum; k<numonu_sla[j]+acum; k++)
02551                                 {
02552                                         if((j==0)||(j==1))
02553                                         {
02554                                                 B_max_sla[k]=BW_max_PID[k];
02555                                         }
02556 
02557                                         if(j==2)
02558                                         {
02559                                                 B_max_sla[k]= (BW_total_ciclo-suma_BW_prioritarios)/numonu_sla[2];
02560                                         }
02561                                 }
02562                                 acum=k;
02563                         }
02564                 }
02565         }
02566         else
02567         {
02568                 // SE ASEGURA UN ANCHO DE BANDA MINIMO A TODAS LAS ONUs:
02569                 for(int i=0; i<(int)par("numOnu"); i++)
02570                 {
02571                         if(BW_max_PID[i] < Bw_min)
02572                         {
02573                                 BW_max_PID[i] = Bw_min;
02574                         }
02575                 }
02576                 //Para que en cargas bajas no se vuelva loco intentando llegar a los estipulados y baje mucho el bw del sla2:
02577                 for(int i=0; i<(int)par("numOnu"); i++)
02578                 {
02579                         Total_PID=Total_PID+BW_max_PID[i];
02580                 }
02581                 //Si es mayor que el ancho total disponible en el tiempo de ciclo máximo, hay que escalar:
02582                 for(int i=0; i<(int)par("numOnu"); i++)
02583                 {
02584                         B_max_sla[i]=(BW_total_ciclo*BW_max_PID[i])/Total_PID;
02585                 }
02586         }
02587         // LIMITAR QUE LOS BWs ASIGNADOS SUPONGAN DAR BWs MAYORES DE 100Mb/s (TASA MAXIMA):
02588         double bw_rep;
02589         int onus_mas=0;
02590         do
02591         {
02592                 bw_rep=0;
02593                 double BW_tasa_max = 100*1000000*(T_cycle + 16*T_guarda + 16*tasa_tx_gate);
02594                 double Total_PID_ONUs_menores=0;
02595                 for(int i=0; i<(int)par("numOnu"); i++)
02596                 {
02597                         //ev<<" Antes: B_max_sla[" << i << "]=" << B_max_sla[i] << endl;
02598                 }
02599                 for(int i=0; i<(int)par("numOnu"); i++)
02600                 {
02601                         if(B_max_sla[i]>BW_tasa_max)
02602                         {
02603                                 bw_rep=bw_rep+(B_max_sla[i]-BW_tasa_max);
02604                                 B_max_sla[i]= BW_tasa_max;
02605                         }
02606                         else
02607                         {
02608                                         if(B_max_sla[i]!=0)
02609                                         {
02610                                                 Total_PID_ONUs_menores=Total_PID_ONUs_menores+B_max_sla[i];
02611                                         }
02612                         }
02613                 }
02614                 for(int i=0; i<(int)par("numOnu"); i++)
02615                 {
02616                         if((B_max_sla[i]<BW_tasa_max)&&(Total_PID_ONUs_menores!=0))
02617                         {
02618                                 B_max_sla[i]=B_max_sla[i]+(bw_rep*B_max_sla[i]/Total_PID_ONUs_menores);
02619                         }
02620                 }
02621                 onus_mas=0;
02622                 for(int i=0; i<(int)par("numOnu"); i++)
02623                 {
02624                         if(B_max_sla[i]>BW_tasa_max)
02625                         {
02626                                 onus_mas++;
02627                         }
02628                 }
02629         }while(onus_mas!=0);
02630 
02631         for(int i=0; i<(int)par("numOnu"); i++)
02632         {
02633                 //ev<<" Despues: B_max_sla[" << i << "]=" << B_max_sla[i] << endl;
02634         }
02635         // FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE LOS VALORES DADOS A DIFERENTES PARAMETROS EMPLEADOS EN EL PID EN CADA CICLO:
02636         controlfich = fopen("results/control.txt", "a+");
02637         fprintf(controlfich,"%g\t", SIMTIME_DBL(simTime()));
02638         for(int i=0; i<(int)par("numOnu"); i++)
02639         {
02640                 if((i==0)||(i==2)||(i==8))
02641                 {
02642                         fprintf(controlfich,"T=%g -> ONU[%i]: Control=%g\tError=%g\tSuma_error=%g\tBW_max=%g\n", SIMTIME_DBL(simTime()), i, control[i], error[i], sum_error_delay[i], B_max_sla[i]);
02643                 }
02644         }
02645         fprintf(controlfich,"\n");
02646         fclose(controlfich);
02647 
02648         //if(simTime()>=20*aux_cont){
02649                 aux_cont++;
02650 
02651                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL RETARDO MEDIO DE VENTANA PARA LA CLASE P0, POR CADA SLA:
02652                 evaluacion_retardo_slas_P0=fopen("results/retardo_medio_P0_slas.txt", "a+");
02653                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02654                 fprintf(evaluacion_retardo_slas_P0," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)retardo_alg_ONU[0][0], (double)retardo_alg_ONU[2][0], (double)retardo_alg_ONU[8][0]);
02655                 fclose(evaluacion_retardo_slas_P0);
02656 
02657                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL RETARDO MEDIO DE VENTANA PARA LA CLASE P1, POR CADA SLA:
02658                 evaluacion_retardo_slas_P1=fopen("results/retardo_medio_P1_slas.txt", "a+");
02659                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02660                 fprintf(evaluacion_retardo_slas_P1," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)retardo_alg_ONU[0][1], (double)retardo_alg_ONU[2][1], (double)retardo_alg_ONU[8][1]);
02661                 fclose(evaluacion_retardo_slas_P1);
02662 
02663                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_ALLOC_MEDIO, VALOR MEDIO DE LA VENTANA:
02664                 B_alloc_medio=fopen("results/B_alloc_medio.txt", "a+");
02665                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02666                 fprintf(B_alloc_medio," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)bw_alg_ONU[0], (double)bw_alg_ONU[2], (double)bw_alg_ONU[8]);
02667                 fclose(B_alloc_medio);
02668 
02669                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL B_MAX_PID:
02670                 B_max_PID=fopen("results/B_max_PID.txt", "a+");
02671                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02672                 fprintf(B_max_PID," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)B_max_sla[0], (double)B_max_sla[2], (double)B_max_sla[8]);
02673                 fclose(B_max_PID);
02674 
02675                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL ANCHO DE BANDA TOTAL ASIGNADO A CADA SLA:
02676                 B_total=fopen("results/B_total.txt", "a+");
02677                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02678                 fprintf(B_total," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)B_alloc_total[0], (double)B_alloc_total[2], (double)B_alloc_total[8]);
02679                 fclose(B_total);
02680 
02681                 //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL PID_MEDIO:
02682                 pid_medio_file=fopen("results/pid_medio_file.txt", "a+");
02683                 //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
02684                 fprintf(pid_medio_file," %g \t %g \t %g \t %g \n" ,  SIMTIME_DBL(simTime()), (double)PID_MEDIO[0], (double)PID_MEDIO[1], (double)PID_MEDIO[2]);
02685                 fclose(pid_medio_file);
02686         //}
02687 }

void MAC_OLT::pollingmethod_IPACT ( cMessage msg  )  [protected, virtual]

Definition at line 937 of file MAC_OLT.cc.

00938 {
00939         //ev<<" EJECUTAMOS EL METODO IPACT DE POLLING EN EL OLT."<<endl;
00940 
00941         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
00942 
00943         //VARIABLES
00944         double txrate = (double)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
00945         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
00946         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
00947         double T_cycle = 0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
00948         double T_guarda = 0.000005; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
00949         double T_guarda_nonu = T_guarda*((int)par("numOnu")); // TIEMPO DE GUARDA TOTAL DE TODAS LAS ONUS
00950         double T_report_nonu = tasa_tx_report*((int)par("numOnu")); // TASA DE TRANSMISION TOTAL DE LOS PAQUETES REPORT DE TODAS LAS ONUS
00951         double T_cycle_total = T_cycle - T_guarda_nonu - T_report_nonu; // TIEMPO DE CICLO FINAL Y LO VISUALIZAMOS POR PANTALLA
00952         //ev<<" Tiempo de ciclo total: "<<T_cycle_total<<"s"<<endl;
00953         double T_tx_onu; // TIEMPO DE TRANSMISION DE UNA ONU
00954         double B_cycle = txrate*T_cycle_total/8; // ANCHO DE BANDA MAXIMO DEL CICLO EN BYTES
00955         //ev<<" Ancho de banda del ciclo: "<<B_cycle<<"Bytes"<<endl;
00956         long double B_report = txrate*tasa_tx_report/8; // TAMANYO DEL PAQUETE REPORT
00957         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO EL NÚMERO DE COLAS QUE SE DEFINEN
00958         int srcAddress = 9; // DEFINICION DEL IDENTIFICADOR DE LA DIRECCION DE ORIGEN O FUENTE
00959         simtime_t time_tx_onu0; // TIEMPO DE TRANSIMISION DE LA PRIMERA ONU
00960         int onu = reportmsg->getSrcAddress(); // VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
00961         int lengthmethod = (int)par("methodlength_longvariable0_longfija1");
00962         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
00963         cTopology topo; // DEFINIMOS UN PARAMETRO DE LA TOPOLOGIA DE LA RED
00964         double longitud_total_red; // DEFINIMOS LA VARIABLE QUE NOS INDICA LA LONGITUD TOTAL DE LA RED
00965         // ASIGANCION DE PESOS
00966         Wsla[0] = (int)par("w_sla0"); // PESO DEL SLA0 DEFINIDO EN NUESTRA RED
00967         Wsla[1] = (int)par("w_sla1"); // PESO DEL SLA1 DEFINIDO EN NUESTRA RED
00968         Wsla[2] = (int)par("w_sla2"); // PESO DEL SLA2 DEFINIDO EN NUESTRA RED
00969 
00970         // ASIGNACION DEL NÚMERO DE ONUS
00971         numonu_sla[0] = (int)par("numonu_sla0"); // NÚMERO DE ONUs ASOCIADO AL SLA0
00972         numonu_sla[1] = (int)par("numonu_sla1"); // NÚMERO DE ONUs ASOCIADO AL SLA1
00973         numonu_sla[2] = (int)par("numonu_sla2"); // NÚMERO DE ONUs ASOCIADO AL SLA2
00974 
00975         //ASIGNACION DE ANCHO DE BANDAS
00976         BW_sla[0] = (int)par("BW_garantizado0"); //ANCHO DE BANDA ASOCIADO AL SLA0
00977         BW_sla[1] = (int)par("BW_garantizado1"); //ANCHO DE BANDA ASOCIADO AL SLA1
00978         BW_sla[2] = (int)par("BW_garantizado2"); //ANCHO DE BANDA ASOCIADO AL SLA2
00979 
00980         // CALCULAMOS EL DELAY O RETARDO DEPENDIENDO DE LA LONGITUD DE NUESTRA RED
00981         switch(lengthmethod)
00982         {
00983                 case 0:
00984                         // METODO DE LONGITUD VARIABLE
00985                         topo.extractByParameter( "numlong" ); // EXTRAEMOS LOS NODOS DE NUESTRA RED QUE UTILIZAN EL PARAMETRO numlong
00986                         delay_pon1 = ((int)par("longpon1")*3)/(velocidad*2); // CALCULAMOS EL RETARDO DEL SEGMENTO DE LA RED QUE UNE EL OLT Y EL SPLITTER
00987                         // RECORREMOS CON EL BUCLE FOR TODAS LAS ONUS PARA CALCULAR EL RETARDO DEL CANAL QUE UNE EL SPLITTER CON CADA ONU
00988                         for(int i=0; i<(int)par("numOnu"); i++)
00989                         {
00990                                 cModule *module = getParentModule()->getParentModule()->getSubmodule("onu", i); // DEFINIMOS EL PARAMETRO MODULE QUE NOS INDICA EL CAMINO HASTA EL NODO DEL QUE QUEREMOS OBTENER INFORMACION
00991                                 cTopology::Node *nodeonuOut = topo.getNodeFor(module); // NOMBRE DEL NODO QUE SACAMOS DEL GRAFO
00992                                 // RECORREMOS CON EL BUCLE FOR TODOS LOS ENLACES DE SALIDA QUE TIENE ESE NODO PARA OBTENER LA INFORMACION QUE SOLICITAMOS
00993                                 for(int j=0; j<nodeonuOut->getNumOutLinks(); j++)
00994                                 {
00995                                         delay_pon2[i] = (check_and_cast<cDelayChannel*>(nodeonuOut->getLinkOut(j)->getLocalGate()->getChannel()))->getDelay();
00996                                         //ev<<" Retardo Onu"<<i<<": "<<delay_pon2[i]<<endl; // VISUALIZAMOS EL VALOR DEL RETARDO
00997                                         delay_total[i] = delay_pon1 + delay_pon2[i]; // CALCULAMOS EL RETARDO TOTAL DE LA RED Y LO VISUALIZAMOS
00998                                         //ev<<" Retardo Total de la red PON: "<<delay_total[i]<<endl;
00999                                 }
01000                         }
01001                         break;
01002 
01003                 case 1:
01004                         // METODO DE LONGITUD FIJA
01005                         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
01006                         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
01007                         break;
01008 
01009                 default:
01010                         ev<<"Error al elegir el metodo de longitudes."<<endl;
01011                         break;
01012 
01013         }
01014 
01015         // OBTENEMOS Y VISUALIZAMOS POR PANTALLA EL TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE
01016         // COMPARAMOS SI SE TRATA DE LONGITUD DE LA RED VARIABLE O LONGITUD DE LA RED FIJA
01017         if((int)par("methodlength_longvariable0_longfija1")==0)
01018         {
01019                 // METODO DE LONGITUD VARIABLE
01020                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS ALEATORIAS
01021                 tiempo_sim_delay_datarate = simTime() + delay_total[onu] + tasa_tx_gate;
01022                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
01023         }
01024         else if((int)par("methodlength_longvariable0_longfija1")==1)
01025         {
01026                 // METODO DE LONGITUD FIJA
01027                 // TIEMPO DE SIMULACION + DELAY CORRESPONDIENTE + TASA DE TRANSMISION DEL PAQUETE GATE CON DISTANCIAS FIJAS
01028                 tiempo_sim_delay_datarate = simTime() + delay + tasa_tx_gate;
01029                 //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl;
01030         }
01031 
01032         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA DE CADA ONU ASIGNADO POR EL SLA QUE CORRESPONDE A CADA ONU
01033         // (SOLO LA PRIMERA VEZ)
01034         if(prueba==0)
01035         {
01036                 for(int j=0; j<(int)par("numSLA"); j++)
01037                 {
01038                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01039                         for(int i=0; i<numonu_sla[j]; i++)
01040                         {
01041                                 SLA_onu[id_onu+i] = Wsla[j]; // ASIGANAMOS A LA VARIABLE SLA_onu[] EL VALOR DEL PESO DEL SLA AL QUE ESTA ASOCIADA ESA ONU
01042                                 BW_SLA_onu[id_onu+i] = BW_sla[j]; //ASIGNAMOS A LA VARIABLE BW_SLA_onu[] EL VALOR DEL ANCHO DE BANDA GARANTIZADO POR SLA
01043                                 //ev<<" ONU "<<id_onu+i<<": Peso="<<Wsla[j]<<endl; // VISUALIZAMOS EL PESO ASOCIADO A CADA ONU
01044                                 numsla[id_onu+i] = j; // INTRODUCIMOS EN LA VARIABLE numsla[] EL IDENTIFICADOR DEL SLA PARA CADA ONU YA QUE LO UTILIZAREMOS PARA RECOGER EL RETARDO DE CADA SLA
01045                                 numero_sla[id_onu+i]=j;
01046                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU
01047                                 if(i==(numonu_sla[j]-1))
01048                                 {
01049                                                 id_onu=id_onu+1+i;
01050                                 }
01051                         }
01052                 }
01053                 id_onu=0; // IGUALAMOS EL IDENTIFICADOR DE LA ONU AL VALOR 0
01054                 // RECORREMOS MEDIANTE ESTE BUCLE FOR LOS SLAs DEFINIDOS EN NUESTRA RED PARA REALIZAR EL SUMATORIO PARA CALCULAR EL ANCHO DE BANDA ASOCIADO A CADA SLA
01055                 for(int i=0; i<(int)par("numSLA"); i++)
01056                 {
01057                                 sumatorio = sumatorio + (numonu_sla[i]*Wsla[i]); // CALCULAMOS EL SUMATORIO Y LO VISUALIZAMOS POR PANTALLA
01058                                 //ev<<" Sumatorio: "<<sumatorio<<endl;
01059                 }
01060                 for(int j=0; j<(int)par("numSLA"); j++)
01061                 {
01062                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01063                         for(int i=0; i<numonu_sla[j]; i++)
01064                         {
01065                                 B_max_sla[id+i] = B_cycle*Wsla[j]/sumatorio; // CALCULAMOS EL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU
01066                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU
01067                                 if(i==(numonu_sla[j]-1))
01068                                 {
01069                                                                         id=id+1+i;
01070                                 }
01071                         }
01072                 }
01073                 prueba=1;
01074         }
01075         id=0;
01076         sumatorio=0;
01077         //ev << " ONU[" << onu << "] --> SLA[" << numsla[onu] << "]." << endl;
01078         //ev << " Ancho de banda maximo para la ONU[" << onu << "]: " << B_max_sla[onu] << " Bytes" << endl;
01079 
01080         //VAMOS A CALCULAR EL ANCHO DE BANDA DEMANDADO Y LO GUARDAMOS EN LA TABLA
01081         //ev<<" Calculamos el Bandwidth Demandado y lo guardamos en la tabla del OLT."<<endl;
01082         // SUMAMOS EL TAMANYO DEL ESTADO DE LAS COLAS DE LA ONU QUE A MANDADO EL REPORT QUE LLEGA AL OLT
01083         for(int i=0; i<(int)par("numqueue"); i++)
01084         {
01085                 sumqueue = sumqueue + reportmsg->getQueue_estado(i); // Suma Bytes de todas las colas Ethernet de la ONU[]
01086         }
01087         // SI LA SUMA TOTAL DEL TAMANYO DE LAS COLAS ES 0, DAMOS UN VALOR PREDETERMINADO DE 20 BYTES
01088         if(sumqueue == 0)
01089         {
01090                 sumqueue = 20; // Longitud minima: 20 Bytes
01091         }
01092 
01093         // ASIGNAMOS LA SUMA TOTAL A LA VARIABLE DEL ANCHO DE BANDA DEMANDADO DE LA ONU
01094         B_demand[onu] = sumqueue;
01095 
01096         sumqueue = 0;// DAMOS EL VALOR 0 A LA SUMA DE LAS COLAS. DE ESTA MANERA LA INICIALIZAMOS DE NUEVO A 0
01097 
01098         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE EL ANCHO DE BANDA DEMANDADO POR LA ONU Y LO VISUALIZAMOS POR PANTALLA
01099         table_module->table_olt_report[onu][(int)par("numqueue")] = B_demand[onu];
01100         //ev << " ONU[" << onu << "] --> " << "Bandwidth Demandado: " << B_demand[onu] << " Bytes" << endl;
01101 
01102         /* Recoger delay por sla */
01103         if(simTime()>=1 && onu==(int)par("numOnu")-1)
01104         {
01105                 int prioridades = 2; // Clases de servicio de las que se controla el retardo con el PID (P0 y P1)
01106                 double delay_sla[(int)par("numSLA")][prioridades]; // Suma del retardo de todos los paquetes recibidos en un ciclo de cada SLA y prioridad
01107                 int paquetes_sla[(int)par("numSLA")][prioridades]; // Numero total de paquetes recibidos en un ciclo de cada SLA y prioridad
01108 
01109                 // Se ponen a cero todas las variables auxiliares para este nuevo ciclo:
01110                 for(int i=0; i<(int)par("numSLA"); i++)
01111                 {
01112                         for(int j=0; j<prioridades; j++)
01113                         {
01114                                 delay_sla[i][j]=0.0;
01115                                 paquetes_sla[i][j]=0;
01116                         }
01117                 }
01118                 int acum=0, k=0;
01119                 for (int j=0; j<(int)par("numSLA"); j++)
01120                 {
01121                         for(k=acum; k<numonu_sla[j]+acum; k++)
01122                         {
01123                                 for(int p=0; p<prioridades; p++)
01124                                 {
01125                                         // Aunque se va imprimiendo con cada actualizacion de cada onu de cada sla, el valor correcto
01126                                         // del retardo total y numero de paquetes de cada sla es el ultimo que sale impreso en el Tkenv.
01127                                         delay_sla[j][p]=delay_sla[j][p]+delay_onu[k][p];
01128                                         //ev<<" Retardo de los paquetes del SLA " << j << " con prioridad P" << p << ": " << delay_sla[j][p] << " segundos." << endl;
01129                                         paquetes_sla[j][p]=paquetes_sla[j][p] + paq_onu[k][p];
01130                                         //ev<<" Paquetes recibidos en el SLA " << j << " con prioridad P" << p << ": " << paquetes_sla[j][p] << endl;
01131                                         delay_onu[k][p]=0.0; // Para el siguiente ciclo
01132                                         paq_onu[k][p]=0.0; // Para el siguiente ciclo
01133                                 }
01134                         }
01135                         acum=k;
01136                         for(int p=0; p<prioridades; p++)
01137                         {
01138                                 if(paquetes_sla[j][p]>0) //Si hay algún paquete, entonces puedo dividir para sacar el delay:
01139                                 {
01140                                         recoger_delay_por_sla(j, (double)(delay_sla[j][p]/paquetes_sla[j][p]), p);
01141                                 }
01142                         }
01143                 }
01144                 if(simTime() >= 3*contador_aux)
01145                 {
01146                         contador_aux++;
01147                         //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL RETARDO MEDIO DE VENTANA PARA LA CLASE P0, POR CADA SLA:
01148                         evaluacion_retardo_slas_P0=fopen("results/retardo_medio_P0_slas.txt", "a+");
01149                         //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
01150                         fprintf(evaluacion_retardo_slas_P0," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)retardo_alg_ONU[0][0], (double)retardo_alg_ONU[2][0], (double)retardo_alg_ONU[8][0]);
01151                         fclose(evaluacion_retardo_slas_P0);
01152 
01153                         //FICHERO PARA LA RECOGIDA DE LOS DATOS SOBRE EL RETARDO MEDIO DE VENTANA PARA LA CLASE P1, POR CADA SLA:
01154                         evaluacion_retardo_slas_P1=fopen("results/retardo_medio_P1_slas.txt", "a+");
01155                         //" T \t  SLA_0  \t  SLA_1  \t  SLA_2  \n"
01156                         fprintf(evaluacion_retardo_slas_P1," %g \t %g \t %g \t %g \n" , SIMTIME_DBL(simTime()), (double)retardo_alg_ONU[0][1], (double)retardo_alg_ONU[2][1], (double)retardo_alg_ONU[8][1]);
01157                         fclose(evaluacion_retardo_slas_P1);
01158                 }
01159         }
01160 
01161         // EJECUTAMOS EL ALGORITMO IPACT YA QUE SE EJECUTA CADA VEZ QUE LLEGA UN MENSAJE REPORT DESDE LAS ONUS
01162         if(tiempo_tx_siguiente <= tiempo_sim_delay_datarate)
01163         {
01164                 //ev<<" **CASO A. Tiempo de Transmision siguiente menor.**"<<endl;
01165 
01166                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
01167                 if(B_demand[onu] <= B_max_sla[onu])
01168                 {
01169                         //ev << "       No se supera el BW maximo" << endl;
01170                         B_alloc[onu] = B_demand[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
01171                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01172                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01173                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01174 
01175                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01176                 }
01177                 else if(B_demand[onu] > B_max_sla[onu])
01178                 {
01179                         //ev << "       Se pide mas del BW maximo" << endl;
01180                         B_alloc[onu] = B_max_sla[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
01181                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01182                         //ev<<" Ancho de Banda Asigando ONU "<<onu<<": "<<B_alloc[onu]<<endl;
01183                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01184                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01185                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01186                 }
01187                 //ev << " ONU[" << onu << "] --> " << "Bandwidth Asignado: " << B_alloc[onu] << " Bytes" << endl;
01188                 T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
01189 
01190                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01191                 GATEmsg *packet = new GATEmsg("gate");
01192                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01193                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01194                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01195                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01196                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01197                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01198 
01199                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01200                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01201                 {
01202                         B_slot[0]= B_alloc[onu]; // DEFINIMOS ANCHO DE BANDA DE SLOT
01203                         packet->setGrant_IntervalTx(0,B_slot[0]);
01204                 }
01205                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01206                 {
01207                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
01208                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01209                         for(int b=0; b<(int)par("numqueue"); b++)
01210                         {
01211                                 B_slot[b] = B_alloc[onu]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01212                                 packet->setGrant_IntervalTx(b,B_slot[b]);
01213                                 //ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
01214                         }
01215                 }
01216                 packet->setGrant_IniTime(tiempo_sim_delay_datarate); // TIEMPO DE INICIO DE TRANSMISION
01217                 /*
01218                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01219                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01220                 ev<<" Paquete Gate."<<endl;
01221                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01222                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01223                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01224                 ev<<" Tipo "<<packet->getKind()<<endl;
01225                 ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
01226                 ev<<"  "<<endl;
01227                 */
01228                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01229                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01230                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU
01231                 tiempo_tx_siguiente = tiempo_sim_delay_datarate + T_tx_onu;
01232                 //ev<<" Tiempo de Transmision Siguiente: "<<tiempo_tx_siguiente<<endl;
01233         }
01234         else if(tiempo_tx_siguiente > tiempo_sim_delay_datarate)
01235         {
01236                 //ev<<" **CASO B. Tiempo de Transmision siguiente mayor.**"<<endl;
01237 
01238                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
01239                 if(B_demand[onu] <= B_max_sla[onu])
01240                 {
01241                         //ev << "       No se supera el BW maximo" << endl;
01242                         B_alloc[onu] = B_demand[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
01243                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01244                         //ev<<" Ancho de Banda Asigando ONU "<<onu<<": "<<B_alloc[onu]<<endl;
01245                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01246                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01247                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<"Bytes"<<endl;
01248 
01249                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01250                 }
01251                 else if(B_demand[onu] > B_max_sla[onu])
01252                 {
01253                         //ev << "       Se pide mas del BW maximo" << endl;
01254                         B_alloc[onu] = B_max_sla[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
01255                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01256                         //ev<<" Ancho de Banda Asigando ONU "<<onu<<": "<<B_alloc[onu]<<endl;
01257                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01258                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01259                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<"Bytes"<<endl;
01260                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01261                 }
01262                 //ev << " ONU[" << onu << "] --> " << "Bandwidth Asignado: " << B_alloc[onu] << " Bytes" << endl;
01263                 T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
01264 
01265                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01266                 GATEmsg *packet = new GATEmsg("gate");
01267                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01268                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01269                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01270                 packet->setLambdagate(0); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01271                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01272                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01273 
01274                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01275                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01276                 {
01277                         B_slot[0]= B_alloc[onu]; // DEFINIMOS ANCHO DE BANDA DE SLOT
01278                         packet->setGrant_IntervalTx(0,B_slot[0]);
01279                 }
01280                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01281                 {
01282                         //FALTA ALGORITMO PARA ASIGNAR POR COLAS!!!!!!!!!
01283                         // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01284                         for(int b=0; b<(int)par("numqueue"); b++)
01285                         {
01286                                 B_slot[b] = B_alloc[onu]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01287                                 packet->setGrant_IntervalTx(b,B_slot[b]);
01288                                 //ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
01289                         }
01290                 }
01291                 packet->setGrant_IniTime(tiempo_tx_siguiente); // TIEMPO DE INICIO DE TRANSMISION
01292                 /*
01293                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01294                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01295                 ev<<" Paquete Gate."<<endl;
01296                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01297                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01298                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01299                 ev<<" Tipo "<<packet->getKind()<<endl;
01300                 ev<<" Tiempo inicial Tx "<<packet->getGrant_IniTime()<<endl;
01301                 ev<<"  "<<endl;
01302                 */
01303                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01304                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01305                 //ACTUALIZAMOS EL TIEMPO DE INICIO DE TRANSMISION PARA LA SIGUIENTE ONU
01306                 tiempo_tx_siguiente = tiempo_tx_siguiente + T_tx_onu;
01307                 //ev<<" Tiempo de Transmision Siguiente: "<<tiempo_tx_siguiente<<endl;
01308         }
01309         delete reportmsg; // BORRAMOS EL PAQUETE REPORT
01310 }

void MAC_OLT::recoger_bw_por_onu ( cMessage msg  )  [protected, virtual]

Definition at line 2970 of file MAC_OLT.cc.

02971 {
02972         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
02973 
02974         //ev<<" "<<endl;
02975         //ev<<" ENTRO EN EL CODIGO PARA RECOGER ANCHO DE BANDA POR ONU "<<endl;
02976         //ev<<" "<<endl;
02977 
02978         double win_max = 10;//7.5; //TAMANYO MAXIMO DE VENTANA //DaSPID->Twindow=10s.
02979         int onu=reportmsg->getSrcAddress(); //VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
02980         double bw_giv_ant=0.0; //VARIABLE QUE GUARDARI EL ANCHO DE BANDA ANTERIOR
02981         double tiempo_ant=0.0; //VARIABLE QUE GUARDARI EL TIEMPO ANTERIOR
02982         double win_time; //VARIABLE PARA EL TIEMPO DE VENTANA
02983         double bw_borrar_acum; //VARIABLE QUE VA A IR ACUMULANDO LA SUMA DEL ANCHO DE BANDA DE TODOS LOS PAQUETES BORRADOS
02984         double Mbps_borrar_acum; //VARIABLE QUE VA A IR ACUMULANDO LA SUMA DEL ANCHO DE BANDA DE TODOS LOS PAQUETES BORRADOS EN MBPS
02985         double bw_borrar; //ANCHO DE BANDA DEL PAQUETE BORRADO
02986         double Mbps_borrar; //MBPS BORRADOS DE UN PAQUETE
02987 
02988         //ENTRAR SI EN LA COLA YA TENEMOS ALGUN PAQUETE
02989         if(cola_vector[onu].size()!=0)
02990         {
02991                                 bw_giv_ant=cola_vector[onu][cola_vector[onu].size()-1][0];
02992                                 tiempo_ant=cola_vector[onu][cola_vector[onu].size()-1][1];
02993         }
02994 
02995         cola_vector[onu].resize(cola_vector[onu].size()+1);
02996         cola_vector[onu][cola_vector[onu].size()-1].resize(3, 0.0);
02997 
02998         cola_vector[onu][cola_vector[onu].size()-1][0]= B_alloc[onu];
02999         cola_vector[onu][cola_vector[onu].size()-1][1]= SIMTIME_DBL(simTime());
03000         cola_vector[onu][cola_vector[onu].size()-1][2]= ((double)bw_giv_ant/(SIMTIME_DBL(simTime())-tiempo_ant));
03001 
03002         //ACTUALIZAMOS EL TIEMPO DE VENTANA
03003         win_time = cola_vector[onu][0][1];
03004 
03005         //ENTRAMOS SI NO SUPERAMOS EL TAMANYO MAXIMO DE LA VENTANA
03006         if((SIMTIME_DBL(simTime())-win_time)<win_max)
03007         {
03008                 //CALCULAMOS EL BW ACUMULADO Y EL BW MEDIO
03009                 bw_acum_ONU[onu]=bw_acum_ONU[onu]+(double)B_alloc[onu];
03010                 bw_alg_ONU[onu]=(double)(bw_acum_ONU[onu]/cola_vector[onu].size());
03011                 //ev<<" B_acumulado "<<bw_acum_ONU[onu]<<" y tamaño "<<cola_vector[onu].size()<<endl;
03012                 //ev<<" MEDIA de la ONU: "<<onu<<" : "<<bw_alg_ONU[onu]<<endl;
03013                 //ev<<" La cola de la ONU "<<onu<<" NO ha llegado al maximo tiempo de ventana, que es: "<<win_max<<endl;
03014                 bw_acum_Mbps[onu]= bw_acum_Mbps[onu]+(double)(bw_giv_ant/(SIMTIME_DBL(simTime())-tiempo_ant));
03015                 bw_alg_Mbps[onu]=(double)(bw_acum_Mbps[onu]/cola_vector[onu].size());
03016         }
03017         //ENTRAMOS SI SUPERAMOS EL TAMANYO MAXIMO DE LA VENTANA
03018         else
03019         {
03020                 bw_borrar_acum=0;
03021                 Mbps_borrar_acum=0.0;
03022                 //ev<<" La cola de la ONU "<<onu<<" SI ha llegado al maximo tiempo de ventana, que es: "<<win_max<<endl;
03023                 //BORRAMOS PAQUETES MIENTRAS SUPEREMOS EL TAMANYO MAXIMO DE LA VENTANA
03024                 while ( (SIMTIME_DBL(simTime())-win_time)>win_max)
03025                 {
03026                         bw_borrar=cola_vector[onu][0][0];
03027 
03028                         Mbps_borrar=cola_vector[onu][0][2];
03029                         cola_vector[onu].erase(cola_vector[onu].begin());
03030 
03031                         bw_borrar_acum = bw_borrar_acum + bw_borrar;
03032                         Mbps_borrar_acum = Mbps_borrar_acum + Mbps_borrar;
03033                         win_time = cola_vector[onu][0][1];
03034                         //ev<<" bw_borrado "<<bw_borrar<<endl;
03035                 }
03036                 //ev<<" El siguiente win time de la ventana es "<<win_time<<endl;
03037                 bw_acum_ONU[onu]=bw_acum_ONU[onu]+(double)B_alloc[onu] - bw_borrar_acum;
03038                 bw_alg_ONU[onu]=bw_acum_ONU[onu]/cola_vector[onu].size();
03039                 //ev<<" B_acumulado "<<bw_acum_ONU[onu]<<" y tamaño "<<cola_vector[onu].size()<<endl;
03040                 //ev<<" MEDIA de la ONU en bits: "<<onu<<" : "<<bw_alg_ONU[onu]<<endl;
03041                 bw_acum_Mbps[onu]=bw_acum_Mbps[onu]+(double)(bw_giv_ant/(SIMTIME_DBL(simTime())-tiempo_ant))- Mbps_borrar_acum;
03042                 bw_alg_Mbps[onu]=(double)(bw_acum_Mbps[onu]/cola_vector[onu].size());
03043         }
03044         //CALCULAMOS LA MEDIA DE UNA ONU DE CADA SLA
03045         if(onu==0)
03046         {
03047                 PID_MEDIO_TOTAL[0]=PID_MEDIO_TOTAL[0]+BW_max_PID[0];
03048                 cont_aux0++;
03049                 PID_MEDIO[0]=PID_MEDIO_TOTAL[0]/cont_aux0;
03050         }
03051         else if(onu==2)//1)
03052         {
03053                 PID_MEDIO_TOTAL[1]=PID_MEDIO_TOTAL[1]+BW_max_PID[1];
03054                 cont_aux2++;
03055                 PID_MEDIO[1]=PID_MEDIO_TOTAL[1]/cont_aux2;
03056         }
03057         else if(onu==8)//6)
03058         {
03059                 PID_MEDIO_TOTAL[2]=PID_MEDIO_TOTAL[2]+BW_max_PID[2];
03060                 cont_aux10++;
03061                 PID_MEDIO[2]=PID_MEDIO_TOTAL[2]/cont_aux10;
03062         }
03063 }

void MAC_OLT::recoger_delay_por_sla ( int  sla,
double  retardo,
int  prioridad 
) [protected, virtual]

Definition at line 2692 of file MAC_OLT.cc.

02693 {
02694         // FUNCION PARA RECOGER EL RETARDO POR SLA CADA VENTANA TEMPORAL:
02695         // La ventana es ahora un array 2D, 3x2results/tamano_throughput_slas.txt (3 SLAs y 2 clases de servicio controladas).
02696         // Se tiene una cola para cada SLA y prioridad, y se va insertando la media del retardo de los paquetes
02697         // en un ciclo ("Tcycle"). Además, se guarda el tiempo en que se obtuvo tal retardo para que si la cola
02698         // supera un cierto tamaño (en segundos), se borra la primera muestra y se inserta la nueva al final.
02699         //ev<<" Entro en 'recoger_delay' para las ONUs del SLA " << sla << ", con prioridad de servicio P" << prioridad << " y retardo=" << retardo << endl;
02700         double win_max = 10; // Tiempo maximo de la ventana deslizante
02701         double win_time;
02702         //double delay_giv_aux;
02703         double delay_giv_ant=0.0;
02704         double delay_borrar_acum=0;
02705         double delay_borrar;
02706         double tiempo_ant = 0.0;
02707 
02708         // SI EN LA COLA YA SE TIENE ALGUN PAQUETE, SE GUARDAN LOS PARAMETROS DEL ULTIMO EN ESTAS VARIABLES AUXILIARES:
02709         if(vector_ventana[sla][prioridad].size()!=0)
02710         {
02711                 delay_giv_ant = vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][0];
02712                 tiempo_ant = vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][1];
02713                 //ev<<" Retardo medio del ciclo anterior: " << delay_giv_ant << endl;
02714                 //ev<<" Tiempo de ventana del ciclo anterior: " << tiempo_ant << endl;
02715         }
02716         // Redimension de la ventana para albergar un nuevo elemento:
02717         vector_ventana[sla][prioridad].resize(vector_ventana[sla][prioridad].size()+1);
02718         vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1].resize(2,0.0);
02719         // Almacenamiento en la ventana del retardo medio de este ciclo y el tiempo actual:
02720         vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][0] = retardo;
02721         vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][1] = SIMTIME_DBL(simTime());
02722 
02723         //ev<<" Retardo medio de este ciclo: " << vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][0] << endl;
02724         //ev<<" Tiempo de ventana de este ciclo: " << vector_ventana[sla][prioridad][vector_ventana[sla][prioridad].size()-1][1] << endl;
02725 
02726         // Obtencion del tiempo en que fue registrada la primera muestra:
02727         win_time = vector_ventana[sla][prioridad][0][1];
02728         // SI NO SE SUPERA EL TAMANYO MAXIMO DE LA VENTANA (10 segundos)...
02729         if((SIMTIME_DBL(simTime())-win_time)<win_max)
02730         {
02731                 //ev<<" La cola del SLA " << sla << " NO ha llegado al maximo tiempo de ventana, que son " << win_max << "s." << endl;
02732                 // CALCULO DEL RETARDO ACUMULADO Y EL RETARDO MEDIO PARA LOS PAQUETES DE ESTE SLA Y ESTA PRIORIDAD:
02733                 retardo_acum_SLA[sla][prioridad] = retardo_acum_SLA[sla][prioridad] + retardo;
02734                 retardo_alg_SLA[sla][prioridad] = (double)retardo_acum_SLA[sla][prioridad]/vector_ventana[sla][prioridad].size();
02735                 //ev<<" Retardo acumulado: " << retardo_acum_SLA[sla][prioridad] << "s | Longitud: " << vector_ventana[sla][prioridad].size() << endl;
02736                 //ev<<" MEDIA del SLA " << sla << ": " << retardo_alg_SLA[sla][prioridad] << endl;
02737         }
02738         // SI SE SUPERA EL TAMANYO MAXIMO DE LA VENTANA (10 segundos), SE BORRAN PAQUETES:
02739         else
02740         {
02741                 //ev<<" La cola del SLA " << sla << " SI ha llegado al maximo tiempo de ventana, que es: " << win_max << " --> BORRADO DE PAQUETES" << endl;
02742                 delay_borrar_acum = 0.0;
02743                 // MIENTRAS SE SUPERE EL TAMANYO MAXIMO DE LA VENTANA, SE BORRAN PAQUETES:
02744                 while((SIMTIME_DBL(simTime())-win_time) > win_max)
02745                 {
02746                         delay_borrar = vector_ventana[sla][prioridad][0][0];
02747                         vector_ventana[sla][prioridad].erase(vector_ventana[sla][prioridad].begin());
02748                         delay_borrar_acum = delay_borrar_acum + delay_borrar;
02749                         win_time = vector_ventana[sla][prioridad][0][1];
02750                         //ev<<" Retardo borrado: " << delay_borrar << " | Retardo total borrado: " << delay_borrar_acum << endl;
02751                 }
02752                 //ev<<" Longitud de la ventana: " << SIMTIME_DBL(simTime()) - win_time << " segundos." << endl;
02753                 retardo_acum_SLA[sla][prioridad] = retardo_acum_SLA[sla][prioridad] + retardo - delay_borrar_acum;
02754                 retardo_alg_SLA[sla][prioridad] = retardo_acum_SLA[sla][prioridad]/vector_ventana[sla][prioridad].size();
02755                 //ev<<" Retardo acumulado: " << retardo_acum_SLA[sla][prioridad] <<" | Longitud de la ventana: " << vector_ventana[sla][prioridad].size() << endl;
02756                 //ev<<" MEDIA del retardo del SLA " << sla << ", para la prioridad P" << prioridad << ": " << retardo_alg_SLA[sla][prioridad] << endl;
02757         }
02758         // Como 'PID_control_delay()' se basa en los retardos de las ONUs individuales, se asigna a cada ONU el retardo correspondiente a su SLA:
02759         int aux=0, j;
02760         for(int i=0; i<(int)par("numSLA"); i++)
02761         {
02762                 for(j=aux; j<(int)numonu_sla[i]+aux; j++)
02763                 {
02764                         for(int k=0; k<2; k++)
02765                         {
02766                                 retardo_alg_ONU[j][k] = retardo_alg_SLA[i][k];
02767                         }
02768                 }
02769                 aux = j;
02770         }
02771 }

void MAC_OLT::wdmmethod ( cMessage msg  )  [protected, virtual]

Definition at line 1315 of file MAC_OLT.cc.

01316 {
01317         /*
01318         ev<<" "<<endl;
01319         ev<<" EJECUTAMOS EL METODO CON MODULACION WDM."<<endl;
01320         ev<<" "<<endl;
01321         */
01322         REPORTmsg *reportmsg = check_and_cast<REPORTmsg *>(msg); // CHEQUEAMOS EL PAQUETE REPORT
01323 
01324         //VARIABLES
01325         double T_guarda = 0.000005; // TIEMPO DE GUARDA QUE SE ESPERA ENTRA LA TRANSMISION DE DOS ONUS
01326         double T_cycle = 0.002; // TIEMPO DE CICLO MAXIMO EN MILISEGUNDOS
01327         double T_guarda_nonu = T_guarda*((int)par("numOnu")); // TIEMPO DE GUARDA TOTAL DE TODAS LAS ONUS
01328         double txrate = (int)par("txrate"); // TASA DE TRANSMISION EN BITS POR SEGUNDO
01329         double tasa_tx_gate = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE GATE DE 64 BYTES
01330         double tasa_tx_report = 512/txrate; // TASA DE TRANSMISION DEL PAQUETE REPORT DE 64 BYTES
01331         double longitud_total_red; // DEFINIMOS LA VARIABLE QUE NOS INDICA LA LONGITUD TOTAL DE LA RED
01332         double velocidad = 300000000; // DEFINIMOS EL PARAMETRO VELOCIDAD DE LA VELOCIDAD DE LA LUZ (EN M/S)
01333         int onu = reportmsg->getSrcAddress(); // VARIABLE QUE NOS INDICA EL IDENTIFICADOR DE LA ONU CORRESPONDIENTE
01334         long double B_report = txrate*tasa_tx_report/8; // TAMANYO DEL PAQUETE REPORT
01335         double T_tx_onu; // TIEMPO DE TRANSMISION DE UNA ONU
01336         int srcAddress = 9; // DEFINICION DEL IDENTIFICADOR DE LA DIRECCION DE ORIGEN O FUENTE
01337         int B_max; //VARIABLE QUE EMPLEAREMOS PARA DETERMINAR EL ANCHO DE BANDA MAXIMO
01338         simtime_t t_tx = 99999; //VARIABLE AUXILIAR EMPLEADA PARA COMPARAR
01339         double B_slot[(int)par("numqueue")]; // VARIABLE DE ANCHO DE BANDA DE SLOT CON TAMANYO EL NÚMERO DE COLAS QUE SE DEFINEN
01340         double T_report_nonu = tasa_tx_report*((int)par("numOnu")); // TASA DE TRANSMISION TOTAL DE LOS PAQUETES REPORT DE TODAS LAS ONUS
01341         double T_cycle_total = T_cycle - T_guarda_nonu - T_report_nonu; // TIEMPO DE CICLO FINAL Y LO VISUALIZAMOS POR PANTALLA
01342         long double B_cycle = txrate*T_cycle_total/8; // ANCHO DE BANDA MAXIMO DEL CICLO EN BYTES
01343 
01344         // ASIGANCION DE PESOS
01345         Wsla[0] = (int)par("w_sla0"); // PESO DEL SLA0 DEFINIDO EN NUESTRA RED
01346         Wsla[1] = (int)par("w_sla1"); // PESO DEL SLA1 DEFINIDO EN NUESTRA RED
01347         Wsla[2] = (int)par("w_sla2"); // PESO DEL SLA2 DEFINIDO EN NUESTRA RED
01348 
01349         // ASIGNACION DEL NÚMERO DE ONUS
01350         numonu_sla[0] = (int)par("numonu_sla0"); // NÚMERO DE ONUs ASOCIADO AL SLA0
01351         numonu_sla[1] = (int)par("numonu_sla1"); // NÚMERO DE ONUs ASOCIADO AL SLA1
01352         numonu_sla[2] = (int)par("numonu_sla2"); // NÚMERO DE ONUs ASOCIADO AL SLA2
01353 
01354         //CALCULAMOS EL RETARDO QUE TENDREMOS SUPONIENDO QUE LAS LONGITUDES VAN A SER FIJAS
01355         longitud_total_red = ((int)par("longpon1")+(int)par("longpon2")); // DEFINIMOS EL PARAMETRO QUE INDICA LA LONGITUD TOTAL DE LA RED EN METROS
01356         delay = (longitud_total_red*3)/(velocidad*2); // CALCULAMOS EL RETARDO O DELAY PARA LA RED SEGUN LA LONGITU QUE DEFINAMOS AL PRINCIPION DE LA SIMULACION
01357 
01358         tiempo_sim_delay_datarate = simTime() + delay + tasa_tx_gate;
01359         //ev<<" Tiempo de simulacion + delay + tasa tx gate: "<<tiempo_sim_delay_datarate<<" s."<<endl<<endl;
01360 
01361         t_tx=SIMTIME_DBL(t_tx);
01362 
01363 
01364         for(int j=0; j<(int)par("numSLA"); j++)
01365         {
01366                 // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01367                 for(int i=0; i<numonu_sla[j]; i++)
01368                 {
01369                         SLA_onu[id_onu+i] = Wsla[j]; // ASIGANAMOS A LA VARIABLE SLA_onu[] EL VALOR DEL PESO DEL SLA AL QUE ESTA ASOCIADA ESA ONU
01370                         //ev<<" ONU "<<id_onu+i<<": Peso="<<Wsla[j]<<endl; // VISUALIZAMOS EL PESO ASOCIADO A CADA ONU
01371                         numsla[id_onu+i] = j; // INTRODUCIMOS EN LA VARIABLE numsla[] EL IDENTIFICADOR DEL SLA PARA CADA ONU YA QUE LO UTILIZAREMOS PARA RECOGER EL RETARDO DE CADA SLA
01372                         numero_sla[id_onu+i]=j;
01373                         // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU QUE
01374                         if(i==(numonu_sla[j]-1))
01375                         {
01376                                         id_onu=id_onu+1+i;
01377                         }
01378                 }
01379         }
01380         id_onu=0; // IGUALAMOS EL IDENTIFICADOR DE LA ONU AL VALOR 0
01381 
01382         // RECORREMOS MEDIANTE ESTE BUCLE FOR LOS SLAs DEFINIDOS EN NUESTRA RED PARA REALIZAR EL SUMATORIO PARA CALCULAR EL ANCHO DE BANDA ASOCIADO A CADA SLA
01383         for(int i=0; i<(int)par("numSLA"); i++)
01384         {
01385                         sumatorio = sumatorio + (numonu_sla[i]*Wsla[i]); // CALCULAMOS EL SUMATORIO Y LO VISUALIZAMOS POR PANTALLA
01386         }
01387 
01388         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs PARA CALCULAR EL ANCHO DE BANDA DE CADA ONU ASIGNADO POR EL SLA QUE CORRESPONDE A CADA ONU
01389         for(int j=0; j<(int)par("numSLA"); j++)
01390         {
01391                         // RECORREMOS MEDIANTE ESTE BUCLE FOR TODAS LAS ONUs ASOCIADAS A UN SLA
01392                         for(int i=0; i<numonu_sla[j]; i++)
01393                         {
01394                                 B_max_sla[id+i] = B_cycle*int(par("numlong"))*Wsla[j]/sumatorio; // CALCULAMOS EL ANCHO DE BANDA ASOCIADO A CADA ONU SEGUN EL SLA ASOCIADO A LA ONU
01395                                 //ev<<" Ancho de Banda de SLA de la ONU"<<id+i<<": "<<B_max_sla[id+i]<<endl; // VISUALIZAMOS EL ANCHO DE BANDA
01396                                 // MEDIANTE ESTE IF, VAMOS INCREMENTANDO EL IDENTIFICADOR DE LA ONU:
01397                                 if(i==(numonu_sla[j]-1))
01398                                 {
01399                                         id=id+1+i;
01400                                 }
01401                         }
01402         }
01403         id=0;
01404         sumatorio=0;
01405 
01406         // SUMAMOS EL TAMANYO DEL ESTADO DE LAS COLAS DE LA ONU QUE HA MANDADO EL REPORT QUE LLEGA AL OLT
01407         for(int i=0; i<(int)par("numqueue"); i++)
01408         {
01409                 sumqueue = sumqueue + reportmsg->getQueue_estado(i);
01410 
01411         }
01412 
01413         // SI LA SUMA TOTAL DEL TAMANYO DE LAS COLAS ES 0, DAMOS UN VALOR PREDETERMINADO DE 20 BYTES
01414         if(sumqueue == 0)
01415         {
01416                         sumqueue = 20;
01417         }
01418 
01419         // ASIGNAMOS LA SUMA TOTAL A LA VARIABLE DEL ANCHO DE BANDA DEMANDADO DE LA ONU
01420         B_demand[onu] = sumqueue;
01421 
01422         sumqueue = 0;// DAMOS EL VALOR 0 A LA SUMA DE LAS COLAS. DE ESTA MANERA LA INICIALIZAMOS DE NUEVO A 0
01423 
01424         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE EL ANCHO DE BANDA DEMANDADO POR LA ONU Y LO VISUALIZAMOS POR PANTALLA
01425         table_module->table_olt_report[onu][(int)par("numqueue")] = B_demand[onu];
01426         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Demandado: "<< B_demand[onu]<<"Bytes"<<endl;
01427 
01428         //CALCULAMOS ANCHO DE BANDA MAXIMO DE CADA ONU DEPENDIENDO DEL SLA
01429         B_max = 15000; // ASIGNAMOS UN VALOR AL ANCHO DE BANDA MAXIMO Y LO VISUALIZAMOS POR PANTALLA (BYTES)
01430         //ev<<" Ancho de Banda Maximo asignado por ONU "<<onu<<": " <<B_max_sla[onu]<<endl;
01431 
01432         //ev<<" Ancho de banda demandado"<<": "<<B_demand[onu]<<endl;
01433 
01434                 // COMPARAMOS SI EL ANCHO DE BANDA DEMANDADO ES MAYOR O MENOR QUE EL ANCHO DE BANDA MAXIMO
01435                 if(B_demand[onu] <= B_max_sla[onu])
01436                 {
01437                         B_alloc[onu] = B_demand[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA DEMANDADO MAS EL TAMANYO DEL PAQUETE REPORT
01438                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01439                         //ev<<" Ancho de Banda Asigando ONU "<<onu<<": "<<B_alloc[onu]<<endl;
01440                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01441                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01442                         //ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<"Bytes"<<endl;
01443                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01444                 }
01445                 else if(B_demand[onu] > B_max_sla[onu])
01446                 {
01447                         B_alloc[onu] = B_max_sla[onu] + B_report; // DAMOS EL VALOR AL ANCHO DE BANDA ASIGNADO DEL ANCHO DE BANDA  MAXIMO MIS EL TAMANYO DEL PAQUETE REPORT
01448                         // VISUALIZAMOS POR PANTALLA EL ANCHO DE BANDA ASIGNADO
01449                         ev<<" Ancho de Banda Asigando ONU "<<onu<<": "<<B_alloc[onu]<<endl;
01450                         // GUARDAMOS EN LA TABLA DEL MODULO OLT_TABLE LA VARIABLE DEL ANCHO DE BANDA ASIGANDO Y LO VISUALIZAMOS POR PANTALLA
01451                         table_module->table_olt_report[onu][(int)par("numqueue")+1] = B_alloc[onu];
01452                         ev<<" ONU "<< onu<<"->"<< "Bandwidth Asignado: "<< B_alloc[onu]<<"Bytes"<<endl;
01453                         ev<<" "<<endl;
01454                         T_alloc[onu] = B_alloc[onu]*8/txrate; // CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU CON RESPECTO AL ANCHO DE BANDA ASIGNADO
01455                 }
01456         T_tx_onu = T_alloc[onu] + T_guarda; //CALCULAMOS EL TIEMPO DE TRANSMISION DE LA ONU
01457         //BUCLE PARA RECORRER LAS DISTINTAS LONGITUDES DE ONDA EN LAS QUE ESTAMOS TRABAJANDO
01458         for(int i=0; i<(int)par("numlong"); i++)
01459         {
01460                 //ev<<" Tiempo actual de la longitud de onda "<<i<<": "<<tiempo_tx_sig[i]<<endl;
01461                 //VAMOS A IR COMPARANDO QUE LONGITUD DE ONDA QUEDA VACIA PRIMERO Y ENVIAREMOS NUESTRO PAQUETE POR ESA
01462                 if(tiempo_tx_sig[i]<t_tx)
01463                 {
01464                         t_tx=tiempo_tx_sig[i];
01465                         aux=i;
01466                 }
01467         }
01468         if(t_tx<=tiempo_sim_delay_datarate)
01469         {
01470                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01471                 GATEmsg *packet = new GATEmsg("gate");
01472                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01473                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01474                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01475                 packet->setLambdagate(aux); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01476                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01477                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01478                 packet->setNumsla(numero_sla[onu]);
01479                 packet->setGrant_IniTime(tiempo_sim_delay_datarate); // TIEMPO DE INICIO DE TRANSMISION
01480                 /*
01481                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01482                 ev<<" "<<endl;
01483                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01484                 ev<<" Paquete Gate."<<endl;
01485                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01486                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01487                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01488                 ev<<" Tipo "<<packet->getKind()<<endl;
01489                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
01490                 ev<<" SLA: "<<packet ->getNumsla()<<endl;
01491                 ev<<"  "<<endl;
01492                 */
01493                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01494                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01495                 {
01496                                 B_slot[0]= B_alloc[onu]; // DEFINIMOS ANCHO DE BANDA DE SLOT
01497                                 packet->setGrant_IntervalTx(0,B_slot[0]);
01498                 }
01499                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01500                 {
01501                                 // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01502                                 for(int b=0; b<(int)par("numqueue"); b++)
01503                                 {
01504                                         B_slot[b] = B_alloc[onu]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01505                                         packet->setGrant_IntervalTx(b,B_slot[b]);
01506                                         //ev<<" Ancho de Banda de Slot "<<b<<" "<<B_slot[b]<<endl;
01507                                 }
01508                 }
01509                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01510                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01511                 //ACTUALIZAMOS EL TIEMPO DE CADA LAMBDA SUMANDO EL TIEMPO ACTUAL DE LA LAMBDA QUE SE VACIO ANTES CON EL TIEMPO DE TRANSMISION DE LA ONU
01512                 tiempo_tx_sig[aux]=tiempo_sim_delay_datarate+T_tx_onu;
01513         }
01514         else if(t_tx>tiempo_sim_delay_datarate)
01515         {
01516                 //CREAMOS EL PAQUETE GATE PARA LA ONU
01517                 GATEmsg *packet = new GATEmsg("gate");
01518                 packet->setSrcAddress(srcAddress); // DIRECCION DE ORIGEN O FUENTE
01519                 packet->setDestAddress(onu); // DIRECCION DE DESTINO
01520                 packet->setByteLength(64); // TAMANYO DEL PAQUETE GATE
01521                 packet->setLambdagate(aux); // LONGITUD DE ONDA POR LA QUE SE TRANSMITE EL PAQUETE GATE
01522                 packet->setKind(0); // IDENTIFICADOR DEL PAQUETE GATE
01523                 packet->setGrant_IntervalTxArraySize((int)par("numqueue")); // TAMANYO DEL ARRAY QUE CONTIENE EL ANCHO DE BANDA DE SLOT
01524                 packet->setNumsla(numero_sla[onu]);
01525                 packet->setGrant_IniTime(t_tx); // TIEMPO DE INICIO DE TRANSMISION
01526                 /*
01527                 // VISUALIZAMOS POR PANTALLA TODOS LOS CAMPOS DEL PAQUETE GATE
01528                 ev<<" "<<endl;
01529                 ev<<" Creamos el paquete gate para la Onu "<<packet->getDestAddress()<<endl;
01530                 ev<<" Paquete Gate."<<endl;
01531                 ev<<" Origen OLT ID: "<<packet->getSrcAddress()<<endl;
01532                 ev<<" Destino ONU "<<packet->getDestAddress()<<endl;
01533                 ev<<" Longitud de onda de envio, Lambda "<< packet->getLambdagate()<<endl;
01534                 ev<<" Tipo "<<packet->getKind()<<endl;
01535                 ev<<" Tiempo iniciar Tx "<<packet->getGrant_IniTime()<<endl;
01536                 ev<<" SLA: "<<packet ->getNumsla()<<endl;
01537                 ev<<"  "<<endl;
01538                 */
01539                 // DEPENDIENDO DEL METODO DE EXTRACCION DE PAQUETES, SE DEFINE UN ANCHO DE BANDA DE SLOT GENERAL O UNO PARA CADA COLA
01540                 if((int)par("extractionmethod_StrictPQ0_Centralized1")==0)
01541                 {
01542                                 B_slot[0]= B_alloc[onu]; // DEFINIMOS ANCHO DE BANDA DE SLOT
01543                                 packet->setGrant_IntervalTx(0,B_slot[0]);
01544                 }
01545                 else if((int)par("extractionmethod_StrictPQ0_Centralized1")==1)
01546                 {
01547                                 // BUCLE FOR PARA DEFINIR UN ANCHO DE BANDA DE SLOT PARA CADA COLA
01548                                 for(int b=0; b<(int)par("numqueue"); b++)
01549                                 {
01550                                         B_slot[b] = B_alloc[onu]; // DEFINIMOS EL ANCHO DE BANDA DE SLOT PARA CADA COLA
01551                                         packet->setGrant_IntervalTx(b,B_slot[b]);
01552                                 }
01553                 }
01554                 // ENVIAMOS LOS PAQUETES GATE MEDIANTE EL ENVIO RETARDADO
01555                 sendDelayed(packet, tasa_tx_gate, "mactxOut");
01556                 //ACTUALIZAMOS EL TIEMPO DE CADA LAMBDA SUMANDO EL TIEMPO ACTUAL DE LA LAMBDA QUE SE VACIO ANTES CON EL TIEMPO DE TRANSMISION DE LA ONU
01557                 tiempo_tx_sig[aux]=t_tx+T_tx_onu;
01558         }
01559         delete reportmsg; // BORRAMOS EL PAQUETE REPORT
01560 }


Member Data Documentation

Definition at line 85 of file MAC_OLT.h.

Definition at line 143 of file MAC_OLT.h.

Definition at line 61 of file MAC_OLT.h.

FILE* MAC_OLT::B_alloc_medio [private]

Definition at line 37 of file MAC_OLT.h.

FILE* MAC_OLT::B_alloc_periodico [private]

Definition at line 46 of file MAC_OLT.h.

Definition at line 111 of file MAC_OLT.h.

Definition at line 78 of file MAC_OLT.h.

Definition at line 62 of file MAC_OLT.h.

Definition at line 73 of file MAC_OLT.h.

Definition at line 59 of file MAC_OLT.h.

Definition at line 65 of file MAC_OLT.h.

Definition at line 99 of file MAC_OLT.h.

Definition at line 74 of file MAC_OLT.h.

FILE* MAC_OLT::B_max_PID [private]

Definition at line 38 of file MAC_OLT.h.

Definition at line 86 of file MAC_OLT.h.

Definition at line 87 of file MAC_OLT.h.

Definition at line 110 of file MAC_OLT.h.

Definition at line 128 of file MAC_OLT.h.

Definition at line 58 of file MAC_OLT.h.

FILE* MAC_OLT::B_total [private]

Definition at line 41 of file MAC_OLT.h.

Definition at line 47 of file MAC_OLT.h.

FILE* MAC_OLT::BW_acum [private]

Definition at line 40 of file MAC_OLT.h.

Definition at line 103 of file MAC_OLT.h.

Definition at line 101 of file MAC_OLT.h.

Definition at line 104 of file MAC_OLT.h.

Definition at line 102 of file MAC_OLT.h.

Definition at line 95 of file MAC_OLT.h.

Definition at line 96 of file MAC_OLT.h.

FILE* MAC_OLT::BW_Mbps [private]

Definition at line 39 of file MAC_OLT.h.

Definition at line 107 of file MAC_OLT.h.

Definition at line 108 of file MAC_OLT.h.

vector<vector<vector<double> > > MAC_OLT::cola_vector

Definition at line 100 of file MAC_OLT.h.

Definition at line 127 of file MAC_OLT.h.

Definition at line 124 of file MAC_OLT.h.

Definition at line 126 of file MAC_OLT.h.

Definition at line 125 of file MAC_OLT.h.

Definition at line 144 of file MAC_OLT.h.

Definition at line 117 of file MAC_OLT.h.

Definition at line 114 of file MAC_OLT.h.

Definition at line 145 of file MAC_OLT.h.

Definition at line 97 of file MAC_OLT.h.

FILE* MAC_OLT::controlfich [private]

Definition at line 43 of file MAC_OLT.h.

Definition at line 69 of file MAC_OLT.h.

Definition at line 130 of file MAC_OLT.h.

Definition at line 70 of file MAC_OLT.h.

Definition at line 71 of file MAC_OLT.h.

Definition at line 72 of file MAC_OLT.h.

Definition at line 121 of file MAC_OLT.h.

std::vector<Analysis> MAC_OLT::desviacionBwMax [private]

Definition at line 49 of file MAC_OLT.h.

Definition at line 113 of file MAC_OLT.h.

Definition at line 93 of file MAC_OLT.h.

Definition at line 118 of file MAC_OLT.h.

Definition at line 98 of file MAC_OLT.h.

Definition at line 138 of file MAC_OLT.h.

Definition at line 119 of file MAC_OLT.h.

Definition at line 44 of file MAC_OLT.h.

Definition at line 45 of file MAC_OLT.h.

Definition at line 140 of file MAC_OLT.h.

Definition at line 139 of file MAC_OLT.h.

Definition at line 88 of file MAC_OLT.h.

Definition at line 75 of file MAC_OLT.h.

Definition at line 106 of file MAC_OLT.h.

Definition at line 105 of file MAC_OLT.h.

Definition at line 77 of file MAC_OLT.h.

Definition at line 141 of file MAC_OLT.h.

Definition at line 91 of file MAC_OLT.h.

Definition at line 81 of file MAC_OLT.h.

Definition at line 83 of file MAC_OLT.h.

Definition at line 54 of file MAC_OLT.h.

Definition at line 131 of file MAC_OLT.h.

Definition at line 146 of file MAC_OLT.h.

Definition at line 147 of file MAC_OLT.h.

Definition at line 92 of file MAC_OLT.h.

Definition at line 122 of file MAC_OLT.h.

FILE* MAC_OLT::pid_medio_file [private]

Definition at line 42 of file MAC_OLT.h.

Definition at line 123 of file MAC_OLT.h.

Definition at line 142 of file MAC_OLT.h.

Definition at line 109 of file MAC_OLT.h.

Definition at line 134 of file MAC_OLT.h.

Definition at line 135 of file MAC_OLT.h.

Definition at line 133 of file MAC_OLT.h.

Definition at line 136 of file MAC_OLT.h.

Definition at line 80 of file MAC_OLT.h.

Definition at line 94 of file MAC_OLT.h.

Definition at line 137 of file MAC_OLT.h.

Definition at line 79 of file MAC_OLT.h.

Definition at line 57 of file MAC_OLT.h.

Definition at line 56 of file MAC_OLT.h.

Definition at line 68 of file MAC_OLT.h.

Definition at line 63 of file MAC_OLT.h.

Definition at line 64 of file MAC_OLT.h.

Definition at line 55 of file MAC_OLT.h.

Definition at line 89 of file MAC_OLT.h.

Definition at line 90 of file MAC_OLT.h.

Definition at line 67 of file MAC_OLT.h.

Definition at line 84 of file MAC_OLT.h.

Definition at line 66 of file MAC_OLT.h.

Definition at line 60 of file MAC_OLT.h.

Definition at line 115 of file MAC_OLT.h.

Definition at line 116 of file MAC_OLT.h.

Definition at line 120 of file MAC_OLT.h.

vector<vector<vector<vector<double> > > > MAC_OLT::vector_ventana

Definition at line 132 of file MAC_OLT.h.

Definition at line 76 of file MAC_OLT.h.

Definition at line 82 of file MAC_OLT.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