Re: Profiler class, suggestions and comments welcome
On Aug 20, 11:59 pm, Francesco <entul...@gmail.com> wrote:
On 20 Ago, 13:32, Francesco <entul...@gmail.com> wrote:
On 20 Ago, 10:49, James Kanze <james.ka...@gmail.com> wrote:
On Aug 19, 8:21 pm, Francesco <entul...@gmail.com> wrote:
namespace profiler {
class Profile {
public:
Profile(const std::string& sid)
: id(sid), start_time(clock()) {}
Does this really have to be inline.
I don't know, maybe I'll try to profile it to check whether
it makes any difference.
Thinking again I've got your question right. You didn't mean
whether it made any difference, but whether the savings where
signifying.
Exactly. Or more to the point, whether you knew that it would
make a significant difference.
I used my profiler onto the two ctor versions using this code:
-------
#include "profiler_utils.h" // 3rd version as posted before
using namespace profiler_utils;
using namespace std;
struct inline_ctor {
string s;
clock_t t;
inline_ctor(const string& rs = "") : s(rs), t(clock()) {}
};
struct separate_ctor {
string s;
clock_t t;
separate_ctor(const string& = "");
};
const size_t arr_max = 10000;
template<class T> void test(const string& s) {
Profiler p(s);
T* ptr = new T[arr_max];
for(size_t i = 0; i < arr_max; ++i) {
ptr[i] = T("text");
}
delete[] ptr;
}
Note that for such a small array, the allocation could easily
take up a significant amount of time, and affect your
measurements. And that your new T[ arr_max ] also calls the
default constructor. And that your loop includes an assignment
operator as well. Also, a good compiler will note that elements
in the array are never accessed after the assign, and end up
suppressing the entire loop.
Benchmarking is a tricky art---you want the compiler to apply
all relevant optimizations, but not to optimize away what you're
actually trying to measure. My BenchHarness class uses a
virtual function to encapsulate what I'm trying to measure; in
the base class, this function is empty, and in the derived
classes, I put the code I'm trying to measure. When I set the
iteration count (via a static member function in BenchHarness),
I run the test on the base class, and save the results (which
correspond to the time necessary to call the empty function).
When I run benchmarks with the derived classes, I subtract this
saved value from the total, so that (hopefully), I end up with
only the time taken for what I'm trying to measure. And at
least with the compilers I generally use, calling through a
virtual function seems to stump the optimizer, so my loops don't
get optimized out. I also run each test once immediately before
starting the measurements, so that I'm not measuring cache
misses the first time through.
separate_ctor::separate_ctor(const string& rs) : s(rs), t(clock()) {}
Given that this definition is in the same file, a lot (most?)
compilers will generate it inline anyway. (There are some
compilers which will generate it inline even if the definition
is in a different file, but they aren't legion.)
int main() {
for(size_t i = 0; i < arr_max; ++i) {
test<separate_ctor>("separate");
test<inline_ctor>("inline");
}
report(cout);
return 0;}
-------
Here is the output I got:
---[ profiler report ]---
Id: inline
Avg time: 14.752 msecs
Total time: 147520 msecs
Calls count: 10000
Id: separate
Avg time: 15.2241 msecs
Total time: 152241 msecs
Calls count: 10000
---[ end report ]--------
Now the problem is: how should I interpret this result?
If I got it right, this means that the inline ctor beats the
the separated one by just...
(15.2241 - 14.752) / 20000 == 0.000023605 milliseconds per constructo=
r
call
That's about 24 nanoseconds. That sounds about right for the
cost of a function call on a modern machine. On the other hand,
the difference in the measurements is about 3%. I'm not sure
your harness provides that sort of precision.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34