性能剖析器

 PerformanceProfiler.h:
#include<iostream>
using namespace std;
#include<map>
#include<windows.h>
#include<time.h>
#include<string>
#include<assert.h>
#include<stdarg.h>
#include<thread>
#include<mutex>
#include<algorithm>
#include<vector>

typedef long long LongType;

////////////保存适配器抽象基类//////////////
class SaveAdapter
{
public:
           //纯虚函数，强制要求派生类重写，重新实现
           virtual void Save(const char* fmt, ...) = 0;
};

//控制台保存适配器
class ConsoleSaveAdapter :public SaveAdapter//公有继承
{
           virtual void Save(const char* format , ...)
          {
                    va_list args;
                    va_start(args, format);
                   vfprintf( stdout, format , args);//输出重定向
                    va_end(args);
          }
};

//文件保存适配器
class FileSaveAdapter :public SaveAdapter
{
public:
          FileSaveAdapter( const char * filename)
                   :_fout(0)
          {
                   _fout = fopen( filename, "w" );
                    assert(_fout);
          }
          
          ~FileSaveAdapter()
          {
                    if (_fout)
                   {
                             fclose(_fout);
                   }
          }

           virtual void Save(const char* format , ...)
          {
                    if (_fout)
                   {
                              va_list args;
                              va_start(args, format);
                             vfprintf(_fout, format, args);//输出重定向到_fout
                              va_end(args);
                   }
          }

protected:
           //设置为保护类型，造成scopedPtr,防拷贝
          FileSaveAdapter( const FileSaveAdapter & f);
           FileSaveAdapter& operator=(const FileSaveAdapter& f);
private:
           FILE* _fout;
};

/////////////单例基类///////////////////
//单例模式的是指就是全局的静态指针，这个指针只能生成一个对象
template<class T>
class Singleton
{
public:
           static T * GetInstance()
          {
                    if (_sInstance == NULL )
                   {
                              lock_guard<mutex > lock(_mutex);
                              if (_sInstance == NULL )
                             {
                                      _sInstance = new T ();
                             }
                   }
                    return _sInstance;
          }

protected:
           //默认构造函数
          Singleton()
          {}
           //成员变量
           static T * _sInstance;
           static mutex _mutex;
};

//静态成员初始化
template<class T>
T* Singleton <T>::_sInstance = NULL;

template<class T>
mutex Singleton <T>::_mutex;

enum PP_CONFIG_OPTION
{
           PPCO_NONE = 0,               //不做剖析
           PPCO_PROFILER = 2,           //开启剖析
           PPCO_SAVE_TO_CONSOLE = 4,    //保存到控制台
           PPCO_SAVE_TO_FILE = 8,       //保存到文件
           PPCO_SAVE_BY_CALL_COUNT = 16,//按调用次数降序保存
           PPCO_SAVE_BY_COST_TIME=32,   //按调用花费时间降序保存

};

/////////////配置管理////////////////
class ConfigManager :public Singleton<ConfigManager >
{
public:
           void SetOptions(int flag)
          {
                   _flag = flag;
          }
          
           int GetOptions()
          {
                    return _flag;
          }

          ConfigManager()
                   :_flag( PPCO_PROFILER | PPCO_SAVE_TO_CONSOLE | PPCO_SAVE_TO_FILE)
          {}

private:
           int _flag;
};

///////////////获取路径中最后的文件名///////////////////
static string GetFileName(const string& path )
{
           char ch = ‘/‘ ;

#ifdef _WIN32
          ch = ‘\\‘;
#endif

           size_t pos = path .rfind(ch);//逆序查找
           if (pos == string ::npos)
          {
                    return path ;
          }
           else
          {
                    return path .substr(pos + 1);
          }
}

/////////性能剖析节点///////////
struct PPNode
{
           string _filename;//文件名
           string _function;//函数名
           int _line;       //行号
           string _desc;    //描述

          PPNode( const char * filename, const char * function, int line , const char * desc)
                   :_filename( filename)
                   , _function( function)
                   , _line( line)
                   , _desc( desc)
          {}

           bool operator<(const PPNode& node)const
          {
                    if (_line > node ._line)
                              return false ;
                    if (_line < node ._line)
                              return true ;
                    if (_filename > node ._filename)
                              return false ;
                    if (_filename < node ._filename)
                              return true ;
                    if (_function > node ._function)
                              return false ;
                    if (_function < node ._function)
                              return true ;
                    return false ;
          }

           //比较相等
           bool operator==(const PPNode& node)const
          {
                    return _function == node ._function
                             &&_line == node._line
                             &&_filename == node._filename;
          }

