CCRakNetUDT.h

Go to the documentation of this file.

#include "RakNetDefines.h"

#if USE_SLIDING_WINDOW_CONGESTION_CONTROL!=1

#ifndef __CONGESTION_CONTROL_UDT_H
#define __CONGESTION_CONTROL_UDT_H

#include "NativeTypes.h"
#include "RakNetTime.h"
#include "RakNetTypes.h"
#include "DS_Queue.h"

#define CC_TIME_TYPE_BYTES 8

namespace RakNet
{


typedef uint64_t CCTimeType;




typedef uint24_t DatagramSequenceNumberType;
typedef double BytesPerMicrosecond;
typedef double BytesPerSecond;
typedef double MicrosecondsPerByte;

#define CC_RAKNET_UDT_PACKET_HISTORY_LENGTH 64
#define RTT_HISTORY_LENGTH 64

#define UDP_HEADER_SIZE 28

#define CC_DEBUG_PRINTF_1(x)
#define CC_DEBUG_PRINTF_2(x,y)
#define CC_DEBUG_PRINTF_3(x,y,z)
#define CC_DEBUG_PRINTF_4(x,y,z,a)
#define CC_DEBUG_PRINTF_5(x,y,z,a,b)
//#define CC_DEBUG_PRINTF_1(x) printf(x)
//#define CC_DEBUG_PRINTF_2(x,y) printf(x,y)
//#define CC_DEBUG_PRINTF_3(x,y,z) printf(x,y,z)
//#define CC_DEBUG_PRINTF_4(x,y,z,a) printf(x,y,z,a)
//#define CC_DEBUG_PRINTF_5(x,y,z,a,b) printf(x,y,z,a,b)

class CCRakNetUDT
{
    public:
    
    CCRakNetUDT();
    ~CCRakNetUDT();

    void Init(CCTimeType curTime, uint32_t maxDatagramPayload);

    void Update(CCTimeType curTime, bool hasDataToSendOrResend);

    int GetRetransmissionBandwidth(CCTimeType curTime, CCTimeType timeSinceLastTick, uint32_t unacknowledgedBytes, bool isContinuousSend);
    int GetTransmissionBandwidth(CCTimeType curTime, CCTimeType timeSinceLastTick, uint32_t unacknowledgedBytes, bool isContinuousSend);

    bool ShouldSendACKs(CCTimeType curTime, CCTimeType estimatedTimeToNextTick);

    DatagramSequenceNumberType GetAndIncrementNextDatagramSequenceNumber(void);
    DatagramSequenceNumberType GetNextDatagramSequenceNumber(void);

    void OnSendBytes(CCTimeType curTime, uint32_t numBytes);

    void OnGotPacketPair(DatagramSequenceNumberType datagramSequenceNumber, uint32_t sizeInBytes, CCTimeType curTime);

    bool OnGotPacket(DatagramSequenceNumberType datagramSequenceNumber, bool isContinuousSend, CCTimeType curTime, uint32_t sizeInBytes, uint32_t *skippedMessageCount);

    void OnResend(CCTimeType curTime);
    void OnNAK(CCTimeType curTime, DatagramSequenceNumberType nakSequenceNumber);

    void OnAck(CCTimeType curTime, CCTimeType rtt, bool hasBAndAS, BytesPerMicrosecond _B, BytesPerMicrosecond _AS, double totalUserDataBytesAcked, bool isContinuousSend, DatagramSequenceNumberType sequenceNumber );
    void OnDuplicateAck( CCTimeType curTime, DatagramSequenceNumberType sequenceNumber ) {}
    
    void OnSendAckGetBAndAS(CCTimeType curTime, bool *hasBAndAS, BytesPerMicrosecond *_B, BytesPerMicrosecond *_AS);

    void OnSendAck(CCTimeType curTime, uint32_t numBytes);

    void OnSendNACK(CCTimeType curTime, uint32_t numBytes);
    
    CCTimeType GetRTOForRetransmission(void) const;

    void SetMTU(uint32_t bytes);

    uint32_t GetMTU(void) const;

    BytesPerMicrosecond GetLocalSendRate(void) const {return 1.0 / SND;}
    BytesPerMicrosecond GetLocalReceiveRate(CCTimeType currentTime) const;
    BytesPerMicrosecond GetRemoveReceiveRate(void) const {return AS;}
    //BytesPerMicrosecond GetEstimatedBandwidth(void) const {return B;}
    BytesPerMicrosecond GetEstimatedBandwidth(void) const {return GetLinkCapacityBytesPerSecond()*1000000.0;}
    double GetLinkCapacityBytesPerSecond(void) const {return estimatedLinkCapacityBytesPerSecond;};

    double GetRTT(void) const;

    bool GetIsInSlowStart(void) const {return isInSlowStart;}
    uint32_t GetCWNDLimit(void) const {return (uint32_t) (CWND*MAXIMUM_MTU_INCLUDING_UDP_HEADER);}


