microbenchmark.hpp

Go to the documentation of this file.

/*
  MICROBENCHMARK.hpp  -  multithreaded timing measurement

   Copyright (C)
     2018,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_TEST_MICROBENCHMARK_H
#define LIB_TEST_MICROBENCHMARK_H


#include "lib/meta/function.hpp"
#include "lib/scoped-collection.hpp"
#include "lib/sync-barrier.hpp"
#include "lib/thread.hpp"

#include "lib/test/microbenchmark-adaptor.hpp"

#include <chrono>



namespace lib {
namespace test{
  
  namespace {
    constexpr size_t DEFAULT_RUNS = 10'000'000;
    using CLOCK_SCALE = std::micro;          // Results are in µ-sec
  }
  
  
  template<class FUN>
  inline double
  benchmarkTime (FUN const& invokeTestCode, const size_t repeatCnt =1)
  {
    using std::chrono::steady_clock;
    using Dur = std::chrono::duration<double, CLOCK_SCALE>;
    
    auto start = steady_clock::now();
    invokeTestCode();
    Dur duration = steady_clock::now () - start;
    return duration.count() / repeatCnt;
  };
  
  
  template<class FUN>
  inline size_t
  benchmarkLoop (FUN const& testSubject, const size_t repeatCnt = DEFAULT_RUNS)
  {
    // the test subject gets the current loop-index and returns a checksum value
    auto subject4benchmark = microbenchmark::adapted4benchmark (testSubject);
    
    size_t checksum{0};
    for (size_t i=0; i<repeatCnt; ++i)
      checksum += subject4benchmark(i);
    return checksum;
  }
  
  
  template<class FUN>
  inline auto
  microBenchmark (FUN const& testSubject, const size_t repeatCnt = DEFAULT_RUNS)
  {
    volatile size_t checksum{0};
    auto invokeTestLoop = [&]{ checksum = benchmarkLoop (testSubject, repeatCnt); };
    double micros = benchmarkTime (invokeTestLoop, repeatCnt);
    return std::make_pair (micros, checksum);
  }
  
  
  
  
  template<size_t nThreads, class FUN>
  inline auto
  threadBenchmark(FUN const& subject, const size_t repeatCnt = DEFAULT_RUNS)
  {
    using std::chrono::steady_clock;
    using Dur = std::chrono::duration<double, CLOCK_SCALE>;
    
    // the test subject gets the current loop-index and returns a checksum value
    auto subject4benchmark = microbenchmark::adapted4benchmark (subject);
    using Subject = decltype(subject4benchmark);
    
    struct Thread
      : lib::ThreadJoinable<>
      {
        Thread(Subject const& subject, size_t loopCnt, SyncBarrier& testStart)
          : ThreadJoinable{"Micro-Benchmark"
                          ,[this,loopCnt, testSubject=subject, &testStart]
                           () mutable              // local (mutable) copy of the test-subject-Functor
                             {
                               testStart.sync();   // block until all threads are ready
                               auto start = steady_clock::now();
                               for (size_t i=0; i < loopCnt; ++i)
                                 checksum += testSubject(i);
                               duration = steady_clock::now () - start;
                             }}
          { }
                             // Note: barrier at begin and join at end both ensure data synchronisation
        Dur duration{};      // measured time within thread
        size_t checksum{0};  // collected checksum
      };
    
    SyncBarrier testStart{nThreads + 1};           // coordinated start of timing measurement
    lib::ScopedCollection<Thread> threads(nThreads);
    for (size_t n=0; n<nThreads; ++n)              // create test threads
      threads.emplace (subject4benchmark, repeatCnt, testStart);

    testStart.sync();                              // barrier until all threads are ready
    
    size_t checksum{0};
    Dur sumDuration{0.0};
    for (auto& thread : threads)
      {
        thread.join();                             // block on measurement end (fence)
        sumDuration += thread.duration;
        checksum    += thread.checksum;
      }
    
    double micros = sumDuration.count() / (nThreads * repeatCnt);
    return std::make_tuple (micros, checksum);
  }
  
  
  
}} // namespace lib::test
#endif /*LIB_TEST_MICROBENCHMARK_H*/