Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename SeqNum to SequenceNumber

Browse source
This commit is contained in:
Stephen Birarda 2015-07-28 13:39:19 -07:00
parent 45f6a984af
commit 606356cdcf
15 changed files with 271 additions and 272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
libraries/networking/src/udt/CongestionControl.cpp
View file

@ -21,13 +21,13 @@ void UdtCC::init() {
setAckTimer(_rcInterval);
_lastAck = _sendCurrSeqNum;
_lastDecSeq = SeqNum{ SeqNum::MAX };
_lastDecSeq = SequenceNumber{ SequenceNumber::MAX };
_congestionWindowSize = 16.0;
_packetSendPeriod = 1.0;
}
void UdtCC::onACK(SeqNum ackNum) {
void UdtCC::onACK(SequenceNumber ackNum) {
int64_t B = 0;
double inc = 0;
// Note: 1/24/2012
@ -89,7 +89,7 @@ void UdtCC::onACK(SeqNum ackNum) {
_packetSendPeriod = (_packetSendPeriod * _rcInterval) / (_packetSendPeriod * inc + _rcInterval);
}
void UdtCC::onLoss(const std::vector<SeqNum>& losslist) {
void UdtCC::onLoss(const std::vector<SequenceNumber>& losslist) {
//Slow Start stopped, if it hasn't yet
if (_slowStart) {
_slowStart = false;

18
libraries/networking/src/udt/CongestionControl.h
View file

@ -14,7 +14,7 @@
#include <vector>
#include "SeqNum.h"
#include "SequenceNumber.h"
namespace udt {
@ -29,8 +29,8 @@ public:
virtual void init() {}
virtual void close() {}
virtual void onAck(SeqNum ackNum) {}
virtual void onLoss(const std::vector<SeqNum>& lossList) {}
virtual void onAck(SequenceNumber ackNum) {}
virtual void onLoss(const std::vector<SequenceNumber>& lossList) {}
virtual void onPacketSent(const Packet& packet) {}
virtual void onPacketReceived(const Packet& packet) {}
@ -48,7 +48,7 @@ protected:
double _maxCongestionWindowSize = 0.0; // maximum cwnd size, in packets
int _mss = 0; // Maximum Packet Size, including all packet headers
SeqNum _sendCurrSeqNum; // current maximum seq num sent out
SequenceNumber _sendCurrSeqNum; // current maximum seq num sent out
int _recvieveRate = 0; // packet arrive rate at receiver side, packets per second
int _rtt = 0; // current estimated RTT, microsecond
@ -59,7 +59,7 @@ private:
void setMss(int mss) { _mss = mss; }
void setMaxCongestionWindowSize(int window) { _maxCongestionWindowSize = window; }
void setBandwidth(int bandwidth) { _bandwidth = bandwidth; }
void setSndCurrSeqNum(SeqNum seqNum) { _sendCurrSeqNum = seqNum; }
void setSndCurrSeqNum(SequenceNumber seqNum) { _sendCurrSeqNum = seqNum; }
void setRcvRate(int rate) { _recvieveRate = rate; }
void setRtt(int rtt) { _rtt = rtt; }
@ -92,17 +92,17 @@ public:
public:
virtual void init();
virtual void onACK(SeqNum ackNum);
virtual void onLoss(const std::vector<SeqNum>& lossList);
virtual void onACK(SequenceNumber ackNum);
virtual void onLoss(const std::vector<SequenceNumber>& lossList);
virtual void onTimeout();
private:
int _rcInterval = 0; // UDT Rate control interval
uint64_t _lastRCTime = 0; // last rate increase time
bool _slowStart = true; // if in slow start phase
SeqNum _lastAck; // last ACKed seq num
SequenceNumber _lastAck; // last ACKed seq num
bool _loss = false; // if loss happened since last rate increase
SeqNum _lastDecSeq; // max pkt seq num sent out when last decrease happened
SequenceNumber _lastDecSeq; // max pkt seq num sent out when last decrease happened
double _lastDecPeriod = 1; // value of pktsndperiod when last decrease happened
int _nakCount = 0; // NAK counter
int _decRandom = 1; // random threshold on decrease by number of loss events

54
libraries/networking/src/udt/Connection.cpp
View file

@ -41,7 +41,7 @@ void Connection::sendACK(bool wasCausedBySyncTimeout) {
auto currentTime = high_resolution_clock::now();
static high_resolution_clock::time_point lastACKSendTime;
SeqNum nextACKNumber = nextACK();
SequenceNumber nextACKNumber = nextACK();
if (nextACKNumber <= _lastReceivedAcknowledgedACK) {
// we already got an ACK2 for this ACK we would be sending, don't bother
@ -93,10 +93,10 @@ void Connection::sendACK(bool wasCausedBySyncTimeout) {
void Connection::sendLightACK() const {
// create the light ACK packet, make it static so we can re-use it
static const int LIGHT_ACK_PACKET_PAYLOAD_BYTES = sizeof(SeqNum);
static const int LIGHT_ACK_PACKET_PAYLOAD_BYTES = sizeof(SequenceNumber);
static auto lightACKPacket = ControlPacket::create(ControlPacket::ACK, LIGHT_ACK_PACKET_PAYLOAD_BYTES);
SeqNum nextACKNumber = nextACK();
SequenceNumber nextACKNumber = nextACK();
if (nextACKNumber == _lastReceivedAcknowledgedACK) {
// we already got an ACK2 for this ACK we would be sending, don't bother
@ -113,31 +113,31 @@ void Connection::sendLightACK() const {
_sendQueue->sendPacket(*lightACKPacket);
}
SeqNum Connection::nextACK() const {
SequenceNumber Connection::nextACK() const {
if (_lossList.getLength() > 0) {
return _lossList.getFirstSeqNum();
return _lossList.getFirstSequenceNumber();
} else {
return _largestReceivedSeqNum;
return _lastReceivedSequenceNumber;
}
}
void Connection::processReceivedSeqNum(SeqNum seq) {
void Connection::processReceivedSequenceNumber(SequenceNumber seq) {
// If this is not the next sequence number, report loss
if (seq > _largestReceivedSeqNum + 1) {
if (_largestReceivedSeqNum + 1 == seq - 1) {
_lossList.append(_largestReceivedSeqNum + 1);
if (seq > _lastReceivedSequenceNumber + 1) {
if (_lastReceivedSequenceNumber + 1 == seq - 1) {
_lossList.append(_lastReceivedSequenceNumber + 1);
} else {
_lossList.append(_largestReceivedSeqNum + 1, seq - 1);
_lossList.append(_lastReceivedSequenceNumber + 1, seq - 1);
}
// create the loss report packet, make it static so we can re-use it
static const int NAK_PACKET_PAYLOAD_BYTES = 2 * sizeof(SeqNum);
static const int NAK_PACKET_PAYLOAD_BYTES = 2 * sizeof(SequenceNumber);
static auto lossReport = ControlPacket::create(ControlPacket::NAK, NAK_PACKET_PAYLOAD_BYTES);
lossReport->reset(); // We need to reset it every time.
// pack in the loss report
lossReport->writePrimitive(_largestReceivedSeqNum + 1);
if (_largestReceivedSeqNum + 1 != seq - 1) {
lossReport->writePrimitive(_lastReceivedSequenceNumber + 1);
if (_lastReceivedSequenceNumber + 1 != seq - 1) {
lossReport->writePrimitive(seq - 1);
}
@ -145,9 +145,9 @@ void Connection::processReceivedSeqNum(SeqNum seq) {
_sendQueue->sendPacket(*lossReport);
}
if (seq > _largestReceivedSeqNum) {
if (seq > _lastReceivedSequenceNumber) {
// Update largest recieved sequence number
_largestReceivedSeqNum = seq;
_lastReceivedSequenceNumber = seq;
} else {
// Otherwise, it's a resend, remove it from the loss list
_lossList.remove(seq);
@ -157,7 +157,7 @@ void Connection::processReceivedSeqNum(SeqNum seq) {
void Connection::processControl(unique_ptr<ControlPacket> controlPacket) {
switch (controlPacket->getType()) {
case ControlPacket::ACK: {
if (controlPacket->getPayloadSize() == sizeof(SeqNum)) {
if (controlPacket->getPayloadSize() == sizeof(SequenceNumber)) {
processLightACK(move(controlPacket));
} else {
processACK(move(controlPacket));
@ -182,7 +182,7 @@ void Connection::processControl(unique_ptr<ControlPacket> controlPacket) {
void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
// read the ACK sub-sequence number
SeqNum currentACKSubSequenceNumber;
SequenceNumber currentACKSubSequenceNumber;
controlPacket->readPrimitive(&currentACKSubSequenceNumber);
// check if we need send an ACK2 for this ACK
@ -193,7 +193,7 @@ void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
if (sinceLastACK2.count() > _synInterval || currentACKSubSequenceNumber == _lastSentACK2) {
// setup a static ACK2 packet we will re-use
static const int ACK2_PAYLOAD_BYTES = sizeof(SeqNum);
static const int ACK2_PAYLOAD_BYTES = sizeof(SequenceNumber);
static auto ack2Packet = ControlPacket::create(ControlPacket::ACK2, ACK2_PAYLOAD_BYTES);
// reset the ACK2 Packet before writing the sub-sequence number to it
@ -208,11 +208,11 @@ void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
}
// read the ACKed sequence number
SeqNum ack;
SequenceNumber ack;
controlPacket->readPrimitive(&ack);
// validate that this isn't a BS ACK
if (ack > _sendQueue->getCurrentSeqNum()) {
if (ack > _sendQueue->getCurrentSequenceNumber()) {
// in UDT they specifically break the connection here - do we want to do anything?
return;
}
@ -232,7 +232,7 @@ void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
}
// make sure this isn't a repeated ACK
if (ack <= SeqNum(_atomicLastReceivedACK)) {
if (ack <= SequenceNumber(_atomicLastReceivedACK)) {
return;
}
@ -249,7 +249,7 @@ void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
// set the RTT for congestion control
if (controlPacket->getPayloadSize() > (qint64) (sizeof(SeqNum) + sizeof(SeqNum) + sizeof(rtt))) {
if (controlPacket->getPayloadSize() > (qint64) (sizeof(SequenceNumber) + sizeof(SequenceNumber) + sizeof(rtt))) {
int32_t deliveryRate, bandwidth;
controlPacket->readPrimitive(&deliveryRate);
controlPacket->readPrimitive(&bandwidth);
@ -265,7 +265,7 @@ void Connection::processACK(std::unique_ptr<ControlPacket> controlPacket) {
void Connection::processLightACK(std::unique_ptr<ControlPacket> controlPacket) {
// read the ACKed sequence number
SeqNum ack;
SequenceNumber ack;
controlPacket->readPrimitive(&ack);
// must be larger than the last received ACK to be processed
@ -280,7 +280,7 @@ void Connection::processLightACK(std::unique_ptr<ControlPacket> controlPacket) {
void Connection::processACK2(std::unique_ptr<ControlPacket> controlPacket) {
// pull the sub sequence number from the packet
SeqNum subSequenceNumber;
SequenceNumber subSequenceNumber;
controlPacket->readPrimitive(&subSequenceNumber);
// check if we had that subsequence number in our map
@ -306,9 +306,9 @@ void Connection::processACK2(std::unique_ptr<ControlPacket> controlPacket) {
void Connection::processNAK(std::unique_ptr<ControlPacket> controlPacket) {
// read the loss report
SeqNum start, end;
SequenceNumber start, end;
controlPacket->readPrimitive(&start);
if (controlPacket->bytesLeftToRead() >= (qint64)sizeof(SeqNum)) {
if (controlPacket->bytesLeftToRead() >= (qint64)sizeof(SequenceNumber)) {
controlPacket->readPrimitive(&end);
}
}

24
libraries/networking/src/udt/Connection.h
View file

@ -29,8 +29,8 @@ class Socket;
class Connection {
public:
using SequenceNumberTimePair = std::pair<SeqNum, std::chrono::high_resolution_clock::time_point>;
using SentACKMap = std::unordered_map<SeqNum, SequenceNumberTimePair>;
using SequenceNumberTimePair = std::pair<SequenceNumber, std::chrono::high_resolution_clock::time_point>;
using SentACKMap = std::unordered_map<SequenceNumber, SequenceNumberTimePair>;
Connection(Socket* parentSocket, HifiSockAddr destination);
@ -39,11 +39,11 @@ public:
void sendACK(bool wasCausedBySyncTimeout = true);
void sendLightACK() const;
SeqNum nextACK() const;
SequenceNumber nextACK() const;
SeqNum getLastReceivedACK() const { return SeqNum(_atomicLastReceivedACK); }
SequenceNumber getLastReceivedACK() const { return SequenceNumber(_atomicLastReceivedACK); }
void processReceivedSeqNum(SeqNum seq);
void processReceivedSequenceNumber(SequenceNumber seq);
void processControl(std::unique_ptr<ControlPacket> controlPacket);
private:
@ -57,14 +57,14 @@ private:
int _synInterval; // Periodical Rate Control Interval, defaults to 10ms
LossList _lossList; // List of all missing packets
SeqNum _largestReceivedSeqNum { SeqNum::MAX }; // The largest sequence number received from the peer
SeqNum _lastReceivedACK { SeqNum::MAX }; // The last ACK received
std::atomic<uint32_t> _atomicLastReceivedACK { (uint32_t) SeqNum::MAX }; // Atomic for thread-safe get of last ACK received
SeqNum _lastReceivedAcknowledgedACK { SeqNum::MAX }; // The last sent ACK that has been acknowledged via an ACK2 from the peer
SeqNum _currentACKSubSequenceNumber; // The current ACK sub-sequence number (used for Acknowledgment of ACKs)
SequenceNumber _lastReceivedSequenceNumber { SequenceNumber::MAX }; // The largest sequence number received from the peer
SequenceNumber _lastReceivedACK { SequenceNumber::MAX }; // The last ACK received
std::atomic<uint32_t> _atomicLastReceivedACK { (uint32_t) SequenceNumber::MAX }; // Atomic for thread-safe get of last ACK received
SequenceNumber _lastReceivedAcknowledgedACK { SequenceNumber::MAX }; // The last sent ACK that has been acknowledged via an ACK2 from the peer
SequenceNumber _currentACKSubSequenceNumber; // The current ACK sub-sequence number (used for Acknowledgment of ACKs)
SeqNum _lastSentACK { SeqNum::MAX }; // The last sent ACK
SeqNum _lastSentACK2; // The last sent ACK sub-sequence number in an ACK2
SequenceNumber _lastSentACK { SequenceNumber::MAX }; // The last sent ACK
SequenceNumber _lastSentACK2; // The last sent ACK sub-sequence number in an ACK2
int _totalReceivedACKs { 0 };

14
libraries/networking/src/udt/LossList.cpp
View file

@ -14,7 +14,7 @@
using namespace udt;
using namespace std;
void LossList::append(SeqNum seq) {
void LossList::append(SequenceNumber seq) {
assert(_lossList.back().second < seq);
if (getLength() > 0 && _lossList.back().second + 1 == seq) {
@ -25,7 +25,7 @@ void LossList::append(SeqNum seq) {
_length += 1;
}
void LossList::append(SeqNum start, SeqNum end) {
void LossList::append(SequenceNumber start, SequenceNumber end) {
if (getLength() > 0 && _lossList.back().second + 1 == start) {
_lossList.back().second = end;
} else {
@ -34,8 +34,8 @@ void LossList::append(SeqNum start, SeqNum end) {
_length += seqlen(start, end);
}
void LossList::remove(SeqNum seq) {
auto it = find_if(_lossList.begin(), _lossList.end(), [&seq](pair<SeqNum, SeqNum> pair) {
void LossList::remove(SequenceNumber seq) {
auto it = find_if(_lossList.begin(), _lossList.end(), [&seq](pair<SequenceNumber, SequenceNumber> pair) {
return pair.first <= seq && seq <= pair.second;
});
@ -54,9 +54,9 @@ void LossList::remove(SeqNum seq) {
}
}
void LossList::remove(SeqNum start, SeqNum end) {
void LossList::remove(SequenceNumber start, SequenceNumber end) {
// Find the first segment sharing sequence numbers
auto it = find_if(_lossList.begin(), _lossList.end(), [&start, &end](pair<SeqNum, SeqNum> pair) {
auto it = find_if(_lossList.begin(), _lossList.end(), [&start, &end](pair<SequenceNumber, SequenceNumber> pair) {
return (pair.first <= start && start <= pair.second) ||
(start <= pair.first && pair.first <= end);
});
@ -93,7 +93,7 @@ void LossList::remove(SeqNum start, SeqNum end) {
}
}
SeqNum LossList::getFirstSeqNum() const {
SequenceNumber LossList::getFirstSequenceNumber() const {
assert(getLength() > 0);
return _lossList.front().first;
}

16
libraries/networking/src/udt/LossList.h
View file

@ -14,7 +14,7 @@
#include <list>
#include "SeqNum.h"
#include "SequenceNumber.h"
namespace udt {
@ -23,20 +23,20 @@ public:
LossList() {}
// Should always add at the end
void append(SeqNum seq);
void append(SeqNum start, SeqNum end);
void append(SequenceNumber seq);
void append(SequenceNumber start, SequenceNumber end);
void remove(SeqNum seq);
void remove(SeqNum start, SeqNum end);
void remove(SequenceNumber seq);
void remove(SequenceNumber start, SequenceNumber end);
int getLength() const { return _length; }
SeqNum getFirstSeqNum() const;
SequenceNumber getFirstSequenceNumber() const;
private:
std::list<std::pair<SeqNum, SeqNum>> _lossList;
std::list<std::pair<SequenceNumber, SequenceNumber>> _lossList;
int _length { 0 };
};
}
#endif // hifi_LossList_h
#endif // hifi_LossList_h

8
libraries/networking/src/udt/Packet.cpp
View file

@ -65,7 +65,7 @@ Packet::Packet(qint64 size, bool isReliable, bool isPartOfMessage) :
adjustPayloadStartAndCapacity();
// set the UDT header to default values
writeSequenceNumber(SeqNum());
writeSequenceNumber(SequenceNumber());
}
Packet::Packet(std::unique_ptr<char> data, qint64 size, const HifiSockAddr& senderSockAddr) :
@ -131,13 +131,13 @@ void Packet::readIsPartOfMessage() {
void Packet::readSequenceNumber() {
SequenceNumberAndBitField seqNumBitField = *reinterpret_cast<SequenceNumberAndBitField*>(_packet.get());
_sequenceNumber = SeqNum{ seqNumBitField & ~BIT_FIELD_MASK }; // Remove the bit field
_sequenceNumber = SequenceNumber{ seqNumBitField & ~BIT_FIELD_MASK }; // Remove the bit field
}
void Packet::writeSequenceNumber(SeqNum seqNum) {
void Packet::writeSequenceNumber(SequenceNumber seqNum) {
// grab pointer to current SequenceNumberAndBitField
SequenceNumberAndBitField* seqNumBitField = reinterpret_cast<SequenceNumberAndBitField*>(_packet.get());
// write new value by ORing (old value & BIT_FIELD_MASK) with new seqNum
*seqNumBitField = (*seqNumBitField & BIT_FIELD_MASK) | (SeqNum::Type)seqNum;
*seqNumBitField = (*seqNumBitField & BIT_FIELD_MASK) | (SequenceNumber::Type) seqNum;
}

9
libraries/networking/src/udt/Packet.h
View file

@ -18,7 +18,7 @@
#include "BasePacket.h"
#include "PacketHeaders.h"
#include "SeqNum.h"
#include "SequenceNumber.h"
namespace udt {
@ -26,7 +26,6 @@ class Packet : public BasePacket {
Q_OBJECT
public:
// NOTE: The SequenceNumber is only actually 29 bits to leave room for a bit field
using SequenceNumber = uint32_t;
using SequenceNumberAndBitField = uint32_t;
// NOTE: The MessageNumber is only actually 29 bits to leave room for a bit field
@ -49,8 +48,8 @@ public:
virtual qint64 totalHeadersSize() const; // Cumulated size of all the headers
void writeSequenceNumber(SeqNum seqNum);
SeqNum getSequenceNumber() const { return _sequenceNumber; }
void writeSequenceNumber(SequenceNumber seqNum);
SequenceNumber getSequenceNumber() const { return _sequenceNumber; }
protected:
Packet(qint64 size, bool isReliable = false, bool isPartOfMessage = false);
@ -68,7 +67,7 @@ protected:
bool _isReliable { false };
bool _isPartOfMessage { false };
SeqNum _sequenceNumber;
SequenceNumber _sequenceNumber;
};
} // namespace udt

10
libraries/networking/src/udt/SendQueue.cpp
View file

@ -84,7 +84,7 @@ void SendQueue::sendPacket(const BasePacket& packet) {
_socket->writeUnreliablePacket(packet, _destination);
}
void SendQueue::ack(SeqNum ack) {
void SendQueue::ack(SequenceNumber ack) {
if (_lastAck == ack) {
return;
}
@ -98,7 +98,7 @@ void SendQueue::ack(SeqNum ack) {
_lastAck = ack;
}
void SendQueue::nak(std::list<SeqNum> naks) {
void SendQueue::nak(std::list<SequenceNumber> naks) {
QWriteLocker locker(&_naksLock);
_naks.splice(_naks.end(), naks); // Add naks at the end
}
@ -113,9 +113,9 @@ void SendQueue::sendNextPacket() {
_lastSendTimestamp = sendTime;
if (_nextPacket) {
_nextPacket->writeSequenceNumber(++_currentSeqNum);
_nextPacket->writeSequenceNumber(++_currentSequenceNumber);
sendPacket(*_nextPacket);
_atomicCurrentSeqNum.store((uint32_t) _currentSeqNum);
_atomicCurrentSequenceNumber.store((uint32_t) _currentSequenceNumber);
// Insert the packet we have just sent in the sent list
QWriteLocker locker(&_sentLock);
@ -125,7 +125,7 @@ void SendQueue::sendNextPacket() {
}
bool hasResend = false;
SeqNum seqNum;
SequenceNumber seqNum;
{
// Check nak list for packet to resend
QWriteLocker locker(&_naksLock);

18
libraries/networking/src/udt/SendQueue.h
View file

@ -21,7 +21,7 @@
#include "../HifiSockAddr.h"
#include "SeqNum.h"
#include "SequenceNumber.h"
namespace udt {
@ -42,7 +42,7 @@ public:
quint64 getLastSendTimestamp() const { return _lastSendTimestamp; }
SeqNum getCurrentSeqNum() const { return SeqNum(_atomicCurrentSeqNum); }
SequenceNumber getCurrentSequenceNumber() const { return SequenceNumber(_atomicCurrentSequenceNumber); }
int getPacketSendPeriod() const { return _packetSendPeriod; }
void setPacketSendPeriod(int newPeriod) { _packetSendPeriod = newPeriod; }
@ -52,8 +52,8 @@ public slots:
void stop();
void sendPacket(const BasePacket& packet);
void ack(SeqNum ack);
void nak(std::list<SeqNum> naks);
void ack(SequenceNumber ack);
void nak(std::list<SequenceNumber> naks);
private slots:
void sendNextPacket();
@ -72,10 +72,10 @@ private:
Socket* _socket { nullptr }; // Socket to send packet on
HifiSockAddr _destination; // Destination addr
SeqNum _currentSeqNum; // Last sequence number sent out
SeqNum _lastAck; // Last ACKed sequence number
SequenceNumber _currentSequenceNumber; // Last sequence number sent out
SequenceNumber _lastAck; // Last ACKed sequence number
std::atomic<uint32_t> _atomicCurrentSeqNum; // Atomic for last sequence number sent out
std::atomic<uint32_t> _atomicCurrentSequenceNumber; // Atomic for last sequence number sent out
std::unique_ptr<QTimer> _sendTimer; // Send timer
std::atomic<int> _packetSendPeriod { 0 }; // Interval between two packet send envent in msec
@ -83,10 +83,10 @@ private:
std::atomic<bool> _running { false };
mutable QReadWriteLock _naksLock; // Protects the naks list.
std::list<SeqNum> _naks; // Sequence numbers of packets to resend
std::list<SequenceNumber> _naks; // Sequence numbers of packets to resend
mutable QReadWriteLock _sentLock; // Protects the sent packet list
std::unordered_map<SeqNum, std::unique_ptr<Packet>> _sentPackets; // Packets waiting for ACK.
std::unordered_map<SequenceNumber, std::unique_ptr<Packet>> _sentPackets; // Packets waiting for ACK.
};
}

34
libraries/networking/src/udt/SeqNum.cpp
View file

@ -1,34 +0,0 @@
//
// SeqNum.cpp
// libraries/networking/src/udt
//
// Created by Clement on 7/23/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "SeqNum.h"
int udt::seqcmp(const SeqNum& seq1, const SeqNum& seq2) {
return (glm::abs(seq1._value - seq2._value) < SeqNum::THRESHOLD) ? (seq1._value - seq2._value)
: (seq2._value - seq1._value);
}
int udt::seqlen(const SeqNum& seq1, const SeqNum& seq2) {
return (seq1._value <= seq2._value) ? (seq2._value - seq1._value + 1)
: (seq2._value - seq1._value + SeqNum::MAX + 2);
}
int udt::seqoff(const SeqNum& seq1, const SeqNum& seq2) {
if (glm::abs(seq1._value - seq2._value) < SeqNum::THRESHOLD) {
return seq2._value - seq1._value;
}
if (seq1._value < seq2._value) {
return seq2._value - seq1._value - SeqNum::MAX - 1;
}
return seq2._value - seq1._value + SeqNum::MAX + 1;
}

147
libraries/networking/src/udt/SeqNum.h
View file

@ -1,147 +0,0 @@
//
// SeqNum.h
// libraries/networking/src/udt
//
// Created by Clement on 7/23/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_SeqNum_h
#define hifi_SeqNum_h
#include <functional>
#include <glm/detail/func_common.hpp>
namespace udt {
class SeqNum {
public:
// Base type of sequence numbers
using Type = uint32_t;
// Values are for 29 bit SeqNum
static const Type THRESHOLD = 0x0FFFFFFF; // threshold for comparing sequence numbers
static const Type MAX = 0x1FFFFFFF; // maximum sequence number used in UDT
SeqNum() = default;
SeqNum(const SeqNum& other) : _value(other._value) {}
// Only explicit conversions
explicit SeqNum(char* value) { _value = (*reinterpret_cast<int32_t*>(value)) & MAX; }
explicit SeqNum(Type value) { _value = (value <= MAX) ? value : MAX; }
explicit operator Type() { return _value; }
inline SeqNum& operator++() {
_value = (_value == MAX) ? 0 : ++_value;
return *this;
}
inline SeqNum& operator--() {
_value = (_value == 0) ? MAX : --_value;
return *this;
}
inline SeqNum operator++(int) {
SeqNum before = *this;
(*this)++;
return before;
}
inline SeqNum operator--(int) {
SeqNum before = *this;
(*this)--;
return before;
}
inline SeqNum& operator=(const SeqNum& other) {
_value = other._value;
return *this;
}
inline SeqNum& operator+=(Type inc) {
_value = (_value + inc > MAX) ? _value + inc - (MAX + 1) : _value + inc;
return *this;
}
inline SeqNum& operator-=(Type dec) {
_value = (_value < dec) ? MAX - (dec - _value + 1) : _value - dec;
return *this;
}
inline bool operator==(const SeqNum& other) const {
return _value == other._value;
}
inline bool operator!=(const SeqNum& other) const {
return _value != other._value;
}
friend bool operator<(const SeqNum& a, const SeqNum& b);
friend bool operator>(const SeqNum& a, const SeqNum& b);
friend bool operator<=(const SeqNum& a, const SeqNum& b);
friend bool operator>=(const SeqNum& a, const SeqNum& b);
friend SeqNum operator+(const SeqNum a, const Type& b);
friend SeqNum operator+(const Type& a, const SeqNum b);
friend SeqNum operator-(const SeqNum a, const Type& b);
friend SeqNum operator-(const Type& a, const SeqNum b);
friend int seqcmp(const SeqNum& seq1, const SeqNum& seq2);
friend int seqlen(const SeqNum& seq1, const SeqNum& seq2);
friend int seqoff(const SeqNum& seq1, const SeqNum& seq2);
private:
Type _value { 0 };
friend struct std::hash<SeqNum>;
};
inline bool operator<(const SeqNum& a, const SeqNum& b) {
return (glm::abs(a._value - b._value) < SeqNum::THRESHOLD) ? a._value < b._value : b._value < a._value;
}
inline bool operator>(const SeqNum& a, const SeqNum& b) {
return (glm::abs(a._value - b._value) < SeqNum::THRESHOLD) ? a._value > b._value : b._value > a._value;
}
inline bool operator<=(const SeqNum& a, const SeqNum& b) {
return (glm::abs(a._value - b._value) < SeqNum::THRESHOLD) ? a._value <= b._value : b._value <= a._value;
}
inline bool operator>=(const SeqNum& a, const SeqNum& b) {
return (glm::abs(a._value - b._value) < SeqNum::THRESHOLD) ? a._value >= b._value : b._value >= a._value;
}
inline SeqNum operator+(SeqNum a, const SeqNum::Type& b) {
a += b;
return a;
}
inline SeqNum operator+(const SeqNum::Type& a, SeqNum b) {
b += a;
return b;
}
inline SeqNum operator-(SeqNum a, const SeqNum::Type& b) {
a -= b;
return a;
}
inline SeqNum operator-(const SeqNum::Type& a, SeqNum b) {
b -= a;
return b;
}
int seqcmp(const SeqNum& seq1, const SeqNum& seq2);
int seqlen(const SeqNum& seq1, const SeqNum& seq2);
int seqoff(const SeqNum& seq1, const SeqNum& seq2);
}
template<> struct std::hash<udt::SeqNum> {
size_t operator()(const udt::SeqNum& seqNum) const {
return std::hash<unsigned long>()(seqNum._value);
}
};
#endif // hifi_SeqNum_h

34
libraries/networking/src/udt/SequenceNumber.cpp Normal file
View file

@ -0,0 +1,34 @@
//
// SequenceNumber.cpp
// libraries/networking/src/udt
//
// Created by Clement on 7/23/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "SequenceNumber.h"
int udt::seqcmp(const SequenceNumber& seq1, const SequenceNumber& seq2) {
return (glm::abs(seq1._value - seq2._value) < SequenceNumber::THRESHOLD) ? (seq1._value - seq2._value)
: (seq2._value - seq1._value);
}
int udt::seqlen(const SequenceNumber& seq1, const SequenceNumber& seq2) {
return (seq1._value <= seq2._value) ? (seq2._value - seq1._value + 1)
: (seq2._value - seq1._value + SequenceNumber::MAX + 2);
}
int udt::seqoff(const SequenceNumber& seq1, const SequenceNumber& seq2) {
if (glm::abs(seq1._value - seq2._value) < SequenceNumber::THRESHOLD) {
return seq2._value - seq1._value;
}
if (seq1._value < seq2._value) {
return seq2._value - seq1._value - SequenceNumber::MAX - 1;
}
return seq2._value - seq1._value + SequenceNumber::MAX + 1;
}

147
libraries/networking/src/udt/SequenceNumber.h Normal file
View file

@ -0,0 +1,147 @@
//
// SequenceNumber.h
// libraries/networking/src/udt
//
// Created by Clement on 7/23/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_SequenceNumber_h
#define hifi_SequenceNumber_h
#include <functional>
#include <glm/detail/func_common.hpp>
namespace udt {
class SequenceNumber {
public:
// Base type of sequence numbers
using Type = uint32_t;
// Values are for 29 bit SequenceNumber
static const Type THRESHOLD = 0x0FFFFFFF; // threshold for comparing sequence numbers
static const Type MAX = 0x1FFFFFFF; // maximum sequence number used in UDT
SequenceNumber() = default;
SequenceNumber(const SequenceNumber& other) : _value(other._value) {}
// Only explicit conversions
explicit SequenceNumber(char* value) { _value = (*reinterpret_cast<int32_t*>(value)) & MAX; }
explicit SequenceNumber(Type value) { _value = (value <= MAX) ? value : MAX; }
explicit operator Type() { return _value; }
inline SequenceNumber& operator++() {
_value = (_value == MAX) ? 0 : ++_value;
return *this;
}
inline SequenceNumber& operator--() {
_value = (_value == 0) ? MAX : --_value;
return *this;
}
inline SequenceNumber operator++(int) {
SequenceNumber before = *this;
(*this)++;
return before;
}
inline SequenceNumber operator--(int) {
SequenceNumber before = *this;
(*this)--;
return before;
}
inline SequenceNumber& operator=(const SequenceNumber& other) {
_value = other._value;
return *this;
}
inline SequenceNumber& operator+=(Type inc) {
_value = (_value + inc > MAX) ? _value + inc - (MAX + 1) : _value + inc;
return *this;
}
inline SequenceNumber& operator-=(Type dec) {
_value = (_value < dec) ? MAX - (dec - _value + 1) : _value - dec;
return *this;
}
inline bool operator==(const SequenceNumber& other) const {
return _value == other._value;
}
inline bool operator!=(const SequenceNumber& other) const {
return _value != other._value;
}
friend bool operator<(const SequenceNumber& a, const SequenceNumber& b);
friend bool operator>(const SequenceNumber& a, const SequenceNumber& b);
friend bool operator<=(const SequenceNumber& a, const SequenceNumber& b);
friend bool operator>=(const SequenceNumber& a, const SequenceNumber& b);
friend SequenceNumber operator+(const SequenceNumber a, const Type& b);
friend SequenceNumber operator+(const Type& a, const SequenceNumber b);
friend SequenceNumber operator-(const SequenceNumber a, const Type& b);
friend SequenceNumber operator-(const Type& a, const SequenceNumber b);
friend int seqcmp(const SequenceNumber& seq1, const SequenceNumber& seq2);
friend int seqlen(const SequenceNumber& seq1, const SequenceNumber& seq2);
friend int seqoff(const SequenceNumber& seq1, const SequenceNumber& seq2);
private:
Type _value { 0 };
friend struct std::hash<SequenceNumber>;
};
inline bool operator<(const SequenceNumber& a, const SequenceNumber& b) {
return (glm::abs(a._value - b._value) < SequenceNumber::THRESHOLD) ? a._value < b._value : b._value < a._value;
}
inline bool operator>(const SequenceNumber& a, const SequenceNumber& b) {
return (glm::abs(a._value - b._value) < SequenceNumber::THRESHOLD) ? a._value > b._value : b._value > a._value;
}
inline bool operator<=(const SequenceNumber& a, const SequenceNumber& b) {
return (glm::abs(a._value - b._value) < SequenceNumber::THRESHOLD) ? a._value <= b._value : b._value <= a._value;
}
inline bool operator>=(const SequenceNumber& a, const SequenceNumber& b) {
return (glm::abs(a._value - b._value) < SequenceNumber::THRESHOLD) ? a._value >= b._value : b._value >= a._value;
}
inline SequenceNumber operator+(SequenceNumber a, const SequenceNumber::Type& b) {
a += b;
return a;
}
inline SequenceNumber operator+(const SequenceNumber::Type& a, SequenceNumber b) {
b += a;
return b;
}
inline SequenceNumber operator-(SequenceNumber a, const SequenceNumber::Type& b) {
a -= b;
return a;
}
inline SequenceNumber operator-(const SequenceNumber::Type& a, SequenceNumber b) {
b -= a;
return b;
}
int seqcmp(const SequenceNumber& seq1, const SequenceNumber& seq2);
int seqlen(const SequenceNumber& seq1, const SequenceNumber& seq2);
int seqoff(const SequenceNumber& seq1, const SequenceNumber& seq2);
}
template<> struct std::hash<udt::SequenceNumber> {
size_t operator()(const udt::SequenceNumber& SequenceNumber) const {
return std::hash<unsigned long>()(SequenceNumber._value);
}
};
#endif // hifi_SequenceNumber_h

4
libraries/networking/src/udt/Socket.h
View file

@ -28,7 +28,7 @@ namespace udt {
class BasePacket;
class ControlSender;
class Packet;
class SeqNum;
class SequenceNumber;
using PacketFilterOperator = std::function<bool(const Packet&)>;
@ -70,7 +70,7 @@ private:
std::unordered_map<HifiSockAddr, BasePacketHandler> _unfilteredHandlers;
std::unordered_map<HifiSockAddr, SeqNum> _packetSequenceNumbers;
std::unordered_map<HifiSockAddr, SequenceNumber> _packetSequenceNumbers;
int32_t _synInterval = 10; // 10ms
QTimer _synTimer;