Attachment #1781 for bug #1831

View | Details | Raw Unified | Return to bug 1831
Collapse All | Expand All




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013 ResiliNets, ITTC, University of Kansas
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as


NS_LOG_COMPONENT_DEFINE ("TcpVariantsComparison");

bool firstCwnd = true;
bool firstSshThr = true;
Time current = Time::FromInteger(3, Time::S);  //Only record cwnd and ssthresh values every 3 seconds
bool first = true;

static void
OutputTrace ()
{
 // *stream->GetStream() << newtime << " " << newval << std::endl;
 // old_time = newval;
}

static void
CwndTracer (Ptr<OutputStreamWrapper>stream, uint32_t oldval, uint32_t newval)
{
  if (firstCwnd)
  if (old_time == 0 && first)
  {
    double mycurrent = current.GetSeconds();
    *stream->GetStream() << new_time << " " << mycurrent << " " << newval << std::endl;
    first = false;
    output = Simulator::Schedule(current,&OutputTrace);
  }
  else
  {
    if (output.IsExpired())
    {
      *stream->GetStream () << "0.0 " << oldval << std::endl;
      firstCwnd = false;
      output = Simulator::Schedule(current,&OutputTrace);
    }
  *stream->GetStream () << Simulator::Now ().GetSeconds () << " " << newval << std::endl;
}

static void
SsThreshTracer (Ptr<OutputStreamWrapper>stream, uint32_t oldval, uint32_t newval)
{
  if (firstCwnd)
  if (old_time == 0 && first)
  {
    double mycurrent = current.GetSeconds();
    *stream->GetStream() << new_time << " " << mycurrent << " " << newval << std::endl;
    first = false;
    output = Simulator::Schedule(current,&OutputTrace);
  }
  else
  {
    if (output.IsExpired())
    {
      *stream->GetStream () << "0.0 " << oldval << std::endl;
      firstSshThr = false;
      output = Simulator::Schedule(current,&OutputTrace);
    }
  *stream->GetStream () << Simulator::Now ().GetSeconds () << " " << newval << std::endl;
}


static void
TraceCwnd (std::string cwnd_tr_file_name)
{
  AsciiTraceHelper ascii;
  if (cwnd_tr_file_name.compare ("") == 0)
    {
      NS_LOG_DEBUG ("No trace file for cwnd provided");
      return;
    }
  else
    {
      Ptr<OutputStreamWrapper> stream = ascii.CreateFileStream (cwnd_tr_file_name.c_str ());
      Config::ConnectWithoutContext ("/NodeList/1/$ns3::TcpL4Protocol/SocketList/0/CongestionWindow",MakeBoundCallback (&CwndTracer, stream));
    }
}

static void
TraceSsThresh (std::string ssthresh_tr_file_name)
{
  AsciiTraceHelper ascii;
  if (ssthresh_tr_file_name.compare ("") == 0)
    {
      NS_LOG_DEBUG ("No trace file for ssthresh provided");
      return;
    }
  else
    {
      Ptr<OutputStreamWrapper> stream = ascii.CreateFileStream (ssthresh_tr_file_name.c_str ());
      Config::ConnectWithoutContext ("/NodeList/1/$ns3::TcpL4Protocol/SocketList/0/SlowStartThreshold",MakeBoundCallback (&SsThreshTracer, stream));
    }
}



  CommandLine cmd;
  cmd.AddValue ("transport_prot", "Transport protocol to use: TcpTahoe, TcpReno, TcpNewReno, TcpWestwood, TcpWestwoodPlus ", transport_prot);
  cmd.AddValue ("error_p", "Packet error rate", error_p);
  cmd.AddValue ("bandwidth", "Bottleneck bandwidth", bandwidth);
  cmd.AddValue ("access_bandwidth", "Access link bandwidth", access_bandwidth);
  cmd.AddValue ("delay", "Access link delay", access_delay);
  cmd.AddValue ("tracing", "Flag to enable/disable tracing", tracing);
  cmd.AddValue ("tr_name", "Name of output trace file", tr_file_name);
  cmd.AddValue ("cwnd_tr_name", "Name of output trace file", cwnd_tr_file_name);
  cmd.AddValue ("ssthresh_tr_name", "Name of output trace file", ssthresh_tr_file_name);
  cmd.AddValue ("data", "Number of Megabytes of data to transmit", data_mbytes);
  cmd.AddValue ("mtu", "Size of IP packets to send in bytes", mtu_bytes);
  cmd.AddValue ("num_flows", "Number of flows", num_flows);
  cmd.AddValue ("duration", "Time to allow flows to run in seconds", duration);
  cmd.AddValue ("run", "Run index (for setting repeatable seeds)", run);
  cmd.AddValue ("flow_monitor", "Enable flow monitor", flow_monitor);
  cmd.Parse (argc, argv);

  SeedManager::SetSeed (1);
  SeedManager::SetRun (run);

  // User may find it convenient to enable logging
  //LogComponentEnable("TcpVariantsComparison", LOG_LEVEL_ALL);

  //LogComponentEnable("DropTailQueue", LOG_LEVEL_ALL);

  // Calculate the ADU size
  Header* temp_header = new Ipv4Header ();
  uint32_t ip_header = temp_header->GetSerializedSize ();
  NS_LOG_LOGIC ("IP Header size is: " << ip_header);
  delete temp_header;
  temp_header = new TcpHeader ();
  uint32_t tcp_header = temp_header->GetSerializedSize ();
  NS_LOG_LOGIC ("TCP Header size is: " << tcp_header);
  delete temp_header;
  uint32_t tcp_adu_size = mtu_bytes - (ip_header + tcp_header);

  float stop_time = start_time + duration;

  // Select TCP variant
  if (transport_prot.compare ("TcpTahoe") == 0)
    {
      Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpTahoe::GetTypeId ()));
    Config::SetDefault("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpReno::GetTypeId()));
  else if (transport_prot.compare("TcpNewReno") == 0)
    Config::SetDefault("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpNewReno::GetTypeId()));
  else if (transport_prot.compare("TcpWestwood") == 0)
    {// the default protocol type in ns3::TcpWestwood is WESTWOOD
      Config::SetDefault("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId()));
      Config::SetDefault("ns3::TcpWestwood::FilterType", EnumValue(TcpWestwood::TUSTIN));
    }
  else if (transport_prot.compare ("TcpReno") == 0)
    {
      Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpReno::GetTypeId ()));
    }
  else if (transport_prot.compare ("TcpNewReno") == 0)
    {
      Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpNewReno::GetTypeId ()));
    }
  else if (transport_prot.compare ("TcpWestwood") == 0)
    { // the default protocol type in ns3::TcpWestwood is WESTWOOD
      Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId ()));
      Config::SetDefault ("ns3::TcpWestwood::FilterType", EnumValue (TcpWestwood::TUSTIN));
    }
  else if (transport_prot.compare ("TcpWestwoodPlus") == 0)
    {
      Config::SetDefault ("ns3::TcpL4Protocol::SocketType", TypeIdValue (TcpWestwood::GetTypeId ()));
      Config::SetDefault ("ns3::TcpWestwood::ProtocolType", EnumValue (TcpWestwood::WESTWOODPLUS));
      Config::SetDefault ("ns3::TcpWestwood::FilterType", EnumValue (TcpWestwood::TUSTIN));
    }
  else
    {

  NodeContainer gateways;
  gateways.Create (1);
  NodeContainer sources;
  sources.Create (num_flows);
  NodeContainer sinks;
  sinks.Create (num_flows);

  // Configure the error model
  // Here we use RateErrorModel with packet error rate
  Ptr<UniformRandomVariable> uv = CreateObject<UniformRandomVariable> ();
  uv->SetStream (50);
  RateErrorModel error_model;
  error_model.SetRandomVariable (uv);
  error_model.SetUnit (RateErrorModel::ERROR_UNIT_PACKET);
  error_model.SetRate (error_p);

  PointToPointHelper UnReLink;
  UnReLink.SetDeviceAttribute ("DataRate", StringValue (bandwidth));

  LocalLink.SetDeviceAttribute ("DataRate", StringValue (access_bandwidth));
  LocalLink.SetChannelAttribute ("Delay", StringValue (access_delay));
  Ipv4InterfaceContainer sink_interfaces;
  for (int i = 0; i < num_flows; i++)
    {
      NetDeviceContainer devices;
      devices = LocalLink.Install (sources.Get (i), gateways.Get (0));
      address.NewNetwork ();
      Ipv4InterfaceContainer interfaces = address.Assign (devices);
      devices = UnReLink.Install (gateways.Get (0), sinks.Get (i));
      address.NewNetwork ();
      interfaces = address.Assign (devices);
      sink_interfaces.Add (interfaces.Get (1));
    }

  NS_LOG_INFO ("Initialize Global Routing.");

  Address sinkLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
  PacketSinkHelper sinkHelper ("ns3::TcpSocketFactory", sinkLocalAddress);

  for (uint16_t i = 0; i < sources.GetN (); i++)
    {
      AddressValue remoteAddress (InetSocketAddress (sink_interfaces.GetAddress (i, 0), port));

      if (transport_prot.compare ("TcpTahoe") == 0
          || transport_prot.compare ("TcpReno") == 0
          || transport_prot.compare ("TcpNewReno") == 0
          || transport_prot.compare ("TcpWestwood") == 0
          || transport_prot.compare ("TcpWestwoodPlus") == 0)
        {
          Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (tcp_adu_size));
          BulkSendHelper ftp ("ns3::TcpSocketFactory", Address ());
          ftp.SetAttribute ("Remote", remoteAddress);
          ftp.SetAttribute ("SendSize", UintegerValue (tcp_adu_size));
          ftp.SetAttribute ("MaxBytes", UintegerValue (int(data_mbytes * 1000000)));

          ApplicationContainer sourceApp = ftp.Install (sources.Get (i));
          sourceApp.Start (Seconds (start_time * i));
          sourceApp.Stop (Seconds (stop_time - 3));

          sinkHelper.SetAttribute ("Protocol", TypeIdValue (TcpSocketFactory::GetTypeId ()));
          ApplicationContainer sinkApp = sinkHelper.Install (sinks);
          sinkApp.Start (Seconds (start_time * i));
          sinkApp.Stop (Seconds (stop_time));
        }
      else

    {
      std::ofstream ascii;
      Ptr<OutputStreamWrapper> ascii_wrap;
      if (tr_file_name.compare ("") == 0)
        {
          NS_LOG_DEBUG ("No trace file provided");
          exit (1);
        }
      else
        {
          ascii.open (tr_file_name.c_str ());
          ascii_wrap = new OutputStreamWrapper (tr_file_name.c_str (), std::ios::out);
        }

      stack.EnableAsciiIpv4All (ascii_wrap);

      Simulator::Schedule (Seconds (0.00001), &TraceCwnd, cwnd_tr_file_name);
      Simulator::Schedule (Seconds (0.00001), &TraceSsThresh, ssthresh_tr_file_name);
    }

  UnReLink.EnablePcapAll ("TcpVariantsComparison", true);
  LocalLink.EnablePcapAll ("TcpVariantsComparison", true);

  // Flow monitor
  FlowMonitorHelper flowHelper;
  if (flow_monitor)
    {
      flowHelper.InstallAll ();
    }

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

  if (flow_monitor)
    {
      flowHelper.SerializeToXmlFile ("TcpVariantsComparison.flowmonitor", true, true);
    }

  Simulator::Destroy ();




                    MakeUintegerAccessor (&TcpNewReno::m_retxThresh),
                    MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("LimitedTransmit", "Enable limited transmit",
                   BooleanValue (false),
                   MakeBooleanAccessor (&TcpNewReno::m_limitedTx),
                   MakeBooleanChecker ())
    .AddTraceSource ("CongestionWindow",
                     "The TCP connection's congestion window",
                     MakeTraceSourceAccessor (&TcpNewReno::m_cWnd))
    .AddTraceSource ("SlowStartThreshold",
                     "TCP slow start threshold (bytes)",
                     MakeTraceSourceAccessor (&TcpNewReno::m_ssThresh))
 ;
  return tid;
}


    }
  else if (m_inFastRec && seq >= m_recover)
    { // Full ACK (RFC2582 sec.3 bullet #5 paragraph 2, option 1)
      m_cWnd = std::min (m_ssThresh.Get (), BytesInFlight () + m_segmentSize);
      m_inFastRec = false;
      NS_LOG_INFO ("Received full ACK. Leaving fast recovery with cwnd set to " << m_cWnd);
    }

