source: Revenant/geoworld/include/gwpaging.h@ 7ef8ec4

#ifndef __GEOWORLDPAGING_H__
#define __GEOWORLDPAGING_H__

#include <string>
#include <fstream>
#include <vector>

#include <mars_calc.h>
#include <mars_streams.h>
#include <mars_util.h>

#include <boost/thread.hpp>

#include "gwtypes.h"
#include "gwutil.h"
#include "geoworld.h"
#include "stratum.h"

namespace geoworld
{
        typedef mars::OctTree_SphereIndexed< MineralPtr, GeoSpherePack::SCALAR > OctTreeMineralDeposits;

        class GeoWorldPage
        {
        private:
                GeoHeightMap _heightmap;
                Stratum _stratum;
                OctTreeMineralDeposits _minerals;
                                
                mutable bool _bShouldAbort;
                mutable size_t _nIFaceRefCount;
                GW_MUTEX(atomic);
                GW_MUTEX(work);

                void checkOutIFace () const;
                void checkInIFace () const;

        public:
                class IFaceEx : public std::exception
                {
                public:
            const std::string message;
            
                        IFaceEx (const char * szMsg) : message(szMsg) {}
                };

                class Interface 
                {
                private:
                        GeoWorldPage * _pParent;

                        GW_MUTEX(atomic);

                public:
                        GeoHeightMap & heightmap;
                        Stratum & stratum;
                        OctTreeMineralDeposits & minerals;

                        Interface (GeoWorldPage * pParent);
            Interface (Interface && move);
                        ~Interface();

                        Stratum::View * createStratumView (const WorldUnit nLeft, const WorldUnit nTop, const int nShallow, const WorldUnit nRight, const WorldUnit nBottom, const WorldUnit nDeep) const;
                        Stratum::View * createStratumView (const WorldUnit nLeft, const WorldUnit nTop, const WorldUnit nRight, const WorldUnit nBottom) const;
                        void releaseStratumView (const Stratum::View * pView) const;

                        GeoHeightMap::View * createHeightMapView (const unsigned short nLeft, const unsigned short nTop, const unsigned short nRight, const unsigned short nBottom) const;
                        void releaseHeightMapView (const GeoHeightMap::View * pView) const;

                        inline bool isAborted() const { return _pParent->isAborted(); }
                };

                const unsigned int x, y;

                GeoWorldPage(const GeoHeightMap::View & hm, const unsigned int nPageX, const unsigned int nPageY, const unsigned short nDepth, const size_t nLayers);
                ~GeoWorldPage();
                
                void abort (const bool bWait = false) const;
                bool isAborted() const;

                const Interface acquireInterface() const { return Interface(const_cast< GeoWorldPage * > (this)); }
                Interface acquireInterface() { return Interface(this); }
        };

        class InstanceFile
        {
        public:
                class Ex : public std::exception
                {
                public:
            const std::string message;
            
                        Ex (const char * szMsg) : message(szMsg) {}
                };

                struct InfoHeader
                {
                        char IDENT[4];
                        unsigned long endian;
                        unsigned short version;
                        unsigned short stratumcount;
                        unsigned short dim, depth;

                        InfoHeader();
                        bool validate() const;
                };

                InstanceFile();
                InstanceFile(const unsigned short nDim, const unsigned short nDepth, const unsigned short nLayerCount);
                ~InstanceFile();

                inline const Stratum & getStratum() const { return *_pStratum; }
                inline Stratum & getStratum() { return *_pStratum; }

                inline GeoHeightMap::View & top () { return _pStratum->getBase(); }
                inline const GeoHeightMap::View & top () const { return _pStratum->getBase(); }

                inline GeoStratumField::View & layer (const size_t c) { return _pStratum->field(c); }
                inline const GeoStratumField::View & layer (const size_t c) const { return _pStratum->field(c); }

                static void write (const std::string & sFileName, const InstanceFile * pInstFile);
                static InstanceFile * load (const std::string & sFileName);

        private:
                Stratum * _pStratum;
                unsigned short _nDim, _nDepth;

                static std::fstream * open (const std::string & sFileName, const std::ios::openmode & nMode);

                std::ostream & operator >> (std::ostream & outs) const;
                std::istream & operator << (std::istream & ins);
        };

        class PagingStore
        {
        public:
                PagingStore (const std::string & sFileName, const std::string & sStoreDirectory, const std::string & sFilePrefix = "gwpage-", const std::string & sFileSuffix = ".gwp");

                GeoWorldPage * requestPage (const unsigned int nPageX, const unsigned int nPageY);

                void releasePage (GeoWorldPage * pPage);
                std::string makeFilename (const unsigned int nPageX, const unsigned int nPageY) const;
                static unsigned long calculatePageID (const unsigned int nPageX, const unsigned int nPageY);

                inline unsigned int getNumPagesWide () const { return _pFile->getTilesWide(); }
                inline unsigned int getNumPagesHigh () const { return _pFile->getTilesHigh(); }

                ~PagingStore();

        private:
                FileSource * _pFile;
                std::string _sFilePrefix, _sFileSuffix, _sStoreDirectory;
                FileSource::MainDEM::Block * _pUtilityBlock;

                InstanceFile * loadInstanceFile( const unsigned int nPageX, const unsigned int nPageY ) const;
                void logBorders( const GeoHeightMap::View &base, const unsigned int nPageX, const unsigned int nPageY );

                GW_MUTEX(mtxMaster);

                class PageMutexProvider
                {
                public:
                        class NeighborhoodMutex
                        {
                        public:
                                enum Spot
                                {
                                        N = 0, 
                                        W = 1, 
                                        E = 2, 
                                        S = 3,
                                        C = 4,

                                        TotalSpots = 5
                                };

                                explicit NeighborhoodMutex (boost::shared_mutex * const * ppmtx);
                                NeighborhoodMutex(NeighborhoodMutex && movable);
                                ~NeighborhoodMutex();

                                void genLock();

                        private:
                                NeighborhoodMutex (const NeighborhoodMutex & copy);
                                NeighborhoodMutex & operator = (const NeighborhoodMutex & copy);

                                typedef boost::upgrade_lock< boost::shared_mutex > preamble_lock;
                                typedef boost::upgrade_to_unique_lock< boost::shared_mutex > upgraded_lock;
                                typedef boost::unique_lock< boost::shared_mutex > gen_lock;
                                typedef boost::shared_lock< boost::shared_mutex > qry_lock;

                                typedef DetachableScopedTryLock< boost::shared_mutex, qry_lock > DetachableScopedQueryTryLock;
                                typedef DetachableScopedTryLock< boost::shared_mutex, gen_lock > DetachableScopedGenerationTryLock;

                                boost::shared_mutex * _pmtxNeighbors[TotalSpots];
                                qry_lock * _plckNeighbors[TotalSpots];
                                gen_lock * _plckCenter;
                                preamble_lock * _plckPreamble;

                                STATIC_GW_MUTEX(ATOMIC);
                        };

                        PageMutexProvider (const unsigned int nCellsX, const unsigned int nCellsY);
                        ~PageMutexProvider();

                        NeighborhoodMutex acquireNeighborhood (const long nPageX, const long nPageY);

                private:
                        boost::shared_mutex ** _ppShMutexes;
                        unsigned int _nW, _nH;
                        size_t _szLen;

                        size_t idx(const long nPageX, const long nPageY) const;
                } * _pMutexProvider;
        };
}

#endif