feat: boostrap hicn 22.02

The current patch provides several new features, improvements,
bug fixes and also complete rewrite of entire components.

- lib
The hicn packet parser has been improved with a new packet
format fully based on UDP. The TCP header is still temporarily
supported but the UDP header will replace completely the new hicn
packet format. Improvements have been made to make sure every
packet parsing operation is made via this library. The current
new header can be used as header between the payload and the
UDP header or as trailer in the UDP surplus area to be tested
when UDP options will start to be used.

- hicn-light
The portable packet forwarder has been completely rewritten from
scratch with the twofold objective to improve performance and
code size but  also to drop dependencies such as libparc which is
now removed by the current implementation.

- hicn control
the control library is the agent that is used to program the
packet forwarders via their binary API. This component has
benefited from significant improvements in terms of interaction
model which is now event driven and more robust to failures.

- VPP plugin has been updated to support VPP 22.02

- transport
Major improvement have been made to the RTC protocol, to the
support of IO modules and to the security sub system. Signed
manifests are the default data authenticity and integrity framework.
Confidentiality can be enabled by sharing the encryption key to the
prod/cons layer. The library has been tested with group key based
applications such as broadcast/multicast and real-time on-line
meetings with trusted server keys or MLS.

- testing
Unit testing has been introduced using GoogleTest. One third of
the code base is covered by unit testing with priority on
critical features. Functional testing has also been introduce
using Docker, linux bridging and Robot Framework to define
test with Less Code techniques to facilitate the extension
of the coverage.

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: Angelo Mantellini <manangel@cisco.com>
Co-authored-by: Jacques Samain <jsamain@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Enrico Loparco <eloparco@cisco.com>
Co-authored-by: Giulio Grassi <gigrassi@cisco.com>

Change-Id: I75d0ef70f86d921e3ef503c99271216ff583c215
Signed-off-by: Luca Muscariello <muscariello@ieee.org>
Signed-off-by: Mauro Sardara <msardara@cisco.com>

23 files changed, 298 insertions, 51 deletions

diff --git a/libtransport/includes/hicn/transport/utils/CMakeLists.txt b/libtransport/includes/hicn/transport/utils/CMakeLists.txt
index 75f727f03..bbd149e09 100644
--- a/libtransport/includes/hicn/transport/utils/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/utils/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 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:
@@ -19,6 +19,7 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/chrono_typedefs.h
   ${CMAKE_CURRENT_SOURCE_DIR}/branch_prediction.h
   ${CMAKE_CURRENT_SOURCE_DIR}/ring_buffer.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_quality_score.h
   ${CMAKE_CURRENT_SOURCE_DIR}/literals.h
   ${CMAKE_CURRENT_SOURCE_DIR}/conversions.h
   ${CMAKE_CURRENT_SOURCE_DIR}/linux.h
diff --git a/libtransport/includes/hicn/transport/utils/array.h b/libtransport/includes/hicn/transport/utils/array.h
index 7c0ed65d8..d57bfabaf 100644
--- a/libtransport/includes/hicn/transport/utils/array.h
+++ b/libtransport/includes/hicn/transport/utils/array.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/branch_prediction.h b/libtransport/includes/hicn/transport/utils/branch_prediction.h
index 8cbfaca76..626cb1573 100644
--- a/libtransport/includes/hicn/transport/utils/branch_prediction.h
+++ b/libtransport/includes/hicn/transport/utils/branch_prediction.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/chrono_typedefs.h b/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
index 8f28e763c..ddfbd00cd 100644
--- a/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
+++ b/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
@@ -17,11 +17,102 @@
 
 #include <chrono>
 
