BUG: Fix delivery rate (#425)

Delivery rate should take into account the pacing delay.

Author: drgulevich

source/flow/i_flow.hpp

@@ -16,6 +16,7 @@ class IFlow : public Identifiable {
     virtual void send_packet() = 0;
     virtual std::shared_ptr<IConnection> get_conn() const = 0;
     virtual SizeByte get_delivered_data_size() const = 0;
+    virtual TimeNs get_fct() const = 0;
     virtual std::shared_ptr<IHost> get_sender() const = 0;
     virtual std::shared_ptr<IHost> get_receiver() const = 0;
 };

source/flow/tcp/tcp_flow.cpp

@@ -30,13 +30,19 @@ TcpFlow::TcpFlow(Id a_id, std::shared_ptr<IConnection> a_conn,
     if (m_dest.lock() == nullptr) {
         throw std::invalid_argument("Receiver for TcpFlow is nullptr");
     }
+    m_init_time = Scheduler::get_instance().get_current_time();
     initialize_flag_manager();
 }
 
 SizeByte TcpFlow::get_delivered_data_size() const {
     return m_delivered_data_size;
 }
 
+TimeNs TcpFlow::get_fct() const {
+    TimeNs now = Scheduler::get_instance().get_current_time();
+    return now - m_init_time;
+}
+
 std::shared_ptr<IHost> TcpFlow::get_sender() const { return m_src.lock(); }
 
 std::shared_ptr<IHost> TcpFlow::get_receiver() const { return m_dest.lock(); }
@@ -94,6 +100,7 @@ Packet TcpFlow::create_ack(Packet data) {
     ack.dest_id = m_src.lock()->get_id();
     ack.size = SizeByte(1);
     ack.flow = this;
+    ack.generated_time = data.generated_time;
     ack.sent_time = data.sent_time;
     ack.delivered_data_size_at_origin = data.delivered_data_size_at_origin;
     ack.ttl = M_MAX_TTL;
@@ -198,7 +205,7 @@ void TcpFlow::update(Packet packet) {
 
         SpeedGbps delivery_rate =
             (m_delivered_data_size - packet.delivered_data_size_at_origin) /
-            rtt;
+            (current_time - packet.generated_time);
         MetricsCollector::get_instance().add_delivery_rate(
             packet.flow->get_id(), current_time, delivery_rate);
 

source/flow/tcp/tcp_flow.hpp

@@ -21,6 +21,7 @@ class TcpFlow : public IFlow, public std::enable_shared_from_this<TcpFlow> {
     void update(Packet packet) final;
 
     SizeByte get_delivered_data_size() const final;
+    TimeNs get_fct() const final;
     std::shared_ptr<IHost> get_sender() const final;
     std::shared_ptr<IHost> get_receiver() const;
     Id get_id() const final;
@@ -48,6 +49,7 @@ class TcpFlow : public IFlow, public std::enable_shared_from_this<TcpFlow> {
     Packet generate_packet();
 
     TimeNs get_max_timeout() const;
+    TimeNs m_init_time;
     void send_packet_now(Packet packet);
     void retransmit_packet(PacketNum packet_num);
 

source/packet.cpp

@@ -5,13 +5,15 @@
 namespace sim {
 
 Packet::Packet(SizeByte a_size, IFlow* a_flow, Id a_source_id, Id a_dest_id,
-               TimeNs a_sent_time, SizeByte a_delivered_data_size_at_origin,
+               TimeNs a_generated_time, TimeNs a_sent_time,
+               SizeByte a_delivered_data_size_at_origin,
                bool a_ecn_capable_transport, bool a_congestion_experienced)
     : flags(0),
       source_id(a_source_id),
       dest_id(a_dest_id),
       size(a_size),
       flow(a_flow),
+      generated_time(a_generated_time),
       sent_time(a_sent_time),
       delivered_data_size_at_origin(a_delivered_data_size_at_origin),
       ecn_capable_transport(a_ecn_capable_transport),
@@ -32,6 +34,7 @@ std::string Packet::to_string() const {
     oss << ", packet_num: " << packet_num;
     oss << ", size(byte): " << size;
     oss << ", flow: " << (flow ? "set" : "null");
+    oss << ", generated time: " << generated_time;
     oss << ", sent time: " << sent_time;
     oss << ", TTL: " << ttl;
     oss << ", flags: " << flags.get_bits();

source/packet.hpp

@@ -10,7 +10,7 @@ namespace sim {
 struct Packet {
     Packet(SizeByte a_size = SizeByte(0), IFlow* a_flow = nullptr,
            Id a_source_id = "", Id a_dest_id = "",
-           TimeNs a_sent_time = TimeNs(0),
+           TimeNs a_generated_time = TimeNs(0), TimeNs a_sent_time = TimeNs(0),
            SizeByte a_delivered_at_origin = SizeByte(0),
            bool a_ecn_capable_transport = true,
            bool a_congestion_experienced = false);
@@ -24,6 +24,8 @@ struct Packet {
     Id dest_id;
     SizeByte size;
     IFlow* flow;
+    TimeNs generated_time;  // Note: ACK's generated time is the data packet
+                            // generated time
     TimeNs sent_time;  // Note: ACK's sent time is the data packet sent time
     SizeByte delivered_data_size_at_origin;  // For ACK this is inherited from
                                              // data packet

source/utils/summary.cpp

@@ -4,16 +4,19 @@
 
 namespace sim {
 
-Summary::Summary(std::map<Id, std::map<Id, SizeByte>> a_values)
+Summary::Summary(std::map<Id, std::map<Id, SpeedGbps>> a_values)
     : m_values(std::move(a_values)) {}
 
-Summary::Summary(const std::unordered_set<std::shared_ptr<IConnection>>& connections) {
+Summary::Summary(
+    const std::unordered_set<std::shared_ptr<IConnection>>& connections) {
     for (const auto& conn : connections) {
         Id conn_id = conn->get_id();
         auto flows = conn->get_flows();
         for (const auto& flow : flows) {
-            m_values[conn_id].insert(std::make_pair(
-                flow->get_id(), flow->get_delivered_data_size()));
+            SpeedGbps throughput =
+                flow->get_delivered_data_size() / flow->get_fct();
+            m_values[conn_id].insert(
+                std::make_pair(flow->get_id(), throughput));
         }
     }
 }
@@ -24,7 +27,7 @@ void Summary::write_to_csv(std::filesystem::path output_path) const {
     if (!out) {
         throw std::runtime_error("Failed to create file for summary");
     }
-    out << "Conn id, Flow id, Delivered data (bytes)\n";
+    out << "Conn id, Flow id, Throughput (Gbps)\n";
     for (const auto& [conn_id, flows] : m_values) {
         for (const auto& [flow_id, value] : flows) {
             out << conn_id << ", " << flow_id << ", " << value << "\n";

source/utils/summary.hpp

@@ -2,8 +2,8 @@
 #include <filesystem>
 #include <unordered_set>
 
-#include "flow/i_flow.hpp"
 #include "connection/i_connection.hpp"
+#include "flow/i_flow.hpp"
 #include "types.hpp"
 
 namespace sim {
@@ -12,13 +12,14 @@ namespace sim {
 // Maps flow Ids to count of delivered bytes
 class Summary {
 public:
-    Summary(std::map<Id, std::map<Id, SizeByte>> values);
-    Summary(const std::unordered_set<std::shared_ptr<IConnection>>& connections);
+    Summary(std::map<Id, std::map<Id, SpeedGbps>> values);
+    Summary(
+        const std::unordered_set<std::shared_ptr<IConnection>>& connections);
 
     void write_to_csv(std::filesystem::path output_path) const;
 
 private:
-    std::map<Id, std::map<Id, SizeByte>> m_values;
+    std::map<Id, std::map<Id, SpeedGbps>> m_values;
 };
 
 }  // namespace sim

test/switch/flow_mock.cpp

@@ -9,10 +9,9 @@ void FlowMock::update([[maybe_unused]] sim::Packet packet) {};
 
 std::uint32_t FlowMock::get_sending_quota() const { return 1; }
 void FlowMock::send_packet() {}
-std::shared_ptr<sim::IConnection> FlowMock::get_conn() const {
-    return nullptr;
-}
+std::shared_ptr<sim::IConnection> FlowMock::get_conn() const { return nullptr; }
 SizeByte FlowMock::get_delivered_data_size() const { return SizeByte(0); }
+TimeNs FlowMock::get_fct() const { return TimeNs(0); }
 
 std::shared_ptr<sim::IHost> FlowMock::get_sender() const { return nullptr; }
 std::shared_ptr<sim::IHost> FlowMock::get_receiver() const {

test/switch/flow_mock.hpp

@@ -14,6 +14,7 @@ class FlowMock : public sim::IFlow {
     void send_packet() final;
     std::shared_ptr<sim::IConnection> get_conn() const final;
     virtual SizeByte get_delivered_data_size() const final;
+    virtual TimeNs get_fct() const final;
 
     std::shared_ptr<sim::IHost> get_sender() const final;
     std::shared_ptr<sim::IHost> get_receiver() const final;