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 (  ) 

00178 {
00179     cancelAndDelete(initFinishedTimer);
00180 }


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.

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

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(simulation.simTime()
00118                + lifetime, churnMsg);
00119 
00120     RECORD_STATS(globalStatistics->recordOutVector(
00121                       "BaseOverlay: Session Time", lifetime));
00122     RECORD_STATS(globalStatistics->recordOutVector(
00123                      "BaseOverlay: Time between creates",
00124                      simulation.simTime() - lastCreate));
00125 
00126     lastCreate = simulation.simTime();
00127 }

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

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

double LifetimeChurn::distributionFunction (  )  [protected]

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

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

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


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 Tue Jul 24 16:51:18 2007 for ITM OverSim by  doxygen 1.5.1