LifetimeChurn Class Reference

#include <LifetimeChurn.h>

Inheritance diagram for LifetimeChurn:

ChurnGenerator List of all members.

Detailed Description

Lifetime based churn generating class.


Public Member Functions

void handleMessage (cMessage *msg)
void initializeChurn ()
 ~LifetimeChurn ()

Protected Member Functions

void updateDisplayString ()
void createNode (double lifetime, bool initialize)
void deleteNode (TransportAddress &addr)
double distributionFunction ()
void scheduleCreateNodeAt (double creationTime, double lifetime)

Private Attributes

GlobalStatisticsglobalStatistics
double initialMean
 mean of update interval during initalization phase
double initialDeviation
 deviation of update interval during initalization phase
double targetMean
 mean of update interval after initalization phase
std::string lifetimeDistName
 name of the distribution function
double lifetimeMean
 mean node lifetime
double lifetimeDistPar1
 distribution function parameter
cMessage * initFinishedTimer
 timer to signal end of init phase
double lastCreate
double lastDelete


Constructor & Destructor Documentation

LifetimeChurn::~LifetimeChurn (  ) 

00179 {
00180     cancelAndDelete(initFinishedTimer);
00181 }


Member Function Documentation

void LifetimeChurn::handleMessage ( cMessage *  msg  )  [virtual]

Implements ChurnGenerator.

00087 {
00088     if (!msg->isSelfMessage()) {
00089         delete msg;
00090         return;
00091     }
00092 
00093     // init phase finished
00094     if (msg == initFinishedTimer) {
00095         underlayConfigurator->initFinished();
00096         return;
00097     }
00098 
00099     ChurnMessage* churnMsg = check_and_cast<ChurnMessage*>(msg);
00100     
00101     if (churnMsg->getCreateNode() == true) {
00102         createNode(churnMsg->getLifetime(), false);
00103     } else {
00104         deleteNode(churnMsg->getAddr());
00105     }
00106     
00107     delete msg;
00108 }

void LifetimeChurn::initializeChurn (  )  [virtual]

Implements ChurnGenerator.

00030 {
00031     Enter_Method_Silent();
00032 
00033     initialMean = par("initialMobilityDelay");
00034     initialDeviation = initialMean / 3;
00035     lifetimeMean = par("lifetimeMean");
00036     lifetimeDistName = std::string(par("lifetimeDistName"));
00037     lifetimeDistPar1 = par("lifetimeDistPar1");
00038     
00039     if (lifetimeDistPar1 != 1) {
00040         opp_error("LifetimeChurn currently only works with "
00041           "lifetimeDistPar1=1");
00042     }
00043 
00044     WATCH(lifetimeMean);
00045 
00046     globalStatistics = GlobalStatisticsAccess().get();
00047 
00048     lastCreate = lastDelete = simulation.simTime();
00049 
00050     double initFinishedTime = initialMean *
00051         (targetOverlayTerminalNum - initialOverlayTerminalNum);
00052 
00053     //underlayConfigurator->firstNodeId = createRandomNode(true)->getModuleID();
00054 
00055     // create initial overlay nodes
00056     for (int i = 0; i < initialOverlayTerminalNum; i++) {
00057 
00058         createNode(initFinishedTime + distributionFunction(), true);
00059 
00060         // create same number of currently dead nodes
00061         scheduleCreateNodeAt(initFinishedTime +
00062                              distributionFunction(),
00063                              distributionFunction());
00064     }
00065 
00066     // create the remaining nodes in bootstrap phase
00067     for (int i = 0; i < (int)par("targetOverlayTerminalNum") -
00068              initialOverlayTerminalNum; i++) {
00069 
00070         scheduleCreateNodeAt(truncnormal(initialMean*i, initialDeviation),
00071                              initFinishedTime +
00072                              distributionFunction() -
00073                              truncnormal(initialMean*i, initialDeviation));
00074 
00075         // create same number of currently dead nodes
00076         scheduleCreateNodeAt(initFinishedTime +
00077                              distributionFunction(),
00078                              distributionFunction());
00079     }
00080 
00081     initFinishedTimer = new cMessage("initFinishedTimer");
00082 
00083     scheduleAt(initFinishedTime, initFinishedTimer);
00084 }

