How to Calculate Mean Slow Down in ns3

To calculate the Mean slowdown in ns3, we want to measure the difference among the expected completion of packet transmission and the actual completion time and then average the overall tasks. It is basically used for scheduling and to know how much time the task is finished compared to the innovative scenarios. Here are the procedures on how to calculate the slowdown in ns3 simulator:

Steps to Calculate Mean Slowdown

  1. Set Up the Simulation: Create a network topology and configure nodes, links, and applications.
  2. Monitor Packet Transmission Times: Track the start and end times of packet transmissions to measure completion times.
  3. Calculate Slowdown for Each Packet: Determine the expected completion time and compare it to the actual completion time.
  4. Compute Mean Slowdown: Average the slowdown values over all packets.

Example Implementation

Here is a sample on how to configure the point-to-point network in ns3 and to evaluate the mean slowdown of transmission of packets:

Setting Up the Network 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>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE(“MeanSlowdownExample”);

struct PacketInfo {

Time sendTime;

Time expectedCompletionTime;

};

std::map<uint64_t, PacketInfo> packetInfoMap;

uint64_t packetId = 0;

double totalSlowdown = 0.0;

uint32_t packetCount = 0;

void PacketSentCallback(Ptr<const Packet> packet)

{

PacketInfo info;

info.sendTime = Simulator::Now();

// Assume expected completion time based on link speed and packet size

uint32_t packetSize = packet->GetSize();

DataRate linkSpeed = DataRate(“5Mbps”);

Time transmissionTime = Seconds(static_cast<double>(packetSize * 8) / linkSpeed.GetBitRate());

info.expectedCompletionTime = info.sendTime + transmissionTime;

packetInfoMap[packetId++] = info;

}

void PacketReceivedCallback(Ptr<const Packet> packet)

{

Time receiveTime = Simulator::Now();

uint64_t receivedPacketId = packetId – packetInfoMap.size();

if (packetInfoMap.find(receivedPacketId) != packetInfoMap.end())

{

PacketInfo info = packetInfoMap[receivedPacketId];

Time actualCompletionTime = receiveTime – info.sendTime;

Time expectedCompletionTime = info.expectedCompletionTime – info.sendTime;

double slowdown = actualCompletionTime.GetSeconds() / expectedCompletionTime.GetSeconds();

totalSlowdown += slowdown;

packetCount++;

packetInfoMap.erase(receivedPacketId);

}

}

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

{

Time::SetResolution(Time::NS);

LogComponentEnable(“MeanSlowdownExample”, 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 mean slowdown

double meanSlowdown = packetCount > 0 ? totalSlowdown / packetCount : 0.0;

std::cout << “Total Packets Sent: ” << packetId << std::endl;

std::cout << “Total Packets Received: ” << packetCount << std::endl;

std::cout << “Mean Slowdown: ” << meanSlowdown << std::endl;

Simulator::Destroy();

return 0;

}

Explanation:

  1. PacketInfo Structure:
    • A structure PacketInfo is defined to store the send time and expected completion time of each packet.
  2. Global Variables:
    • packetInfoMap: A map to store PacketInfo for each packet, indexed by a unique packet ID.
    • packetId: A counter to assign unique IDs to packets.
    • totalSlowdown: A variable to accumulate the total slowdown.
    • packetCount: A counter for the number of packets received.
  3. Simulation Setup:
    • Two nodes are created and connected using a point-to-point link.
    • The link is configured with a specific data rate and delay.
  4. Application Setup:
    • A UDP server is installed on the destination node (Node 1).
    • A UDP client is installed on the source node (Node 0) to send packets to the server.
  5. Packet Timestamps:
    • PacketSentCallback: Records the send time and calculates the expected completion time for each packet.
    • PacketReceivedCallback: Calculates the actual completion time and the slowdown for each packet. Updates the total slowdown and packet count.
  6. Running the Simulation:
    • The simulation runs for a specified period, during which packets are sent and received.
    • The mean slowdown is calculated as the average of the slowdown values for all received packets.

At the end, the mean slowdown will simulated for particular period at that time it calculates how much packets will complete the task with the use of ns3. Also we offer more information regarding the execution of the mean slowdown in alternative tools.