Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	src/micro_benchmark_rdtsc_impl.h	Lines:	26	27	96.3 %
Date:	2025-03-16 06:08:08	Branches:	36	38	94.7 %


/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#ifndef __MICRO_BENCHMARK_RDTSC_IMPL_H__
#define __MICRO_BENCHMARK_RDTSC_IMPL_H__

#include "phoenix_timer.h"
#include "micro_benchmark_rdtsc.h"

///Do the micro benchmarking of a given function and gives performance results in cy
/**	@param[out] ellapsedTimeCy : ellapsed time in cy
 * 	@param[out] ellapsedTimeErrorCy : error on the ellapsed time in cy
 * 	@param nbTestPerf : number of performance test
 * 	@param nbCallPerTest : number of calls per performance test
 * 	@param __f : function to be called and benchmarked
 * 	@param __args : parameter of the function to be benchmarked
*/
template<typename _Callable, typename... _Args>
void micro_benchmarkRdtsc(double & ellapsedTimeCy, double & ellapsedTimeErrorCy, size_t nbTestPerf, size_t nbCallPerTest,
			_Callable&& __f, _Args&&... __args)
{
	VecEllapsedTime vecTimeCy;
	for(size_t i(0lu); i < nbTestPerf; ++i){
		//Stating the timer
		size_t beginTime = phoenix_rdtsc();
		for(size_t j(0lu); j < nbCallPerTest; ++j){
			__f(__args...);
		}
		//Get the time of the nbCallPerTest calls
		size_t elapsedTime(phoenix_rdtsc() - beginTime);
		double fullCy(elapsedTime/((double)nbCallPerTest));
		vecTimeCy.push_back(fullCy);
	}
	MapOrderedTime mapOrderTime;
	micro_benchmarkVecToMap(mapOrderTime, vecTimeCy);
	size_t nbValueUsed(vecTimeCy.size()*0.7 + 1lu);
	if(nbValueUsed > vecTimeCy.size()){
		nbValueUsed = vecTimeCy.size();
	}
	micro_benchmarkComputeTime(ellapsedTimeCy, ellapsedTimeErrorCy, mapOrderTime, nbValueUsed);
}

///Do the micro benchmarking of a given function and gives performance results in cy
/**	@param[out] ellapsedTimeCy : ellapsed time in cy
 * 	@param[out] ellapsedTimeErrorCy : error on the ellapsed time in cy
 * 	@param[out] timePerElement : time per element in cy
 * 	@param[out] timeErrorPerElement : error of time per element in cy
 * 	@param nbTestPerf : number of performance test
 * 	@param nbCallPerTest : number of calls per performance test
 * 	@param nbElement : number of element treated by the function __f
 * 	@param __f : function to be called and benchmarked
 * 	@param __args : parameter of the function to be benchmarked
*/
template<typename _Callable, typename... _Args>
void micro_benchmarkRdtsc(double & ellapsedTimeCy, double & ellapsedTimeErrorCy,
			double & timePerElement, double & timeErrorPerElement, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement,
			_Callable&& __f, _Args&&... __args)
{
	micro_benchmarkRdtsc(ellapsedTimeCy, ellapsedTimeErrorCy, nbTestPerf, nbCallPerTest, __f, __args...);
	timePerElement = ellapsedTimeCy/((double)nbElement);
	timeErrorPerElement = ellapsedTimeErrorCy/((double)nbElement);
}

///Do the micro benchmarking of a given function and gives performance results in cy and print the result
/**	@param testName : name of the performance test
 * 	@param nbTestPerf : number of performance test
 * 	@param nbCallPerTest : number of calls per performance test
 * 	@param nbElement : number of element treated by the function __f
 * 	@param __f : function to be called and benchmarked
 * 	@param __args : parameter of the function to be benchmarked
*/
template<typename _Callable, typename... _Args>
void micro_benchmarkRdtscPrint(const std::string & testName, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement, _Callable&& __f, _Args&&... __args){
	double ellapsedTimeCy(0.0), ellapsedTimeErrorCy(0.0), timePerElement(0.0), timeErrorPerElement(0.0);
	micro_benchmarkRdtsc(ellapsedTimeCy, ellapsedTimeErrorCy, timePerElement, timeErrorPerElement, nbTestPerf, nbCallPerTest, nbElement, __f, __args...);

	std::cout << testName << " : nbElement = "<<nbElement<<", timePerElement = " << timePerElement << " cy/el ± "<<timeErrorPerElement<<", elapsedTime = " << ellapsedTimeCy << " cy ± "<<ellapsedTimeErrorCy << std::endl;
	std::cerr << nbElement << "\t" << timePerElement << "\t" << ellapsedTimeCy << "\t" << timeErrorPerElement << "\t" << ellapsedTimeErrorCy << std::endl;
}


