SubSpaceTable Class Reference

#include <SubSpaceTable.h>

List of all members.

Public Member Functions

 ~SubSpaceTable ()
virtual int numInitStages () const
virtual void initialize (int stage)
virtual void finish ()
virtual void handleMessage (cMessage *msg)
void setResponsibleNode (int id, IPAddress resp_ip)
void setBackupNode (int id, IPAddress backup_ip)
void createTable (int size)
SubSpacegetSubSpace (unsigned int id)
int getSize ()
std::vector< SubSpace * > getAllNeighbors (int id)
void toString ()
void addNode (int subSpaceId, IPAddress nodeIp)
void removeNode (int subSpaceId, IPAddress nodeIp)
bool isInNodeList (int subSpaceId, IPAddress nodeIp)
void record (int subSpaceId, int logType, double value)

Public Attributes

std::vector
< std::list
< IPAddress > > 
nodeList

Private Member Functions

void processCollectStats ()

Private Attributes

int size
std::vector< SubSpace * > subSpaceTable
std::vector
< cOutVector * > 
intNodesCountLog
std::vector
< cOutVector * > 
playerOnlineLog
std::vector< int > replacedNodesLog
cOutVector sessionTime
cOutVector * treeLog
cOutVector droppedEventsLog
cOutVector * respLogUp
cOutVector * respLogDown
cOutVector * backupLogUp
cOutVector * backupLogDown
cOutVector * intLogUp
cOutVector * intLogDown
cOutVector * eventOut
unsigned long eventLog [1000]
unsigned long eventCount
cMessage * collectStatsTimer
double collectStatsDelay


Constructor & Destructor Documentation

SubSpaceTable::~SubSpaceTable (  ) 

00046                               {
00047         this->finish();
00048 }


Member Function Documentation

virtual int SubSpaceTable::numInitStages ( void   )  const [inline, virtual]

00031 {return 6;}

void SubSpaceTable::initialize ( int  stage  )  [virtual]

00025 {
00026         // Wait for IPAdressResolver
00027         if ( stage != 5 ) return;
00028         // 
00029         WATCH_PTRVECTOR(subSpaceTable);
00030         //WATCH_VECTOR(nodeList);
00031         
00032         collectStatsTimer = new cMessage("CollectStats");
00033         collectStatsDelay = 1;
00034         scheduleAt(simTime() + collectStatsDelay, collectStatsTimer);
00035         
00036         sessionTime.setName("Session Stats");
00037         //initialize eventlog
00038         int i =0;
00039         eventCount = 0;
00040         while ( i < 1000 ) {
00041                 eventLog[i] = 0;
00042                 i++;
00043         }
00044 }

void SubSpaceTable::finish (  )  [virtual]

00060 {
00061         //cleanup
00062         for(uint i=0; i < subSpaceTable.size(); ++i) {
00063                 delete subSpaceTable.at(i);
00064                 /*delete maxEventDelayLog.at(i);
00065                 delete avgEventDelayLog.at(i);
00066                 delete minEventDelayLog.at(i);
00067                 */
00068                 delete playerOnlineLog.at(i);
00069                 delete intNodesCountLog.at(i);
00070                 /*
00071                 delete replacedNodesLog.at(i);
00072                 delete maxCommunicationLog.at(i);
00073                 delete avgCommunicationLog.at(i);
00074                 delete minCommunicationLog.at(i);
00075                 */
00076         }
00077         if (backupLogUp != NULL) {
00078                 delete backupLogUp;
00079                 backupLogUp = NULL;
00080                 delete backupLogDown;
00081                 delete respLogUp;
00082                 delete respLogDown;
00083                 delete intLogUp;
00084                 delete intLogDown;
00085                 delete treeLog;
00086                 subSpaceTable.clear();
00087                 int i=0;
00088                 unsigned long count=0;
00089                 while(i < 1000) {
00090                         count += eventLog[i];
00091                         eventOut->record(i, (double) count / eventCount );
00092                         i++;
00093                 }
00094                 delete eventOut;
00095         }
00096         
00097         //communicationStats.clear();
00098         // no statistics yet
00099 }

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

