resolve conversations

Author: root

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>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<Bit>(value_64));
     }
     if (unit == Byte::suffix) {
-        return SizeByte(static_cast<uint64_t>(value));
+        return SizeByte(value_64);
     }
     if (unit == KBit::suffix) {
-        return SizeByte(Size<KBit>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<KBit>(value_64));
     }
     if (unit == KByte::suffix) {
-        return SizeByte(Size<KByte>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<KByte>(value_64));
     }
     if (unit == MBit::suffix) {
-        return SizeByte(Size<MBit>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<MBit>(value_64));
     }
     if (unit == MByte::suffix) {
-        return SizeByte(Size<MByte>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<MByte>(value_64));
     }
     if (unit == GBit::suffix) {
-        return SizeByte(Size<GBit>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<GBit>(value_64));
     }
     if (unit == GByte::suffix) {
-        return SizeByte(Size<GByte>(static_cast<uint64_t>(value)));
+        return SizeByte(Size<GByte>(value_64));
     }
     return std::unexpected("Unsupported size unit: " + unit);
 }

source/topology/link/i_link.hpp

@@ -9,11 +9,17 @@
 namespace sim {
 
 struct LinkContext {
+    struct ActivityTime {
+        TimeNs first;
+        TimeNs last;
+
+        TimeNs active_time() const { return last - first; }
+    };
+
     SpeedGbps speed;
     TimeNs latency;
-    std::optional<TimeNs> m_first_activity_time = std::nullopt;
-    std::optional<TimeNs> m_last_activiti_time = std::nullopt;
-    SizeByte m_total_data = SizeByte(0ul);
+    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) <
@@ -55,6 +61,9 @@ class ILink : public Identifiable, public IMetricable {
     virtual SizeByte get_max_to_ingress_queue_size() const = 0;
 
     virtual const LinkContext& get_ctx() const = 0;
+
+protected:
+    virtual void record_activity() = 0;
 };
 
 }  // namespace sim

source/topology/link/link.cpp

@@ -2,8 +2,6 @@
 
 #include <spdlog/fmt/fmt.h>
 
-#include <algorithm>
-
 #include "logger/logger.hpp"
 #include "scheduler/scheduler.hpp"
 #include "utils/filesystem.hpp"
@@ -32,6 +30,7 @@ void Link::schedule_arrival(const Packet& packet) {
                         m_id, packet.to_string()));
         return;
     }
+    record_activity();
 
     if (empty_before_push) {
         start_head_packet_sending();
@@ -137,11 +136,9 @@ void Link::transmit() {
         return;
     }
 
-    TimeNs current_time = Scheduler::get_instance().get_current_time();
+    record_activity();
 
-    if (!m_ctx.m_first_activity_time.has_value()) {
-        m_ctx.m_first_activity_time = current_time;
-    }
+    TimeNs current_time = Scheduler::get_instance().get_current_time();
 
     Scheduler::get_instance().add(
         current_time + m_ctx.latency,
@@ -163,14 +160,8 @@ void Link::arrive(const Packet& packet) {
                         m_id, packet.to_string()));
         return;
     }
-
+    record_activity();
     m_to.lock()->notify_about_arrival();
-    if (!m_ctx.m_last_activiti_time.has_value()) {
-        m_ctx.m_last_activiti_time = std::make_optional<TimeNs>(0ul);
-    }
-    m_ctx.m_last_activiti_time.value() =
-        std::max(m_ctx.m_last_activiti_time.value(),
-                 Scheduler::get_instance().get_current_time());
 
     LOG_INFO("Packet arrived to the next device. Packet: " +
              packet.to_string());
@@ -183,49 +174,18 @@ void Link::start_head_packet_sending() {
         [link = shared_from_this()]() { link->transmit(); });
 }
 