    static bool GreaterThan(DatagramSequenceNumberType a, DatagramSequenceNumberType b);
    static bool LessThan(DatagramSequenceNumberType a, DatagramSequenceNumberType b);
//  void SetTimeBetweenSendsLimit(unsigned int bitsPerSecond);
    uint64_t GetBytesPerSecondLimitByCongestionControl(void) const;

    protected:
    // --------------------------- PROTECTED VARIABLES ---------------------------
    MicrosecondsPerByte SND;
    
    double CWND;
    
    CCTimeType nextSYNUpdate;
        
        
    int packetPairRecieptHistoryWriteIndex;

    //BytesPerMicrosecond B;
    
    double RTT;
    
    // double RTTVar;   
    double minRTT, maxRTT;
        
    BytesPerMicrosecond packetArrivalHistory[CC_RAKNET_UDT_PACKET_HISTORY_LENGTH];
    BytesPerMicrosecond packetArrivalHistoryContinuousGaps[CC_RAKNET_UDT_PACKET_HISTORY_LENGTH];
    unsigned char packetArrivalHistoryContinuousGapsIndex;
    uint64_t continuousBytesReceived;
    CCTimeType continuousBytesReceivedStartTime;
    unsigned int packetArrivalHistoryWriteCount;

    int packetArrivalHistoryWriteIndex;

    CCTimeType lastPacketArrivalTime;

    BytesPerMicrosecond AS;

    CCTimeType lastTransmitOfBAndAS;
    
    bool isInSlowStart;
    
    uint32_t NAKCount;
    
    uint32_t AvgNAKNum;
    
    uint32_t DecCount;

    uint32_t DecInterval;

    DatagramSequenceNumberType nextDatagramSequenceNumber;

    CCTimeType lastPacketPairPacketArrivalTime;

    DatagramSequenceNumberType lastPacketPairSequenceNumber;

    CCTimeType lastUpdateWindowSizeAndAck;

    double ExpCount;

    uint64_t totalUserDataBytesSent;
    
    CCTimeType oldestUnsentAck;
    
    // Maximum amount of bytes that the user can send, e.g. the size of one full datagram
    uint32_t MAXIMUM_MTU_INCLUDING_UDP_HEADER;
    
    // Max window size
    double CWND_MAX_THRESHOLD;
    
    DatagramSequenceNumberType expectedNextSequenceNumber;

    // How many times have we sent B and AS? Used to force it to send at least CC_RAKNET_UDT_PACKET_HISTORY_LENGTH times
    // Otherwise, the default values in the array generate inaccuracy
    uint32_t sendBAndASCount;

    BytesPerMicrosecond mostRecentPacketArrivalHistory;

    bool hasWrittenToPacketPairReceiptHistory;

//  uint32_t rttHistory[RTT_HISTORY_LENGTH];
//  uint32_t rttHistoryIndex;
//  uint32_t rttHistoryWriteCount;
//  uint32_t rttSum, rttLow;
//  CCTimeType lastSndUpdateTime;
    double estimatedLinkCapacityBytesPerSecond;

    // --------------------------- PROTECTED METHODS ---------------------------
    void SetNextSYNUpdate(CCTimeType currentTime);
    
    BytesPerMicrosecond ReceiverCalculateDataArrivalRate(CCTimeType curTime) const;
    BytesPerMicrosecond ReceiverCalculateDataArrivalRateMedian(void) const;

    static BytesPerMicrosecond CalculateListMedianRecursive(const BytesPerMicrosecond inputList[CC_RAKNET_UDT_PACKET_HISTORY_LENGTH], int inputListLength, int lessThanSum, int greaterThanSum);
//  static uint32_t CalculateListMedianRecursive(const uint32_t inputList[RTT_HISTORY_LENGTH], int inputListLength, int lessThanSum, int greaterThanSum);
        
    CCTimeType GetSenderRTOForACK(void) const;

    void EndSlowStart(void);

    inline double BytesPerMicrosecondToPacketsPerMillisecond(BytesPerMicrosecond in);

    //void UpdateRTT(CCTimeType rtt);

    void UpdateWindowSizeAndAckOnAckPreSlowStart(double totalUserDataBytesAcked);

    void UpdateWindowSizeAndAckOnAckPerSyn(CCTimeType curTime, CCTimeType rtt, bool isContinuousSend, DatagramSequenceNumberType sequenceNumber);


    void ResetOnDataArrivalHalveSNDOnNoDataTime(CCTimeType curTime);
    
    // Init array
    void InitPacketArrivalHistory(void);

    // Printf
    void PrintLowBandwidthWarning(void);

    // Bug: SND can sometimes get super high - have seen 11693
    void CapMinSnd(const char *file, int line);

    void DecreaseTimeBetweenSends(void);
    void IncreaseTimeBetweenSends(void);

    int bytesCanSendThisTick;

    CCTimeType lastRttOnIncreaseSendRate;
    CCTimeType lastRtt;

    DatagramSequenceNumberType nextCongestionControlBlock;
    bool hadPacketlossThisBlock;
    DataStructures::Queue<CCTimeType> pingsLastInterval;
};

}

#endif

#endif