| Index: net/third_party/udt/src/queue.h
|
| ===================================================================
|
| --- net/third_party/udt/src/queue.h (revision 78992)
|
| +++ net/third_party/udt/src/queue.h (working copy)
|
| @@ -1,519 +0,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 01/12/2011
|
| -*****************************************************************************/
|
| -
|
| -
|
| -#ifndef __UDT_QUEUE_H__
|
| -#define __UDT_QUEUE_H__
|
| -
|
| -#include "common.h"
|
| -#include "packet.h"
|
| -#include "channel.h"
|
| -#include <vector>
|
| -#include <map>
|
| -#include <queue>
|
| -
|
| -class CUDT;
|
| -
|
| -struct CUnit
|
| -{
|
| - CPacket m_Packet; // packet
|
| - int m_iFlag; // 0: free, 1: occupied, 2: msg read but not freed (out-of-order), 3: msg dropped
|
| -};
|
| -
|
| -class CUnitQueue
|
| -{
|
| -friend class CRcvQueue;
|
| -friend class CRcvBuffer;
|
| -
|
| -public:
|
| - CUnitQueue();
|
| - ~CUnitQueue();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Initialize the unit queue.
|
| - // Parameters:
|
| - // 1) [in] size: queue size
|
| - // 2) [in] mss: maximum segament size
|
| - // 3) [in] version: IP version
|
| - // Returned value:
|
| - // 0: success, -1: failure.
|
| -
|
| - int init(const int& size, const int& mss, const int& version);
|
| -
|
| - // Functionality:
|
| - // Increase (double) the unit queue size.
|
| - // Parameters:
|
| - // None.
|
| - // Returned value:
|
| - // 0: success, -1: failure.
|
| -
|
| - int increase();
|
| -
|
| - // Functionality:
|
| - // Decrease (halve) the unit queue size.
|
| - // Parameters:
|
| - // None.
|
| - // Returned value:
|
| - // 0: success, -1: failure.
|
| -
|
| - int shrink();
|
| -
|
| - // Functionality:
|
| - // find an available unit for incoming packet.
|
| - // Parameters:
|
| - // None.
|
| - // Returned value:
|
| - // Pointer to the available unit, NULL if not found.
|
| -
|
| - CUnit* getNextAvailUnit();
|
| -
|
| -private:
|
| - struct CQEntry
|
| - {
|
| - CUnit* m_pUnit; // unit queue
|
| - char* m_pBuffer; // data buffer
|
| - int m_iSize; // size of each queue
|
| -
|
| - CQEntry* m_pNext;
|
| - }
|
| - *m_pQEntry, // pointer to the first unit queue
|
| - *m_pCurrQueue, // pointer to the current available queue
|
| - *m_pLastQueue; // pointer to the last unit queue
|
| -
|
| - CUnit* m_pAvailUnit; // recent available unit
|
| -
|
| - int m_iSize; // total size of the unit queue, in number of packets
|
| - int m_iCount; // total number of valid packets in the queue
|
| -
|
| - int m_iMSS; // unit buffer size
|
| - int m_iIPversion; // IP version
|
| -
|
| -private:
|
| - CUnitQueue(const CUnitQueue&);
|
| - CUnitQueue& operator=(const CUnitQueue&);
|
| -};
|
| -
|
| -struct CSNode
|
| -{
|
| - CUDT* m_pUDT; // Pointer to the instance of CUDT socket
|
| - uint64_t m_llTimeStamp; // Time Stamp
|
| -
|
| - int m_iHeapLoc; // location on the heap, -1 means not on the heap
|
| -};
|
| -
|
| -class CSndUList
|
| -{
|
| -friend class CSndQueue;
|
| -
|
| -public:
|
| - CSndUList();
|
| - ~CSndUList();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Insert a new UDT instance into the list.
|
| - // Parameters:
|
| - // 1) [in] ts: time stamp: next processing time
|
| - // 2) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void insert(const int64_t& ts, const CUDT* u);
|
| -
|
| - // Functionality:
|
| - // Update the timestamp of the UDT instance on the list.
|
| - // Parameters:
|
| - // 1) [in] u: pointer to the UDT instance
|
| - // 2) [in] resechedule: if the timestampe shoudl be rescheduled
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void update(const CUDT* u, const bool& reschedule = true);
|
| -
|
| - // Functionality:
|
| - // Retrieve the next packet and peer address from the first entry, and reschedule it in the queue.
|
| - // Parameters:
|
| - // 0) [out] addr: destination address of the next packet
|
| - // 1) [out] pkt: the next packet to be sent
|
| - // Returned value:
|
| - // 1 if successfully retrieved, -1 if no packet found.
|
| -
|
| - int pop(sockaddr*& addr, CPacket& pkt);
|
| -
|
| - // Functionality:
|
| - // Remove UDT instance from the list.
|
| - // Parameters:
|
| - // 1) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void remove(const CUDT* u);
|
| -
|
| - // Functionality:
|
| - // Retrieve the next scheduled processing time.
|
| - // Parameters:
|
| - // None.
|
| - // Returned value:
|
| - // Scheduled processing time of the first UDT socket in the list.
|
| -
|
| - uint64_t getNextProcTime();
|
| -
|
| -private:
|
| - void insert_(const int64_t& ts, const CUDT* u);
|
| - void remove_(const CUDT* u);
|
| -
|
| -private:
|
| - CSNode** m_pHeap; // The heap array
|
| - int m_iArrayLength; // physical length of the array
|
| - int m_iLastEntry; // position of last entry on the heap array
|
| -
|
| - pthread_mutex_t m_ListLock;
|
| -
|
| - pthread_mutex_t* m_pWindowLock;
|
| - pthread_cond_t* m_pWindowCond;
|
| -
|
| - CTimer* m_pTimer;
|
| -
|
| -private:
|
| - CSndUList(const CSndUList&);
|
| - CSndUList& operator=(const CSndUList&);
|
| -};
|
| -
|
| -struct CRNode
|
| -{
|
| - CUDT* m_pUDT; // Pointer to the instance of CUDT socket
|
| - uint64_t m_llTimeStamp; // Time Stamp
|
| -
|
| - CRNode* m_pPrev; // previous link
|
| - CRNode* m_pNext; // next link
|
| -
|
| - bool m_bOnList; // if the node is already on the list
|
| -};
|
| -
|
| -class CRcvUList
|
| -{
|
| -public:
|
| - CRcvUList();
|
| - ~CRcvUList();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Insert a new UDT instance to the list.
|
| - // Parameters:
|
| - // 1) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void insert(const CUDT* u);
|
| -
|
| - // Functionality:
|
| - // Remove the UDT instance from the list.
|
| - // Parameters:
|
| - // 1) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void remove(const CUDT* u);
|
| -
|
| - // Functionality:
|
| - // Move the UDT instance to the end of the list, if it already exists; otherwise, do nothing.
|
| - // Parameters:
|
| - // 1) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void update(const CUDT* u);
|
| -
|
| -public:
|
| - CRNode* m_pUList; // the head node
|
| -
|
| -private:
|
| - CRNode* m_pLast; // the last node
|
| -
|
| -private:
|
| - CRcvUList(const CRcvUList&);
|
| - CRcvUList& operator=(const CRcvUList&);
|
| -};
|
| -
|
| -class CHash
|
| -{
|
| -public:
|
| - CHash();
|
| - ~CHash();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Initialize the hash table.
|
| - // Parameters:
|
| - // 1) [in] size: hash table size
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void init(const int& size);
|
| -
|
| - // Functionality:
|
| - // Look for a UDT instance from the hash table.
|
| - // Parameters:
|
| - // 1) [in] id: socket ID
|
| - // Returned value:
|
| - // Pointer to a UDT instance, or NULL if not found.
|
| -
|
| - CUDT* lookup(const int32_t& id);
|
| -
|
| - // Functionality:
|
| - // Insert an entry to the hash table.
|
| - // Parameters:
|
| - // 1) [in] id: socket ID
|
| - // 2) [in] u: pointer to the UDT instance
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void insert(const int32_t& id, const CUDT* u);
|
| -
|
| - // Functionality:
|
| - // Remove an entry from the hash table.
|
| - // Parameters:
|
| - // 1) [in] id: socket ID
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void remove(const int32_t& id);
|
| -
|
| -private:
|
| - struct CBucket
|
| - {
|
| - int32_t m_iID; // Socket ID
|
| - CUDT* m_pUDT; // Socket instance
|
| -
|
| - CBucket* m_pNext; // next bucket
|
| - } **m_pBucket; // list of buckets (the hash table)
|
| -
|
| - int m_iHashSize; // size of hash table
|
| -
|
| -private:
|
| - CHash(const CHash&);
|
| - CHash& operator=(const CHash&);
|
| -};
|
| -
|
| -class CRendezvousQueue
|
| -{
|
| -public:
|
| - CRendezvousQueue();
|
| - ~CRendezvousQueue();
|
| -
|
| -public:
|
| - void insert(const UDTSOCKET& id, const int& ipv, const sockaddr* addr);
|
| - void remove(const UDTSOCKET& id);
|
| - bool retrieve(const sockaddr* addr, UDTSOCKET& id);
|
| -
|
| -private:
|
| - struct CRL
|
| - {
|
| - UDTSOCKET m_iID;
|
| - int m_iIPversion;
|
| - sockaddr* m_pPeerAddr;
|
| - };
|
| - std::vector<CRL> m_vRendezvousID; // The sockets currently in rendezvous mode
|
| -
|
| - pthread_mutex_t m_RIDVectorLock;
|
| -};
|
| -
|
| -class CSndQueue
|
| -{
|
| -friend class CUDT;
|
| -friend class CUDTUnited;
|
| -
|
| -public:
|
| - CSndQueue();
|
| - ~CSndQueue();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Initialize the sending queue.
|
| - // Parameters:
|
| - // 1) [in] c: UDP channel to be associated to the queue
|
| - // 2) [in] t: Timer
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void init(const CChannel* c, const CTimer* t);
|
| -
|
| - // Functionality:
|
| - // Send out a packet to a given address.
|
| - // Parameters:
|
| - // 1) [in] addr: destination address
|
| - // 2) [in] packet: packet to be sent out
|
| - // Returned value:
|
| - // Size of data sent out.
|
| -
|
| - int sendto(const sockaddr* addr, CPacket& packet);
|
| -
|
| -private:
|
| -#ifndef WIN32
|
| - static void* worker(void* param);
|
| -#else
|
| - static DWORD WINAPI worker(LPVOID param);
|
| -#endif
|
| -
|
| - pthread_t m_WorkerThread;
|
| -
|
| -private:
|
| - CSndUList* m_pSndUList; // List of UDT instances for data sending
|
| - CChannel* m_pChannel; // The UDP channel for data sending
|
| - CTimer* m_pTimer; // Timing facility
|
| -
|
| - pthread_mutex_t m_WindowLock;
|
| - pthread_cond_t m_WindowCond;
|
| -
|
| - volatile bool m_bClosing; // closing the worker
|
| - pthread_cond_t m_ExitCond;
|
| -
|
| -private:
|
| - CSndQueue(const CSndQueue&);
|
| - CSndQueue& operator=(const CSndQueue&);
|
| -};
|
| -
|
| -class CRcvQueue
|
| -{
|
| -friend class CUDT;
|
| -friend class CUDTUnited;
|
| -
|
| -public:
|
| - CRcvQueue();
|
| - ~CRcvQueue();
|
| -
|
| -public:
|
| -
|
| - // Functionality:
|
| - // Initialize the receiving queue.
|
| - // Parameters:
|
| - // 1) [in] size: queue size
|
| - // 2) [in] mss: maximum packet size
|
| - // 3) [in] version: IP version
|
| - // 4) [in] hsize: hash table size
|
| - // 5) [in] c: UDP channel to be associated to the queue
|
| - // 6) [in] t: timer
|
| - // Returned value:
|
| - // None.
|
| -
|
| - void init(const int& size, const int& payload, const int& version, const int& hsize, const CChannel* c, const CTimer* t);
|
| -
|
| - // Functionality:
|
| - // Read a packet for a specific UDT socket id.
|
| - // Parameters:
|
| - // 1) [in] id: Socket ID
|
| - // 2) [out] packet: received packet
|
| - // Returned value:
|
| - // Data size of the packet
|
| -
|
| - int recvfrom(const int32_t& id, CPacket& packet);
|
| -
|
| -private:
|
| -#ifndef WIN32
|
| - static void* worker(void* param);
|
| -#else
|
| - static DWORD WINAPI worker(LPVOID param);
|
| -#endif
|
| -
|
| - pthread_t m_WorkerThread;
|
| -
|
| -private:
|
| - CUnitQueue m_UnitQueue; // The received packet queue
|
| -
|
| - CRcvUList* m_pRcvUList; // List of UDT instances that will read packets from the queue
|
| - CHash* m_pHash; // Hash table for UDT socket looking up
|
| - CChannel* m_pChannel; // UDP channel for receving packets
|
| - CTimer* m_pTimer; // shared timer with the snd queue
|
| -
|
| - int m_iPayloadSize; // packet payload size
|
| -
|
| - volatile bool m_bClosing; // closing the workder
|
| - pthread_cond_t m_ExitCond;
|
| -
|
| -private:
|
| - int setListener(const CUDT* u);
|
| - void removeListener(const CUDT* u);
|
| -
|
| - void setNewEntry(CUDT* u);
|
| - bool ifNewEntry();
|
| - CUDT* getNewEntry();
|
| -
|
| - void storePkt(const int32_t& id, CPacket* pkt);
|
| -
|
| -private:
|
| - pthread_mutex_t m_LSLock;
|
| - volatile CUDT* m_pListener; // pointer to the (unique, if any) listening UDT entity
|
| - CRendezvousQueue* m_pRendezvousQueue; // The list of sockets in rendezvous mode
|
| -
|
| - std::vector<CUDT*> m_vNewEntry; // newly added entries, to be inserted
|
| - pthread_mutex_t m_IDLock;
|
| -
|
| - std::map<int32_t, std::queue<CPacket*> > m_mBuffer; // temporary buffer for rendezvous connection request
|
| - pthread_mutex_t m_PassLock;
|
| - pthread_cond_t m_PassCond;
|
| -
|
| -private:
|
| - CRcvQueue(const CRcvQueue&);
|
| - CRcvQueue& operator=(const CRcvQueue&);
|
| -};
|
| -
|
| -struct CMultiplexer
|
| -{
|
| - CSndQueue* m_pSndQueue; // The sending queue
|
| - CRcvQueue* m_pRcvQueue; // The receiving queue
|
| - CChannel* m_pChannel; // The UDP channel for sending and receiving
|
| - CTimer* m_pTimer; // The timer
|
| -
|
| - int m_iPort; // The UDP port number of this multiplexer
|
| - int m_iIPversion; // IP version
|
| - int m_iMSS; // Maximum Segment Size
|
| - int m_iRefCount; // number of UDT instances that are associated with this multiplexer
|
| - bool m_bReusable; // if this one can be shared with others
|
| -
|
| - int m_iID; // multiplexer ID
|
| -};
|
| -
|
| -#endif
|
|
|
Chromium Code Reviews
