unusedFeatureTileTracker.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <features/featuresDefines.h>

#include <tbb/spin_rw_mutex.h>
#include <tbb/tick_count.h>
#include <atomic>

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

#include <list>

#include <vrfutil/objectCounter.h>

class DtConsoleCommandManager;
class DtConsoleCommandOwner;

namespace MAKVRinTerra
{
   class DT_DLL_features DtUnusedFeatureTileTracker
#ifdef DtObjectDebugger_Enable
      : public DtObjectDebugger<DtUnusedFeatureTileTracker>
#endif
   {
   public:
      class DT_DLL_features Trackable;
      class DT_DLL_features Sentinel;

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

      DtUnusedFeatureTileTracker(
         DtConsoleCommandManager* mgr=0,
         const std::string& name = "tracker");

      ~DtUnusedFeatureTileTracker();

      void start();

      unsigned length() const;

      unsigned size() const;

      unsigned totalLength() const;

      void setMaxSize(unsigned max);

      unsigned maxSize() const;

      void setMinUnusedTime(double);

      double minUnusedTime() const;

      unsigned long unloadUntilSize(unsigned maxSize, double minTime);
      unsigned long unloadUntilSize(unsigned maxSize);

      void addSubtracker(const Ptr& subtracker);

      void info(std::ostream&) const;

      void print(std::ostream&) const;

   private:
      friend class Trackable;

      typedef tbb::spin_rw_mutex Mutex;

      bool add(Trackable&);

      bool add(const std::shared_ptr<Trackable>&);

      bool remove(Trackable&);

      bool removeAndUnload(Trackable&);

      void run();

      mutable Mutex myMutex;
      TrackableList myUnused;

      bool myDoneFlag;
      std::unique_ptr<std::thread> myPageOutThread;

      std::atomic<unsigned> myMaxSize;
      std::atomic<double> myMinUnusedTime;

      typedef std::vector<Ptr> SubTrackerList;
      SubTrackerList mySubtrackers;

      mutable Mutex myTotalListMutex;
      TrackableRawPtrList myTrackables;

      std::unique_ptr<DtConsoleCommandManager> myCommandManager;
      std::unique_ptr<DtConsoleCommandOwner> myCommandOwner;
   };

   class DtUnusedFeatureTileTracker::Trackable
      : private boost::noncopyable
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger<DtUnusedFeatureTileTracker::Trackable>
#endif
   {
   public:
      static bool UnloadTryCatch(Trackable&);

      virtual ~Trackable();

      virtual std::string label() const = 0;

      virtual void load() = 0;

      virtual bool unload() = 0;

      virtual bool loading() const = 0;

      virtual bool loaded() const = 0;

      virtual unsigned size() const = 0;

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

      std::shared_ptr<Sentinel> getSentinel(bool loadIfNotPresent=true) const;

      void addToUnusedList();

      unsigned useCount() const;

      tbb::tick_count unusedTime() const;

   protected:
      explicit Trackable(const DtUnusedFeatureTileTracker::Ptr&);

   private:
      friend class DtUnusedFeatureTileTracker;
      friend class Sentinel;

      typedef tbb::spin_rw_mutex Mutex;

      void sentinelDestroyed();

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

      mutable Mutex myMutex;

      const DtUnusedFeatureTileTracker::WeakPtr myTracker;

      std::weak_ptr<Sentinel> mySentinel;
      boost::optional<TrackableList::iterator> myIterator;
      boost::optional<TrackableRawPtrList::iterator> myTrackableListIterator;

      tbb::tick_count myUnusedTime;
   };

   class DtUnusedFeatureTileTracker::Sentinel
      : private boost::noncopyable
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger<DtUnusedFeatureTileTracker::Sentinel>
#endif
   {
   public:
      typedef std::shared_ptr<Sentinel> Ptr;

      ~Sentinel();

   private:
      friend class Trackable;

      explicit Sentinel(const std::shared_ptr<Trackable>&);

      const std::shared_ptr<Trackable> myTrackable;
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtUnusedFeatureTileTracker);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtUnusedFeatureTileTracker::Trackable);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtUnusedFeatureTileTracker::Sentinel);