C:/knet/include/kNet/UDPMessageConnection.h

Go to the documentation of this file.

/* Copyright 2010 Jukka Jylänki

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */
#pragma once

#include "MessageConnection.h"
#include "SequentialIntegerSet.h"
#include "Array.h"
#include "OrderedHashTable.h"

/*
UDP packet format: 3 bytes if InOrder=false. 5-6 bytes if InOrder=true.
1bit   - InOrder packet.   This packet contains InOrder messages.
1bit   - Reliable packet.  This packet is expected to be Acked by the receiver.
6 bits - The six lowest bits of the PacketID.
u16      The 16 next bits of the PacketID. This gives 22 bits of the PacketID in total.
* u8       InOrder array length.
* N x u8-u16   InOrder PacketID delta counter. VLE-encoded 1.7/8 Only present if InOrder=true.
.Message.
.Message.
...
.Message.


Message format: 2 bytes if FRGSTART=FRAGMENT=false.
1bit - FRGSTART. This is the first fragment of the message (offset=0)
1bit - FRAGMENT. This message is a fragment of a bigger message -flag. If FRGSTART=true, this field is not read and is assumed to be true.
1bit - InOrder. This message may be processed by the application only after all the previous InOrder messages have been processed.
* 1bit - InOrder. This message may be processed by the application only after all the previous InOrder messages have been processed.
* 1bit - InOrder. This message may be processed by the application only after all the previous InOrder messages have been processed.
(Old: 1bit - Unused.)
(Old: 1bit - Unused.)
11 bits Content length (includes both the length of MessageID and Content Data fields)
* u8 InOrder array index.                                         Only present if InOrder=7 (111 in base 2).
u8-u32 # of Fragments in whole message  VLE-encoded 1.7/1.7/16    Only present if FRGSTART=true.
u8 Fragment Transfer ID                                           Only present if FRAGMENT=true or FRGSTART=true.
* New: u8-u32 Fragment number           VLE-encoded 1.7/1.7/16    Only present if FRAGMENT=true and FRGSTART=false.
(Old: u8-u16 Fragment number            VLE-encoded 1.7/8         Only present if FRAGMENT=true.)
.Content.

Content format:
u8-u32 MessageID              VLE-encoded 1.7/1.7/16
N bytes Content data

*/

namespace kNet
{

class UDPMessageConnection : public MessageConnection
{
public:
   UDPMessageConnection(Network *owner, NetworkServer *ownerServer, Socket *socket, ConnectionState startingState);
   ~UDPMessageConnection();

   void SetDatagramInFlowRatePerSecond(int newDatagramReceiveRate, bool internalCall);

private:
   virtual SocketReadResult ReadSocket(size_t &bytesRead);

   void ExtractMessages(const char *data, size_t numBytes);

   SocketReadResult UDPReadSocket(size_t &bytesRead);

   // Congestion control and data rate management:
   void PerformFlowControl();
   void HandleFlowControlRequestMessage(const char *data, size_t numBytes);

   void UpdateRTOCounterOnPacketAck(float rtt);
   void UpdateRTOCounterOnPacketLoss();

   // Closing down the connection:
   void SendDisconnectMessage(bool isInternal);
   void HandleDisconnectMessage();
   void SendDisconnectAckMessage();
   void HandleDisconnectAckMessage();

   // Acknowledging reliable datagrams:
   void PerformPacketAckSends();
   void SendPacketAckMessage();
   void HandlePacketAckMessage(const char *data, size_t numBytes);
   
   bool HandleMessage(packet_id_t packetID, u32 messageID, const char *data, size_t numBytes);

   void ComputePacketLoss();

   void AddReceivedPacketIDStats(packet_id_t packetID);
   bool HaveReceivedPacketID(packet_id_t packetID) const;

   packet_id_t lastReceivedInOrderPacketID;

   packet_id_t lastSentInOrderPacketID;

   packet_id_t datagramPacketIDCounter;

   float retransmissionTimeout;

   tick_t lastFrameTime;
   int numAcksLastFrame;
   int numLossesLastFrame;

   float datagramSendRate; 

   float lowestDatagramSendRateOnPacketLoss;

   // These variables correspond to RFC2988, http://tools.ietf.org/html/rfc2988 , section 2.
   bool rttCleared; 
   float smoothedRTT;
   float rttVariation;

   // The following are used for statistics purposes:

   float packetLossRate; 
   float packetLossCount; 

   struct PacketAckTrack
   {
      PacketAckTrack()
      :sendCount(0)
      {
      }

      tick_t sentTick;

      tick_t timeoutTick;

      packet_id_t packetID;

      float datagramSendRate;

      int sendCount;

      bool inOrder;

      packet_id_t previousInOrderPacketID;

      Array<NetworkMessage*> messages;

      static int Hash(const PacketAckTrack &item, int maxElemsMask) { return item.packetID & maxElemsMask; }
      static int Hash(int key, int maxElemsMask) { return key & maxElemsMask; }
   };

   void ProcessPacketTimeouts();
   void HandleFlowControl();

   void DoUpdateConnection();

   PacketSendResult SendOutPacket();
   void SendOutPackets();
   unsigned long TimeUntilCanSendPacket() const;

   void PerformDisconnection();

   bool CanSendOutNewDatagram() const;

   void NewDatagramSent();

   mutable tick_t lastDatagramSendTime; 

   PolledTimer udpUpdateTimer;

   PolledTimer statsUpdateTimer;

   typedef std::map<packet_id_t, PacketAckTrack> PacketAckTrackMap;
// PacketAckTrackMap outboundPacketAckTrack;
   typedef WaitFreeQueue<PacketAckTrack> PacketAckTrackQueue;
// PacketAckTrackQueue outboundPacketAckTrack;
   OrderedHashTable<PacketAckTrack, PacketAckTrack> outboundPacketAckTrack;

   static int BiasedBinarySearchFindPacketIndex(UDPMessageConnection::PacketAckTrackQueue &queue, int packetID);

   void FreeOutboundPacketAckTrack(packet_id_t packetID);

   // Contains a list of all messages we've received that we need to Ack at some point.
   PacketAckTrackMap inboundPacketAckTrack;

   int datagramOutRatePerSecond;

   int datagramInRatePerSecond;

   std::set<unsigned long> receivedReliableMessages;

   SequentialIntegerSet receivedPacketIDs;

   // The following are temporary data structures used by various internal routines for processing.
   // They are created here as members to avoid having to create objects on the stack at each call to 
   // time-sensitive functions.
   std::vector<NetworkMessage *> datagramSerializedMessages; // MessageConnection::UDPSendOutPacket()
   std::vector<NetworkMessage *> skippedMessages; // MessageConnection::UDPSendOutPacket()
   std::vector<char> assembledData; // MessageConnection::DatagramExtractMessages

   float GetPacketLossCount() const { return packetLossCount; }

   float GetPacketLossRate() const { return packetLossRate; }

   void Initialize();

   void DumpConnectionStatus() const;

   friend class NetworkServer;
};

} // ~kNet