Attachment #1863 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 ();

(-)a/src/internet/model/nsc-tcp-socket-impl.cc (-4 / +9 lines)

Lines 57-62	Link Here

    .AddTraceSource ("CongestionWindow",

    .AddTraceSource ("CongestionWindow",

                     "The TCP connection's congestion window",

                     "The TCP connection's congestion window",

                     MakeTraceSourceAccessor (&NscTcpSocketImpl::m_cWnd))

                     MakeTraceSourceAccessor (&NscTcpSocketImpl::m_cWnd))

    .AddTraceSource ("SlowStartThreshold",

                     "TCP slow start threshold (bytes)",

                     MakeTraceSourceAccessor (&NscTcpSocketImpl::m_ssThresh))

  return tid;

  return tid;

Lines 106-111	Link Here

106

    m_cWnd (sock.m_cWnd),

109

    m_cWnd (sock.m_cWnd),

107

    m_ssThresh (sock.m_ssThresh),

110

    m_ssThresh (sock.m_ssThresh),

108

    m_initialCWnd (sock.m_initialCWnd),

111

    m_initialCWnd (sock.m_initialCWnd),

112

    m_initialSsThresh (sock.m_initialSsThresh),

109

    m_lastMeasuredRtt (Seconds (0.0)),

113

    m_lastMeasuredRtt (Seconds (0.0)),

110

    m_cnTimeout (sock.m_cnTimeout),

114

    m_cnTimeout (sock.m_cnTimeout),

111

    m_cnCount (sock.m_cnCount),

115

    m_cnCount (sock.m_cnCount),

Lines 152-157	Link Here

152

  m_node = node;

156

  m_node = node;

153

  // Initialize some variables

157

  // Initialize some variables

154

  m_cWnd = m_initialCWnd * m_segmentSize;

158

  m_cWnd = m_initialCWnd * m_segmentSize;

159

  m_ssThresh = m_initialSsThresh;

155

  m_rxWindowSize = m_advertisedWindowSize;

160

  m_rxWindowSize = m_advertisedWindowSize;

156

161

157

162

Lines 730-744	Link Here

730

735

731

736

732

void

737

void

733

NscTcpSocketImpl::SetSSThresh (uint32_t threshold)

738

NscTcpSocketImpl::SetInitialSSThresh (uint32_t threshold)

734

739

735

  m_ssThresh = threshold;

740

  m_initialSsThresh = threshold;

736

741

737

742

738

uint32_t

743

uint32_t

739

NscTcpSocketImpl::GetSSThresh (void) const

744

NscTcpSocketImpl::GetInitialSSThresh (void) const

740

745

741

  return m_ssThresh;

746

  return m_initialSsThresh;

742

747

743

748

744

void

749

void




   * \returns the window size
   */
  virtual uint32_t GetAdvWin (void) const;
  virtual void SetInitialSSThresh (uint32_t threshold);
  virtual uint32_t GetInitialSSThresh (void) const;
  virtual void SetInitialCwnd (uint32_t cwnd);
  virtual uint32_t GetInitialCwnd (void) const;
  virtual void SetConnTimeout (Time timeout);

  uint32_t                       m_segmentSize;          //!< SegmentSize
  uint32_t                       m_rxWindowSize;         //!< Receive window size
  uint32_t                       m_advertisedWindowSize; //!< Window to advertise
  TracedValue<uint32_t>          m_ssThresh;             //!< Slow Start Threshold
  TracedValue<uint32_t>          m_cWnd;                 //!< Congestion window
  uint32_t                       m_ssThresh;             //!< Slow Start Threshold
  uint32_t                       m_initialCWnd;          //!< Initial cWnd value
  uint32_t                       m_initialSsThresh;      //!< Initial Slow Start Threshold

  // Round trip time estimation
  Time m_lastMeasuredRtt; //!< Last measured RTT

(-)a/src/internet/model/tcp-newreno.cc (-9 / +14 lines)

