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
- Set Up the Simulation Environment:
- Download ns3 in the computer.
- Include necessary modules for your simulation (e.g., LTE, WiFi, Internet, and Mobility).
- Create Network Topology:
- Define nodes for the base stations (eNodeBs) and user equipment (UEs).
- Set up the wireless network with appropriate configurations.
- Configure Applications:
- Install traffic-generating applications (e.g., UDP, TCP) on the UEs.
- Enable Tracing and Metrics Collection:
- Enable tracing to capture relevant metrics such as connection requests and blocked requests.
- Run the Simulation:
- Execute the simulation and collect the trace data.
- 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:
- Setup Logging:
- Enable logging for the UDP applications to track their activities.
- Create Nodes and Network:
- Create nodes representing UEs and eNodeBs.
- Configure mobility models for UEs and eNodeBs.
- Install LTE and EPC Helper:
- Create and configure LTE and EPC helpers.
- Install LTE devices on the UEs and eNodeBs.
- Install Internet Stack:
- Install the Internet stack on UEs.
- Assign IP addresses to the UEs.
- Attach UEs to eNodeBs:
- Attach each UE to an eNodeB. Here, a round-robin attachment is used for simplicity.
- Install Applications:
- Install UDP server applications on the UEs.
- Install UDP client applications on the UEs, sending traffic to the server.
- 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.
- Run Simulation:
- Run the simulation for the specified duration.
- 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.