FEAT: add links reports (#553)

close #552

---------

Co-authored-by: root <root@zfk.localdomain>

Author: S1mpotyaga

source/network/connection/connection.cpp

@@ -11,7 +11,7 @@ std::shared_ptr<Connection> Connection::create_shared(
 
 Connection::Connection(Id a_id, std::shared_ptr<IMPLB> a_mplb)
     : m_id(std::move(a_id)),
-      m_context{SizeByte(0), SizeByte(0)},
+      m_context{SizeByte(0ul), SizeByte(0ul)},
       m_mplb(a_mplb) {}
 
 utils::StrExpected<void> Connection::send_data(Data data,
@@ -28,7 +28,7 @@ utils::StrExpected<void> Connection::send_data(Data data,
             Scheduler::get_instance().get_current_time();
     }
     m_data_context_table[data_id] =
-        DataContext{data.size, SizeByte(0), SizeByte(0), callback};
+        DataContext{data.size, SizeByte(0ul), SizeByte(0ul), callback};
     m_context.total_data_added += data.size;
     m_sending_queue.push(data_id);
 
@@ -67,7 +67,7 @@ void Connection::send_new_portion() {
         }
 
         SizeByte quota = m_mplb->get_context().sending_quota;
-        if (quota == SizeByte(0)) {
+        if (quota == SizeByte(0ul)) {
             LOG_INFO(fmt::format(
                 "Sending quota is zero; could not send data with id {}",
                 id.to_string()));

source/network/connection/flow/flows_summary/flows_summary.cpp

@@ -29,7 +29,7 @@ void FlowsSummary::write_to_csv(std::filesystem::path output_path) const {
                  ? ctx.last_ack_receive_time.value() - ctx.start_time.value()
                  : TimeNs(0));
 
-        double overhead = ctx.delivered_size != SizeByte(0)
+        double overhead = ctx.delivered_size != SizeByte(0ul)
                               ? (ctx.sent_size / ctx.delivered_size - 1) * 100
                               : std::nan("");
         // Effective delivery rate is average delivery rate calculated on the

source/network/connection/flow/i_flow.hpp

@@ -11,9 +11,9 @@
 namespace sim {
 
 struct FlowContext : FlowFourTuple {
-    SizeByte sent_size = SizeByte(0);
-    SizeByte delivered_size = SizeByte(0);
-    SizeByte retransmit_size = SizeByte(0);
+    SizeByte sent_size = SizeByte(0ul);
+    SizeByte delivered_size = SizeByte(0ul);
+    SizeByte retransmit_size = SizeByte(0ul);
 
     std::optional<TimeNs> start_time = std::nullopt;
     std::optional<TimeNs> last_ack_receive_time = std::nullopt;

source/network/connection/flow/packet.hpp

@@ -15,10 +15,10 @@ struct Packet;
 using OnPacketDeliveryCallback = std::function<void(const Packet&)>;
 
 struct Packet : FourTuple {
-    Packet(SizeByte a_size = SizeByte(0), Id a_source_id = "",
+    Packet(SizeByte a_size = SizeByte(0ul), Id a_source_id = "",
            Id a_dest_id = "", TimeNs a_generated_time = TimeNs(0),
            TimeNs a_sent_time = TimeNs(0),
-           SizeByte a_delivered_at_origin = SizeByte(0),
+           SizeByte a_delivered_at_origin = SizeByte(0ul),
            bool a_ecn_capable_transport = true,
            bool a_congestion_experienced = false);
 

source/network/connection/flow/tcp/tcp_flow.cpp

@@ -138,7 +138,7 @@ void TcpFlow::process_data_packet(const Packet& data,
     ack.sender_port = m_context.receiver_port;
     ack.receiver_id = IdWithHash(m_context.sender->get_id());
     ack.receiver_port = m_context.sender_port;
-    ack.size = SizeByte(1);
+    ack.size = SizeByte(1ul);
     ack.ttl = M_MAX_TTL;
     auto exp_void = ack.flags.set_flag(m_packet_type_label, PacketType::ACK);
     if (!exp_void.has_value()) {

source/network/connection/i_connection.hpp

@@ -12,8 +12,8 @@
 namespace sim {
 
 struct ConnectionContext {
-    SizeByte total_data_added = SizeByte(0);
-    SizeByte total_data_delivered = SizeByte(0);
+    SizeByte total_data_added = SizeByte(0ul);
+    SizeByte total_data_delivered = SizeByte(0ul);
     utils::Statistics<SpeedGbps> delivery_rate_statistics =
         utils::Statistics<SpeedGbps>();
     std::optional<TimeNs> first_send_data_time = std::nullopt;

source/network/connection/mplb/single_cc/single_cc_mplb.cpp

@@ -23,9 +23,9 @@ SingleCCMplb::SingleCCMplb(MetricableCC a_cc,
                            SizeByte a_packet_size,
                            SingleCCMetricsFilters a_metrics_filters)
     : m_cc(std::move(a_cc)),
-      m_sent_data_size(0),
-      m_delivered_data_size(0),
-      m_packets_in_flight(0),
+      m_sent_data_size(0ul),
+      m_delivered_data_size(0ul),
+      m_packets_in_flight(0ul),
       m_path_chooser(std::move(a_path_chooser)),
       m_packet_size(a_packet_size),
       m_delivery_rate_fairness(m_path_chooser->get_flows_table()),
@@ -44,7 +44,7 @@ utils::StrExpected<void> SingleCCMplb::send_data(Data data,
     TimeNs shift(0);
 
     std::size_t packets_count =
-        (data.size + m_packet_size - SizeByte(1)) / m_packet_size;
+        (data.size + m_packet_size - SizeByte(1ul)) / m_packet_size;
 
     std::shared_ptr<utils::CallbackObserver> observer =
         std::make_shared<utils::CallbackObserver>(packets_count, callback);

source/network/connection/mplb/single_cc/single_cc_mplb.hpp

@@ -20,7 +20,7 @@ class SingleCCMplb : public IMPLB,
 
     static std::shared_ptr<SingleCCMplb> create_shared(
         MetricableCC a_cc, std::unique_ptr<IPathChooser> a_path_chooser,
-        SizeByte a_packet_size = SizeByte(1500),
+        SizeByte a_packet_size = SizeByte(1500ul),
         SingleCCMetricsFilters a_metrics_filters = DEFAULT_METRICS_FILTERS);
 
     [[nodiscard]] virtual utils::StrExpected<void> send_data(

source/parser/parse_utils.cpp

@@ -84,30 +84,31 @@ utils::StrExpected<SizeByte> parse_size(const std::string &size) {
         return std::unexpected(maybe_value_unit.error());
     }
 
-    auto [value, unit] = maybe_value_unit.value();
+    auto [value_32, unit] = maybe_value_unit.value();
+    uint64_t value_64 = static_cast<uint64_t>(value_32);
     if (unit == Bit::suffix) {
-        return SizeByte(Size<Bit>(value));
+        return SizeByte(Size<Bit>(value_64));
     }
     if (unit == Byte::suffix) {
-        return SizeByte(value);
+        return SizeByte(value_64);
     }
     if (unit == KBit::suffix) {
-        return SizeByte(Size<KBit>(value));
+        return SizeByte(Size<KBit>(value_64));
     }
     if (unit == KByte::suffix) {
-        return SizeByte(Size<KByte>(value));
+        return SizeByte(Size<KByte>(value_64));
     }
     if (unit == MBit::suffix) {
-        return SizeByte(Size<MBit>(value));
+        return SizeByte(Size<MBit>(value_64));
     }
     if (unit == MByte::suffix) {
-        return SizeByte(Size<MByte>(value));
+        return SizeByte(Size<MByte>(value_64));
     }
     if (unit == GBit::suffix) {
-        return SizeByte(Size<GBit>(value));
+        return SizeByte(Size<GBit>(value_64));
     }
     if (unit == GByte::suffix) {
-        return SizeByte(Size<GByte>(value));
+        return SizeByte(Size<GByte>(value_64));
     }
     return std::unexpected("Unsupported size unit: " + unit);
 }

source/topology/link/i_link.hpp

@@ -9,8 +9,15 @@
 namespace sim {
 
 struct LinkContext {
+    struct ActivityTime {
+        TimeNs first;
+        TimeNs last;
+    };
+
     SpeedGbps speed;
     TimeNs latency;
+    std::optional<ActivityTime> activity_time = std::nullopt;
+    SizeByte total_data_transferred = SizeByte(0ul);
 
     bool operator<(const LinkContext& ctx) const {
         return std::make_pair(speed, latency) <