lp-reliability.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2014-2024,  Regents of the University of California,
 *                           Arizona Board of Regents,
 *                           Colorado State University,
 *                           University Pierre & Marie Curie, Sorbonne University,
 *                           Washington University in St. Louis,
 *                           Beijing Institute of Technology,
 *                           The University of Memphis.
 *
 * This file is part of NFD (Named Data Networking Forwarding Daemon).
 * See AUTHORS.md for complete list of NFD authors and contributors.
 *
 * NFD is free software: you can redistribute it and/or modify it under the terms
 * of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef NFD_DAEMON_FACE_LP_RELIABILITY_HPP
#define NFD_DAEMON_FACE_LP_RELIABILITY_HPP
 
#include "face-common.hpp"
 
#include <ndn-cxx/lp/packet.hpp>
#include <ndn-cxx/lp/sequence.hpp>
#include <ndn-cxx/util/rtt-estimator.hpp>
#include <ndn-cxx/util/scheduler.hpp>
 
#include <map>
#include <queue>
 
namespace nfd::face {
 
class GenericLinkService;
 
class LpReliability : noncopyable
{
public:
  static constexpr size_t RESERVED_HEADER_SPACE = tlv::sizeOfVarNumber(lp::tlv::TxSequence) +
                                                  tlv::sizeOfVarNumber(sizeof(lp::Sequence)) +
                                                  sizeof(lp::Sequence);
 
  struct Options
  {
    bool isEnabled = false;
 
    size_t maxRetx = 3;
 
    time::nanoseconds idleAckTimerPeriod = 5_ms;
 
    size_t seqNumLossThreshold = 3;
  };
 
  LpReliability(const Options& options, GenericLinkService* linkService);
 
  signal::Signal<LpReliability, Interest> onDroppedInterest;
 
  void
  setOptions(const Options& options);
 
  const GenericLinkService*
  getLinkService() const noexcept
  {
    return m_linkService;
  }
 
  void
  handleOutgoing(std::vector<lp::Packet>& frags, lp::Packet&& pkt, bool isInterest);
 
  bool
  processIncomingPacket(const lp::Packet& pkt);
 
  void
  piggyback(lp::Packet& pkt, ssize_t mtu);
 
NFD_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  class UnackedFrag;
  class NetPkt;
  using UnackedFrags = std::map<lp::Sequence, UnackedFrag>;
 
  lp::Sequence
  assignTxSequence(lp::Packet& frag);
 
  void
  startIdleAckTimer();
 
  std::vector<lp::Sequence>
  findLostLpPackets(UnackedFrags::iterator ackIt);
 
  std::vector<lp::Sequence>
  onLpPacketLost(lp::Sequence txSeq, bool isTimeout);
 
  void
  onLpPacketAcknowledged(UnackedFrags::iterator fragIt);
 
  void
  deleteUnackedFrag(UnackedFrags::iterator fragIt);
 
NFD_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  class UnackedFrag
  {
  public:
    explicit
    UnackedFrag(lp::Packet p)
      : pkt(std::move(p))
    {
    }
 
  public:
    lp::Packet pkt;
    ndn::scheduler::ScopedEventId rtoTimer;
    time::steady_clock::time_point sendTime = time::steady_clock::now();
    size_t retxCount = 0;
    size_t nGreaterSeqAcks = 0; 
    shared_ptr<NetPkt> netPkt;
  };
 
  class NetPkt
  {
  public:
    NetPkt(lp::Packet&& p, bool isInterest)
      : pkt(std::move(p))
      , isInterest(isInterest)
    {
    }
 
  public:
    std::vector<UnackedFrags::iterator> unackedFrags;
    lp::Packet pkt;
    bool isInterest;
    bool didRetx = false;
  };
 
  Options m_options;
  GenericLinkService* m_linkService = nullptr;
  UnackedFrags m_unackedFrags;
  // An iterator that points to the first unacknowledged fragment in the current window. The window
  // can wrap around so that the beginning of the window is at a TxSequence greater than other
  // fragments in the window. When the window is moved past the last item in the iterator, the
  // first fragment in the map will become the start of the window.
  UnackedFrags::iterator m_firstUnackedFrag;
  std::queue<lp::Sequence> m_ackQueue;
  std::map<lp::Sequence, time::steady_clock::time_point> m_recentRecvSeqs;
  std::queue<lp::Sequence> m_recentRecvSeqsQueue;
  lp::Sequence m_lastTxSeqNo;
  ndn::scheduler::ScopedEventId m_idleAckTimer;
  ndn::util::RttEstimator m_rttEst;
};
 
std::ostream&
operator<<(std::ostream& os, const FaceLogHelper<LpReliability>& flh);
 
} // namespace nfd::face
 
#endif // NFD_DAEMON_FACE_LP_RELIABILITY_HPP