BasePSApp Class Reference

#include <BasePSApp.h>

Inheritance diagram for BasePSApp:

List of all members.

Protected Types
typedef std::vector < subscriptionItem >::iterator	subscrIter
	The iterator for the Subscriptions' Table.
Protected Member Functions
virtual void	initialize (int stage)
virtual int	numInitStages () const
virtual void	handleMessage (cMessage *msg)
virtual void	finish ()
virtual bool	cancelInformationItem (int type)
virtual InformationItem *	returnMyRandII ()
virtual InformationItem *	returnRandII ()
virtual void	publishMetaDataPacket (subscriptionItem subItem)
Protected Attributes
long	seqNum
	The sequence number of each transmitted packet.
long	packetsSent
	Statistic for the packets sent.
long	packetsReceived
	Statistic for packets received.
cOutVector	eedVector
	End-to-end delay vector.
cStdDev	eedStats
	End-to-end delay statistics.
std::vector< subscriptionItem >	subscriptions
	The module's Subscriptions' Table.
IITable *	iit
	Pointer to the Information Item Table module.
cPar *	datarate
	The bitrate of every publication stream.

---

Detailed Description

The basic definition of the application used for publishing and subscribing in the publish-subscribe network. Because the is a high degree of overlap in the functionality of the publish and subscribe applications, this class is used to define some common operations and parameters.

The subscriptions of each applications are stored in an vector of subscription items. These items are represented by a complex struct containing the Information Item details, along with it's meta data. The meta data structure is used later only by publishers, but future implementation might include Subscriber usage as well.

---

Member Typedef Documentation

typedef std::vector<subscriptionItem>::iterator BasePSApp::subscrIter [protected]

The iterator for the Subscriptions' Table.

---

Member Function Documentation

bool BasePSApp::cancelInformationItem

(

int

type

)

[protected, virtual]

Remove an Information Item from the relevant table of the module.

                                              {

        //Choose randomly a subscription, according to its popularity
        InformationItem *II=returnMyRandII();

        if(II==NULL) {
                ev << "Tried to delete Information Item, but subscription list is empty!"  << endl;
        }
        else {

                subscriptionItem subitem;
                subitem.ii=II;
                subscrIter iter=find(subscriptions.begin(),subscriptions.end(),subitem);

                //Check if removing publication
                if(type==UNPUBLISH_INFO) {
                        if(iit->removePubElement(II,this->getParentModule())) {
                                subscriptions.erase(iter);
                                return true;
                        }
                }
                //Check if removing subscription
                else if(type==UNSUBSCRIBE_INFO) {
                        if(iit->removeSubElement(II,this->getParentModule())) {
                                subscriptions.erase(iter);
                                return true;
                        }
                }
                //If non of the above then we have an error
                else {
                        ev << this->getFullName() << ": Wrong command was given while trying to remove Information Item!" << endl;
                }
        }

        return false;
}

void BasePSApp::finish

(

)

[protected, virtual]

Called with finish() function is called for the whole simulation.

Reimplemented from cComponent.

Reimplemented in PEtherApp, and SEtherApp.

{
        //Record Scalars
    recordScalar("packets sent", packetsSent);
    recordScalar("packets rcvd", packetsReceived);
    recordScalar("end-to-end delay mean", eedStats.getMean());
    recordScalar("end-to-end delay stddev", eedStats.getStddev());
    recordScalar("end-to-end delay min", eedStats.getMin());
    recordScalar("end-to-end delay max", eedStats.getMax());

    //Clear the subscriptions table;
    subscriptions.clear();
}

void BasePSApp::handleMessage

(

cMessage *

msg

)

[protected, virtual]

Handles a message received by this module. In this case it does nothing.

Reimplemented from cSimpleModule.

Reimplemented in PEtherApp, and SEtherApp.

{
        //Nothing to do... deleting message
        delete msg;
}

void BasePSApp::initialize

(

int

stage

)

[protected, virtual]

Initialized the parameters of the class, like the statistic variables and the pointer to the Information Item Table.

Reimplemented from cComponent.

Reimplemented in PEtherApp, and SEtherApp.

{
        if(stage==1) {
                // parameters
                seqNum = 0;
                datarate= &par("datarate");

                // statistics
                packetsSent = packetsReceived = 0;
                eedVector.setName("end-to-end delay");
                eedStats.setName("end-to-end delay");
                WATCH_VECTOR(subscriptions);
                WATCH(packetsSent);
                WATCH(packetsReceived);
                WATCH(seqNum);
        }
        //The topology manager and IITable have been initialized at stage 2 so we access it now
        if(stage==3)
        {
                //Get access to the Information Access tablet to bypass the TV need
                iit=IITableAccess<IITable>("iiTable").get();
        }
}

