#include <LoadBalancingTree.h>
Public Member Functions | |
~LoadBalancingTree () | |
LoadBalancingTree () | |
LoadBalancingTree (int subSpaceId, unsigned int maxPlayerLeafs, unsigned int treeWidth) | |
std::list< TreeMessage > | addPlayer (int playerId, IPAddress playerIp) |
std::list< TreeMessage > | removePlayer (int playerId) |
std::list< TreeMessage > | removePlayer (IPAddress playerIp) |
std::list< IPAddress > | getList () |
std::list< PlayerNode > | getAllPlayers () |
std::list< IPAddress > | getAllNodes () |
std::list< IPAddress > | getAllIntNodes () |
std::list< TreeMessage > | addIntermediateNode (IPAddress destip) |
std::list< IPAddress > | exchangeNode (IPAddress oldNodeIp, IPAddress newNodeIp) |
std::list< TreeMessage > | replace (IPAddress newNodeIp) |
std::list< TreeNode > | serialize () |
void | rebuildTree (std::list< TreeNode > source) |
void | printTree () |
Public Attributes | |
unsigned int | size |
std::list< IPAddress > | readyIntermediateNodes |
std::list< IPAddress > | usedIntermediateNodes |
int | replacedIntermediateNodes |
Protected Member Functions | |
NodePos | searchPlayer (int playerId) |
NodePos | searchPlayer (IPAddress playerIp) |
std::list< TreeNode * > | searchNodes (IPAddress playerIp) |
TreeNode * | searchLeftmostNode () |
TreeNode * | searchLastNode () |
Protected Attributes | |
TreeNode * | root |
TreeNode * | lastTreeNode |
std::list< TreeNode > | waitingNodes |
std::list< TreeNode >::iterator | iW |
std::list< TreeNode * > | freed |
std::list< TreeNode * >::iterator | f |
std::list< TreeNode * > | inReplace |
std::list< TreeNode * >::iterator | iR |
std::list< IPAddress >::iterator | rI |
unsigned int | maxPlayerLeafs |
unsigned int | treeWidth |
int | lock |
int | subSpaceId |
int | actions |
Friends | |
std::ostream & | operator<< (std::ostream &Stream, LoadBalancingTree t) |
LoadBalancingTree::~LoadBalancingTree | ( | ) |
LoadBalancingTree::LoadBalancingTree | ( | ) |
00021 { 00022 this->root = new TreeNode(); 00023 this->root->parent = NULL; 00024 this->lastTreeNode = this->root; 00025 this->size=0; 00026 this->lock = 0; 00027 actions=0; 00028 replacedIntermediateNodes = 0; 00029 }
LoadBalancingTree::LoadBalancingTree | ( | int | subSpaceId, | |
unsigned int | maxPlayerLeafs, | |||
unsigned int | treeWidth | |||
) |
00031 { 00032 this->maxPlayerLeafs = maxPlayerLeafs; 00033 this->treeWidth = treeWidth; 00034 this->root = new TreeNode(); 00035 this->root->parent = NULL; 00036 this->lastTreeNode = root; 00037 this->size = 0; 00038 this->lock = 0; 00039 this->subSpaceId = subSpaceId; 00040 actions=0; 00041 replacedIntermediateNodes = 0; 00042 }
std::list< TreeMessage > LoadBalancingTree::addPlayer | ( | int | playerId, | |
IPAddress | playerIp | |||
) |
00045 { 00046 actions++; 00047 std::list<TreeMessage> returnList; 00048 bool alreadyWaiting = false; 00049 for( iW = waitingNodes.begin() ; iW != waitingNodes.end(); ++iW ) { 00050 if( iW->playerId == playerId ) { 00051 alreadyWaiting = true; 00052 } 00053 } 00054 if ( searchPlayer(playerId).parent != NULL || alreadyWaiting ) { 00055 return returnList; 00056 } 00057 TreeMessage msg; 00058 if( ( (size > ( (usedIntermediateNodes.size() + readyIntermediateNodes.size()) * maxPlayerLeafs) + 0.5*maxPlayerLeafs) && lock == 0) || (size > (usedIntermediateNodes.size() + 2)*maxPlayerLeafs ) ) { 00059 lock = 1; 00060 TreeMessage newIntMsg; 00061 newIntMsg.type=2; 00062 returnList.push_back( newIntMsg); 00063 } 00064 msg.type = 0; 00065 msg.playerip = playerIp; 00066 if( freed.size() > 0 ) { 00067 TreeNode* foo = freed.front(); 00068 msg.destip = foo->destip; 00069 if( foo->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg); 00070 TreeNode blub = TreeNode( foo , playerId, playerIp); 00071 foo->leafs.push_back( blub ); 00072 freed.pop_front(); 00073 size++; 00074 } 00075 else if ( lastTreeNode->leafs.size() < maxPlayerLeafs) { 00076 msg.destip = lastTreeNode->destip; 00077 if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg); 00078 lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp) ); 00079 size++; 00080 } 00081 else { 00082 if( readyIntermediateNodes.size() > 0 ) { 00083 TreeNode* parent = lastTreeNode->parent; 00084 if( parent == NULL ) { 00085 parent = root; 00086 } 00087 00088 IPAddress destip = readyIntermediateNodes.front(); 00089 readyIntermediateNodes.pop_front(); 00090 usedIntermediateNodes.push_back( destip ); 00091 if( lastTreeNode != root && (parent->childs.size() < treeWidth) ) { 00092 //lastTreeNode->parent has enough space for another child 00093 parent->childs.push_back( TreeNode(parent, destip) ); 00094 lastTreeNode = &( parent->childs.back()); // set lastTreeNode to the new child 00095 msg.destip = lastTreeNode->destip; 00096 if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg); 00097 lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp)); // add player to new child 00098 size++; 00099 } 00100 else { 00101 lastTreeNode = searchLeftmostNode() ; 00102 lastTreeNode->childs.push_back( TreeNode(lastTreeNode, destip) ); 00103 // Add |treeWidth| Players to the new Node. (specified in protocoll) 00104 TreeNode tmp; 00105 uint max = treeWidth; 00106 if( lastTreeNode->leafs.size() < treeWidth ) max= lastTreeNode->leafs.size(); 00107 for( unsigned int i=0; i < max; ++i) { 00108 tmp = lastTreeNode->leafs.front(); 00109 TreeMessage msg1; 00110 msg1.type = 1; 00111 msg1.destip = lastTreeNode->destip; 00112 msg1.playerip = tmp.destip; 00113 if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg1 ); 00114 00115 TreeMessage msg2; 00116 msg2.type = 0; 00117 msg2.destip = lastTreeNode->childs.back().destip; //=new Child 00118 msg2.playerip = tmp.destip; 00119 returnList.push_back( msg2 ); 00120 tmp.parent = &(lastTreeNode->childs.back()); 00121 lastTreeNode->childs.back().leafs.push_back(tmp); 00122 lastTreeNode->leafs.pop_front(); 00123 } 00124 lastTreeNode = &( lastTreeNode->childs.back() ); 00125 if( treeWidth == maxPlayerLeafs ) { // Not enough space for new Node (only if treeWidth=maxPlayerLeafs) 00126 waitingNodes.push_back( TreeNode( lastTreeNode, playerId, playerIp) ); 00127 } 00128 else { 00129 msg.destip = lastTreeNode->destip; 00130 returnList.push_back( msg); 00131 lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp)); //add Player to the new Node 00132 size++; 00133 } 00134 00135 } 00136 } 00137 else { 00138 waitingNodes.push_back( TreeNode( lastTreeNode, playerId, playerIp) ); 00139 } 00140 } 00141 return returnList; 00142 }
std::list< TreeMessage > LoadBalancingTree::removePlayer | ( | int | playerId | ) |
00144 { 00145 00146 actions++; 00147 std::list<TreeMessage> returnList; 00148 NodePos playerPos = searchPlayer(playerId); 00149 if ( playerPos.parent != NULL) { 00150 size--; 00151 TreeMessage msg; 00152 msg.type = 1; 00153 msg.destip = playerPos.parent->destip; 00154 msg.playerip = playerPos.it->destip; 00155 returnList.push_back( msg ); 00156 playerPos.parent->leafs.erase(playerPos.it); 00157 freed.push_back( playerPos.parent ); 00158 if( freed.size() > maxPlayerLeafs + 1 ) { 00159 lastTreeNode = searchLastNode(); 00160 // We have to delete one Intermediate TreeNode 00161 TreeNode tmp; 00162 while( lastTreeNode->leafs.size() > 0 && freed.size() > 0 ) { 00163 if( &*freed.front() != &*lastTreeNode ) { 00164 tmp = lastTreeNode->leafs.front(); 00165 TreeMessage msg1; 00166 msg1.type = 0; 00167 msg1.playerip = tmp.destip; 00168 msg1.destip = freed.front()->destip; 00169 tmp.parent = freed.front(); 00170 freed.front()->leafs.push_back( tmp ); 00171 returnList.push_back(msg1); 00172 TreeMessage msg2; 00173 msg2.type = 1; 00174 msg2.playerip = tmp.destip; 00175 msg2.destip = lastTreeNode->destip; 00176 returnList.push_back(msg2); 00177 lastTreeNode->leafs.pop_front(); 00178 } 00179 freed.pop_front(); 00180 } 00181 //Check if we have an entry in free by ourself 00182 std::list<TreeNode*>::iterator f = freed.begin(); 00183 while( f != freed.end() ) { 00184 if( &**f == &*lastTreeNode ) { 00185 f = freed.erase(f); 00186 } 00187 else { ++f; } 00188 } 00189 //check if we're in replace 00190 f = inReplace.begin(); 00191 while( f != inReplace.end() ) { 00192 if( &**f == &*lastTreeNode ) { 00193 f = inReplace.erase(f); 00194 } 00195 else { ++f; } 00196 } 00197 //Remove us from usedIntermediateNodes 00198 std::list<IPAddress>::iterator ip = usedIntermediateNodes.begin(); 00199 while( ip != usedIntermediateNodes.end() ) { 00200 if( *ip == lastTreeNode->destip ) { 00201 usedIntermediateNodes.erase(ip); 00202 break; 00203 } 00204 else { ++ip; } 00205 } 00206 TreeMessage msg3; 00207 msg3.type=3; 00208 msg3.destip = lastTreeNode->destip; 00209 returnList.push_back( msg3 ); 00210 00211 TreeNode* toRemoved = lastTreeNode; 00212 lastTreeNode = lastTreeNode->parent; 00213 if( lastTreeNode == NULL ) lastTreeNode = root; 00214 for(lastTreeNode->ic = lastTreeNode->childs.begin() ; lastTreeNode->ic != lastTreeNode->childs.end(); ++(lastTreeNode->ic) ) { 00215 if( &*(lastTreeNode->ic) == toRemoved ) { 00216 lastTreeNode->childs.erase(lastTreeNode->ic); 00217 break; 00218 } 00219 } 00220 00221 if( lastTreeNode->childs.size() > 0 ) { 00222 lastTreeNode = &( lastTreeNode->childs.back() ); 00223 } 00224 } 00225 } 00226 else { 00227 bool found = false; 00228 for( iW = waitingNodes.begin(); iW != waitingNodes.end(); ++iW ) { 00229 if( iW->playerId == playerId ) { 00230 waitingNodes.erase(iW); 00231 found = true; 00232 break; 00233 } 00234 } 00235 } 00236 return returnList; 00237 }
std::list< TreeMessage > LoadBalancingTree::removePlayer | ( | IPAddress | playerIp | ) |
00239 { 00240 actions++; 00241 std::list<TreeMessage> returnList; 00242 NodePos playerPos = searchPlayer(playerIp); 00243 if( playerPos.parent != NULL ) { 00244 returnList = removePlayer( playerPos.it->playerId ); 00245 std::list<TreeNode*> toReplace = searchNodes( playerIp); 00246 if( toReplace.size() > 0 ) { 00247 while( toReplace.size() > 0 ) { 00248 inReplace.push_back ( toReplace.front() ); 00249 toReplace.pop_front(); 00250 TreeMessage msg; 00251 msg.type = 2; 00252 returnList.push_back( msg ); 00253 } 00254 } 00255 } 00256 return returnList; 00257 }
std::list< IPAddress > LoadBalancingTree::getList | ( | ) |
00278 { 00279 std::list<IPAddress> ipList; 00280 for(root->ic = root->childs.begin(); root->ic != root->childs.end(); ++root->ic) { 00281 ipList.push_back(root->ic->destip); 00282 } 00283 for(root->il = root->leafs.begin(); root->il != root->leafs.end() ; ++root->il) { 00284 ipList.push_back(root->il->destip); 00285 } 00286 for( iR = inReplace.begin(); iR != inReplace.end(); ++iR) { 00287 TreeNode* visit = *iR; 00288 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++(visit->ic) ) { 00289 ipList.push_back( visit->ic->destip); 00290 } 00291 for( visit->il = visit->leafs.begin(); visit->il != visit->leafs.end(); ++(visit->il) ) { 00292 ipList.push_back( visit->il->destip); 00293 } 00294 } 00295 00296 for( iW = waitingNodes.begin(); iW != waitingNodes.end(); ++iW) { 00297 ipList.push_back( iW->destip ); 00298 } 00299 return ipList; 00300 }
std::list< PlayerNode > LoadBalancingTree::getAllPlayers | ( | ) |
00303 { 00304 std::list<PlayerNode> returnList; 00305 00306 std::list<TreeNode*> queue; 00307 std::list<TreeNode*>::iterator q; 00308 queue.push_back( root ); 00309 TreeNode* visit; 00310 std::list<TreeNode>::iterator il; 00311 std::list<TreeNode>::iterator ic; 00312 00313 while ( queue.size() > 0 ) { 00314 visit = queue.front(); 00315 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) { 00316 returnList.push_back( PlayerNode( il->playerId, il->destip, 0, 0) ); 00317 } 00318 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00319 queue.push_back( &(*ic) ); 00320 } 00321 queue.pop_front(); 00322 } 00323 return returnList; 00324 }
std::list< IPAddress > LoadBalancingTree::getAllNodes | ( | ) |
00326 { 00327 std::list<IPAddress> returnList; 00328 00329 std::list<TreeNode*> queue; 00330 std::list<TreeNode*>::iterator q; 00331 queue.push_back( root ); 00332 TreeNode* visit; 00333 std::list<TreeNode>::iterator il; 00334 std::list<TreeNode>::iterator ic; 00335 00336 while ( queue.size() > 0 ) { 00337 visit = queue.front(); 00338 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) { 00339 returnList.push_back( il->destip); 00340 } 00341 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00342 queue.push_back( &(*ic) ); 00343 returnList.push_back(ic->destip); 00344 } 00345 queue.pop_front(); 00346 } 00347 return returnList; 00348 }
std::list< IPAddress > LoadBalancingTree::getAllIntNodes | ( | ) |
00349 { 00350 std::list<IPAddress> returnList; 00351 std::list<TreeNode*> queue; 00352 std::list<TreeNode*>::iterator q; 00353 queue.push_back( root ); 00354 TreeNode* visit; 00355 std::list<TreeNode>::iterator ic; 00356 00357 while ( queue.size() > 0 ) { 00358 visit = queue.front(); 00359 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00360 queue.push_back( &(*ic) ); 00361 returnList.push_back(ic->destip); 00362 } 00363 queue.pop_front(); 00364 } 00365 return returnList; 00366 }
std::list< TreeMessage > LoadBalancingTree::addIntermediateNode | ( | IPAddress | destip | ) |
00498 { 00499 std::list<TreeMessage> returnList; 00500 lock = 0; 00501 if( inReplace.size() > 0 ) { 00502 returnList = replace(destip); 00503 } 00504 else { 00505 readyIntermediateNodes.push_back( destip ); 00506 uint i = 0; 00507 while( waitingNodes.size() > 0 && i < maxPlayerLeafs ) { 00508 TreeNode tmp2 = waitingNodes.front(); 00509 waitingNodes.pop_front(); 00510 std::list<TreeMessage> tmp = this->addPlayer( tmp2.playerId, tmp2.destip); 00511 while( tmp.size() > 0 ) { 00512 returnList.push_back( tmp.front() ); 00513 tmp.pop_front(); 00514 } 00515 i++; 00516 } 00517 } 00518 return returnList; 00519 00520 }
std::list< IPAddress > LoadBalancingTree::exchangeNode | ( | IPAddress | oldNodeIp, | |
IPAddress | newNodeIp | |||
) |
00259 { 00260 std::list<IPAddress> returnList; 00261 std::list<TreeNode*> toReplace = searchNodes(oldNodeIp); 00262 while( toReplace.size() > 0 ) { 00263 inReplace.push_front( toReplace.front() ); 00264 std::list<TreeNode>::iterator i; 00265 for( i = toReplace.front()->childs.begin() ; i != toReplace.front()->childs.end(); ++i) { 00266 returnList.push_back( i->destip); 00267 } 00268 for( i = toReplace.front()->leafs.begin() ; i != toReplace.front()->leafs.end(); ++i) { 00269 returnList.push_back( i->destip); 00270 } 00271 replace(newNodeIp); 00272 toReplace.pop_front(); //missing messages 00273 00274 } 00275 return returnList; 00276 }
std::list< TreeMessage > LoadBalancingTree::replace | ( | IPAddress | newNodeIp | ) |
00480 { 00481 std::list<TreeMessage> returnList; 00482 if( inReplace.size() > 0 ) { 00483 TreeNode* node = inReplace.front(); 00484 node->destip = newNodeIp; 00485 for(node->il = node->leafs.begin(); node->il != node->leafs.end(); ++(node->il) ) { 00486 TreeMessage msg1; 00487 msg1.type = 0; 00488 msg1.playerip = node->il->destip; 00489 msg1.destip = newNodeIp; 00490 returnList.push_back(msg1); 00491 } 00492 replacedIntermediateNodes++; 00493 inReplace.pop_front(); 00494 } 00495 return returnList; 00496 }
std::list< TreeNode > LoadBalancingTree::serialize | ( | ) |
00522 { 00523 std::list<TreeNode> returnVector; 00524 std::list<TreeNode*> queue; 00525 queue.push_back( root ); 00526 std::list<TreeNode>::iterator ic; 00527 std::list<TreeNode>::iterator il; 00528 std::list<TreeNode*>::iterator ir; 00529 std::list<IPAddress>::iterator ip; 00530 TreeNode* visit; 00531 while ( queue.size() > 0 ) { 00532 visit = queue.front(); 00533 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00534 queue.push_back( &(*ic) ); 00535 returnVector.push_back(TreeNode(-1, ic->destip)); 00536 } 00537 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) { 00538 returnVector.push_back( TreeNode(il->playerId, il->destip) ); 00539 } 00540 returnVector.push_back( TreeNode(-5, (IPAddress) "127.0.0.1" ) ); 00541 queue.pop_front(); 00542 } 00543 returnVector.push_back( TreeNode(-6, (IPAddress) "127.0.0.1" ) ); 00544 for(ip = readyIntermediateNodes.begin() ; ip != readyIntermediateNodes.end() ; ++ip) { 00545 returnVector.push_back( TreeNode( -3, (*ip) ) ); 00546 } 00547 returnVector.push_back( TreeNode(-7, (IPAddress) "127.0.0.1" ) ); 00548 for(il = waitingNodes.begin(); il != waitingNodes.end(); ++il ) { 00549 returnVector.push_back( TreeNode(il->playerId, il->destip) ); 00550 } 00551 returnVector.push_back( TreeNode(-8, (IPAddress) "127.0.0.1" ) ); 00552 00553 for(ir = inReplace.begin(); ir != inReplace.end(); ++ir) { 00554 returnVector.push_back( TreeNode( -2 , (*ir)->destip ) ); 00555 } 00556 returnVector.push_back( TreeNode( -10 - replacedIntermediateNodes, (IPAddress) "127.0.0.1") ); 00557 return returnVector; 00558 }
void LoadBalancingTree::rebuildTree | ( | std::list< TreeNode > | source | ) |
00560 { 00561 std::list<TreeNode>::iterator i= source.begin(); 00562 this->root->parent = NULL; 00563 int state=0; 00564 std::list<TreeNode*> queue; 00565 std::list<TreeNode*>::iterator q; 00566 queue.push_back( root ); 00567 for( i = source.begin(); i != source.end(); ++i ) { 00568 if( state == 0) { 00569 if( i->playerId == -1 ) { 00570 // create a new child in queue.front 00571 (queue.front())->childs.push_back( TreeNode( queue.front(), i->playerId, i->destip ) ); 00572 queue.push_back( &((queue.front())->childs.back()) ); 00573 } 00574 else if( i->playerId == -5 ) { 00575 // go to next child 00576 uint k=0; 00577 // has actual node some free leaf slots? 00578 for(k=queue.front()->leafs.size(); k < maxPlayerLeafs - treeWidth; ++k) { 00579 freed.push_back(queue.front()); 00580 } 00581 queue.pop_front(); 00582 } 00583 else if ( i->playerId > 0) { 00584 (queue.front())->leafs.push_back( TreeNode( queue.front(), i->playerId, i->destip ) ); 00585 } 00586 else if ( i->playerId == -6 ) { 00587 state = 1; 00588 } 00589 } 00590 else if ( state == 1 ) { 00591 if ( i->playerId == -3 ) { 00592 readyIntermediateNodes.push_back( i->destip ); 00593 } 00594 else if ( i->playerId == -7 ) { 00595 state = 2; 00596 } 00597 } 00598 else if ( state == 2) { 00599 if ( i->playerId > 0 ) { 00600 waitingNodes.push_back( TreeNode(queue.front(), i->playerId, i->destip ) ); 00601 } 00602 else if( i->playerId == -8 ) { 00603 state = 3; 00604 } 00605 } 00606 else if ( state == 3) { 00607 if ( i->playerId == -2 ) { 00608 std::list<TreeNode*> pos = searchNodes( i->destip ); 00609 std::list<TreeNode*>::iterator p; 00610 for( p = pos.begin(); p != pos.end(); ++p ) { 00611 if( (*p)->playerId == -1 ) { 00612 inReplace.push_back( *p ); 00613 } 00614 } 00615 } 00616 else if( i->playerId < -10) { 00617 replacedIntermediateNodes = abs(i->playerId) - 10; 00618 } 00619 } 00620 } 00621 lastTreeNode = searchLeftmostNode(); 00622 }
void LoadBalancingTree::printTree | ( | ) |
00623 { 00624 std::cout << root << " " << lastTreeNode << " " << " " << waitingNodes.size() << " " << inReplace.size() << " " <<freed.size() << "\n"; 00625 std::list<TreeNode*> queue; 00626 queue.push_back( root ); 00627 std::list<TreeNode>::iterator ic; 00628 TreeNode* visit; 00629 int num= 0; 00630 int layer=0; 00631 while ( queue.size() > 0 ) { 00632 visit = queue.front(); 00633 std::cout << "NodeNum: " << num << " ChildSize: " << visit->childs.size() << " LeafSize: " << visit->leafs.size() << " NodeIp: " << visit->destip << " | "; 00634 if( num % treeWidth == 0) std::cout << " ### "; 00635 if( num == pow(treeWidth, layer) || num == 0 ) { 00636 std::cout << "\n\n"; 00637 layer++; 00638 } 00639 num++; 00640 00641 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00642 queue.push_back( &(*ic) ); 00643 } 00644 queue.pop_front(); 00645 } 00646 }
NodePos LoadBalancingTree::searchPlayer | ( | int | playerId | ) | [protected] |
00368 { 00369 std::list<TreeNode*> queue; 00370 std::list<TreeNode*>::iterator q; 00371 queue.push_back( root ); 00372 TreeNode* visit; 00373 std::list<TreeNode>::iterator il; 00374 std::list<TreeNode>::iterator ic; 00375 00376 while ( queue.size() > 0 ) { 00377 visit = queue.front(); 00378 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) { 00379 if( il->playerId == playerId ) { 00380 NodePos playerPos; 00381 playerPos.parent = il->parent; 00382 playerPos.it = il; 00383 return playerPos; 00384 } 00385 } 00386 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00387 queue.push_back( &(*ic) ); 00388 } 00389 queue.pop_front(); 00390 } 00391 NodePos playerPos; 00392 playerPos.parent = NULL; 00393 return playerPos; 00394 }
NodePos LoadBalancingTree::searchPlayer | ( | IPAddress | playerIp | ) | [protected] |
00398 { 00399 std::list<TreeNode*> queue; 00400 std::list<TreeNode*>::iterator q; 00401 queue.push_back( root ); 00402 TreeNode* visit; 00403 std::list<TreeNode>::iterator il; 00404 std::list<TreeNode>::iterator ic; 00405 00406 while ( queue.size() > 0 ) { 00407 visit = queue.front(); 00408 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) { 00409 if( il->destip == playerIp ) { 00410 NodePos playerPos; 00411 playerPos.parent = il->parent; 00412 playerPos.it = il; 00413 return playerPos; 00414 } 00415 } 00416 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00417 queue.push_back( &(*ic) ); 00418 } 00419 queue.pop_front(); 00420 } 00421 NodePos playerPos; 00422 playerPos.parent = NULL; 00423 return playerPos; 00424 }
std::list< TreeNode * > LoadBalancingTree::searchNodes | ( | IPAddress | playerIp | ) | [protected] |
00460 { 00461 std::list<TreeNode*> returnList; 00462 std::list<TreeNode*> queue; 00463 std::list<TreeNode*>::iterator q; 00464 queue.push_back( root ); 00465 std::list<TreeNode>::iterator ic; 00466 TreeNode* visit; 00467 while( queue.size() > 0 ) { 00468 visit = queue.front(); 00469 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00470 if( ic->destip == destip ) { 00471 returnList.push_back( &(*ic) ); 00472 } 00473 queue.push_back( &(*ic) ); 00474 } 00475 queue.pop_front(); 00476 } 00477 return returnList; 00478 }
TreeNode * LoadBalancingTree::searchLeftmostNode | ( | ) | [protected] |
00426 { 00427 std::list<TreeNode*> queue; 00428 std::list<TreeNode*>::iterator q; 00429 queue.push_back( root ); 00430 TreeNode* visit; 00431 while ( queue.size() > 0 ) { 00432 visit = queue.front(); 00433 if( visit->childs.size() < treeWidth ) { 00434 return visit; 00435 } 00436 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++visit->ic) { 00437 queue.push_back( &(*(visit->ic)) ); 00438 } 00439 queue.pop_front(); 00440 } 00441 return root; 00442 }
TreeNode * LoadBalancingTree::searchLastNode | ( | ) | [protected] |
00444 { 00445 std::list<TreeNode*> queue; 00446 std::list<TreeNode*>::iterator q; 00447 queue.push_back( root ); 00448 TreeNode* visit = root; 00449 while ( queue.size() > 0 ) { 00450 visit = queue.front(); 00451 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++visit->ic) { 00452 queue.push_back( &(*(visit->ic)) ); 00453 } 00454 queue.pop_front(); 00455 } 00456 return visit; 00457 }
std::ostream& operator<< | ( | std::ostream & | Stream, | |
LoadBalancingTree | t | |||
) | [friend] |
00648 { 00649 std::ostream& output = Stream << "Size: " << t.size << "readyIntermediateNodes " << t.readyIntermediateNodes.size() << "InReplace: " << t.inReplace.size() << " Freed: " << t.freed.size() << "\n\n"; 00650 00651 std::list<TreeNode*> queue; 00652 queue.push_back( t.root ); 00653 std::list<TreeNode>::iterator ic; 00654 TreeNode* visit; 00655 int num= 0; 00656 int layer=0; 00657 while ( queue.size() > 0 ) { 00658 visit = queue.front(); 00659 output << "NodeNum: " << num << " ChildSize: " << visit->childs.size() << " LeafSize: " << visit->leafs.size() << " NodeIp: " << visit->destip << " | "; 00660 if( num % t.treeWidth == 0) output << " ### "; 00661 if( num == pow(t.treeWidth, layer) || num == 0 ) { 00662 output << "\n\n"; 00663 layer++; 00664 } 00665 num++; 00666 00667 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) { 00668 queue.push_back( &(*ic) ); 00669 } 00670 queue.pop_front(); 00671 } 00672 return output; 00673 }
unsigned int LoadBalancingTree::size |
std::list<IPAddress> LoadBalancingTree::readyIntermediateNodes |
std::list<IPAddress> LoadBalancingTree::usedIntermediateNodes |
TreeNode* LoadBalancingTree::root [protected] |
TreeNode* LoadBalancingTree::lastTreeNode [protected] |
std::list<TreeNode> LoadBalancingTree::waitingNodes [protected] |
std::list<TreeNode>::iterator LoadBalancingTree::iW [protected] |
std::list<TreeNode*> LoadBalancingTree::freed [protected] |
std::list<TreeNode*>::iterator LoadBalancingTree::f [protected] |
std::list<TreeNode*> LoadBalancingTree::inReplace [protected] |
std::list<TreeNode*>::iterator LoadBalancingTree::iR [protected] |
std::list<IPAddress>::iterator LoadBalancingTree::rI [protected] |
unsigned int LoadBalancingTree::maxPlayerLeafs [protected] |
unsigned int LoadBalancingTree::treeWidth [protected] |
int LoadBalancingTree::lock [protected] |
int LoadBalancingTree::subSpaceId [protected] |
int LoadBalancingTree::actions [protected] |