+namespace std {
+namespace chrono {
+namespace detail {
+
+template <typename From, typename To>
+struct posix_duration_cast;
+
+// chrono -> timespec caster
+template <typename Rep, typename Period>
+struct posix_duration_cast<std::chrono::duration<Rep, Period>,
+                           struct timespec> {
+  static struct timespec cast(std::chrono::duration<Rep, Period> const &d) {
+    struct timespec tv;
+
+    std::chrono::seconds const sec =
+        std::chrono::duration_cast<std::chrono::seconds>(d);
+
+    tv.tv_sec = sec.count();
+    tv.tv_nsec =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(d - sec).count();
+
+    return tv;
+  }
+};
+
+// timespec -> chrono caster
+template <typename Rep, typename Period>
+struct posix_duration_cast<struct timespec,
+                           std::chrono::duration<Rep, Period>> {
+  static std::chrono::duration<Rep, Period> cast(struct timespec const &tv) {
+    return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(
+        std::chrono::seconds(tv.tv_sec) + std::chrono::nanoseconds(tv.tv_nsec));
+  }
+};
+
+}  // namespace detail
+
+// chrono -> timespec
+template <typename T, typename Rep, typename Period>
+auto duration_cast(std::chrono::duration<Rep, Period> const &d) ->
+    typename std::enable_if<std::is_same<T, struct timespec>::value,
+                            struct timespec>::type {
+  return detail::posix_duration_cast<std::chrono::duration<Rep, Period>,
+                                     timespec>::cast(d);
+}
+
+// timespec -> chrono
+template <typename Duration>
+Duration duration_cast(struct timespec const &tv) {
+  return detail::posix_duration_cast<struct timespec, Duration>::cast(tv);
+}
+
+}  // namespace chrono
+}  // namespace std
+
 namespace utils {
 
-using SteadyClock = std::chrono::steady_clock;
-using TimePoint = SteadyClock::time_point;
-using Milliseconds = std::chrono::milliseconds;
-using Microseconds = std::chrono::microseconds;
+template <typename T>
+class Time {
+ public:
+  using Clock = T;
+  using TimePoint = typename Clock::time_point;
+  using Rep = double;
+  using Seconds = std::chrono::duration<Rep>;
+  using Milliseconds = std::chrono::duration<Rep, std::milli>;
+  using Microseconds = std::chrono::duration<Rep, std::micro>;
+
+  static auto now() { return Clock::now(); }
+
+  // From epochs
+  static auto nowMs() {
+    return std::chrono::duration_cast<Milliseconds>(now().time_since_epoch());
+  }
+
+  // From epoch
+  static auto nowUs() {
+    return std::chrono::duration_cast<Microseconds>(now().time_since_epoch());
+  }
+
+  template <typename D>
+  static auto getDuration(const TimePoint &start, const TimePoint &end) {
+    return std::chrono::duration_cast<D>(end - start);
+  }
+
+  static auto getDurationS(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Seconds>(start, end);
+  }
+  static auto getDurationMs(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Milliseconds>(start, end);
+  }
+  static auto getDurationUs(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Microseconds>(start, end);
+  }
+};
+
+using SteadyTime = Time<std::chrono::steady_clock>;
+using SystemTime = Time<std::chrono::system_clock>;
 
 }  // namespace utils
diff --git a/libtransport/includes/hicn/transport/utils/conversions.h b/libtransport/includes/hicn/transport/utils/conversions.h
index 52d3e3168..812803175 100644
--- a/libtransport/includes/hicn/transport/utils/conversions.h
+++ b/libtransport/includes/hicn/transport/utils/conversions.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/daemonizator.h b/libtransport/includes/hicn/transport/utils/daemonizator.h
index 028d74865..1d0a0b309 100644
--- a/libtransport/includes/hicn/transport/utils/daemonizator.h
+++ b/libtransport/includes/hicn/transport/utils/daemonizator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/event_thread.h b/libtransport/includes/hicn/transport/utils/event_thread.h
index 15ec1d62c..2cd2f3aca 100644
--- a/libtransport/includes/hicn/transport/utils/event_thread.h
+++ b/libtransport/includes/hicn/transport/utils/event_thread.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
@@ -97,6 +97,19 @@ class EventThread {
     io_service_.get().dispatch(std::forward<Func&&>(f));
   }
 
