How to add timer to every method of class? - c++

Question

How to 'implicitly' add some sort of timer for every method of class, excluding constructor and destructor?
What I'm doing now for every method of class:
void MyClass::SomeFunc()
{
cout << __PRETTY_FUNCTION__ <<endl;
boost::timer::cpu_timer timer;
//Some code
boost::timer::cpu_times elapsed = timer.elapsed();
cout << __PRETTY_FUNCTION__ << " : WALLCLOCK TIME: " << elapsed.wall / 1e9 << " seconds" << endl;
}
What I want:
void MyClass::SomeFunc()
{
//Some code
}
assuming behaviour of this two parts of code should be equivalent.

Answer 1

You can almost achieve this using RAII:
struct FunctionLogger {
FunctionLogger(const char* func)
: m_func(func)
{
cout << func <<endl;
}
~FunctionLogger() {
boost::timer::cpu_times elapsed = timer.elapsed();
GSULOG << m_func << " : WALLCLOCK TIME: " << elapsed.wall / 1e9 << " seconds" << endl;
}
const char* m_func;
boost::timer::cpu_timer timer;
};
Now:
void MyClass::SomeFunc()
{
FunctionLogger _(__PRETTY_FUNCTION__);
//Some code
}
And of course if you like macros:
#define FL FunctionLogger _(__PRETTY_FUNCTION__)
void MyClass::SomeFunc()
{
FL;
//Some code
}
If you are looking for an industrial-grade solution for this sort of thing, the term of art is Aspect Oriented Programming. But it's not directly supported by C++.

Answer 2

What you are trying to do is known as known as profiling (getting the duration of each function call) and instrumentation (injecting code into the functions to get more detailed, but probably less accurate, timing information).
By far the best way of doing this is by not doing it yourself, but by running your code under a profiler (an off-the-shelf application which does the timing and, optionally, instrumentation automatically, all without polluting your source code.)

Answer 3

If you want to avoid modifying code, and are willing to sacrifice that __PRETTY_FUNCTION__ output. You can achieve this by accessing the class through a timing handle.
First you define a RAII class for timing, kind of like in John Zwinck's answer:
template<typename T>
struct TimingDecorator {
T *ptr_;
boost::timer::cpu_timer timer;
TimingDecorator (T* ptr) : ptr_(ptr) {}
~TimingDecorator () {
boost::timer::cpu_times elapsed = timer.elapsed();
GSULOG << " : WALLCLOCK TIME: " << elapsed.wall / 1e9 << " seconds" << endl;
}
T* operator->() { return ptr_; }
T const * operator->() const { return ptr_; }
};
Then you define a handle that forces all access to the class through the decorator:
template<typename T>
struct TimingHandle {
T &obj_;
boost::timer::cpu_timer timer;
TimingHandle (T const& obj) : obj_(obj) {}
TimingDecorator<T> operator->() { return &obj_; }
TimingDecorator<T const> operator->() const { return &obj_; }
};
And then for timing you do all access through the handle:
MyClass obj;
TimingHandle<MyClass> obj_timing(obj);
GSULOG << "MyClass::SomeFunc" << endl;
obj_timing->SomeFunc();
I should point out that the last two lines can be wrapped in a macro (if you don't mind using one), to avoid repeating yourself.
#define MYCLASS_TIME_FUNC(handle, func) \
GSULOG << "MyClass::" #func << endl; \
(handle)->func
Which you ultimately can use as
MYCLASS_TIME_FUNC(obj_timing, SomeFunc2)(/* params for SomeFunc2 */);

Answer 4

Reversing the initiatives a bit you can also use:
template <typename Caption, typename F>
auto timed(Caption const& task, F&& f) {
return [f=std::forward<F>(f), task](auto&&... args) {
using namespace std::chrono;
struct measure {
high_resolution_clock::time_point start;
Caption task;
~measure() { GSU_LOCK << " -- (" << task << " completed in " << duration_cast<microseconds>(high_resolution_clock::now() - start).count() << "µs)\n"; }
} timing { high_resolution_clock::now(), task };
return f(std::forward<decltype(args)>(args)...);
};
}
Which you can use like: Live On Coliru
timed_rand = time("Generate a random number", &::rand);
for (int i = 0; i<10; ++i)
std::cout << timed_rand() << " ";
With a bit of MACRO help you can make it even more verstatile to use:
Live On Coliru
#include <iostream>
#include <chrono>
using namespace std::literals::string_literals;
#define GSU_LOG std::clog
template <typename Caption, typename F>
auto timed(Caption const& task, F&& f) {
return [f=std::forward<F>(f), task](auto&&... args) -> decltype(auto) {
using namespace std::chrono;
struct measure {
high_resolution_clock::time_point start;
Caption task;
~measure() { GSU_LOG << " -- (" << task << " completed in " << duration_cast<microseconds>(high_resolution_clock::now() - start).count() << "µs)\n"; }
} timing { high_resolution_clock::now(), task };
return f(std::forward<decltype(args)>(args)...);
};
}
#define TIMED(expr) (timed(__FILE__ + (":" + std::to_string(__LINE__)) + " " #expr, [&]() -> decltype(auto) {return (expr);})())
int main() {
std::string line;
while (TIMED(std::getline(std::cin, line))) {
std::cout << "Simple arithmetic: " << TIMED(42 * TIMED(line.length())) << "\n";
}
}
Prints
$ clang++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp
$ for a in x xx xxx; do sleep 0.5; echo "$a"; done | ./a.out
-- (main.cpp:25 std::getline(std::cin, line) completed in 497455µs)
-- (main.cpp:26 line.length() completed in 36µs)
-- (main.cpp:26 42 * TIMED(line.length()) completed in 106µs)
Simple arithmetic: 42
-- (main.cpp:25 std::getline(std::cin, line) completed in 503516µs)
-- (main.cpp:26 line.length() completed in 14µs)
-- (main.cpp:26 42 * TIMED(line.length()) completed in 42µs)
Simple arithmetic: 84
-- (main.cpp:25 std::getline(std::cin, line) completed in 508554µs)
-- (main.cpp:26 line.length() completed in 14µs)
-- (main.cpp:26 42 * TIMED(line.length()) completed in 38µs)
Simple arithmetic: 126
-- (main.cpp:25 std::getline(std::cin, line) completed in 286µs)
Note you could also make the lambda accumulate data for different calls and report the totals/average.