ParetoChurn Class Reference

Lifetime churn based on shifted pareto distribution. More...

#include <ParetoChurn.h>

Inheritance diagram for ParetoChurn:
ChurnGenerator

List of all members.

Classes

struct  node_stat

Public Member Functions

void handleMessage (cMessage *msg)
void initializeChurn ()
 ParetoChurn ()
 ~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 lifetimeMean
 mean node lifetime
double deadtimeMean
 mean node deadtime
simtime_t lastCreatetime
simtime_t lastDeletetime
cMessage * initFinishedTimer
 timer to signal end of init phase

Detailed Description

Lifetime churn based on shifted pareto distribution.

This class implements the curn model proposed in

Yao, Z.; Leonard, D.; Wang, X. & Loguinov, D. "Modeling Heterogeneous User Churn and Local Resilience of Unstructured P2P Networks" Proceedings of the 2006 14th IEEE International Conference on Network Protocols, 2006. ICNP '06. 2006, pp. 32--41

Definition at line 46 of file ParetoChurn.h.


Constructor & Destructor Documentation

ParetoChurn::ParetoChurn (  )  [inline]

Definition at line 51 of file ParetoChurn.h.

00051 { initFinishedTimer = NULL; };

ParetoChurn::~ParetoChurn (  ) 

Definition at line 247 of file ParetoChurn.cc.

00247                           {
00248     // destroy self timer messages
00249     cancelAndDelete(initFinishedTimer);
00250 }


Member Function Documentation

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

Definition at line 209 of file ParetoChurn.cc.

Referenced by individualLifetime(), individualMeanTime(), and residualLifetime().

00210 {
00211     return 1/(mean*(alpha -1));
00212 }

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

Definition at line 162 of file ParetoChurn.cc.

Referenced by handleMessage().

00164 {
00165     ParetoChurnMessage* churnMsg = new ParetoChurnMessage("DeleteNode");
00166     TransportAddress* ta = underlayConfigurator->createNode(type, initialize);
00167     churnMsg->setAddr(*ta);
00168     delete ta;
00169     churnMsg->setCreateNode(false);
00170     churnMsg->setMeanLifetime(meanLifetime);
00171     churnMsg->setMeanDeadtime(meanDeadtime);
00172     scheduleAt(std::max(simTime(), simTime() + lifetime
00173                    - underlayConfigurator->getGracefulLeaveDelay()), churnMsg);
00174 
00175     RECORD_STATS(globalStatistics->recordOutVector("ParetoChurn: Session Time",
00176                                                    lifetime));
00177 
00178     RECORD_STATS(globalStatistics->recordOutVector("ParetoChurn: "
00179                  "Time between creates", SIMTIME_DBL(simTime() - lastCreatetime)));
00180 
00181     lastCreatetime = simTime();
00182 }

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

Definition at line 184 of file ParetoChurn.cc.

Referenced by handleMessage().

00186 {
00187     // Kill node
00188     underlayConfigurator->preKillNode(NodeType(), &addr);
00189 
00190     RECORD_STATS(globalStatistics->recordOutVector("ParetoChurn: "
00191                "Time between deletes", SIMTIME_DBL(simTime() - lastDeletetime)));
00192     lastDeletetime = simTime();
00193     scheduleCreateNodeAt(SIMTIME_DBL(simTime()+individualLifetime(meanDeadtime)),
00194                          individualLifetime(meanLifetime), meanLifetime,
00195                          meanDeadtime);
00196 }

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

Implements ChurnGenerator.

Definition at line 132 of file ParetoChurn.cc.

