How to Calculate Network Gross and Net Bit Rate in ns3

To calculate the network gross and net bit rate in ns3, it includes estimating the total data rate at different layers of the network stack. The gross bit rate is defined as data rate including all protocol overheads, while the net bit rate is to the actual usable data rate excluding protocol overheads.

If you require more help then reach ns3simulation.com, network gross and net bit rate in ns3 performance analysis are assisted by us.

Step-by-Step Guide to Calculate Network Gross and Net Bit Rate in ns3

1. Set Up the Simulation Environment:
   • Download ns3 and setup correctly.
   • Include necessary modules for your simulation (e.g., LTE, Internet, Mobility).
2. Create Network Topology:
   • Define nodes for the base stations (eNodeBs), access points (APs), 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 data rates.
5. Run the Simulation:
   • Execute the simulation and collect the trace data.
6. Analyze the Results:
   • Post-process the trace data to calculate the gross and net bit rates.

Example Code Snippet for LTE Network

Below is a sample on how to implement the LTE network, generate traffic, and capture data rates 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/flow-monitor-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“LteBitRateExample”);

void CalculateBitRates (Ptr<FlowMonitor> monitor, Ptr<Ipv4FlowClassifier> classifier)

{

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

double grossBitRate = 0.0;

double netBitRate = 0.0;

for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin (); i != stats.end (); ++i)

{

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

NS_LOG_UNCOND (“Flow ” << i->first << ” (” << t.sourceAddress << ” -> ” << t.destinationAddress << “)”);

NS_LOG_UNCOND (”  Tx Bytes:   ” << i->second.txBytes);

NS_LOG_UNCOND (”  Rx Bytes:   ” << i->second.rxBytes);

NS_LOG_UNCOND (”  Duration:   ” << i->second.timeLastRxPacket.GetSeconds () – i->second.timeFirstRxPacket.GetSeconds ());

double duration = i->second.timeLastRxPacket.GetSeconds () – i->second.timeFirstTxPacket.GetSeconds ();

grossBitRate += i->second.txBytes * 8.0 / duration;

netBitRate += i->second.rxBytes * 8.0 / duration;

}

NS_LOG_UNCOND (“Gross Bit Rate: ” << grossBitRate / 1000 / 1000 << ” Mbps”);

NS_LOG_UNCOND (“Net Bit Rate: ” << netBitRate / 1000 / 1000 << ” Mbps”);

}

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

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

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// Calculate and log the bit rates

CalculateBitRates (monitor, classifier);

// 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. Set Up FlowMonitor:
   • Install a FlowMonitor to collect and analyze flow statistics.
8. Run Simulation:
   • Run the simulation for the specified duration.
9. Calculate and Log Bit Rates:
   • After the simulation, extract the flow statistics.
   • Calculate the gross bit rate as the sum of all transmitted bytes over time.
   • Calculate the net bit rate as the sum of all received bytes over time.

Analyzing the Results:

• Gross Bit Rate:
  • The gross bit rate includes all protocol overheads and is calculated using the transmitted bytes.

Gross Bit Rate=TxBytes×8Duration\text{Gross Bit Rate} = \frac{\text{TxBytes} \times 8}{\text{Duration}}Gross Bit Rate=DurationTxBytes×8​

• Net Bit Rate:
  • The net bit rate excludes protocol overheads and is calculated using the received bytes.

Net Bit Rate=RxBytes×8Duration\text{Net Bit Rate} = \frac{\text{RxBytes} \times 8}{\text{Duration}}Net Bit Rate=DurationRxBytes×8​

This sample offers the simple setup for the gross and net bit rates in an ns-3 simulation.

In this script, we had explored how the gross and net bit rates calculate the data at various layers of network stack using ns3. We also offer additional details on how the gross and net bit rate performs in other tools.