一个简单的C++性能测试工具(ms级别)

C++11或以上编译器，实现ms级计数，参考下面的代码

#include 
...
		unsigned short _hour;
		unsigned short _minute;
		float          _second;
...		
		[](unsigned short &_hour,
			unsigned short &_minute,
			float &_second) {
			using namespace std::chrono;
			auto time_now = system_clock::now();
			auto duration_in_ms = duration_cast(time_now.time_since_epoch());//从1970年开始
			auto ms = duration_in_ms.count();//获取毫秒级时间戳   //https://www.epochconverter.com/
			//auto milli = ms + 8 * 60 * 60 * 1000;//此处转化为东八区北京时间，如果是其它时区需要按需求修改

			auto partial_ms = ms % 1000;//只取毫秒部份

			auto tt = system_clock::to_time_t(time_now);
			struct tm* ptm = localtime(&tt);

			_hour = ptm->tm_hour;
			_minute = ptm->tm_min;
			_second = ptm->tm_sec + partial_ms / 1000.0;
		}(_hour, _minute, _second);
...

C++11前，老的编译器，实现ms级计数，参考下面的代码。

#include "sperformance.h"

#include 
#include 

int main(int argc, char** argv)
{
	kagula::PerformanceTest pt;
	
	{
		pt.start();
		boost::this_thread::sleep(boost::posix_time::milliseconds(0));
		pt.stop();

		std::cout << "First time:" << pt.toString() << std::endl << std::endl;
	}


	{
		pt.start();
		boost::this_thread::sleep(boost::posix_time::milliseconds(100));
		pt.stop();

		std::cout << "Second time:" << pt.toString() << std::endl << std::endl;
	}


	{
		pt.start();
		boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
		pt.stop();

		std::cout << "Third time:" << pt.toString() << std::endl << std::endl;
	}

	std::cin.get();

	return 0;
}

 

依赖的头文件

#ifndef _SPERFORMANCE_H_
#define _SPERFORMANCE_H_

#include 
#include 

#include 
#include    

namespace kagula
{
	/*
	* Title:
	* Description:
	* 以毫秒(Millisecond)为单位测试程序代码段的运行时间。
	* Dependencies: boost 1.61
	* Test Environment: VS2013 Update5
	* Remark: 
	* [1]计量单位ms
	* [2]优点:[a]使用简单[2]只依赖boost，可以跨平台.
	* */
	struct PerformanceTest
	{
		PerformanceTest() :m_lastFPS(.0f),
			m_minElapsedTime(1000.0f), m_maxElapsedTime(.0f), m_lastElapsedTime(.0f){}
		std::string toString();

		void start();
		void stop();

		float getMinFPS();
		float getMaxFPS();
		float getLastFPS();
		float getAvgFPS();

		float getElapsedTime();
		float getAvgTime();
	private:
		float m_minFPS;
		float m_maxFPS;
		float m_lastFPS;
		float m_avgFPS;


		float m_minElapsedTime;////milli second unit
		float m_maxElapsedTime;
		float m_avgElapsedTime;
		float m_lastElapsedTime;

		std::list m_listHistoryElapsedTime;

		void setInMilliSecond(unsigned long long milliSecond);

		boost::mutex m_mutexRW;
		boost::posix_time::ptime m_timeStart;
	};

	//std::string GetCurrentTime();
}
#endif

 

依赖的实现文件

#include "sperformance.h"

#include 
#include 

namespace kagula
{
	void PerformanceTest::start()
	{
		m_timeStart = boost::posix_time::microsec_clock::universal_time();
	}

	void PerformanceTest::stop()
	{
		boost::posix_time::ptime timeStop = boost::posix_time::microsec_clock::universal_time();

		boost::posix_time::millisec_posix_time_system_config::time_duration_type timeElapsed;
		timeElapsed = timeStop - m_timeStart;

		unsigned long long llElapsedTime = timeElapsed.total_milliseconds();

		setInMilliSecond(llElapsedTime);
	}

	void PerformanceTest::setInMilliSecond(unsigned long long milliSecond)
	{
		boost::lock_guard lock(m_mutexRW);

		//Prevent division zero error.
		if (milliSecond <= 0)
			milliSecond = 1;

		m_lastElapsedTime = milliSecond;

		//
		if (m_minElapsedTime > milliSecond)
			m_minElapsedTime = milliSecond;

		m_maxFPS = 1000 / m_minElapsedTime;

		//
		if (m_maxElapsedTime < milliSecond)
			m_maxElapsedTime = milliSecond;

		m_minFPS = 1000 / m_maxElapsedTime;

		//
		m_lastFPS = 1000 / (float)milliSecond;

		//
		m_listHistoryElapsedTime.push_back(m_lastElapsedTime);

		std::list::iterator iter = m_listHistoryElapsedTime.begin();
		float fTemp = .0f;
		while (iter != m_listHistoryElapsedTime.end())
		{
			fTemp += *iter;

			iter++;
		}

		m_avgElapsedTime = fTemp / m_listHistoryElapsedTime.size();
		m_avgFPS = 1000 / m_avgElapsedTime;

		if (m_listHistoryElapsedTime.size() > 1024)
		{
			m_listHistoryElapsedTime.pop_front();
			//http://www.cplusplus.com/reference/list/list/pop_front/
		}
	}//end function

	std::string PerformanceTest::toString()
	{
		boost::lock_guard lock(m_mutexRW);

		std::stringstream ss;

		ss << "Last elapsed time is " << std::setw(5) << std::setprecision(2) << std::fixed\
			<< m_lastElapsedTime \
			<< "ms, last fps is " << m_lastFPS\
			<< " ,minimum elapsed time is " << m_minElapsedTime \
			<< "ms, maximum elapsed time is " << m_maxElapsedTime\
			<< "ms, avelage elapsed time is " << m_avgElapsedTime\
			<< "ms, average fps is " << m_avgFPS;

		return ss.str();
	}


	float PerformanceTest::getElapsedTime()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_lastElapsedTime;
	}

	float PerformanceTest::getAvgTime()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_avgElapsedTime;
	}

	float PerformanceTest::getAvgFPS()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_avgFPS;
	}

	float PerformanceTest::getMinFPS()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_minFPS;
	}

	float PerformanceTest::getMaxFPS()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_maxFPS;
	}

	float PerformanceTest::getLastFPS()
	{
		boost::lock_guard lock(m_mutexRW);
		return m_lastFPS;
	}

	boost::mutex g_mutexGetCurrentTime;
	std::string GetCurrentTime()
	{
		boost::lock_guard lock(g_mutexGetCurrentTime);
		//下面这段代码可能会导致boost::log多线程冲突问题
		boost::posix_time::time_facet* p_tfacet = new boost::posix_time::time_facet("%Y-%m-%d %H:%M:%S%F");
		std::stringstream ss;
		ss.imbue(std::locale(ss.getloc(), p_tfacet));
		ss << "[" << boost::posix_time::microsec_clock::local_time() << "]: ";

		return ss.str();
	}
}