virtual int BasePSApp::numInitStages

(

)

const [inline, protected, virtual]

Returns the number of initialization stages.

Reimplemented from cComponent.

Reimplemented in PEtherApp, and SEtherApp.

{return 4;};

void BasePSApp::publishMetaDataPacket

(

subscriptionItem

subItem

)

[protected, virtual]

                                                              {
        //Increase sequence number
        seqNum++;

        // Generate Message name
        char msgname[30];
        sprintf(msgname, "MetaDataMsg-%d-%ld", getId(), seqNum);
        ev << "Generating packet `" << msgname << "'\n";

        //Create Message
        MetaDataPacket *metadatapacket = new MetaDataPacket(msgname);

        //Set packet size
        metadatapacket->setByteLength(/*type*/ 1  + /*ID*/ 1 + /*scopeLen*/ (PURSUIT_ID_LEN)*(subItem.ii->scopeSize()) + /*QoSList*/ (subItem.qos.size())*(QoS_ITEM_SIZE));

        //Set Message Parameters
        metadatapacket->setID(*subItem.ii);
        metadatapacket->setType(PUB_METADATA);
        metadatapacket->setItemNum(subItem.qos.size());
        metadatapacket->setIIStatus(subItem.qos);

        //Send the message to the Topology Manager
        this->sendDirect(metadatapacket,simulation.getModuleByPath("tm"),simulation.getModuleByPath("tm")->findGate("TMin"));
}

InformationItem * BasePSApp::returnMyRandII

(

)

[protected, virtual]

Is used by nodes to choose an Information Item, from the subscriptions table. The choices are made according to the popularity of each subscriptions.

                                           {

        double propArray[subscriptions.size()];
        InformationItem *II=NULL;
        double sum=0;

        //Define iterator
        subscrIter iter;

        //Check all subscriptions made in the IITable and their popularity
        //Afterwards create a matrix defining the popularity boundaries
        for(unsigned int i=0;i<subscriptions.size();i++) {
                propArray[i]=sum+subscriptions[i].ii->getPop();
                sum+=subscriptions[i].ii->getPop();
        }

        //Randomly choose one Information Item to return
        double choice=dblrand()*sum;

        //Find out the choice made, between all existing Information Items
        for(unsigned int i=0;i<subscriptions.size();i++) {
                if(choice<propArray[i]) {
                        II=subscriptions[i].ii;
                        return II;
                }
                i++;
        }

        return II;
}

InformationItem * BasePSApp::returnRandII

(

)

[protected, virtual]

Is used by publishers to choose an Information Item, requested by a subscription from this node. This way subscriptions can be met and increase their number of publishers and subscribers per Information Item.

                                         {

        double propArray[iit->getNumOfRendezvous()];
        InformationItem *II=NULL;
        unsigned int i=0;
        double sum=0;

        //Define iterator
        IITable::RVVectorIt iter;

        //Check all subscriptions made in the IITable and their popularity
        //Afterwards create a matrix defining the popularity boundaries
        for(iter=iit->rendezvous.begin();iter!=iit->rendezvous.end();iter++) {
                propArray[i]=sum+iter->first->getPop();
                sum+=iter->first->getPop();
                i++;
        }

        //Randomly choose one Information Item to return
        double choice=dblrand()*sum;

        //Reinitialize array counter
        i=0;

        //Find out the choice made, between all existing Information Items
        for(iter=iit->rendezvous.begin();iter!=iit->rendezvous.end();iter++) {
                if(choice<propArray[i]) {
                        II=iter->first;
                        return II;
                }
                i++;
        }

        return II;
}

---

Member Data Documentation

cPar* BasePSApp::datarate [protected]

The bitrate of every publication stream.

cStdDev BasePSApp::eedStats [protected]

End-to-end delay statistics.

cOutVector BasePSApp::eedVector [protected]

End-to-end delay vector.

IITable* BasePSApp::iit [protected]

Pointer to the Information Item Table module.

long BasePSApp::packetsReceived [protected]

Statistic for packets received.

long BasePSApp::packetsSent [protected]

Statistic for the packets sent.

long BasePSApp::seqNum [protected]

The sequence number of each transmitted packet.

std::vector<subscriptionItem> BasePSApp::subscriptions [protected]

The module's Subscriptions' Table.

---

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

• BasePSApp.h
• BasePSApp.cc