How to Calculate Mean Slow Down in ns3

To calculate Mean Slow Down (MSD) in ns3, we have to measure the slowdown experienced by flows or tasks relative to their ideal execution time. MSD is particularly relatable in scheduling and resource allocation scenarios to calculate the performance and fairness of the network.

Steps for calculation

1. Set up your ns3 :

• Make sure that ns3 is installed in the computer. If not, install it.

 

2. Create a new ns3 script :

• In the scratch directory of ns3, create a new script.

 

3. Include necessary libraries :

• In your script, include the necessary libraries.

 

4. Define network topology :

• For your network topology, create multiple nodes.

5. Simulate task or flow execution :

• To simulate tasks or flows and track their execution times, implement the logic.

6. Measure slowdown and Calculate mean slow down :

• Measure the actual and ideal execution times of tasks or flows, calculate their slowdown, and compute the mean slowdown..

Example for calculating mean slow down in ns3

Here is the example for the calculation of mean slow down :

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

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“MeanSlowDownCalculationExample”);

struct FlowInfo

{

Time startTime;

Time endTime;

Time idealTime;

};

std::vector<FlowInfo> flowInfos;

void FlowStart(Ptr<Socket> socket, uint32_t flowId)

{

FlowInfo info;

info.startTime = Simulator::Now();

info.idealTime = Seconds(1.0); // Assume ideal execution time is 1 second for simplicity

flowInfos.push_back(info);

}

void FlowEnd(Ptr<Socket> socket, uint32_t flowId)

{

Time endTime = Simulator::Now();

flowInfos[flowId].endTime = endTime;

}

void CalculateMeanSlowDown()

{

double totalSlowDown = 0.0;

for (const auto& info : flowInfos)

{

Time actualTime = info.endTime – info.startTime;

double slowDown = actualTime.GetSeconds() / info.idealTime.GetSeconds();

totalSlowDown += slowDown;

}

double meanSlowDown = totalSlowDown / flowInfos.size();

std::cout << “Mean Slow Down: ” << meanSlowDown << std::endl;

}

void GenerateTraffic(Ptr<Socket> socket, uint32_t pktSize, uint32_t pktCount, Time interPacketInterval, uint32_t flowId)

{

if (pktCount > 0)

{

socket->Send(Create<Packet>(pktSize));

Simulator::Schedule(interPacketInterval, &GenerateTraffic, socket, pktSize, pktCount – 1, interPacketInterval, flowId);

}

else

{

FlowEnd(socket, flowId);

}

}

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

{

uint32_t nNodes = 2;

double simulationTime = 10.0;

uint32_t packetSize = 1024;

uint32_t numPackets = 10;

Time interPacketInterval = MilliSeconds(100);

CommandLine cmd;

cmd.AddValue(“nNodes”, “Number of nodes”, nNodes);

cmd.AddValue(“simulationTime”, “Total simulation time”, simulationTime);

cmd.AddValue(“packetSize”, “Size of each packet”, packetSize);

cmd.AddValue(“numPackets”, “Number of packets to send”, numPackets);

cmd.AddValue(“interPacketInterval”, “Interval between packets”, interPacketInterval);

cmd.Parse(argc, argv);

NodeContainer nodes;

nodes.Create(nNodes);

PointToPointHelper pointToPoint;

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

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

NetDeviceContainer devices;

devices = pointToPoint.Install(nodes);

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces = address.Assign(devices);

Ptr<Socket> sourceSocket = Socket::CreateSocket(nodes.Get(0), TypeId::LookupByName(“ns3::UdpSocketFactory”));

Ptr<Socket> sinkSocket = Socket::CreateSocket(nodes.Get(1), TypeId::LookupByName(“ns3::UdpSocketFactory”));

InetSocketAddress remote = InetSocketAddress(interfaces.GetAddress(1), 9);

sinkSocket->Bind(remote);

sourceSocket->Connect(remote);

// Start and schedule flows

for (uint32_t flowId = 0; flowId < 5; ++flowId)

{

Simulator::ScheduleWithContext(sourceSocket->GetNode()->GetId(), Seconds(flowId * 2.0), &FlowStart, sourceSocket, flowId);

Simulator::ScheduleWithContext(sourceSocket->GetNode()->GetId(), Seconds(flowId * 2.0 + 1.0), &GenerateTraffic, sourceSocket, packetSize, numPackets, interPacketInterval, flowId);

}

Simulator::Stop(Seconds(simulationTime));

Simulator::Run();

Simulator::Destroy();

CalculateMeanSlowDown();

return 0;

}

Explanation

1. Nodes and links :

Two nodes are created. Point-to-point links between nodes are configured.

2. Applications :

On both sender and receiver nodes, a UDP sockets are created to simulate traffic flows.

3. Traffic generation :

To send packets from the source node to the sink node at regular intervals, GenerateTraffic is implememted. Tracked the start and end times of each flow to measure their actual execution time

4. Flow management :

To record the start and end times of each flow, the FlowStart and FlowEnd are implemented. In a FlowInfo structure, stored flow information including the ideal execution time.

5. Mean slow down logic :

To calculate the slowdown for each flow and compute the mean slowdown across all flows,  CalculateMeanSlowDown is implemented.

6. Running the Simulation :

The simulation runs sending and receiving packets for multiple flows. sending and receiving packets for multiple flows. The mean slowdown is calculated and printed, after the simulation.

Overall, we had successfully learned on calculating mean slow down in ns3 by measuring the slowdown experienced by flows or tasks relative to their ideal execution time. Also, we provide more related information on mean slow down.

We work on all concepts of Mean Slow Down (MSD) so share your parameters with us ,we carry on comparative analysis and guarantee best results.