ParetoChurn Class Reference

#include <ParetoChurn.h>

Inheritance diagram for ParetoChurn:

ChurnGenerator List of all members.

Detailed Description

Lifetime churn based on shifted pareto distribution Implements the curn model presented in FIXME: paper reference.


Public Member Functions

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

Protected Member Functions

void updateDisplayString ()
void createNode (double lifetime, double meanLifetime, double meanDeadtime, bool initialize)
void deleteNode (TransportAddress &addr, double meanLifetime, double meanDeadtime)
double shiftedPareto (double a, double b, int rng=0)
 implements a shifted pareto funcion
double betaByMean (double mean, double alpha=3)
 returns a shifted pareto function's beta param by given mean and alpha
double individualMeanTime (double mean)
 returns the individual mean life/dead time of a node
double individualLifetime (double mean)
 returns a individual lifetime (or deadtime) based on a node's mean lifetime
double residualLifetime (double mean)
 returns the resiidual lifetime (or deadtime) based on a node's mean lifetime
void scheduleCreateNodeAt (double creationTime, double lifetime, double meanLifetime, double meanDeadtime)

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 deadtimeMean
 mean node deadtime
double lastCreatetime
double lastDeletetime
uint32_t randomNodeOffset
 parameter for ofsetting node numbers to get more random node churn
cMessage * mobilityTimer
 message to schedule events
cMessage * initFinishedTimer
 timer to signal end of init phase


Constructor & Destructor Documentation

ParetoChurn::~ParetoChurn (  ) 

00200                           {
00201     // destroy self timer messages
00202     cancelAndDelete(mobilityTimer);
00203     cancelAndDelete(initFinishedTimer);
00204 }


Member Function Documentation

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

Implements ChurnGenerator.

00091 {
00092     if (!msg->isSelfMessage()) {
00093         delete msg;
00094         return;
00095     }
00096 
00097     // init phase finished
00098     if (msg ==  initFinishedTimer) {
00099         underlayConfigurator->initFinished();
00100         delete msg;
00101         return;
00102     }
00103 
00104     ParetoChurnMessage* churnMsg = check_and_cast<ParetoChurnMessage*>(msg);
00105     
00106     if (churnMsg->getCreateNode() == true) {
00107         createNode(churnMsg->getLifetime(), churnMsg->getMeanLifetime(),
00108                 churnMsg->getMeanDeadtime(), false);
00109     } else {
00110         deleteNode(churnMsg->getAddr(), churnMsg->getMeanLifetime(),
00111                 churnMsg->getMeanDeadtime());
00112     }
00113     
00114     delete msg;
00115 }

void ParetoChurn::initializeChurn (  )  [virtual]

Implements ChurnGenerator.

00032 {
00033     Enter_Method_Silent();
00034 
00035     initialMean = par("initialMobilityDelay");
00036     initialDeviation = initialMean / 3;
00037     lifetimeMean = par("lifetimeMean");
00038     deadtimeMean = par("deadtimeMean");
00039 
00040     WATCH(lifetimeMean);
00041     WATCH(deadtimeMean);
00042 
00043     lastCreatetime = 0;
00044     lastDeletetime = 0;
00045 
00046     globalStatistics = GlobalStatisticsAccess().get();
00047 
00048     double initFinishedTime = initialMean * targetOverlayTerminalNum;
00049     if (initialOverlayTerminalNum) opp_warning("ParetoChurn ignores parameter "
00050             "initialOverlayTerminalNum, but it is set to a number != 0");
00051 
00052    
00053     randomNodeOffset = intuniform(0, 0xFFFFFFFF);
00054 
00055     // try to create a stable equilibrium of nodes in init phase
00056     //
00057     // check for each node if he is present in initial state
00058     for (int i = 0; i < (int)par("targetOverlayTerminalNum"); i++) {
00059 
00060         double nodeLifetimeMean = individualMeanTime(lifetimeMean);
00061         double nodeDeadtimeMean = individualMeanTime(deadtimeMean);
00062         double nodeAvailability = nodeLifetimeMean/(nodeLifetimeMean
00063                                                     + nodeDeadtimeMean);
00064 
00065         RECORD_STATS(globalStatistics->recordOutVector("Node availability",
00066                                                        nodeAvailability));
00067 
00068         // draw a random value. if it is smaller than availability,
00069         // then node is alive
00070         // note: residual lifetime is shiftedPareto(2, beta) and not
00071         // shiftedPareto(3, beta)
00072         if (uniform(0, 1) < nodeAvailability) {
00073             double scheduleTime = truncnormal(initialMean*i, initialDeviation);
00074             scheduleCreateNodeAt(scheduleTime, initFinishedTime - scheduleTime
00075                                  + residualLifetime(nodeLifetimeMean), 
00076                                  nodeLifetimeMean, nodeDeadtimeMean);
00077         } else {
00078             // node is dead, schedule creation at the end of residual dead time
00079             scheduleCreateNodeAt(initFinishedTime
00080                                  + residualLifetime(nodeDeadtimeMean),
00081                                  individualLifetime(nodeLifetimeMean),
00082                                  nodeLifetimeMean, nodeDeadtimeMean);
00083         }
00084     }
00085 
00086     initFinishedTimer = new cMessage("initFinishTimer");
00087     scheduleAt(initFinishedTime, initFinishedTimer);
00088 }

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

