Performance Analysis of TCP Reno Congestion Control Under Varying Round-Trip Time Conditions | NS3 Project 14

Performance Analysis of TCP Reno Congestion Control Under Varying Round-Trip Time Conditions: An ns-3 Simulation Study

 

PROMPT

Part 1:

You are an expert in ns-3 network simulation and C++.

I want you to design and implement a complete ns-3 simulation in C++ to analyze the performance of TCP Reno over a point-to-point link with varying RTT values (10 ms to 200 ms).

Requirements:

1. Simulation Setup

●        Create a point-to-point network topology (2 nodes).

●        Configure link parameters such as:

○        Data rate (choose a reasonable default like 5 Mbps or 10 Mbps)

○        Packet size

○        Queue type (DropTail or similar)

●        Use TCP Reno as the transport protocol.

●        Ensure RTT variation is achieved by modifying propagation delay (range: 10 ms to 200 ms in steps).

2. Traffic Configuration

●        Use a TCP application (e.g., BulkSendApplication or OnOffApplication).

●        Configure a receiver using PacketSink.

●        Run simulations for multiple RTT values.

3. Metrics to Analyze
   Collect and output the following:

●        Throughput

●        Packet loss

●        End-to-end delay

●        Congestion window (cwnd) behavior over time

4. Tracing and Logging

●        Enable trace files for:

○        Congestion window (cwnd)

○        Packet drops

○        Throughput

●        Generate a trace matrix (trace files/logs) that can be used for analysis.

5. NetAnim Visualization

●        Integrate NetAnim:

○        Generate an XML animation file.

○        Ensure node positions and packet flows are visible.

6. PCAP / Wireshark Support

●        Enable PCAP tracing so that the simulation output can be analyzed in Wireshark.

●        Clearly mention how to open and inspect the generated PCAP files.

7. Graph Generation (Gnuplot)

●        Generate output files compatible with Gnuplot.

●        Provide scripts or instructions to plot:

○        RTT vs Throughput

○        RTT vs Packet Loss

○        Time vs Congestion Window

8. Code Structure

●        Write clean, modular C++ code compatible with ns-3.

●        Include comments explaining each section.

●        Ensure the code compiles and runs without errors.

9. Execution Instructions
   After writing the code, provide:

●        Steps to compile and run the simulation in ns-3

●        Commands to enable tracing

●        Steps to view:

○        NetAnim visualization

○        Wireshark (PCAP files)

○        Gnuplot graphs

10. Expected Output Explanation

●        Briefly explain what trends are expected when RTT increases (e.g., effect on throughput and cwnd).

 

Part 2

You are an expert in ns-3 and C++.

I have already implemented a TCP Reno RTT analysis simulation in ns-3. Now I want you to update and refine the existing implementation with the following changes:

1. Integrate FlowMonitor

Enhance the simulation by adding FlowMonitor to collect detailed performance metrics.

Include FlowMonitor module:
#include "ns3/flow-monitor-module.h"

●         

●        Install FlowMonitor on all nodes.

●        Collect and compute:

○        Throughput per flow

○        Packet loss

○        Delay statistics

●        Output results in a readable format (console + optional XML file).

2. Output Enhancements

●        Ensure FlowMonitor results are:

○        Printed clearly after simulation ends

○        Optionally exported to an XML file (e.g., flowmon.xml)

3. Maintain Existing Features

Make sure the following features remain intact:

●        RTT variation (10 ms to 200 ms)

●        NetAnim XML generation

●        PCAP tracing (for Wireshark)

●        Trace files (cwnd, drops, etc.)

●        Gnuplot-compatible output

4. Code Quality

●        Keep the code modular and well-commented

●        Avoid redundancy while integrating FlowMonitor

●        Ensure compatibility with standard ns-3 versions

5. Execution Instructions Update

Update the run instructions to reflect:

●        New filename (tcp-reno-rtt-analysis.cc)

●        FlowMonitor output usage

●        Any new compilation flags if required

 

 

 

CODE:

 