void LifetimeChurn::updateDisplayString (  )  [protected, virtual]

Implements ChurnGenerator.

00172 {
00173     char buf[80];
00174     sprintf(buf, "lifetime churn");
00175     displayString().setTagArg("t", 0, buf);
00176 }

void LifetimeChurn::createNode ( double  lifetime,
bool  initialize 
) [protected]

00111 {
00112     
00113 
00114     ChurnMessage* churnMsg = new ChurnMessage("DeleteNode");
00115     churnMsg->setAddr(*underlayConfigurator->createNode(type, initialize));
00116     churnMsg->setCreateNode(false);
00117     scheduleAt(max(simulation.simTime(), simulation.simTime()
00118                    + lifetime - underlayConfigurator->getGracefulLeaveDelay()),
00119                churnMsg);
00120 
00121     RECORD_STATS(globalStatistics->recordOutVector(
00122                       "BaseOverlay: Session Time", lifetime));
00123     RECORD_STATS(globalStatistics->recordOutVector(
00124                      "BaseOverlay: Time between creates",
00125                      simulation.simTime() - lastCreate));
00126 
00127     lastCreate = simulation.simTime();
00128 }

void LifetimeChurn::deleteNode ( TransportAddress addr  )  [protected]

00131 {
00132     underlayConfigurator->preKillNode(NodeType(), &addr);
00133 
00134     scheduleCreateNodeAt(simulation.simTime()
00135                          + distributionFunction(), distributionFunction());
00136 
00137     RECORD_STATS(globalStatistics->recordOutVector(
00138                      "BaseOverlay: Time between deletes", 
00139                      simulation.simTime() - lastDelete));
00140 
00141     lastDelete = simulation.simTime();
00142 }

double LifetimeChurn::distributionFunction (  )  [protected]

00153 {
00154     double par;
00155 
00156     if (lifetimeDistName == "weibull") {
00157         par = lifetimeMean / tgamma(1 + (1/lifetimeDistPar1));
00158         return weibull(par, lifetimeDistPar1);
00159     } else if (lifetimeDistName == "pareto_shifted") {
00160         par = lifetimeMean * (lifetimeDistPar1-1) / lifetimeDistPar1;
00161         return pareto_shifted(lifetimeDistPar1, par, 0);
00162     } else {
00163         opp_error("LifetimeChurn::distribution function: Invalid value "
00164                   "for parameter lifetimeDistName!");
00165     }
00166 
00167     return 0;
00168 }

void LifetimeChurn::scheduleCreateNodeAt ( double  creationTime,
double  lifetime 
) [protected]

00145 {
00146     ChurnMessage* churnMsg = new ChurnMessage("CreateNode");
00147     churnMsg->setCreateNode(true);
00148     churnMsg->setLifetime(lifetime);
00149     scheduleAt(creationTime, churnMsg);
00150 }


Member Data Documentation

GlobalStatistics* LifetimeChurn::globalStatistics [private]

double LifetimeChurn::initialMean [private]

mean of update interval during initalization phase

double LifetimeChurn::initialDeviation [private]

deviation of update interval during initalization phase

double LifetimeChurn::targetMean [private]

mean of update interval after initalization phase

std::string LifetimeChurn::lifetimeDistName [private]

name of the distribution function

double LifetimeChurn::lifetimeMean [private]

mean node lifetime

double LifetimeChurn::lifetimeDistPar1 [private]

distribution function parameter

cMessage* LifetimeChurn::initFinishedTimer [private]

timer to signal end of init phase

double LifetimeChurn::lastCreate [private]

double LifetimeChurn::lastDelete [private]


The documentation for this class was generated from the following files:
Generated on Wed Sep 26 12:13:01 2007 for ITM OverSim by  doxygen 1.5.1