Implements ChurnGenerator.

00194 {
00195     char buf[80];
00196     sprintf(buf, "pareto churn");
00197     displayString().setTagArg("t", 0, buf);
00198 }

void ParetoChurn::createNode ( double  lifetime,
double  meanLifetime,
double  meanDeadtime,
bool  initialize 
) [protected]

00119 {
00120     ParetoChurnMessage* churnMsg = new ParetoChurnMessage("DeleteNode");
00121     churnMsg->setAddr(*underlayConfigurator->createNode(type, initialize));
00122     churnMsg->setCreateNode(false);
00123     churnMsg->setMeanLifetime(meanLifetime);
00124     churnMsg->setMeanDeadtime(meanDeadtime);
00125     scheduleAt(simulation.simTime() + lifetime, churnMsg);
00126 
00127     RECORD_STATS(globalStatistics->recordOutVector("BaseOverlay: Session Time",
00128                                                    lifetime));
00129 
00130     RECORD_STATS(globalStatistics->recordOutVector(
00131                      "BaseOverlay: Interarrivaltime",
00132                      simulation.simTime() - lastCreatetime));
00133 
00134     lastCreatetime = simulation.simTime();
00135 }

void ParetoChurn::deleteNode ( TransportAddress addr,
double  meanLifetime,
double  meanDeadtime 
) [protected]

00139 {
00140     // Kill node
00141     underlayConfigurator->preKillNode(NodeType(), &addr);
00142 
00143     RECORD_STATS(globalStatistics->recordOutVector(
00144                      "BaseOverlay: Interdeletiontime",
00145                      simulation.simTime() - lastDeletetime));
00146     lastDeletetime = simulation.simTime();
00147     scheduleCreateNodeAt(simulation.simTime()+individualLifetime(meanDeadtime),
00148                          individualLifetime(meanLifetime), meanLifetime,
00149                          meanDeadtime);
00150 }

double ParetoChurn::shiftedPareto ( double  a,
double  b,
int  rng = 0 
) [protected]

implements a shifted pareto funcion

00169 {
00170     // What OMNET calles "pareto_shifted" in reality is a gerneralized pareto,
00171     // not a shifted pareto...
00172     return (pareto_shifted(a, b, 0, rng)/b - 1) / b;
00173 }

double ParetoChurn::betaByMean ( double  mean,
double  alpha = 3 
) [protected]

returns a shifted pareto function's beta param by given mean and alpha

Parameters:
mean the wanted mean
alpha the alph param of the shifted pareto (defaults to 3)
Returns:
the beta parameter
00164 {
00165     return 1/(mean*(alpha -1));
00166 }

double ParetoChurn::individualMeanTime ( double  mean  )  [protected]

returns the individual mean life/dead time of a node

Parameters:
mean the global mean life/dead time
Returns:
the mean life/dead time of the node
00176 {
00177     return shiftedPareto(3, betaByMean(mean));
00178 }

double ParetoChurn::individualLifetime ( double  mean  )  [protected]

returns a individual lifetime (or deadtime) based on a node's mean lifetime

Parameters:
mean the node's men lifetime
Returns:
the lifetime
00181 {
00182     return shiftedPareto(3, betaByMean(mean));
00183 }

double ParetoChurn::residualLifetime ( double  mean  )  [protected]

returns the resiidual lifetime (or deadtime) based on a node's mean lifetime

Parameters:
mean the node's men lifetime
Returns:
the residual lifetime
00189 {
00190     return shiftedPareto(2, betaByMean(mean));
00191 }

void ParetoChurn::scheduleCreateNodeAt ( double  creationTime,
double  lifetime,
double  meanLifetime,
double  meanDeadtime 
) [protected]

00154 {
00155     ParetoChurnMessage* churnMsg = new ParetoChurnMessage("CreateNode");
00156     churnMsg->setCreateNode(true);
00157     churnMsg->setLifetime(lifetime);
00158     churnMsg->setMeanLifetime(meanLifetime);
00159     churnMsg->setMeanDeadtime(meanDeadtime);
00160     scheduleAt(creationTime, churnMsg);
00161 }


Member Data Documentation

GlobalStatistics* ParetoChurn::globalStatistics [private]

double ParetoChurn::initialMean [private]

mean of update interval during initalization phase

double ParetoChurn::initialDeviation [private]

deviation of update interval during initalization phase

double ParetoChurn::targetMean [private]

mean of update interval after initalization phase

std::string ParetoChurn::lifetimeDistName [private]

name of the distribution function

double ParetoChurn::lifetimeMean [private]

mean node lifetime

double ParetoChurn::deadtimeMean [private]

mean node deadtime

double ParetoChurn::lastCreatetime [private]

double ParetoChurn::lastDeletetime [private]

uint32_t ParetoChurn::randomNodeOffset [private]

parameter for ofsetting node numbers to get more random node churn

cMessage* ParetoChurn::mobilityTimer [private]

message to schedule events

cMessage* ParetoChurn::initFinishedTimer [private]

timer to signal end of init phase


The documentation for this class was generated from the following files:
Generated on Tue Jul 24 16:51:19 2007 for ITM OverSim by  doxygen 1.5.1