/* ===================================================================
*
* TCP Reno Performance Analysis over a Point-to-Point Link with Varying RTT
* ns-3 version : 3.42
* Author ID : 24BPS1135
*
* ─────────────────────────────────────────────────────────────────────
* TOPOLOGY (one instance per simulation run)
* ─────────────────────────────────────────────────────────────────────
*
* n0 (BulkSend) ──────[P2P 10 Mbps | delay = RTT/2]────── n1 (PacketSink)
*
* ────────────────────────────────────────────────────────────────────
* WHAT THIS SIMULATION DOES
* ─────────────────────────────────────────────────────────────────────
* Sweeps RTT values {10, 25, 50, 75, 100, 125, 150, 175, 200} ms by running
* 9 back-to-back ns-3 simulations. Each run collects:
*
* Via FlowMonitor
* • Throughput (Mbps)
* • Goodput (Mbps) – application-layer useful bytes / time
* • Packet loss ratio
* • Average / min / max end-to-end delay (ms)
* • Mean jitter (ms)
* • Tx / Rx packet & byte counts
*

* Via trace callbacks
* • Congestion window over time → cwnd_rtt_Xms.dat
*
* ────────────────────────────────────────────────────────────────────
* OUTPUT FILES (all written to scratch/results/)
─────────────────────────────────────────────────────────────────────
* summary.dat RTT | Throughput | Goodput | Loss | Delay | Jitter
* cwnd_rtt_Xms.dat Time(s) | cwnd(segments) – one file per RTT
* flowmon_rtt_Xms.xml FlowMonitor XML export – one file per RTT
* tcp-reno-rtt-Xms.tr ASCII link-level trace – one file per RTT
* tcp-reno-rtt-0-0.pcap Sender PCAP (RTT = 10 ms only)
* tcp-reno-rtt-0-1.pcap Receiver PCAP (RTT = 10 ms only)
* tcp-reno-netanim.xml NetAnim animation (RTT = 10 ms only)
*
────────────────────────────────────────────────────────────────────
* COMPILE & RUN (from the ns-3 root directory)
 ────────────────────────────────────────────────────────────────────
* mkdir -p scratch/results
* ./ns3 build scratch/24BPS1135
* ./ns3 run scratch/24BPS1135
*
* VISUALISE

* Wireshark : wireshark scratch/results/tcp-reno-rtt-0-0.pcap
* NetAnim : ./netanim-3.109/NetAnim → open tcp-reno-netanim.xml
* FlowMonitor: open scratch/results/flowmon_rtt_Xms.xml in any XML viewer
* Gnuplot : gnuplot scratch/plot_throughput.plt
* gnuplot scratch/plot_loss.plt
* gnuplot scratch/plot_cwnd.plt
* =====================================================================
/
// ── Standard library ──────────────────────────────────────────────────────────
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <sys/stat.h> // POSIX mkdir(2)
// ── ns-3 modules ──────────────────────────────────────────────────────────────
#include "ns3/applications-module.h"
#include "ns3/core-module.h"
#include "ns3/flow-monitor-module.h" // FlowMonitor – per-flow statistics
#include "ns3/internet-module.h"
#include "ns3/netanim-module.h" // NetAnim XML animation
#include "ns3/network-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/traffic-control-module.h"
using namespace ns3;

NS_LOG_COMPONENT_DEFINE("24BPS1135");

// =============================================================================

// GLOBAL STATE

// Shared between simulation runs and trace callbacks.

// All global variables are prefixed with g_.

// =============================================================================

/// Per-run congestion-window output stream (opened/closed in RunSimulation)

static std::ofstream g_cwndStream;

/// Cross-run summary file (opened once in main(), closed at the very end)

static std::ofstream g_summaryStream;

/// TCP Maximum Segment Size – used by the cwnd callback to convert bytes→segs

static uint32_t g_segmentSize = 1024; // bytes

// =============================================================================

// TRACE CALLBACKS

// =============================================================================

/**

* CwndChange

* ──────────

* Invoked automatically by the ns-3 tracing subsystem whenever the sender's

* congestion window (CongestionWindow attribute) changes.

*

* Output format (tab-separated, written to g_cwndStream):

* <simulation_time_s> <TAB> <cwnd_in_segments>

*

* Converting bytes → segments gives an intuitive unit for the Gnuplot graph.

*

* @param oldCwnd Previous cwnd value in bytes (unused, required by signature)

* @param newCwnd New cwnd value in bytes

*/

static void

CwndChange(uint32_t /* oldCwnd */, uint32_t newCwnd)

