src/network/nPriorizing.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

#ifndef ArmageTron_nPRIORIZING_H
#define ArmageTron_nPRIORIZING_H

#include "defs.h"
#include "tHeap.h"

class nBandwidthSceduler;
class nBandwidthArbitrator;
class nSendBuffer;
class nBandwidthControl;
class nBandwidthTask;
class nBandwidthTaskPriorizer;

tDECLARE_REFOBJ( nBandwidthTask )
tDECLARE_REFOBJ( nBandwidthArbitrator )

// small task that will eat away some bandwidth
class nBandwidthTask: public tHeapElement, public tReferencable< nBandwidthTask >
{
    friend class tReferencable< nBandwidthTask >;
    friend class nBandwidthTaskPriorizer;

public:
    enum nType
    {
        Type_System = 0,                                                        // extremely important task for the integrety of the connection
        Type_Vital  = 1,                                                        // task important for someone's survival in the game
        Type_Casual = 2,                                                        // not so important task
        Type_Count  = 3
    };

    void Execute( nSendBuffer& buffer, nBandwidthControl& control )             {       this->DoExecute( buffer, control );     }                               // executes the small task
    void Priorize()                                                                                                             {       if ( this->priorizer_ ) this->DoPriorize(); }           // rethinks priority

    int         EstimateSize    ( void          ) const {       return this->DoEstimateSize(); }        // estimate bandwidth usage

    nType       Type                    ( void          ) const {       return type_;           }                               // returns the type of task
    REAL        Priority                ( void          ) const {       return priority_;       }                               // returns the priority ( event gets important after 1/priority_ seconds )

    void        SetType                 ( nType t       );                                                                                              // sets the task type
    void        AddPriority             ( REAL add      )               { priority_ += add; this->Priorize(); } // adds priority
void    Timestep                ( REAL dt       )               { waiting_ += dt;       this->Priorize(); }     // adds time

protected:
    virtual void DoExecute( nSendBuffer& buffer, nBandwidthControl& control ) = 0;                              // executes whatever it has to do
    virtual int  DoEstimateSize() const = 0;                                                                                                    // estimate bandwidth usage
    virtual void DoPriorize();                                                                                                                                  // rethinks priority

    virtual tHeapBase *Heap() const;                                                                                                                    // in wich heap are we?

    virtual ~nBandwidthTask();
    nBandwidthTask( nType type );
private:
    nType type_;                                                                        // type of this task
    REAL priority_;                                                                     // something terrible happens if this task is not executed within 1/priority_ seconds
    REAL waiting_;                                                                      // time this task is already waiting ( plus small offset )
    nBandwidthTaskPriorizer* priorizer_;                        // the arbitrator taking care of this task
};

// bandwidth priorizer: selects bandwidth taks
class nBandwidthTaskPriorizer
{
public:
    typedef tHeap< nBandwidthTask > nTaskHeap;
    typedef nBandwidthTask::nType nType;

    nTaskHeap& Tasks( nType t )
    {
        tASSERT( 0 <= t && t < nBandwidthTask::Type_Count );

        return tasks_[ t ];
    }

    const nTaskHeap& Tasks( nType t ) const
    {
        tASSERT( 0 <= t && t < nBandwidthTask::Type_Count );

        return tasks_[ t ];
    }

    void Insert( nBandwidthTask* task );                                                        // inserts a task into the queue
    nBandwidthTask* PeekNext( nType type );                                                     // returns the top priority task
    virtual ~nBandwidthTaskPriorizer(){}
protected:
    tJUST_CONTROLLED_PTR<nBandwidthTask> Next( nType type );            // removes and returns the top priority task
private:
    virtual void OnChange(){};                                                                          // called on every change of data
    nTaskHeap tasks_[ nBandwidthTask::Type_Count ];
};

// bandwidth arbitrator: executes bandwidth tasks
class nBandwidthArbitrator: public nBandwidthTaskPriorizer, public tHeapElement, public tListMember, public tReferencable< nBandwidthArbitrator >
{
    friend class nBandwidthSceduler;
    friend class tReferencable< nBandwidthArbitrator >;

public:
    bool Fill( nSendBuffer& buffer, nBandwidthControl& control );       // fills the send buffer with top priority messages
    void Timestep( REAL dt );                                                                           // advances timers of all tasks
    bool UseBandwidth( REAL dt ){ return DoUseBandwidth( dt ); }        // consumes some bandwidth
protected:
    nBandwidthArbitrator();
    ~nBandwidthArbitrator();
private:
    nType FirstType() const;                                                                            // determines the type of the message to send next
    virtual void OnChange();                                                                            // called on every change of data
    virtual bool DoUseBandwidth( REAL dt ) = 0;
    virtual tHeapBase* Heap() const;

    virtual REAL TimeScale(){ return 0.1f; }                                            // higher values let really urgent messages be sent even if the bandwidth control objectd
    virtual REAL PacketOverhead(){ return 60.0f; }                                      // overhead in bytes per sent packet. Determines average package size

    nBandwidthSceduler* sceduler_;
};

// sceduler: distributes bandwidth around all arbitrators
class nBandwidthSceduler
{
    friend class nBandwidthArbitrator;

public:
    ~nBandwidthSceduler();

    void UseBandwidth( REAL dt );                                                                               // consumes bandwidth
    void AddArbitrator          ( nBandwidthArbitrator& arbitrator );           // adds an arbitrator
    void RemoveArbitrator       ( nBandwidthArbitrator& arbitrator );           // removes an arbitrator
private:
    tList< nBandwidthArbitrator, false, true >          arbitratorList_;        // arbitrators managed by the sceduler
    tHeap< nBandwidthArbitrator >                                       arbitratorHeap_;        // arbitrators managed by the sceduler organized in priority heap
};

class nNetObject;

// object syncing or creating bandwidth task
class nBandwidthTaskObject: public nBandwidthTask
{
public:
    nBandwidthTaskObject( nType type, nNetObject& object );
    virtual ~nBandwidthTaskObject();

    nNetObject& Object() const { return *object_; }
protected:
    virtual int  DoEstimateSize() const;                                                                                                        // estimate bandwidth usage
private:
    tJUST_CONTROLLED_PTR< nNetObject > object_;
};

// object syncing bandwidth task
class nBandwidthTaskSync: public nBandwidthTaskObject
{
public:
    nBandwidthTaskSync( nType type, nNetObject& object )
            : nBandwidthTaskObject( type, object )
    {}

protected:
    virtual void DoExecute( nSendBuffer& buffer, nBandwidthControl& control );                          // executes whatever it has to do
};

// object syncing bandwidth task
class nBandwidthTaskCreate: public nBandwidthTaskObject
{
public:
    nBandwidthTaskCreate( nType type, nNetObject& object )
            : nBandwidthTaskObject( type, object )
    {}

protected:
    virtual void DoExecute( nSendBuffer& buffer, nBandwidthControl& control );                          // executes whatever it has to do
};

#endif

---