00051 {
00052         if( msg->isName("CollectStats") ) {
00053                 processCollectStats();
00054         } else {
00055                 error("this module doesn't handle messages");
00056         }
00057 }

void SubSpaceTable::setResponsibleNode ( int  id,
IPAddress  resp_ip 
)

00292                                                                 {
00293         subSpaceTable.at(id)->setRespIp(resp_ip);
00294         
00295         if ( id == 0 ) { // left upper corner
00296                 subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00297                 subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00298                 subSpaceTable.at(id + size + 1)->setNeighbor(NW, resp_ip);
00299                 return;
00300         }
00301         if ( id == (size-1) ) { // right upper corner
00302                 subSpaceTable.at(id -1 )->setNeighbor(E, resp_ip);
00303                 subSpaceTable.at(id + size -1 )->setNeighbor(NE, resp_ip);
00304                 subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00305                 return;
00306         }
00307         if ( id == (size*size) - size ) { // left buttom corner
00308                 subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00309                 subSpaceTable.at(id - size +1)->setNeighbor(SW, resp_ip);
00310                 subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00311                 return;
00312         }
00313         if ( id == (size*size) - 1) { // right buttom corner
00314                 subSpaceTable.at(id - size - 1)->setNeighbor(SE, resp_ip);
00315                 subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00316                 subSpaceTable.at(id - 1)->setNeighbor(E, resp_ip);
00317                 return;
00318         }
00319         if ( id < size ) { // First Row, we got no top neighbors
00320                 subSpaceTable.at(id -1 )->setNeighbor(E, resp_ip);
00321                 subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00322                 subSpaceTable.at(id + size -1 )->setNeighbor(NE, resp_ip);
00323                 subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00324                 subSpaceTable.at(id + size + 1)->setNeighbor(NW, resp_ip);
00325                 return;
00326         }
00327         if ( (id % size) == 0 ) { // Left Row -> we got no left neighbors
00328                 subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00329                 subSpaceTable.at(id - size +1)->setNeighbor(SW, resp_ip);
00330                 subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00331                 subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00332                 subSpaceTable.at(id + size + 1)->setNeighbor(NW, resp_ip);
00333                 return;
00334         }
00335         if ( (id % size) == (size - 1) ) { // Right Row -> we got no right neighbors
00336                 subSpaceTable.at(id - size - 1)->setNeighbor(SE, resp_ip);
00337                 subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00338                 subSpaceTable.at(id -1 )->setNeighbor(E, resp_ip);
00339                 subSpaceTable.at(id + size -1 )->setNeighbor(NE, resp_ip);
00340                 subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00341                 return;
00342         }
00343         if ( id >= (size*size) - size ) { // Buttom Row -> we got no buttom neighbors
00344                 subSpaceTable.at(id - size - 1)->setNeighbor(SE, resp_ip);
00345                 subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00346                 subSpaceTable.at(id - size +1)->setNeighbor(SW, resp_ip);
00347                 subSpaceTable.at(id -1 )->setNeighbor(E, resp_ip);
00348                 subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00349                 return;
00350         }
00351         // We have really all 8 neighbors:
00352         subSpaceTable.at(id - size - 1)->setNeighbor(SE, resp_ip);
00353         subSpaceTable.at(id - size)->setNeighbor(S, resp_ip);
00354         subSpaceTable.at(id - size +1)->setNeighbor(SW, resp_ip);
00355         subSpaceTable.at(id -1 )->setNeighbor(E, resp_ip);
00356         subSpaceTable.at(id + 1)->setNeighbor(W, resp_ip);
00357         subSpaceTable.at(id + size -1 )->setNeighbor(NE, resp_ip);
00358         subSpaceTable.at(id + size)->setNeighbor(N, resp_ip);
00359         subSpaceTable.at(id + size + 1)->setNeighbor(NW, resp_ip);
00360 }

void SubSpaceTable::setBackupNode ( int  id,
IPAddress  backup_ip 
)

00362                                                              {
00363         subSpaceTable.at(id)->setBackupIp(backup_ip);
00364 }

