src/common/profiler.hpp

Idź do dokumentacji tego pliku.

/* header file for src/common/profiler.cpp */

#ifndef _CORE_COMMON_PROFILER_HPP
#define _CORE_COMMON_PROFILER_HPP

void *memset(void *buffer, int c, uint32 num);          /*ansi-c memset function*//*src/memory/memset.hpp*/
namespace Arch {
 namespace x86 {
  namespace RTC {
   extern uint64 volatile up_time; }}}  /*src/arch/x86/rtc.hpp*/


namespace Debug {
namespace Profiler {

inline uint64 rdtsc()
 {
union
 {
        uint32 u32[2];
        uint64 u64;
 };
        asm volatile ("rdtsc" :"=a" (u32[0]), "=d"(u32[1]));
        return u64;
 }

//NOTE: the profiling data will include the time, when the function's thread was scheduled down.
//NOTE: race situations may occur which make the results less reliable. Not that often, though.

//info on a function
struct profiling_s
 {
        uint64 volatile Time;   //the time the function used
        uint32 volatile Calls;  //the count of the function being called
        uint32 volatile Active; //how many calls of the function are atm
        char *Name;     //function name as in __func__
 };

//how big the buffer should be
#define MAX_PROFILER    200

extern uint32 ProfilerCount;
extern struct profiling_s ProfilerBuf[MAX_PROFILER];

#define PROFILER_ENABLE
#ifdef PROFILER_ENABLE
 //begin collecting profiling information for a function
 #define _Pf(n) static uint32 __Zx3Ed8_ = 0xffff;       \
                uint64 __ZxCOMPS; \
                                do {            \
                                if (__Zx3Ed8_ == 0xffff) { __Zx3Ed8_= Debug::Profiler::ProfilerCount++; \
                                        if (Debug::Profiler::ProfilerCount >= MAX_PROFILER)     \
                                                {cout((char*)n); \
                                                sysfail("profiler: buffer too small!"); }\
                                        memset(&Debug::Profiler::ProfilerBuf[__Zx3Ed8_],0,sizeof(Debug::Profiler::profiling_s)); \
                                                Debug::Profiler::ProfilerBuf[__Zx3Ed8_].Name=(char*)n; }        \
                                __ZxCOMPS=/*Arch::x86::RTC::up_time;*/Debug::Profiler::rdtsc(); \
                                Debug::Profiler::ProfilerBuf[__Zx3Ed8_].Active++;               \
                                                                                \
                        } while(0)

 //the same, but with the default function name macro                   
 #define _PF    _Pf(__func__)

 //end collecting profiling information for a function
 #define _PFEnd         do {            \
                                Debug::Profiler::ProfilerBuf[__Zx3Ed8_].Time+=Debug::Profiler::rdtsc()/*Arch::x86::RTC::up_time*/-__ZxCOMPS;\
                                Debug::Profiler::ProfilerBuf[__Zx3Ed8_].Active--; \
                                Debug::Profiler::ProfilerBuf[__Zx3Ed8_].Calls++;\
                        } while (0)

 //end collecting && return from a function
 #define Preturn(r)     do { _PFEnd; return r; } while(0)
 #define preturn(r)     do { _PFEnd; return r; } while(0)

void stats(bool SortBySlowest);
int ProfilingCompar(const void*,const void*);
#endif /*PROFILER_ENABLE*/

#ifndef PROFILER_ENABLE
 #define _PF    do { } while(0)
 #define _Pf(n) do { } while (0)
 #define _PFEnd do { } while (0)
 #define Preturn(r) do { return r; } while(0)
 #define preturn(r) do { return r; } while(0)
 inline void stats(bool SortBySlowest) { }
#endif  /*PROFILER_ENABLE*/


  };    /*namespace Profiler*/
 };     /*namespace Debug*/

inline uint64 rdtsc()
 {
   return Debug::Profiler::rdtsc();
 }

#endif

---