Simulation of Selective Repeat ARQ and Go-Back-N under High Error Rates using ns-3 | NS3 Project 13

To simulate Selective Repeat (SR) and Go-Back-N (GBN) ARQ protocols using ns-3 and compare their performance under high error rates in terms of throughput, delay, and packet loss.

LLM + PROMPT (VERY IMPORTANT)

LLM Used: ChatGPT (OpenAI GPT-5.3)

Prompt Used:

“Simulate Selective Repeat ARQ and compare its performance with Go-Back-N under high error rates using ns-3. Provide complete code, steps, and graph generation.”

NETWORK TOPOLOGY

• Two nodes:
  • Node 0 → Sender
  • Node 1 → Receiver
• Connected using Point-to-Point link

Parameters:

• Bandwidth: 5 Mbps
• Delay: 2 ms
• Error Rate: High (e.g., 1e-3)

PROTOCOL MAPPING

• GBN → TCP Tahoe
• SR → TCP NewReno

Source Code:

#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/error-model.h"
#include "ns3/flow-monitor-module.h"
#include "ns3/netanim-module.h"

using namespace ns3;

int main(int argc, char *argv[])
{
  std::string tcpType = "TcpNewReno"; // default
  double errorRate = 1e-3;

  CommandLine cmd;
  cmd.AddValue("tcpType", "Tcp Variant", tcpType);
  cmd.AddValue("errorRate", "Error rate", errorRate);
  cmd.Parse(argc, argv);

  if (tcpType == "TcpNewReno")
  {
    Config::SetDefault("ns3::TcpL4Protocol::SocketType",
                       TypeIdValue(TcpNewReno::GetTypeId()));
  }
  else
  {
    Config::SetDefault("ns3::TcpL4Protocol::SocketType",
                       TypeIdValue(TcpHighSpeed::GetTypeId()));
  }

  NodeContainer nodes;
  nodes.Create(2);

  PointToPointHelper p2p;
  p2p.SetDeviceAttribute("DataRate", StringValue("5Mbps"));
  p2p.SetChannelAttribute("Delay", StringValue("2ms"));

  NetDeviceContainer devices = p2p.Install(nodes);
  p2p.EnablePcapAll("sr_vs_gbn");

  Ptr<RateErrorModel> em = CreateObject<RateErrorModel>();
  em->SetAttribute("ErrorRate", DoubleValue(errorRate));
  devices.Get(1)->SetAttribute("ReceiveErrorModel", PointerValue(em));

  InternetStackHelper stack;
  stack.Install(nodes);

  Ipv4AddressHelper address;
  address.SetBase("10.1.1.0", "255.255.255.0");
  Ipv4InterfaceContainer interfaces = address.Assign(devices);

  uint16_t port = 5000;
  PacketSinkHelper sink("ns3::TcpSocketFactory",
                        InetSocketAddress(Ipv4Address::GetAny(), port));
  ApplicationContainer sinkApp = sink.Install(nodes.Get(1));
  sinkApp.Start(Seconds(0.0));
  sinkApp.Stop(Seconds(20.0));

  BulkSendHelper source("ns3::TcpSocketFactory",
                        InetSocketAddress(interfaces.GetAddress(1), port));
  source.SetAttribute("MaxBytes", UintegerValue(0));
  ApplicationContainer sourceApp = source.Install(nodes.Get(0));
  sourceApp.Start(Seconds(1.0));
  sourceApp.Stop(Seconds(20.0));

  FlowMonitorHelper flowmon;
  Ptr<FlowMonitor> monitor = flowmon.InstallAll();

  Simulator::Stop(Seconds(20.0));
  Simulator::Run();

  monitor->CheckForLostPackets();
  auto stats = monitor->GetFlowStats();
  for (auto &flow : stats)
  {
    double throughput = flow.second.rxBytes * 8.0 /
      (flow.second.timeLastRxPacket.GetSeconds() -
       flow.second.timeFirstTxPacket.GetSeconds()) / 1024;
    std::cout << "Throughput: " << throughput << " Kbps\n";
    std::cout << "Lost Packets: " << flow.second.lostPackets << "\n";
    std::cout << "Delay: " << flow.second.delaySum.GetSeconds() << " sec\n";
  }

  monitor->SerializeToXmlFile("sr_vs_gbn.xml", true, true);
  AnimationInterface anim("sr_vs_gbn.xml");

  Simulator::Destroy();
  return 0;
}

Output:

i) Selective Repeat ARQ (3, 4, 5)

→ IO Graph Using Wireshark

→ NetAnim

NetAnim

→ Go-Back-N (3, 4, 5)

→ IO Graph Using Wireshark

→ NetAnim

NetAnim

SR vs GBN

Throughput Difference

OBSERVATION

1. Go-Back-N (TCP Tahoe)

• Retransmits multiple packets after loss
• High packet loss
• Lower throughput
• Higher delay

2. Selective Repeat (TCP NewReno)

• Retransmits only lost packets
• Efficient bandwidth usage
• Higher throughput
• Lower delay

RESULT

Selective Repeat ARQ performs better than Go-Back-N under high error conditions due to selective retransmission, resulting in improved throughput and reduced delay.