void SubSpaceTable::createTable ( int  size  ) 

00101                                         {
00102         this->size = size;
00103         for(int id=0; id < size*size; id++ ) {
00104                 subSpaceTable.push_back( new SubSpace(id, (IPAddress) "127.0.0.1" , (IPAddress) "127.0.0.1" ) );
00105                 replacedNodesLog.push_back(0);
00106                 std::list<IPAddress> newList;
00107                 nodeList.push_back( newList );
00108                 
00109                 char buffer[255];
00110                 /*
00111                 // MaxEventDelay
00112                 cOutVector* log = new cOutVector;
00113                 maxEventDelayLog.push_back( log  );
00114                 sprintf(buffer, "MaxEventDelayLog for SubSpace ID: %i", id);
00115                 maxEventDelayLog.back()->setName(buffer);
00116                 // AvgEventDelay
00117                 log = new cOutVector;
00118                 avgEventDelayLog.push_back( log  );
00119                 sprintf(buffer, "AvgEventDelayLog for SubSpace ID: %i", id);
00120                 avgEventDelayLog.back()->setName(buffer);
00121                 // MinEventDelay
00122                 log = new cOutVector;
00123                 minEventDelayLog.push_back( log  );
00124                 sprintf(buffer, "MinEventDelayLog for SubSpace ID: %i", id);
00125                 minEventDelayLog.back()->setName(buffer);               
00126                 */
00127                 // PlayerOnline
00128                 cOutVector* log = new cOutVector;
00129                 playerOnlineLog.push_back( log  );
00130                 sprintf(buffer, "PlayerOnline for SubSpace ID: %i", id);
00131                 playerOnlineLog.back()->setName(buffer);
00132                 /*// Dropped Events
00133                 log = new cOutVector;
00134                 droppedEventsLog.push_back( log  );
00135                 sprintf(buffer, "Dropped Events for SubSpace ID: %i", id);
00136                 droppedEventsLog.back()->setName(buffer);
00137                 
00138                 // Replaced IntermediateNodes
00139                 log = new cOutVector;
00140                 replacedNodesLog.push_back( log  );
00141                 sprintf(buffer, "Replacements of IntermediateNodes for SubSpace ID: %i", id);
00142                 replacedNodesLog.back()->setName(buffer);
00143                 */
00144                 // # of IntermediateNodes 
00145                 log = new cOutVector;
00146                 intNodesCountLog.push_back( log  );
00147                 sprintf(buffer, "Number of actual IntermediateNodes for SubSpace ID: %i", id);
00148                 intNodesCountLog.back()->setName(buffer);
00149                 /*// Max Communication Delay
00150                 sprintf(buffer, "Max Communication Delay for SubSpace ID: %i", id);
00151                 log = new cOutVector(buffer,2);
00152                 maxCommunicationLog.push_back( log  );
00153                 // Avg Communication Delay
00154                 sprintf(buffer, "Avg Communication Delay for SubSpace ID: %i", id);
00155                 log = new cOutVector(buffer,2);
00156                 avgCommunicationLog.push_back( log  );
00157                 // Min Communication Delay
00158                 sprintf(buffer, "Min Communication Delay for SubSpace ID: %i", id);             
00159                 log = new cOutVector(buffer, 2);
00160                 minCommunicationLog.push_back( log  );
00161                 cStdDev stat;
00162                 communicationStats.push_back(stat);*/
00163         }
00164         //maxEventDelay.setName("Max EventDelay for all Subspace/Players:");
00165         //avgEventDelay.setName("Avg EventDelay for all Subspace/Players:");
00166         //minEventDelay.setName("Min EventDelay for all SubSpace/Players:");
00167         
00168         //maxTreeDelay.setName("Max TreeDelay for all Subspace/Players:");
00169         //avgTreeDelay.setName("Avg TreeDelay for all Subspace/Players:");
00170         //minTreeDelay.setName("Min TreeDelay for all SubSpace/Players:");
00171         droppedEventsLog.setName("Dropped Events Logs for all Subspaces");
00172         treeLog = new cOutVector("TreeDelay for all Subspace/Players", 2);
00173         respLogUp = new cOutVector("ResponsibleNode Upstream Bandwith Log", 2);
00174         respLogDown = new cOutVector("ResponsibleNode Downstream Bandwith Log", 2);
00175         backupLogUp = new cOutVector("BackupNode Upstream Bandwith Log", 2);
00176         backupLogDown = new cOutVector("BackupNode Downstream Bandwith Log", 2);
00177         intLogUp = new cOutVector("IntermediateNode Upstream Bandwith Log", 2);
00178         intLogDown = new cOutVector("IntermediateNode Downstream Bandwith Log", 2);
00179         eventOut = new cOutVector("EventDelay Log for all Subspace/Players", 2);
00180         //eventLog.setName("EventDelay Log for all Subspace/Players");
00181         
00182 }

