How to Calculate Delay Variance in ns3

To calculate delay variance in ns3, we need to measure the variability in packet delay times because they traverse the network. This metric is essential for calculating the quality of service in networks, specifically for applications sensitive to delay variations, that includes VoIP and video streaming.

Steps for calculating delay variance

1. Set up the simulation :

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

2. Install applications :

• To send and receive packets, use a UDP client and server applications.

3. Record packet Timestamps:

• To record the timestamps when packets are sent and received, use packet tracing.

4. Calculate delay and variance :

• Compute the delay for each packet and then calculate the variance of these delays.

Example of a simple delay variance calculation

Create a basic network topology and point-to-point network in ns3.

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”

#include <iostream>

#include <vector>

#include <numeric>

#include <cmath>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE(“DelayVarianceExample”);

std::vector<double> delays;

class TimeTag : public Tag

{

public:

TimeTag () {}

TimeTag (Time time) : m_time (time) {}

static TypeId GetTypeId (void)

{

static TypeId tid = TypeId (“ns3::TimeTag”)

.SetParent<Tag> ()

.AddConstructor<TimeTag> ();

return tid;

}

virtual TypeId GetInstanceTypeId (void) const

{

return GetTypeId ();

}

virtual void Serialize (TagBuffer i) const

{

int64_t time = m_time.GetNanoSeconds ();

i.Write ((const uint8_t *)&time, sizeof (time));

}

virtual void Deserialize (TagBuffer i)

{

int64_t time;

i.Read ((uint8_t *)&time, sizeof (time));

m_time = NanoSeconds (time);

}

virtual uint32_t GetSerializedSize (void) const

{

return sizeof (int64_t);

}

virtual void Print (std::ostream &os) const

{

os << “t=” << m_time;

}

void SetTime (Time time)

{

m_time = time;

}

 

Time GetTime (void) const

{

return m_time;

}

private:

Time m_time;

};

void PacketSentCallback(Ptr<const Packet> packet)

{

TimeTag tag(Simulator::Now());

const_cast<Packet *>(packet)->AddByteTag(tag);

}

void PacketReceivedCallback(Ptr<const Packet> packet)

{

TimeTag tag;

bool found = packet->FindFirstMatchingByteTag(tag);

if (found)

{

Time sendTime = tag.GetTime();

Time receiveTime = Simulator::Now();

Time delay = receiveTime – sendTime;

delays.push_back(delay.GetMilliSeconds());

}

}

double CalculateVariance(const std::vector<double>& values)

{

if (values.empty())

return 0.0;

double sum = std::accumulate(values.begin(), values.end(), 0.0);

double mean = sum / values.size();

double sq_sum = std::inner_product(values.begin(), values.end(), values.begin(), 0.0);

double variance = sq_sum / values.size() – mean * mean;

return variance;

}

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

{

Time::SetResolution(Time::NS);

LogComponentEnable(“DelayVarianceExample”, LOG_LEVEL_INFO);

// Create nodes

NodeContainer nodes;

nodes.Create(2);

// Set up point-to-point link

PointToPointHelper pointToPoint;

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

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

NetDeviceContainer devices;

devices = pointToPoint.Install(nodes);

// Install the Internet stack

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces = address.Assign(devices);

// Set up UDP server on Node 1

uint16_t port = 9;

UdpServerHelper server(port);

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

serverApp.Start(Seconds(1.0));

serverApp.Stop(Seconds(10.0));

// Set up UDP client on Node 0

UdpClientHelper client(interfaces.GetAddress(1), 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));

// Connect packet sent and received callbacks

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

devices.Get(1)->TraceConnectWithoutContext(“PhyRxEnd”, MakeCallback(&PacketReceivedCallback));

Simulator::Run();

// Calculate delay variance

double delayVariance = CalculateVariance(delays);

std::cout << “Delay Variance: ” << delayVariance << ” ms^2″ << std::endl;

Simulator::Destroy();

return 0;

}

Explanation:

1. TimeTag Class:
   • To store the timestamp when the packet is sent, a custom Tag class TimeTag is defined.
   • This tag is serialized and deserialized with the packet.
2. Global Variables:
   • delays: A vector to store the delay of each packet.
3. Simulation Setup:
   • Created two nodes and they are connected using a point-to-point link.
   • The link is configured with a specific data rate and delay.
4. Application Setup:
   • On the destination node (Node 1), a UDP server is installed.
   • On the source node (Node 0), A UDP client is installed to send packets to the server.
5. Packet Timestamps:
   • To add a TimeTag to the packet when it is sent, storing the current simulation time, PacketSentCallback is used.
   • To retrieve the TimeTag from the received packet and calculates the delay, PacketReceivedCallback is used.
6. Variance Calculation:
   • CalculateVarianceis used to calculate the variance of the delays stored in the vector.
7. Running the Simulation:
   • For a specified period, the simulation runs during which packets are sent and received.
   • The delay for each packet is recorded in the delays vector.
8. Calculating Delay Variance:
   • The variance of the recorded delays is calculated and printed to the console after the simulation ends.

Totally, we had a performance analysis on calculating delay variance in ns3 by measuring the variability in packet delay times as they traverse the network.

We conduct performance evaluations for determining Delay Variance in ns3 by sharing all the necessary parameters with us. We will then provide you with accurate results. Moreover, we offer comprehensive details on Delay Variance.