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 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 * initFinishedTimer
 timer to signal end of init phase


Constructor & Destructor Documentation

ParetoChurn::~ParetoChurn (  ) 

00209                           {
00210     // destroy self timer messages
00211     cancelAndDelete(initFinishedTimer);
00212 }


Member Function Documentation

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

Implements ChurnGenerator.

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

void ParetoChurn::initializeChurn (  )  [virtual]

Implements ChurnGenerator.

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

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

Implements ChurnGenerator.

00203 {
00204     char buf[80];
00205     sprintf(buf, "pareto churn");
00206     displayString().setTagArg("t", 0, buf);
00207 }

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

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

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

00148 {
00149     // Kill node
00150     underlayConfigurator->preKillNode(NodeType(), &addr);
00151 
00152     RECORD_STATS(globalStatistics->recordOutVector(
00153                      "BaseOverlay: Interdeletiontime",
00154                      simulation.simTime() - lastDeletetime));
00155     lastDeletetime = simulation.simTime();
00156     scheduleCreateNodeAt(simulation.simTime()+individualLifetime(meanDeadtime),
00157                          individualLifetime(meanLifetime), meanLifetime,
00158                          meanDeadtime);
00159 }

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

implements a shifted pareto funcion

00178 {
00179     // What OMNET calles "pareto_shifted" in reality is a gerneralized pareto,
00180     // not a shifted pareto...
00181     return (pareto_shifted(a, b, 0, rng)/b - 1) / b;
00182 }

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
00173 {
00174     return 1/(mean*(alpha -1));
00175 }

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

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
00190 {
00191     return shiftedPareto(3, betaByMean(mean));
00192 }

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
00198 {
00199     return shiftedPareto(2, betaByMean(mean));
00200 }

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

00163 {
00164     ParetoChurnMessage* churnMsg = new ParetoChurnMessage("CreateNode");
00165     churnMsg->setCreateNode(true);
00166     churnMsg->setLifetime(lifetime);
00167     churnMsg->setMeanLifetime(meanLifetime);
00168     churnMsg->setMeanDeadtime(meanDeadtime);
00169     scheduleAt(creationTime, churnMsg);
00170 }


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::initFinishedTimer [private]

timer to signal end of init phase


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:29 2008 for ITM OverSim by  doxygen 1.5.3