(-)a/src/internet/model/tcp-newreno.h (-1 / +1 lines)

Lines 77-83	Link Here

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  SequenceNumber32       m_recover;      //!< Previous highest Tx seqnum for fast recovery

  SequenceNumber32       m_recover;      //!< Previous highest Tx seqnum for fast recovery

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

(-)a/src/internet/model/tcp-reno.cc (+3 lines)

Lines 48-53	Link Here

    .AddTraceSource ("CongestionWindow",

    .AddTraceSource ("CongestionWindow",

                     "The TCP connection's congestion window",

                     "The TCP connection's congestion window",

                     MakeTraceSourceAccessor (&TcpReno::m_cWnd))

                     MakeTraceSourceAccessor (&TcpReno::m_cWnd))

    .AddTraceSource ("SlowStartThreshold",

                     "TCP slow start threshold (bytes)",

                     MakeTraceSourceAccessor (&TcpReno::m_ssThresh))

  return tid;

  return tid;

(-)a/src/internet/model/tcp-reno.h (-1 / +1 lines)

Lines 79-85	Link Here

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  bool                   m_inFastRec;    //!< currently in fast recovery

  bool                   m_inFastRec;    //!< currently in fast recovery

(-)a/src/internet/model/tcp-tahoe.cc (+3 lines)

