How to Begin Implement Network Maximum Transfer Unit in NS3

To begin implementing and focusing on the impacts of the Network Maximum Transfer Unit (MTU) within NS3, we can set up maximum packet size that permitted for transmission through the network interface. MTU acts an important role in computing the fragmentation, packet processing efficiency, and overall network performance. Below is a stepwise guide on how to execute the Network Maximum Transfer Unit (MTU) using NS3:

Steps to Implement Network MTU in NS3

1. Understand MTU

• Definition: MTU is the maximum size (which denotes in bytes) of a data packet that can be transmitted through the network devoid of fragmentation.
• Default MTU:
  • Ethernet: 1500 bytes.
  • Point-to-Point links in NS3: Normally set to 1500 bytes.
• Effect of MTU:
  • If a packet surpasses the MTU size then it will be split.
  • Inappropriate MTU settings can be triggered the performance issues such as retransmissions or packet drops.

2. Set Up NS3 Environment

1. Install NS3:
   • Make sure that we have installed and set up NS3 on the system. Also, we can download it.
2. Choose a Base Scenario:
   • Make a simple topology with a point-to-point link or a basic router scenario.

3. Configure MTU in NS3

1. Set MTU for a Device: Make use of SetMtu() approach on network devices setting up the MTU.

device->SetMtu(1400); // Set MTU to 1400 bytes

1. Observe Fragmentation: Monitor whether packets are split when they surpass the MTU.

4. Implement a Simulation with MTU Configuration

Here’s a sample script, which sets up MTU at point-to-point link and examines their impacts.

Example Script: Configuring MTU 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”

using namespace ns3;

void CheckPacketSize(Ptr<const Packet> packet) {

NS_LOG_UNCOND(“Packet Size: ” << packet->GetSize() << ” bytes”);

}

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

CommandLine cmd;

cmd.Parse(argc, argv);

// Create nodes

NodeContainer nodes;

nodes.Create(2);

// Configure Point-to-Point link

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

pointToPoint.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices = pointToPoint.Install(nodes);

// Set custom MTU

devices.Get(0)->SetMtu(1400); // Set MTU to 1400 bytes on the first device

devices.Get(1)->SetMtu(1400); // Set MTU to 1400 bytes on the second device

// Install Internet stack

InternetStackHelper stack;

stack.Install(nodes);

// Assign IP addresses

Ipv4AddressHelper address;

address.SetBase(“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign(devices);

// Install applications

uint16_t port = 9;

UdpEchoServerHelper server(port);

ApplicationContainer serverApp = server.Install(nodes.Get(1));

serverApp.Start(Seconds(1.0));

serverApp.Stop(Seconds(10.0));

UdpEchoClientHelper client(interfaces.GetAddress(1), port);

client.SetAttribute(“MaxPackets”, UintegerValue(10));

client.SetAttribute(“Interval”, TimeValue(Seconds(1.0)));

client.SetAttribute(“PacketSize”, UintegerValue(2000)); // Exceeds MTU, will cause fragmentation

ApplicationContainer clientApp = client.Install(nodes.Get(0));

clientApp.Start(Seconds(2.0));

clientApp.Stop(Seconds(10.0));

// Add tracing for packets

devices.Get(0)->TraceConnectWithoutContext(“PhyTxBegin”, MakeCallback(&CheckPacketSize));

Simulator::Run();

Simulator::Destroy();

return 0;

}

Explanation of the Script

1. MTU Configuration:
   • Set 1400 bytes by MTU for both devices at point-to-point link.
2. Packet Size:
   • The client application tries to transmit the packets of size 2000 bytes that surpasses the MTU and it will trigger fragmentation.
3. Tracing:
   • The CheckPacketSize function records the size of packets to be sent, and it supports to monitor the fragmentation.
4. UDP Application:
   • A UdpEchoClient forwards packets to a UdpEchoServer generating traffic.

5. Run the Simulation

1. Build the script:

./waf –run “your-script-name”

1. Monitor the outcomes for records that showing packet sizes and behavior of fragmentation.

6. Analyze Results

• Check for Fragmentation:
  • Confirm whether packets surpassing the MTU are split.
  • Analyze the packet details with the support of Wireshark or NS3 tracing tools.
• Measure Performance:
  • Observe throughput and latency for examining the effect of various MTU values.

Advanced Extensions

1. Dynamic MTU:
   • During the simulation, execute a scenario in which MTU values dynamically modify.
2. Multiple MTU Values:
   • Replicate diverse MTU settings at various links and then examine its influence over end-to-end interaction.
3. Performance Metrics:
   • Assess the effect of MTU on performance parameters such as throughput, latency, and packet loss.
4. MTU and Protocols:
   • Experiment the diverse transport protocols (TCP, UDP) behavior including diverse MTU settings.
5. Visualization:
   • Transfer outcomes to leverage external tools such as MATLAB or Python for graphical analysis.

In this module, systematic implementation steps of Network Maximum Transfer Unit with NS3 sample snippets have been delivered. More advanced specifies will be available as required.