{

g_cwndStream << std::fixed << std::setprecision(6)

<< Simulator::Now().GetSeconds() << "\t"

<< static_cast<double>(newCwnd) / g_segmentSize << "\n";

}

// =============================================================================

// HELPER: connect the cwnd trace source after the TCP socket exists

// =============================================================================

/**

* ConnectCwndTrace

* ─────────────────

* Called via Simulator::Schedule() ~1 ms after BulkSend::StartApplication()

* so that the TCP socket has been created and appears in SocketList.

*

* Trace path explained:

* /NodeList/0 → sender node (index 0)

* $ns3::TcpL4Protocol → TCP layer object

* /SocketList/0 → first (and only) TCP socket

* /CongestionWindow → traced uint32 attribute

*/

static void

ConnectCwndTrace()

{

Config::ConnectWithoutContext(

"/NodeList/0/$ns3::TcpL4Protocol/SocketList/0/CongestionWindow",

MakeCallback(&CwndChange));

}

// =============================================================================

// FLOWMONITOR REPORTING

// Separated into its own function to keep RunSimulation() readable.

// =============================================================================

/**

* PrintFlowMonitorStats

* ──────────────────────

* Extracts per-flow statistics from FlowMonitor after the simulation ends,

* prints a detailed human-readable report to stdout, exports the full XML

* record to disk, and returns the four summary scalars needed by the

* cross-run summary table.

*

* FlowMonitor statistics used

* ───────────────────────────

* fs.txPackets / rxPackets / lostPackets

* Counters maintained by the FlowProbe installed on each node.

*

* fs.txBytes / rxBytes

* Byte counters including all headers (IP + TCP + payload).

* Throughput = rxBytes * 8 / duration (Mbps).

*

* fs.delaySum

* Sum of (rxTimestamp – txTimestamp) over all received packets.

* Average delay = delaySum / rxPackets.

*

* fs.jitterSum

* Sum of |delay_i – delay_{i-1}| (inter-arrival jitter).

* Mean jitter = jitterSum / (rxPackets – 1).

*

* fs.timeFirstRxPacket / timeLastRxPacket

* Wall-clock time of the first/last packet received by the sink.

* Using this window for throughput avoids the TCP handshake dead time.

*

* @param monitor Active FlowMonitor object (post-simulation)

* @param flowHelper Helper used to retrieve the classifier

* @param port Destination port of the flow of interest

* @param rttMs RTT of this run (for labelling only)

* @param xmlFile Filesystem path for the FlowMonitor XML export

* @param[out] tput Computed throughput in Mbps

* @param[out] loss Computed packet loss ratio [0,1]

* @param[out] delay Computed average delay in ms

* @param[out] jitter Computed mean jitter in ms

*/

static void

PrintFlowMonitorStats(Ptr<FlowMonitor> monitor,

FlowMonitorHelper& flowHelper,

uint32_t port,

uint32_t rttMs,

const std::string& xmlFile,

double& tput,

double& loss,

double& delay,

double& jitter)