#endif


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/***************************************
2			Auteur : Pierre Aubert
3			Mail : pierre.aubert@lapp.in2p3.fr
4			Licence : CeCILL-C
5			****************************************/
6
7			#ifndef __MICRO_BENCHMARK_RDTSC_IMPL_H__
8			#define __MICRO_BENCHMARK_RDTSC_IMPL_H__
9
10			#include "phoenix_timer.h"
11			#include "micro_benchmark_rdtsc.h"
12
13			///Do the micro benchmarking of a given function and gives performance results in cy
14			/** @param[out] ellapsedTimeCy : ellapsed time in cy
15			* @param[out] ellapsedTimeErrorCy : error on the ellapsed time in cy
16			* @param nbTestPerf : number of performance test
17			* @param nbCallPerTest : number of calls per performance test
18			* @param __f : function to be called and benchmarked
19			* @param __args : parameter of the function to be benchmarked
20			*/
21			template<typename _Callable, typename... _Args>
22		30	void micro_benchmarkRdtsc(double & ellapsedTimeCy, double & ellapsedTimeErrorCy, size_t nbTestPerf, size_t nbCallPerTest,
23			_Callable&& __f, _Args&&... __args)
24			{
25		60	VecEllapsedTime vecTimeCy;
26	✓✓	12030	for(size_t i(0lu); i < nbTestPerf; ++i){
27			//Stating the timer
28	✓	12000	size_t beginTime = phoenix_rdtsc();
29	✓✓	7212000	for(size_t j(0lu); j < nbCallPerTest; ++j){
30	✓	7200000	__f(__args...);
31			}
32			//Get the time of the nbCallPerTest calls
33	✓	12000	size_t elapsedTime(phoenix_rdtsc() - beginTime);
34		12000	double fullCy(elapsedTime/((double)nbCallPerTest));
35	✓	12000	vecTimeCy.push_back(fullCy);
36			}
37	✓✗	36	MapOrderedTime mapOrderTime;
38	✓	30	micro_benchmarkVecToMap(mapOrderTime, vecTimeCy);
39	✓	30	size_t nbValueUsed(vecTimeCy.size()*0.7 + 1lu);
40	✗✓	30	if(nbValueUsed > vecTimeCy.size()){
41			nbValueUsed = vecTimeCy.size();
42			}
43	✓	30	micro_benchmarkComputeTime(ellapsedTimeCy, ellapsedTimeErrorCy, mapOrderTime, nbValueUsed);
44		30	}
45
46			///Do the micro benchmarking of a given function and gives performance results in cy
47			/** @param[out] ellapsedTimeCy : ellapsed time in cy
48			* @param[out] ellapsedTimeErrorCy : error on the ellapsed time in cy
49			* @param[out] timePerElement : time per element in cy
50			* @param[out] timeErrorPerElement : error of time per element in cy
51			* @param nbTestPerf : number of performance test
52			* @param nbCallPerTest : number of calls per performance test
53			* @param nbElement : number of element treated by the function __f
54			* @param __f : function to be called and benchmarked
55			* @param __args : parameter of the function to be benchmarked
56			*/
57			template<typename _Callable, typename... _Args>
58		30	void micro_benchmarkRdtsc(double & ellapsedTimeCy, double & ellapsedTimeErrorCy,
59			double & timePerElement, double & timeErrorPerElement, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement,
60			_Callable&& __f, _Args&&... __args)
61			{
62		30	micro_benchmarkRdtsc(ellapsedTimeCy, ellapsedTimeErrorCy, nbTestPerf, nbCallPerTest, __f, __args...);
63		30	timePerElement = ellapsedTimeCy/((double)nbElement);
64		30	timeErrorPerElement = ellapsedTimeErrorCy/((double)nbElement);
65		12	}
66
67			///Do the micro benchmarking of a given function and gives performance results in cy and print the result
68			/** @param testName : name of the performance test
69			* @param nbTestPerf : number of performance test
70			* @param nbCallPerTest : number of calls per performance test
71			* @param nbElement : number of element treated by the function __f
72			* @param __f : function to be called and benchmarked
73			* @param __args : parameter of the function to be benchmarked
74			*/
75			template<typename _Callable, typename... _Args>
76		30	void micro_benchmarkRdtscPrint(const std::string & testName, size_t nbTestPerf, size_t nbCallPerTest, size_t nbElement, _Callable&& __f, _Args&&... __args){
77		30	double ellapsedTimeCy(0.0), ellapsedTimeErrorCy(0.0), timePerElement(0.0), timeErrorPerElement(0.0);
78	✓	30	micro_benchmarkRdtsc(ellapsedTimeCy, ellapsedTimeErrorCy, timePerElement, timeErrorPerElement, nbTestPerf, nbCallPerTest, nbElement, __f, __args...);
79
80	✓✓✓✓ ✓✓✓✓ ✓✓✓✓	30	std::cout << testName << " : nbElement = "<<nbElement<<", timePerElement = " << timePerElement << " cy/el ± "<<timeErrorPerElement<<", elapsedTime = " << ellapsedTimeCy << " cy ± "<<ellapsedTimeErrorCy << std::endl;
81	✓✓✓✓ ✓✓✓✓ ✓✓	30	std::cerr << nbElement << "\t" << timePerElement << "\t" << ellapsedTimeCy << "\t" << timeErrorPerElement << "\t" << ellapsedTimeErrorCy << std::endl;
82		30	}
83
84
85			#endif