PacketSender.h

//
//  PacketSender.h
//  libraries/networking/src
//
//  Created by Brad Hefta-Gaub on 8/12/13.
//  Copyright 2013 High Fidelity, Inc.
//
//  Threaded or non-threaded packet sender.
//
//  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_PacketSender_h
#define hifi_PacketSender_h
 
#include <QWaitCondition>
 
#include "GenericThread.h"
#include "NodeList.h"
#include "SharedUtil.h"
 
class PacketSender : public GenericThread {
    Q_OBJECT
public:
 
    static const quint64 USECS_PER_SECOND;
    static const quint64 SENDING_INTERVAL_ADJUST;
    static const int TARGET_FPS;
    static const int MAX_SLEEP_INTERVAL;
 
    static const int DEFAULT_PACKETS_PER_SECOND;
    static const int MINIMUM_PACKETS_PER_SECOND;
    static const int MINIMAL_SLEEP_INTERVAL;
 
    PacketSender(int packetsPerSecond = DEFAULT_PACKETS_PER_SECOND);
    ~PacketSender();
 
    void queuePacketForSending(const SharedNodePointer& destinationNode, std::unique_ptr<NLPacket> packet);
    void queuePacketListForSending(const SharedNodePointer& destinationNode, std::unique_ptr<NLPacketList> packetList);
 
    void setPacketsPerSecond(int packetsPerSecond);
    int getPacketsPerSecond() const { return _packetsPerSecond; }
 
    virtual bool process() override;
    virtual void terminating() override;
 
    bool hasPacketsToSend() const { return _packets.size() > 0; }
 
    size_t packetsToSendCount() const { return _packets.size(); }
 
    void setProcessCallIntervalHint(int usecsPerProcessCall) { _usecsPerProcessCallHint = usecsPerProcessCall; }
 
    float getLifetimePPS() const
        { return getLifetimeInSeconds() == 0 ? 0 : (float)((float)_totalPacketsSent / getLifetimeInSeconds()); }
 
    float getLifetimeBPS() const
        { return getLifetimeInSeconds() == 0 ? 0 : (float)((float)_totalBytesSent / getLifetimeInSeconds()); }
 
    float getLifetimePPSQueued() const
        { return getLifetimeInSeconds() == 0 ? 0 : (float)((float)_totalPacketsQueued / getLifetimeInSeconds()); }
 
    float getLifetimeBPSQueued() const
        { return getLifetimeInSeconds() == 0 ? 0 : (float)((float)_totalBytesQueued / getLifetimeInSeconds()); }
 
    quint64 getLifetimeInUsecs() const { return (usecTimestampNow() - _started); }
 
    float getLifetimeInSeconds() const { return ((float)getLifetimeInUsecs() / (float)USECS_PER_SECOND); }
 
    quint64 getLifetimePacketsSent() const { return _totalPacketsSent; }
 
    quint64 getLifetimeBytesSent() const { return _totalBytesSent; }
 
    quint64 getLifetimePacketsQueued() const { return _totalPacketsQueued; }
 
    quint64 getLifetimeBytesQueued() const { return _totalBytesQueued; }
signals:
    void packetSent(quint64);
protected:
    int _packetsPerSecond;
    int _usecsPerProcessCallHint;
    quint64 _lastProcessCallTime;
    SimpleMovingAverage _averageProcessCallTime;
 
private:
    std::list<NodePacketOrPacketListPair> _packets;
    quint64 _lastSendTime;
 
    bool threadedProcess();
    bool nonThreadedProcess();
 
    quint64 _lastPPSCheck;
    size_t _packetsOverCheckInterval;
 
    quint64 _started;
    quint64 _totalPacketsSent;
    quint64 _totalBytesSent;
 
    quint64 _totalPacketsQueued;
    quint64 _totalBytesQueued;
 
    QWaitCondition _hasPackets;
    QMutex _waitingOnPacketsMutex;
};
 
#endif // hifi_PacketSender_h