loadEqualizer.h

/* Copyright (c) 2008-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library 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 Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQS_LOADEQUALIZER_H
#define EQS_LOADEQUALIZER_H

#include "../channelListener.h" // base class
#include "equalizer.h"          // base class

#include <eq/client/range.h>
#include <eq/client/viewport.h>

#include <deque>
#include <vector>

namespace eq
{
namespace server
{
    class LoadEqualizer;
    std::ostream& operator << ( std::ostream& os, const LoadEqualizer* );

    class LoadEqualizer : public Equalizer, protected ChannelListener
    {
    public:
        LoadEqualizer();
        LoadEqualizer( const LoadEqualizer& from );
        virtual ~LoadEqualizer();
        virtual Equalizer* clone() const { return new LoadEqualizer( *this ); }
        virtual void toStream( std::ostream& os ) const { os << this; }

        enum Mode
        {
            MODE_DB = 0,     
            MODE_HORIZONTAL, 
            MODE_VERTICAL,   
            MODE_2D          
        };

        void setMode( const Mode mode ) { _mode = mode; }

        Mode getMode() const { return _mode; }

        void setDamping( const float damping ) { _damping = damping; }

        float getDamping() const { return _damping; }

        virtual void notifyUpdatePre( Compound* compound, 
                                      const uint32_t frameNumber );

        virtual void notifyLoadData( Channel* channel, 
                                     const uint32_t frameNumber, 
                                     const uint32_t nStatistics,
                                     const eq::Statistic* statistics );

    protected:
        virtual void notifyChildAdded( Compound* compound, Compound* child )
            { EQASSERT( !_tree ); }
        virtual void notifyChildRemove( Compound* compound, Compound* child )
            { EQASSERT( !_tree ); }

    private:
        Mode  _mode;    
        float _damping; 
        
        struct Node
        {
            Node() : left(0), right(0), compound(0), splitMode( MODE_VERTICAL )
                   , time( 0.0f ), usage( 0.0f ) {}
            ~Node() { delete left; delete right; }

            Node*     left;      //<! Left child (only on non-leafs)
            Node*     right;     //<! Right child (only on non-leafs)
            Compound* compound;  //<! The corresponding child (only on leafs)
            LoadEqualizer::Mode splitMode; //<! What to adapt
            float     time;      //<! target render time for next frame
            float     usage;     //<! total usage of subtree
        };
        friend std::ostream& operator << ( std::ostream& os, const Node* node );
        typedef std::vector< Node* > LBNodeVector;

        Node* _tree; // <! The binary split tree of all children

        struct Data
        {
            Data() : channel( 0 ), taskID( 0 ), time( -1 ) {}

            Channel*     channel;
            uint32_t     taskID;
            eq::Viewport vp;
            eq::Range    range;
            int64_t      time;
            float        load;          //<! time/vp.area
        };

        typedef std::vector< Data >                  LBDataVector;
        typedef std::pair< uint32_t,  LBDataVector > LBFrameData;
        
        std::deque< LBFrameData > _history;
        
        //-------------------- Methods --------------------
        Node* _buildTree( const CompoundVector& children );

        void _clearTree( Node* node );

        void _checkHistory();
        
        void _computeSplit();
        float _assignTargetTimes( Node* node, const float totalTime, 
                                  const float resourceTime );
        void _assignLeftoverTime( Node* node, const float time );
        void _removeEmpty( LBDataVector& items );
        void _computeSplit( Node* node, LBDataVector* sortedData,
                            const eq::Viewport& vp, const eq::Range& range );

        static bool _compareX( const Data& data1, const Data& data2 )
            { return data1.vp.x < data2.vp.x; }
        static bool _compareY( const Data& data1, const Data& data2 )
            { return data1.vp.y < data2.vp.y; }
        static bool _compareRange( const Data& data1, const Data& data2 )
            { return data1.range.start < data2.range.start; }
    };

    std::ostream& operator << ( std::ostream& os, const LoadEqualizer::Mode );
}
}

#endif // EQS_LOADEQUALIZER_H