FEAT: Add hasher parsing support

configuration_examples/topology_examples/bus_topology.yml

@@ -1,6 +1,7 @@
 devices:
   sender1:
     type: host
+    hasher: symmetric
   sender2:
     type: host
   receiver1:
@@ -9,7 +10,7 @@ devices:
     type: host
   bus:
     type: switch
-    ecn:  
+    ecn:
       min: 0.2
       max: 0.3
       probability: 1.0
@@ -42,28 +43,28 @@ links:
     latency: 1ns
     throughput: 1Gbps
     ingress_buffer_size: 4096B
-    egress_buffer_size: 4096B    
+    egress_buffer_size: 4096B
   link5:
     from: receiver1
     to: bus
     latency: 1ns
     throughput: 1Gbps
     ingress_buffer_size: 4096B
-    egress_buffer_size: 4096B    
+    egress_buffer_size: 4096B
   link6:
     from: bus
     to: receiver1
     latency: 1ns
     throughput: 1Gbps
     ingress_buffer_size: 4096B
-    egress_buffer_size: 4096B    
+    egress_buffer_size: 4096B
   link7:
     from: receiver2
     to: bus
     latency: 1ns
     throughput: 1Gbps
     ingress_buffer_size: 4096B
-    egress_buffer_size: 4096B    
+    egress_buffer_size: 4096B
   link8:
     from: bus
     to: receiver2

source/device/host.cpp

@@ -2,12 +2,13 @@
 
 #include <spdlog/fmt/fmt.h>
 
+#include "link/i_link.hpp"
 #include "logger/logger.hpp"
