SRT: Build SRT from source by SRS. 4.0.115

trunk/3rdparty/srt-1-fit/srtcore/ATTIC/ccc.cpp

@@ -0,0 +1,360 @@
+/*
+ * SRT - Secure, Reliable, Transport
+ * Copyright (c) 2018 Haivision Systems Inc.
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * 
+ */
+
+/*****************************************************************************
+Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 02/21/2013
+modified by
+   Haivision Systems Inc.
+*****************************************************************************/
+
+
+#include "core.h"
+#include "ccc.h"
+#include <cmath>
+#include <cstring>
+
+CCC::CCC():
+m_iSYNInterval(CUDT::m_iSYNInterval),
+m_dPktSndPeriod(1.0),
+m_dCWndSize(16.0),
+m_iBandwidth(),
+m_dMaxCWndSize(),
+m_iMSS(),
+m_iSndCurrSeqNo(),
+m_iRcvRate(),
+m_iRTT(),
+m_pcParam(NULL),
+m_iPSize(0),
+m_UDT(),
+m_iACKPeriod(0),
+m_iACKInterval(0),
+m_bUserDefinedRTO(false),
+m_iRTO(-1),
+m_PerfInfo()
+{
+}
+
+CCC::~CCC()
+{
+   delete [] m_pcParam;
+}
+
+void CCC::setACKTimer(int msINT)
+{
+   m_iACKPeriod = msINT > m_iSYNInterval ? m_iSYNInterval : msINT;
+}
+
+void CCC::setACKInterval(int pktINT)
+{
+   m_iACKInterval = pktINT;
+}
+
+void CCC::setRTO(int usRTO)
+{
+   m_bUserDefinedRTO = true;
+   m_iRTO = usRTO;
+}
+
+void CCC::sendCustomMsg(CPacket& pkt) const
+{
+   CUDT* u = CUDT::getUDTHandle(m_UDT);
+
+   if (NULL != u)
+   {
+      pkt.m_iID = u->m_PeerID;
+#ifdef SRT_ENABLE_CTRLTSTAMP
+      pkt.m_iTimeStamp = int(CTimer::getTime() - u->m_StartTime);
+#endif
+      u->m_pSndQueue->sendto(u->m_pPeerAddr, pkt);
+   }
+}
+
+const CPerfMon* CCC::getPerfInfo()
+{
+   try
+   {
+      CUDT* u = CUDT::getUDTHandle(m_UDT);
+      if (NULL != u)
+         u->sample(&m_PerfInfo, false);
+   }
+   catch (...)
+   {
+      return NULL;
+   }
+
+   return &m_PerfInfo;
+}
+
+void CCC::setMSS(int mss)
+{
+   m_iMSS = mss;
+}
+
+void CCC::setBandwidth(int bw)
+{
+   m_iBandwidth = bw;
+}
+
+void CCC::setSndCurrSeqNo(int32_t seqno)
+{
+   m_iSndCurrSeqNo = seqno;
+}
+
+void CCC::setRcvRate(int rcvrate)
+{
+   m_iRcvRate = rcvrate;
+}
+
+void CCC::setMaxCWndSize(int cwnd)
+{
+   m_dMaxCWndSize = cwnd;
+}
+
+void CCC::setRTT(int rtt)
+{
+   m_iRTT = rtt;
+}
+
+void CCC::setUserParam(const char* param, int size)
+{
+   delete [] m_pcParam;
+   m_pcParam = new char[size];
+   memcpy(m_pcParam, param, size);
+   m_iPSize = size;
+}
+
+//
+CUDTCC::CUDTCC():
+m_iRCInterval(),
+m_LastRCTime(),
+m_bSlowStart(),
+m_iLastAck(),
+m_bLoss(),
+m_iLastDecSeq(),
+m_dLastDecPeriod(),
+m_iNAKCount(),
+m_iDecRandom(),
+m_iAvgNAKNum(),
+m_iDecCount()
+{
+}
+
+void CUDTCC::init()
+{
+   m_iRCInterval = m_iSYNInterval;
+   m_LastRCTime = CTimer::getTime();
+   setACKTimer(m_iRCInterval);
+
+   m_bSlowStart = true;
+   m_iLastAck = m_iSndCurrSeqNo;
+   m_bLoss = false;
+   m_iLastDecSeq = CSeqNo::decseq(m_iLastAck);
+   m_dLastDecPeriod = 1;
+   m_iAvgNAKNum = 0;
+   m_iNAKCount = 0;
+   m_iDecRandom = 1;
+
+   m_dCWndSize = 16;
+   m_dPktSndPeriod = 1;
+}
+
+void CUDTCC::onACK(int32_t ack)
+{
+   int64_t B = 0;
+   double inc = 0;
+   // Note: 1/24/2012
+   // The minimum increase parameter is increased from "1.0 / m_iMSS" to 0.01
+   // because the original was too small and caused sending rate to stay at low level
+   // for long time.
+   const double min_inc = 0.01;
+
+   uint64_t currtime = CTimer::getTime();
+   if (currtime - m_LastRCTime < (uint64_t)m_iRCInterval)
+      return;
+
+   m_LastRCTime = currtime;
+
+#ifdef SRT_ENABLE_BSTATS
+   //m_iRcvRate is bytes/sec
+   if (m_bSlowStart)
+   {
+      m_dCWndSize += CSeqNo::seqlen(m_iLastAck, ack);
+      m_iLastAck = ack;
+
+      if (m_dCWndSize > m_dMaxCWndSize)
+      {
+         m_bSlowStart = false;
+         if (m_iRcvRate > 0)
+            m_dPktSndPeriod = 1000000.0 / ((m_iRcvRate + m_iMSS - 1) / m_iMSS);
+         else
+            m_dPktSndPeriod = (m_iRTT + m_iRCInterval) / m_dCWndSize;
+      }
+   }
+   else
+      m_dCWndSize = ((m_iRcvRate + m_iMSS -1) / m_iMSS) / 1000000.0 * (m_iRTT + m_iRCInterval) + 16;
+#else
+   if (m_bSlowStart)
+   {
+      m_dCWndSize += CSeqNo::seqlen(m_iLastAck, ack);
+      m_iLastAck = ack;
+
+      if (m_dCWndSize > m_dMaxCWndSize)
+      {
+         m_bSlowStart = false;
+         if (m_iRcvRate > 0)
+            m_dPktSndPeriod = 1000000.0 / m_iRcvRate;
+         else
+            m_dPktSndPeriod = (m_iRTT + m_iRCInterval) / m_dCWndSize;
+      }
+   }
+   else
+      m_dCWndSize = m_iRcvRate / 1000000.0 * (m_iRTT + m_iRCInterval) + 16;
+#endif
+
+   // During Slow Start, no rate increase
+   if (m_bSlowStart)
+      return;
+
+   if (m_bLoss)
+   {
+      m_bLoss = false;
+      return;
+   }
+
+   //m_iBandwidth is pkts/sec
+   B = (int64_t)(m_iBandwidth - 1000000.0 / m_dPktSndPeriod);
+   if ((m_dPktSndPeriod > m_dLastDecPeriod) && ((m_iBandwidth / 9) < B))
+      B = m_iBandwidth / 9;
+   if (B <= 0)
+      inc = min_inc;
+   else
+   {
+      // inc = max(10 ^ ceil(log10( B * MSS * 8 ) * Beta / MSS, 1/MSS)
+      // Beta = 1.5 * 10^(-6)
+
+      inc = pow(10.0, ceil(log10(B * m_iMSS * 8.0))) * 0.0000015 / m_iMSS;
+
+      if (inc < min_inc)
+         inc = min_inc;
+   }
+
+   m_dPktSndPeriod = (m_dPktSndPeriod * m_iRCInterval) / (m_dPktSndPeriod * inc + m_iRCInterval);
+}
+
+void CUDTCC::onLoss(const int32_t* losslist, int)
+{
+   //Slow Start stopped, if it hasn't yet
+   if (m_bSlowStart)
+   {
+      m_bSlowStart = false;
+      if (m_iRcvRate > 0)
+      {
+         // Set the sending rate to the receiving rate.
+#ifdef SRT_ENABLE_BSTATS
+         //Need average packet size here for better send period
+         m_dPktSndPeriod = 1000000.0 / ((m_iRcvRate + m_iMSS - 1) / m_iMSS);
+#else
+         m_dPktSndPeriod = 1000000.0 / m_iRcvRate;
+#endif
+         return;
+      }
+      // If no receiving rate is observed, we have to compute the sending
+      // rate according to the current window size, and decrease it
+      // using the method below.
+      m_dPktSndPeriod = m_dCWndSize / (m_iRTT + m_iRCInterval);
+   }
+
+   m_bLoss = true;
+
+   if (CSeqNo::seqcmp(losslist[0] & 0x7FFFFFFF, m_iLastDecSeq) > 0)
+   {
+      m_dLastDecPeriod = m_dPktSndPeriod;
+      m_dPktSndPeriod = ceil(m_dPktSndPeriod * 1.125);
+
+      m_iAvgNAKNum = (int)ceil(m_iAvgNAKNum * 0.875 + m_iNAKCount * 0.125);
+      m_iNAKCount = 1;
+      m_iDecCount = 1;
+
+      m_iLastDecSeq = m_iSndCurrSeqNo;
+
+      // remove global synchronization using randomization
+      srand(m_iLastDecSeq);
+      m_iDecRandom = (int)ceil(m_iAvgNAKNum * (double(rand()) / RAND_MAX));
+      if (m_iDecRandom < 1)
+         m_iDecRandom = 1;
+   }
+   else if ((m_iDecCount ++ < 5) && (0 == (++ m_iNAKCount % m_iDecRandom)))
+   {
+      // 0.875^5 = 0.51, rate should not be decreased by more than half within a congestion period
+      m_dPktSndPeriod = ceil(m_dPktSndPeriod * 1.125);
+      m_iLastDecSeq = m_iSndCurrSeqNo;
+   }
+}
+
+void CUDTCC::onTimeout()
+{
+   if (m_bSlowStart)
+   {
+      m_bSlowStart = false;
+      if (m_iRcvRate > 0)
+#ifdef SRT_ENABLE_BSTATS
+         // Need average packet size here
+         m_dPktSndPeriod = 1000000.0 / ((m_iRcvRate + m_iMSS - 1) / m_iMSS);
+#else
+         m_dPktSndPeriod = 1000000.0 / m_iRcvRate;
+#endif
+      else
+         m_dPktSndPeriod = m_dCWndSize / (m_iRTT + m_iRCInterval);
+   }
+   else
+   {
+      /*
+      m_dLastDecPeriod = m_dPktSndPeriod;
+      m_dPktSndPeriod = ceil(m_dPktSndPeriod * 2);
+      m_iLastDecSeq = m_iLastAck;
+      */
+   }
+}

