exponential backoff algorithm

在看NDN的默认转发策略BestRoute Strategy中提到了指数退避算法，回忆了一下，即为：

在一个共享信道的情况下，当网络上的节点在发生冲突时，每个节点节点等待一定的时间后重新发送。在二进制指数退避算法中，等待时间随着以二为底的指数增长。如果重试失败，那么下次的等待时间将会是上次的等待时间二倍。如果重试次数大于最大重试次数，那么包将从包队列中去除。

BestRoute Strategy：把Interest发给具有最小cost的下一跳，没收到要重传时选择次小cost的下一跳

This strategy forwards a new Interest to the lowest-cost nexthop (except downstream). After that, if consumer retransmits the Interest (and is not suppressed according to exponential backoff algorithm), the strategy forwards the Interest again to the lowest-cost nexthop (except downstream) that is not previously used. If all nexthops have been used, the strategy starts over with the first nexthop.

This strategy returns Nack to all downstreams with reason NoRoute if there is no usable nexthop, which may be caused by: (a) the FIB entry contains no nexthop; (b) the FIB nexthop happens to be the sole downstream; (c) the FIB nexthops violate scope.

This strategy returns Nack to all downstreams if all upstreams have returned Nacks. The reason of the sent Nack equals the least severe reason among received Nacks.

    1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */   26 #include "best-route-strategy2.hpp"   27 #include "core/logger.hpp"   28    29 namespace nfd {   30 namespace fw {   31    32 NFD_LOG_INIT("BestRouteStrategy2");   33    34 const Name BestRouteStrategy2::STRATEGY_NAME("ndn:/localhost/nfd/strategy/best-route/%FD%04");   35 NFD_REGISTER_STRATEGY(BestRouteStrategy2);   36    37 const time::milliseconds BestRouteStrategy2::RETX_SUPPRESSION_INITIAL(10);   38 const time::milliseconds BestRouteStrategy2::RETX_SUPPRESSION_MAX(250);   39    40 BestRouteStrategy2::BestRouteStrategy2(Forwarder& forwarder, const Name& name)   41   : Strategy(forwarder, name)   42   , m_retxSuppression(RETX_SUPPRESSION_INITIAL,   43                       RetxSuppressionExponential::DEFAULT_MULTIPLIER,   44                       RETX_SUPPRESSION_MAX)   45 {   46 }   47    55 static inline bool   56 predicate_NextHop_eligible(const shared_ptr<pit::Entry>& pitEntry,   57   const fib::NextHop& nexthop, FaceId currentDownstream,   58   bool wantUnused = false,   59   time::steady_clock::TimePoint now = time::steady_clock::TimePoint::min())   60 {   61   shared_ptr<Face> upstream = nexthop.getFace();   62    63   // upstream is current downstream   64   if (upstream->getId() == currentDownstream)   65     return false;   66    67   // forwarding would violate scope   68   if (pitEntry->violatesScope(*upstream))   69     return false;   70    71   if (wantUnused) {   72     // NextHop must not have unexpired OutRecord   73     pit::OutRecordCollection::const_iterator outRecord = pitEntry->getOutRecord(*upstream);   74     if (outRecord != pitEntry->getOutRecords().end() &&   75         outRecord->getExpiry() > now) {   76       return false;   77     }   78   }   79    80   return true;   81 }   82    86 static inline fib::NextHopList::const_iterator   87 findEligibleNextHopWithEarliestOutRecord(const shared_ptr<pit::Entry>& pitEntry,   88                                          const fib::NextHopList& nexthops,   89                                          FaceId currentDownstream)   90 {   91   fib::NextHopList::const_iterator found = nexthops.end();   92   time::steady_clock::TimePoint earliestRenewed = time::steady_clock::TimePoint::max();   93   for (fib::NextHopList::const_iterator it = nexthops.begin(); it != nexthops.end(); ++it) {   94     if (!predicate_NextHop_eligible(pitEntry, *it, currentDownstream))   95       continue;   96     pit::OutRecordCollection::const_iterator outRecord = pitEntry->getOutRecord(*it->getFace());   97     BOOST_ASSERT(outRecord != pitEntry->getOutRecords().end());   98     if (outRecord->getLastRenewed() < earliestRenewed) {   99       found = it;  100       earliestRenewed = outRecord->getLastRenewed();  101     }  102   }  103   return found;  104 }  105   106 void  107 BestRouteStrategy2::afterReceiveInterest(const Face& inFace,  108                                          const Interest& interest,  109                                          shared_ptr<fib::Entry> fibEntry,  110                                          shared_ptr<pit::Entry> pitEntry)  111 {  112   const fib::NextHopList& nexthops = fibEntry->getNextHops();  113   fib::NextHopList::const_iterator it = nexthops.end();  114   115   RetxSuppression::Result suppression = m_retxSuppression.decide(inFace, interest, *pitEntry);  116   if (suppression == RetxSuppression::NEW) {  117     // forward to nexthop with lowest cost except downstream  118     it = std::find_if(nexthops.begin(), nexthops.end(),  119       bind(&predicate_NextHop_eligible, pitEntry, _1, inFace.getId(),  120            false, time::steady_clock::TimePoint::min()));  121   122     if (it == nexthops.end()) {  123       NFD_LOG_DEBUG(interest << " from=" << inFace.getId() << " noNextHop");  124   125       lp::NackHeader nackHeader;  126       nackHeader.setReason(lp::NackReason::NO_ROUTE);  127       this->sendNack(pitEntry, inFace, nackHeader);  128   129       this->rejectPendingInterest(pitEntry);  130       return;  131     }  132   133     shared_ptr<Face> outFace = it->getFace();  134     this->sendInterest(pitEntry, outFace);  135     NFD_LOG_DEBUG(interest << " from=" << inFace.getId()  136                            << " newPitEntry-to=" << outFace->getId());  137     return;  138   }  139   140   if (suppression == RetxSuppression::SUPPRESS) {  141     NFD_LOG_DEBUG(interest << " from=" << inFace.getId()  142                            << " suppressed");  143     return;  144   }  145   146   // find an unused upstream with lowest cost except downstream  147   it = std::find_if(nexthops.begin(), nexthops.end(),  148                     bind(&predicate_NextHop_eligible, pitEntry, _1, inFace.getId(),  149                          true, time::steady_clock::now()));  150   if (it != nexthops.end()) {  151     shared_ptr<Face> outFace = it->getFace();  152     this->sendInterest(pitEntry, outFace);  153     NFD_LOG_DEBUG(interest << " from=" << inFace.getId()  154                            << " retransmit-unused-to=" << outFace->getId());  155     return;  156   }  157   158   // find an eligible upstream that is used earliest  159   it = findEligibleNextHopWithEarliestOutRecord(pitEntry, nexthops, inFace.getId());  160   if (it == nexthops.end()) {  161     NFD_LOG_DEBUG(interest << " from=" << inFace.getId() << " retransmitNoNextHop");  162   }  163   else {  164     shared_ptr<Face> outFace = it->getFace();  165     this->sendInterest(pitEntry, outFace);  166     NFD_LOG_DEBUG(interest << " from=" << inFace.getId()  167                            << " retransmit-retry-to=" << outFace->getId());  168   }  169 }  170   175 inline lp::NackReason  176 compareLessSevere(lp::NackReason x, lp::NackReason y)  177 {  178   if (x == lp::NackReason::NONE) {  179     return y;  180   }  181   if (y == lp::NackReason::NONE) {  182     return x;  183   }  184   return static_cast<lp::NackReason>(std::min(static_cast<int>(x), static_cast<int>(y)));  185 }  186   187 void  188 BestRouteStrategy2::afterReceiveNack(const Face& inFace, const lp::Nack& nack,  189                                      shared_ptr<fib::Entry> fibEntry,  190                                      shared_ptr<pit::Entry> pitEntry)  191 {  192   int nOutRecordsNotNacked = 0;  193   Face* lastFaceNotNacked = nullptr;  194   lp::NackReason leastSevereReason = lp::NackReason::NONE;  195   for (const pit::OutRecord& outR : pitEntry->getOutRecords()) {  196     const lp::NackHeader* inNack = outR.getIncomingNack();  197     if (inNack == nullptr) {  198       ++nOutRecordsNotNacked;  199       lastFaceNotNacked = outR.getFace().get();  200       continue;  201     }  202   203     leastSevereReason = compareLessSevere(leastSevereReason, inNack->getReason());  204   }  205   206   lp::NackHeader outNack;  207   outNack.setReason(leastSevereReason);  208   209   if (nOutRecordsNotNacked == 1) {  210     BOOST_ASSERT(lastFaceNotNacked != nullptr);  211     pit::InRecordCollection::const_iterator inR = pitEntry->getInRecord(*lastFaceNotNacked);  212     if (inR != pitEntry->getInRecords().end()) {  213       // one out-record not Nacked, which is also a downstream  214       NFD_LOG_DEBUG(nack.getInterest() << " nack-from=" << inFace.getId() <<  215                     " nack=" << nack.getReason() <<  216                     " nack-to(bidirectional)=" << lastFaceNotNacked->getId() <<  217                     " out-nack=" << outNack.getReason());  218       this->sendNack(pitEntry, *lastFaceNotNacked, outNack);  219       return;  220     }  221   }  222   223   if (nOutRecordsNotNacked > 0) {  224     NFD_LOG_DEBUG(nack.getInterest() << " nack-from=" << inFace.getId() <<  225                   " nack=" << nack.getReason() <<  226                   " waiting=" << nOutRecordsNotNacked);  227     // continue waiting  228     return;  229   }  230   231   232   NFD_LOG_DEBUG(nack.getInterest() << " nack-from=" << inFace.getId() <<  233                 " nack=" << nack.getReason() <<  234                 " nack-to=all out-nack=" << outNack.getReason());  235   this->sendNacks(pitEntry, outNack);  236 }  237   238 } // namespace fw  239 } // namespace nfd