DatabasePager

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * 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
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSGDB_DATABASEPAGER
#define OSGDB_DATABASEPAGER 1
 
#include <osg/NodeVisitor>
#include <osg/Group>
#include <osg/PagedLOD>
#include <osg/Drawable>
#include <osg/GraphicsThread>
#include <osg/FrameStamp>
#include <osg/ObserverNodePath>
#include <osg/observer_ptr>
 
#include <OpenThreads/Thread>
#include <OpenThreads/Mutex>
#include <OpenThreads/ScopedLock>
#include <OpenThreads/Condition>
 
#include <osgUtil/IncrementalCompileOperation>
 
#include <osgDB/SharedStateManager>
#include <osgDB/ReaderWriter>
#include <osgDB/Options>
 
 
#include <map>
#include <list>
#include <algorithm>
#include <functional>
 
namespace osgDB {
 
 

class OSGDB_EXPORT DatabasePager : public osg::NodeVisitor::DatabaseRequestHandler
{
    public :
 
        typedef OpenThreads::Thread::ThreadPriority ThreadPriority;
 
        DatabasePager();
 
        DatabasePager(const DatabasePager& rhs);
 
        virtual const char* className() const { return "DatabasePager"; }

        virtual DatabasePager* clone() const { return new DatabasePager(*this); }

        static osg::ref_ptr<DatabasePager>& prototype();

        static DatabasePager* create();
 
 

        virtual void requestNodeFile(const std::string& fileName, osg::NodePath& nodePath,
                                     float priority, const osg::FrameStamp* framestamp,
                                     osg::ref_ptr<osg::Referenced>& databaseRequest,
                                     const osg::Referenced* options);

        int setSchedulePriority(OpenThreads::Thread::ThreadPriority priority);

        virtual int cancel();
 
        virtual bool isRunning() const;

        virtual void clear();
 
        class OSGDB_EXPORT DatabaseThread : public osg::Referenced, public OpenThreads::Thread
        {
        public:
 
            enum Mode
            {
                HANDLE_ALL_REQUESTS,
                HANDLE_NON_HTTP,
                HANDLE_ONLY_HTTP
            };
 
            DatabaseThread(DatabasePager* pager, Mode mode, const std::string& name);
 
            DatabaseThread(const DatabaseThread& dt, DatabasePager* pager);
 
            void setName(const std::string& name) { _name = name; }
            const std::string& getName() const { return _name; }
 
            void setDone(bool done) { _done.exchange(done?1:0); }
            bool getDone() const { return _done!=0; }
 
            void setActive(bool active) { _active = active; }
            bool getActive() const { return _active; }
 
            virtual int cancel();
 
            virtual void run();
 
        protected:
 
            virtual ~DatabaseThread();
 
            OpenThreads::Atomic _done;
            volatile bool       _active;
            DatabasePager*      _pager;
            Mode                _mode;
            std::string         _name;
 
        };
 
        virtual void setProcessorAffinity(const OpenThreads::Affinity& affinity);
        OpenThreads::Affinity& getProcessorAffinity() { return _affinity; }
        const OpenThreads::Affinity& getProcessorAffinity() const { return _affinity; }
 
        void setUpThreads(unsigned int totalNumThreads=2, unsigned int numHttpThreads=1);
 
        virtual unsigned int addDatabaseThread(DatabaseThread::Mode mode, const std::string& name);
 
        DatabaseThread* getDatabaseThread(unsigned int i) { return _databaseThreads[i].get(); }
 
        const DatabaseThread* getDatabaseThread(unsigned int i) const { return _databaseThreads[i].get(); }
 
        unsigned int getNumDatabaseThreads() const { return static_cast<unsigned int>(_databaseThreads.size()); }

        void setDatabasePagerThreadPause(bool pause);

        bool getDatabasePagerThreadPause() const { return _databasePagerThreadPaused; }

        void setAcceptNewDatabaseRequests(bool acceptNewRequests) { _acceptNewRequests = acceptNewRequests; }

        bool getAcceptNewDatabaseRequests() const { return _acceptNewRequests; }

        int getNumFramesActive() const { return _numFramesActive; }

        virtual void signalBeginFrame(const osg::FrameStamp* framestamp);

        virtual void signalEndFrame();
 

        virtual void registerPagedLODs(osg::Node* subgraph, unsigned int frameNumber = 0);

        void setIncrementalCompileOperation(osgUtil::IncrementalCompileOperation* ico);

        osgUtil::IncrementalCompileOperation* getIncrementalCompileOperation() { return _incrementalCompileOperation.get(); }
 

        void setDoPreCompile(bool flag) { _doPreCompile = flag; }

        bool getDoPreCompile() const { return _doPreCompile; }
 
 

        void setTargetMaximumNumberOfPageLOD(unsigned int target) { _targetMaximumNumberOfPageLOD = target; }

        unsigned int getTargetMaximumNumberOfPageLOD() const { return _targetMaximumNumberOfPageLOD; }
 

        void setDeleteRemovedSubgraphsInDatabaseThread(bool flag) { _deleteRemovedSubgraphsInDatabaseThread = flag; }

        bool getDeleteRemovedSubgraphsInDatabaseThread() const { return _deleteRemovedSubgraphsInDatabaseThread; }
 
        enum DrawablePolicy
        {
            DO_NOT_MODIFY_DRAWABLE_SETTINGS,
            USE_DISPLAY_LISTS,
            USE_VERTEX_BUFFER_OBJECTS,
            USE_VERTEX_ARRAYS
        };

        void setDrawablePolicy(DrawablePolicy policy) { _drawablePolicy = policy; }

        DrawablePolicy getDrawablePolicy() const { return _drawablePolicy; }
 

        void setApplyPBOToImages(bool assignPBOToImages) { _assignPBOToImages = assignPBOToImages; }

        bool getApplyPBOToImages() const { return _assignPBOToImages; }
 

        void setUnrefImageDataAfterApplyPolicy(bool changeAutoUnRef, bool valueAutoUnRef) { _changeAutoUnRef = changeAutoUnRef; _valueAutoUnRef = valueAutoUnRef; }

        void getUnrefImageDataAfterApplyPolicy(bool& changeAutoUnRef, bool& valueAutoUnRef) const { changeAutoUnRef = _changeAutoUnRef; valueAutoUnRef = _valueAutoUnRef; }
 

        void setMaxAnisotropyPolicy(bool changeAnisotropy, float valueAnisotropy) { _changeAnisotropy = changeAnisotropy; _valueAnisotropy = valueAnisotropy; }

        void getMaxAnisotropyPolicy(bool& changeAnisotropy, float& valueAnisotropy) const { changeAnisotropy = _changeAnisotropy; valueAnisotropy = _valueAnisotropy; }
 

        bool requiresUpdateSceneGraph() const;

        virtual void updateSceneGraph(const osg::FrameStamp& frameStamp);

        bool requiresRedraw() const;

        unsigned int getFileRequestListSize() const { return static_cast<unsigned int>(_fileRequestQueue->size() + _httpRequestQueue->size()); }

        unsigned int getDataToCompileListSize() const { return static_cast<unsigned int>(_dataToCompileList->size()); }

        unsigned int getDataToMergeListSize() const { return static_cast<unsigned int>(_dataToMergeList->size()); }

        bool getRequestsInProgress() const;

        double getMinimumTimeToMergeTile() const { return _minimumTimeToMergeTile; }

        double getMaximumTimeToMergeTile() const { return _maximumTimeToMergeTile; }

        double getAverageTimeToMergeTiles() const { return (_numTilesMerges > 0) ? _totalTimeToMergeTiles/static_cast<double>(_numTilesMerges) : 0; }

        void resetStats();
 
        typedef std::set< osg::ref_ptr<osg::StateSet> >                 StateSetList;
        typedef std::vector< osg::ref_ptr<osg::Drawable> >              DrawableList;
 
        class ExpirePagedLODsVisitor;
 
        typedef std::list<  osg::ref_ptr<osg::Object> > ObjectList;
 
        struct PagedLODList : public osg::Referenced
        {
            virtual PagedLODList* clone() = 0;
            virtual void clear() = 0;
            virtual unsigned int size() = 0;
            virtual void removeExpiredChildren(int numberChildrenToRemove, double expiryTime, unsigned int expiryFrame, ObjectList& childrenRemoved, bool visitActive) = 0;
            virtual void removeNodes(osg::NodeList& nodesToRemove) = 0;
            virtual void insertPagedLOD(const osg::observer_ptr<osg::PagedLOD>& plod) = 0;
            virtual bool containsPagedLOD(const osg::observer_ptr<osg::PagedLOD>& plod) const = 0;
        };
 
        void setMarkerObject(osg::Object* mo) { _markerObject = mo; }
        osg::Object* getMarkerObject() { return _markerObject.get(); }
        const osg::Object* getMarkerObject() const { return _markerObject.get(); }
 
    protected:
 
        virtual ~DatabasePager();
 
        friend class DatabaseThread;
        friend struct DatabaseRequest;
 
        struct RequestQueue;
 
        struct OSGDB_EXPORT DatabaseRequest : public osg::Referenced
        {
            DatabaseRequest():
                osg::Referenced(true),
                _valid(false),
                _frameNumberFirstRequest(0),
                _timestampFirstRequest(0.0),
                _priorityFirstRequest(0.f),
                _frameNumberLastRequest(0),
                _timestampLastRequest(0.0),
                _priorityLastRequest(0.0f),
                _numOfRequests(0),
                _groupExpired(false)
            {}
 
            void invalidate();
 
            bool valid() const { return _valid; }
 
            bool isRequestCurrent (int frameNumber) const
            {
                return _valid && (frameNumber - _frameNumberLastRequest <= 1);
            }
 
            bool                                _valid;
            std::string                         _fileName;
            unsigned int                        _frameNumberFirstRequest;
            double                              _timestampFirstRequest;
            float                               _priorityFirstRequest;
            unsigned int                        _frameNumberLastRequest;
            double                              _timestampLastRequest;
            float                               _priorityLastRequest;
            unsigned int                        _numOfRequests;
 
            osg::observer_ptr<osg::Node>        _terrain;
            osg::observer_ptr<osg::Group>       _group;
 
            osg::ref_ptr<osg::Node>             _loadedModel;
            osg::ref_ptr<Options>               _loadOptions;
            osg::ref_ptr<ObjectCache>           _objectCache;
 
            osg::observer_ptr<osgUtil::IncrementalCompileOperation::CompileSet> _compileSet;
            bool                                _groupExpired; // flag used only in update thread
        };
 
 
        struct OSGDB_EXPORT RequestQueue : public osg::Referenced
        {
        public:
 
            RequestQueue(DatabasePager* pager);
 
            void add(DatabaseRequest* databaseRequest);
            void remove(DatabaseRequest* databaseRequest);
 
            void addNoLock(DatabaseRequest* databaseRequest);
 
            void takeFirst(osg::ref_ptr<DatabaseRequest>& databaseRequest);

            bool pruneOldRequestsAndCheckIfEmpty();
 
            virtual void updateBlock() {}
 
            void invalidate(DatabaseRequest* dr);
 
            bool empty();
 
            unsigned int size();
 
            void clear();
 
 
            typedef std::list< osg::ref_ptr<DatabaseRequest> > RequestList;
            void swap(RequestList& requestList);
 
            DatabasePager*              _pager;
            RequestList                 _requestList;
            OpenThreads::Mutex          _requestMutex;
            unsigned int                _frameNumberLastPruned;
 
        protected:
            virtual ~RequestQueue();
        };
 
 
        typedef std::vector< osg::ref_ptr<DatabaseThread> > DatabaseThreadList;
 
        struct OSGDB_EXPORT ReadQueue : public RequestQueue
        {
            ReadQueue(DatabasePager* pager, const std::string& name);
 
            void block() { _block->block(); }
 
            void release() { _block->release(); }
 
            virtual void updateBlock();
 
 
            osg::ref_ptr<osg::RefBlock> _block;
 
            std::string                 _name;
 
            OpenThreads::Mutex          _childrenToDeleteListMutex;
            ObjectList                  _childrenToDeleteList;
        };
 
        // forward declare inner helper classes
        class FindCompileableGLObjectsVisitor;
        friend class FindCompileableGLObjectsVisitor;
 
        struct DatabasePagerCompileCompletedCallback;
        friend struct DatabasePagerCompileCompletedCallback;
 
        class FindPagedLODsVisitor;
        friend class FindPagedLODsVisitor;
 
        struct SortFileRequestFunctor;
        friend struct SortFileRequestFunctor;
 
 
        OpenThreads::Mutex              _run_mutex;
        OpenThreads::Mutex              _dr_mutex;
        bool                            _startThreadCalled;
 
        void compileCompleted(DatabaseRequest* databaseRequest);

        virtual void removeExpiredSubgraphs(const osg::FrameStamp &frameStamp);

        void addLoadedDataToSceneGraph(const osg::FrameStamp &frameStamp);
 
 
        OpenThreads::Affinity           _affinity;
 
        bool                            _done;
        bool                            _acceptNewRequests;
        bool                            _databasePagerThreadPaused;
 
        DatabaseThreadList              _databaseThreads;
 
        int                             _numFramesActive;
        mutable OpenThreads::Mutex      _numFramesActiveMutex;
        OpenThreads::Atomic             _frameNumber;
 
        osg::ref_ptr<ReadQueue>         _fileRequestQueue;
        osg::ref_ptr<ReadQueue>         _httpRequestQueue;
        osg::ref_ptr<RequestQueue>      _dataToCompileList;
        osg::ref_ptr<RequestQueue>      _dataToMergeList;
 
        DrawablePolicy                  _drawablePolicy;
 
        bool                            _assignPBOToImages;
        bool                            _changeAutoUnRef;
        bool                            _valueAutoUnRef;
        bool                            _changeAnisotropy;
        float                           _valueAnisotropy;
 
        bool                            _deleteRemovedSubgraphsInDatabaseThread;
 
 
        osg::ref_ptr<PagedLODList>      _activePagedLODList;
 
        unsigned int                    _targetMaximumNumberOfPageLOD;
 
        bool                            _doPreCompile;
        osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation;
 
 
        double                          _minimumTimeToMergeTile;
        double                          _maximumTimeToMergeTile;
        double                          _totalTimeToMergeTiles;
        unsigned int                    _numTilesMerges;
 
        osg::ref_ptr<osg::Object>       _markerObject;
};
 
}
 
#endif