objectCounter.h

Go to the documentation of this file.

#pragma once

#include <vrfutil/vrfutilDefines.h>

#include <tbb/atomic.h>
#include <string>
#include <assert.h>
#include <boost/function.hpp>

#ifndef USE_VLD_MEMORY_TRACKING
#define DT_OBJECT_DEBUGGING_ENABLED
#endif

//#define DT_OBJECT_TRACKING_ENABLED

#ifdef DT_OBJECT_TRACKING_ENABLED
#include <tbb/spin_mutex.h>
#include <list>
#endif

#ifdef _DEBUG
template <typename D, bool Enable = false>
class DtObjectDebugger;
#else
template <typename D, bool Enable = false>
class DtObjectDebugger;
#endif

#ifndef DT_OBJECT_DEBUGGING_ENABLED
#define DT_DEFINE_OBJECT_DEBUGGER_NAME(type)
#define DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(type)
#define DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE2(type)

template <typename D, bool Enable>
class DtObjectDebugger
{
public:
   DtObjectDebugger() {};
};

#else

class DtObjectContainer;

class DT_DLL_vrfutil DtObjectCounter
{
public:
   template <typename D, bool Enable>
   friend class DtObjectDebugger;

   typedef unsigned long long       CounterType;
   typedef tbb::atomic<CounterType> AtomicType;

   typedef boost::function<std::string ()> NameFunction;

   static void Init();

   static std::string Print(std::string regex = "");
   static std::string PrettyPrintSize(size_t);
   static std::string DetectLeaks();

   explicit DtObjectCounter(
      const NameFunction&,
      size_t size = 1,
      bool enable = true,
      const DtObjectContainer* container = 0);

   explicit DtObjectCounter(
      const std::string&,
      size_t size = 1,
      bool enable = true,
      const DtObjectContainer* container = 0);

   ~DtObjectCounter();

   CounterType value() const { return myCount; }

   CounterType total() const { return myTotal; }

   size_t size() const { return mySize; }

   size_t totalSize() const { return value() * size(); }

   const DtObjectContainer* objects() const { return myObjects; }

private:
   CounterType increment() { ++myCount; return myTotal++; }

   void decrement() { --myCount; }

   AtomicType myCount, myTotal;
   const size_t mySize;
   const bool myEnableFlag;

   const DtObjectContainer* myObjects;

   DtObjectCounter(const DtObjectCounter&);
   void operator=(const DtObjectCounter&);
};

#ifdef DT_OBJECT_TRACKING_ENABLED

class DtObjectTracker;

class DT_DLL_vrfutil DtObjectContainer
{
public:
   typedef tbb::spin_mutex                   Mutex;
   typedef std::list<const DtObjectTracker*> TrackableList;
   typedef TrackableList::iterator           Handle;

   typedef boost::function<void (const DtObjectTracker&)> IterateFunction;

   Handle add(const DtObjectTracker& obj);
   void remove(Handle h);

   void iterate(const IterateFunction&) const;
   void print(std::ostream&, unsigned width = 0) const;

private:
   mutable Mutex myMutex;
   TrackableList myTrackables;
};

class DT_DLL_vrfutil DtObjectTracker
{
public:
   virtual std::string debugText() const;

   DtObjectCounter::CounterType objectIndex() const { return myObjectIndex; }

protected:
   DtObjectTracker() : myObjectIndex(0) { }

   virtual ~DtObjectTracker();

private:
   template <typename D, bool Enable>
   friend class DtObjectDebugger;

   DtObjectContainer::Handle myHandle;
   DtObjectCounter::CounterType myObjectIndex;
};

#else

class DtObjectTracker { };

#endif

template <typename D, bool Enable>
class DtObjectDebugger : public DtObjectTracker
{
public:
   static DtObjectCounter::CounterType ObjectCount()
   {
      return theStaticCount.value();
   }

   static const DtObjectContainer* ObjectContainer()
   {
      return ObjectContainerMutable();
   }

protected:
   explicit DtObjectDebugger()
   {
      if (Enable)
      {
#ifdef DT_OBJECT_TRACKING_ENABLED
         myObjectIndex = theStaticCount.increment();
         myHandle = ObjectContainerMutable()->add(*this);
#else
         theStaticCount.increment();
#endif
      }
   }

   explicit DtObjectDebugger(const DtObjectDebugger&)
   {
      if (Enable)
      {
#ifdef DT_OBJECT_TRACKING_ENABLED
         myObjectIndex = theStaticCount.increment();
         myHandle = ObjectContainerMutable()->add(*this);
#else
         theStaticCount.increment();
#endif
      }
   }

   ~DtObjectDebugger()
   {
#ifdef DT_OBJECT_TRACKING_ENABLED
      if (Enable)
         ObjectContainerMutable()->remove(myHandle);
#endif

      if (Enable)
         theStaticCount.decrement();
   }

private:
   static DtObjectCounter theStaticCount;

   static DtObjectContainer* ObjectContainerMutable()
   {
#ifdef DT_OBJECT_TRACKING_ENABLED
      static DtObjectContainer theObjectContainer;
      return &theObjectContainer;
#else
      return 0;
#endif
   }
};

template <typename D>
struct DtObjectDebuggerLabel
{
   static inline std::string value()
   {
      return "Unnamed";
   }
};

template <typename D, bool Enabled>
DtObjectCounter DtObjectDebugger<D,Enabled>::theStaticCount(
   &DtObjectDebuggerLabel<D>::value,
   sizeof(D),
   Enabled,
   DtObjectDebugger<D,Enabled>::ObjectContainer());

#define DT_NAME_OBJECT_DEBUGGER(type, name) \
   template <>                              \
   struct DtObjectDebuggerLabel< type >     \
   {                                        \
      static inline std::string value()     \
      {                                     \
         return name ;                      \
      }                                     \
   };                                       \

#define DT_DEFINE_OBJECT_DEBUGGER_NAME(type) \
   template <>                               \
   struct DtObjectDebuggerLabel< type >      \
   {                                         \
      static inline std::string value()      \
      {                                      \
         return #type ;                      \
      }                                      \
   };                                        \

#define DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(type) \
   template <typename T>                              \
   struct DtObjectDebuggerLabel< type <T> >           \
   {                                                  \
      static inline std::string value()               \
      {                                               \
         std::string name( #type "<" );               \
         name += DtObjectDebuggerLabel<T>::value();   \
         name += ">";                                 \
         return name;                                 \
      }                                               \
   };                                                 \

#define DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE2(type) \
   template <typename T1, typename T2>                 \
   struct DtObjectDebuggerLabel< type <T1,T2> >       \
   {                                                  \
      static inline std::string value()               \
      {                                               \
         std::string name( #type "<" );               \
         name += DtObjectDebuggerLabel<T1>::value();  \
         name += ",";                                 \
         name += DtObjectDebuggerLabel<T2>::value();  \
         name += ">";                                 \
         return name;                                 \
      }                                               \
   };                                                 \

#endif