// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see http://www.gnu.org/licenses/.
//
#include "AEBase.h"
Define_Module(AEBase);
const char* PAR_AVGBW = "averageBandwidth";
const char* PAR_AVGSDUBW = "averageSDUBandwidth";
const char* PAR_PEAKBWDUR = "peakBandwidthDuration";
const char* PAR_PEAKSDUBWDUR = "peakSDUBandwidthDuration";
const char* PAR_BURSTPERIOD = "burstPeriod";
const char* PAR_BURSTDURATION = "burstDuration";
const char* PAR_UNDETECTBITERR = "undetectedBitErr";
const char* PAR_MAXSDUSIZE = "maxSDUsize";
const char* PAR_PARTIALDELIVER = "partialDelivery";
const char* PAR_INCOMPLETEDELIVER = "incompleteDelivery";
const char* PAR_FORCEORDER = "forceOrder";
const char* PAR_MAXALLOWGAP = "maxAllowGap";
const char* PAR_DELAY = "delay";
const char* PAR_JITTER = "jitter";
const char* PAR_COSTTIME = "costTime";
const char* PAR_COSTBITS = "costBits";
const APNamingInfo& AEBase::getApni() const {
return apni;
}
void AEBase::setApni(const APNamingInfo& apni) {
this->apni = apni;
}
const Flows& AEBase::getFlows() const {
return flows;
}
void AEBase::setFlows(const Flows& flows) {
this->flows = flows;
}
const std::string& AEBase::getSrcAeInstance() const {
return srcAeInstance;
}
void AEBase::setSrcAeInstance(const std::string& srcAeInstance) {
this->srcAeInstance = srcAeInstance;
}
const std::string& AEBase::getSrcAeName() const {
return srcAeName;
}
void AEBase::setSrcAeName(const std::string& srcAeName) {
this->srcAeName = srcAeName;
}
const std::string& AEBase::getSrcApInstance() const {
return srcApInstance;
}
void AEBase::setSrcApInstance(const std::string& srcApInstance) {
this->srcApInstance = srcApInstance;
}
const std::string& AEBase::getSrcApName() const {
return srcApName;
}
void AEBase::setSrcApName(const std::string& srcApName) {
this->srcApName = srcApName;
}
void AEBase::initNamingInfo() {
//Source info
srcApName = this->getParentModule()->par(PAR_APNAME).stdstringValue();
srcApInstance = this->getParentModule()->par(PAR_APINSTANCE).stdstringValue();
srcAeName = this->par(PAR_AENAME).stdstringValue();
srcAeInstance = this->par(PAR_AEINSTANCE).stdstringValue();
apni = APNamingInfo(APN(this->srcApName), this->srcApInstance,
this->srcAeName, this->srcAeInstance);
}
void AEBase::initialize()
{
initNamingInfo();
initQoSRequiremets();
}
const QosCube& AEBase::getQoSRequirements() const {
return QoSRequirements;
}
void AEBase::setQoSRequirements(const QosCube& qoSRequirements) {
QoSRequirements = qoSRequirements;
}
void AEBase::initQoSRequiremets() {
//Check whether module has all QoS parameters
if (! (hasPar(PAR_AVGBW) &&
hasPar(PAR_AVGSDUBW) &&
hasPar(PAR_PEAKBWDUR) &&
hasPar(PAR_PEAKSDUBWDUR) &&
hasPar(PAR_BURSTPERIOD) &&
hasPar(PAR_BURSTDURATION) &&
hasPar(PAR_UNDETECTBITERR) &&
hasPar(PAR_MAXSDUSIZE) &&
hasPar(PAR_PARTIALDELIVER) &&
hasPar(PAR_INCOMPLETEDELIVER) &&
hasPar(PAR_FORCEORDER) &&
hasPar(PAR_MAXALLOWGAP) &&
hasPar(PAR_DELAY) &&
hasPar(PAR_JITTER) &&
hasPar(PAR_COSTTIME) &&
hasPar(PAR_COSTBITS)
)
) {
std::stringstream ss;
ss << "Module " << this->getFullName() << " is not derived from AEBase. It misses some important QoS parameters!";
error(ss.str().c_str());
}
//Create QoS cube according to parameters
QosCube cube;
int avgBand = VAL_QOSPARAMDONOTCARE; //Average bandwidth (measured at the application in bits/sec)
int avgSDUBand = VAL_QOSPARAMDONOTCARE; //Average SDU bandwidth (measured in SDUs/sec)
int peakBandDuration = VAL_QOSPARAMDONOTCARE; //Peak bandwidth-duration (measured in bits/sec);
int peakSDUBandDuration = VAL_QOSPARAMDONOTCARE; //Peak SDU bandwidth-duration (measured in SDUs/sec);
int burstPeriod = VAL_QOSPARAMDONOTCARE; //Burst period measured in useconds
int burstDuration = VAL_QOSPARAMDONOTCARE; //Burst duration, measured in usecs fraction of Burst Period
int undetectedBitErr = VAL_QOSPARAMDONOTCARE; //Undetected bit error rate measured as a probability
int maxSDUsize = VAL_QOSPARAMDONOTCARE; //MaxSDUSize measured in bytes
bool partDeliv = VAL_QOSPARAMDEFBOOL; //Partial Delivery - Can SDUs be delivered in pieces rather than all at once?
bool incompleteDeliv = VAL_QOSPARAMDEFBOOL; //Incomplete Delivery - Can SDUs with missing pieces be delivered?
bool forceOrder = VAL_QOSPARAMDEFBOOL; //Must SDUs be delivered in order?
unsigned int maxAllowGap = VAL_QOSPARAMDONOTCARE; //Max allowable gap in SDUs, (a gap of N SDUs is considered the same as all SDUs delivered, i.e. a gap of N is a "don't care.")
int delay = VAL_QOSPARAMDONOTCARE; //Delay in usecs
int jitter = VAL_QOSPARAMDONOTCARE; //Jitter in usecs2
int costtime = VAL_QOSPARAMDONOTCARE; //measured in $/ms
int costbits = VAL_QOSPARAMDONOTCARE; //measured in $/Mb
avgBand = par(PAR_AVGBW);
if (avgBand < 0)
avgBand = VAL_QOSPARAMDONOTCARE;
avgSDUBand = par(PAR_AVGSDUBW);
if (avgSDUBand < 0)
avgSDUBand = VAL_QOSPARAMDONOTCARE;
peakBandDuration = par(PAR_PEAKBWDUR);
if (peakBandDuration < 0)
peakBandDuration = VAL_QOSPARAMDONOTCARE;
peakSDUBandDuration = par(PAR_PEAKSDUBWDUR);
if (peakSDUBandDuration < 0)
peakSDUBandDuration = VAL_QOSPARAMDONOTCARE;
burstPeriod = par(PAR_BURSTPERIOD);
if (burstPeriod < 0)
burstPeriod = VAL_QOSPARAMDONOTCARE;
burstDuration = par(PAR_BURSTDURATION);
if (burstDuration < 0)
burstDuration = VAL_QOSPARAMDONOTCARE;
undetectedBitErr = par(PAR_UNDETECTBITERR);
if (undetectedBitErr < 0 || undetectedBitErr > 1 )
undetectedBitErr = VAL_QOSPARAMDONOTCARE;
maxSDUsize = par(PAR_MAXSDUSIZE);
if (maxSDUsize < 0)
maxSDUsize = VAL_QOSPARAMDONOTCARE;
partDeliv = par(PAR_PARTIALDELIVER);
incompleteDeliv = par(PAR_INCOMPLETEDELIVER);
forceOrder = par(PAR_FORCEORDER);
maxAllowGap = par(PAR_MAXALLOWGAP);
if (maxAllowGap < 0)
maxAllowGap = VAL_QOSPARAMDONOTCARE;
delay = par(PAR_DELAY);
if (delay < 0)
delay = VAL_QOSPARAMDONOTCARE;
jitter = par(PAR_JITTER);
if (jitter < 0)
jitter = VAL_QOSPARAMDONOTCARE;
costtime = par(PAR_COSTTIME);
if (costtime < 0)
costtime = VAL_QOSPARAMDONOTCARE;
costbits = par(PAR_COSTBITS);
if (costbits < 0)
costbits = VAL_QOSPARAMDONOTCARE;
cube.setQosId(0);
cube.setAvgBand(avgBand);
cube.setAvgSduBand(avgSDUBand);
cube.setPeakBandDuration(peakBandDuration);
cube.setPeakSduBandDuration(peakSDUBandDuration);
cube.setBurstPeriod(burstPeriod);
cube.setBurstDuration(burstDuration);
cube.setUndetectedBitErr(undetectedBitErr);
cube.setMaxSduSize(maxSDUsize);
cube.setPartialDelivery(partDeliv);
cube.setIncompleteDelivery(incompleteDeliv);
cube.setForceOrder(forceOrder);
cube.setMaxAllowGap(maxAllowGap);
cube.setDelay(delay);
cube.setJitter(jitter);
cube.setCostBits(costbits);
cube.setCostTime(costtime);
this->setQoSRequirements(cube);
//EV << "QQQQQQ\n" << cube << "\n\nXXXX\n" << this->getQoSRequirements();
}
void AEBase::handleMessage(cMessage *msg)
{
// TODO - Generated method body
}
void AEBase::insertFlow(Flow& flow) {
flows.push_back(flow);
}
bool AEBase::hasFlow(const Flow* flow) {
for (TFlowsIter it = flows.begin(); it != flows.end(); ++it) {
if (*it == *flow)
return true;
}
return false;
}