sync-barrier-performance-test.cpp

Go to the documentation of this file.

/*
  SyncBarrierPerformance(Test)  -  investigate performance of yield-waiting synchronisation
 
   Copyright (C)
     2023,            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.
 
* *****************************************************************/
 
#include "lib/test/run.hpp"
#include "lib/sync-barrier.hpp"
#include "lib/test/microbenchmark.hpp"
#include "lib/format-cout.hpp"
#include "lib/sync.hpp"
 
using test::Test;
using std::array;
 
 
namespace lib {
namespace test {
  
  namespace {// Test setup....
    
    const uint NUM_STAGES = 1024;
    
    class FakeBarrier
      {
        public:
          FakeBarrier(uint=0) { /* be happy */ }
          void sync()         { /* indulge */  }
      };
    
    
    class MonitorSync
      : public Sync<NonrecursiveLock_Waitable>
      {
        int latch_;
        
        bool allPassed() { return latch_ <= 0; }
        
        public:
          MonitorSync (uint nFold =2)
            : latch_{int(nFold)}
            { }
          
          void
          sync()
            {
              Lock sync{this};
              --latch_;
              sync.wait ([this]{ return allPassed(); });
              sync.notify_all();
            }
          
        private:
      };
  }//(End)Test setup
  
  
  
  
  /*******************************************************************/
  class SyncBarrierPerformance_test : public Test
    {
      template<class BAR, size_t nThreads>
      double
      performanceTest()
        {
          BAR barrier[NUM_STAGES];
          for (uint i=0; i<NUM_STAGES; ++i)
            new(&barrier[i]) BAR{nThreads};
          
          auto testSubject = [&](size_t i) -> size_t
                                {
                                  barrier[i].sync();
                                  return i;       // prevent empty loop optimisation
                                };
          
          auto [micros, cnt] = threadBenchmark<nThreads> (testSubject, NUM_STAGES);
          CHECK (cnt == nThreads * NUM_STAGES*(NUM_STAGES-1)/2);
          return micros;
        }
      
      
      
      virtual void
      run (Arg)
        {
          cout<<"\n\n■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■"<<endl;
          
          double time_yieldWait_80 = performanceTest<SyncBarrier, 80>();
          double time_yieldWait_64 = performanceTest<SyncBarrier, 64>();
          double time_yieldWait_48 = performanceTest<SyncBarrier, 48>();
          double time_yieldWait_32 = performanceTest<SyncBarrier, 32>();
          double time_yieldWait_16 = performanceTest<SyncBarrier, 16>();
          double time_yieldWait_8  = performanceTest<SyncBarrier,  8>();
          double time_yieldWait_4  = performanceTest<SyncBarrier,  4>();
          double time_yieldWait_2  = performanceTest<SyncBarrier,  2>();
          //
          double time_emptySetup   = performanceTest<FakeBarrier,  5>();
          //
          double time_sleepWait_16 = performanceTest<MonitorSync, 16>();
          double time_sleepWait_8  = performanceTest<MonitorSync,  8>();
          double time_sleepWait_4  = performanceTest<MonitorSync,  4>();
          double time_sleepWait_2  = performanceTest<MonitorSync,  2>();
          
          cout<<"\n___Microbenchmark_______  (µs)"
              <<"\nemptySetup             : "<<time_emptySetup
              <<"\n                       : "
              <<"\nSyncBarrier (2 Thr)    : "<<time_yieldWait_2
              <<"\nSyncBarrier (4 Thr)    : "<<time_yieldWait_4
              <<"\nSyncBarrier (8 Thr)    : "<<time_yieldWait_8
              <<"\nSyncBarrier (16 Thr)   : "<<time_yieldWait_16
              <<"\nSyncBarrier (32 Thr)   : "<<time_yieldWait_32
              <<"\nSyncBarrier (48 Thr)   : "<<time_yieldWait_48
              <<"\nSyncBarrier (64 Thr)   : "<<time_yieldWait_64
              <<"\nSyncBarrier (80 Thr)   : "<<time_yieldWait_80
              <<"\n                       : "
              <<"\nMonitorWait (2 Thr)    : "<<time_sleepWait_2
              <<"\nMonitorWait (4 Thr)    : "<<time_sleepWait_4
              <<"\nMonitorWait (8 Thr)    : "<<time_sleepWait_8
              <<"\nMonitorWait (16 Thr)   : "<<time_sleepWait_16
              <<"\n________________________\n"
              <<"\nbarriers..... "<<NUM_STAGES
              <<endl;
          
          // Unable to assert more than a sanity check here....
          CHECK (time_emptySetup < time_yieldWait_4);
        }
    };
  
  
  
  LAUNCHER (SyncBarrierPerformance_test, "function common");
  
  
  
}} // namespace lib::test