profileNode.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/vrfutilDefines.h"

#include "vrfutil/columnLogger.h"

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

#include <iosfwd>

namespace makVrf
{
   class DtProfileManager;

   typedef unsigned long long DtUInt64;

   struct DT_DLL_vrfutil DtProfileStat
   {
      DtUInt64 instructions;
      double time;

      DtProfileStat();

      void reset();

      double instructionsPerSecond() const;

      DtProfileStat& operator+=(const DtProfileStat&);

      template <typename T>
      DtProfileStat operator/(const T& val) const
      {
         DtProfileStat stat(*this);
         stat.instructions /= val;
         stat.time /= val;
         return stat;
      }
   };

   struct DT_DLL_vrfutil DtProfileTimestamp
   {
      static DtProfileTimestamp Now();

      DtProfileTimestamp();

      DtProfileStat operator-(const DtProfileTimestamp&) const;

      DtUInt64 instructionCount;
      tbb::tick_count timestamp;
   };

   class DT_DLL_vrfutil DtProfileNode
   {
   public:
      enum Attributes
      {
         ENONE      = 0,
         EVIRTUAL   = 1,  
         EINVISIBLE = 2,  
         ENODE      = 3   
      };

      DtProfileNode(
         const char* name,
         DtProfileManager* mgr,
         DtProfileNode * parent,
         Attributes attr);

      ~DtProfileNode();

      DtProfileNode* getChildNode(const char*, Attributes attr = ENONE);

      bool isVirtual() const { return ((myAttributes & EVIRTUAL) != 0); }
      bool isInvisible() const { return ((myAttributes & EINVISIBLE) != 0); }

      DtProfileNode* parent() const { return myParent; }
      DtProfileNode* sibling() const { return mySibling; }
      DtProfileNode* child() const { return myChild; }

      void reset();

      const char* name() const { return myName; }
      int totalCalls() const { return myTotalCalls; }
      DtProfileStat totalTime() const { return myTotalTime; }
      DtProfileStat timeLastFrame() const;
      unsigned nestingLevel() const { return myNestingLevel; }

      void nextFrame();

   protected:
      friend class DtProfileManager;

      DtProfileTimestamp call();
      bool finish(const DtProfileTimestamp& start);

      DtProfileManager* myManager;

      const char* myName; 


      typedef tbb::spin_mutex StatMutex;
      mutable StatMutex myStatMutex;
      DtProfileStat myTotalTime;     
      DtProfileStat myTimeLastFrame; 

      tbb::atomic<int>   myTotalCalls;       
      tbb::atomic<int>   myTotalCallsThisFrame;
      //int              myRecursionCounter; //! current recursion level

      typedef tbb::spin_rw_mutex Mutex;
      mutable Mutex myMutex;

      DtProfileNode* myParent;
      DtProfileNode* myLogParent;
      DtProfileNode* myLogRoot;
      DtProfileNode* myChild;
      DtProfileNode* mySibling;
      unsigned myNestingLevel;

      Attributes myAttributes;

      DtColumnLogger::Column* myParentColumn;
      DtColumnLogger::Column* myTimeColumn;
      DtColumnLogger::Column* myInstColumn;
      DtColumnLogger::Column* myRateColumn;
   };
}