{

// Ask FlowMonitor to mark any packets still in-flight as lost

monitor->CheckForLostPackets();

// Export the full XML record (histograms + probe samples + flow stats)

// enableHistograms=true, enableProbes=true

monitor->SerializeToXmlFile(xmlFile, true, true);

std::cout << " FlowMonitor XML → " << xmlFile << "\n";

Ptr<Ipv4FlowClassifier> classifier =

DynamicCast<Ipv4FlowClassifier>(flowHelper.GetClassifier());

FlowMonitor::FlowStatsContainer stats = monitor->GetFlowStats();

// Print a header banner

std::cout << "\n"

<< " ┌─────────────────────────────────────────────────┐\n"

<< " │ FlowMonitor Report – RTT = " << std::setw(4) << rttMs

<< " ms │\n"

<< " └─────────────────────────────────────────────────┘\n";

bool flowFound = false;

for (auto& kv : stats)

{

Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow(kv.first);

// Only report the TCP upload flow n0 → n1 (destination port = 9)

if (t.destinationPort != port)

continue;

flowFound = true;

const FlowMonitor::FlowStats& fs = kv.second;

// ── Throughput ────────────────────────────────────────────────────

// Duration between first and last received packet is used so that

// the TCP handshake and FIN exchange do not dilute the measurement.

double durationSec =

(fs.timeLastRxPacket - fs.timeFirstRxPacket).GetSeconds();

double throughputMbps = 0.0;

if (durationSec > 0.0)

throughputMbps = (static_cast<double>(fs.rxBytes) * 8.0)

/ (durationSec * 1.0e6);

// ── Goodput ───────────────────────────────────────────────────────

// Same formula but using payload bytes only.

// Approximation: subtract 40 B (IP 20 B + TCP 20 B) per received packet.

const uint32_t hdrBytes = 40;

double payloadBytes = (fs.rxBytes > fs.rxPackets * hdrBytes)

? static_cast<double>(fs.rxBytes - fs.rxPackets * hdrBytes)

: static_cast<double>(fs.rxBytes);

double goodputMbps = 0.0;

if (durationSec > 0.0)

goodputMbps = (payloadBytes * 8.0) / (durationSec * 1.0e6);

// ── Packet loss ───────────────────────────────────────────────────

double lossRatio = 0.0;

if (fs.txPackets > 0)

lossRatio = static_cast<double>(fs.lostPackets)

/ static_cast<double>(fs.txPackets);

// ── Delay statistics ──────────────────────────────────────────────

// ns-3.42 FlowStats provides delaySum (aggregate); min/max are not

// tracked natively. Average delay is derived from the aggregate.

double avgDelayMs = 0.0;

if (fs.rxPackets > 0)

{

avgDelayMs = (fs.delaySum.GetSeconds() * 1000.0)

/ static_cast<double>(fs.rxPackets);

}

// ── Jitter ────────────────────────────────────────────────────────

// FlowMonitor accumulates |delay_i - delay_{i-1}| in jitterSum.

// Mean jitter = jitterSum / (rxPackets - 1) if rxPackets > 1.

double meanJitterMs = 0.0;

if (fs.rxPackets > 1)

meanJitterMs = (fs.jitterSum.GetSeconds() * 1000.0)

/ static_cast<double>(fs.rxPackets - 1);

// ── Console output ────────────────────────────────────────────────

std::cout << std::fixed

<< " Flow ID : " << kv.first << "\n"

<< " Src → Dst : "

<< t.sourceAddress << ":" << t.sourcePort << " → "

<< t.destinationAddress << ":" << t.destinationPort << "\n"

<< " Protocol : "

<< (t.protocol == 6 ? "TCP" : "UDP") << "\n"

<< " ─── Packet counters ──────────────────────────────\n"

<< " Tx packets : " << fs.txPackets << "\n"

<< " Rx packets : " << fs.rxPackets << "\n"

<< " Lost packets : " << fs.lostPackets

<< " (" << std::setprecision(4) << lossRatio * 100.0 << " %)\n"

<< " Tx bytes : " << fs.txBytes << "\n"

<< " Rx bytes : " << fs.rxBytes << "\n"

<< " ─── Throughput ───────────────────────────────────\n"

<< " Throughput : " << std::setprecision(4)

<< throughputMbps << " Mbps\n"

<< " Goodput : " << std::setprecision(4)

<< goodputMbps << " Mbps\n"

<< " ─── Delay (end-to-end) ───────────────────────────\n"

<< " Avg delay : " << std::setprecision(3)

<< avgDelayMs << " ms\n"

<< " (min/max per-pkt delay not tracked by ns-3 FlowStats)\n"

<< " ─── Jitter ───────────────────────────────────────\n"

<< " Mean jitter : " << std::setprecision(3)

<< meanJitterMs << " ms\n";

// Return summary scalars to the caller

tput = throughputMbps;

loss = lossRatio;

delay = avgDelayMs;

jitter = meanJitterMs;

}

if (!flowFound)

{

std::cout << " WARNING: no matching flow found (port " << port << ")\n";

}

}

// ====================================================================
// RunSimulation
// ==============================================================
/**
* RunSimulation
* ──────────────
* Builds the entire network, runs the simulation for the given RTT value,

* collects all metrics, and writes all trace/output files for that run.

* Ends with Simulator::Destroy() so the next call starts from a clean slate.

*

* @param rttMs Target RTT in milliseconds (channel delay = RTT / 2)

* @param enablePcap Generate PCAP files for this run (sender + receiver)

* @param enableNetAnim Generate NetAnim XML for this run

* @param resultsDir Output directory path (must already exist)

*/

