internet: Added TCP Illinois

src/internet/model/tcp-illinois.cc

@@ -0,0 +1,380 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2016 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
+ * published by the Free Software Foundation;
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author: Keerthi Ganta <keerthiganta@ku.edu>
+ *         Truc Anh N. Nguyen <annguyen@ittc.ku.edu>
+ *
+ * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
+ * ResiliNets Research Group  http://wiki.ittc.ku.edu/resilinets
+ * Information and Telecommunication Technology Center (ITTC)
+ * and Department of Electrical Engineering and Computer Science
+ * The University of Kansas Lawrence, KS USA.
+ */
+
+
+#include "tcp-illinois.h"
+#include "ns3/tcp-socket-base.h"
+#include "ns3/log.h"
+
+namespace ns3 {
+
+NS_LOG_COMPONENT_DEFINE ("TcpIllinois");
+NS_OBJECT_ENSURE_REGISTERED (TcpIllinois);
+
+TypeId
+TcpIllinois::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::TcpIllinois")
+    .SetParent<TcpNewReno> ()
+    .AddConstructor<TcpIllinois> ()
+    .SetGroupName ("Internet")
+    .AddAttribute ("AlphaMin", "Minimum alpha threshold",
+                   DoubleValue (0.3),
+                   MakeDoubleAccessor (&TcpIllinois::m_alphaMin),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("AlphaMax", "Maximum alpha threshold",
+                   DoubleValue (10.0),
+                   MakeDoubleAccessor (&TcpIllinois::m_alphaMax),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("AlphaBase", "Alpha base threshold",
+                   DoubleValue (1.0),
+                   MakeDoubleAccessor (&TcpIllinois::m_alphaBase),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("BetaMin", "Minimum beta threshold",
+                   DoubleValue (0.125),
+                   MakeDoubleAccessor (&TcpIllinois::m_betaMin),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("BetaMax", "Maximum beta threshold",
+                   DoubleValue (0.5),
+                   MakeDoubleAccessor (&TcpIllinois::m_betaMax),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("BetaBase", "Beta base threshold",
+                   DoubleValue (0.5),
+                   MakeDoubleAccessor (&TcpIllinois::m_betaBase),
+                   MakeDoubleChecker<double> ())
+    .AddAttribute ("WinThresh", "Window threshold",
+                   UintegerValue (15),
+                   MakeUintegerAccessor (&TcpIllinois::m_winThresh),
+                   MakeUintegerChecker<uint32_t> ())
+    .AddAttribute ("Theta", "Theta threshold",
+                   UintegerValue (5),
+                   MakeUintegerAccessor (&TcpIllinois::m_theta),
+                   MakeUintegerChecker<uint32_t> ())
+  ;
+  return tid;
+}
+
+TcpIllinois::TcpIllinois (void)
+  : TcpNewReno (),
+    m_sumRtt (Time (0)),
+    m_cntRtt (0),
+    m_baseRtt (Time::Max ()),
+    m_maxRtt (Time::Min ()),
+    m_endSeq (0),
+    m_alpha (m_alphaMax),
+    m_beta (m_betaBase),
+    m_rttAbove (false),
+    m_rttLow (0),
+    m_alphaMin (0.3),
+    m_alphaMax (10.0),
+    m_alphaBase (1.0),
+    m_betaMin (0.125),
+    m_betaMax (0.5),
+    m_betaBase (0.5),
+    m_winThresh (15),
+    m_theta (5),
+    m_ackCnt (0)
+{
+  NS_LOG_FUNCTION (this);
+}
+
+TcpIllinois::TcpIllinois (const TcpIllinois& sock)
+  : TcpNewReno (sock),
+    m_sumRtt (sock.m_sumRtt),
+    m_cntRtt (sock.m_cntRtt),
+    m_baseRtt (sock.m_baseRtt),
+    m_maxRtt (sock.m_maxRtt),
+    m_endSeq (sock.m_endSeq),
+    m_alpha (sock.m_alpha),
+    m_beta (sock.m_beta),
+    m_rttAbove (sock.m_rttAbove),
+    m_rttLow (sock.m_rttLow),
+    m_alphaMin (sock.m_alphaMin),
+    m_alphaMax (sock.m_alphaMax),
+    m_alphaBase (sock.m_alphaBase),
+    m_betaMin (sock.m_betaMin),
+    m_betaMax (sock.m_betaMax),
+    m_betaBase (sock.m_betaBase),
+    m_winThresh (sock.m_winThresh),
+    m_theta (sock.m_theta),
+    m_ackCnt (sock.m_ackCnt)
+{
+  NS_LOG_FUNCTION (this);
+}
+
+TcpIllinois::~TcpIllinois (void)
+{
+  NS_LOG_FUNCTION (this);
+}
+
+void
+TcpIllinois::RecalcParam (Ptr<TcpSocketState> tcb)
+{
+  NS_LOG_FUNCTION (this << tcb);
+
+  if (tcb->m_cWnd < m_winThresh)
+    {
+      NS_LOG_INFO ("cWnd < winThresh, set alpha & beta to base values");
+
+      m_alpha = m_alphaBase;
+      m_beta = m_betaBase;
+    }
+  else if (m_cntRtt > 0)
+    {
+      double dm = (double) CalculateMaxDelay ().GetMilliSeconds ();
+      double da = (double) CalculateAvgDelay ().GetMilliSeconds ();
+
+      NS_LOG_INFO ("Updated to dm = " << dm << " da = " << da);
+
+      CalculateAlpha (da, dm);
+      CalculateBeta (da, dm);
+    }
+
+  Reset (tcb);
+}
+
+void
+TcpIllinois::CongestionStateSet (Ptr<TcpSocketState> tcb, const TcpSocketState::TcpCongState_t newState)
+{
+  NS_LOG_FUNCTION (this << tcb << newState);
+
+  if (newState == TcpSocketState::CA_LOSS)
+    {
+      m_alpha = m_alphaBase;
+      m_beta = m_betaBase;
+      m_rttLow = 0;
+      m_rttAbove = false;
+      Reset (tcb);
+    }
+}
+
+void
+TcpIllinois::IncreaseWindow (Ptr<TcpSocketState> tcb, uint32_t segmentsAcked)
+{
+  NS_LOG_FUNCTION (this << segmentsAcked);
+
+  if (tcb->m_lastAckedSeq >= m_endSeq)
+    {
+      RecalcParam (tcb);
+    }
+
+  if (tcb->m_cWnd < tcb->m_ssThresh)
+    {
+      segmentsAcked = TcpNewReno::SlowStart (tcb, segmentsAcked);
+      NS_LOG_INFO ("In SlowStart, updated to cwnd " << tcb->m_cWnd <<
+                   " ssthresh " << tcb->m_ssThresh);
+    }
+  else
+    {
+      uint32_t segCwnd = tcb->GetCwndInSegments ();
+      uint32_t oldCwnd = segCwnd;
+
+      if (segmentsAcked > 0)
+        {
+          m_ackCnt += segmentsAcked * m_alpha;
+        }
+
+      while (m_ackCnt >= segCwnd)
+        {
+          m_ackCnt -= segCwnd;
+          segCwnd += 1;
+        }
+
+      if (segCwnd != oldCwnd)
+        {
+          tcb->m_cWnd = segCwnd * tcb->m_segmentSize;
+          NS_LOG_INFO ("In CongAvoid, updated to cwnd " << tcb->m_cWnd <<
+                       " ssthresh " << tcb->m_ssThresh);
+        }
+    }
+}
+
+void
+TcpIllinois::PktsAcked (Ptr<TcpSocketState> tcb, uint32_t packetsAcked, const Time &rtt)
+{
+  NS_LOG_FUNCTION (this << tcb << packetsAcked << rtt);
+
+  if (rtt.IsZero ())
+    {
+      return;
+    }
+
+  // Keep track of minimum RTT
+  m_baseRtt = std::min (m_baseRtt, rtt);
+
+  // Keep track of maximum RTT
+  m_maxRtt = std::max (rtt, m_maxRtt);
+
+  ++m_cntRtt;
+  m_sumRtt += rtt;
+
+  NS_LOG_INFO ("Updated baseRtt = " << m_baseRtt << " maxRtt = " << m_maxRtt <<
+               " cntRtt = " << m_cntRtt << " sumRtt = " << m_sumRtt);
+}
+
+uint32_t
+TcpIllinois::GetSsThresh (Ptr<const TcpSocketState> tcb, uint32_t bytesInFlight)
+{
+  NS_LOG_FUNCTION (this << tcb << bytesInFlight);
+
+  uint32_t segBytesInFlight = bytesInFlight / tcb->m_segmentSize;
+  uint32_t ssThresh = std::max (2.0, (1.0 - m_beta) * segBytesInFlight);
+
+  NS_LOG_DEBUG ("Calculated ssThresh (in segments) = " << ssThresh);
+
+  return ssThresh * tcb->m_segmentSize;
+}
+
+void
+TcpIllinois::CalculateAlpha (double da, double dm)
+{
+  NS_LOG_FUNCTION (this << da << dm);
+
+  double d1 = dm / 100;
+
+  if (da <= d1)
+    {
+      NS_LOG_INFO ("da <= d1");
+
+      if (!m_rttAbove)
+        { // In case we can't get out of this low delay zone, we use alphaMax
+          m_alpha = m_alphaMax;
+        }
+      if (++m_rttLow >= m_theta)
+        {
+          /*
+           * da needs to stay below d1 for theta times RTT amount of time
+           * before we can increase alpha to alphaMax
+           */
+          NS_LOG_INFO ("da stays below d1 for theta times RTT amount of time, increase alpha to alphaMax");
+
+          m_rttLow = 0;
+          m_rttAbove = false;
+          m_alpha = m_alphaMax;
+        }
+    }
+  else
+    {
+      NS_LOG_INFO ("da > d1");
+
+      m_rttAbove = true;
+      /*
+       * alpha = k1 / (k2 + da), where
+       * k1 = ((dm - d1) * alphaMin * alphaMax) / (alphaMax - alphaMin)
+       * k2 = (((dm - d1) * alphaMin) / (alphaMax - alphaMin)) - d1
+       */
+      dm -= d1;
+      da -= d1;
+      m_alpha = (dm * m_alphaMax) / (dm + (da * (m_alphaMax - m_alphaMin)) / m_alphaMin);
+    }
+
+  NS_LOG_INFO ("Updated to alpha = " << m_alpha);
+}
+
+void
+TcpIllinois::CalculateBeta (double da, double dm)
+{
+  NS_LOG_FUNCTION (this << da << dm);
+
+  double d2, d3;
+
+  d2 = dm / 10;
+  d3 = (8 * dm) / 10;
+
+  if (da <= d2)
+    {
+      NS_LOG_INFO ("da <= d2");
+
+      m_beta = m_betaMin;
+    }
+
+  else if (da > d2 && da < d3)
+    {
+      NS_LOG_INFO ("da > d2 && da < d3");
+
+      /*
+       * beta = k3 + k4 * da, where
+       * k3 = (betaMin * d3 - betaMax * d2) / (d3 - d2)
+       * k4 = (betaMax - betaMin) / (d3 - d2)
+       */
+      m_beta = (m_betaMin * d3 - m_betaMax * d2 + (m_betaMax - m_betaMin) * da) / (d3 - d2);
+
+    }
+
+  else if (da >= d3 || d3 <= d2)
+    {
+      NS_LOG_INFO ("da >= d3 || d3 <= d2");
+
+      m_beta = m_betaMax;
+    }
+
+  NS_LOG_INFO ("Updated to beta = " << m_beta);
+}
+
+Time
+TcpIllinois::CalculateAvgDelay ()
+{
+  NS_LOG_FUNCTION (this);
+
+  return (m_sumRtt / m_cntRtt - m_baseRtt);
+}
+
+Time
+TcpIllinois::CalculateMaxDelay ()
+{
+  NS_LOG_FUNCTION (this);
+
+  return (m_maxRtt - m_baseRtt);
+}
+
+void
+TcpIllinois::Reset (Ptr<TcpSocketState> tcb)
+{
+  NS_LOG_FUNCTION (this);
+
+  m_endSeq = tcb->m_nextTxSequence;
+  m_cntRtt = 0;
+  m_sumRtt = Time (0);
+}
+
+Ptr<TcpCongestionOps>
+TcpIllinois::Fork (void)
+{
+  NS_LOG_FUNCTION (this);
+
+  return CopyObject<TcpIllinois> (this);
+}
+
+std::string
+TcpIllinois::GetName () const
+{
+  NS_LOG_FUNCTION (this);
+
+  return "TcpIllinois";
+}
+}
+// namespace ns3