Using RAII idiom for profiling

The RAII is a well-known C++ idiom. The idea is simple and great at the same time. Two things in life are certain: birth and death. If you are wondering about taxes, please don't forget that I am Italian and in my country taxes are not mandatory.

In object oriented world birth means constructor. The constructor is the first function called when we create it, so it is a wonderful place to allocate a resource. Death means destructor, when a object goes out of scope the destructor is always called (of course if you leak the resource the destructor is not called). That's great, the destructor is the perfect place to release the memory.

Check this link for more information on RAII. What I am going to show you is a very simple class that implement this idiom to get profiling information.

Profiling

If you need to make your application go faster you need to know where your application is actually performing worst. DON'T SPECULATE! The developer are not good to guess where an application is going slow, if they were good the there wouldn't be slow applications.

Profiling is tedious, you need to put extra debug output everywhere, check the result and at the end remove them from the code (of course you can use a profiling tool, but sometimes the learning curve is so big that it is better using trivial way).

The RAII idiom will rescue us, have a look at this class:

1. #ifndef _PROFILER_H_
2. #define _PROFILER_H_
4. #include <string>
5. #include <iostream>
6. #include <sys/time.h>
8. using std::string;
9. using std::ostream;
11. namespace BitingCpp
12. {
13.     class Profiler
14.     {
15.         public:
16.             Profiler(string what,
17.                      ostream& out = std::cout,
18.                      bool verbose = false);
19.             ~Profiler(); /* throw() */
20.         private:
21.             Profiler(const Profiler& rhs);
22.             Profiler& operator=(const Profiler& rhs);
23.             string what_;
24.             timeval start_;
25.             timeval end_;
26.             ostream& out_;
27.             bool verbose_;
28.     };
29. } //namespace BitingCpp
31. #endif

As you can see the class provides only constructor and destructor. The copies are not allowed. There are some private member and this is the implementation file:

1. #include "Profiler.h"
2. using std::endl;
4. namespace BitingCpp
5. {
6.     Profiler::Profiler(string what,ostream& out,
7.                                 bool verbose) :
8.                                 what_(what), start_(),
9.                                 end_(),out_(out),verbose_(verbose)
10.     {
11.         gettimeofday(&start_,0);
12.         if (verbose_)
13.             out_ << "Begin of " << what_ << " at " << start_.tv_sec
14.                  << " s " << start_.tv_usec << " us" << endl;
15.     }
16.        
17.     Profiler::~Profiler() /* throw() */
18.     {
19.         try
20.         {
21.             gettimeofday(&end_,0);
22.             if (verbose_)
23.                 out_ << "End of " << what_ << " at " << end_.tv_sec
24.                      << " s " << end_.tv_usec << " us" << endl;
25.            
26.             double timems =
27.               ((static_cast<double>(end_.tv_sec - start_.tv_sec))
28.               *1000.0 + ((end_.tv_usec - start_.tv_usec)/1000.0));
29.             out_ << what_ << " running time: "
30.                  << timems  << " ms " << endl;
31.         }
32.         catch(...) {} // to avoid core dump during the stack unwind!
33.     }
34. } //namespace BitingCpp

The constructor stores the timestamp of creation (and print an optional statement) and the destructor makes a simple calculation and print the result.

This small program shows how to use this class:

1. #include <iostream>
2. #include "Profiler.h"
4. int main (int argc, char *argv[])
5. {
6.     BitingCpp::Profiler mainProfile(__FUNCTION__);
7.    
8.     BitingCpp::Profiler* justFirstLongLoop =
9.        new BitingCpp::Profiler("Just First Long Loop");
10.    
11.     int j = 0;
12.     for (int i=0; i < 10000000; i++)
13.         j += i*i;
14.        
15.     delete justFirstLongLoop; // trigger the deconstructor
17.     BitingCpp::Profiler anotherBigLoop("Another Big Loop");
18.     j = 0;
19.     for (int i=0; i < 10000000; i++)
20.         j += i*i;
21.    
22.    
23.     return 0; // anotherBigLoop goes out of
24. }             // scope first and then mainProfile

The output of this program is something like that:

Just First Long Loop running time: 52.852 ms
Another Big Loop running time: 52.435 ms
main running time: 105.829 ms

Now it is clear why the copies are not allowed, what does copying a Profiler object mean? The Profiler keeps track of its date of birth (actually a timeval structure). If I copy a Profiler object which date of birth should the new object have? The same of the first one or the time stamp of the copy operation? Too many question and furthermore I cannot see the point to make a copy of a Profiler object in the first place.

Note: the code is working on UNIX platform. You can easily change the implementation file to use Windows functions. __FUNCTION__ macro should be pretty much cross platform, I don't think it is already in the standard, but I am sure is widely supported.