Lines 45-57	Link Here

                    MakeUintegerAccessor (&TcpNewReno::m_retxThresh),

                    MakeUintegerAccessor (&TcpNewReno::m_retxThresh),

                    MakeUintegerChecker<uint32_t> ())

                    MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("LimitedTransmit", "Enable limited transmit",

    .AddAttribute ("LimitedTransmit", "Enable limited transmit",

		    BooleanValue (false),

                   BooleanValue (false),

		    MakeBooleanAccessor (&TcpNewReno::m_limitedTx),

                   MakeBooleanAccessor (&TcpNewReno::m_limitedTx),

		    MakeBooleanChecker ())

                   MakeBooleanChecker ())

    .AddTraceSource ("CongestionWindow",

    .AddTraceSource ("CongestionWindow",

                     "The TCP connection's congestion window",

                     "The TCP connection's congestion window",

                     MakeTraceSourceAccessor (&TcpNewReno::m_cWnd))

                     MakeTraceSourceAccessor (&TcpNewReno::m_cWnd))

    .AddTraceSource ("SlowStartThreshold",

                     "TCP slow start threshold (bytes)",

                     MakeTraceSourceAccessor (&TcpNewReno::m_ssThresh))

  return tid;

  return tid;

Lines 134-140	Link Here

134

137

135

  else if (m_inFastRec && seq >= m_recover)

138

  else if (m_inFastRec && seq >= m_recover)

136

    { // Full ACK (RFC2582 sec.3 bullet #5 paragraph 2, option 1)

139

    { // Full ACK (RFC2582 sec.3 bullet #5 paragraph 2, option 1)

137

      m_cWnd = std::min (m_ssThresh, BytesInFlight () + m_segmentSize);

140

      m_cWnd = std::min (m_ssThresh.Get (), BytesInFlight () + m_segmentSize);

138

      m_inFastRec = false;

141

      m_inFastRec = false;

139

      NS_LOG_INFO ("Received full ACK. Leaving fast recovery with cwnd set to " << m_cWnd);

142

      NS_LOG_INFO ("Received full ACK. Leaving fast recovery with cwnd set to " << m_cWnd);

140

143

Lines 220-234	Link Here

220

223

221

224

222

void

225

void

223

TcpNewReno::SetSSThresh (uint32_t threshold)

226

TcpNewReno::SetInitialSSThresh (uint32_t threshold)

224

227

225

  m_ssThresh = threshold;

228

  NS_ABORT_MSG_UNLESS (m_state == CLOSED, "TcpNewReno::SetSSThresh() cannot change initial ssThresh after connection started.");

229

  m_initialSsThresh = threshold;

226

230

227

231

228

uint32_t

232

uint32_t

229

TcpNewReno::GetSSThresh (void) const

233

TcpNewReno::GetInitialSSThresh (void) const

230

234

231

  return m_ssThresh;

235

  return m_initialSsThresh;

232

236

233

237

234

void

238

void

Lines 253-258	Link Here

253

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

257

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

254

*/

258

*/

255

  m_cWnd = m_initialCWnd * m_segmentSize;

259

  m_cWnd = m_initialCWnd * m_segmentSize;

260

  m_ssThresh = m_initialSsThresh;

256

261

257

262

258

} // namespace ns3

263

} // namespace ns3





  // Implementing ns3::TcpSocket -- Attribute get/set
  virtual void     SetSegSize (uint32_t size);
  virtual void     SetInitialSSThresh (uint32_t threshold);
  virtual uint32_t GetInitialSSThresh (void) const;
  virtual void     SetInitialCwnd (uint32_t cwnd);
  virtual uint32_t GetInitialCwnd (void) const;
private:


protected:
  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window
  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold
  uint32_t               m_initialCWnd;  //!< Initial cWnd value
  uint32_t               m_initialSsThresh;  //!< Initial Slow Start Threshold value
  SequenceNumber32       m_recover;      //!< Previous highest Tx seqnum for fast recovery
  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold
  bool                   m_inFastRec;    //!< currently in fast recovery




    .AddTraceSource ("CongestionWindow",
                     "The TCP connection's congestion window",
                     MakeTraceSourceAccessor (&TcpReno::m_cWnd))
    .AddTraceSource ("SlowStartThreshold",
                     "TCP slow start threshold (bytes)",
                     MakeTraceSourceAccessor (&TcpReno::m_ssThresh))
  ;
  return tid;
}

}

void
TcpReno::SetInitialSSThresh (uint32_t threshold)
{
  NS_ABORT_MSG_UNLESS (m_state == CLOSED, "TcpReno::SetSSThresh() cannot change initial ssThresh after connection started.");
  m_initialSsThresh = threshold;
}

uint32_t
TcpReno::GetInitialSSThresh (void) const
{
  return m_initialSsThresh;
}

void

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.
   */
  m_cWnd = m_initialCWnd * m_segmentSize;
  m_ssThresh = m_initialSsThresh;
}

} // namespace ns3





  // Implementing ns3::TcpSocket -- Attribute get/set
  virtual void     SetSegSize (uint32_t size);
  virtual void     SetInitialSSThresh (uint32_t threshold);
  virtual uint32_t GetInitialSSThresh (void) const;
  virtual void     SetInitialCwnd (uint32_t cwnd);
  virtual uint32_t GetInitialCwnd (void) const;
private:


protected:
  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window
  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold
  uint32_t               m_initialCWnd;  //!< Initial cWnd value
  uint32_t               m_initialSsThresh;  //!< Initial Slow Start Threshold value
  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold
  bool                   m_inFastRec;    //!< currently in fast recovery
};




}

void
TcpRfc793::SetInitialSSThresh (uint32_t threshold)
{
  NS_LOG_WARN ("DoD TCP does not perform slow start");
}

uint32_t
TcpRfc793::GetInitialSSThresh (void) const
{
  NS_LOG_WARN ("DoD TCP does not perform slow start");
  return 0;

(-)a/src/internet/model/tcp-rfc793.h (-2 / +2 lines)

Lines 58-65	Link Here

protected:

protected:

  virtual Ptr<TcpSocketBase> Fork (); // Call CopyObject<TcpRfc793> to clone me

  virtual Ptr<TcpSocketBase> Fork (); // Call CopyObject<TcpRfc793> to clone me

  virtual void DupAck (const TcpHeader& t, uint32_t count);

  virtual void DupAck (const TcpHeader& t, uint32_t count);

  virtual void     SetSSThresh (uint32_t threshold);

  virtual void     SetInitialSSThresh (uint32_t threshold);

  virtual uint32_t GetSSThresh (void) const;

  virtual uint32_t GetInitialSSThresh (void) const;

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual uint32_t GetInitialCwnd (void) const;

  virtual uint32_t GetInitialCwnd (void) const;

};

};

(-)a/src/internet/model/tcp-socket-base.h (-2 / +2 lines)

Lines 132-139	Link Here

132

  virtual uint32_t GetRcvBufSize (void) const;

132

  virtual uint32_t GetRcvBufSize (void) const;

133

  virtual void     SetSegSize (uint32_t size);

133

  virtual void     SetSegSize (uint32_t size);

134

  virtual uint32_t GetSegSize (void) const;

134

  virtual uint32_t GetSegSize (void) const;

135

  virtual void     SetSSThresh (uint32_t threshold) = 0;

135

  virtual void     SetInitialSSThresh (uint32_t threshold) = 0;

136

  virtual uint32_t GetSSThresh (void) const = 0;

136

  virtual uint32_t GetInitialSSThresh (void) const = 0;

137

  virtual void     SetInitialCwnd (uint32_t cwnd) = 0;

