53 SelectionHeap::SelectionHeap(
63 SelectionHeap::~SelectionHeap(
70 SelectionHeap::resize(
84 SelectionHeap::insert(
88 if( heapSize >= maxHeapSize )
return FAILED_BY_FULL;
89 heap[++heapSize] = inSolver;
96 SelectionHeap::remove(
101 heap[1] = heap[heapSize];
115 SelectionHeap::toString(
118 std::ostringstream os;
119 os <<
"--- selection heap ---" << std::endl;
120 os <<
"maxHeapSize: " << maxHeapSize << std::endl;
121 os <<
"heapSize: " << heapSize << std::endl;
122 for( std::size_t i = 1; i <= heapSize; i++ )
124 os <<
"heap[" << i <<
"]->rank: " 125 << heap[i]->
getRank() << std::endl
126 <<
"heap[" << i <<
"]->status: " 127 <<
static_cast<int>(heap[i]->getStatus()) << std::endl
128 <<
"heap[" << i <<
"]->bestBound: " 129 << heap[i]->getBestDualBoundValue() << std::endl
130 <<
"heap[" << i <<
"]->numOfNodesLeft: " 131 << heap[i]->getNumOfNodesLeft() << std::endl
132 <<
"heap[" << i <<
"]->numOfDiff: " 133 << heap[i]->getNumOfDiffNodesLeft() << std::endl
134 <<
"heap[" << i <<
"]->collectingMode: " 135 << heap[i]->isInCollectingMode() << std::endl;
141 DescendingSelectionHeap::DescendingSelectionHeap(
152 double newDualBoundValue
210 while (
heap[pos/2] != NULL &&
211 (
heap[pos/2]->getBestDualBoundValue()
236 (
heap[j]->getBestDualBoundValue()
237 <
heap[j+1]->getBestDualBoundValue() ) ) j++;
261 double newDualBoundValue
318 while (
heap[pos/2] != NULL &&
319 (
heap[pos/2]->getBestDualBoundValue()
343 (
heap[j]->getBestDualBoundValue()
344 >
heap[j+1]->getBestDualBoundValue() ) ) j++;
422 std::ostringstream os;
423 os <<
"--- selection heap ---" << std::endl;
425 os <<
"heapSize: " <<
heapSize << std::endl;
426 for( std::size_t i = 1; i <=
heapSize; i++ )
428 os <<
"heap[" << i <<
"]->rank: " 430 <<
"heap[" << i <<
"]->status: " 432 <<
"heap[" << i <<
"]->bestBound: " 433 <<
heap[i]->getBestDualBoundValue() << std::endl
434 <<
"heap[" << i <<
"]->numOfNodesLeft: " 436 <<
"heap[" << i <<
"]->numOfDiff: " 438 <<
"heap[" << i <<
"]->collectingMode: " 456 double newDualBoundValue
514 while (
heap[pos/2] != NULL &&
515 (
heap[pos/2]->getBestDualBoundValue()
540 (
heap[j]->getBestDualBoundValue()
541 <
heap[j+1]->getBestDualBoundValue() ) ) j++;
565 double newDualBoundValue
622 while (
heap[pos/2] != NULL &&
623 (
heap[pos/2]->getBestDualBoundValue()
647 (
heap[j]->getBestDualBoundValue()
648 >
heap[j+1]->getBestDualBoundValue() ) ) j++;
665 int nGoodNodesInNodePool,
666 double averageDualBoundGain
672 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
676 map<int, BbParaSolverPoolElementPtr>::iterator p;
679 p = inactiveSolvers.find(rank);
680 if( p != inactiveSolvers.end() )
682 if( p->second->getRank() != rank ||
687 inactiveSolvers.erase(p);
708 if( ( (nDualBoundGainTesting*2) + nGoodNodesInNodePool ) < getNumInactiveSolvers() +
719 nDualBoundGainTesting++;
730 paraNode->
send(paraComm, rank);
744 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
748 map<int, BbParaSolverPoolElementPtr>::iterator p;
751 p = inactiveSolvers.find(rank);
752 if( p != inactiveSolvers.end() )
754 if( p->second->getRank() != rank ||
759 inactiveSolvers.erase(p);
774 nNodesInSolvers += nNodesLeft;
785 int nGoodNodesInNodePool,
786 double averageDualBoundGain
789 map<int, BbParaSolverPoolElementPtr>::iterator p;
794 if( !paraRacingSolverPool )
796 p = inactiveSolvers.begin();
797 if( p == inactiveSolvers.end() )
801 rank = p->second->getRank();
805 for( p = inactiveSolvers.begin(); p != inactiveSolvers.end(); ++p )
810 rank = p->second->getRank();
814 if( p == inactiveSolvers.end() )
827 inactiveSolvers.erase(p);
829 (!rampUpPhase) && (!paraRacingSolverPool ) &&
830 inactiveSolvers.size() >
841 if( ( (nDualBoundGainTesting*2) + nGoodNodesInNodePool ) < getNumInactiveSolvers() +
852 nDualBoundGainTesting++;
863 paraNode->
send(paraComm, rank);
875 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
879 map<int, BbParaSolverPoolElementPtr>::iterator p;
882 p = activeSolvers.find(rank);
883 if( p != activeSolvers.end() )
885 if( p->second->getRank() != rank ||
890 if( collectingMode || p->second->isCandidateOfCollecting() )
892 THROW_LOGICAL_ERROR3(
"Rank = ", rank,
" should not be in colleting mode and shuould not be a candidate of collecting.");
894 p->second->addSubtreeRoot(paraNode);
908 std::cout <<
"Status = " <<
static_cast<int>(pool[
SOLVER_POOL_INDEX( rank )]->getStatus()) << std::endl;
920 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
924 map<int, BbParaSolverPoolElementPtr>::iterator p;
927 p = activeSolvers.find(rank);
928 if( p != activeSolvers.end() )
930 if( p->second->getRank() != rank ||
941 p->second->makeSubtreeRootCurrent(paraNode);
954 std::cout <<
"Status = " <<
static_cast<int>(pool[
SOLVER_POOL_INDEX( rank )]->getStatus()) << std::endl;
966 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
970 map<int, BbParaSolverPoolElementPtr>::iterator p;
973 p = activeSolvers.find(rank);
974 if( p != activeSolvers.end() )
976 if( p->second->getRank() != rank ||
987 p->second->removeSubtreeRoot(paraNode);
1000 std::cout <<
"Status = " <<
static_cast<int>(pool[
SOLVER_POOL_INDEX( rank )]->getStatus()) << std::endl;
1054 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1058 map<int, BbParaSolverPoolElementPtr>::iterator p;
1061 p = activeSolvers.find(rank);
1062 if( p != activeSolvers.end() )
1064 if( p->second->getRank() != rank ||
1075 BbParaNode *node = p->second->extractSubtreeRoot(paraNode);
1096 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1100 map<int, BbParaSolverPoolElementPtr>::iterator p;
1103 p = activeSolvers.find(rank);
1104 if( p != activeSolvers.end() )
1106 if( p->second->getRank() != rank ||
1116 return p->second->getSelfSplitNodes();
1134 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1146 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1150 map<int, BbParaSolverPoolElementPtr>::iterator p;
1153 p = activeSolvers.find(rank);
1154 if( p != activeSolvers.end() )
1156 if( p->second->getRank() != rank ||
1166 return p->second->deleteCurrentNode();
1179 std::cout <<
"Status = " <<
static_cast<int>(pool[
SOLVER_POOL_INDEX( rank )]->getStatus()) << std::endl;
1189 long long numOfNodesSolved,
1193 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1198 if( breakingFirstSubtree && rank == 1 )
1200 breakingFirstSubtree =
false;
1202 sendSwitchOutCollectingModeIfNecessary( rank );
1203 map<int, BbParaSolverPoolElementPtr>::iterator p;
1208 p = activeSolvers.find(rank);
1209 if( p != activeSolvers.end() )
1211 if( p->second->getRank() != rank ||
1216 if( numOfNodesSolved >= 0 )
1218 nNodesSolvedInSolvers += numOfNodesSolved - p->second->getNumOfNodesSolved();
1221 nNodesInSolvers -= p->second->getNumOfNodesLeft();
1232 nCollectingModeSolvers--;
1234 selectionHeap->top()->getNumOfNodesLeft() > 1 &&
1235 selectionHeap->top()->isGenerator() &&
1236 (!selectionHeap->top()->isCollectingProhibited()) &&
1237 selectionHeap->top()->isOutCollectingMode() )
1242 switchInCollectingToSolver(selectionHeap->top()->getRank(), paraNodePool);
1245 if( p->second->isCandidateOfCollecting() )
1247 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
1248 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
1249 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
1251 if( pCandidate->second->getRank() == rank )
1254 assert( pCandidate != candidatesOfCollectingModeSolvers.end() );
1255 pCandidate->second->setCandidateOfCollecting(
false);
1256 candidatesOfCollectingModeSolvers.erase(pCandidate);
1258 activeSolvers.erase(p);
1270 if( collectingModeSolverHeap && pool[
SOLVER_POOL_INDEX(rank)]->isInCollectingMode() )
1286 long long numOfNodesSolved,
1287 int numOfSelfSplitNodesLeft,
1291 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1296 if( breakingFirstSubtree && rank == 1 )
1298 breakingFirstSubtree =
false;
1300 sendSwitchOutCollectingModeIfNecessary( rank );
1301 map<int, BbParaSolverPoolElementPtr>::iterator p;
1304 p = activeSolvers.find(rank);
1305 if( p != activeSolvers.end() )
1307 if( p->second->getRank() != rank ||
1312 nNodesSolvedInSolvers += numOfNodesSolved - p->second->getNumOfNodesSolved();
1314 nNodesInSolvers -= p->second->getNumOfNodesLeft();
1325 nCollectingModeSolvers--;
1326 if( selectionHeap->top()->getNumOfNodesLeft() > 1 &&
1327 selectionHeap->top()->isGenerator() &&
1328 (!selectionHeap->top()->isCollectingProhibited()) &&
1329 selectionHeap->top()->isOutCollectingMode() )
1334 switchInCollectingToSolver(selectionHeap->top()->getRank(), paraNodePool);
1337 if( p->second->isCandidateOfCollecting() )
1339 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
1340 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
1341 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
1343 if( pCandidate->second->getRank() == rank )
1346 assert( pCandidate != candidatesOfCollectingModeSolvers.end() );
1347 pCandidate->second->setCandidateOfCollecting(
false);
1348 candidatesOfCollectingModeSolvers.erase(pCandidate);
1350 activeSolvers.erase(p);
1362 if( collectingModeSolverHeap && pool[
SOLVER_POOL_INDEX(rank)]->isInCollectingMode() )
1369 if( collectingModeSolverHeap && pool[
SOLVER_POOL_INDEX(rank)]->isInCollectingMode() )
1382 activateSolver(rank, node, numOfSelfSplitNodesLeft);
1392 if( rank < originRank || rank >= (
signed)(originRank +
nSolvers) )
1396 map<int, BbParaSolverPoolElementPtr>::iterator p;
1399 p = activeSolvers.find(rank);
1400 if( p != activeSolvers.end() )
1402 if( p->second->getRank() != rank ||
1407 nNodesSolvedInSolvers -= p->second->getNumOfNodesSolved();
1408 nNodesInSolvers -= p->second->getNumOfNodesLeft();
1409 activeSolvers.erase(p);
1421 if( collectingModeSolverHeap && pool[
SOLVER_POOL_INDEX(rank)]->isInCollectingMode() )
1434 if( !collectingMode )
1438 if( activeSolvers.size() > 0 )
1440 map<int, BbParaSolverPoolElementPtr>::iterator p;
1441 for( p = activeSolvers.begin(); p != activeSolvers.end(); ++p)
1443 int rank = p->second->getRank();
1444 sendSwitchOutCollectingModeIfNecessary(rank);
1457 nDualBoundGainTesting--;
1461 assert(nCollectingModeSolvers == 0);
1462 nCollectingModeSolvers = 0;
1463 candidatesOfCollectingModeSolvers.clear();
1464 collectingMode =
false;
1465 switchOutTime = paraTimer->getElapsedTime();
1482 if( collectingModeSolverHeap )
1486 nCollectingModeSolvers--;
1502 if( collectingModeSolverHeap )
1506 nCollectingModeSolvers--;
1520 getNumInactiveSolvers() +
1527 nCollect = 0 - (nCollect + 1);
1531 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1542 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
1543 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
1544 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
1546 if( pCandidate->second->getRank() == rank )
1549 assert( pCandidate != candidatesOfCollectingModeSolvers.end() );
1550 pCandidate->second->setCandidateOfCollecting(
false);
1551 candidatesOfCollectingModeSolvers.erase(pCandidate);
1554 if( collectingModeSolverHeap )
1558 nCollectingModeSolvers++;
1568 ( beforeInitialCollect || (!beforeInitialCollect && beforeFinishingFirstCollect) ) &&
1576 switchOutTime > 0 &&
1577 (paraTimer->getElapsedTime() - switchOutTime) <
1579 mCollectingNodes < 100 )
1581 if( candidatesOfCollectingModeSolvers.size() > 0 &&
1582 candidatesOfCollectingModeSolvers.begin()->second->getNumOfDiffNodesLeft() < 0 )
1585 if( mCollectingNodes <= 0 ) mCollectingNodes = 1;
1590 if( mCollectingNodes > mMaxCollectingNodes )
1592 mMaxCollectingNodes = mCollectingNodes;
1595 switchOutTime = -1.0;
1598 int nCollect =
static_cast<int>(
1599 getNumInactiveSolvers() +
1603 map<int, BbParaSolverPoolElementPtr>::iterator p;
1604 if( activeSolvers.size() > 0 )
1606 if( breakingFirstSubtree )
1608 for( p = activeSolvers.begin();
1609 p != activeSolvers.end();
1612 if( p->second->getRank() == 1 )
1614 int rank = p->second->getRank();
1616 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1627 if( collectingModeSolverHeap )
1631 nCollectingModeSolvers++;
1638 double globalBestDualBoundValue = selectionHeap->top()->getBestDualBoundValue();
1643 for( p = activeSolvers.begin();
1644 p != activeSolvers.end() && nLimitCollectingModeSolvers > nCollectingModeSolvers;
1647 if( p->second->getNumOfNodesLeft() > 1 &&
1648 ( (p->second->getBestDualBoundValue() - globalBestDualBoundValue) /
1649 max( fabs(globalBestDualBoundValue), 1.0 ) ) < bgap )
1651 int rank = p->second->getRank();
1655 int nCollectPerSolver = std::min(
1660 nCollectPerSolver = 0 - (nCollectPerSolver + 1);
1663 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1672 nCollect -= nCollectPerSolver;
1674 nCollectingModeSolvers++;
1680 if( !paraNodePool->
isEmpty() &&
1681 ( ( (p->second->getBestDualBoundValue() - globalBestDualBoundValue) /
1682 max( fabs(globalBestDualBoundValue), 1.0 ) ) > ( bgap * mBgap ) ) )
1684 int rank = p->second->getRank();
1685 sendSwitchOutCollectingModeIfNecessary( rank );
1694 std::multimap< double, int > boundOrderMap;
1695 for( p = activeSolvers.begin(); p != activeSolvers.end(); ++p )
1697 boundOrderMap.insert(std::make_pair(p->second->getBestDualBoundValue(),p->second->getRank()));
1699 std::multimap< double, int >::iterator pbo;
1700 for( pbo = boundOrderMap.begin();
1701 pbo != boundOrderMap.end() && nLimitCollectingModeSolvers > nCollectingModeSolvers;
1704 int rank = pbo->second;
1710 int nCollectPerSolver = std::min(
1715 nCollectPerSolver = 0 - (nCollectPerSolver + 1);
1718 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1727 nCollect -= nCollectPerSolver;
1730 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
1731 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
1732 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
1734 if( pCandidate->second->getRank() == rank )
1737 assert( pCandidate != candidatesOfCollectingModeSolvers.end() );
1738 pCandidate->second->setCandidateOfCollecting(
false);
1739 candidatesOfCollectingModeSolvers.erase(pCandidate);
1742 assert( collectingModeSolverHeap );
1744 nCollectingModeSolvers++;
1753 if( !paraNodePool->
isEmpty() &&
1754 ( ( (pool[
SOLVER_POOL_INDEX(rank)]->getBestDualBoundValue() - globalBestDualBoundValue) /
1755 max( fabs(globalBestDualBoundValue), 1.0 ) ) > ( bgap * mBgap ) ) )
1757 sendSwitchOutCollectingModeIfNecessary( rank );
1761 sendSwitchOutCollectingModeIfNecessary( rank );
1762 int nCollectPerSolver = std::min(
1767 nCollectPerSolver = 0 - (nCollectPerSolver + 1);
1770 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1779 nCollect -= nCollectPerSolver;
1781 assert( collectingModeSolverHeap );
1789 for(; pbo != boundOrderMap.end() &&
1790 static_cast<int>( candidatesOfCollectingModeSolvers.size() )
1791 < std::min((
int)nLimitCollectingModeSolvers,
1795 int rank = pbo->second;
1800 candidatesOfCollectingModeSolvers.insert(
1810 std::multimap< int, int > nNodesOrderMap;
1811 for( p = activeSolvers.begin(); p != activeSolvers.end(); ++p )
1813 nNodesOrderMap.insert(std::make_pair(p->second->getNumOfNodesLeft(),p->second->getRank()));
1815 std::multimap< int, int >::iterator pno;
1816 for( pno = nNodesOrderMap.begin();
1817 pno != nNodesOrderMap.end() && nLimitCollectingModeSolvers > nCollectingModeSolvers;
1820 int rank = pno->second;
1823 ( (pool[
SOLVER_POOL_INDEX(rank)]->getBestDualBoundValue() - globalBestDualBoundValue) /
1824 max( fabs(globalBestDualBoundValue), 1.0 ) ) < bgap )
1828 int nCollectPerSolver = std::min(
1833 nCollectPerSolver = 0 - (nCollectPerSolver + 1);
1836 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1845 nCollect -= nCollectPerSolver;
1847 nCollectingModeSolvers++;
1853 if( !paraNodePool->
isEmpty() &&
1854 ( ( (pool[
SOLVER_POOL_INDEX(rank)]->getBestDualBoundValue() - globalBestDualBoundValue) /
1855 max( fabs(globalBestDualBoundValue), 1.0 ) ) > ( bgap * mBgap ) ) )
1857 sendSwitchOutCollectingModeIfNecessary( rank );
1865 std::multimap< double, int > boundOrderMap;
1866 for( p = activeSolvers.begin(); p != activeSolvers.end(); ++p )
1868 boundOrderMap.insert(std::make_pair(p->second->getBestDualBoundValue(),p->second->getRank()));
1870 std::multimap< int, int > nNodesOrderMap;
1871 for( p = activeSolvers.begin(); p != activeSolvers.end(); ++p )
1873 nNodesOrderMap.insert(std::make_pair(p->second->getNumOfNodesLeft(),p->second->getRank()));
1875 std::multimap< double, int >::iterator pbo;
1876 std::multimap< int, int >::iterator pno;
1877 pbo = boundOrderMap.begin();
1878 pno = nNodesOrderMap.begin();
1879 bool boundOrderSection =
true;
1880 while( pbo != boundOrderMap.end()
1881 && pno != nNodesOrderMap.end()
1882 && nLimitCollectingModeSolvers > nCollectingModeSolvers )
1885 if( boundOrderSection )
1887 if( pbo != boundOrderMap.end() )
1891 boundOrderSection =
false;
1895 boundOrderSection =
false;
1901 if( pno != nNodesOrderMap.end() )
1905 boundOrderSection =
true;
1907 boundOrderSection =
true;
1913 ( (pool[
SOLVER_POOL_INDEX(rank)]->getBestDualBoundValue() - globalBestDualBoundValue) /
1914 max( fabs(globalBestDualBoundValue), 1.0 ) ) < bgap )
1918 int nCollectPerSolver = std::min(
1923 nCollectPerSolver = 0 - (nCollectPerSolver + 1);
1926 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
1935 nCollect -= nCollectPerSolver;
1937 nCollectingModeSolvers++;
1943 if( !paraNodePool->
isEmpty() &&
1944 ( ( (pool[
SOLVER_POOL_INDEX(rank)]->getBestDualBoundValue() - globalBestDualBoundValue) /
1945 max( fabs(globalBestDualBoundValue), 1.0 ) ) > ( bgap * mBgap ) ) )
1947 sendSwitchOutCollectingModeIfNecessary( rank );
1958 collectingMode =
true;
1959 if( !beforeInitialCollect ) beforeFinishingFirstCollect =
false;
1960 beforeInitialCollect =
false;
1966 long long numOfNodesSolved,
1968 double solverLocalBestDualBound,
1972 map<int, BbParaSolverPoolElementPtr>::iterator p;
1973 p = activeSolvers.find(rank);
1974 if( p != activeSolvers.end() )
1976 if( (numOfNodesSolved - p->second->getNumOfNodesSolved() ) < 0 )
1978 std::cout <<
"numOfNodesSolved = " << numOfNodesSolved <<
", p->second->getNumOfNodesSolved() = " << p->second->getNumOfNodesSolved() << std::endl;
1982 nNodesSolvedInSolvers += numOfNodesSolved - p->second->getNumOfNodesSolved();
1984 nNodesInSolvers += numOfNodesLeft - p->second->getNumOfNodesLeft();
1985 p->second->setNumOfDiffNodesSolved( numOfNodesSolved - p->second->getNumOfNodesSolved() );
1986 p->second->setNumOfNodesSolved(numOfNodesSolved);
1987 p->second->setNumOfDiffNodesLeft( numOfNodesLeft - p->second->getNumOfNodesLeft() );
1988 p->second->setNumOfNodesLeft(numOfNodesLeft);
1989 if( p->second->getBestDualBoundValue() < solverLocalBestDualBound )
1991 p->second->setDualBoundValue(solverLocalBestDualBound);
1992 selectionHeap->updateDualBoundValue(*(p->second->getSelectionHeapElement()), solverLocalBestDualBound);
1993 if( p->second->isInCollectingMode() )
1995 if( collectingModeSolverHeap )
1997 collectingModeSolverHeap->updateDualBoundValue(*(p->second->getCollectingModeSolverHeapElement()), solverLocalBestDualBound);
2006 double globalBestDualBoundValue = selectionHeap->top()->getBestDualBoundValue();
2007 if( globalBestDualBoundValue > p->second->getBestDualBoundValue() )
2009 std::cout <<
"Top rank = " << selectionHeap->top()->getRank() << std::endl;
2010 std::cout <<
"Top bound = " << selectionHeap->top()->getBestDualBoundValue() << std::endl;
2011 std::cout <<
"This bound = " << p->second->getBestDualBoundValue() << std::endl;
2012 std::cout <<
"myRank = " << rank << std::endl;
2013 std::cout <<
"solverLocalBestDualBound = " << p->second->getBestDualBoundValue() << std::endl;
2014 std::cout << selectionHeap->toString();
2015 if( collectingModeSolverHeap )
2017 std::cout << collectingModeSolverHeap->toString();
2023 && numOfNodesSolved > 1 )
2026 nDualBoundGainTesting--;
2029 if( collectingMode )
2034 if( !selectionHeap->top()->isInCollectingMode() &&
2035 selectionHeap->top()->isGenerator() &&
2036 (!selectionHeap->top()->isCollectingProhibited()) &&
2037 selectionHeap->top()->getNumOfNodesLeft() > 1 )
2039 if( nLimitCollectingModeSolvers > nCollectingModeSolvers )
2041 switchInCollectingToSolver(selectionHeap->top()->getRank(), paraNodePool);
2046 < selectionHeap->top()->getBestDualBoundValue() )
2048 if( !( breakingFirstSubtree && rank == 1 ) )
2050 if( !paraNodePool->
isEmpty() )
2052 sendSwitchOutCollectingModeIfNecessary( rank );
2054 switchInCollectingToSolver(selectionHeap->top()->getRank(), paraNodePool);
2061 if( collectingModeSolverHeap &&
2062 !( breakingFirstSubtree && collectingModeSolverHeap->getHeapSize() <= 1 ) &&
2063 ( p->second->getBestDualBoundValue() - collectingModeSolverHeap->top()->getBestDualBoundValue() ) > absoluteGap &&
2064 ( (!candidatesOfCollectingModeSolvers.empty()) &&
2065 ( candidatesOfCollectingModeSolvers.begin()->second->getBestDualBoundValue() + absoluteGap )
2066 < p->second->getBestDualBoundValue() )
2069 assert( p->second->getRank() == rank );
2070 assert( rank != selectionHeap->top()->getRank() );
2071 if( !paraNodePool->
isEmpty() )
2073 sendSwitchOutCollectingModeIfNecessary( rank );
2076 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
2077 pCandidate = candidatesOfCollectingModeSolvers.begin();
2078 assert( pCandidate->second->isOutCollectingMode() );
2080 nCollect = std::min(pCandidate->second->getNumOfNodesLeft()/4,
2082 getNumInactiveSolvers() +
2089 nCollect = 0 - (nCollect + 1);
2092 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
2101 pCandidate->second->setCollectingMode(
true);
2102 collectingModeSolverHeap->insert( pCandidate->second );
2103 nCollectingModeSolvers++;
2104 pCandidate->second->setCandidateOfCollecting(
false);
2105 candidatesOfCollectingModeSolvers.erase(pCandidate);
2109 if( !paraNodePool->
isEmpty() &&
2110 ( ( ( ( p->second->getBestDualBoundValue() - globalBestDualBoundValue ) /
2111 max( fabs(globalBestDualBoundValue), 1.0 ) ) > ( bgap * mBgap ) ) ) )
2113 sendSwitchOutCollectingModeIfNecessary( p->second->getRank() );
2120 if( nLimitCollectingModeSolvers > nCollectingModeSolvers )
2122 if( pool[
SOLVER_POOL_INDEX(rank)]->getRank() == selectionHeap->top()->getRank() &&
2125 selectionHeap->top()->getNumOfNodesLeft() > 1 )
2127 switchInCollectingToSolver(rank, paraNodePool);
2132 if( !paraNodePool->
isEmpty() &&
2134 collectingModeSolverHeap &&
2135 !( breakingFirstSubtree && collectingModeSolverHeap->getHeapSize() <= 1 ) &&
2137 < collectingModeSolverHeap->top()->getBestDualBoundValue() )
2139 sendSwitchOutCollectingModeIfNecessary( collectingModeSolverHeap->top()->getRank() );
2144 bool manyIdleSolversExist =
false;
2145 if( getNumInactiveSolvers() >
nSolvers/4 ) manyIdleSolversExist =
true;
2146 if( nLimitCollectingModeSolvers > nCollectingModeSolvers )
2148 if( manyIdleSolversExist )
2150 double temp = switchOutTime;
2151 switchOutCollectingMode();
2152 switchOutTime = temp;
2153 switchInCollectingMode(paraNodePool);
2157 if( selectionHeap->top()->getNumOfNodesLeft() > 1 &&
2158 selectionHeap->top()->isGenerator() &&
2159 (!selectionHeap->top()->isCollectingProhibited()) &&
2160 selectionHeap->top()->isOutCollectingMode() )
2162 switchInCollectingToSolver(selectionHeap->top()->getRank(), paraNodePool);
2166 if( !candidatesOfCollectingModeSolvers.empty() )
2168 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
2169 pCandidate = candidatesOfCollectingModeSolvers.begin();
2170 assert( pCandidate->second->isOutCollectingMode() );
2171 nCollect = std::min(pCandidate->second->getNumOfNodesLeft()/4,
2173 getNumInactiveSolvers() +
2180 nCollect = 0 - (nCollect + 1);
2183 if( paraNodePool->
isEmpty() && nLimitCollectingModeSolvers > 10 )
2192 pCandidate->second->setCollectingMode(
true);
2193 if( collectingModeSolverHeap )
2195 collectingModeSolverHeap->insert( pCandidate->second );
2197 nCollectingModeSolvers++;
2198 pCandidate->second->setCandidateOfCollecting(
false);
2199 candidatesOfCollectingModeSolvers.erase(pCandidate);
2203 assert( rank == p->second->getRank() );
2204 if( p->second->getNumOfNodesLeft() > 1 &&
2205 p->second->isGenerator() &&
2206 ( !p->second->isCollectingProhibited() ) &&
2207 p->second->isOutCollectingMode() &&
2209 ( ( ( p->second->getBestDualBoundValue() - globalBestDualBoundValue ) /
2210 max( fabs(globalBestDualBoundValue), 1.0 ) ) < bgap ) ) )
2212 switchInCollectingToSolver(rank, paraNodePool);
2222 if( !candidatesOfCollectingModeSolvers.empty() )
2224 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
2225 if( p->second->isCandidateOfCollecting() )
2227 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
2228 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
2230 if( pCandidate->second->getRank() == rank )
2233 if( pCandidate == candidatesOfCollectingModeSolvers.end() )
2238 pCandidate->second->setCandidateOfCollecting(
false);
2239 candidatesOfCollectingModeSolvers.erase(pCandidate);
2241 if( static_cast<int>( candidatesOfCollectingModeSolvers.size() )
2242 == std::min((
signed)nLimitCollectingModeSolvers,
2245 std::multimap< double, BbParaSolverPoolElementPtr >::reverse_iterator prCandidate;
2246 prCandidate = candidatesOfCollectingModeSolvers.rbegin();
2247 if( p->second->getNumOfNodesLeft() > 1 &&
2248 p->second->isGenerator() &&
2249 prCandidate->second->getBestDualBoundValue() > p->second->getBestDualBoundValue() )
2254 assert(prCandidate.base()->second == tCandidate);
2255 if( prCandidate.base()->second != tCandidate )
2257 THROW_LOGICAL_ERROR4(
"prCandidate.base()->second != tCandidate, prCandidate.base()->second = ", prCandidate.base()->second,
", tCandidate = ", tCandidate );
2259 prCandidate.base()->second->setCandidateOfCollecting(
false);
2260 candidatesOfCollectingModeSolvers.erase(prCandidate.base());
2261 candidatesOfCollectingModeSolvers.insert(
2262 make_pair(p->second->getBestDualBoundValue(),p->second)
2264 p->second->setCandidateOfCollecting(
true);
2271 if( collectingModeSolverHeap &&
2272 !( breakingFirstSubtree && collectingModeSolverHeap->getHeapSize() <= 1 ) &&
2273 p->second->getNumOfNodesLeft() > 1 &&
2274 p->second->isGenerator() &&
2275 ( p->second->getBestDualBoundValue() - collectingModeSolverHeap->top()->getBestDualBoundValue() ) < absoluteGap )
2277 candidatesOfCollectingModeSolvers.insert(
2278 make_pair(p->second->getBestDualBoundValue(),p->second)
2280 p->second->setCandidateOfCollecting(
true);
2287 if( collectingModeSolverHeap &&
2288 !( breakingFirstSubtree && collectingModeSolverHeap->getHeapSize() <= 1 ) &&
2289 p->second->getNumOfNodesLeft() > 1 &&
2290 p->second->isGenerator() &&
2291 ( p->second->getBestDualBoundValue() - collectingModeSolverHeap->top()->getBestDualBoundValue() ) < absoluteGap )
2293 candidatesOfCollectingModeSolvers.insert(
2294 make_pair(p->second->getBestDualBoundValue(),p->second)
2296 p->second->setCandidateOfCollecting(
true);
2303 std::cout <<
"ASBD = " << selectionHeap->top()->getBestDualBoundValue() <<
"(" << selectionHeap->top()->getRank() <<
")";
2304 if( collectingModeSolverHeap && collectingModeSolverHeap->getHeapSize() > 0 )
2306 std::cout <<
", CMSBD = " << collectingModeSolverHeap->top()->getBestDualBoundValue() <<
"(" << collectingModeSolverHeap->top()->getRank() <<
")";
2308 if( !candidatesOfCollectingModeSolvers.empty() )
2310 std::cout <<
", CCSBD = ";
2311 std::multimap< double, BbParaSolverPoolElementPtr >::iterator pCandidate;
2312 for( pCandidate = candidatesOfCollectingModeSolvers.begin();
2313 pCandidate != candidatesOfCollectingModeSolvers.end(); ++pCandidate )
2315 std::cout <<
", " << pCandidate->second->getBestDualBoundValue() <<
"(" << pCandidate->second->getRank() <<
")";
2318 std::cout << std::endl;
2333 long long numOfNodesSolved,
2335 double solverLocalBestDualBound
2341 std::cout <<
"Tried to update no racing status solver's info." << std::endl;
2342 std::cout <<
"Update solver rank = " << rank << std::endl;
2378 selectionHeap->updateDualBoundValue(*(pool[
SOLVER_POOL_INDEX(rank)]->getSelectionHeapElement()), solverLocalBestDualBound);
2381 nNodesInBestSolver = selectionHeap->top()->getNumOfNodesLeft();
2382 nNodesSolvedInBestSolver = selectionHeap->top()->getNumOfNodesSolved();
2384 if( selectionHeap->getHeapSize() > 0 )
2386 if( selectionHeap->top()->getBestDualBoundValue() > bestDualBound )
2388 bestDualBound = selectionHeap->top()->getBestDualBoundValue();
2393 if( bestDualBoundInSolvers < solverLocalBestDualBound )
2395 bestDualBoundInSolvers = solverLocalBestDualBound;
2418 winnerRank = selectionHeap->top()->getRank();
2426 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2432 winnerRank = selectionHeap->top()->getRank();
2440 winnerRank = selectionHeap->top()->getRank();
2449 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2453 winnerRank = selectionHeap->top()->getRank();
2461 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers 2466 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2470 winnerRank = selectionHeap->top()->getRank();
2478 winnerRank = selectionHeap->top()->getRank();
2486 winnerRank = selectionHeap->top()->getRank();
2495 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2501 winnerRank = selectionHeap->top()->getRank();
2505 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers 2514 winnerRank = selectionHeap->top()->getRank();
2523 winnerRank = selectionHeap->top()->getRank();
2526 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers 2535 winnerRank = selectionHeap->top()->getRank();
2545 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2548 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers )
2553 if( selectionHeap->top()->getNumOfNodesLeft() >
2558 winnerRank = selectionHeap->top()->getRank();
2563 if( selectionHeap->top()->getNumOfNodesLeft() >
2566 winnerRank = selectionHeap->top()->getRank();
2571 if( paraDetTimer->getElapsedTime() >
2574 winnerRank = selectionHeap->top()->getRank();
2580 if( paraTimer->getElapsedTime() >
2583 winnerRank = selectionHeap->top()->getRank();
2595 if( selectionHeap->top()->getNumOfNodesLeft() >
nSolvers )
2599 winnerRank = selectionHeap->top()->getRank();
2604 if( paraDetTimer->getElapsedTime() >
2607 winnerRank = selectionHeap->top()->getRank();
2618 if( selectionHeap->top()->getNumOfNodesLeft() >
nSolvers )
2622 winnerRank = selectionHeap->top()->getRank();
2627 if( paraTimer->getElapsedTime() >
2630 winnerRank = selectionHeap->top()->getRank();
2643 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2646 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers )
2657 winnerRank = selectionHeap->top()->getRank();
2662 if( paraDetTimer->getElapsedTime() >
2665 winnerRank = selectionHeap->top()->getRank();
2677 winnerRank = selectionHeap->top()->getRank();
2682 if( paraTimer->getElapsedTime() >
2685 winnerRank = selectionHeap->top()->getRank();
2696 if( nEvaluationStage >= static_cast<int>(
nSolvers*solverRatio) )
2699 if( selectionHeap->top()->getNumOfNodesLeft() <=
nSolvers )
2710 winnerRank = selectionHeap->top()->getRank();
2715 if( paraDetTimer->getElapsedTime() >
2718 winnerRank = selectionHeap->top()->getRank();
2725 if( selectionHeap->top()->getNumOfNodesLeft() >
2728 winnerRank = selectionHeap->top()->getRank();
2739 winnerRank = selectionHeap->top()->getRank();
2744 if( paraTimer->getElapsedTime() >
2747 winnerRank = selectionHeap->top()->getRank();
2754 if( selectionHeap->top()->getNumOfNodesLeft() >
2757 winnerRank = selectionHeap->top()->getRank();
const std::string toString()
stringfy of this object for debugging
virtual bool isSolverActive(int rank)
check if the specified Solver is active or not
std::size_t heapSize
current used heap size
#define SOLVER_POOL_INDEX(rank)
virtual void removeSubtreeRootNode(int rank, BbParaNode *node)
remove subtree root node from the active solver with the specified rank
virtual void makeSubtreeRootNodeCurrent(int rank, BbParaNode *node)
make subtree root node as current task for the specified rank
#define THROW_LOGICAL_ERROR4(msg1, msg2, msg3, msg4)
virtual void deleteElement(BbParaSolverPoolElementPtr solver)
delete BbParaSolverPoolElementPtr from Selection Heap
BbParaMergeNodeInfo * getMergeNodeInfo()
get merge node information struct
virtual void deleteElement(BbParaSolverPoolElementPtr solver)
delete BbParaSolverPoolElementPtr from CollectingModeSolver Heap
int getRank()
get rank of the Solver
static const int TagLightWeightRootNodeProcess
virtual void downHeap(std::size_t pos)
down heap
static const int RatioToApplyLightWeightRootProcess
BbParaSolverPoolElementPtr * getSelectionHeapElement()
extract current solving BbParaNode
static const int KeepRacingUntilToFindFirstSolution
static const int TagNoTestDualBoundGain
BbParaSolverPoolElementPtr * getCollectingModeSolverHeapElement()
get collecting mode Solver heap element
virtual void deleteElement(BbParaSolverPoolElementPtr solver)
delete BbParaSolverPoolElementPtr from Selection Heap
virtual void switchInCollectingToSolver(int rank, BbParaNodePool *paraNodePool)
switch a Solver to be in collecting mode
virtual void upHeap(std::size_t pos)
up heap
ResultOfInsert
results of insert
void setCollectingModeSolverHeapElement(BbParaSolverPoolElementPtr *inCollectingModeSolverHeapElement)
set collecting mode Solver heap element
virtual BbParaNode * extractSelfSplitSubtreeRootNode(int rank, BbParaNode *node)
extract self-split subtree root node from the active solver with the specified rank ...
static const int LightWeightRootNodeProcess
static const int NChangeIntoCollectingMode
virtual void updateDualBoundValue(BbParaSolverPoolElementPtr solver, double value)
update selection heap by a new dual bound value of this Solver
virtual void downHeap(std::size_t pos)
down heap
void setSelectionHeapElement(BbParaSolverPoolElementPtr *inSelectionHeapElement)
set selection heap element
static const int SolverOrderInCollectingMode
static const int RacingRampUpTerminationCriteria
virtual void updateDualBoundValue(BbParaSolverPoolElementPtr solver, double value)
update CollectingModeSolver heap by a new dual bound value of this Solver
Defines for UG Framework.
virtual int send(ParaComm *comm, int destination)=0
send this object
static const int ControlCollectingModeOnSolverSide
static const int NMaxCanditatesForCollecting
virtual void downHeap(std::size_t pos)
down heap
class BbParaRacingSolverPool (Racing Solver Pool)
class CollectingModeSolverHeap
virtual void deleteCurrentSubtreeRootNode(int rank)
delete current self-split subtree root node from the active solver with the specified rank ...
int getNumOfDiffNodesLeft()
get number of nodes left difference between current number and that in the previous notification time...
virtual BbParaNode * extractSelfSplitSubtreeRootNodes(int rank)
extract self-split subtree root node from the active solver with the specified rank ...
AscendingCollectingModeSolverHeap(std::size_t size)
constructor
virtual void resetCountersInSolver(int rank, long long numOfNodesSolved, int numOfSelfSplitNodesLeft, BbParaNodePool *paraNodePool)
reset counters in the Solver specified by rank
#define PARA_COMM_CALL(paracommcall)
static const int Deterministic
static const int StopRacingNumberOfNodesLeftMultiplier
CollectingModeSolverHeap(std::size_t size)
constructor
static const int CountingSolverRatioInRacing
virtual void upHeap(std::size_t pos)
up heap
static const int ParaDOUBLE
BbParaNode * next
this pointer is used in case of self-split ramp-up in LC this field is not transferred ...
static const int TagInCollectingMode
AscendingSelectionHeap(std::size_t size)
constructor
std::size_t heapSize
current used heap size
virtual BbParaNode * solverDied(int rank)
kill the Solver specified by rank
DescendingCollectingModeSolverHeap(std::size_t size)
constructor
class BbParaSolverPoolElement (This class includes information about a Solver status) ...
#define THROW_LOGICAL_ERROR1(msg1)
virtual void deleteElement(BbParaSolverPoolElementPtr solver)
delete BbParaSolverPoolElementPtr from CollectingModeSolver Heap
virtual void updateDualBoundValue(BbParaSolverPoolElementPtr solver, double value)
update CollectingModeSolver heap by a new dual bound value of this Solver
SolverStatus getStatus()
get Solver status
static const int TagTestDualBoundGain
static const int StopRacingTimeLimitMultiplier
int getNumOfNodesLeft()
get number of nodes left
virtual void enforcedSwitchOutCollectingMode(int rank)
enforced to switch out collecting mode of the Solver specified by rank if it is necessary ...
virtual void inactivateSolver(int rank, long long numOfNodesSolved, BbParaNodePool *paraNodePool)
inactivate the Solver specified by rank
#define THROW_LOGICAL_ERROR2(msg1, msg2)
virtual bool isEmpty()=0
check if this pool is empty or not
static const int ParaBYTE
void resize(std::size_t size)
resize CollectingModeSolver Heap
virtual unsigned int getNumOfGoodNodes(double globalBestBound)=0
get number of good (heavy) BbParaNodes in this pool
virtual ~CollectingModeSolverHeap()
destructor
virtual bool isWinnerDecided(bool feasibleSol)
check racing termination criteria
ResultOfInsert
results of insert
static const int StopRacingNumberOfNodesLeft
std::size_t maxHeapSize
maximum size of this heap
static const int StopRacingTimeLimit
virtual void sendSwitchOutCollectingModeIfNecessary(int rank)
switch out collecting mode of the Solver specified by rank if it is necessary
virtual void activateSolver(int rank, BbParaNode *node, int nGoodNodesInNodePool, double averageDualBoundGain)
activate the Solver specified by rank with specified node which has been sent
int getMergingStatus()
get merging status
virtual void upHeap(std::size_t pos)
up heap
BbParaSolverPoolElementPtr remove()
remove top priority BbParaSolverPoolElementPtr from CollectingModeSolver Heap */
void setBestDualBoundValue(double inBestDualBoundValue)
set best dual bound value
static const int TagNoWaitModeSend
virtual void updateSolverStatus(int rank, long long numNodesSolved, int numNodesLeft, double solverLocalBestBound)
update Solver status
double getBestDualBoundValue()
get best dual bound value
virtual void addNewSubtreeRootNode(int rank, BbParaNode *node)
add new subtree root node to the active solver with the specified rank
static const int NEvaluationSolversToStopRacing
static const int MultiplierForCollectingMode
virtual void upHeap(std::size_t pos)
up heap
ResultOfInsert insert(BbParaSolverPoolElementPtr solver)
insert BbParaSolverPoolElementPtr to CollectingModeSolver Heap
static const int CollectingModeInterval
virtual void downHeap(std::size_t pos)
down heap
static const int DualBoundGainTest
bool isInCollectingMode()
check if this Solver is in collecting mode or not
virtual BbParaNode * getSelfSplitSubtreeRootNodes(int rank)
get self-split subtree root node from the active solver with the specified rank
BbParaSolverPoolElementPtr * heap
heap : contents are BbParaSolverPoolElementPtr
virtual void updateDualBoundValue(BbParaSolverPoolElementPtr solver, double value)
update selection heap by a new dual bound value of this Solver
BbParaSolverPoolElementPtr * heap
heap : contents are BbParaSolverPoolElementPtr
static const int TagOutCollectingMode
virtual void switchOutCollectingMode()
switch out collecting mode
#define THROW_LOGICAL_ERROR3(msg1, msg2, msg3)