MessageObserver Class Reference

#include <MessageObserver.h>

List of all members.

Classes

struct  MulticastGroup

Public Member Functions

 MessageObserver ()
 ~MessageObserver ()
void initialize ()
void finish ()
void handleMessage (cMessage *msg)
void joinedGroup (int moduleId, OverlayKey groupId)
 Adds one to node count for group.
void leftGroup (int moduleId, OverlayKey groupId)
 Subtracts one from node count for group.
void sentMessage (ALMTestTracedMessage *msg)
 Counts n - 1 messages pending reception, where n is the size of the group to which the message is sent.
void receivedMessage (ALMTestTracedMessage *msg)
 Counts one received message for group.

Private Types

typedef std::pair< int,
OverlayKey
NodeGroupPair
typedef std::pair< int, long > NodeMessagePair

Private Attributes

std::map< OverlayKey,
MulticastGroup
groups
std::map< NodeGroupPair,
simtime_t > 
joinedAt
std::map< NodeMessagePair,
simtime_t > 
receivedAt
cMessage * gcTimer
double gcInterval
double cacheMaxAge

Friends

std::ostream & operator<< (std::ostream &os, MessageObserver::MulticastGroup const &mg)
std::ostream & operator<< (std::ostream &os, MessageObserver::NodeGroupPair const &ngp)

Detailed Description

Definition at line 33 of file MessageObserver.h.


Member Typedef Documentation

typedef std::pair<int, OverlayKey> MessageObserver::NodeGroupPair [private]

Definition at line 86 of file MessageObserver.h.

typedef std::pair<int, long> MessageObserver::NodeMessagePair [private]

Definition at line 88 of file MessageObserver.h.


Constructor & Destructor Documentation

MessageObserver::MessageObserver (  ) 

Definition at line 30 of file MessageObserver.cc.

00030                                  {
00031     gcTimer = new cMessage("garbage_collection");
00032     gcInterval = 1.0;
00033     cacheMaxAge = 10.0;
00034 }

MessageObserver::~MessageObserver (  ) 

Definition at line 36 of file MessageObserver.cc.

00036                                   {
00037     cancelAndDelete(gcTimer);
00038 }


Member Function Documentation

void MessageObserver::finish (  ) 

Definition at line 52 of file MessageObserver.cc.

00052                              {
00053     uint64_t totalSent = 0;
00054     uint64_t totalReceived = 0;
00055     for (std::map<OverlayKey, MulticastGroup>::iterator i = groups.begin(); i != groups.end(); ++i) {
00056         std::stringstream message;
00057         message << "MessageObserver: Group " << i->first;
00058         std::string name;
00059 
00060         name = message.str() + " Sent Messages";
00061         recordScalar(name.c_str(), (double)i->second.sent);
00062 
00063         name = message.str() + " Received Messages";
00064         recordScalar(name.c_str(), (double)i->second.received);
00065 
00066         name = message.str() + " Delivered Percentage";
00067         recordScalar(name.c_str(), ((double)i->second.received * 100.0) / (double)i->second.sent);
00068 
00069         totalSent += i->second.sent;
00070         totalReceived += i->second.received;
00071     }
00072 
00073     recordScalar("MessageObserver: Total Sent Messages", (double)totalSent);
00074     recordScalar("MessageObserver: Total Received Messages", (double)totalReceived);
00075     recordScalar("MessageObserver: Total Delivered Percentage", ((double)totalReceived * 100.0) / (double)totalSent);
00076 }

void MessageObserver::handleMessage ( cMessage *  msg  ) 

Definition at line 78 of file MessageObserver.cc.

00078                                                  {
00079     if (msg == gcTimer) {
00080         simtime_t now = OPP::simTime();
00081         std::map<NodeMessagePair, simtime_t>::iterator i, iPrev;
00082         i = receivedAt.begin();
00083         while (i != receivedAt.end()) {
00084             if (now - i->second >= cacheMaxAge) {
00085                 iPrev = i;
00086                 ++i;
00087                 receivedAt.erase(iPrev);
00088             }
00089             else {
00090                 ++i;
00091             }
00092         }
00093         scheduleAt(OPP::simTime() + gcInterval, gcTimer);
00094     }
00095 }

void MessageObserver::initialize (  ) 

Definition at line 40 of file MessageObserver.cc.

00040                                  {
00041     WATCH_MAP(groups);
00042     WATCH_MAP(joinedAt);
00043     WATCH_MAP(receivedAt);
00044     
00045     gcInterval = par("gcInterval");
00046     cacheMaxAge = par("cacheMaxAge");
00047 
00048     if (gcInterval > 0.0)
00049         scheduleAt(OPP::simTime() + gcInterval, gcTimer);
00050 }

void MessageObserver::joinedGroup ( int  moduleId,
OverlayKey  groupId 
)

Adds one to node count for group.

Definition at line 100 of file MessageObserver.cc.

Referenced by ALMTest::joinGroup().

00100                                                                   {
00101     groups[groupId].size += 1;
00102     joinedAt[NodeGroupPair(moduleId, groupId)] = OPP::simTime();
00103 }

void MessageObserver::leftGroup ( int  moduleId,
OverlayKey  groupId 
)

Subtracts one from node count for group.

Definition at line 108 of file MessageObserver.cc.