static void

RunSimulation(uint32_t rttMs,

bool enablePcap,

bool enableNetAnim,

const std::string& resultsDir)

{

// ── Parameters ────────────────────────────────────────────────────────────

const double simTime = 30.0; // simulation duration (seconds)

const uint32_t port = 9; // TCP destination port (discard)

const uint32_t halfRttMs = rttMs / 2; // one-way propagation delay

g_segmentSize = 1024; // TCP MSS (bytes)

std::cout << "\n╔══════════════════════════════════════════════════╗\n"

<< "║ RTT = " << std::setw(4) << rttMs

<< " ms (one-way delay = " << std::setw(3) << halfRttMs

<< " ms) ║\n"

<< "╚══════════════════════════════════════════════════╝\n";

// ── A. TCP / socket defaults ──────────────────────────────────────────────

// Must be set BEFORE any socket objects are instantiated.

// TcpLinuxReno: AIMD – cwnd += 1 MSS per ACK (CA), halved on loss (MD)

Config::SetDefault("ns3::TcpL4Protocol::SocketType",

TypeIdValue(TypeId::LookupByName("ns3::TcpLinuxReno")));

// Classic Reno recovery: enter FR/R on 3 duplicate ACKs, halve cwnd

Config::SetDefault("ns3::TcpL4Protocol::RecoveryType",

TypeIdValue(TypeId::LookupByName("ns3::TcpClassicRecovery")));

// 1 MB send/receive buffers – ensures TCP buffer never limits throughput

Config::SetDefault("ns3::TcpSocket::SndBufSize", UintegerValue(1 << 20));

Config::SetDefault("ns3::TcpSocket::RcvBufSize", UintegerValue(1 << 20));

// Maximum segment size (MSS)

Config::SetDefault("ns3::TcpSocket::SegmentSize", UintegerValue(g_segmentSize));

// Start slow-start with cwnd = 1 for a clear, reproducible trace

Config::SetDefault("ns3::TcpSocket::InitialCwnd", UintegerValue(1));

// ACK every segment (DelAckCount = 1) → finer-grained cwnd trace

Config::SetDefault("ns3::TcpSocket::DelAckCount", UintegerValue(1));

// No SACK – keeps behaviour identical to textbook Reno

Config::SetDefault("ns3::TcpSocketBase::Sack", BooleanValue(false));

// ── B. Create nodes ────────────────────────────────────────────────────────

NodeContainer nodes;

nodes.Create(2);

// nodes.Get(0) → sender (n0)

// nodes.Get(1) → receiver (n1)

// ── C. Point-to-point link ────────────────────────────────────────────────

// RTT = 2 × propagation delay

// ⟹ channel delay = RTT / 2

std::ostringstream delayOss;

delayOss << halfRttMs << "ms";

PointToPointHelper p2p;

p2p.SetDeviceAttribute ("DataRate", StringValue("10Mbps"));

p2p.SetChannelAttribute("Delay", StringValue(delayOss.str()));

// DropTail FIFO queue with 100-packet capacity

p2p.SetQueue("ns3::DropTailQueue", "MaxSize", StringValue("100p"));

NetDeviceContainer devices = p2p.Install(nodes);

// ── D. Internet stack (TCP/IP) ────────────────────────────────────────────

InternetStackHelper internet;

internet.Install(nodes);

// ── E. IP addressing ──────────────────────────────────────────────────────

Ipv4AddressHelper ipv4;

ipv4.SetBase("10.1.1.0", "255.255.255.0");

Ipv4InterfaceContainer interfaces = ipv4.Assign(devices);

// ── F. Applications ───────────────────────────────────────────────────────

// n0 runs BulkSendApplication → saturates the link as fast as TCP allows

// n1 runs PacketSink → absorbs everything that arrives

Address receiverAddr(InetSocketAddress(interfaces.GetAddress(1), port));

// Sender on n0

BulkSendHelper bulkSend("ns3::TcpSocketFactory", receiverAddr);

bulkSend.SetAttribute("MaxBytes", UintegerValue(0)); // unlimited

bulkSend.SetAttribute("SendSize", UintegerValue(g_segmentSize)); // 1 MSS/write

ApplicationContainer senderApps = bulkSend.Install(nodes.Get(0));

senderApps.Start(Seconds(1.0));

senderApps.Stop (Seconds(simTime));

// Receiver on n1

PacketSinkHelper packetSink("ns3::TcpSocketFactory",

InetSocketAddress(Ipv4Address::GetAny(), port));

ApplicationContainer sinkApps = packetSink.Install(nodes.Get(1));

sinkApps.Start(Seconds(0.5)); // starts before the sender

sinkApps.Stop (Seconds(simTime + 1.0));

// ── G. Congestion-window trace ────────────────────────────────────────────

// Open the per-run data file and schedule the trace connection.

std::ostringstream cwndFilename;

cwndFilename << resultsDir << "/cwnd_rtt_" << rttMs << "ms.dat";

g_cwndStream.open(cwndFilename.str());

g_cwndStream << "# Time(s)\tcwnd(segments) [RTT=" << rttMs << "ms]\n";

// BulkSend::StartApplication() fires at t = 1.0 s and creates the socket.

// Schedule the trace hook 1 ms later so the socket is in SocketList[0].

Simulator::Schedule(Seconds(1.001), &ConnectCwndTrace);

// ── H. FlowMonitor ────────────────────────────────────────────────────────

// FlowMonitor installs probes on every node to intercept packets at both

// the Tx and Rx sides of each IP layer, recording timestamps, byte counts,

// and sequence numbers. Statistics are accumulated until the simulation

// ends, then extracted in section M below.

FlowMonitorHelper flowHelper;

Ptr<FlowMonitor> monitor = flowHelper.InstallAll();

// ── I. ASCII trace (.tr) ──────────────────────────────────────────────────

// One file per RTT; records every enqueue/dequeue/drop event on the link.

// Useful for manual inspection or awk/grep post-processing.

AsciiTraceHelper ascii;

std::string trFilename = resultsDir + "/tcp-reno-rtt-"

+ std::to_string(rttMs) + "ms.tr";

p2p.EnableAsciiAll(ascii.CreateFileStream(trFilename));

// ── J. PCAP trace ─────────────────────────────────────────────────────────

// Generated only for the first run (RTT = 10 ms) to keep disk usage low.

// Files: tcp-reno-rtt-0-0.pcap (sender), tcp-reno-rtt-0-1.pcap (receiver)

//

// How to open:

// wireshark scratch/results/tcp-reno-rtt-0-0.pcap

//

// Useful Wireshark display filters:

// tcp – show all TCP segments

// tcp.flags.syn == 1 – handshake only

// tcp.analysis.retransmission – retransmissions

// tcp.analysis.duplicate_ack – duplicate ACKs (precede loss detection)

if (enablePcap)

{

std::string pcapPrefix = resultsDir + "/tcp-reno-rtt";
p2p.EnablePcapAll(pcapPrefix, false); // false = non-promiscuous
}
// ── K. NetAnim ────────────────────────────────────────────────────────────

// Generated only for the first run to avoid huge XML files.
//
// How to open:
// 1. cd /path/to/ns-allinone-3.42/netanim-3.109
// 2. ./NetAnim
// 3. File → Open → scratch/results/tcp-reno-netanim.xml
// 4. Press ▶ to animate packet flows between n0 and n1
AnimationInterface* anim = nullptr;
if (enableNetAnim)
{
std::string animFilename = resultsDir + "/tcp-reno-netanim.xml";
anim = new AnimationInterface(animFilename);
anim->SetConstantPosition(nodes.Get(0), 10.0, 30.0); // sender – left
anim->SetConstantPosition(nodes.Get(1), 70.0, 30.0); // receiver – right
anim->UpdateNodeDescription(nodes.Get(0), "n0 Sender (BulkSend)");
anim->UpdateNodeDescription(nodes.Get(1), "n1 Receiver (PacketSink)");
anim->UpdateNodeSize(nodes.Get(0)->GetId(), 4.0, 4.0);
anim->UpdateNodeSize(nodes.Get(1)->GetId(), 4.0, 4.0);
// Store packet metadata (UID, size, timestamps) for detailed replay
anim->EnablePacketMetadata(true);
}
// ── L. Run ────────────────────────────────────────────────────────────────
Simulator::Stop(Seconds(simTime + 2.0));
Simulator::Run();
// ── M. Collect & report FlowMonitor statistics ────────────────────────────
// Build the FlowMonitor XML filename for this run
std::string xmlFile = resultsDir + "/flowmon_rtt_" + std::to_string(rttMs) + "ms.xml";
double throughputMbps = 0.0;
double lossRatio = 0.0;
double avgDelayMs = 0.0;
double meanJitterMs = 0.0;

PrintFlowMonitorStats(monitor,flowHelper,port,rttMs,xmlFile,throughputMbps,lossRatio,avgDelayMs,meanJitterMs);

// ── N. Write one row to the cross-run summary file ────────────────────────
g_summaryStream << std::fixed << std::setprecision(6)
<< rttMs << "\t"
<< throughputMbps << "\t"
<< lossRatio << "\t"
<< avgDelayMs << "\t"
<< meanJitterMs << "\n";
g_summaryStream.flush();
// ── O. Cleanup ────────────────────────────────────────────────────────────
g_cwndStream.close();
// AnimationInterface must be destroyed before Simulator::Destroy()
if (anim)
{
delete anim;
anim = nullptr;
}
// Simulator::Destroy() tears down all ns-3 global state (nodes, devices,

// channels, event queue) so the next RunSimulation() call is independent.

Simulator::Destroy();

}