00133 {
00134     if (!msg->isSelfMessage()) {
00135         delete msg;
00136         return;
00137     }
00138 
00139     // init phase finished
00140     if (msg ==  initFinishedTimer) {
00141         underlayConfigurator->initFinished();
00142         cancelEvent(initFinishedTimer);
00143         delete initFinishedTimer;
00144         initFinishedTimer = NULL;
00145 
00146         return;
00147     }
00148 
00149     ParetoChurnMessage* churnMsg = check_and_cast<ParetoChurnMessage*>(msg);
00150 
00151     if (churnMsg->getCreateNode() == true) {
00152         createNode(churnMsg->getLifetime(), churnMsg->getMeanLifetime(),
00153                    churnMsg->getMeanDeadtime(), false);
00154     } else {
00155         deleteNode(churnMsg->getAddr(), churnMsg->getMeanLifetime(),
00156                    churnMsg->getMeanDeadtime());
00157     }
00158 
00159     delete msg;
00160 }

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

Definition at line 227 of file ParetoChurn.cc.

Referenced by deleteNode(), and initializeChurn().

00228 {
00229     return shiftedPareto(3, betaByMean(mean));
00230 }

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

Definition at line 221 of file ParetoChurn.cc.

Referenced by initializeChurn().

00222 {
00223 //    return shiftedPareto(3, betaByMean(mean*exp(1)));
00224     return shiftedPareto(3, betaByMean(mean));
00225 }

void ParetoChurn::initializeChurn (  )  [virtual]

Implements ChurnGenerator.

Definition at line 44 of file ParetoChurn.cc.

00045 {
00046     Enter_Method_Silent();
00047 
00048     initialMean = par("initPhaseCreationInterval");
00049     initialDeviation = initialMean / 3;
00050     lifetimeMean = par("lifetimeMean");
00051     deadtimeMean = par("deadtimeMean");
00052 
00053     WATCH(lifetimeMean);
00054     WATCH(deadtimeMean);
00055 
00056     lastCreatetime = 0;
00057     lastDeletetime = 0;
00058 
00059     globalStatistics = GlobalStatisticsAccess().get();
00060 
00061     double initFinishedTime = initialMean * targetOverlayTerminalNum;
00062 
00063     // try to create a stable equilibrium of nodes in init phase
00064     //
00065     // check for each node if he is present in initial state
00066     // and roll individual mean life+dead times
00067     int liveNodes = 0;
00068     double sum_l_i = 0;
00069     std::deque<node_stat> node_stats;
00070 
00071     for (int i = 0; liveNodes < (int)par("targetOverlayTerminalNum"); i++) {
00072 
00073         double nodeLifetimeMean = individualMeanTime(lifetimeMean);
00074         globalStatistics->recordOutVector("ParetoChurn: Node individual "
00075                                           "mean lifetime", nodeLifetimeMean);
00076         double nodeDeadtimeMean = individualMeanTime(deadtimeMean);
00077         globalStatistics->recordOutVector("ParetoChurn: Node individual "
00078                                           "mean deadtime", nodeDeadtimeMean);
00079         sum_l_i += 1.0/(nodeLifetimeMean + nodeDeadtimeMean);
00080         node_stat nodeStat;
00081         nodeStat.l = nodeLifetimeMean;
00082         nodeStat.d = nodeDeadtimeMean;
00083         double nodeAvailability = nodeLifetimeMean/(nodeLifetimeMean
00084                                                     + nodeDeadtimeMean);
00085 
00086         globalStatistics->recordOutVector("Node availability", nodeAvailability);
00087 
00088         nodeStat.alive = uniform(0, 1) < nodeAvailability;
00089         if (nodeStat.alive) {
00090             liveNodes++;
00091         }
00092         node_stats.push_back( nodeStat );
00093     }
00094 
00095     // compute "stretch" factor to reach the configured average lifetime
00096     // this is neccessary as "individual" lifetime mean has to be bigger than
00097     // "global" lifetime mean, as short-lived nodes will factor in more often
00098     double mean_life = 0;
00099     int numNodes = node_stats.size();
00100     for( int i = 0; i < numNodes; ++i ){
00101         node_stat& stat = node_stats[i];
00102         mean_life += stat.l/( (stat.l + stat.d) * sum_l_i );
00103     }
00104     double stretch = lifetimeMean/mean_life;
00105     liveNodes = 0;
00106 
00107     // schedule creation for all (alive or dead) nodes
00108     for( int i = 0; i < numNodes; ++i ){
00109         node_stat& stat = node_stats.front();
00110         stat.l *= stretch;
00111         stat.d *= stretch;
00112 
00113         if( stat.alive ){
00114             double scheduleTime = truncnormal(initialMean*liveNodes, initialDeviation);
00115             scheduleCreateNodeAt(scheduleTime, initFinishedTime - scheduleTime
00116                                  + residualLifetime(stat.l),
00117                                  stat.l, stat.d);
00118             liveNodes++;
00119         } else {
00120             scheduleCreateNodeAt(initFinishedTime
00121                                  + residualLifetime(stat.d),
00122                                  individualLifetime(stat.l),
00123                                  stat.l, stat.d);
00124         }
00125         node_stats.pop_front();
00126     }
00127 
00128     initFinishedTimer = new cMessage("initFinishTimer");
00129     scheduleAt(initFinishedTime, initFinishedTimer);
00130 }

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