trunk/3rdparty/srt-1-fit/srtcore/ATTIC/ccc.h

@@ -0,0 +1,219 @@
+/*****************************************************************************
+Copyright (c) 2001 - 2009, The Board of Trustees of the University of Illinois.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the
+  above copyright notice, this list of conditions
+  and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the University of Illinois
+  nor the names of its contributors may be used to
+  endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************/
+
+/*****************************************************************************
+written by
+   Yunhong Gu, last updated 02/28/2012
+*****************************************************************************/
+
+
+#ifndef __UDT_CCC_H__
+#define __UDT_CCC_H__
+
+
+#include "udt.h"
+#include "packet.h"
+
+
+class UDT_API CCC
+{
+friend class CUDT;
+
+public:
+   CCC();
+   virtual ~CCC();
+
+private:
+   CCC(const CCC&);
+   CCC& operator=(const CCC&) {return *this;}
+
+public:
+
+      /// Callback function to be called (only) at the start of a UDT connection.
+      /// note that this is different from CCC(), which is always called.
+
+   virtual void init() {}
+
+      /// Callback function to be called when a UDT connection is closed.
+
+   virtual void close() {}
+
+      /// Callback function to be called when an ACK packet is received.
+      /// @param [in] ackno the data sequence number acknowledged by this ACK.
+
+   virtual void onACK(int32_t) {}
+
+      /// Callback function to be called when a loss report is received.
+      /// @param [in] losslist list of sequence number of packets, in the format describled in packet.cpp.
+      /// @param [in] size length of the loss list.
+
+   virtual void onLoss(const int32_t*, int) {}
+
+      /// Callback function to be called when a timeout event occurs.
+
+   virtual void onTimeout() {}
+
+      /// Callback function to be called when a data is sent.
+      /// @param [in] seqno the data sequence number.
+      /// @param [in] size the payload size.
+
+   virtual void onPktSent(const CPacket*) {}
+
+      /// Callback function to be called when a data is received.
+      /// @param [in] seqno the data sequence number.
+      /// @param [in] size the payload size.
+
+   virtual void onPktReceived(const CPacket*) {}
+
+      /// Callback function to Process a user defined packet.
+      /// @param [in] pkt the user defined packet.
+
+   virtual void processCustomMsg(const CPacket*) {}
+
+protected:
+
+      /// Set periodical acknowldging and the ACK period.
+      /// @param [in] msINT the period to send an ACK.
+
+   void setACKTimer(int msINT);
+
+      /// Set packet-based acknowldging and the number of packets to send an ACK.
+      /// @param [in] pktINT the number of packets to send an ACK.
+
+   void setACKInterval(int pktINT);
+
+      /// Set RTO value.
+      /// @param [in] msRTO RTO in macroseconds.
+
+   void setRTO(int usRTO);
+
+      /// Send a user defined control packet.
+      /// @param [in] pkt user defined packet.
+
+   void sendCustomMsg(CPacket& pkt) const;
+
+      /// retrieve performance information.
+      /// @return Pointer to a performance info structure.
+
+   const CPerfMon* getPerfInfo();
+
+      /// Set user defined parameters.
+      /// @param [in] param the paramters in one buffer.
+      /// @param [in] size the size of the buffer.
+
+   void setUserParam(const char* param, int size);
+
+private:
+   void setMSS(int mss);
+   void setMaxCWndSize(int cwnd);
+   void setBandwidth(int bw);
+   void setSndCurrSeqNo(int32_t seqno);
+   void setRcvRate(int rcvrate);
+   void setRTT(int rtt);
+
+protected:
+   const int32_t& m_iSYNInterval;	// UDT constant parameter, SYN
+
+   double m_dPktSndPeriod;              // Packet sending period, in microseconds
+   double m_dCWndSize;                  // Congestion window size, in packets
+
+   int m_iBandwidth;			// estimated bandwidth, packets per second
+   double m_dMaxCWndSize;               // maximum cwnd size, in packets
+
+   int m_iMSS;				// Maximum Packet Size, including all packet headers
+   int32_t m_iSndCurrSeqNo;		// current maximum seq no sent out
+   int m_iRcvRate;			// packet arrive rate at receiver side, packets per second
+   int m_iRTT;				// current estimated RTT, microsecond
+
+   char* m_pcParam;			// user defined parameter
+   int m_iPSize;			// size of m_pcParam
+
+private:
+   UDTSOCKET m_UDT;                     // The UDT entity that this congestion control algorithm is bound to
+
+   int m_iACKPeriod;                    // Periodical timer to send an ACK, in milliseconds
+   int m_iACKInterval;                  // How many packets to send one ACK, in packets
+
+   bool m_bUserDefinedRTO;              // if the RTO value is defined by users
+   int m_iRTO;                          // RTO value, microseconds
+
+   CPerfMon m_PerfInfo;                 // protocol statistics information
+};
+
+class CCCVirtualFactory
+{
+public:
+   virtual ~CCCVirtualFactory() {}
+
+   virtual CCC* create() = 0;
+   virtual CCCVirtualFactory* clone() = 0;
+};
+
+template <class T>
+class CCCFactory: public CCCVirtualFactory
+{
+public:
+   virtual ~CCCFactory() {}
+
+   virtual CCC* create() {return new T;}
+   virtual CCCVirtualFactory* clone() {return new CCCFactory<T>;}
+};
+
+class CUDTCC: public CCC
+{
+public:
+   CUDTCC();
+
+public:
+   virtual void init();
+   virtual void onACK(int32_t);
+   virtual void onLoss(const int32_t*, int);
+   virtual void onTimeout();
+
+private:
+   int m_iRCInterval;			// UDT Rate control interval
+   uint64_t m_LastRCTime;		// last rate increase time
+   bool m_bSlowStart;			// if in slow start phase
+   int32_t m_iLastAck;			// last ACKed seq no
+   bool m_bLoss;			// if loss happened since last rate increase
+   int32_t m_iLastDecSeq;		// max pkt seq no sent out when last decrease happened
+   double m_dLastDecPeriod;		// value of pktsndperiod when last decrease happened
+   int m_iNAKCount;                     // NAK counter
+   int m_iDecRandom;                    // random threshold on decrease by number of loss events
+   int m_iAvgNAKNum;                    // average number of NAKs per congestion
+   int m_iDecCount;			// number of decreases in a congestion epoch
+};
+
+#endif