How to Calculate Network Link success rate in ns3

To calculate network link success rate in ns3, we need to measure the ratio of successfully received packets to the total transmitted packets through a link. This metric indicates the reliability and performance of the communication link between nodes in the network. Here is a quick guide on calculating network link success rate in ns3.

Steps for calculating network link success rate

1. Set up the simulation :

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

2. Create Network Topology:

• For the base stations (eNodeBs), access points (APs) and user equipment (UEs), define the nodes. Set up the wireless network with appropriate configurations.

3. Install applications :

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

4. Enable tracing and Metrics Collection:

• To capture relevant metrics such as transmitted and received packets, use ns3 tracing capabilities.

5. Run the simulation :

• Execute the simulation and collect the trace data.

6. Analyze the results :

• Post-process the trace data to calculate the link success rate.

Example of a simple LTE Network

Create a basic set up of LTE network, generate traffic, and capture packet transmission and reception statistics in ns3.

#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 “ns3/lte-module.h”

#include “ns3/epc-helper.h”

#include “ns3/mobility-module.h”

#include “ns3/flow-monitor-module.h”

#include “ns3/config-store.h”

#include “ns3/log.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“LteLinkSuccessRateExample”);

void CalculateLinkSuccessRate (Ptr<FlowMonitor> monitor)

{

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

uint64_t totalTxPackets = 0;

uint64_t totalRxPackets = 0;

for (auto const& entry : stats)

{

totalTxPackets += entry.second.txPackets;

totalRxPackets += entry.second.rxPackets;

}

double successRate = (double) totalRxPackets / totalTxPackets;

NS_LOG_UNCOND (“Link Success Rate: ” << successRate);

}

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

{

// Set up logging

LogComponentEnable (“UdpClient”, LOG_LEVEL_INFO);

LogComponentEnable (“UdpServer”, LOG_LEVEL_INFO);

// Create LTE network nodes

NodeContainer ueNodes;

NodeContainer enbNodes;

ueNodes.Create (10);

enbNodes.Create (3);

// Install Mobility model

MobilityHelper mobility;

mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”);

mobility.Install (enbNodes);

mobility.SetPositionAllocator (“ns3::GridPositionAllocator”,

“MinX”, DoubleValue (0.0),

“MinY”, DoubleValue (0.0),

“DeltaX”, DoubleValue (50.0),

“DeltaY”, DoubleValue (50.0),

“GridWidth”, UintegerValue (3),

“LayoutType”, StringValue (“RowFirst”));

mobility.Install (ueNodes);

// Create LTE helper and EPC helper

Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();

lteHelper->SetEpcHelper (epcHelper);

// Install LTE devices to the nodes

NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);

NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice (ueNodes);

// Install Internet stack on UEs

InternetStackHelper internet;

internet.Install (ueNodes);

// Assign IP addresses to UEs

Ipv4InterfaceContainer ueIpIface;

ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevs));

// Attach UEs to eNodeBs

for (uint32_t i = 0; i < ueNodes.GetN (); ++i)

{

lteHelper->Attach (ueLteDevs.Get (i), enbLteDevs.Get (i % enbNodes.GetN ()));

}

// Install and start applications on UEs and remote host

uint16_t dlPort = 1234;

ApplicationContainer clientApps;

ApplicationContainer serverApps;

for (uint32_t i = 0; i < ueNodes.GetN (); ++i)

{

UdpServerHelper myServer (dlPort);

serverApps.Add (myServer.Install (ueNodes.Get (i)));

UdpClientHelper myClient (ueIpIface.GetAddress (i), dlPort);

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

myClient.SetAttribute (“Interval”, TimeValue (MilliSeconds (100)));

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

clientApps.Add (myClient.Install (ueNodes.Get (i)));

}

serverApps.Start (Seconds (1.0));

serverApps.Stop (Seconds (10.0));

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

// Set up FlowMonitor to collect performance metrics

FlowMonitorHelper flowmon;

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

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// Calculate link success rate

CalculateLinkSuccessRate (monitor);

// Clean up

Simulator::Destroy ();

return 0;

}

Explanation:

1. Setup Logging:
   • To track activities, enable logging for the UDP applications.
2. Create Nodes and Network:
   • To represent UEs and eNodeBs, create nodes.
   • For UEs and eNodeBs, configure mobility models.
3. Install LTE and EPC Helper:
   • Configure and create LTE and EPC helpers.
   • On the UEs and eNodeBs, install LTE devices.
4. Install Internet Stack:
   • On UEs, install the Internet stack.
   • Assign IP addresses to the UEs.
5. Attach UEs to eNodeBs:
   • Attach each UE to an eNodeB. Here, a round-robin attachment is used for simplicity.
6. Install Applications:
   • On UEs, install UDP server applications.
   • Install UDP client applications on the UEs, sending traffic to the server.
7. Set Up FlowMonitor :
   • To collect and analyze flow statistics, install a FlowMonitor.
8. Run Simulation:
   • Run the simulation for the specified duration.
9. Calculate Link Success Rate :
   • Extract the flow statistics, after the simulation.
   • Calculate the link success rate as the ratio of received packets to transmitted packets.

Analyzing the Results:

• Link success rate :
• By dividing the total number of received packets by the total number of transmitted packets, The link success rate is calculated.

Link Success Rate=Total Received PacketsTotal Transmitted Packets\text{Link Success Rate} = \frac{\text{Total Received Packets}}{\text{Total Transmitted Packets}}Link Success Rate=Total Transmitted PacketsTotal Received Packets

• This metric provides an indication of the reliability and performance of the communication links in the network.

On the whole we had our simulation results for calculating network link success rate in ns3 by measuring the ratio of successfully received packets to the total transmitted packets over a link. Calculation of network link success rate in ns3tool for your project will be aided by ns3simulation.com, Also, we provide more project topics related to Network link success rate.