137

  virtual void     SetInitialCwnd (uint32_t cwnd) = 0;

138

  virtual uint32_t GetInitialCwnd (void) const = 0;

138

  virtual uint32_t GetInitialCwnd (void) const = 0;

139

  virtual void     SetConnTimeout (Time timeout);

139

  virtual void     SetConnTimeout (Time timeout);

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

Lines 58-68	Link Here

                   MakeUintegerAccessor (&TcpSocket::GetSegSize,

                   MakeUintegerAccessor (&TcpSocket::GetSegSize,

                                         &TcpSocket::SetSegSize),

                                         &TcpSocket::SetSegSize),

                   MakeUintegerChecker<uint32_t> ())

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("SlowStartThreshold",

    .AddAttribute ("InitialSlowStartThreshold",

                   "TCP slow start threshold (bytes)",

                   "TCP initial slow start threshold (bytes)",

                   UintegerValue (0xffff),

                   UintegerValue (0xffff),

                   MakeUintegerAccessor (&TcpSocket::GetSSThresh,

                   MakeUintegerAccessor (&TcpSocket::GetInitialSSThresh,

                                         &TcpSocket::SetSSThresh),

                                         &TcpSocket::SetInitialSSThresh),

                   MakeUintegerChecker<uint32_t> ())

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("InitialCwnd",

    .AddAttribute ("InitialCwnd",

                   "TCP initial congestion window size (segments)",

                   "TCP initial congestion window size (segments)",




  virtual uint32_t GetSegSize (void) const = 0;

  /**
   * \brief Set the initial Slow Start Threshold.
   * \param threshold the Slow Start Threshold (in bytes)
   */
  virtual void SetInitialSSThresh (uint32_t threshold) = 0;

  /**
   * \brief Get the initial Slow Start Threshold.
   * \returns the Slow Start Threshold (in bytes)
   */
  virtual uint32_t GetInitialSSThresh (void) const = 0;

  /**
   * \brief Set the initial Congestion Window.

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

Lines 47-52	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;

Lines 108-114	Link Here

108

TcpTahoe::NewAck (SequenceNumber32 const& seq)

111

TcpTahoe::NewAck (SequenceNumber32 const& seq)

109

112

110

  NS_LOG_FUNCTION (this << seq);

113

  NS_LOG_FUNCTION (this << seq);

111

  NS_LOG_LOGIC ("TcpTahoe receieved ACK for seq " << seq <<

114

  NS_LOG_LOGIC ("TcpTahoe received ACK for seq " << seq <<

112

                " cwnd " << m_cWnd <<

115

                " cwnd " << m_cWnd <<

113

                " ssthresh " << m_ssThresh);

116

                " ssthresh " << m_ssThresh);

114

  if (m_cWnd < m_ssThresh)

117

  if (m_cWnd < m_ssThresh)

Lines 172-186	Link Here

172

175

173

176

174

void

177

void

175

TcpTahoe::SetSSThresh (uint32_t threshold)

178

TcpTahoe::SetInitialSSThresh (uint32_t threshold)

176

179

177

  m_ssThresh = threshold;

180

  NS_ABORT_MSG_UNLESS (m_state == CLOSED, "TcpTahoe::SetSSThresh() cannot change initial ssThresh after connection started.");

181

  m_initialSsThresh = threshold;

178

182

179

183

180

uint32_t

184

uint32_t

181

TcpTahoe::GetSSThresh (void) const

185

TcpTahoe::GetInitialSSThresh (void) const

182

186

183

  return m_ssThresh;

187

  return m_initialSsThresh;

184

188

185

189

186

void

190

void

Lines 205-210	Link Here

205

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

209

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

206

*/

210

*/

207

  m_cWnd = m_initialCWnd * m_segmentSize;

211

  m_cWnd = m_initialCWnd * m_segmentSize;

212

  m_ssThresh = m_initialSsThresh;

208

213

209

214

210

} // namespace ns3

215

} // namespace ns3





  // Implementing ns3::TcpSocket -- Attribute get/set
  virtual void     SetSegSize (uint32_t size);
  virtual void     SetInitialSSThresh (uint32_t threshold);
  virtual uint32_t GetInitialSSThresh (void) const;
  virtual void     SetInitialCwnd (uint32_t cwnd);
  virtual uint32_t GetInitialCwnd (void) const;
private:


protected:
  TracedValue<uint32_t>  m_cWnd;         //!< Congestion window
  TracedValue<uint32_t>  m_ssThresh;     //!< Slow Start Threshold
  uint32_t               m_initialCWnd;  //!< Initial cWnd value
  uint32_t               m_initialSsThresh;  //!< Initial Slow Start Threshold value
  uint32_t               m_retxThresh;   //!< Fast Retransmit threshold
};