Lines 48-53	Link Here

    .AddTraceSource ("CongestionWindow",

    .AddTraceSource ("CongestionWindow",

                     "The TCP connection's congestion window",

                     "The TCP connection's congestion window",

                     MakeTraceSourceAccessor (&TcpTahoe::m_cWnd))

                     MakeTraceSourceAccessor (&TcpTahoe::m_cWnd))

    .AddTraceSource ("SlowStartThreshold",

                     "TCP slow start threshold (bytes)",

                     MakeTraceSourceAccessor (&TcpTahoe::m_ssThresh))

  return tid;

  return tid;

(-)a/src/internet/model/tcp-tahoe.h (-1 / +1 lines)

Lines 83-89	Link Here

protected:

protected:

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window

  uint32_t               m_ssThresh;     //!< Slow Start Threshold

  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_initialCWnd;  //!< Initial cWnd value

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold

};

};

(-)a/src/internet/model/tcp-westwood.cc (-1 / +4 lines)

Lines 57-62	Link Here

      .AddConstructor<TcpWestwood>()

      .AddConstructor<TcpWestwood>()

      .AddTraceSource("CongestionWindow", "The TCP connection's congestion window",

      .AddTraceSource("CongestionWindow", "The TCP connection's congestion window",

                      MakeTraceSourceAccessor(&TcpWestwood::m_cWnd))

                      MakeTraceSourceAccessor(&TcpWestwood::m_cWnd))

      .AddTraceSource ("SlowStartThreshold",

                       "TCP slow start threshold (bytes)",

                       MakeTraceSourceAccessor (&TcpWestwood::m_ssThresh))

      .AddAttribute("FilterType", "Use this to choose no filter or Tustin's approximation filter",

      .AddAttribute("FilterType", "Use this to choose no filter or Tustin's approximation filter",

                    EnumValue(TcpWestwood::TUSTIN), MakeEnumAccessor(&TcpWestwood::m_fType),

                    EnumValue(TcpWestwood::TUSTIN), MakeEnumAccessor(&TcpWestwood::m_fType),

                    MakeEnumChecker(TcpWestwood::NONE, "None", TcpWestwood::TUSTIN, "Tustin"))

                    MakeEnumChecker(TcpWestwood::NONE, "None", TcpWestwood::TUSTIN, "Tustin"))