SubSpace * SubSpaceTable::getSubSpace ( unsigned int  id  ) 

00285                                                     {
00286         if( id < subSpaceTable.size() ) {
00287                 return subSpaceTable.at(id);
00288         }
00289         return NULL;
00290 }

int SubSpaceTable::getSize (  ) 

00264                            {
00265         return subSpaceTable.size();
00266 }

std::vector< SubSpace * > SubSpaceTable::getAllNeighbors ( int  id  ) 

00366                                                           {
00367         // returns all 8+1 Neighbors of a Subspace.push_back(
00368         std::vector<SubSpace*> neighbors;
00369         neighbors.push_back(getSubSpace(id)); // Not a true neighbor but we want to give it back too
00370         // Some special Cases we got no 8 neighbors
00371         if ( id == 0 ) { // left upper corner
00372                 neighbors.push_back(getSubSpace( id + 1));
00373                 neighbors.push_back(getSubSpace( id + size));
00374                 neighbors.push_back(getSubSpace( id + size + 1));
00375                 return neighbors;
00376         }
00377         else if ( id == (size-1) ) { // right upper corner
00378                 neighbors.push_back(getSubSpace( id - 1));
00379                 neighbors.push_back(getSubSpace( id + size - 1));
00380                 neighbors.push_back(getSubSpace( id + size));
00381                 return neighbors;
00382         }
00383         else if ( id == (size*size) - size ) { // left buttom corner
00384                 neighbors.push_back(getSubSpace( id-size ));
00385                 neighbors.push_back(getSubSpace( id - size + 1));
00386                 neighbors.push_back(getSubSpace( id + 1));
00387                 return neighbors;
00388         }
00389         else if ( id == (size*size) - 1) { // right buttom corner
00390                 neighbors.push_back(getSubSpace( id - size- 1));
00391                 neighbors.push_back(getSubSpace( id-size ));
00392                 neighbors.push_back(getSubSpace( id - 1));
00393                 return neighbors;
00394         }
00395         
00396         else if ( id < size ) { // First Row, we got no top neighbors
00397                 neighbors.push_back(getSubSpace( id - 1));
00398                 neighbors.push_back(getSubSpace( id + 1));
00399                 neighbors.push_back(getSubSpace( id + size - 1));
00400                 neighbors.push_back(getSubSpace( id + size));
00401                 neighbors.push_back(getSubSpace( id + size + 1));
00402                 return neighbors;
00403         }
00404         else if ( (id % size) == 0 ) { // Left Row -> we got no left neighbors
00405                 neighbors.push_back(getSubSpace( id-size ));
00406                 neighbors.push_back(getSubSpace( id - size + 1));
00407                 neighbors.push_back(getSubSpace( id + 1));
00408                 neighbors.push_back(getSubSpace( id + size));
00409                 neighbors.push_back(getSubSpace( id + size + 1));
00410                 return neighbors;
00411         }
00412         else if ( (id % size) == (size - 1) ) { // Right Row -> we got no right neighbors
00413                 neighbors.push_back(getSubSpace( id - size- 1));
00414                 neighbors.push_back(getSubSpace( id-size ));
00415                 neighbors.push_back(getSubSpace( id - 1));
00416                 neighbors.push_back(getSubSpace( id + size - 1));
00417                 neighbors.push_back(getSubSpace( id + size));
00418                 return neighbors;
00419         }
00420         else if ( id >= (size*size) - size ) { // Buttom Row -> we got no buttom neighbors
00421                 neighbors.push_back(getSubSpace( id - size- 1));
00422                 neighbors.push_back(getSubSpace( id-size ));
00423                 neighbors.push_back(getSubSpace( id - size + 1));
00424                 neighbors.push_back(getSubSpace( id - 1));
00425                 neighbors.push_back(getSubSpace( id + 1));
00426                 return neighbors;
00427         }
00428         // We really got 8 neighbors:
00429         neighbors.push_back(getSubSpace( id - size- 1));
00430         neighbors.push_back(getSubSpace( id-size ));
00431         neighbors.push_back(getSubSpace( id - size + 1));
00432         neighbors.push_back(getSubSpace( id - 1));
00433         neighbors.push_back(getSubSpace( id + 1));
00434         neighbors.push_back(getSubSpace( id + size - 1));
00435         neighbors.push_back(getSubSpace( id + size));
00436         neighbors.push_back(getSubSpace( id + size + 1));
00437         return neighbors;
00438 
00439 }