Referenced by ALMTest::leaveGroup().

00108                                                                 {
00109     std::map<OverlayKey, MulticastGroup>::iterator iter = groups.find(groupId);
00110     if (iter == groups.end()) {
00111         EV << "Warning: MessageObserver asked to remove node from nonexistent group " << groupId.toString();
00112     }
00113     else if (iter->second.size == 0) {
00114         EV << "Warning: MessageObserver asked to remove node from empty group " << groupId.toString();
00115     }
00116     else {
00117         iter->second.size -= 1;
00118     }
00119     joinedAt.erase(NodeGroupPair(moduleId, groupId));
00120 }

void MessageObserver::receivedMessage ( ALMTestTracedMessage *  msg  ) 

Counts one received message for group.

Definition at line 147 of file MessageObserver.cc.

Referenced by ALMTest::handleMCast().

00147                                                                {
00148     if (msg == NULL) {
00149         error("%s called with null message.", __PRETTY_FUNCTION__);
00150     }
00151 
00152     std::map<OverlayKey, MulticastGroup>::iterator iGroup;
00153     iGroup = groups.find(msg->getGroupId());
00154     if (iGroup == groups.end()) {
00155         EV << "Warning: MessageObserver notified of received message for nonexistent group " << msg->getGroupId().toString();
00156     }
00157     else if (iGroup->second.size == 0) {
00158         EV << "Warning: MessageObserver notified of received message for empty group " << msg->getGroupId().toString();
00159     }
00160     else if (msg->getSenderId() != msg->getReceiverId()) {
00161 
00162         // Only count if message was received after joining
00163         std::map<NodeGroupPair, simtime_t>::iterator iJoinInfo;
00164         iJoinInfo = joinedAt.find(NodeGroupPair(msg->getReceiverId(), msg->getGroupId()));
00165 
00166         if (iJoinInfo != joinedAt.end() && iJoinInfo->second < msg->getTimestamp()) {
00167             
00168             // Check if this message has not already been received
00169             NodeMessagePair nmp = NodeMessagePair(msg->getReceiverId(), msg->getMcastId());
00170             if (receivedAt.find(nmp) == receivedAt.end()) {
00171                 iGroup->second.received += 1;
00172                 receivedAt[nmp] = msg->getTimestamp();
00173             }
00174         }
00175     }
00176     else {
00177         // TODO: Count looped messages here?
00178     }
00179 }

void MessageObserver::sentMessage ( ALMTestTracedMessage *  msg  ) 

Counts n - 1 messages pending reception, where n is the size of the group to which the message is sent.

Counts n - 1 messages pending reception, where n is the size of the group.

Definition at line 126 of file MessageObserver.cc.

Referenced by ALMTest::sendDataToGroup().

00126                                                            {
00127     if (msg == NULL) {
00128         error("%s called with null message.", __PRETTY_FUNCTION__);
00129     }
00130 
00131     std::map<OverlayKey, MulticastGroup>::iterator iter;
00132     iter = groups.find(msg->getGroupId());
00133     if (iter == groups.end()) {
00134         EV << "Warning: MessageObserver notified of sent message for nonexistent group " << msg->getGroupId().toString();
00135     }
00136     else if (iter->second.size == 0) {
00137         EV << "Warning: MessageObserver notified of sent message for empty group " << msg->getGroupId().toString();
00138     }
00139     else {
00140         iter->second.sent += iter->second.size - 1;
00141     }
00142 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
MessageObserver::NodeGroupPair const &  ngp 
) [friend]

Definition at line 186 of file MessageObserver.cc.

00186                                                                                   {
00187     cModule* module = OPP::cSimulation::getActiveSimulation()->getModule(ngp.first);
00188     return os << "(" << (module != NULL ? module->getFullPath() : "Deleted node")
00189         << ", " << ngp.second << ")";
00190 }

std::ostream& operator<< ( std::ostream &  os,
MessageObserver::MulticastGroup const &  mg 
) [friend]

Definition at line 181 of file MessageObserver.cc.

00181                                                                                   {
00182     return os << "Nodes: " << mg.size << "; Messages Sent: " << mg.sent
00183         << ", Received: " << mg.received << ", Dropped: " << (mg.sent - mg.received);
00184 }


Member Data Documentation

double MessageObserver::cacheMaxAge [private]

Definition at line 106 of file MessageObserver.h.

Referenced by handleMessage(), initialize(), and MessageObserver().

double MessageObserver::gcInterval [private]

Definition at line 103 of file MessageObserver.h.

Referenced by handleMessage(), initialize(), and MessageObserver().

cMessage* MessageObserver::gcTimer [private]

Definition at line 100 of file MessageObserver.h.

Referenced by handleMessage(), initialize(), MessageObserver(), and ~MessageObserver().

std::map<NodeGroupPair, simtime_t> MessageObserver::joinedAt [private]

Definition at line 94 of file MessageObserver.h.

Referenced by initialize(), joinedGroup(), leftGroup(), and receivedMessage().

std::map<NodeMessagePair, simtime_t> MessageObserver::receivedAt [private]

Definition at line 97 of file MessageObserver.h.

Referenced by handleMessage(), initialize(), and receivedMessage().


The documentation for this class was generated from the following files:
Generated on Wed May 26 16:21:18 2010 for OverSim by  doxygen 1.6.3