How to Begin Implement Network Burstiness in NS3

To begin implementing and analyzing the Network Burstiness in ns3, we follow these steps. Burstiness denotes to the variations within traffic intensity, which is typified by phases of high activity (bursts) and low activity (idle times). We will instruct you on how to execute and examine the Network Burstiness in NS3:

Steps to Begin Implement Network Burstiness in NS3

1. Understand Network Burstiness

Burstiness can happen in networks because of:

• Application-layer traffic models.
• Protocol behavior like TCP slow start or congestion control.
• Variability within user-generated traffic.

Following is crucial parameters to examine the burstiness:

• Traffic intensity over time.
• Packet arrival patterns such as burst intervals, burst sizes.
• Queue dynamics and packet loss by reason of bursts.

2. Set Up Your Environment

Make sure that we have effectively installed ns3 and properly functioning on the system. Get more knowledge about the ns3 scripting.

3. Create a Network Topology

Example: Point-to-Point Topology

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 Topology

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

NetDeviceContainer wifiDevices;

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

4. Set Up the Internet Stack

We can install the Internet stack for 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. Generate Bursty Traffic

Example: On-Off Application

The OnOffApplication makes bursty traffic including the times of activity (ON) and inactivity (OFF):

OnOffHelper onOff(“ns3::UdpSocketFactory”, InetSocketAddress(interfaces.GetAddress(1), 9));

onOff.SetAttribute(“DataRate”, StringValue(“5Mbps”)); // Data rate during ON state

onOff.SetAttribute(“PacketSize”, UintegerValue(1024)); // Packet size in bytes

onOff.SetAttribute(“OnTime”, StringValue(“ns3::ExponentialRandomVariable[Mean=1.0]”)); // ON period

onOff.SetAttribute(“OffTime”, StringValue(“ns3::ExponentialRandomVariable[Mean=1.0]”)); // OFF period

ApplicationContainer app = onOff.Install(nodes.Get(0));

app.Start(Seconds(1.0));

app.Stop(Seconds(10.0));

Example: Traffic Generator

Manually, we can schedule packets for custom burst models:

void GenerateBurstTraffic(Ptr<Socket> socket, uint32_t burstSize, Time interval) {

for (uint32_t i = 0; i < burstSize; ++i) {

Ptr<Packet> packet = Create<Packet>(1024); // Packet size in bytes

socket->Send(packet);

}

Simulator::Schedule(interval, &GenerateBurstTraffic, socket, burstSize, interval);

}

// Example usage

Ptr<Socket> socket = Socket::CreateSocket(nodes.Get(0), UdpSocketFactory::GetTypeId());

socket->Connect(InetSocketAddress(interfaces.GetAddress(1), 9));

GenerateBurstTraffic(socket, 10, Seconds(2.0)); // Send 10 packets every 2 seconds

6. Enable Tracing

Packet-Level Tracing

Allow packet tracing for examining the burst models:

AsciiTraceHelper ascii;

pointToPoint.EnableAsciiAll(ascii.CreateFileStream(“burstiness.tr”));

Queue Tracing

During bursts, we need to observe the queue dynamics:

Ptr<Queue<Packet>> queue = DynamicCast<PointToPointNetDevice>(devices.Get(0))->GetQueue();

queue->TraceConnectWithoutContext(“PacketsInQueue”, MakeCallback([](uint32_t qSize) {

std::cout << “Queue size: ” << qSize << ” packets at time ” << Simulator::Now().GetSeconds() << “s\n”;

}));

7. Measure Burstiness Metrics

Analyze Traffic Intensity

Track arrival rates and packet transmission for examining the traffic intensity:

uint32_t packetsSent = 0, packetsReceived = 0;

void PacketSentCallback(Ptr<const Packet> packet) {

packetsSent++;

}

void PacketReceivedCallback(Ptr<const Packet> packet) {

packetsReceived++;

}

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

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

Log Packet Timestamps

Monitor inter-arrival times for logging packets:

std::vector<double> arrivalTimes;

void LogPacketArrival(Ptr<const Packet> packet) {

static Time lastTime = Simulator::Now();

Time currentTime = Simulator::Now();

double interArrival = (currentTime – lastTime).GetSeconds();

arrivalTimes.push_back(interArrival);

lastTime = currentTime;

}

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

Analyze Bursty Behavior

Towards the end of the replication, we want to examine the arrivalTimes for bursty models and variability.

8. Use FlowMonitor

FlowMonitor monitors the performance parameters with burst-induced packet loss and delay:

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

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

<< ” Throughput: ” << flow.second.rxBytes * 8.0 / (flow.second.timeLastRxPacket.GetSeconds() – flow.second.timeFirstTxPacket.GetSeconds()) / 1e6 << ” Mbps\n”;

std::cout << ”  Packet Loss Ratio: ” << (flow.second.txPackets – flow.second.rxPackets) * 100.0 / flow.second.txPackets << “%\n”;

}

9. Visualize Results

• NetAnim: For envisioning the bursty traffic using NetAnim tools within real-time:

AnimationInterface anim(“network_burstiness.xml”);

• Transfer information such as inter-arrival times, queue lengths into a file for graphing to utilize tools like MATLAB or Excel.

10. Experiment and Optimize

• Experiment with changing ON/OFF periods and burst sizes.
• Fine-tune link capacities and queue sizes for managing the bursty traffic.
• Replicate diverse traffic models like Poisson, heavy-tailed distributions.

11. Run the Simulation

Execute the simulation and then examine their outcomes:

Simulator::Run();

Simulator::Destroy();

This manual helps you efficiently implement, analyze and visualize the Network Burstiness using NS3 with stepwise guidance and coding examples. More advanced details will be added based on your desires.