(-)a/src/internet/model/tcp-westwood.cc (-5 / +10 lines)

Lines 56-61	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 272-278	Link Here

272

  if (count == 3 && !m_inFastRec)

275

  if (count == 3 && !m_inFastRec)

273

    {// Triple duplicate ACK triggers fast retransmit

276

    {// Triple duplicate ACK triggers fast retransmit

274

     // Adjust cwnd and ssthresh based on the estimated BW

277

     // Adjust cwnd and ssthresh based on the estimated BW

275

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

278

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

276

      if (m_cWnd > m_ssThresh)

279

      if (m_cWnd > m_ssThresh)

277

280

278

          m_cWnd = m_ssThresh;

281

          m_cWnd = m_ssThresh;

Lines 380-396	Link Here

380

383

381

384

382

void

385

void

383

TcpWestwood::SetSSThresh (uint32_t threshold)

386

TcpWestwood::SetInitialSSThresh (uint32_t threshold)

384

387

385

  NS_LOG_FUNCTION (this);

388

  NS_LOG_FUNCTION (this);

386

  m_ssThresh = threshold;

389

  NS_ABORT_MSG_UNLESS (m_state == CLOSED, "TcpWestwood::SetSSThresh() cannot change initial ssThresh after connection started.");

390

  m_initialSsThresh = threshold;

387

391

388

392

389

uint32_t

393

uint32_t

390

TcpWestwood::GetSSThresh (void) const

394

TcpWestwood::GetInitialSSThresh (void) const

391

395

392

  NS_LOG_FUNCTION (this);

396

  NS_LOG_FUNCTION (this);

393

  return m_ssThresh;

397

  return m_initialSsThresh;

394

398

395

399

396

void

400

void

Lines 417-422	Link Here

417

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

421

   * m_segmentSize are set by the attribute system in ns3::TcpSocket.

418

*/

422

*/

419

  m_cWnd = m_initialCWnd * m_segmentSize;

423

  m_cWnd = m_initialCWnd * m_segmentSize;

424

  m_ssThresh = m_initialSsThresh;

420

425

421

426

422

} // namespace ns3

427

} // namespace ns3





  // Implementing ns3::TcpSocket -- Attribute get/set
  virtual void     SetSegSize (uint32_t size);
  virtual void     SetInitialSSThresh (uint32_t threshold);
  virtual uint32_t GetInitialSSThresh (void) const;
  virtual void     SetInitialCwnd (uint32_t cwnd);
  virtual uint32_t GetInitialCwnd (void) const;



protected:
  TracedValue<uint32_t>  m_cWnd;                   //!< Congestion window
  TracedValue<uint32_t>  m_ssThresh;               //!< Slow Start Threshold
  uint32_t               m_initialCWnd;            //!< Initial cWnd value
  uint32_t               m_initialSsThresh;        //!< Initial Slow Start Threshold value
  bool                   m_inFastRec;              //!< Currently in fast recovery if TRUE

  TracedValue<double>    m_currentBW;              //!< Current value of the estimated BW

Return to bug 1831