           //打印PPNode节点信息
           void Serialize(SaveAdapter & sa)const
          {
                    sa.Save("Filename:%s,Function:%s,Line:%d\n" , _filename.c_str(), _function.c_str(), _line);
          }
};

///////////////性能剖析段///////////////////////
struct PPSection
{
           friend class PerformanceProfiler;
public:
          PPSection()
                   :_beginTime(0)  
                   , _totalCostTime(0)  
                   , _totalCallCount(0)
                   , _totalRefCount(0)
          {}

           void Begin(int id)//开始函数
          {
                    lock_guard<mutex > lock(_mutex);
                   ++_callCountMap[ id];
                    if (_refCountMap[id ] == 0)
                   {
                             _beginTimeMap[ id] = clock();//计时函数
                   }
                   ++_refCountMap[ id];
                   ++_totalCallCount;
                   ++_totalRefCount;
          }

           void End(int id)
          {
                    lock_guard<mutex > lock(_mutex);
                    LongType refCount = --_refCountMap[id ];
                   --_totalRefCount; //先将总的引用计数减1
                    //引用计数<=0时，更新剖析段花费的时间
                    if (refCount <= 0)
                   {
                              map<int , LongType>:: iterator it = _beginTimeMap.find(id );
                              if (it != _beginTimeMap.end())
                             {
                                       LongType costTime = clock() - it->second;
                                       if (_refCountMap[id ] == 0)
                                      {
                                                _costTimeMap[ id] += costTime;
                                      }
                                       else
                                      {
                                                _costTimeMap[ id] = costTime;
                                      }
                                      _totalCostTime += costTime;

                             }
                   }
          }

           //线程打印信息
           void Serialize(SaveAdapter & sa)
          {
                    //如果总的引用计数不等于0，表示剖析段不匹配
                    if (_totalRefCount)
                              sa.Save("Performance Profiler Not Match!\n" );
                    //序列化效率统计信息
                    auto costTimeIt = _costTimeMap.begin();
                    for (; costTimeIt != _costTimeMap.end(); ++costTimeIt)
                   {
                              LongType callCount = _callCountMap[costTimeIt->first];
                              sa.Save("Thread Id:%d,Cost Time:%.2f,Call Count:%d\n",
                                      costTimeIt->first, (double)costTimeIt->second / CLOCKS_PER_SEC , callCount);
                   }
                    //CLOCKS_PER_SEC将clock函数时间转化为以秒为单位
                    sa.Save("Total CostTime:%.2f,Total Call Count:%d\n" ,
                             ( double)_totalCostTime / CLOCKS_PER_SEC , _totalCallCount);
          }
private:
           //加锁
           //<threadid,资源统计>
           //多个线程同时访问时，每个线程的开始时间，花费时间，访问次数都不相同
           map<int , LongType> _beginTimeMap;
           map<int , LongType> _costTimeMap;
           map<int , LongType> _callCountMap;
           map<int , LongType> _refCountMap; //利用引用计数方式解决递归时的计时问题
          
           //总的
           int _beginTime;//总的开始时间
           LongType _totalCostTime; //花费时间
           LongType _totalCallCount;//调用次数
           LongType _totalRefCount;//引用次数

           //锁
           mutex _mutex;
};

///////////获取当前线程id////////////////
static int GetThreadId()
{
#ifdef _WIN32
           return ::GetCurrentThreadId();
#else
           return ::thread_self();
#endif
}

//性能剖析器
class PerformanceProfiler :public Singleton<PerformanceProfiler >
{
public:
           friend class Singleton< PerformanceProfiler>;
           PPSection* CreateSection(const char* filename, const char * function,
                    int line, const char* desc);
           static void OutPut();

protected:
           static bool CompareByCallCount(map< PPNode, PPSection*>::iterator lhs, map< PPNode, PPSection *>::iterator rhs);
           static bool CompareByCostTime(map< PPNode, PPSection*>::iterator lhs, map< PPNode, PPSection *>::iterator rhs);

          PerformanceProfiler()
          {
                    //程序结束时输出剖析结果
                   atexit(OutPut);
                   time(&_beginTime);
          }