-#include "utils/validation.hpp"
 
 namespace sim {
 
-Host::Host(Id a_id) : RoutingModule(a_id) {}
+Host::Host(Id a_id, std::unique_ptr<IHasher> a_hasher)
+    : RoutingModule(a_id, std::move(a_hasher)) {}
 
 bool Host::notify_about_arrival(Time arrival_time) {
     return m_process_scheduler.notify_about_arriving(arrival_time,

source/device/host.hpp

@@ -9,9 +9,11 @@
 
 namespace sim {
 
-class Host : public IHost, public RoutingModule, public std::enable_shared_from_this<Host> {
+class Host : public IHost,
+             public RoutingModule,
+             public std::enable_shared_from_this<Host> {
 public:
-    Host(Id id);
+    Host(Id id, std::unique_ptr<IHasher> a_hasher = nullptr);
     ~Host() = default;
 
     bool notify_about_arrival(Time arrive_time) final;

source/device/routing_module.hpp

@@ -7,7 +7,7 @@
 #include "utils/loop_iterator.hpp"
 
 namespace sim {
-    
+
 class RoutingModule : public virtual IRoutingDevice {
 public:
     RoutingModule(Id a_id = "", std::unique_ptr<IHasher> a_hasher = nullptr);
@@ -16,7 +16,8 @@ class RoutingModule : public virtual IRoutingDevice {
     Id get_id() const final;
     bool add_inlink(std::shared_ptr<ILink> link) final;
     bool add_outlink(std::shared_ptr<ILink> link) final;
-    bool update_routing_table(Id dest_id, std::shared_ptr<ILink> link, size_t paths_count = 1) final;
+    bool update_routing_table(Id dest_id, std::shared_ptr<ILink> link,
+                              size_t paths_count = 1) final;
     // returns next inlink and moves inlinks set iterator forward
     std::shared_ptr<ILink> next_inlink() final;
     std::shared_ptr<ILink> get_link_to_destination(Packet packet) const final;

source/device/switch.cpp

@@ -1,15 +1,12 @@
 #include "device/switch.hpp"
 
-#include <iostream>
-
+#include "link/i_link.hpp"
 #include "logger/logger.hpp"
-#include "utils/validation.hpp"
 
 namespace sim {
 
-Switch::Switch(Id a_id, ECN&& a_ecn)
-    : RoutingModule(a_id),
-      m_ecn(std::move(a_ecn)) {}
+Switch::Switch(Id a_id, ECN&& a_ecn, std::unique_ptr<IHasher> a_hasher)
+    : RoutingModule(a_id, std::move(a_hasher)), m_ecn(std::move(a_ecn)) {}
 
 bool Switch::notify_about_arrival(Time arrival_time) {
     return m_process_scheduler.notify_about_arriving(arrival_time,
@@ -29,7 +26,7 @@ Time Switch::process() {
 
     // requests queue size here to consider processing packet
     float ingress_queue_filling = link->get_to_ingress_queue_size() /
-                               (float)link->get_max_to_ingress_queue_size();
+                                  (float)link->get_max_to_ingress_queue_size();
     std::optional<Packet> optional_packet = link->get_packet();
     if (!optional_packet.has_value()) {
         LOG_WARN("No packet in link");

source/device/switch.hpp

@@ -1,16 +1,19 @@
 #pragma once
 
-#include "device/routing_module.hpp"
 #include "device/interfaces/i_switch.hpp"
+#include "device/routing_module.hpp"
 #include "device/scheduling_module.hpp"
 #include "ecn.hpp"
 #include "event/process.hpp"
 
 namespace sim {
 
-class Switch : public ISwitch, public RoutingModule, public std::enable_shared_from_this<Switch> {
+class Switch : public ISwitch,
+               public RoutingModule,
+               public std::enable_shared_from_this<Switch> {
 public:
-    Switch(Id a_id, ECN&& a_ecn = ECN(1.0, 1.0, 0.0));
+    Switch(Id a_id, ECN&& a_ecn = ECN(1.0, 1.0, 0.0),
+           std::unique_ptr<IHasher> a_hasher = nullptr);
     ~Switch() = default;
 
     bool notify_about_arrival(Time arrival_time) final;

source/parser/identifiable_parser/parse_host.cpp

@@ -1,13 +1,20 @@
+#include <memory>
+
 #include "device/host.hpp"
 #include "identifiable_parser.hpp"
+#include "parser/parse_utils.hpp"
+#include "utils/hasher.hpp"
 
 namespace sim {
 
 template <>
-std::shared_ptr<Host> Parser<Host>::parse_object(
-    const YAML::Node& key_node, const YAML::Node& value_node) {
-    (void)value_node;
-    return std::make_shared<Host>(key_node.as<Id>());
+std::shared_ptr<Host> Parser<Host>::parse_object(const YAML::Node& key_node,
+                                                 const YAML::Node& value_node) {
+    std::unique_ptr<IHasher> hasher = nullptr;
+    if (value_node["hasher"]) {
+        hasher = parse_hasher(value_node);
+    }
+    return std::make_shared<Host>(key_node.as<Id>(), std::move(hasher));
 }
 
-}  // namespace sim
+}  // namespace sim

source/parser/identifiable_parser/parse_switch.cpp

@@ -1,5 +1,7 @@
+#include "device/ecn.hpp"
 #include "device/switch.hpp"
 #include "identifiable_parser.hpp"
+#include "parser/parse_utils.hpp"
 
 namespace sim {
 static ECN parse_ecn(const YAML::Node& node) {
@@ -13,10 +15,17 @@ template <>
 std::shared_ptr<Switch> Parser<Switch>::parse_object(
     const YAML::Node& key_node, const YAML::Node& value_node) {
     Id id = key_node.as<Id>();
+    std::unique_ptr<IHasher> hasher = nullptr;
+    if (value_node["hasher"]) {
+        hasher = parse_hasher(value_node);
+    }
     const YAML::Node& ecn_node = value_node["ecn"];
     if (ecn_node) {
-        return std::make_shared<Switch>(id, parse_ecn(ecn_node));
+        return std::make_shared<Switch>(id, parse_ecn(ecn_node),
+                                        std::move(hasher));
     }
-    return std::make_shared<Switch>(id);
+    ECN default_ecn = ECN(1.0, 1.0, 0.0);
+    return std::make_shared<Switch>(id, std::move(default_ecn),
+                                    std::move(hasher));
 }
-}  // namespace sim
+}  // namespace sim

source/parser/parse_utils.cpp

@@ -2,8 +2,12 @@
 
 #include <spdlog/fmt/fmt.h>
 
+#include <memory>
 #include <stdexcept>
 
+#include "logger/logger.hpp"
+#include "utils/hasher.hpp"
+
 static std::pair<uint32_t, std::string> parse_value_unit(
     const std::string &value_with_unit) {
     const size_t unit_pos = value_with_unit.find_first_not_of("0123456789");
@@ -52,4 +56,20 @@ uint32_t parse_with_default(
         return default_value;
     }
     return value_parser(node[field_name].as<std::string>());
-}
+}
+
+std::unique_ptr<sim::IHasher> parse_hasher(const YAML::Node &node) {
+    const std::string hasher_field_name = "hasher";
+    const std::string hasher_value = node[hasher_field_name].as<std::string>();
+    if (hasher_value == "random") {
+        return std::make_unique<sim::RandomHasher>();
+    }
+    if (hasher_value == "base") {
+        return std::make_unique<sim::BaseHasher>();
+    }
+    if (hasher_value == "symmetric") {
+        return std::make_unique<sim::SymmetricHasher>();
+    }
+    LOG_WARN(fmt::format("Unknown hasher type: {}", hasher_value));
+    return std::make_unique<sim::BaseHasher>();
+}

source/parser/parse_utils.hpp

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "logger/logger.hpp"
+#include "utils/hasher.hpp"
 
 uint32_t parse_throughput(const std::string& throughput);
 uint32_t parse_latency(const std::string& latency);
@@ -17,3 +18,5 @@ uint32_t parse_with_default(
     const YAML::Node& node, std::string_view field_name,
     std::function<uint32_t(const std::string&)> value_parser,
     uint32_t default_value);
+
+std::unique_ptr<sim::IHasher> parse_hasher(const YAML::Node& node);