-void Link::write_queue_metrics_to_csv(std::ofstream& out,
-                                      const LinkQueue& queue) const {
-    if (queue.get_type() == LinkQueueType::FromEgress) {
-        out << "Egress buffer (switch)\n";
-    } else {
-        out << "Ingress buffer (host)\n";
-    }
-
-    out << "Maximal size"
-        << ", Average size"
-        << ", Peak size"
-        << ", Packets transmitted"
-        << ", Packets dropped"
-        << ", Drop percent\n";
-
-    std::optional<SizeByte> average_opt =
-        queue.get_ctx().size_statistics.get_mean();
-    SizeByte average =
-        (average_opt.has_value() ? average_opt.value() : SizeByte(0ul));
-    double drop_percent =
-        queue.get_ctx().packets_dropped /
-        static_cast<double>(queue.get_ctx().packets_dropped +
-                            queue.get_ctx().packets_transmitted);
-
-    out << queue.get_ctx().size << ", " << average << ", "
-        << queue.get_max_size() << ", " << queue.get_ctx().packets_transmitted
-        << ", " << queue.get_ctx().packets_dropped << ", " << drop_percent
-        << "\n\n";
-}
-
 void Link::write_inner_metrics(std::filesystem::path output_dir) const {
-    std::filesystem::path output_path = output_dir / "metrics.csv";
+    std::filesystem::path output_path = output_dir / "summary.csv";
     utils::create_all_directories(output_path);
     std::ofstream out(output_path);
     if (!out) {
         throw std::runtime_error(fmt::format(
-            "Failed to create file for summary: {}", output_path.string()));
+            "Failed to create file for report of link '{}': (file path: {})",
+            m_id, output_path.string()));
     }
     write_thoughput_to_csv(out);