           //输出序列化信息
           //为了有效使用了vector能够调用sort排序，只要自己添加Compare仿函数
           void _Output(SaveAdapter & sa)
          {
                    sa.Save("=====================Performance Profiler Report====================\n\n");
                    sa.Save("Profiler Begin Time:%s\n",ctime(&_beginTime));
                    unique_lock<mutex > lock(_mutex);
                    vector<map <PPNode, PPSection*>::iterator > vInfos;

                    //PPSection作为查询值，里面保存运行时间，运行次数，开始时间和结束时间
                    auto it = _ppMap.begin();
                    for (; it != _ppMap.end(); ++it)
                   {
                             vInfos.push_back(it);
                   }
                   
                    //按配置条件对剖析结果进行排序输出
                    int flag = ConfigManager ::GetInstance()->GetOptions();
                    if (flag&PPCO_SAVE_BY_COST_TIME )
                             sort(vInfos.begin(), vInfos.end(), CompareByCostTime);
                    else
                             sort(vInfos.begin(), vInfos.end(), CompareByCallCount);
                    for (int index = 0; index < vInfos.size(); ++index)
                   {
                              sa.Save("NO%d. Delciption:%s\n" , index + 1, vInfos[index]->first._desc.c_str());
                             vInfos[index]->first.Serialize( sa);
                             vInfos[index]->second->Serialize( sa);
                              sa.Save("\n" );
                   }
                     sa.Save("================================end==============================\n\n" );
          }
private:
           map<PPNode , PPSection*> _ppMap;
           time_t _beginTime;
           mutex _mutex;
};

//////////atexit函数/////////
struct Release
{
          ~Release()
          {
                    PerformanceProfiler::GetInstance()->OutPut();
          }
};

/////性能剖析阶段开始/////
#define PERFORMANCE_PROFILER_EE_BEGIN (sign,desc)            PPSection* sign##section = NULL ;  if (ConfigManager::GetInstance()->GetOptions()&PPCO_PROFILER){          sign##section = PerformanceProfiler ::GetInstance()->CreateSection(__FILE__, __FUNCTION__, __LINE__ , desc);           sign##section->Begin(GetThreadId()); }

#define PERFORMANCE_PROFILER_EE_END (sign)  if (sign##section)          sign##section->End(GetThreadId());

//设置剖析选项
#define SET_PERFORMANCE_PROFILER_OPTIONS (flag)           ConfigManager::GetInstance()->SetOptions(flag);

###########################################################################################

PerformanceProfiler.cpp:

#include"performanceProfiler.h"

PPSection* PerformanceProfiler ::CreateSection(const char* filename, const char* function,
           int line , const char* desc )
{
           //第一次必须进行查找
           PPSection* pps = NULL ;
           PPNode node(filename , function, line, desc );
           unique_lock<mutex > lock(_mutex);

           map<PPNode , PPSection*> :: iterator it = _ppMap.find(node);
           if (it != _ppMap.end())
          {
                    return it->second;
          }
           else
          {
                   pps = new PPSection ;
                   _ppMap[node] = pps;
          }
           return pps;
}

void PerformanceProfiler ::OutPut()
{
           int flag = ConfigManager ::GetInstance()->GetOptions();
           if (flag&PPCO_SAVE_TO_CONSOLE )
          {
                    ConsoleSaveAdapter csa;
                    PerformanceProfiler::GetInstance()->_Output(csa);
          }
           if (flag&PPCO_SAVE_TO_FILE )
          {
                    FileSaveAdapter fsa("PerformanceProfilerReport.txt" );
                    PerformanceProfiler::GetInstance()->_Output(fsa);
          }
}

bool PerformanceProfiler ::CompareByCallCount(map< PPNode, PPSection*>::iterator lhs, map<PPNode , PPSection*>:: iterator rhs )
{
           return lhs ->second->_totalCallCount > rhs->second->_totalCallCount;
}

bool PerformanceProfiler ::CompareByCostTime(map< PPNode, PPSection*>::iterator lhs, map<PPNode , PPSection*>:: iterator rhs )
{
           return lhs ->second->_totalCostTime > rhs->second->_totalCostTime;
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

test.cpp:
void Run(int n)
{
           while(n --)
          {
                    PERFORMANCE_PROFILER_EE_BEGIN(ntwork, "网络传输" );
                   Sleep(1000);
                    PERFORMANCE_PROFILER_EE_END(ntwork);

                    PERFORMANCE_PROFILER_EE_BEGIN(mid, "中间逻辑" );
                   Sleep(500);
                    PERFORMANCE_PROFILER_EE_END(mid);

                    PERFORMANCE_PROFILER_EE_BEGIN(sql, "数据库" );
                   Sleep(500);
                    PERFORMANCE_PROFILER_EE_END(sql);
          }
}

void Test()
{
           thread t1(Run, 1);
           thread t2(Run, 2);
           thread t3(Run, 3);

          t1.join();
          t2.join();
          t3.join();
}

int main()
{
          Test();
           PerformanceProfiler::GetInstance()->OutPut();
          system( "pause");
           return 0;
}