[HICN-713] Transport Library Major Refactoring 2

Co-authored-by: Luca Muscariello <muscariello@ieee.org>
Co-authored-by: Michele Papalini <micpapal@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Giulio Grassi <gigrassi@cisco.com>
Signed-off-by: Mauro Sardara <msardara@cisco.com>
Change-Id: I5b2c667bad66feb45abdb5effe22ed0f6c85d1c2

1 files changed, 0 insertions, 984 deletions

diff --git a/libtransport/src/protocols/rtc.cc b/libtransport/src/protocols/rtc.cc
deleted file mode 100644
index a01b8daa5..000000000
--- a/libtransport/src/protocols/rtc.cc
+++ /dev/null
@@ -1,984 +0,0 @@
-/*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <hicn/transport/interfaces/socket_consumer.h>
-#include <implementation/socket_consumer.h>
-#include <math.h>
-#include <protocols/rtc.h>
-
-#include <random>
-
-namespace transport {
-
-namespace protocol {
-
-using namespace interface;
-
-RTCTransportProtocol::RTCTransportProtocol(
-    implementation::ConsumerSocket *icn_socket)
-    : TransportProtocol(icn_socket, nullptr),
-      DatagramReassembly(icn_socket, this),
-      inflightInterests_(1 << default_values::log_2_default_buffer_size),
-      modMask_((1 << default_values::log_2_default_buffer_size) - 1) {
-  icn_socket->getSocketOption(PORTAL, portal_);
-  rtx_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
-  probe_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
-  sentinel_timer_ =
-      std::make_unique<asio::steady_timer>(portal_->getIoService());
-  round_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
-  initParams();
-}
-
-RTCTransportProtocol::~RTCTransportProtocol() {}
-
-void RTCTransportProtocol::resume() {
-  if (is_running_) return;
-
-  is_running_ = true;
-  inflightInterestsCount_ = 0;
-
-  probeRtt();
-  sentinelTimer();
-  newRound();
-  scheduleNextInterests();
-
-  portal_->runEventsLoop();
-  is_running_ = false;
-}
-
-// private
-void RTCTransportProtocol::initParams() {
-  portal_->setConsumerCallback(this);
-  // controller var
-  currentState_ = HICN_RTC_SYNC_STATE;
-
-  // cwin var
-  currentCWin_ = HICN_INITIAL_CWIN;
-  maxCWin_ = HICN_INITIAL_CWIN_MAX;
-
-  // names/packets var
-  actualSegment_ = 0;
-  inflightInterestsCount_ = 0;
-  interestRetransmissions_.clear();
-  lastSegNacked_ = 0;
-  lastReceived_ = 0;
-  lastReceivedTime_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                          std::chrono::steady_clock::now().time_since_epoch())
-                          .count();
-  lastEvent_ = lastReceivedTime_;
-  highestReceived_ = 0;
-  firstSequenceInRound_ = 0;
-
-  rtx_timer_used_ = false;
-  for (int i = 0; i < (1 << default_values::log_2_default_buffer_size); i++) {
-    inflightInterests_[i] = {0};
-  }
-
-  // stats
-  firstPckReceived_ = false;
-  receivedBytes_ = 0;
-  sentInterest_ = 0;
-  receivedData_ = 0;
-  packetLost_ = 0;
-  lossRecovered_ = 0;
-  avgPacketSize_ = HICN_INIT_PACKET_SIZE;
-  gotNack_ = false;
-  gotFutureNack_ = 0;
-  rounds_ = 0;
-  roundsWithoutNacks_ = 0;
-  pathTable_.clear();
-
-  // CC var
-  estimatedBw_ = 0.0;
-  lossRate_ = 0.0;
-  queuingDelay_ = 0.0;
-  protocolState_ = HICN_RTC_NORMAL_STATE;
-
-  producerPathLabels_[0] = 0;
-  producerPathLabels_[1] = 0;
-  initied = false;
-
-  socket_->setSocketOption(GeneralTransportOptions::INTEREST_LIFETIME,
-                           (uint32_t)HICN_RTC_INTEREST_LIFETIME);
-}
-
-// private
-void RTCTransportProtocol::reset() {
-  initParams();
-  probeRtt();
-  sentinelTimer();
-  newRound();
-}
-
-uint32_t max(uint32_t a, uint32_t b) {
-  if (a > b)
-    return a;
-  else
-    return b;
-}
-
-uint32_t min(uint32_t a, uint32_t b) {
-  if (a < b)
-    return a;
-  else
-    return b;
-}
-
-void RTCTransportProtocol::newRound() {
-  round_timer_->expires_from_now(std::chrono::milliseconds(HICN_ROUND_LEN));
-  round_timer_->async_wait([this](std::error_code ec) {
-    if (ec) return;
-    updateStats(HICN_ROUND_LEN);
-    newRound();
-  });
-}
-
-void RTCTransportProtocol::updateDelayStats(
-    const ContentObject &content_object) {
-  uint32_t segmentNumber = content_object.getName().getSuffix();
-  uint32_t pkt = segmentNumber & modMask_;
-
-  if (inflightInterests_[pkt].state != sent_) return;
-
-  if (interestRetransmissions_.find(segmentNumber) !=
-      interestRetransmissions_.end())
-    // this packet was rtx at least once
-    return;
-
-  uint32_t pathLabel = content_object.getPathLabel();
-
-  if (pathTable_.find(pathLabel) == pathTable_.end()) {
-    // found a new path
-    std::shared_ptr<RTCDataPath> newPath = std::make_shared<RTCDataPath>();
-    pathTable_[pathLabel] = newPath;
-  }
-
-  // RTT measurements are useful both from NACKs and data packets
-  uint64_t RTT = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count() -
-                 inflightInterests_[pkt].transmissionTime;
-
-  pathTable_[pathLabel]->insertRttSample(RTT);
-  auto payload = content_object.getPayload();
-
-  // we collect OWD only for datapackets
-  if (payload->length() != HICN_NACK_HEADER_SIZE) {
-    uint64_t *senderTimeStamp = (uint64_t *)payload->data();
-    int64_t OWD = std::chrono::duration_cast<std::chrono::milliseconds>(
-                      std::chrono::steady_clock::now().time_since_epoch())
-                      .count() -
-                  *senderTimeStamp;
-
-    pathTable_[pathLabel]->insertOwdSample(OWD);
-    pathTable_[pathLabel]->computeInterArrivalGap(segmentNumber);
-  } else {
-    pathTable_[pathLabel]->receivedNack();
-  }
-}
-
-void RTCTransportProtocol::updateStats(uint32_t round_duration) {
-  if (pathTable_.empty()) return;
-
-  if (receivedBytes_ != 0) {
-    double bytesPerSec =
-        (double)(receivedBytes_ *
-                 ((double)HICN_MILLI_IN_A_SEC / (double)round_duration));
-    estimatedBw_ = (estimatedBw_ * HICN_ESTIMATED_BW_ALPHA) +
-                   ((1 - HICN_ESTIMATED_BW_ALPHA) * bytesPerSec);
-  }
-
-  uint64_t minRtt = UINT_MAX;
-  uint64_t maxRtt = 0;
-
-  for (auto it = pathTable_.begin(); it != pathTable_.end(); it++) {
-    it->second->roundEnd();
-    if (it->second->isActive()) {
-      if (it->second->getMinRtt() < minRtt) {
-        minRtt = it->second->getMinRtt();
-        producerPathLabels_[0] = it->first;
-      }
-      if (it->second->getMinRtt() > maxRtt) {
-        maxRtt = it->second->getMinRtt();
-        producerPathLabels_[1] = it->first;
-      }
-    }
-  }
-
-  if (pathTable_.find(producerPathLabels_[0]) == pathTable_.end() ||
-      pathTable_.find(producerPathLabels_[1]) == pathTable_.end())
-    return;  // this should not happen
-
-  // as a queuing delay we keep the lowest one among the two paths
-  // if one path is congested the forwarder should decide to do not
-  // use it so it does not make sense  to inform the application
-  // that maybe we have a problem
-  if (pathTable_[producerPathLabels_[0]]->getQueuingDealy() <
-      pathTable_[producerPathLabels_[1]]->getQueuingDealy())
-    queuingDelay_ = pathTable_[producerPathLabels_[0]]->getQueuingDealy();
-  else
-    queuingDelay_ = pathTable_[producerPathLabels_[1]]->getQueuingDealy();
-
-  if (sentInterest_ != 0 && currentState_ == HICN_RTC_NORMAL_STATE) {
-    uint32_t numberTheoricallyReceivedPackets_ =
-        highestReceived_ - firstSequenceInRound_;
-    double lossRate = 0;
-    if (numberTheoricallyReceivedPackets_ != 0)
-      lossRate = (double)((double)(packetLost_ - lossRecovered_) /
-                          (double)numberTheoricallyReceivedPackets_);
-
-    if (lossRate < 0) lossRate = 0;
-
-    if (initied) {
-      lossRate_ = lossRate_ * HICN_ESTIMATED_LOSSES_ALPHA +
-                  (lossRate * (1 - HICN_ESTIMATED_LOSSES_ALPHA));
-    } else {
-      lossRate_ = lossRate;
-      initied = true;
-    }
-  }
-
-  if (avgPacketSize_ == 0) avgPacketSize_ = HICN_INIT_PACKET_SIZE;
-
-  // for the BDP we use the max rtt, so that we calibrate the window on the
-  // RTT of the slowest path. In this way we are sure that the window will
-  // never be too small
-  uint32_t BDP = (uint32_t)ceil(
-      (estimatedBw_ *
-       (double)((double)pathTable_[producerPathLabels_[1]]->getMinRtt() /
-                (double)HICN_MILLI_IN_A_SEC) *
-       HICN_BANDWIDTH_SLACK_FACTOR) /
-      avgPacketSize_);
-  uint32_t BW = (uint32_t)ceil(estimatedBw_);
-  computeMaxWindow(BW, BDP);
-
-  if (*stats_summary_) {
-    // Send the stats to the app
-    stats_->updateQueuingDelay(queuingDelay_);
-    stats_->updateLossRatio(lossRate_);
-    stats_->updateAverageRtt(pathTable_[producerPathLabels_[1]]->getMinRtt());
-    (*stats_summary_)(*socket_->getInterface(), *stats_);
-  }
-  // bound also by interest lifitime* production rate
-  if (!gotNack_) {
-    roundsWithoutNacks_++;
-    if (currentState_ == HICN_RTC_SYNC_STATE &&
-        roundsWithoutNacks_ >= HICN_ROUNDS_IN_SYNC_BEFORE_SWITCH) {
-      currentState_ = HICN_RTC_NORMAL_STATE;
-    }
-  } else {
-    roundsWithoutNacks_ = 0;
-  }
-
-  updateCCState();
-  updateWindow();
-
-  if (queuingDelay_ > 25.0) {
-    // this indicates that the client will go soon out of synch,
-    // switch to synch mode
-    if (currentState_ == HICN_RTC_NORMAL_STATE) {
-      currentState_ = HICN_RTC_SYNC_STATE;
-    }
-    computeMaxWindow(BW, 0);
-    increaseWindow();
-  }
-
-  // in any case we reset all the counters
-
-  gotNack_ = false;
-  gotFutureNack_ = 0;
-  receivedBytes_ = 0;
-  sentInterest_ = 0;
-  receivedData_ = 0;
-  packetLost_ = 0;
-  lossRecovered_ = 0;
-  rounds_++;
-  firstSequenceInRound_ = highestReceived_;
-}
-
-void RTCTransportProtocol::updateCCState() {
-  // TODO
-}
-
-void RTCTransportProtocol::computeMaxWindow(uint32_t productionRate,
-                                            uint32_t BDPWin) {
-  if (productionRate ==
-      0)  // we have no info about the producer, keep the previous maxCWin
-    return;
-
-  uint32_t interestLifetime = default_values::interest_lifetime;
-  socket_->getSocketOption(GeneralTransportOptions::INTEREST_LIFETIME,
-                           interestLifetime);
-  uint32_t maxWaintingInterest = (uint32_t)ceil(
-      (productionRate / avgPacketSize_) *
-      (double)((double)(interestLifetime *
-                        HICN_INTEREST_LIFETIME_REDUCTION_FACTOR) /
-               (double)HICN_MILLI_IN_A_SEC));
-
-  if (currentState_ == HICN_RTC_SYNC_STATE) {
-    // in this case we do not limit the window with the BDP, beacuse most
-    // likely it is wrong
-    maxCWin_ = maxWaintingInterest;
-    return;
-  }
-
-  // currentState = RTC_NORMAL_STATE
-  if (BDPWin != 0) {
-    maxCWin_ = (uint32_t)ceil((double)BDPWin +
-                              (((double)BDPWin * 30.0) / 100.0));  // BDP + 30%
-  } else {
-    maxCWin_ = min(maxWaintingInterest, maxCWin_);
-  }
-
-  if (maxCWin_ < HICN_MIN_CWIN) maxCWin_ = HICN_MIN_CWIN;
-}
-
-void RTCTransportProtocol::updateWindow() {
-  if (currentState_ == HICN_RTC_SYNC_STATE) return;
-
-  if (estimatedBw_ == 0) return;
-
-  if (currentCWin_ < maxCWin_ * 0.9) {
-    currentCWin_ =
-        min(maxCWin_, (uint32_t)(currentCWin_ * HICN_WIN_INCREASE_FACTOR));
-  } else if (currentCWin_ > maxCWin_) {
-    currentCWin_ =
-        max((uint32_t)(currentCWin_ * HICN_WIN_DECREASE_FACTOR), HICN_MIN_CWIN);
-  }
-}
-
-void RTCTransportProtocol::decreaseWindow() {
-  // this is used only in SYNC mode
-  if (currentState_ == HICN_RTC_NORMAL_STATE) return;
-
-  if (gotFutureNack_ == 1)
-    currentCWin_ = min((currentCWin_ - 1),
-                       (uint32_t)ceil((double)maxCWin_ * 0.66));  // 2/3
-  else
-    currentCWin_--;
-
-  currentCWin_ = max(currentCWin_, HICN_MIN_CWIN);
-}
-
-void RTCTransportProtocol::increaseWindow() {
-  // this is used only in SYNC mode
-  if (currentState_ == HICN_RTC_NORMAL_STATE) return;
-
-  // we need to be carefull to do not increase the window to much
-  if (currentCWin_ < ((double)maxCWin_ * 0.7)) {
-    currentCWin_ = currentCWin_ + 1;  // exponential
-  } else {
-    currentCWin_ = min(
-        maxCWin_,
-        (uint32_t)ceil(currentCWin_ + (1.0 / (double)currentCWin_)));  // linear
-  }
-}
-
-void RTCTransportProtocol::probeRtt() {
-  probe_timer_->expires_from_now(std::chrono::milliseconds(1000));
-  probe_timer_->async_wait([this](std::error_code ec) {
-    if (ec) return;
-    probeRtt();
-  });
-
-  // To avoid sending the first probe, because the transport is not running yet
-  if (is_first_ && !is_running_) return;
-
-  time_sent_probe_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                         std::chrono::steady_clock::now().time_since_epoch())
-                         .count();
-
-  Name *interest_name = nullptr;
-  socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
-                           &interest_name);
-  // get a random numbe in the probe seq range
-  std::default_random_engine eng((std::random_device())());
-  std::uniform_int_distribution<uint32_t> idis(HICN_MIN_PROBE_SEQ,
-                                               HICN_MAX_PROBE_SEQ);
-  probe_seq_number_ = idis(eng);
-  interest_name->setSuffix(probe_seq_number_);
-
-  // we considere the probe as a rtx so that we do not incresea inFlightInt
-  received_probe_ = false;
-  TRANSPORT_LOGD("Send content interest %u (probeRtt)",
-                 interest_name->getSuffix());
-  sendInterest(interest_name, true);
-}
-
-void RTCTransportProtocol::sendInterest(Name *interest_name, bool rtx) {
-  auto interest = getPacket();
-  interest->setName(*interest_name);
-
-  uint32_t interestLifetime = default_values::interest_lifetime;
-  socket_->getSocketOption(GeneralTransportOptions::INTEREST_LIFETIME,
-                           interestLifetime);
-  interest->setLifetime(uint32_t(interestLifetime));
-
-  if (*on_interest_output_) {
-    (*on_interest_output_)(*socket_->getInterface(), *interest);
-  }
-
-  if (TRANSPORT_EXPECT_FALSE(!is_running_ && !is_first_)) {
-    return;
-  }
-
-  portal_->sendInterest(std::move(interest));
-
-  sentInterest_++;
-
-  if (!rtx) {
-    packets_in_window_[interest_name->getSuffix()] = 0;
-    inflightInterestsCount_++;
-  }
-}
-
-void RTCTransportProtocol::scheduleNextInterests() {
-  if (!is_running_ && !is_first_) return;
-
-  TRANSPORT_LOGD("----- [window %u - inflight_interests %u = %d] -----",
-                 currentCWin_, inflightInterestsCount_,
-                 currentCWin_ - inflightInterestsCount_);
-
-  while (inflightInterestsCount_ < currentCWin_) {
-    Name *interest_name = nullptr;
-    socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
-                             &interest_name);
-
-    interest_name->setSuffix(actualSegment_);
-
-    // if the producer socket is not stated (does not reply even with nacks)
-    // we keep asking for something without marking anything as lost (see
-    // timeout). In this way when the producer socket will start the
-    // consumer socket will not miss any packet
-    if (TRANSPORT_EXPECT_FALSE(!firstPckReceived_)) {
-      uint32_t pkt = actualSegment_ & modMask_;
-      inflightInterests_[pkt].state = sent_;
-      inflightInterests_[pkt].sequence = actualSegment_;
-      actualSegment_ = (actualSegment_ + 1) % HICN_MIN_PROBE_SEQ;
-      TRANSPORT_LOGD(
-          "Send content interest %u (scheduleNextInterests no replies)",
-          interest_name->getSuffix());
-      sendInterest(interest_name, false);
-      return;
-    }
-
-    // we send the packet only if it is not pending yet
-    // notice that this is not true for rtx packets
-    if (portal_->interestIsPending(*interest_name)) {
-      actualSegment_ = (actualSegment_ + 1) % HICN_MIN_PROBE_SEQ;
-      continue;
-    }
-
-    uint32_t pkt = actualSegment_ & modMask_;
-    // if we already reacevied the content we don't ask it again
-    if (inflightInterests_[pkt].state == received_ &&
-        inflightInterests_[pkt].sequence == actualSegment_) {
-      actualSegment_ = (actualSegment_ + 1) % HICN_MIN_PROBE_SEQ;
-      continue;
-    }
-
-    // same if the packet is lost
-    if (inflightInterests_[pkt].state == lost_ &&
-        inflightInterests_[pkt].sequence == actualSegment_) {
-      actualSegment_ = (actualSegment_ + 1) % HICN_MIN_PROBE_SEQ;
-      continue;
-    }
-
-    inflightInterests_[pkt].transmissionTime =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
-
-    // here the packet can be in any state except for lost or recevied
-    inflightInterests_[pkt].state = sent_;
-    inflightInterests_[pkt].sequence = actualSegment_;
-    actualSegment_ = (actualSegment_ + 1) % HICN_MIN_PROBE_SEQ;
-
-    TRANSPORT_LOGD("Send content interest %u (scheduleNextInterests)",
-                   interest_name->getSuffix());
-    sendInterest(interest_name, false);
-  }
-
-  TRANSPORT_LOGD("----- end of scheduleNextInterest -----");
-}
-
-bool RTCTransportProtocol::verifyKeyPackets() {
-  // Not yet implemented
-  return false;
-}
-
-void RTCTransportProtocol::sentinelTimer() {
-  uint32_t wait = 50;
-
-  if (pathTable_.find(producerPathLabels_[0]) != pathTable_.end() &&
-      pathTable_.find(producerPathLabels_[1]) != pathTable_.end()) {
-    // we have all the info to set the timers
-    wait = round(pathTable_[producerPathLabels_[0]]->getInterArrivalGap());
-    if (wait == 0) wait = 1;
-  }
-
-  sentinel_timer_->expires_from_now(std::chrono::milliseconds(wait));
-  sentinel_timer_->async_wait([this](std::error_code ec) {
-    if (ec) return;
-
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock::now().time_since_epoch())
-                       .count();
-
-    if (pathTable_.find(producerPathLabels_[0]) == pathTable_.end() ||
-        pathTable_.find(producerPathLabels_[1]) == pathTable_.end()) {
-      // we have no info, so we send again
-
-      for (auto it = packets_in_window_.begin(); it != packets_in_window_.end();
-           it++) {
-        uint32_t pkt = it->first & modMask_;
-        if (inflightInterests_[pkt].sequence == it->first) {
-          inflightInterests_[pkt].transmissionTime = now;
-          Name *interest_name = nullptr;
-          socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
-                                   &interest_name);
-          interest_name->setSuffix(it->first);
-          it->second++;
-          sendInterest(interest_name, true);
-        }
-      }
-    } else {
-      uint64_t max_waiting_time =  // wait at least 50ms
-          (pathTable_[producerPathLabels_[1]]->getMinRtt() -
-           pathTable_[producerPathLabels_[0]]->getMinRtt()) +
-          (ceil(pathTable_[producerPathLabels_[0]]->getInterArrivalGap()) * 50);
-
-      if ((currentState_ == HICN_RTC_NORMAL_STATE) &&
-          (inflightInterestsCount_ >= currentCWin_) &&
-          ((now - lastEvent_) > max_waiting_time) && (lossRate_ >= 0.05)) {
-        uint64_t RTT = pathTable_[producerPathLabels_[1]]->getMinRtt();
-
-        for (auto it = packets_in_window_.begin();
-             it != packets_in_window_.end(); it++) {
-          uint32_t pkt = it->first & modMask_;
-          if (inflightInterests_[pkt].sequence == it->first &&
-              ((now - inflightInterests_[pkt].transmissionTime) >= RTT)) {
-            inflightInterests_[pkt].transmissionTime = now;
-            Name *interest_name = nullptr;
-            socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
-                                     &interest_name);
-            interest_name->setSuffix(it->first);
-            it->second++;
-            sendInterest(interest_name, true);
-          }
-        }
-      }
-    }
-
-    sentinelTimer();
-  });
-}
-void RTCTransportProtocol::addRetransmissions(uint32_t val) {
-  // add only val in the rtx list
-  addRetransmissions(val, val + 1);
-}
-
-void RTCTransportProtocol::addRetransmissions(uint32_t start, uint32_t stop) {
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-
-  bool new_rtx = false;
-  for (uint32_t i = start; i < stop; i++) {
-    auto it = interestRetransmissions_.find(i);
-    if (it == interestRetransmissions_.end()) {
-      uint32_t pkt = i & modMask_;
-      if (lastSegNacked_ <= i && inflightInterests_[pkt].state != received_) {
-        // it must be larger than the last past nack received
-        packetLost_++;
-        interestRetransmissions_[i] = 0;
-        uint32_t pkt = i & modMask_;
-        // we reset the transmission time setting to now, so that rtx will
-        // happne in one RTT on waint one inter arrival gap
-        inflightInterests_[pkt].transmissionTime = now;
-        new_rtx = true;
-      }
-    }  // if the retransmission is already there the rtx timer will
-       // take care of it
-  }
-
-  // in case a new rtx is added to the map we need to run checkRtx()
-  if (new_rtx) {
-    if (rtx_timer_used_) {
-      // if a timer is pending we need to delete it
-      rtx_timer_->cancel();
-      rtx_timer_used_ = false;
-    }
-    checkRtx();
-  }
-}
-
-uint64_t RTCTransportProtocol::retransmit() {
-  auto it = interestRetransmissions_.begin();
-
-  // cut len to max HICN_MAX_RTX_SIZE
-  // since we use a map, the smaller (and so the older) sequence number are at
-  // the beginnin of the map
-  while (interestRetransmissions_.size() > HICN_MAX_RTX_SIZE) {
-    it = interestRetransmissions_.erase(it);
-  }
-
-  it = interestRetransmissions_.begin();
-  uint64_t smallest_timeout = ULONG_MAX;
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-
-  while (it != interestRetransmissions_.end()) {
-    uint32_t pkt = it->first & modMask_;
-
-    if (inflightInterests_[pkt].sequence != it->first) {
-      // this packet is not anymore in the inflight buffer, erase it
-      it = interestRetransmissions_.erase(it);
-      continue;
-    }
-
-    // we retransmitted the packet too many times
-    if (it->second >= HICN_MAX_RTX) {
-      it = interestRetransmissions_.erase(it);
-      continue;
-    }
-
-    // this packet is too old
-    if ((lastReceived_ > it->first) &&
-        (lastReceived_ - it->first) > HICN_MAX_RTX_MAX_AGE) {
-      it = interestRetransmissions_.erase(it);
-      continue;
-    }
-
-    uint64_t rtx_time = now;
-
-    if (it->second == 0) {
-      // first rtx
-      if (producerPathLabels_[0] != producerPathLabels_[1]) {
-        // multipath
-        if (pathTable_.find(producerPathLabels_[0]) != pathTable_.end() &&
-            pathTable_.find(producerPathLabels_[1]) != pathTable_.end() &&
-            (pathTable_[producerPathLabels_[0]]->getInterArrivalGap() <
-             HICN_MIN_INTER_ARRIVAL_GAP)) {
-          rtx_time = lastReceivedTime_ +
-                     (pathTable_[producerPathLabels_[1]]->getMinRtt() -
-                      pathTable_[producerPathLabels_[0]]->getMinRtt()) +
-                     pathTable_[producerPathLabels_[0]]->getInterArrivalGap();
-        }  // else low rate producer, send it immediatly
-      } else {
-        // single path
-        if (pathTable_.find(producerPathLabels_[0]) != pathTable_.end() &&
-            (pathTable_[producerPathLabels_[0]]->getInterArrivalGap() <
-             HICN_MIN_INTER_ARRIVAL_GAP)) {
-          rtx_time = lastReceivedTime_ +
-                     pathTable_[producerPathLabels_[0]]->getInterArrivalGap();
-        }  // else low rate producer send immediatly
-      }
-    } else {
-      // second or plus rtx, wait for the min rtt
-      if (pathTable_.find(producerPathLabels_[0]) != pathTable_.end()) {
-        uint64_t sent_time = inflightInterests_[pkt].transmissionTime;
-        rtx_time = sent_time + pathTable_[producerPathLabels_[0]]->getMinRtt();
-      }  // if we don't have info we send it immediatly
-    }
-
-    if (now >= rtx_time) {
-      inflightInterests_[pkt].transmissionTime = now;
-      it->second++;
-
-      Name *interest_name = nullptr;
-      socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
-                               &interest_name);
-      interest_name->setSuffix(it->first);
-      TRANSPORT_LOGD("Send content interest %u (retransmit)",
-                     interest_name->getSuffix());
-      sendInterest(interest_name, true);
-    } else if (rtx_time < smallest_timeout) {
-      smallest_timeout = rtx_time;
-    }
-
-    ++it;
-  }
-  return smallest_timeout;
-}
-
-void RTCTransportProtocol::checkRtx() {
-  if (interestRetransmissions_.empty()) {
-    rtx_timer_used_ = false;
-    return;
-  }
-
-  uint64_t next_timeout = retransmit();
-  uint64_t wait = 1;
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-  if (next_timeout != ULONG_MAX && now < next_timeout) {
-    wait = next_timeout - now;
-  }
-  rtx_timer_used_ = true;
-  rtx_timer_->expires_from_now(std::chrono::milliseconds(wait));
-  rtx_timer_->async_wait([this](std::error_code ec) {
-    if (ec) return;
-    rtx_timer_used_ = false;
-    checkRtx();
-  });
-}
-
-void RTCTransportProtocol::onTimeout(Interest::Ptr &&interest) {
-  uint32_t segmentNumber = interest->getName().getSuffix();
-
-  if (segmentNumber >= HICN_MIN_PROBE_SEQ) {
-    // this is a timeout on a probe, do nothing
-    return;
-  }
-
-  uint32_t pkt = segmentNumber & modMask_;
-
-  if (TRANSPORT_EXPECT_FALSE(!firstPckReceived_)) {
-    // we do nothing, and we keep asking the same stuff over
-    // and over until we get at least a packet
-    inflightInterestsCount_--;
-    lastEvent_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-    packets_in_window_.erase(segmentNumber);
-    scheduleNextInterests();
-    return;
-  }
-
-  if (inflightInterests_[pkt].state == sent_) {
-    lastEvent_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-    packets_in_window_.erase(segmentNumber);
-    inflightInterestsCount_--;
-  }
-
-  // check how many times we sent this packet
-  auto it = interestRetransmissions_.find(segmentNumber);
-  if (it != interestRetransmissions_.end() && it->second >= HICN_MAX_RTX) {
-    inflightInterests_[pkt].state = lost_;
-  }
-
-  if (inflightInterests_[pkt].state == sent_) {
-    inflightInterests_[pkt].state = timeout1_;
-  } else if (inflightInterests_[pkt].state == timeout1_) {
-    inflightInterests_[pkt].state = timeout2_;
-  } else if (inflightInterests_[pkt].state == timeout2_) {
-    inflightInterests_[pkt].state = lost_;
-  }
-
-  if (inflightInterests_[pkt].state == lost_) {
-    interestRetransmissions_.erase(segmentNumber);
-  } else {
-    addRetransmissions(segmentNumber);
-  }
-
-  scheduleNextInterests();
-}
-
-bool RTCTransportProtocol::onNack(const ContentObject &content_object,
-                                  bool rtx) {
-  uint32_t *payload = (uint32_t *)content_object.getPayload()->data();
-  uint32_t productionSeg = *payload;
-  uint32_t productionRate = *(++payload);
-  uint32_t nackSegment = content_object.getName().getSuffix();
-
-  bool old_nack = false;
-
-  // if we did not received anything between lastReceived_ + 1 and productionSeg
-  // most likelly some packets got lost
-  if (lastReceived_ != 0) {
-    addRetransmissions(lastReceived_ + 1, productionSeg);
-  }
-
-  if (!rtx) {
-    gotNack_ = true;
-    // we synch the estimated production rate with the actual one
-    estimatedBw_ = (double)productionRate;
-  }
-
-  if (productionSeg > nackSegment) {
-    // we are asking for stuff produced in the past
-    actualSegment_ = max(productionSeg, actualSegment_) % HICN_MIN_PROBE_SEQ;
-
-    if (!rtx) {
-      if (currentState_ == HICN_RTC_NORMAL_STATE) {
-        currentState_ = HICN_RTC_SYNC_STATE;
-      }
-
-      computeMaxWindow(productionRate, 0);
-      increaseWindow();
-    }
-
-    lastSegNacked_ = productionSeg;
-    old_nack = true;
-
-  } else if (productionSeg < nackSegment) {
-    actualSegment_ = productionSeg % HICN_MIN_PROBE_SEQ;
-
-    if (!rtx) {
-      // we are asking stuff in the future
-      gotFutureNack_++;
-      computeMaxWindow(productionRate, 0);
-      decreaseWindow();
-
-      if (currentState_ == HICN_RTC_SYNC_STATE) {
-        currentState_ = HICN_RTC_NORMAL_STATE;
-      }
-    }
-  } else {
-    // we are asking the right thing, but the producer is slow
-    // keep doing the same until the packet is produced
-    actualSegment_ = productionSeg % HICN_MIN_PROBE_SEQ;
-  }
-
-  return old_nack;
-}
-
-void RTCTransportProtocol::onContentObject(
-    Interest::Ptr &&interest, ContentObject::Ptr &&content_object) {
-  // as soon as we get a packet firstPckReceived_ will never be false
-  firstPckReceived_ = true;
-
-  auto payload = content_object->getPayload();
-  uint32_t payload_size = (uint32_t)payload->length();
-  uint32_t segmentNumber = content_object->getName().getSuffix();
-  uint32_t pkt = segmentNumber & modMask_;
-
-  if (*on_content_object_input_) {
-    (*on_content_object_input_)(*socket_->getInterface(), *content_object);
-  }
-
-  if (segmentNumber >= HICN_MIN_PROBE_SEQ) {
-    TRANSPORT_LOGD("Received probe %u", segmentNumber);
-    if (segmentNumber == probe_seq_number_ && !received_probe_) {
-      received_probe_ = true;
-
-      uint32_t pathLabel = content_object->getPathLabel();
-      if (pathTable_.find(pathLabel) == pathTable_.end()) {
-        std::shared_ptr<RTCDataPath> newPath = std::make_shared<RTCDataPath>();
-        pathTable_[pathLabel] = newPath;
-      }
-
-      // this is the expected probe, update the RTT and drop the packet
-      uint64_t RTT = std::chrono::duration_cast<std::chrono::milliseconds>(
-                         std::chrono::steady_clock::now().time_since_epoch())
-                         .count() -
-                     time_sent_probe_;
-
-      pathTable_[pathLabel]->insertRttSample(RTT);
-      pathTable_[pathLabel]->receivedNack();
-    }
-    return;
-  }
-
-  // check if the packet is a rtx
-  bool is_rtx = false;
-  if (interestRetransmissions_.find(segmentNumber) !=
-      interestRetransmissions_.end()) {
-    is_rtx = true;
-  } else {
-    auto it_win = packets_in_window_.find(segmentNumber);
-    if (it_win != packets_in_window_.end() && it_win->second != 0)
-      is_rtx = true;
-  }
-
-  if (payload_size == HICN_NACK_HEADER_SIZE) {
-    TRANSPORT_LOGD("Received nack %u", segmentNumber);
-
-    if (inflightInterests_[pkt].state == sent_) {
-      lastEvent_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock::now().time_since_epoch())
-                       .count();
-      packets_in_window_.erase(segmentNumber);
-      inflightInterestsCount_--;
-    }
-
-    bool old_nack = false;
-
-    if (!is_rtx) {
-      // this is not a retransmitted packet
-      old_nack = onNack(*content_object, false);
-      updateDelayStats(*content_object);
-    } else {
-      old_nack = onNack(*content_object, true);
-    }
-
-    // the nacked_ state is used only to avoid to decrease
-    // inflightInterestsCount_ multiple times. In fact, every time that we
-    // receive an event related to an interest (timeout, nacked, content) we
-    // cange the state. In this way we are sure that we do not decrease twice
-    // the counter
-    if (old_nack) {
-      inflightInterests_[pkt].state = lost_;
-      interestRetransmissions_.erase(segmentNumber);
-    } else {
-      inflightInterests_[pkt].state = nacked_;
-    }
-
-  } else {
-    TRANSPORT_LOGD("Received content %u", segmentNumber);
-
-    avgPacketSize_ = (HICN_ESTIMATED_PACKET_SIZE * avgPacketSize_) +
-                     ((1 - HICN_ESTIMATED_PACKET_SIZE) * payload->length());
-
-    receivedBytes_ += (uint32_t)(content_object->headerSize() +
-                                 content_object->payloadSize());
-
-    if (inflightInterests_[pkt].state == sent_) {
-      lastEvent_ = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock::now().time_since_epoch())
-                       .count();
-      packets_in_window_.erase(segmentNumber);
-      inflightInterestsCount_--;  // packet sent without timeouts
-    }
-
-    if (inflightInterests_[pkt].state == sent_ && !is_rtx) {
-      // delay stats are computed only for non retransmitted data
-      updateDelayStats(*content_object);
-    }
-
-    addRetransmissions(lastReceived_ + 1, segmentNumber);
-    if (segmentNumber > highestReceived_) {
-      highestReceived_ = segmentNumber;
-    }
-    if (segmentNumber > lastReceived_) {
-      lastReceived_ = segmentNumber;
-      lastReceivedTime_ =
-          std::chrono::duration_cast<std::chrono::milliseconds>(
-              std::chrono::steady_clock::now().time_since_epoch())
-              .count();
-    }
-    receivedData_++;
-    inflightInterests_[pkt].state = received_;
-
-    auto it = interestRetransmissions_.find(segmentNumber);
-    if (it != interestRetransmissions_.end()) lossRecovered_++;
-
-    interestRetransmissions_.erase(segmentNumber);
-
-    reassemble(std::move(content_object));
-    increaseWindow();
-  }
-
-  scheduleNextInterests();
-}
-
-}  // end namespace protocol
-
-}  // end namespace transport