+  template <typename Func>
+  void addAndWaitForExecution(Func&& f) {
+    auto promise = std::promise<void>();
+    auto future = promise.get_future();
+
+    asio::dispatch(io_service_.get(), [&promise, f = std::forward<Func>(f)]() {
+      f();
+      promise.set_value();
+    });
+
+    future.wait();
+  }
+
   void stop() {
     work_.reset();
 
diff --git a/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h b/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
index 298b6f9d1..19b52b37e 100644
--- a/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
+++ b/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
@@ -1,23 +1,28 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
 #pragma once
 
 #include <hicn/transport/portability/c_portability.h>
+#include <hicn/transport/utils/branch_prediction.h>
 #include <hicn/transport/utils/singleton.h>
 #include <hicn/transport/utils/spinlock.h>
 #include <stdint.h>
 
 #include <cassert>
 #include <cstdlib>
+#include <list>
 #include <memory>
 
 namespace utils {
 template <std::size_t SIZE = 512, std::size_t OBJECTS = 4096>
 class FixedBlockAllocator
-    : public utils::Singleton<FixedBlockAllocator<SIZE, OBJECTS>> {
-  friend class utils::Singleton<FixedBlockAllocator<SIZE, OBJECTS>>;
+    : public utils::ThreadLocalSingleton<FixedBlockAllocator<SIZE, OBJECTS>> {
+  friend class utils::ThreadLocalSingleton<FixedBlockAllocator<SIZE, OBJECTS>>;
+
+  static inline const std::size_t BLOCK_SIZE = SIZE;
+  static inline const std::size_t BLOCKS_PER_POOL = OBJECTS;
 
  public:
   ~FixedBlockAllocator() {
@@ -26,19 +31,19 @@ class FixedBlockAllocator
     }
   }
 
-  void* allocateBlock(size_t size = SIZE) {
-    assert(size <= SIZE);
+  void* allocateBlock() {
     uint32_t index;
-
     SpinLock::Acquire locked(lock_);
     void* p_block = pop();
     if (!p_block) {
-      if (TRANSPORT_EXPECT_FALSE(current_pool_index_ >= max_objects_)) {
+      if (TRANSPORT_EXPECT_FALSE(current_pool_index_ >= BLOCKS_PER_POOL)) {
         // Allocate new memory block
         p_pools_.emplace_front(
-            new typename std::aligned_storage<SIZE>::type[max_objects_]);
+            new typename std::aligned_storage<SIZE>::type[BLOCKS_PER_POOL]);
         // reset current_pool_index_
         current_pool_index_ = 0;
+        // Increase total block count
+        block_count_ += BLOCKS_PER_POOL;
       }
 
       auto& latest = p_pools_.front();
@@ -59,7 +64,7 @@ class FixedBlockAllocator
   }
 
  public:
-  std::size_t blockSize() { return block_size_; }
+  std::size_t blockSize() { return BLOCK_SIZE; }
 
   uint32_t blockCount() { return block_count_; }
 
@@ -69,20 +74,32 @@ class FixedBlockAllocator
 
   uint32_t deallocations() { return deallocations_; }
 
+  void reset() {
+    p_head_ = nullptr;
+    blocks_in_use_ = 0;
+    allocations_ = 0;
+    deallocations_ = 0;
+    current_pool_index_ = 0;
+    block_count_ = BLOCKS_PER_POOL;
+
+    // Delete all memory pools but the first one
+    for (auto it = std::next(p_pools_.begin()); it != p_pools_.end();) {
+      delete[] * it;
+      it = p_pools_.erase(it);
+    }
+  }
+
  private:
   FixedBlockAllocator()
-      : block_size_(SIZE),
-        object_size_(SIZE),
-        max_objects_(OBJECTS),
-        p_head_(NULL),
+      : p_head_(NULL),
         current_pool_index_(0),
-        block_count_(0),
+        block_count_(BLOCKS_PER_POOL),
         blocks_in_use_(0),
         allocations_(0),
         deallocations_(0) {
     static_assert(SIZE >= sizeof(long*), "SIZE must be at least 8 bytes");
     p_pools_.emplace_front(
-        new typename std::aligned_storage<SIZE>::type[max_objects_]);
+        new typename std::aligned_storage<SIZE>::type[BLOCKS_PER_POOL]);
   }
 
   void push(void* p_memory) {
@@ -106,12 +123,6 @@ class FixedBlockAllocator
     Block* p_next;
   };
 
-  static std::unique_ptr<FixedBlockAllocator> instance_;
-
-  const std::size_t block_size_;
-  const std::size_t object_size_;
-  const std::size_t max_objects_;
-
   Block* p_head_;
   uint32_t current_pool_index_;
   std::list<typename std::aligned_storage<SIZE>::type*> p_pools_;
@@ -123,10 +134,6 @@ class FixedBlockAllocator
   SpinLock lock_;
 };
 
-template <std::size_t A, std::size_t B>
-std::unique_ptr<FixedBlockAllocator<A, B>>
-    FixedBlockAllocator<A, B>::instance_ = nullptr;
-
 /**
  * STL Allocator trait to be used with allocate_shared.
  */
diff --git a/libtransport/includes/hicn/transport/utils/hash.h b/libtransport/includes/hicn/transport/utils/hash.h
index 6815ca4bf..7943596e6 100644
--- a/libtransport/includes/hicn/transport/utils/hash.h
+++ b/libtransport/includes/hicn/transport/utils/hash.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/libtransport/includes/hicn/transport/utils/linux.h b/libtransport/includes/hicn/transport/utils/linux.h
index 4fbf5f01e..03d29c1db 100644
--- a/libtransport/includes/hicn/transport/utils/linux.h
+++ b/libtransport/includes/hicn/transport/utils/linux.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/literals.h b/libtransport/includes/hicn/transport/utils/literals.h
index bd00e0a58..531f67362 100644
--- a/libtransport/includes/hicn/transport/utils/literals.h
+++ b/libtransport/includes/hicn/transport/utils/literals.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/log.h b/libtransport/includes/hicn/transport/utils/log.h
index 0947b755e..f4d39b6b1 100644
--- a/libtransport/includes/hicn/transport/utils/log.h
+++ b/libtransport/includes/hicn/transport/utils/log.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/move_wrapper.h b/libtransport/includes/hicn/transport/utils/move_wrapper.h
index 5dc3b461d..73389948d 100644
--- a/libtransport/includes/hicn/transport/utils/move_wrapper.h
+++ b/libtransport/includes/hicn/transport/utils/move_wrapper.h
@@ -23,6 +23,7 @@ namespace utils {
 template <typename F>
 struct MoveWrapper : F {
   MoveWrapper(F&& f) : F(std::move(f)) {}
+  ~MoveWrapper() = default;
 
   MoveWrapper(MoveWrapper&&) = default;
   MoveWrapper& operator=(MoveWrapper&&) = default;
diff --git a/libtransport/includes/hicn/transport/utils/noncopyable.h b/libtransport/includes/hicn/transport/utils/noncopyable.h
index 83923e647..0c54d24a3 100644
--- a/libtransport/includes/hicn/transport/utils/noncopyable.h
+++ b/libtransport/includes/hicn/transport/utils/noncopyable.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/object_pool.h b/libtransport/includes/hicn/transport/utils/object_pool.h
index d9b28e663..63288c655 100644
--- a/libtransport/includes/hicn/transport/utils/object_pool.h
+++ b/libtransport/includes/hicn/transport/utils/object_pool.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/utils/branch_prediction.h>
+#include <hicn/transport/utils/noncopyable.h>
 #include <hicn/transport/utils/spinlock.h>
 
 #include <deque>
@@ -25,7 +26,7 @@
 namespace utils {
 
 template <typename T>
-class ObjectPool {
+class ObjectPool : private utils::NonCopyable {
   class ObjectDeleter {
    public:
     ObjectDeleter(ObjectPool<T> *pool = nullptr) : pool_(pool) {}
@@ -47,8 +48,20 @@ class ObjectPool {
 
   ObjectPool() : destructor_(false) {}
 
-  // No copies
-  ObjectPool(const ObjectPool &other) = delete;
+  ObjectPool(ObjectPool &&other)
+      : object_pool_lock_(std::move(other.object_pool_lock_)),
+        object_pool_(std::move(other.object_pool_)),
+        destructor_(other.destructor_) {}
+
+  ObjectPool &operator=(ObjectPool &&other) {
+    if (this != &other) {
+      object_pool_lock_ = std::move(other.object_pool_lock_);
+      object_pool_ = std::move(other.object_pool_);
+      destructor_ = other.destructor_;
+    }
+
+    return *this;
+  }
 
   ~ObjectPool() {
     destructor_ = true;
diff --git a/libtransport/includes/hicn/transport/utils/ring_buffer.h b/libtransport/includes/hicn/transport/utils/ring_buffer.h
index 52629b82b..3032032c9 100644
--- a/libtransport/includes/hicn/transport/utils/ring_buffer.h
+++ b/libtransport/includes/hicn/transport/utils/ring_buffer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/rtc_quality_score.h b/libtransport/includes/hicn/transport/utils/rtc_quality_score.h
new file mode 100644
index 000000000..2e8ca97d3
--- /dev/null
+++ b/libtransport/includes/hicn/transport/utils/rtc_quality_score.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#pragma once
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RTCQualityScore {
+ public:
+  RTCQualityScore(){};
+  ~RTCQualityScore(){};
+
+  uint8_t getQualityScore(uint64_t RTT, uint32_t loss_rate) {
+    uint32_t delay_index = getDelay(RTT);
+    uint32_t loss_index = getLossRate(loss_rate);
+    return quality_score_[loss_index][delay_index];
+  }
+
+ private:
+  // see quality score map
+  uint8_t quality_score_[7][6]{{5, 5, 5, 4, 3, 1}, {5, 4, 3, 2, 1, 1},
+                               {5, 3, 2, 1, 1, 1}, {5, 2, 1, 1, 1, 1},
+                               {4, 1, 1, 1, 1, 1}, {3, 1, 1, 1, 1, 1},
+                               {1, 1, 1, 1, 1, 1}};
+
+  uint8_t getDelay(uint64_t RTT) {
+    uint64_t OWD = RTT / 2;
+    // we should never get a OWD of 0. so we take the first col if OWD is < 5ms
+    if (OWD < 5) return 0;
+    if (OWD < 50) return 1;
+    if (OWD < 100) return 2;
+    if (OWD < 200) return 3;
+    if (OWD < 300) return 4;
+    return 5;
+  }
+
+  uint8_t getLossRate(uint32_t loss_rate) {
+    // we use 3% as mean loss rate
+    if (loss_rate < 3) return 0;
+    if (loss_rate < 10) return 1;
+    if (loss_rate < 20) return 2;
+    if (loss_rate < 30) return 3;
+    if (loss_rate < 40) return 4;
+    if (loss_rate < 50) return 5;
+    return 6;
+  }
+};
+
+}  // namespace rtc
+
+}  // namespace protocol
+
+}  // namespace transport
diff --git a/libtransport/includes/hicn/transport/utils/singleton.h b/libtransport/includes/hicn/transport/utils/singleton.h
index 4b7b19c0a..cdd8b03bf 100644
--- a/libtransport/includes/hicn/transport/utils/singleton.h
+++ b/libtransport/includes/hicn/transport/utils/singleton.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
@@ -32,4 +32,17 @@ class Singleton : NonCopyable {
   ~Singleton() {}
 };
 
+template <typename T>
+class ThreadLocalSingleton : NonCopyable {
+ public:
+  static T& getInstance() {
+    static thread_local T instance;
+    return instance;
+  }
+
+ protected:
+  ThreadLocalSingleton() {}
+  ~ThreadLocalSingleton() {}
+};
+
 }  // namespace utils
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/utils/spinlock.h b/libtransport/includes/hicn/transport/utils/spinlock.h
index 009a94454..40fc48de3 100644
--- a/libtransport/includes/hicn/transport/utils/spinlock.h
+++ b/libtransport/includes/hicn/transport/utils/spinlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/string_tokenizer.h b/libtransport/includes/hicn/transport/utils/string_tokenizer.h
index 36630eb58..2b2b893a0 100644
--- a/libtransport/includes/hicn/transport/utils/string_tokenizer.h
+++ b/libtransport/includes/hicn/transport/utils/string_tokenizer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/string_utils.h b/libtransport/includes/hicn/transport/utils/string_utils.h
index 313c28cc6..5f9cca13b 100644
--- a/libtransport/includes/hicn/transport/utils/string_utils.h
+++ b/libtransport/includes/hicn/transport/utils/string_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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:
diff --git a/libtransport/includes/hicn/transport/utils/thread_pool.h b/libtransport/includes/hicn/transport/utils/thread_pool.h
new file mode 100644
index 000000000..e4e47209c
--- /dev/null
+++ b/libtransport/includes/hicn/transport/utils/thread_pool.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#pragma once
+
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/noncopyable.h>
+
+#include <thread>
+#include <vector>
+
+namespace utils {
+
+class ThreadPool : public NonCopyable {
+ public:
+  explicit ThreadPool(
+      std::size_t n_threads = std::thread::hardware_concurrency())
+      : workers_(n_threads > 0 ? n_threads : 1) {}
+
+  std::size_t getNThreads() const { return workers_.size(); }
+  EventThread &getWorker(std::size_t i) { return workers_.at(i); }
+
+ private:
+  std::vector<EventThread> workers_;
+};
+
+}  // namespace utils
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/utils/uri.h b/libtransport/includes/hicn/transport/utils/uri.h
index 7c28e8552..30675e880 100644
--- a/libtransport/includes/hicn/transport/utils/uri.h
+++ b/libtransport/includes/hicn/transport/utils/uri.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 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: