unusedFeatureTileTracker.h

Go to the documentation of this file.

#pragma once

#include <features/featuresDefines.h>

#include <boost/optional.hpp>
#include <list>

#include <tbb/spin_rw_mutex.h>
#include <tbb/tbb_thread.h>

namespace MAKVRinTerra
{
   class DT_DLL_features DtUnusedFeatureTileTracker
   {
   public:
      class DT_DLL_features Trackable;
      class DT_DLL_features Sentinel;

      typedef boost::shared_ptr<DtUnusedFeatureTileTracker> Ptr;
      typedef boost::weak_ptr<DtUnusedFeatureTileTracker>   WeakPtr;
      typedef boost::shared_ptr<Trackable>                  TrackablePtr;
      typedef std::list<TrackablePtr>                       TrackableList;

      DtUnusedFeatureTileTracker(unsigned maxSize = 500000);

      ~DtUnusedFeatureTileTracker();

      void start();

      unsigned length() const;

      unsigned size() const;

      void setMaxSize(unsigned max);

      void unloadUntilSize(unsigned maxSize);

   private:
      friend class Trackable;

      typedef tbb::spin_rw_mutex Mutex;

      bool add(Trackable&);

      bool remove(Trackable&);

      void run();

      mutable Mutex myMutex;
      TrackableList myUnused;

      bool myDoneFlag;
      unsigned myMaxSize;
      boost::scoped_ptr<tbb::tbb_thread> myPageOutThread;
   };

   class DtUnusedFeatureTileTracker::Trackable : private boost::noncopyable
   {
   public:
      virtual ~Trackable();

      virtual bool keep() const = 0;

      virtual void load() = 0;

      virtual void unload() = 0;

      virtual unsigned size() const = 0;

      virtual boost::shared_ptr<Trackable> getPtr() = 0;

      boost::shared_ptr<Sentinel> getSentinel();

      unsigned useCount() const;

   protected:
      explicit Trackable(DtUnusedFeatureTileTracker::Ptr);

   private:
      friend class DtUnusedFeatureTileTracker;
      friend class Sentinel;

      typedef tbb::spin_rw_mutex Mutex;

      void sentinelDestroyed();

      bool hasIterator() const { return myIterator; }
      TrackableList::iterator iterator() const { return *myIterator; }

      mutable Mutex myMutex;

      DtUnusedFeatureTileTracker::WeakPtr myTracker;

      boost::weak_ptr<Sentinel> mySentinel;
      boost::optional<TrackableList::iterator> myIterator;
   };

   class DtUnusedFeatureTileTracker::Sentinel : private boost::noncopyable
   {
   public:
      typedef boost::shared_ptr<Sentinel> Ptr;

      ~Sentinel();

   private:
      friend class Trackable;

      Sentinel(boost::shared_ptr<Trackable>);

      boost::shared_ptr<Trackable> myTrackable;
   };
}