void SubSpaceTable::toString (  ) 

00268                              {
00269         for(unsigned int i=0; i < subSpaceTable.size(); i++) {
00270                 if( subSpaceTable.at(i)->getRespIp() != "127.0.0.1" ) {
00271                         if( (i % (int) sqrt(subSpaceTable.size()) ) == 0 ) {
00272                                 ev << "\n";
00273                         }
00274                         ev << "x";
00275                 }
00276                 else { 
00277                 if( (i % (int) sqrt(subSpaceTable.size()) ) == 0 ) {
00278                                 ev << "\n";
00279                         }
00280                 ev << "-";
00281                 }
00282         }
00283 }

void SubSpaceTable::addNode ( int  subSpaceId,
IPAddress  nodeIp 
)

00442                                                             {
00443         nodeList.at(subSpaceId).push_back(nodeIp);
00444 }

void SubSpaceTable::removeNode ( int  subSpaceId,
IPAddress  nodeIp 
)

00445                                                                {
00446         std::list<IPAddress>::iterator i;
00447         for( i = nodeList.at(subSpaceId).begin(); i != nodeList.at(subSpaceId).end(); ++i) {
00448                 if( *i == nodeIp) {
00449                         nodeList.at(subSpaceId).erase(i);
00450                 }
00451                 return;
00452         }
00453 }

bool SubSpaceTable::isInNodeList ( int  subSpaceId,
IPAddress  nodeIp 
)

00454                                                                  {
00455         std::list<IPAddress>::iterator i;
00456         for( i = nodeList.at(subSpaceId).begin(); i != nodeList.at(subSpaceId).end(); ++i) {
00457                 if( *i == nodeIp) {
00458                         return true;
00459                 }
00460         }
00461         return false;
00462 }

void SubSpaceTable::record ( int  subSpaceId,
int  logType,
double  value 
)