Lines 273-279	Link Here

273

  if (count == 3 && !m_inFastRec)

276

  if (count == 3 && !m_inFastRec)

274

    {// Triple duplicate ACK triggers fast retransmit

277

    {// Triple duplicate ACK triggers fast retransmit

275

     // Adjust cwnd and ssthresh based on the estimated BW

278

     // Adjust cwnd and ssthresh based on the estimated BW

276

      m_ssThresh = m_currentBW * static_cast<double> (m_minRtt.GetSeconds());

279

      m_ssThresh = uint32_t(m_currentBW * static_cast<double> (m_minRtt.GetSeconds()));

277

      if (m_cWnd > m_ssThresh)

280

      if (m_cWnd > m_ssThresh)

278

281

279

          m_cWnd = m_ssThresh;

282

          m_cWnd = m_ssThresh;

(-)a/src/internet/model/tcp-westwood.h (-1 / +1 lines)

Lines 164-170	Link Here

164

165

protected:

165

protected:

166

  TracedValue<uint32_t>  m_cWnd;                   //!< Congestion window

166

  TracedValue<uint32_t>  m_cWnd;                   //!< Congestion window

167

  uint32_t               m_ssThresh;               //!< Slow Start Threshold

167

  TracedValue<uint32_t>  m_ssThresh;               //!< Slow Start Threshold

168

  uint32_t               m_initialCWnd;            //!< Initial cWnd value

168

  uint32_t               m_initialCWnd;            //!< Initial cWnd value

169

  bool                   m_inFastRec;              //!< Currently in fast recovery if TRUE

169

  bool                   m_inFastRec;              //!< Currently in fast recovery if TRUE

170

Return to bug 1831