How to Calculate Network Burstiness in ns3

To calculate network business in ns3, we need to measure the variability of traffic flow over time. Burstiness is typically quantified by evaluating the traffic rate over time intervals and identifying periods of high traffic rates compared to average rates.

The steps to calculate network burstiness in ns3 are.

Steps for calculating network burstiness

1. Set up the simulation :

• To simulate the network, create a network topology with nodes, protocols and links configured.

2. Install applications :

• On the nodes, setup applications to generate and receive traffic.

3. Trace the packets :

• To record packet transmission and reception times, use ns3 tracing capabilities.

4. Analyze traffic burstiness :

• Calculate traffic rates over time intervals and compute burstiness metrics.

Example of a simple network burstiness calculation

Create a basic network topology and measure the network burstiness by recording the number of packets sent over fixed time intervals.

set up the simulation

#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”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“NetworkBurstinessExample”);

std::vector<uint32_t> packetCountPerInterval;

uint32_t currentPacketCount = 0;

double intervalDuration = 0.1; // Time interval in seconds

void PacketSentCallback (Ptr<const Packet> packet)

{

currentPacketCount++;

}

void CalculateBurstiness (Time interval)

{

packetCountPerInterval.push_back(currentPacketCount);

currentPacketCount = 0;

Simulator::Schedule(interval, &CalculateBurstiness, interval);

}

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

{

// Create two nodes

NodeContainer nodes;

nodes.Create (2);

// Set up the point-to-point link

PointToPointHelper pointToPoint;

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

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

// Install link devices on nodes

NetDeviceContainer devices;

devices = pointToPoint.Install (nodes);

// Install the internet stack

InternetStackHelper stack;

stack.Install (nodes);

// Assign IP addresses

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces = address.Assign (devices);

// Set up the UDP echo server on Node 1

uint16_t port = 9; // well-known echo port number

UdpEchoServerHelper echoServer (port);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));

serverApps.Start (Seconds (1.0));

serverApps.Stop (Seconds (10.0));

// Set up the UDP echo client on Node 0

UdpEchoClientHelper echoClient (interfaces.GetAddress (1), port);

echoClient.SetAttribute (“MaxPackets”, UintegerValue (1000));

echoClient.SetAttribute (“Interval”, TimeValue (Seconds (0.01))); // 100 packets per second

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

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

// Enable tracing

devices.Get (0)->TraceConnectWithoutContext (“MacTx”, MakeCallback (&PacketSentCallback));

// Schedule burstiness calculation

Simulator::Schedule(Seconds(intervalDuration), &CalculateBurstiness, Seconds(intervalDuration));

// Run the simulation

Simulator::Run ();

// Calculate burstiness

double meanPacketRate = 0.0;

for (uint32_t count : packetCountPerInterval)

{

meanPacketRate += count;

}

meanPacketRate /= packetCountPerInterval.size();

double variance = 0.0;

for (uint32_t count : packetCountPerInterval)

{

variance += (count – meanPacketRate) * (count – meanPacketRate);

}

variance /= packetCountPerInterval.size();

double standardDeviation = std::sqrt(variance);

double burstiness = standardDeviation / meanPacketRate;

std::cout << “Mean Packet Rate: ” << meanPacketRate << ” packets per interval” << std::endl;

std::cout << “Standard Deviation: ” << standardDeviation << ” packets per interval” << std::endl;

std::cout << “Burstiness: ” << burstiness << std::endl;

Simulator::Destroy ();

return 0;

}

Explanation

1. Simulation setup :

Two nodes are created. Those nodes are connected using a point-to-point link.

2. Application setup :

On Node 1, a UDP echo server is installed. and On Node 0, a UDP echo client is installed. Configure the client to send a specified number of packets at a specified interval.

3. Packet tracing :

To count the total number of packets sent in each interval, use a callback function.

4. Analyze Traffic burstiness :

Calculate the mean packet rate and the standard deviation of the packet counts over the intervals. Burstiness is described as the ratio of the standard deviation to the mean packet rate.

Step-by-step breakdown

1. Create Nodes and Links :

Two nodes are created. Those nodes are connected using a point-to-point link with a specified data rate and delay.

2. Install Internet Stack and Applications :

On the nodes, the Internet stack is installed and a UDP echo server and client are set up to generate and receive traffic.

3. Trace Packet Transmission :

To count the total number of packets sent during each time interval, used a callback function.

4. Calculate burstiness :

The packet count for every interval is recorded, and the mean packet rate and standard deviation are calculated. Burstiness is determined as the ratio of the standard deviation to the mean packet rate.

We conduct a performance analysis to determine network burstiness in ns3 through the measurement of traffic flow fluctuation across time. Furthermore, we offer comprehensive details regarding Network burstiness.

At ns3simulation.com you can get performance analysis for your simulation. We carry out a complete comparison study. Moreover, we offer a complete framework for getting Network Burstiness in ns3 simulation.