-
-    write_queue_metrics_to_csv(out, m_to_ingress);
-
-    write_queue_metrics_to_csv(out, m_from_egress);
+    m_to_ingress.write_queue_metrics_to_csv(out);
+    m_from_egress.write_queue_metrics_to_csv(out);
 }
 
 void Link::write_thoughput_to_csv(std::ofstream& out) const {
@@ -236,28 +196,36 @@ void Link::write_thoughput_to_csv(std::ofstream& out) const {
         << ", Utilization"
         << ", Latency\n";
 
-    if (!m_ctx.m_first_activity_time || !m_ctx.m_last_activiti_time) {
+    if (!m_ctx.activity_time.has_value()) {
         out << m_ctx.speed << ", " << 0 << ", " << 0 << ", " << m_ctx.latency
             << "\n\n";
         return;
     }
 
-    TimeNs elapsed_time = m_ctx.m_last_activiti_time.value() -
-                          m_ctx.m_first_activity_time.value();
+    TimeNs elapsed_time = m_ctx.activity_time.value().active_time();
 
-    if (elapsed_time.value() == 0) {
+    if (elapsed_time == TimeNs(0)) {
         out << m_ctx.speed << ", " << 0 << ", " << 0 << ", " << m_ctx.latency
             << "\n\n";
         return;
     }
 
-    uint64_t actual = m_ctx.m_total_data.value() / elapsed_time.value();
+    SpeedGbps actual = m_ctx.total_data_transferred / elapsed_time;
 
-    uint64_t utilization =
-        (m_ctx.speed.value() == 0 ? 0 : actual / m_ctx.speed.value());
+    double utilization =
+        (m_ctx.speed == SpeedGbps(0) ? 0.0 : actual / m_ctx.speed);
 
     out << m_ctx.speed << ", " << actual << ", " << utilization << ", "
         << m_ctx.latency << "\n\n";
 }
 
+void Link::record_activity() {
+    TimeNs now = Scheduler::get_instance().get_current_time();
+    if (!m_ctx.activity_time.has_value()) {
+        m_ctx.activity_time = LinkContext::ActivityTime{now, now};
+    } else {
+        m_ctx.activity_time->last = now;
+    }
+}
+
 }  // namespace sim

source/topology/link/link.hpp

@@ -49,6 +49,9 @@ class Link : public ILink, public std::enable_shared_from_this<Link> {
     virtual void write_inner_metrics(
         std::filesystem::path output_dir) const final;
 
+protected:
+    void record_activity() override;
+
 private:
     Link(Id a_id, std::weak_ptr<IDevice> a_from, std::weak_ptr<IDevice> a_to,
          SpeedGbps a_speed, TimeNs a_delay,
@@ -68,9 +71,6 @@ class Link : public ILink, public std::enable_shared_from_this<Link> {
     // Schedule Transmit event
     void start_head_packet_sending();
 
-    void write_queue_metrics_to_csv(std::ofstream& out,
-                                    const LinkQueue& queue) const;
-
     void write_thoughput_to_csv(std::ofstream& out) const;
 
 private:

source/topology/link/packet_queue/link_queue.cpp

@@ -57,11 +57,46 @@ LinkQueueType LinkQueue::get_type() const { return m_type; }
 
 const LinkQueueContext& LinkQueue::get_ctx() const { return m_ctx; }
 
+void LinkQueue::write_queue_metrics_to_csv(std::ofstream& out) const {
+    if (m_type == LinkQueueType::FromEgress) {
+        out << "Egress buffer of " << m_link_id << "\n";
+    } else {
+        out << "Ingress buffer of " << m_link_id << "\n";
+    }
+
+    out << "Maximal size"
+        << ", Average size"
+        << ", Peak size"
+        << ", Packets transmitted"
+        << ", Packets dropped"
+        << ", Drop percent\n";
+
+    const utils::Statistics<SizeByte> statistics = m_ctx.size_statistics;
+
+    SizeByte average = statistics.get_mean().value_or(SizeByte(0ul));
+
+    double drop_percent = 0;
+    double total_packets =
+        static_cast<double>(m_ctx.packets_dropped + m_ctx.packets_transmitted);
+    if (total_packets > 0) {
+        drop_percent = m_ctx.packets_dropped / total_packets;
+    }
+
+    out << get_max_size();
+    out << ", " << average;
+    out << ", " << statistics.get_peak().value_or(SizeByte(0ul));
+    out << ", " << m_ctx.packets_transmitted;
+    out << ", " << m_ctx.packets_dropped;
+    out << ", " << drop_percent;
+    out << "\n\n";
+}
+
 void LinkQueue::record_size() {
     TimeNs now = Scheduler::get_instance().get_current_time();
     SizeByte queue_size = m_queue.get_size();
     m_queue_size_storage->add_record(now, queue_size.value());
-    m_ctx.size_statistics.add_record(m_queue.get_size());
+    m_ctx.size_statistics.add_record(queue_size);
+    m_ctx.size = queue_size;
 }
 
 }  // namespace sim

source/topology/link/packet_queue/link_queue.hpp

@@ -25,18 +25,18 @@ class LinkQueue {
     LinkQueue(SizeByte a_max_size, Id a_link_id, LinkQueueType a_type);
     ~LinkQueue() = default;
 
-    virtual bool push(const Packet& packet) final;
-    virtual const Packet& front() const final;
-    virtual Packet& front() final;
-    virtual void pop() final;
-
-    virtual SizeByte get_max_size() const final;
-    virtual LinkQueueType get_type() const final;
-    virtual bool empty() const final;
+    bool push(const Packet& packet);
+    const Packet& front() const;
+    Packet& front();
+    void pop();
+
+    SizeByte get_max_size() const;
+    LinkQueueType get_type() const;
+    bool empty() const;
     const LinkQueueContext& get_ctx() const;
+    void write_queue_metrics_to_csv(std::ofstream& out) const;
 
-    virtual std::shared_ptr<const MetricsStorage> get_queue_size_storage()
-        const;
+    std::shared_ptr<const MetricsStorage> get_queue_size_storage() const;
 
 private:
     void record_size();

source/utils/statistics.hpp

@@ -37,6 +37,9 @@ class Statistics {
             m_variance =
                 m_variance * m_factor + (delta * delta) * (1 - m_factor);
         }
+        if (!m_peak || record > *m_peak) {
+            m_peak = record;
+        }
     }
 
     std::optional<T> get_last() const {
@@ -57,12 +60,15 @@ class Statistics {
                                : std::nullopt);
     }
 
+    std::optional<T> get_peak() const { return m_peak; }
+
 private:
     bool m_have_records;
     const double m_factor;
     double m_last;
     double m_mean;
     double m_variance;
+    std::optional<T> m_peak;
 };
 
 }  // namespace utils

test/device/utils.cpp

@@ -36,4 +36,6 @@ SizeByte TestLink::get_max_to_ingress_queue_size() const {
 
 const Id& TestLink::get_id() const { return ""; }
 
+void TestLink::record_activity() {}
+
 }  // namespace test

test/device/utils.hpp

@@ -48,6 +48,9 @@ class TestLink : public sim::ILink {
 
     virtual const sim::LinkContext& get_ctx() const final { return m_ctx; }
 
+protected:
+    void record_activity() override;
+
 private:
     std::weak_ptr<sim::IDevice> src;
     std::weak_ptr<sim::IDevice> dst;

test/switch/link_mock.cpp

@@ -40,3 +40,5 @@ SizeByte LinkMock::get_max_to_ingress_queue_size() const {
 }
 
 const Id& LinkMock::get_id() const { return ""; }
+
+void LinkMock::record_activity() {}