How to Begin Implement Network Packet Delivery Ratio in NS3

To begin implementing and analyzing the Network Packet Delivery Ratio (PDR) using ns3, we can adhere to these systematic steps. Packet Delivery Ratio is a crucial performance parameter, which supports to estimate the packets rate that are effectively received to transmitted through the network.  Below is a step-by-step guide on how to get started with PDR using NS3.

Steps to Begin Implement PDR in NS3

1. Understand Packet Delivery Ratio

PDR is determined by:

PDR=Number of Packets ReceivedNumber of Packets Sent×100\text{PDR} = \frac{\text{Number of Packets Received}}{\text{Number of Packets Sent}} \times 100PDR=Number of Packets SentNumber of Packets Received​×100

2. Set Up Your Environment

We can install and set up ns3 on the system and working properly. Get more knowledge about simple ns3 scripting.

3. Create the Network Topology

Example: Point-to-Point Network

NodeContainer nodes;

nodes.Create(2);

PointToPointHelper pointToPoint;

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

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

NetDeviceContainer devices;

devices = pointToPoint.Install(nodes);

Example: Wireless Network

YansWifiChannelHelper channel = YansWifiChannelHelper::Default();

YansWifiPhyHelper phy = YansWifiPhyHelper::Default();

phy.SetChannel(channel.Create());

WifiHelper wifi;

wifi.SetStandard(WIFI_PHY_STANDARD_80211n);

WifiMacHelper mac;

mac.SetType(“ns3::AdhocWifiMac”);

NodeContainer wifiNodes;

wifiNodes.Create(3);

NetDeviceContainer wifiDevices;

wifiDevices = wifi.Install(phy, mac, wifiNodes);

4. Set Up the Internet Stack

We should install the Internet stack to allow IP-based interaction:

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces = address.Assign(devices);

5. Install Applications to Generate Traffic

Example: UDP Traffic

UdpEchoServerHelper echoServer(9);

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

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

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

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

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(0.01))); // 10ms interval

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

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

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

6. Monitor Packet Delivery

Use Packet Sent and Received Counters

We will need to observe the packets that are transmitted and received by using callbacks.

Track Packets Sent

uint32_t packetsSent = 0;

void PacketSentCallback(Ptr<const Packet> packet) {

packetsSent++;

std::cout << “Packet Sent: ” << packetsSent << std::endl;

}

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

Track Packets Received

uint32_t packetsReceived = 0;

void PacketReceivedCallback(Ptr<const Packet> packet) {

packetsReceived++;

std::cout << “Packet Received: ” << packetsReceived << std::endl;

}

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

7. Calculate PDR

In the end of the simulation, we can be determined the PDR by counters:

void CalculatePDR() {

double pdr = (static_cast<double>(packetsReceived) / packetsSent) * 100;

std::cout << “Packet Delivery Ratio (PDR): ” << pdr << “%” << std::endl;

}

Simulator::Schedule(Seconds(10.1), &CalculatePDR);

8. Analyze Results

Record the transmitted and inherited packets on certain intervals and then estimate the PDR over time. Transfer the data into a file with the support of tools such as MATLAB or Excel for detailed analysis.

9. Use FlowMonitor for Automated PDR Calculation

The FlowMonitorHelper module can be automatically monitored the packet delivery parameters.

Configure FlowMonitor:

FlowMonitorHelper flowmon;

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

Simulator::Stop(Seconds(10.0));

Simulator::Run();

monitor->CheckForLostPackets();

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

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

for (auto& flow : stats) {

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

double pdr = (static_cast<double>(flow.second.rxPackets) / flow.second.txPackets) * 100;

std::cout << “Flow ID: ” << flow.first

<< ” (” << t.sourceAddress << ” -> ” << t.destinationAddress << “)\n”;

std::cout << ”  PDR: ” << pdr << “%” << std::endl;

}

10. Visualize Results

• Transfer PDR data into a file for graphical analysis.
• Envision the behavior of network using NetAnim:

AnimationInterface anim(“pdr_simulation.xml”);

11. Experiment and Optimize

• Experiment with various traffic types such as TCP, UDP.
• Fine-tune network conditions like delay, bandwidth.
• Modify the volume of nodes to monitor how scalability impacts the PDR.

12. Run the Simulation

Finally, execute the simulation and confirm its outcomes:

Simulator::Run();

Simulator::Destroy();

This implementation procedure has been thoroughly explained with numerous steps and NS3 coding snippets and can be further elaborated to address more advanced requirements on this topic.