refactor(lib, hicn-light, vpp, hiperf): HICN-723

 - move infra data structure into the shared lib
 - new packet cache using double hashing and lookup on prefix suffix
 - testing updates
 - authenticated requests using interest manifests

Co-authored-by: Mauro Sardara <msardara@cisco.com>
Co-authored-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Co-authored-by: Michele Papalini <micpapal@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Enrico Loparco <eloparco@cisco.com>

Change-Id: Iaddebfe6aa5279ea8553433b0f519578f6b9ccd9
Signed-off-by: Luca Muscariello <muscariello@ieee.org>

1 files changed, 85 insertions, 21 deletions

diff --git a/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc
index c6bc751e6..4bbd7eac0 100644
--- a/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc
+++ b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc
@@ -14,6 +14,7 @@
  */
 
 #include <hicn/transport/interfaces/notification.h>
+#include <protocols/rtc/rtc_consts.h>
 #include <protocols/rtc/rtc_forwarding_strategy.h>
 
 namespace transport {
@@ -24,8 +25,13 @@ namespace rtc {
 
 using namespace transport::interface;
 
+const double FWD_MAX_QUEUE = 30.0;              // ms
+const double FWD_MAX_RTT = MAX_RTT_BEFORE_FEC;  // ms
+const double FWD_MAX_LOSS_RATE = 0.1;
+
 RTCForwardingStrategy::RTCForwardingStrategy()
-    : init_(false),
+    : low_rate_app_(false),
+      init_(false),
       forwarder_set_(false),
       selected_strategy_(NONE),
       current_strategy_(NONE),
@@ -42,17 +48,56 @@ void RTCForwardingStrategy::setCallback(
 
 void RTCForwardingStrategy::initFwdStrategy(
     std::shared_ptr<core::Portal> portal, core::Prefix& prefix, RTCState* state,
-    strategy_t strategy) {
-  init_ = true;
-  selected_strategy_ = strategy;
-  if (strategy == BOTH)
-    current_strategy_ = BEST_PATH;
-  else
-    current_strategy_ = strategy;
-  rounds_since_last_set_ = 0;
-  prefix_ = prefix;
-  portal_ = portal;
-  state_ = state;
+    interface::RtcTransportRecoveryStrategies strategy) {
+  switch (strategy) {
+    case interface::RtcTransportRecoveryStrategies::LOW_RATE_AND_BESTPATH:
+      init_ = true;
+      low_rate_app_ = true;
+      selected_strategy_ = BEST_PATH;
+      current_strategy_ = BEST_PATH;
+      break;
+    case interface::RtcTransportRecoveryStrategies::LOW_RATE_AND_REPLICATION:
+      init_ = true;
+      low_rate_app_ = true;
+      selected_strategy_ = REPLICATION;
+      current_strategy_ = REPLICATION;
+      break;
+    case interface::RtcTransportRecoveryStrategies::
+        LOW_RATE_AND_ALL_FWD_STRATEGIES:
+      init_ = true;
+      low_rate_app_ = true;
+      selected_strategy_ = BEST_PATH;
+      current_strategy_ = BEST_PATH;
+      break;
+    case interface::RtcTransportRecoveryStrategies::DELAY_AND_BESTPATH:
+      init_ = true;
+      low_rate_app_ = false;
+      selected_strategy_ = BEST_PATH;
+      current_strategy_ = BEST_PATH;
+      break;
+    case interface::RtcTransportRecoveryStrategies::DELAY_AND_REPLICATION:
+      init_ = true;
+      low_rate_app_ = false;
+      selected_strategy_ = REPLICATION;
+      current_strategy_ = REPLICATION;
+      break;
+    case interface::RtcTransportRecoveryStrategies::RECOVERY_OFF:
+    case interface::RtcTransportRecoveryStrategies::RTX_ONLY:
+    case interface::RtcTransportRecoveryStrategies::FEC_ONLY:
+    case interface::RtcTransportRecoveryStrategies::DELAY_BASED:
+    case interface::RtcTransportRecoveryStrategies::LOW_RATE:
+    case interface::RtcTransportRecoveryStrategies::FEC_ONLY_LOW_RES_LOSSES:
+    default:
+      // fwd strategies are not used
+      init_ = false;
+  }
+
+  if (init_) {
+    rounds_since_last_set_ = 0;
+    prefix_ = prefix;
+    portal_ = portal;
+    state_ = state;
+  }
 }
 
 void RTCForwardingStrategy::checkStrategy() {
@@ -99,16 +144,35 @@ void RTCForwardingStrategy::checkStrategyBestPath() {
     return;
   }
 
-  uint8_t qs = state_->getQualityScore();
+  if (low_rate_app_) {
+    // this is used for gaming
+    uint8_t qs = state_->getQualityScore();
 
-  if (qs >= 4 || rounds_since_last_set_ < 25) {  // wait a least 5 sec
-                                                 // between each switch
-    rounds_since_last_set_++;
-    return;
-  }
+    if (qs >= 4 || rounds_since_last_set_ < 25) {  // wait a least 5 sec
+                                                   // between each switch
+      rounds_since_last_set_++;
+      return;
+    }
 
-  // try to switch path
-  setStrategy(BEST_PATH);
+    // try to switch path
+    setStrategy(BEST_PATH);
+  } else {
+    if (rounds_since_last_set_ < 25) {  // wait a least 5 sec
+                                        // between each switch
+      rounds_since_last_set_++;
+      return;
+    }
+
+    double queue = state_->getQueuing();
+    double rtt = state_->getAvgRTT();
+    double loss_rate = state_->getPerSecondLossRate();
+
+    if (queue >= FWD_MAX_QUEUE || rtt >= FWD_MAX_RTT ||
+        loss_rate > FWD_MAX_LOSS_RATE) {
+      // try to switch path
+      setStrategy(BEST_PATH);
+    }
+  }
 }
 
 void RTCForwardingStrategy::checkStrategyReplication() {
@@ -133,7 +197,7 @@ void RTCForwardingStrategy::checkStrategyBoth() {
 
   // TODO
   // for the moment we use only best path.
-  // but later:
+  // for later:
   // 1. if both paths are bad use replication
   // 2. while using replication compute the effectiveness. if the majority of
   //    the packets are coming from a single path, try to use bestpath