How to Calculate Network Blockage probability in ns3

To calculate network blockage probability in ns3 is measured by evaluating the ratio of blocked connection requests to the total connection requests over a period of time and also there is a chance to block the communication due to numerous factors like high traffic load, interference, or limited resources.

Step-by-Step Guide to Calculate Network Blockage Probability in ns3

1. Set Up the Simulation Environment:
   • Download ns3 in the computer.
   • Include necessary modules for your simulation (e.g., LTE, WiFi, Internet, and Mobility).
2. Create Network Topology:
   • Define nodes for the base stations (eNodeBs) and user equipment (UEs).
   • Set up the wireless network with appropriate configurations.
3. Configure Applications:
   • Install traffic-generating applications (e.g., UDP, TCP) on the UEs.
4. Enable Tracing and Metrics Collection:
   • Enable tracing to capture relevant metrics such as connection requests and blocked requests.
5. Run the Simulation:
   • Execute the simulation and collect the trace data.
6. Analyze the Results:
   • Post-process the trace data to calculate the blockage probability.

Example Code Snippet for LTE Network

The given below is the sample script to setup an LTE network, generate traffic, and capture blocked connection attempts in ns-3:

#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/config-store.h”

#include “ns3/log.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“LteBlockageProbabilityExample”);

uint32_t totalConnectionRequests = 0;

uint32_t blockedConnectionRequests = 0;

void ConnectionRequestCallback (Ptr<const Packet> packet, const Address &address)

{

totalConnectionRequests++;

}

void ConnectionBlockedCallback (Ptr<const Packet> packet, const Address &address)

{

blockedConnectionRequests++;

}

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));

// Connect callbacks to connection requests and blocked requests

Config::Connect (“/NodeList/*/DeviceList/*/LteUePhy/UlCqiReport”, MakeCallback (&ConnectionRequestCallback));

Config::Connect (“/NodeList/*/DeviceList/*/LteUePhy/UlCqiReport”, MakeCallback (&ConnectionBlockedCallback));

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// Calculate blockage probability

double blockageProbability = static_cast<double>(blockedConnectionRequests) / totalConnectionRequests;

NS_LOG_UNCOND (“Blockage Probability: ” << blockageProbability);

// Clean up

Simulator::Destroy ();

return 0;

}

Explanation:

1. Setup Logging:
   • Enable logging for the UDP applications to track their activities.
2. Create Nodes and Network:
   • Create nodes representing UEs and eNodeBs.
   • Configure mobility models for UEs and eNodeBs.
3. Install LTE and EPC Helper:
   • Create and configure LTE and EPC helpers.
   • Install LTE devices on the UEs and eNodeBs.
4. Install Internet Stack:
   • Install the Internet stack on UEs.
   • 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:
   • Install UDP server applications on the UEs.
   • Install UDP client applications on the UEs, sending traffic to the server.
7. Connect Callbacks to Connection Requests and Blocked Requests:
   • Connect to the appropriate trace sources to log connection requests and blocked requests.
   • Use ConnectionRequestCallback to count total connection requests.
   • Use ConnectionBlockedCallback to count blocked connection requests.
8. Run Simulation:
   • Run the simulation for the specified duration.
9. Calculate Blockage Probability:
   • Calculate blockage probability as the ratio of blocked connection requests to total connection requests.

Blockage Probability=Blocked Connection RequestsTotal Connection Requests\text{Blockage Probability} = \frac{\text{Blocked Connection Requests}}{\text{Total Connection Requests}}Blockage Probability=Total Connection RequestsBlocked Connection Requests​

Analyzing the Results:

• Blockage Probability:
  • The blockage probability is calculated by dividing the number of blocked connection requests by the total number of connection requests.
  • This metric provides an indication of the network’s ability to handle connection attempts under varying conditions.

At last, Network Blockage probability is measured by evaluating the ratio of blocked connection requests to the total connection requests over a period of time and it handles connection tries under fluctuating conditions.

Network Blockage probability project performance are assisted by ns3simulation.com. Approach us for best results.