a4z_blog_2017_07_11_v1, C++ (gcc)

Language: Layout:

#include <iostream>
#include <chrono>

class StopWatch
{
public:

void start()
  {
    //Expects(not started) ;
    started=true ;
    start_time = std::chrono::system_clock::now();
  }

std::chrono::nanoseconds stop()
  {
    using namespace std::chrono ;
    auto end_time = system_clock::now();
    //Expects(started) ;
    started = false ;
    return duration_cast<nanoseconds>(end_time -start_time) ;
  }

private:
  decltype(std::chrono::system_clock::now()) start_time ;
  bool started{false} ;
};

template<typename ResultType>
struct TimedCallResult
{
  std::chrono::nanoseconds duration ;
  ResultType return_value;

};

template<>
struct TimedCallResult<void>
{
  std::chrono::nanoseconds duration ;
};

namespace details
{
  template<typename ResultType, typename Invokable, typename... Args>
  struct
  TimedCall
  {
    auto operator()(Invokable f, Args&&... args)
      ->TimedCallResult<ResultType>
    {
      using namespace std::chrono ;
      auto start = system_clock::now();
      TimedCallResult<ResultType> r{ nanoseconds{0},
                                     f(std::forward<Args>(args)...)} ;

r.duration = duration_cast<nanoseconds>(system_clock::now() - start);
      return r ;
    }
  };

template<typename Invokable, typename... Args>
  struct
  TimedCall<void,Invokable, Args...>
  {
    auto operator()(Invokable f, Args&&... args)
     ->TimedCallResult<void>
    {
      using namespace std::chrono ;
      auto start = system_clock::now();
      f(std::forward<Args>(args)...) ;

return {duration_cast<nanoseconds>(system_clock::now() - start)} ;
    }
  };
}

template<typename Invokable, typename... Args>
auto
timed_call(Invokable f, Args&&... args)
->  TimedCallResult<decltype(f(std::forward<Args>(args)...))>
{
  using ResultType = decltype(f(std::forward<Args>(args)...));
  details::TimedCall<ResultType ,Invokable, Args...> meassure;
  return meassure(f, std::forward<Args>(args)...) ;
}

void f1(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
void f2(int){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
int  f3(){ std::cout << __PRETTY_FUNCTION__ << std::endl; return 0 ;}
int f4(int x, int y){ std::cout << __PRETTY_FUNCTION__ << std::endl; return x +y ;}
auto f5 = [](int x){ return x+1 ;} ;
template<typename T> T sum(const T& a, const T& b) { return a + b ;}

int
main (void)
{
   auto tcr1 = timed_call(f1) ;
   std::cout << tcr1.duration.count() << std::endl;

auto tcr2 = timed_call(f2, 1) ;
   std::cout << tcr2.duration.count() << std::endl;

auto tcr3 = timed_call(f3) ;
   std::cout << tcr3.duration.count() << " " <<  tcr3.return_value <<std::endl;

auto tcr4 = timed_call(f4, 2, 3) ;
   std::cout << tcr4.duration.count() << " " <<  tcr4.return_value <<std::endl;

auto tcr5 = timed_call(f5,1) ;
   std::cout << tcr5.duration.count() << " " <<  tcr5.return_value <<std::endl;

auto tcr6 = timed_call(sum<int>,1,2) ;
   std::cout << tcr6.duration.count() << " " <<  tcr6.return_value <<std::endl;

StopWatch sw ;
   sw.start() ;
   std::cout << "This took now " << sw.stop().count() << " nanoseconds" <<std::endl ;
   return 0 ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.42 sec, absolute running time: 0.06 sec, cpu time: 0.01 sec, memory peak: 3 Mb, absolute service time: 0,49 sec