Definition at line 235 of file ParetoChurn.cc.

Referenced by initializeChurn().

00236 {
00237     return shiftedPareto(2, betaByMean(mean));
00238 }

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

Definition at line 198 of file ParetoChurn.cc.

Referenced by deleteNode(), and initializeChurn().

00200 {
00201     ParetoChurnMessage* churnMsg = new ParetoChurnMessage("CreateNode");
00202     churnMsg->setCreateNode(true);
00203     churnMsg->setLifetime(lifetime);
00204     churnMsg->setMeanLifetime(meanLifetime);
00205     churnMsg->setMeanDeadtime(meanDeadtime);
00206     scheduleAt(creationTime, churnMsg);
00207 }

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

implements a shifted pareto funcion

Definition at line 214 of file ParetoChurn.cc.

Referenced by individualLifetime(), individualMeanTime(), and residualLifetime().

00215 {
00216     // What OMNET calles "pareto_shifted" in reality is a gerneralized pareto,
00217     // not a shifted pareto...
00218     return (pareto_shifted(a, b, 0, rng)/b - 1) / b;
00219 }

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

Implements ChurnGenerator.

Definition at line 240 of file ParetoChurn.cc.

00241 {
00242     char buf[80];
00243     sprintf(buf, "pareto churn");
00244     getDisplayString().setTagArg("t", 0, buf);
00245 }


Member Data Documentation

double ParetoChurn::deadtimeMean [private]

mean node deadtime

Definition at line 107 of file ParetoChurn.h.

Referenced by initializeChurn().

Definition at line 102 of file ParetoChurn.h.

Referenced by createNode(), deleteNode(), and initializeChurn().

cMessage* ParetoChurn::initFinishedTimer [private]

timer to signal end of init phase

Definition at line 112 of file ParetoChurn.h.

Referenced by handleMessage(), initializeChurn(), ParetoChurn(), and ~ParetoChurn().

deviation of update interval during initalization phase

Definition at line 105 of file ParetoChurn.h.

Referenced by initializeChurn().

double ParetoChurn::initialMean [private]

mean of update interval during initalization phase

Definition at line 104 of file ParetoChurn.h.

Referenced by initializeChurn().

simtime_t ParetoChurn::lastCreatetime [private]

Definition at line 109 of file ParetoChurn.h.

Referenced by createNode(), and initializeChurn().

simtime_t ParetoChurn::lastDeletetime [private]

Definition at line 110 of file ParetoChurn.h.

Referenced by deleteNode(), and initializeChurn().

double ParetoChurn::lifetimeMean [private]

mean node lifetime

Definition at line 106 of file ParetoChurn.h.

Referenced by initializeChurn().


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