ParetoChurn Class Reference

#include <ParetoChurn.h>

Inheritance diagram for ParetoChurn:

ChurnGenerator

List of all members.


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

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 lifetimeMean
 mean node lifetime
double deadtimeMean
 mean node deadtime
double lastCreatetime
double lastDeletetime
cMessage * initFinishedTimer
 timer to signal end of init phase

Classes

struct  node_stat


Constructor & Destructor Documentation

ParetoChurn::~ParetoChurn (  ) 

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


Member Function Documentation

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

Implements ChurnGenerator.

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

void ParetoChurn::initializeChurn (  )  [virtual]

Implements ChurnGenerator.

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

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

Implements ChurnGenerator.

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

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

Referenced by handleMessage().

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

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

Referenced by handleMessage().

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

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

implements a shifted pareto funcion

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

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

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

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

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

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

Referenced by initializeChurn().

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

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

Referenced by deleteNode(), and initializeChurn().

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

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

Referenced by initializeChurn().

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

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

Referenced by deleteNode(), and initializeChurn().

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


Member Data Documentation

double ParetoChurn::initialMean [private]

mean of update interval during initalization phase

Referenced by initializeChurn().

deviation of update interval during initalization phase

Referenced by initializeChurn().

double ParetoChurn::lifetimeMean [private]

mean node lifetime

Referenced by initializeChurn().

double ParetoChurn::deadtimeMean [private]

mean node deadtime

Referenced by initializeChurn().

double ParetoChurn::lastCreatetime [private]

Referenced by createNode(), and initializeChurn().

double ParetoChurn::lastDeletetime [private]

Referenced by deleteNode(), and initializeChurn().

cMessage* ParetoChurn::initFinishedTimer [private]

timer to signal end of init phase

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


The documentation for this class was generated from the following files:

Generated on Fri Sep 19 13:05:07 2008 for ITM OverSim by  doxygen 1.5.5