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

00203                           {
00204     // destroy self timer messages
00205     cancelAndDelete(mobilityTimer);
00206     cancelAndDelete(initFinishedTimer);
00207 }


Member Function Documentation

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

Implements ChurnGenerator.

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

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     int liveNodes = 0;
00059     for (int i = 0; liveNodes < (int)par("targetOverlayTerminalNum"); i++) {
00060 
00061         double nodeLifetimeMean = individualMeanTime(lifetimeMean);
00062         double nodeDeadtimeMean = individualMeanTime(deadtimeMean);
00063         double nodeAvailability = nodeLifetimeMean/(nodeLifetimeMean
00064                                                     + nodeDeadtimeMean);
00065 
00066         RECORD_STATS(globalStatistics->recordOutVector("Node availability",
00067                                                        nodeAvailability));
00068 
00069         // draw a random value. if it is smaller than availability,
00070         // then node is alive
00071         // note: residual lifetime is shiftedPareto(2, beta) and not
00072         // shiftedPareto(3, beta)
00073         if (uniform(0, 1) < nodeAvailability) {
00074             double scheduleTime = truncnormal(initialMean*liveNodes, initialDeviation);
00075             scheduleCreateNodeAt(scheduleTime, initFinishedTime - scheduleTime
00076                                  + residualLifetime(nodeLifetimeMean), 
00077                                  nodeLifetimeMean, nodeDeadtimeMean);
00078             liveNodes++;
00079         } else {
00080             // node is dead, schedule creation at the end of residual dead time
00081             scheduleCreateNodeAt(initFinishedTime
00082                                  + residualLifetime(nodeDeadtimeMean),
00083                                  individualLifetime(nodeLifetimeMean),
00084                                  nodeLifetimeMean, nodeDeadtimeMean);
00085         }
00086     }
00087 
00088     initFinishedTimer = new cMessage("initFinishTimer");
00089     scheduleAt(initFinishedTime, initFinishedTimer);
00090 }

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

Implements ChurnGenerator.

00197 {
00198     char buf[80];
00199     sprintf(buf, "pareto churn");
00200     displayString().setTagArg("t", 0, buf);
00201 }

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

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

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

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

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

implements a shifted pareto funcion

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

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
00167 {
00168     return 1/(mean*(alpha -1));
00169 }

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
00179 {
00180     return shiftedPareto(3, betaByMean(mean));
00181 }

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
00184 {
00185     return shiftedPareto(3, betaByMean(mean));
00186 }

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
00192 {
00193     return shiftedPareto(2, betaByMean(mean));
00194 }

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

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


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 Wed Sep 26 12:13:01 2007 for ITM OverSim by  doxygen 1.5.1