// =============================================================================

// main

// =============================================================================

int

main(int argc, char* argv[])

{

// ── RTT sweep configuration ───────────────────────────────────────────────

// Add or remove values freely. Each entry costs one full simulation run.

std::vector<uint32_t> rttValues = {10, 25, 50, 75, 100, 125, 150, 175, 200};

// Output directory (relative to the ns-3 root where ./ns3 run is invoked)

const std::string resultsDir = "scratch/results";

// ── Create output directory ───────────────────────────────────────────────

// POSIX mkdir – silently fails if the directory already exists (EEXIST)

::mkdir(resultsDir.c_str(), 0755);

// ── Open cross-run summary file ───────────────────────────────────────────

const std::string summaryPath = resultsDir + "/summary.dat";

g_summaryStream.open(summaryPath);

if (!g_summaryStream.is_open())

{

std::cerr << "ERROR: cannot open " << summaryPath << "\n"

<< "Ensure scratch/results/ exists and is writable.\n";

return 1;

}

// Column header – load with: gnuplot 'summary.dat' using 1:2

g_summaryStream

<< "# RTT_ms\tThroughput_Mbps\tLossRatio\tAvgDelay_ms\tMeanJitter_ms\n";

// ── Print banner ──────────────────────────────────────────────────────────

std::cout

<< "╔══════════════════════════════════════════════════════════╗\n"

<< "║ TCP Reno RTT Analysis – ns-3 v3.42 ║\n"

<< "║ ID: 24BPS1135 ║\n"

<< "╠══════════════════════════════════════════════════════════╣\n"

<< "║ Topology n0 (BulkSend) ──[P2P 10 Mbps]── n1 (Sink) ║\n"

<< "║ TCP TcpLinuxReno (classic AIMD) ║\n"

<< "║ MSS " << std::setw(4) << g_segmentSize

<< " bytes ║\n"

<< "║ Sim time 30 s per run ║\n"

<< "║ RTT values 10 25 50 75 100 125 150 175 200 ms ║\n"

<< "║ Results " << resultsDir << "/ ║\n"

<< "╚══════════════════════════════════════════════════════════╝\n";

// ── Main sweep loop ───────────────────────────────────────────────────────

for (std::size_t i = 0; i < rttValues.size(); ++i)

{

const bool firstRun = (i == 0);

RunSimulation(rttValues[i],

firstRun, // enablePcap : PCAP only for RTT = 10 ms

firstRun, // enableNetAnim : NetAnim only for RTT = 10 ms

resultsDir);

}

g_summaryStream.close();

// ── Print the final summary table ─────────────────────────────────────────

std::cout

<< "\n╔══════════════════════════════════════════════════════════════════════╗\n"

<< "║ FINAL RESULTS SUMMARY ║\n"

<< "╠══════════════════════════════════════════════════════════════════════╣\n"

<< "║ "

<< std::left << std::setw(9) << "RTT(ms)"

<< std::setw(18) << "Throughput(Mbps)"

<< std::setw(12) << "Loss Ratio"

<< std::setw(15) << "Avg Delay(ms)"

<< std::setw(15) << "Jitter(ms)"

<< " ║\n"

<< "╠══════════════════════════════════════════════════════════════════════╣\n";

std::ifstream fin(summaryPath);

std::string line;

while (std::getline(fin, line))

{

if (line.empty() || line[0] == '#')

continue;

std::istringstream iss(line);

uint32_t rtt;

double tp, lr, ad, jt;

if (!(iss >> rtt >> tp >> lr >> ad >> jt))

continue;

std::cout

<< "║ "

<< std::left << std::setw(9) << rtt

<< std::fixed << std::setprecision(4)

<< std::setw(18) << tp

<< std::setprecision(6)

<< std::setw(12) << lr

<< std::setprecision(3)

<< std::setw(15) << ad

<< std::setw(15) << jt

<< " ║\n";

}

std::cout

<< "╚══════════════════════════════════════════════════════════════════════╝\n"

<< "\n"

<< "╔══════════════════════════════════════════════════════════════════════╗\n"

<< "║ OUTPUT FILES ║\n"

<< "╠══════════════════════════════════════════════════════════════════════╣\n"

<< "║ summary.dat RTT, Throughput, Loss, Delay, Jitter ║\n"

<< "║ cwnd_rtt_Xms.dat Congestion window trace (9 files) ║\n"

<< "║ flowmon_rtt_Xms.xml FlowMonitor XML export (9 files) ║\n"

<< "║ tcp-reno-rtt-Xms.tr ASCII link traces (9 files) ║\n"

<< "║ tcp-reno-rtt-0-0.pcap Sender PCAP (RTT=10ms, Wireshark) ║\n"

<< "║ tcp-reno-rtt-0-1.pcap Receiver PCAP (RTT=10ms, Wireshark) ║\n"

<< "║ tcp-reno-netanim.xml NetAnim animation (RTT=10ms) ║\n"

<< "╠══════════════════════════════════════════════════════════════════════╣\n";

return 0;

}

 

Output :

 

NetAnim:

NetAnim Visualization (tcp-reno-netanim.xml)

NetAnim displays two nodes — n0 (Sender) on the left and n1 (Receiver) on the right — connected by a link, with animated dots representing packets flowing between them during the simulation. It provides a visual confirmation that data transmission is occurring correctly and that the TCP connection is active between the two endpoints.

Comparison data file

 

This dat file is a referral file to plot the gnu-graphs

 

Gnuplot graphs

 

RTT vs Packet Loss Graph (loss_vs_rtt.png)

This graph plots RTT against the packet loss ratio, showing a gradual upward trend as RTT increases. Higher RTT causes a larger Bandwidth-Delay Product, which overflows the fixed-size DropTail queue more easily, resulting in more frequent packet drops.

 

 

RTT vs Throughput Graph (throughput_vs_rtt.png)

This graph plots RTT (x-axis) against achieved throughput in Mbps (y-axis), showing a downward curve as RTT increases. It demonstrates that TCP Reno becomes progressively less efficient at higher RTTs because the congestion window grows slower when ACKs take longer to return.

 

 

Congestion Window over Time Graph (cwnd_over_time.png)

 At lower RTT the window climbs steeply and reaches a high steady state, while at higher RTT the growth is gradual and resets happen more frequently, keeping cwnd the window climbs steeply and reaches a high steady state, while at higher RTT the growth is gradual and resets happen more frequently, keeping cwnd chronically low.

Tracemetrics result for 10, 100 and 200ms, respectively

The trace metrics comparison illustrates that increasing RTT leads to reduced throughput, higher packet loss, and increased end-to-end delay due to slower congestion window growth and higher Bandwidth-Delay Product in TCP Reno.

 

 

 

Wireshark

The image below shows the TCP three-way handshake (SYN, SYN-ACK, ACK) followed by continuous data transmission between 10.1.1.1 (sender) and 10.1.1.2 (receiver), confirming successful connection establishment and active TCP Reno data flow.

 

The image below displays Wireshark’s Expert Information, highlighting events such as duplicate ACKs, retransmissions, and out-of-order packets, which indicate congestion and TCP Reno’s loss recovery mechanisms.

  

The graph below shows packet flow over time along with TCP errors, illustrating fluctuations in transmission rate and the occurrence of congestion-related issues such as retransmissions during the simulation