00183                                                                     {
00184         /*if( logType == 0 ) {
00185                 maxEventDelayLog.at(subSpaceId)->record(value);
00186         }
00187         else if( logType == 1) {
00188                 avgEventDelayLog.at(subSpaceId)->record(value);
00189         }
00190         else if ( logType == 2) {
00191                 minEventDelayLog.at(subSpaceId)->record(value);
00192         }
00193         */
00194         if ( logType == 5) {
00195                 replacedNodesLog[(int)subSpaceId] = value;
00196 /*              maxCommunicationLog.at(subSpaceId)->record(communicationStats.at(subSpaceId).max(), value);
00197                 avgCommunicationLog.at(subSpaceId)->record(communicationStats.at(subSpaceId).mean(), value);
00198                 minCommunicationLog.at(subSpaceId)->record(communicationStats.at(subSpaceId).min(), value);
00199                 communicationStats.at(subSpaceId).clearResult();
00200                 */
00201         }
00202         else if ( logType == 3) {
00203                 playerOnlineLog.at(subSpaceId)->record(value);
00204         }
00205         else if ( logType == 4) {
00206                 if( value >= 0) droppedEventsLog.record((double) value);
00207         }
00208         else if ( logType == 6) {
00209                 intNodesCountLog.at(subSpaceId)->record(value);
00210         }
00211         /*else if( logType == 7 ) {
00212                 communicationStats.at(subSpaceId).collect(value);
00213         }*/
00214         else if( logType == 8 ) {
00215                 sessionTime.record(value);
00216         }
00217         else if( logType == 9 ) {
00218                 //eventDelay.collect(value);
00219                 int tmp=0;
00220                 tmp = value*1000;
00221                 if( tmp > 999 ) tmp = 999;
00222                 eventLog[tmp]++;
00223                 eventCount++;
00224         }
00225         else if( logType == 10 ) {
00226                 //treeDelay.collect(value);
00227                 treeLog->record(value,replacedNodesLog.at(subSpaceId));
00228         }
00229         else if( logType == 11 ) {
00230                 //subSpaceId = |player(r)| 
00231                 respLogUp->record(value, subSpaceId);
00232         }
00233         else if( logType == 12 ) {
00234                 //subSpaceId = |player(r)| 
00235                 respLogDown->record(value, subSpaceId);
00236         }
00237         else if( logType == 13 ) {
00238                 //subSpaceId = |player(r)| 
00239                 backupLogUp->record(value, subSpaceId);
00240         }
00241         else if( logType == 14 ) {
00242                 //subSpaceId = |player(r)| 
00243                 backupLogDown->record(value, subSpaceId);
00244         }
00245         else if( logType == 15 ) {
00246                 //subSpaceId = |player(r)| 
00247                 intLogUp->record(value, subSpaceId);
00248         }
00249         else if( logType == 16 ) {
00250                 //subSpaceId = |player(r)| 
00251                 intLogDown->record(value, subSpaceId);
00252         }               /*else if ( logType == 7) {
00253                 maxCommunicationLog.at(subSpaceId)->record(value);
00254         }
00255         else if ( logType == 8) {
00256                 avgCommunicationLog.at(subSpaceId)->record(value);
00257         }
00258         else if ( logType == 9) {
00259                 minCommunicationLog.at(subSpaceId)->record(value);
00260         }
00261         */
00262 
00263 }

void SubSpaceTable::processCollectStats (  )  [private]

00463                                         {
00464         cancelEvent(collectStatsTimer);
00465         /*maxEventDelay.record(eventDelay.max());
00466         avgEventDelay.record(eventDelay.mean());
00467         minEventDelay.record(eventDelay.min());
00468         maxTreeDelay.record(treeDelay.max());
00469         avgTreeDelay.record(treeDelay.mean());
00470         minTreeDelay.record(treeDelay.min());
00471         treeDelay.clearResult();
00472         eventDelay.clearResult();
00473         scheduleAt(simTime()+ collectStatsDelay, collectStatsTimer);*/
00474 }


Member Data Documentation

std::vector< std::list<IPAddress> > SubSpaceTable::nodeList

int SubSpaceTable::size [private]

std::vector<SubSpace*> SubSpaceTable::subSpaceTable [private]

std::vector<cOutVector*> SubSpaceTable::intNodesCountLog [private]

std::vector<cOutVector*> SubSpaceTable::playerOnlineLog [private]

std::vector<int> SubSpaceTable::replacedNodesLog [private]

cOutVector SubSpaceTable::sessionTime [private]

cOutVector* SubSpaceTable::treeLog [private]

cOutVector SubSpaceTable::droppedEventsLog [private]

cOutVector* SubSpaceTable::respLogUp [private]

cOutVector* SubSpaceTable::respLogDown [private]

cOutVector* SubSpaceTable::backupLogUp [private]

cOutVector* SubSpaceTable::backupLogDown [private]

cOutVector* SubSpaceTable::intLogUp [private]

cOutVector* SubSpaceTable::intLogDown [private]

cOutVector* SubSpaceTable::eventOut [private]

unsigned long SubSpaceTable::eventLog[1000] [private]

unsigned long SubSpaceTable::eventCount [private]

cMessage* SubSpaceTable::collectStatsTimer [private]

double SubSpaceTable::collectStatsDelay [private]


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