How to time a methods execution using chrono in C++? - c++

Question

So this is the first time i've tried to do performance measuring and have followed some online resources to test a smaller version of my code before i try it on my coursework. Unfortunately i can't get it to print the time taken to complete the function and i'm not sure if i'm even doing it right.
#include <string>
#include <iostream>
#include <unordered_map>
#include <chrono>
using namespace std;
class Timer {
public:
Timer() {
startTimept = std::chrono::high_resolution_clock::now();
}
~Timer() {
Timer Stop();
}
void Stop() {
auto endTimept = std::chrono::high_resolution_clock::now();
auto start = std::chrono::time_point_cast<std::chrono::microseconds>(startTimept).time_since_epoch().count();
auto end = std::chrono::time_point_cast<std::chrono::microseconds>(endTimept).time_since_epoch().count();
auto duration = end - start;
double ms = duration * 0.001;
std::cout << duration << "us (" << ms << "ms)";
}
private:
std::chrono::time_point<std::chrono::high_resolution_clock> startTimept;
};
int main()
{
std::unordered_map<std::string, std::string>::iterator found, start, nFound;
//ADDS PAIRS OF SENTENCE INTO A MAP
std::unordered_map<std::string, std::string> sortMap =
{ { "these", "pairs" }, { "the", "correct" }, { "pairs", "makes" }, { "correct", "sentence" }, { "makes", "the" } };
std::unordered_map<std::string, std::string> swapMap =
{ { "pairs","these" }, {"correct", "the"}, { "makes", "pairs" }, {"sentence", "correct" }, {"the", "makes"} };
//CREATES CONTAINER TO STORE COMPLETE SENTENCE
std::list<std::string> resultSeq;
start = sortMap.begin();
//ADD STARTING WORDS INTO THE LIST
resultSeq.push_back(start->first);
resultSeq.push_back(start->second);
//TEMP POINTER TO SOUGHT WORD
found = sortMap.find(start->second);
//THIS IS THE FUNCTION I AM TRYING TO TEST
{
Timer timer();
for (auto it = sortMap.begin(); it != sortMap.end(); ++it) {
if (it == found) {
resultSeq.push_back(it->second);
found = sortMap.find(it->second);
it = sortMap.begin();
}
}
}
for (std::list<std::string>::iterator hard = resultSeq.begin(); hard != resultSeq.end(); ++hard)
{
std::cout << (*hard) << std::endl;
}
__debugbreak;
}
If anyone can spot what i'm doing wrong or offer any links to help with performance measuring that would be very helpful!

Answer 1

My personal approach, if it's just for quick debugging purposes, would be to use std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();. Since it's pretty wordy, I'd recommend making a wrapper function for it. Anyway, this simply returns the time in milliseconds since 1970 (not sure about that). Then you just stick one before the function and one after it, cout the difference and you have the milliseconds that the function took to execute.

Answer 2

You should use a std::steady_clock to measure time differences. The std::system_clock can be anything and does not need to be monotonic. The same goes for std::high_resolution_clock.
The high_resolution_clock is not implemented consistently across
different standard library implementations, and its use should be
avoided. It is often just an alias for std::chrono::steady_clock or
std::chrono::system_clock, but which one it is depends on the library
or configuration. When it is a system_clock, it is not monotonic
(e.g., the time can go backwards). For example, for gcc's libstdc++ it
is system_clock, for MSVC it is steady_clock, and for clang's libc++
it depends on configuration.
Further, to encapsulate time measuring, you can take advantage of C++'s RAII mechanism:
#include <chrono>
#include <type_traits>
#include <iostream>
template <typename Resolution = std::chrono::duration<double,std::micro>>
class Stopwatch {
typedef std::chrono::steady_clock Clock;
private:
std::chrono::time_point<Clock> last;
public:
void reset() noexcept {
last = Clock::now();
}
Stopwatch() noexcept {
reset();
}
auto operator()() const noexcept {// returns time in Resolution
return Resolution(Clock::now() - last).count();
}
~Stopwatch() {
// bad encapulation, you should reconsider this design!
// e.g. take a std::function as argument to the constructor and call it here
std::cout << (*this)() << "\n";
}
};
int main() {
{ // the block I want to measure
Stopwatch sw;
(void)(1+2+3); // some costly operation
} // end of measured block
}