src/LinearMath/btQuickprof.h

   1
   2 /***************************************************************************************************
   3 **
   4 ** Real-Time Hierarchical Profiling for Game Programming Gems 3
   5 **
   6 ** by Greg Hjelstrom & Byon Garrabrant
   7 **
   8 ***************************************************************************************************/
   9
  10 // Credits: The Clock class was inspired by the Timer classes in
  11 // Ogre (www.ogre3d.org).
  12
  13
  14
  15 #ifndef BT_QUICK_PROF_H
  16 #define BT_QUICK_PROF_H
  17
  18 //To disable built-in profiling, please comment out next line
  19 //#define BT_NO_PROFILE 1
  20 #ifndef BT_NO_PROFILE
  21 #include <stdio.h>//@todo remove this, backwards compatibility
  22 #include "btScalar.h"
  23 #include "btAlignedAllocator.h"
  24 #include <new>
  25
  26
  27
  28
  29
  30 #define USE_BT_CLOCK 1
  31
  32 #ifdef USE_BT_CLOCK
  33
  34 ///The btClock is a portable basic clock that measures accurate time in seconds, use for profiling.
  35 class btClock
  36 {
  37 public:
  38         btClock();
  39
  40         btClock(const btClock& other);
  41         btClock& operator=(const btClock& other);
  42
  43         ~btClock();
  44
  45         /// Resets the initial reference time.
  46         void reset();
  47
  48         /// Returns the time in ms since the last call to reset or since
  49         /// the btClock was created.
  50         unsigned long int getTimeMilliseconds();
  51
  52         /// Returns the time in us since the last call to reset or since
  53         /// the Clock was created.
  54         unsigned long int getTimeMicroseconds();
  55 private:
  56         struct btClockData* m_data;
  57 };
  58
  59 #endif //USE_BT_CLOCK
  60
  61
  62
  63
  64 ///A node in the Profile Hierarchy Tree
  65 class   CProfileNode {
  66
  67 public:
  68         CProfileNode( const char * name, CProfileNode * parent );
  69         ~CProfileNode( void );
  70
  71         CProfileNode * Get_Sub_Node( const char * name );
  72
  73         CProfileNode * Get_Parent( void )               { return Parent; }
  74         CProfileNode * Get_Sibling( void )              { return Sibling; }
  75         CProfileNode * Get_Child( void )                        { return Child; }
  76
  77         void                            CleanupMemory();
  78         void                            Reset( void );
  79         void                            Call( void );
  80         bool                            Return( void );
  81
  82         const char *    Get_Name( void )                                { return Name; }
  83         int                             Get_Total_Calls( void )         { return TotalCalls; }
  84         float                           Get_Total_Time( void )          { return TotalTime; }
  85         void*                   GetUserPointer() const {return m_userPtr;}
  86         void                    SetUserPointer(void* ptr) { m_userPtr = ptr;}
  87 protected:
  88
  89         const char *    Name;
  90         int                             TotalCalls;
  91         float                           TotalTime;
  92         unsigned long int                       StartTime;
  93         int                             RecursionCounter;
  94
  95         CProfileNode *  Parent;
  96         CProfileNode *  Child;
  97         CProfileNode *  Sibling;
  98         void*   m_userPtr;
  99 };
 100
 101 ///An iterator to navigate through the tree
 102 class CProfileIterator
 103 {
 104 public:
 105         // Access all the children of the current parent
 106         void                            First(void);
 107         void                            Next(void);
 108         bool                            Is_Done(void);
 109         bool                Is_Root(void) { return (CurrentParent->Get_Parent() == 0); }
 110
 111         void                            Enter_Child( int index );               // Make the given child the new parent
 112         void                            Enter_Largest_Child( void );    // Make the largest child the new parent
 113         void                            Enter_Parent( void );                   // Make the current parent's parent the new parent
 114
 115         // Access the current child
 116         const char *    Get_Current_Name( void )                        { return CurrentChild->Get_Name(); }
 117         int                             Get_Current_Total_Calls( void ) { return CurrentChild->Get_Total_Calls(); }
 118         float                           Get_Current_Total_Time( void )  { return CurrentChild->Get_Total_Time(); }
 119
 120         void*   Get_Current_UserPointer( void )                 { return CurrentChild->GetUserPointer(); }
 121         void    Set_Current_UserPointer(void* ptr) {CurrentChild->SetUserPointer(ptr);}
 122         // Access the current parent
 123         const char *    Get_Current_Parent_Name( void )                 { return CurrentParent->Get_Name(); }
 124         int                             Get_Current_Parent_Total_Calls( void )  { return CurrentParent->Get_Total_Calls(); }
 125         float                           Get_Current_Parent_Total_Time( void )   { return CurrentParent->Get_Total_Time(); }
 126
 127
 128
 129 protected:
 130
 131         CProfileNode *  CurrentParent;
 132         CProfileNode *  CurrentChild;
 133
 134
 135         CProfileIterator( CProfileNode * start );
 136         friend  class           CProfileManager;
 137 };
 138
 139
 140 ///The Manager for the Profile system
 141 class   CProfileManager {
 142 public:
 143         static  void                                            Start_Profile( const char * name );
 144         static  void                                            Stop_Profile( void );
 145
 146         static  void                                            CleanupMemory(void)
 147         {
 148                 Root.CleanupMemory();
 149         }
 150
 151         static  void                                            Reset( void );
 152         static  void                                            Increment_Frame_Counter( void );
 153         static  int                                             Get_Frame_Count_Since_Reset( void )             { return FrameCounter; }
 154         static  float                                           Get_Time_Since_Reset( void );
 155
 156         static  CProfileIterator *      Get_Iterator( void )
 157         {
 158
 159                 return new CProfileIterator( &Root );
 160         }
 161         static  void                                            Release_Iterator( CProfileIterator * iterator ) { delete ( iterator); }
 162
 163         static void     dumpRecursive(CProfileIterator* profileIterator, int spacing);
 164
 165         static void     dumpAll();
 166
 167 private:
 168         static  CProfileNode                    Root;
 169         static  CProfileNode *                  CurrentNode;
 170         static  int                                             FrameCounter;
 171         static  unsigned long int                                       ResetTime;
 172 };
 173
 174
 175 ///ProfileSampleClass is a simple way to profile a function's scope
 176 ///Use the BT_PROFILE macro at the start of scope to time
 177 class   CProfileSample {
 178 public:
 179         CProfileSample( const char * name )
 180         {
 181                 CProfileManager::Start_Profile( name );
 182         }
 183
 184         ~CProfileSample( void )
 185         {
 186                 CProfileManager::Stop_Profile();
 187         }
 188 };
 189
 190
 191 #define BT_PROFILE( name )                      CProfileSample __profile( name )
 192
 193 #else
 194
 195 #define BT_PROFILE( name )
 196
 197 #endif //#ifndef BT_NO_PROFILE
 198
 199
 200
 201 #endif //BT_QUICK_PROF_H
 202
 203