How to Calculate Network Congestion in ns3

To calculate the network congestion in ns3, needs the following metrics to quantified the congestion that are packet loss, delay, and queue lengths at network devices. We need to estimate how efficiently the network is managing the traffic load.

Here are the procedures on how to implement this in ns3:

Step-by-Step Guide to Calculate Network Congestion in ns3

1. Set Up the Simulation Environment:
   • Download ns3 and configure it.
   • Include necessary modules for your simulation (e.g., Internet, Mobility, specific routing protocols).
2. Create Network Topology:
   • Define nodes and configure the network topology.
   • Set up point-to-point links or WiFi devices and mobility models for the nodes.
3. Configure Applications:
   • Install traffic-generating applications (e.g., UDP, TCP) on the nodes.
4. Enable Tracing and Metrics Collection:
   • Enable tracing to capture relevant metrics such as packet loss, delay, and queue lengths.
5. Run the Simulation:
   • Execute the simulation and collect the trace data.
6. Analyze the Results:
   • Post-process the trace data to analyze network congestion.

Example Code Snippet for Network Congestion

The given below is the sample illustrative on how to set up a network, generate traffic, and capture metrics to compute network congestion in ns-3:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/mobility-module.h”

#include “ns3/flow-monitor-module.h”

#include “ns3/queue-disc-module.h”

#include “ns3/log.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“NetworkCongestionExample”);

void CalculateCongestionMetrics(Ptr<QueueDisc> queue)

{

uint32_t qlen = queue->GetNPackets();

NS_LOG_UNCOND (“Queue length: ” << qlen << ” packets”);

}

int main (int argc, char *argv[])

{

// Set up logging

LogComponentEnable (“UdpClient”, LOG_LEVEL_INFO);

LogComponentEnable (“UdpServer”, LOG_LEVEL_INFO);

// Create nodes

NodeContainer nodes;

nodes.Create (4);

// Install Mobility model

MobilityHelper mobility;

mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”);

mobility.Install (nodes);

// Create point-to-point links

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute (“DataRate”, StringValue (“5Mbps”));

pointToPoint.SetChannelAttribute (“Delay”, StringValue (“2ms”));

NetDeviceContainer devices;

devices.Add(pointToPoint.Install(nodes.Get(0), nodes.Get(1)));

devices.Add(pointToPoint.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(pointToPoint.Install(nodes.Get(2), nodes.Get(3)));

// Install Internet stack

InternetStackHelper internet;

internet.Install (nodes);

// Assign IP addresses

Ipv4AddressHelper address;

address.SetBase (“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign (devices);

// Install and start applications on nodes

uint16_t port = 9; // Discard port (RFC 863)

UdpServerHelper server (port);

ApplicationContainer serverApp = server.Install (nodes.Get (3));

serverApp.Start (Seconds (1.0));

serverApp.Stop (Seconds (10.0));

UdpClientHelper client (interfaces.GetAddress (3), port);

client.SetAttribute (“MaxPackets”, UintegerValue (320));

client.SetAttribute (“Interval”, TimeValue (MilliSeconds (50)));

client.SetAttribute (“PacketSize”, UintegerValue (1024));

ApplicationContainer clientApp = client.Install (nodes.Get (0));

clientApp.Start (Seconds (2.0));

clientApp.Stop (Seconds (10.0));

// Set up FlowMonitor to collect performance metrics

FlowMonitorHelper flowmon;

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

// Set up queue disc to monitor congestion

TrafficControlHelper tch;

tch.SetRootQueueDisc (“ns3::FifoQueueDisc”, “MaxSize”, StringValue (“100p”));

Ptr<QueueDisc> queue = tch.Install(devices).Get(0);

// Schedule periodic congestion metric calculation

Simulator::Schedule(Seconds(1.0), &CalculateCongestionMetrics, queue);

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// Calculate packet loss

monitor->CheckForLostPackets ();

Ptr<Ipv4FlowClassifier>classifier=DynamicCast<Ipv4FlowClassifier>(flowmon.GetClassifier ());

std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats ();

double totalPacketsLost = 0;

double totalDelay = 0;

uint64_t totalRxPackets = 0;

for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin (); i != stats.end (); ++i)

{

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

if (t.sourceAddress == Ipv4Address (“10.1.1.1”) && t.destinationAddress == Ipv4Address (“10.1.1.4”))

{

totalPacketsLost += i->second.lostPackets;

totalDelay += i->second.delaySum.GetSeconds();

totalRxPackets += i->second.rxPackets;

}

}

double avgDelay = totalRxPackets > 0 ? totalDelay / totalRxPackets : 0;

NS_LOG_UNCOND (“Total packets lost: ” << totalPacketsLost);

NS_LOG_UNCOND (“Average delay: ” << avgDelay << ” seconds”);

// Clean up

Simulator::Destroy ();

return 0;

}

Explanation:

1. Setup Logging:
   • Enable logging for the UDP applications to track their activities.
2. Create Nodes:
   • Create a set of nodes representing devices in the network.
3. Install Mobility Model:
   • Install a mobility model on the nodes (e.g., ConstantPositionMobilityModel).
4. Create Point-to-Point Links:
   • Install point-to-point links between the nodes.
5. Install Internet Stack:
   • Install the Internet stack on the nodes.
6. Assign IP Addresses:
   • Assign IP addresses to the network interfaces.
7. Install Applications:
   • Install UDP server and client applications on the nodes.
8. Set Up FlowMonitor:
   • Install FlowMonitor to collect and analyze flow statistics.
9. Set Up Queue Disc to Monitor Congestion:
   • Install a FIFO queue disc on the network devices to monitor queue lengths.
10. Schedule Periodic Congestion Metric Calculation:
    • Schedule a periodic function to calculate and log the queue length, indicating congestion levels.
11. Run Simulation:
    • Run the simulation for the specified duration.
12. Calculate Packet Loss and Delay:
    • After the simulation, extract flow statistics and calculate packet loss and average delay.

Analysing the Results:

• Packet Loss:
  • Packet loss is calculated as the number of packets that were dropped and not successfully delivered to the destination.
  • High packet loss indicates congestion in the network.
• Average Delay:
  • Average delay is calculated as the total delay experienced by all received packets divided by the number of received packets.
  • High average delay indicates congestion in the network.
• Queue Length:
  • The queue length is periodically logged to indicate the level of congestion at the network devices.
  • Long queues indicate congestion as packets are waiting to be transmitted.

In this script, we had learned how the network congestion estimated and simulated in ns3 simulator tool. We offer and deliver the elaborated details about the network congestion.

Network Congestion on ns3simulation with project performance are shared by us, connect with us for more support.